ADDSLASHES() | Возвращает строку с символами слеш (\) |
ALLTRIM() | Удаляет ведущие и замыкающие пробелы в строке символов. |
ASC() | Преобразует символ в его код ASCII. |
AT() | Возвращает позицию подстроки в символьной строке. |
BETWEEN() | Проверка значения |
BUNZIP2() | Распаковывает строку по BZIP2 алгоритму. |
BZIP2() | Пакует строку по bZIP2 алгоритму. |
CHR() | Преобразует код ASCII в его символьное значение. |
CSCOUNT() | Возвращает количество заданных символов в строке. |
DSTRTON() | Преобразует строку c "double"-представлнием в xClipper-число. |
EMPTY() | Определяет, является ли результат выполнения выражения пустым. |
FSTRTON() | Преобразует строку c "float"-представлнием в xClipper-число. |
FT_AT2() | Find position of the nth occurrence of a substring |
FT_BITCLR() | Clear (reset) selected bit in a byte |
FT_BITSET() | Set selected bit in a byte |
FT_BYTEAND() | Perform bit-wise AND on two ASCII characters (bytes) |
FT_BYTENEG() | Perform bit-wise negation on an ASCII character |
FT_BYTENOT() | Perform bit-wise NOT on an ASCII character (byte) |
FT_BYTEOR() | Perform bit-wise OR on two ASCII characters (bytes) |
FT_BYTEXOR() | Perform bit-wise XOR on two ASCII characters (bytes) |
FT_FINDITH() | Find the "ith" occurrence of a substring within a string |
FT_ISBIT() | Test the status of an individual bit |
FT_ISBITON() | Determine the state of individual bits in a number |
FT_METAPH() | Convert a character string to MetaPhone format |
FT_NOOCCUR() | Find the number of times one string occurs in another |
FT_PCHR() | Convert printer control codes |
GLOB() | Проверка на соответствие строки регулярному выражению. |
GUNZIP() | Распаковывает строку по GZIP алгоритму. |
GZIP() | Пакует строку по GZIP алгоритму. |
HARDCR() | Заменяет все мягкие возвраты каретки в символьной строке жесткими |
HASHNAME() | Возвращает строку, из которой был получен хэш-код. |
HASHSTR() | Возвращает хэш-код строки. |
ISALPHA() | Определяет, является ли самый левый символ в строке алфавитным. |
ISDIGIT() | Определяет, является ли первый символ в строке цифрой. |
ISLOWER() | Определяет, является ли первый символ в строке строчной буквой. |
ISUPPER() | Определяет, является ли первый символ в строке заглавной буквой. |
LEFT() | Определяет подстроку, начиная с первого символа в строке. |
LEN() | Определяет длину символьной строки или количество элементов в массиве. |
LIKE() | Проверка на соответствие строки простой маске. |
LOWER() | Переводит символы из верхнего регистра в нижний. |
LTRIM() | Удаляет начальные пробелы из символьной строки. |
MEMOEDIT() | Выводит на экран или редактирует символьные строки или memo-поля. |
MEMOLINE() | Выделяет строку текста из символьной строки или memo-поля. |
MEMOREAD() | Возвращает содержимое дискового файла как строку символов. |
MEMOTRAN() | Замещает символы "возврат каретки/перевод строки" символьной строкой. |
MEMOWRIT() | Записывает символьную строку или memo-поле в дисковый файл. |
MLCOUNT() | Подсчитывает количество строк в memo-поле или символьной строке. |
MLCTOPOS() | Возвращает позицию байта на основе номеров строки и колонки в |
MLPOS() | Определяет номер первого символа подстроки в символьной строке или |
MPOSTOLC() | Возвращает номера строки и колонки форматированного текста, основываясь |
PAD() | Дополняет CHARACTER, DATE и NUMERIC значения символом-заполнителем. |
QOUT() | Выводит список выражений на консоль. |
RAT() | Возвращает позицию последнего вхождения подстроки. |
REPLICATE() | Возвращает строку, повторенную заданное количество раз. |
RIGHT() | Возвращает подстроку, начиная с самого правого символа. |
RTRIM() | Удаляет конечные пробелы из символьной строки. |
SEARCH() | Поиск подстроки в строке по регулярному выражению. |
SOUNDEX() | Преобразует символьную строку в звуковую форму. |
SPACE() | Возвращает строку пробелов. |
STR() | Преобразует числовое выражение в символьную строку. |
STR2VAR() | Конвертировать uucode строку в исходные данные. |
STRTRAN() | Ищет и заменяет символы в символьной строке или memo-поле. |
STUFF() | Удаляет или вставляет символы в строке. |
SUBSTR() | Выделяет подстроку из символьной строки. |
TRANSFORM() | Преобразует заданное выражение в форматированную строку символов. |
TRIM() | Remove trailing spaces from a character string |
TYPE() | Определяет тип выражения. |
UPPER() | Преобразует алфавитные символы нижнего регистра в символы верхнего |
VAL() | Преобразует число в символьной форме в числовой тип. |
VALTYPE() | Определяет тип данных выражения. |
VAR2STR() | Конвертировать данные в uucode строку. |
WEIGHTASC() | Возвращает весовую характеристику символа. |
WEIGHTTABLE() | Возвращает весовую таблицу символов. |
ADDSLASHES(<sString>) --> <sResString>
ADDSLASHES() возвращает строку с символами обратный слэш (\).
ADDSLASHES() возвращает строку <sResString> с обратными слэш перед символами, нуждающимися в экранировании, например в запросах к БД. Это такие символы, как одиночная кавычка ('), двойная кавычка ("), обратный слэш (\) и NUL (нулевой символ).
str := "Name='Ann'" ADDSLASHES(str) // --> Name=\'Ann\'
Не зависит от платформ
ALLTRIM(<символьное выражение>) --> строка символов
ALLTRIM() возвращает строку символов с удаленными пробелами в начале и в конце строки.
ALLTRIM() - функция работы с символьными строками, которая удаляет ведущие и завершающие пробелы из строки. Она выполняет действие сразу двух функций - LTRIM() и RTRIM(), которые удаляют из строки ведущие и заключающие пробелы соответственно. Функции ALLTRIM(), LTRIM() и RTRIM() являются противоположными по действию функциям PADC(), PADR() и PADL(), которые центрируют строки, выравнивают их справа или слева, добавляя в них пробелы.
Этот пример создает строку, содержащую ведущие и завершающие пробелы и затем удаляет их при помощи функции ALLTRIM(): cString = SPACE(10) + "Строка" + SPACE(10) ? LEN(cString) // Результат: 26 ? LEN(ALLTRIM(cString)) // Результат: 6
ASC(<символьное выражение>) --> значение кода ASCII
ASC() возвращает целое число в пределах от 0 до 255, представляющее значение кода ASCII <символьное выражение>.
ASC() - это функция преобразования символов, которая возвращает значение кода ASCII самого первого символа в строке. ASC() в основном используется с выражениями, в которых ведутся арифметические расчеты над числовыми значениями кодов ASCII символов. CHR() и ASC() - это функции, противоположные по действию друг другу.
Этот пример иллюстрирует различные результаты выполнения функции ASC(): ? ASC("A") // Результат: 65 ? ASC("Apple") // Результат: 65 ? ASC("a") // Результат: 97 ? ASC("Z") - ASC("A") // Результат: 25 ? ASC("") // Результат: 0
AT(<подстрока поиска>,<строка>) --> номер позиции
AT() возвращает номер позиции первого появления подстроки <подстрока поиска> в строке <строка> в виде арифметического значения. Если подстрока <подстрока поиска> не найдена, AT() возвращает нуль.
AT() - функция работы с символьными строками, которая определяет позицию первого появления символьной подстроки <подстрока поиска> в строке <строка>. Для определения последнего появления подстроки в строку, используется функция RAT().
Этот пример демонстрирует работу функции AT(): ? AT("a","abcde") // Результат: 1 ? AT("bcd","abcde") // Результат: 2 ? AT("a","bcde") // Результат: 0 В этом примере символьная строка делится на части в местах появления запятой: cTarget = "Langtree, Lilly" ? SUBSTR(cTarget, 1, AT(",", cTarget) - 1) // Результат: Langtree ? SUBSTR(cTarget, AT(",", cTarget) + 2 ) // Результат: Lilly
BETWEEN(<TargetData>, <FirstData>, <SecondData>) --> TRUE || FALSE
Возвращает TRUE если <TargetData> располагается между <FirstData> и <SecondData> включительно.
BETWEEN() сравнивает исходное значение <TargetData> с <FirstData> и <SecondData>. Если <TargetData> находится в границах между <FirstData> и <SecondData>, BETWEEN() возвращает TRUE.
Все сравниваемые значения должны принадлежать какому-либо одному типу (строка, число, дата, ...).
val := 12345 BETWEEN(val, 0, 99999) // --> TRUE BETWEEN(val, 99999, 0) // --> TRUE BETWEEN(val, 9999, 0) // --> FALSE
Не зависит от платформ
CHR(<код ASCII>) --> символ
CHR() возвращает символ, код которого определен <код ASCII>.
CHR() - функция преобразования чисел, которая преобразует код ASCII в символ. Она противоположна по действию функции ASC(). Эта многоплановая функция полезна в часто используемых задачах, таких как:
Посылка управляющих кодов или графических символов на экран или принтер.
Включение звонка.
Преобразование кодов, возвращаемых функцией INKEY(), в символы.
Заполнение буфера клавиатуры.
Следующие примеры показывают работу функции CHR() с различными аргументами: ? CHR(72) // Результат: H ? CHR(ASC("A") + 32) // Результат: a ? CHR(7) // Результат: звуковой сигнал Здесь показана разница между нулевой строкой и нулевым символом: ? LEN("") // Результат: 0 ? LEN(CHR(0)) // Результат: 1
CSCOUNT(<сChar>, <sString>) --> <nCount>
Возвращает количество символов <cChar> в строке <sString>.
CSCOUNT() возвращает количество символов <cChar> в строке <sString>.
CSCOUNT("s", "substr") // --> 2 CSCOUNT("a", "substr") // --> 0
Не зависит от платформ
DSTRTON(<sString>) --> <nValue>
Возвращает числовое значение, сконвертированное из строки с "double" представлением.
DSTRTON() преобразует строку <sString> в число и возвращает его.
fread(file,@str,8)<BR> n=DSTRTON(str)
Не зависит от платформ
FSTRTON(<sString>) --> <nValue>
Возвращает числовое значение, сконвертированное из строки с "float" представлением.
FSTRTON() преобразует строку <sString> в число и возвращает его.
fread(file,@str,8)<BR> n=FSTRTON(str)
Не зависит от платформ
FT_AT2( <cSearch>, <cTarget> [, <nOccurs> [, <lCaseSens> ] ] ) -> nPos
The position of the nth occurrence of a substring
This function will find the nth occurrence of a substring within a string.
cSearch := "t" cTarget := "This is the day that the Lord has made." FT_AT2( cSearch, cTarget ) // Returns ( 9 ) FT_AT2( cSearch, cTarget, 2 ) // Returns ( 17 ) FT_AT2( cSearch, cTarget, 2, .F. ) // Returns ( 9 )
FT_BITCLR( <cByte>, <nBitPos> ) -> cByte
Returns new byte, with designated bit cleared (reset). If parameters are faulty, returns NIL.
In effect, ANDs argument byte with a byte that has all bits set except the target bit. If bit is already clear (0), it remains clear. Note: Calls FT_ISBIT() which is also in this Library.
This function is presented to illustrate that bit-wise operations are possible with Clipper code. For greater speed, write .C or .ASM versions and use the Clipper Extend system.
This code would clear bit 4 in a byte represented by CHR(115): cNewByte := FT_BITCLR( CHR(115), 4 ) ? ASC( cNewbyte ) // result: 99 ? cNewByte // result: 'c' This code would clear bit 5 in the byte represented by letter 'A': FT_BITCLR( 'A', 5 ) // result: 'A', since // bit 5 already clear For a demonstration of Clipper bit manipulations, compile and link the program BITTEST.PRG in the Nanforum Toolkit source code.
FT_BITSET( <cByte>, <nBitPos> ) -> cByte
Returns new byte, with designated bit set. If parameters are faulty, returns NIL.
In effect, ORs argument byte with a byte that has only the target bit set. If bit is already set, it remains set. Note: Calls FT_ISBIT() which is also in this Library.
This function is presented to illustrate that bit-wise operations are possible with Clipper code. For greater speed, write .C or .ASM versions and use the Clipper Extend system.
This code would set bit 4 in a byte represented by CHR(107): cNewbyte := FT_BITSET( CHR(107), 4 ) ? ASC( cNewbyte ) // result: 123 ? cNewbyte // result: '{' This code would set bit 5 in the byte represented by the letter 'A'. ? FT_BITSET( 'A', 5 ) // result: 'a' // bit 5 set For a demonstration of Clipper bit manipulations, compile and link the program BITTEST.PRG in the Nanforum Toolkit source code.
FT_BYTEAND( <cByte1>, <cByte2> ) -> cByte
Returns resulting byte, in CHR() form. If parameters are faulty, returns NIL.
Can be used for any bit-wise masking operation. In effect, this is a bit-by-bit AND operation. Equivalent to AND assembler instruction.
This function is presented to illustrate that bit-wise operations are possible with Clipper code. For greater speed, write .C or .ASM versions and use the Clipper Extend system.
This code would mask out the high nibble (four most significant bits) of the byte represented by chr(123) and leave the low nibble bits as in the parameter byte. cNewbyte := FT_BYTEAND( CHR(123), CHR(15) ) ? asc(cNewByte) // result: 11 ? cNewByte // result: non-printable character For a demonstration of Clipper bit manipulations, compile and link the program BITTEST.PRG in the Nanforum Toolkit source code.
FT_BYTENEG( <cByte> ) -> cNewByte
Returns resulting byte, in CHR() form. If parameters are faulty, returns NIL.
Can be used for bit-wise byte manipulation. In effect, this is a bit-by-bit NEG (two's complement) operation. Equivalent to NEG assembler instruction.
This function is presented to illustrate that bit-wise operations are possible with Clipper code. For greater speed, write .C or .ASM versions and use the Clipper Extend system.
This code performs a bit-wise NEG on byte represented by CHR(32): cNewByte := FT_BYTENOT(CHR(32)) ? asc(cNewByte) // result: 224 For a demonstration of Clipper bit manipulations, compile and link the program BITTEST.PRG in the Nanforum Toolkit source code.
FT_BYTENOT( <cByte> ) -> cNewByte
Returns resulting byte, in CHR() form. If parameters are faulty, returns NIL.
Can be used for bitwise byte manipulation. In effect, this is a bit-by-bit NOT (one's complement) operation. Equivalent to the NOT assembler instruction.
This function is presented to illustrate that bit-wise operations are possible with Clipper code. For greater speed, write .C or .ASM versions and use the Clipper Extend system.
This code performs a bitwise NOT on byte represented by CHR(32): cNewByte := FT_BYTENOT( CHR(32) ) ? ASC( cNewByte ) // result: 223 For a demonstration of Clipper bit manipulations, compile and link the program BITTEST.PRG in the Nanforum Toolkit source code.
FT_BYTEOR( <cByte1>, <cByte2> ) -> cNewByte
Returns resulting byte, in CHR() form. If parameters are faulty, returns NIL.
Can be used for bit-wise byte manipulation. In effect, this is a bit-by-bit OR operation. Equivalent to OR assembler instruction.
This function is presented to illustrate that bit-wise operations are possible with Clipper code. For greater speed, write .C or .ASM versions and use the Clipper Extend system.
This code performs a bit-wise OR on two bytes represented by CHR(20) and CHR(10): cNewByte := FT_BYTEOR( CHR(20), CHR(10) ) ? ASC( cNewByte ) // result: 30 ? cNewByte // result: non-printable character For a demonstration of Clipper bit manipulations, compile and link the program BITTEST.PRG in the Nanforum Toolkit source code.
FT_BYTEXOR( <cByte1>, <cByte2> ) -> cNewByte
Returns resulting byte, in CHR() form. If parameters are faulty, returns NIL.
Can be used for bit-wise byte manipulation. In effect, this is a bit-by-bit XOR operation. Equivalent to XOR assembler instruction.
This function is presented to illustrate that bit-wise operations are possible with Clipper code. For greater speed, write .C or .ASM versions and use the Clipper Extend system.
This code performs a bit-wise XOR on two bytes represented by CHR(32) and CHR(55): cNewByte := FT_BYTEXOR( CHR(32), CHR(55) ) ? ASC( cNewByte ) // result: 23 ? cNewByte // result: non-printable character For a demonstration of Clipper bit manipulations, compile and link the program BITTEST.PRG in the Nanforum Toolkit source code.
FT_FINDITH( <cCheckFor>, <cCheckIn>, <nWhichOccurrence> ; [, <lIgnoreCase> ] ) -> <nStringPosition>
The position in the string cCheckIn of the ith occurrence of cCheckFor.
This function finds the position in a string of the "ith" time another string appears in it.
// Find the Position in cMemoString of // the 10th Occurrence of "the", case // insensitive nNextPosition := FT_FINDITH("the", cMemoString, 10)
FT_ISBIT( <cByte>, <nBitPos> ) -> lResult
.T. if designated bit is set (1), .F. if not set (0), NIL if invalid parameters.
Tests for status of any selected bit in the byte passed as a parameter. Byte must be presented in CHR() form, as a literal constant, or as the one-byte character result of an expression.
This function is presented to illustrate that bit-wise operations are possible with Clipper code. For greater speed, write .C or .ASM versions and use the Clipper Extend system.
This code tests whether bit 3 is set in the byte represented by CHR(107): lBitflag := FT_ISBIT(CHR(107), 3) ? lBitflag // result: .T. This code tests whether bit 5 is set in the byte represented by ASCII 65 (letter 'A') ? FT_ISBIT('A', 5) // result: .F. For a demonstration of Clipper bit manipulations, compile and link the program BITTEST.PRG in the Nanforum Toolkit source code.
FT_ISBITON( <nNumber>, <nBit> ) -> lResult
.T. if the specified bit was on., .F. if off.
This function is useful when dealing with binary integers. It will come in very handy if you use the FT_INT86() function, because the CPU flags are returned as a series of bits. Using this function, you can determine the state of each CPU flag.
if FT_ISBITON( nCPUFlags, 0 ) Qout( "The carry flag was set." ) endif if FT_ISBITON( nCPUFlags, 7 ) Qout( "The sign flag was set." ) endif
FT_METAPH( <cName> [, <nSize> ] ) -> cMetaPhone
A phonetically spelled character string
This function is a character function use to index and search for sound-alike or phonetic matches. It is an alternative to the SOUNDEX() function, and addresses some basic pronunciation rules, by looking at surrounding letters to determine how parts of the string are pronounced. FT_METAPH() will group sound-alikes together, and forgive shortcomings in spelling ability.
USE Persons INDEX ON FT_METAPH( LastName ) TO LastName SEEK FT_METAPH( "Philmore" ) ? FOUND(), LastName // Result: .T. Philmore SEEK FT_METAPH( "Fillmore" ) ? FOUND(), LastName // Result: .T. Philmore
FT_NOOCCUR( <cCheckFor>, <cCheckIn> ; [, <lIgnoreCase> ] ) -> <nOccurrences>
The number of times <cCheckFor> appears in <cCheckIn>
This function finds the number of times a string occurs in a second string.
// Find the number of times "the" appears in cMemoString, case // insensitive nNoOfOccurrences := FT_NOOCCUR( "the", cMemoString ) // Find the number of times "the" appears in cMemoString, case // sensitive nNoOfOccurrences := FT_NOOCCUR( "the", cMemoString, TRUE )
FT_PCHR( <cString> ) -> <cPrinterFormat>
A character string of printer control codes.
This function is useful for allowing the user to enter printer control codes in text (enclosed in double quotes), numeric, hexadecimal, or Epson commands preceded by a slash and returns the printer control code equivalent.
NOTES"
- Combinations of text, numbers, hex, and commands must be separated by commas ("A",27,&1B,/RESET). - Text must be enclosed in double quotes ("x"). - Hexadecimal must be preceded by an ampersand (&1B). - Epson commands, listed below, must be preceded by a forward slash (/RESET).
Epson commands: (slash commands are specific to the Epson)
Job Control:
/RESET or /INIT Reset or initialize the printer /BELL or /BEEP Cause the printer's speaker to beep (not HS) /CAN Clear print buffers (not MX) /SLOW Set low speed mode (not CR, HS, MX) /FAST Cancel low speed mode (not CR, HS, MX) /ONE Select Unidirectional mode /TWO Select Directional mode /ON Activate printer /OFF Turn off printer
/FF or /EJECT Form Feed
Page Control:
/1/6 Set 6 lines per inch /1/8 Set 8 lines per inch /SKIP Set Skip perforation ON /SKIPOFF Set Skip perforation OFF
Font Selection and Manipulation:
/ITALIC Select italic char. set (only FX86, EX, LX, no LQ-1500, SX) /GRAPHIC Select graphic char. set (only FX86, EX, LX, no LQ-1500, SX) /ROMAN Choose Roman font /SANS Choose Sans Serif font /DRAFT Choose draft /NLQ Choose near letter quality /PICA Choose 10 chars per inch /ELITE Choose 12 chars per inch /COND or /SI Choose 15 chars per inch /EMPH Turn emphasize on /EMPHOFF Turn emphasize off /SPANISH Select spanish international char set /USA Select USA international char set
cSetUp := '27,116,1' Set Print ON ? FT_PCHR( cSetUp ) -> (CHR(27)+CHR(116)+CHR(1)) <select Epson char. graphics> ? FT_PCHR( '27,"x",0' ) -> (CHR(27)+CHR(120)+CHR(0)) <Epson draft mode> ? FT_PCHR( '&1B,"E"' ) -> (CHR(27)+CHR(69)) <HP reset> ? FT_PCHR( '/ELITE,/NLQ' ) ->(CHR(27)+CHR(77)+CHR(27)+CHR(120)+CHR(1)) <Epson elite & near letter quality>
GLOB(<sString>, <sReg>, [<lIgnoreCase>]) --> TRUE || FALSE
Возвращает TRUE, если строка соответствует регулярному выражению.
GLOB() возвращает TRUE, если строка соответствует регулярному выражению. Выражение <sReg> это простое регулярное выражение, принятое в DOS.
? GLOB("aaa", "aaa") // --> TRUE ? GLOB("aaa", "[a-z]*") // --> TRUE ? GLOB("aaa", "a*") // --> TRUE ? GLOB("aaa", "*") // --> TRUE ? GLOB("aaa", "a") // --> FALSE ? GLOB("", "a") // --> FALSE ? GLOB("", "*") // --> TRUE
Не зависит от платформ
HARDCR(<строка>) --> преобразованная строка
HARDCR() возвращает символьную строку длиной до 65 535 (64К) символов.
HARDCR() - это функция обработки memo-полей, которая заменяет все мягкие возвраты каретки (CHR(141)) жесткими возвратами каретки (CHR(13)). Она используется для вывода длинных символьных строк и memo-полей, содержащих мягкие возвраты каретки с помощью консольных команд. В xClipper консольные команды ( включая REPORT и LABEL FORM) не выполняют автоматического преобразования мягких возвратов каретки в жесткие, вынуждая вас делать эти преобразования. Мягкие возвраты каретки добавляются в memo-поля функцией MEMOEDIT() при переносе строк.
Вывести memo-поле, отформатированное с помощью автоматического переноса слов функцией MEMOEDIT(): USE sales NEW ? HARDCR(Sales -> Notes)
HASHNAME(<nHashCode>) --> <sStr>
Возвращает строку, из которой был сгенерирован хэш-код.
HASHNAME() возвращает исходную строку, из которой был получен хэш-код <nHashCode>.
HASHSTR("asdf") // --> 1886203041 HASHNAME(1886203041) // --> asdf
HASHSTR(<sStr>) --> <nHashCode>
Возвращает числовое значение - хэш-код, сконвертированное из строки.
HASHSTR() вычисляет хэш-код для строки <sStr> и возвращает его в виде числа. Хэш-код имеет уникальное значение в пределах от 1000000 до MAX_LONG.
HASHSTR("asdf") // --> 1886203041 HASHSTR("ASDF") // --> 1190707477 HASHSTR("aSdF") // --> 1934510729
ISALPHA(<строка символов>) --> признак буквы
ISALPHA() возвращает значение "истина" (.Т.), если первый символ аргумента <строка символов> - буква, в противном случае она возвращает значение "ложь" (.F.).
ISALPHA() - это функция обработки символьных строк, определяющая, начинается ли заданная строка с буквенного символа. Буквенный символ - это любая буква от А до Z верхнего или нижнего регистра. ISALPHA() возвращает значение "ложь" (.F.), если строка начинается с цифры или какого-либо другого символа.
Следующий пример демонстрирует различные результаты вызовов ISALPHA(): ? ISALPHA("AbcDe") // Результат: .T. ? ISALPHA("фBcЛе") // Результат: .T. ? ISALPHA("1BCde") // Результат: .F. ? ISALPHA(".FRED") // Результат: .F.
ISDIGIT(<символьная строка>) --> признак цифры
ISDIGIT() возвращает значение "истина" (.T.), если первый символ в строке является цифрой от 0 до 9, в противном случае - значение "ложь" (.F.).
ISDIGIT() является функцией обработки символьных строк, которая определяет, является ли первый символ аргумента <символьная строка> цифрой от 0 до 9. Если первый символ является любым другим символом, то функция возвратит значение "ложь" (.F.).
ISDIGIT() используется тогда, когда необходимо определить, является ли текущая символьная строка числом перед тем, как превратить ее в числовую величину функцией VAL().
Следующие примеры демонстрируют различные результаты функции ISDIGIT(): ? ISDIGIT("AbcDe") // Результат : .F. ? ISDIGIT("1abcd") // Результат : .T. ? ISDIGIT(".12345") // Результат : .F.
ISLOWER(<символьная строка>) --> признак строчной буквы
ISLOWER() возвращает значение "истина" (.T.), если первый символ в строке является строчной буквой, в противном случае - значение "ложь" (.F.).
ISLOWER() является функцией обработки символьных строк, которая определяет, является ли первый символ в строке строчной буквой. Эта функция противоположна функции ISUPPER(), которая определяет, является ли первый символ в строке прописной буквой.
Функции ISLOWER() и ISUPPER() связаны с функциями LOWER() и UPPER(), которые переводят символы из верхнего регистра в нижний и наоборот.
Следующие примеры демонстрируют различные результаты использования функции ISLOWER(): ? ISLOWER("aBcDe") // Результат: .T. ? ISLOWER("AbcDe") // Результат: .F. ? ISLOWER("1abcd") // Результат: .F. ? ISLOWER("abcde") // Результат: .T.
ISUPPER(<символьная строка>) --> признак заглавной буквы
ISUPPER() возвращает значение "истина" (.T.), если первый символ в строке является прописной буквой, в противном случае - значение "ложь" (.F.).
ISUPPER() является функцией обработки символьных строк, которая определяет, является ли первый символ в строке прописной буквой. Эта функция противоположна функции ISLOWER(), которая определяет, является ли первый символ в строке строчной буквой.
Функции ISUPPER() и ISLOWER() связаны с функциями UPPER() и LOWER(), которые переводят символы из нижнего регистра в верхний и наоборот.
Следующие примеры иллюстрируют использование ISUPPER(): ? ISUPPER("AbCdE") // Результат: .T. ? ISUPPER("aBCdE") // Результат: .F. ? ISUPPER("$abcd") // Результат: .F. ? ISUPPER("8ABCD") // Результат: .F.
LEFT( <символьная строка>, <длина подстроки>) --> символьная подстрока
LEFT() возвращает заданное число символов, начиная с первого символа в строке, в виде символьной подстроки. Если значение аргумента <длина подстроки>- отрицательное или ноль, LEFT() возвращает пустую строку (""). Если значение аргумента <длина подстроки> больше длины исходной строки, LEFT() возвращает всю строку.
LEFT() является функцией обработки символьных строк, которая возвращает подстроку, выделенную из заданной символьной строки. Она аналогична функции SUBSTR(<символьная строка>, 1, <длина подстроки>). LEFT() сходна с RIGHT(), которая возвращает подстроку, начиная с последнего символа в строке.
LEFT(), RIGHT() и SUBSTR() часто используются совместно с функциями AT() и RAT() для определения первой и/или последней позиции подстроки в строке перед ее выделением.
В этом примере выделяются три первых символа из исходной строки: ? LEFT("ABCDEF", 3) // Результат: ABC В этом примере выделяется подстрока с первого символа до первой запятой: LOCAL cName := "James, William" ? LEFT(cName, AT(",", cName) - 1) // Результат: James
LIKE(<sMask>, <sString>) --> TRUE || FALSE
Возвращает TRUE, если строка соответствует маске.
LIKE() возвращает TRUE, если строка соответствует маске. Строка <sMask> может содержать специальные символы: <?>, <*>, <.>
? LIKE("aaa", "aaa") // --> TRUE ? LIKE("aaa", "a*") // --> TRUE ? LIKE("aaa", "*") // --> TRUE ? LIKE("aaa", "a") // --> FALSE ? LIKE("", "a") // --> FALSE ? LIKE("", "*") // --> TRUE
Не зависит от платформ
LOWER(<символьная строка>) --> символьная строка
LOWER() возвращает копию аргумента <символьной строки>, в которой все буквенные символы верхнего регистра преобразованы в буквенные символы нижнего регистра (прописные буквы - в строчные). Все остальные символы остаются без изменений.
LOWER() - функция обработки символьных строк, используемая для преобразования буквенных символов из верхнего регистра в нижний. Она связана с UPPER(), которая преобразует строки из нижнего регистра в верхний. LOWER() также связана с ISLOWER() и ISUPPER(), которые определяют, с какой буквы начинается строка - со строчной или прописной.
LOWER() обычно используют для форматирования символьных строк при выводе на экран. Она также может использоваться для приведения строк к одному виду (прописные или строчные) без учета регистра или в целях индексирования.
Следующие примеры демонстрируют различные результаты LOWER(): ? LOWER("СТРОКА") // Результат: строка ? LOWER("1234 СИМВ = ") // Результат: 1234 симв =
LTRIM(<символьная строка>) --> символьная строка
LTRIM() возвращает копию аргумента <символьная строка> с удаленными начальными пробелами. Если <символьная строка> является нулевой строкой ("") или строкой, состоящей только из пробелов, LTRIM() возвращает нулевую строку ("").
LTRIM() является функцией обработки символьных строк, используемой для форматирования символьных строк с начальными пробелами. Ими могут быть, например, числа, преобразуемые в символьные строки функцией STR().
LTRIM() сходна с функцией RTRIM(), которая удаляет конечные пробелы. Обратными к функциям ALLTRIM(), LTRIM() и RTRIM() являются функции PADC(), PADR() и PADL(), которые центрируют, сдвигают вправо или влево символьные строки путем добавления к ним символов-заполнителей.
Следующие примеры иллюстрируют использование LTRIM() в комбинации с некоторыми другими функциями: nNumber = 18 ? STR(nNumber) // Результат: 18 ? LEN(STR(nNumber)) // Результат: 10 ? LTRIM(STR(nNumber)) // Результат: 18 ? LEN(LTRIM(STR(nNumber))) // Результат: 2
MEMOEDIT( [<символьная строка>], [<верхняя строка>], [<левая колонка>], [<нижняя строка>], [<правая колонка>], [<режим>], [<имя функции пользователя>], [<длина строк>], [<гориз.табуляция>], [<строка буфера>], [<колонка буфера>], [<строка в окне>], [<колонка в окне>] ) --> текстовый буфер
<символьная строка> | - символьная строка или memo-поле, которые |
копируются в текстовый буфер MEMOEDIT(). Если аргумент не задан, | |
текстовый буфер пуст. | |
<верхняя строка> | , <левая колонка>, <нижняя строка>, <правая колонка> |
- координаты верхнего левого и правого нижнего углов окна. Номера | |
строк изменяются от ноля до MAXROW(), а номера колонок - от ноля до | |
MAXCOL(). Если эти аргументы не заданы, их значения по умолчанию | |
принимаются - 0, 0, MAXROW(), MAXCOL(). | |
<режим> | - определяет, подлежит текстовый буфер редактированию или |
нет. Его значение - "истина" (.T.) означает, что редактирование | |
текстового буфера разрешено, тогда как значение - "ложь" (.F.) | |
позволяет пользователю только просмотр текстового буфера. Если | |
аргумент не задан, его значение по умолчанию - "истина" (.T.). | |
<имя функции пользователя> | - имя функции пользователя, которая |
вызывается, когда пользователь нажимает клавишу, не распознаваемую | |
функцией MEMOEDIT() или когда буфер клавиатуры пуст. Аргумент | |
<имя функции> | определяется как символьная величина без скобок и |
параметров. Задание в качестве этого параметра значения "ложь" | |
(.F.) выводит заданную символьную строку на экран и прерывает | |
выполнение MEMOEDIT(). В зависимости от того, определена или нет | |
функция пользователя, поведение MEMOEDIT() различно. (Подробности | |
смотри ниже). | |
<длина строк> | - определяет длину строк, выводимых в окне MEMOEDIT(). |
Если строка длиннее, чем значение аргумента <длина строк>, то остаток | |
переносится на следующую строку в окне MEMOEDIT(). Если значение | |
аргумента <длина строк> больше, чем число колонок в окне MEMOEDIT(), | |
то текст в окне будет перемещаться по мере передвижения курсора за | |
границы окна. Если аргумент <длина строк> не задан, то по умолчанию | |
он принимает значение выражения (<левая колонка> - <правая колонка>). | |
<гориз.табуляция> | - определяет размер шага табуляции, то есть |
количество колонок перемещения курсора при нажатии клавиши <Tab>. | |
Если аргумент не задан, по умолчанию шаг табуляции - 4 пробела. | |
<строка буфера> | и <колонка буфера> - определяют позицию в текстовом |
буфере, с которой начинается вывод на экран, при вызове MEMOEDIT(). | |
Значение аргумента <строка буфера> начинается с 1, а значение | |
аргумента <колонка буфера> начинается с 0. Если аргументы не заданы, | |
по умолчанию их значения принимаются равными 1 и 0 соответственно. | |
<строка в окне> | и <колонка в окне> определяют начальную позицию |
курсора в окне MEMOEDIT(). Значения строки и колонки начинаются с | |
ноля. Если аргументы не заданы, начальная позиция курсора в окне - | |
нулевая строка и текущая колонка. |
MEMOEDIT() возвращает текстовый буфер, если пользователь прерывает редактирование нажатием <Ctrl>-<W>, или копию введенной исходной строки при нажатии клавиши <Esc>.
MEMOLINE(<символьная строка>,[<длина строки>], [<номер строки>], [<шаг табуляции>], [<переключатель переноса>]) --> символьная строка
<символьная строка> | - memo-поле или строка символов, из которой |
выделяется строка текста. | |
<длина строки> | - определяет количество символов в выделяемой строке и |
может принимать значения от 4 до 254. По умолчанию - 79. | |
<номер строки> | - определяет номер строки для выделения. По умолчанию |
принимается 1. | |
<шаг табуляции> | - определяет размер табуляции. Если он не определен, |
то по умолчанию принимается 4. Если <шаг табуляции> больше, чем | |
значение параметра <длина строки>, то шаг табуляции автоматически | |
принимается равным значению параметра <длина строки> - 1. | |
<переключатель переноса> | - включает или выключает режим переноса |
слов. Если его значение "истина" (.T.) - режим включен; значение | |
"ложь"(.F.) - означает, что режим отключен. По умолчанию принимается | |
значение "истина" (.T.) |
MEMOLINE() возвращает подстроку текста с номером <номер строки>, длиной <длина строки> из заданной аргументом <символьная строка> строки. Если в заданной строке меньше символов, чем указано в аргументе <длина строки>, то результирующая строка дополняется пробелами. Если значение аргумента <номер строки> больше, чем количество строк в аргументе <символьная строка>, то MEMOLINE() возвращает пустую строку ("").
Если значение аргумента <переключатель переноса> равно "истина" (.T.) и конец строки попадает внутрь слова, то это слово переносится на следующую строку (ее начало). Если значение аргумента <переключатель переноса> имеет значение "ложь" (.F.), MEMOLINE() возвращает то количество символов, которое определено в аргументе <длина строки>. Следующая строка начинается с символа, следующего за символом "жесткий возврат каретки". Это означает, что промежуточные символы отбрасываются.
MEMOLINE() - функция работы с memo-полями, которая обычно используется в сочетании с MLCOUNT() для выделения строк текста из memo-полей и символьных строк, основываясь на заданном количестве символов в строке.
Способ действия заключается в том, что сначала с помощью MLCOUNT() в memo-поле или символьной строке с учетом наличия режима переноса и табуляции определяется количество строк. Применяя это значение как верхнюю границу для оператора цикла FOR...NEXT, каждую подстроку memo-поля или символьной строки можно извлечь с помощью функции MEMOLINE() и использовать в любой комбинации команд и функций.
Этот пример демонстрирует обычный метод обработки memo-полей и длинных символьных строк, используя комбинацию MLCOUNT() и MEMOLINE(): LOCAL nLineLenght := 40, nTabSize := 3, IWrap := .T. LOCAL nLines, nCurrentLine USE Customer INDEX CustName NEW // nLines := MLCOUNT(CustNotes, nLineLength, nTabSize, lWrap) // SET PRINTER ON FOR nCurrentLine := 1 TO nLines ? MEMOLINE(CustNotes, nLineLength, nCurrentLine, nTabSize, lWrap) NEXT SET PRINTER OFF
MEMOREAD(<имя файла>) --> строка символов
MEMOREAD() возвращает содержимое текстового файла как символьную строку. Максимальный размер файла, который может быть считан - 65 535 символов (64K) - это максимальный размер символьной переменной. Если файл с именем, указанным в аргументе <имя файла>, не может быть найден, MEMOREAD() возвращает строку нулевой длины ("").
MEMOREAD() - функция обработки memo-полей, считывающая содержимое дискового файла в память, где оно может быть обработано как символьная строка или memo-поле. MEMOREAD() используется в сочетании с функциями MEMOEDIT() и MEMOWRIT() для чтения дисковых файлов, их редактирования и записи на диск. MEMOREAD() ищет файл с именем, заданным в аргументе <имя файла>, начиная с текущей директории; если искомый файл не обнаружен, то поиск продолжается в директориях, определенных командой PATH операционной системы DOS. В процессе поиска файла, заданного аргументом <имя файла>, функция MEMOREAD() не использует установок команд xClipper SET DEFAULT и SET PATH.
В сетях MEMOREAD() пытается открыть файл для совместного использования и только для чтения. Если файл уже захвачен другим процессом для индивидуального пользования, MEMOREAD() возвращает нулевую строку ("").
Следующий пример использует MEMOREAD() для присвоения содержимого текстового файла memo-полю Note и символьной переменной. REPLACE Notes WITH MEMOREAD("Temp.txt") cString = MEMOREAD("Temp.txt") В этом примере показана функция, которая редактирует дисковый файл. FUNCTION Editor( cFile) LOCAL cString IF (cString := MEMOREAD(cFile)) == "" ? "Ошибка чтения "+ cFile RETURN .F. ELSE MEMOWRIT( cFile, MEMOEDIT( cString )) RETURN .T. ENDIF
MEMOTRAN( <символьная строка>,[<замещающий символ 1>], <замещающий символ 2>]) --> новая символьная строка.
<символьная строка> | - строка символов или memo-поле. |
[<замещающий символ 1>] - символ, замещающий пару символов "жесткий | |
возврат каретки/перевод строки". По умолчанию - точка с запятой (;). | |
[<замещающий символ 2>] - символ, заменяющий пару : "мягкий возврат | |
каретки/перевод строки". По умолчанию - пробел. |
MEMOTRAN() возвращает копию <символьной строки> с замещенными парами символов "возврат каретки/перевод строки"
MEMOTRAN() - функция обработки memo-полей, которая изменяет длинные символьные строки или memo-поля, содержащие жесткий или мягкий возврат каретки/перевод строки, в форму, удобную для выдачи на дисплей. Эти две символьные комбинации используются функцией MEMOEDIT() как форматирующие признаки конца строки. Мягкий возврат каретки (CHR(141)) ставится в том случае, когда длина строки больше, чем размер окна MEMOEDIT(). Жесткий возврат каретки (CHR(13)) ставится при нажатии клавиши <Enter>.
Функция MEMOTRAN() бывает особенно полезна при выдаче memo-поля командой REPORT FORM, которая не делает переносов, когда встречается мягкий возврат каретки. MEMOTRAN() устраняет этот недостаток, замещая мягкий возврат каретки пробелом. Заметим, что если вы запускаете REPORT FORM, который использует MEMOTRAN(), и при этом MEMOTRAN() нигде больше в программе не встречается, то необходимо при помощи команды EXTERNAL объявить MEMOTRAN() как внешнюю функцию.
В этом примере из memo-поля удаляются все символы конца строки: REPLACE Notes WITH MEMOTRAN(Notes," "," ")
MEMOWRIT()(<имя файла>,<символьная строка>) --> признак завершения
MEMOWRIT() возвращает значение "истина" (.T.), если операция записи в файл прошла успешно, в противном случае возвращает значение "ложь" (.F.).
MEMOWRIT() - функция обработки memo-полей, которая записывает символьную строку или memo-поле в дисковый файл. Если в аргументе <имя файла> не задан маршрут доступа, MEMOWRIT() записывает файл в текущую директорию DOS. Установки команды SET DEFAULT TO не влияют на работу функции. Если файл с именем, указанным в аргументе <имя файла>, уже существует, то он переписывается.
MEMOWRIT() обычно используется в сочетании с функцией MEMOREAD() для загрузки текстовых файлов в память, и затем они могут быть отредактированы, выведены на консоль и потом записаны обратно на диск.
MEMOWRIT() можно также использовать как быстрый путь экспорта memo-поля в текстовый файл.
Этот пример демонстрирует, как MEMOWRIT() может быть использована совместно с MEMOREAD() для редактирования memo-поля внешним редактором: LOCAL cEditor := "MYEDIT.EXE" USE Sales NEW IF MEMOWRIT("Cliptmp.txt", Notes) RUN (cEditor + "Cliptmp.txt") REPLACE Notes WITH MEMOREAD("Cliptmp.txt") ELSE ? "Ошибка записи Cliptmp.txt" BREAK ENDIF
MLCOUNT(<символьная строка>, [<длина строки>],[<шаг табуляции>], [<переключатель переноса>]) --> кол-во строк
<символьная строка> | - memo-поле или строка символов, из которой |
выделяется строка текста. | |
<длина строки> | - определяет количество символов на строку и может |
принимать значения от 4 до 254. По умолчанию - 79. | |
<шаг табуляции> | - определяет размер шага табуляции. Если аргумент не |
определен, то по умолчанию шаг принимается равным 4. Если значение | |
аргумента <шаг табуляции> больше, чем значение аргумента <длина | |
строки>, то величина шага табуляции автоматически принимается равной | |
значению выражения (<длина строки> - 1). | |
<переключатель переноса> | - включает и выключает режим переноса слов. |
Если его значение - "истина" (.T.) - режим включен; если его значение | |
- "ложь" (.F.) - режим отключен. Если аргумент не определен, его | |
значение по умолчанию принимается - "истина" (.T.). |
MLCOUNT() возвращает число строк аргумента <символьная строка> в зависимости от значений аргументов <длина строки> и <шаг табуляции> и наличия или отсутствия режима переноса слов.
MLCOUNT() - функция обработки memo-полей, используемая в сочетании с функцией MEMOLINE() для печати символьных строк и memo-полей на основании заданного количества символов в строке. Способ действия заключается в том, что сначала с помощью MLCOUNT() подсчитывают количество строк в memo-поле или символьной строке. Затем, используя MEMOLINE(), выделяют каждую строку, зациклив этот процесс до тех пор, пока не будут выбраны все строки.
Если значение аргумента <переключатель переноса> - "истина" (.T.) и конец строки попадает внутрь слова, то оно переносится на следующую строку.
Если значение аргумента <переключатель переноса> - "ложь" (.F.), то MLCOUNT() подсчитывает количество строк точно в соответствии со значением, определенным в аргументе <длина строки> для каждой строки. Следующая строка начинается с символа, следующего за ближайшим символом твердого или мягкого возврата каретки.
Символы, попавшие в промежуток, игнорируются.
Этот пример показывает, как выдать на дисплей содержимое каждого memo-поля Notes файла базы данных Sales в виде последовательности строк длиной в 65 символов: USE Sales NEW nLineLength = 65 // DO WHILE ! EOF() nLines = MLCOUNT(Sales --> Notes, nLineLength) FOR nCurrLine = 1 TO nLines ? MEMOLINE(Sales --> Notes, nCurrLine, nLineLength) NEXT SKIP ? ENDDO
MLPOS(<символьная строка>,<длина строки>, <номер строки>, <номер колонки>, [<шаг табуляции>], [<перенос разрешен>]) --> номер позиции
<символьная строка> | - символьная строка для просмотра. |
<длина строки> | - длина форматированной строки. |
<номер строки> | - номер строки; отсчитывается от 1. |
<номер колонки> | - номер колонки; отсчитывается от 0. |
<шаг табуляции> | - определяет размер шага табуляции. Если аргумент не |
задан, по умолчанию величина шага принимается равной 4. | |
<перенос разрешен> | - логическое значение, определяющее разрешение |
переноса слов. Если аргумент не задан, по умолчанию его значение - | |
"истина" (.T.). |
MLCTOPOS() возвращает позицию в байтах внутри <символьная строка>, считая от 1.
MLCTOPOS() - функция для работы с MEMO-полями, определяющая номер позиции в байтах, соответствующий конкретным строке и колонке внутри отформатированного текста. Номер строки считается от единицы, а номер колонки - от нуля, что совместимо с функцией MEMOEDIT(). Возвращаемое значение считается от единицы, это делает удобным использование функции MLCTOPOS() внутри SUBSTR() или других строковых функций.
В этом примере определяется номер позиции байта в строке текста. Текст форматируется на длину 5 символов с разрешением переноса. Определение осуществляется для символа в нулевой колонке третьей строки: cText := "Пометим сторону, где хлеб намазан маслом" // ? MLCTOPOS(cText, 5, 3, 0) // Результат: 9
MLPOS(<символьная строка>,<длина строки>,<номер строки>, [<шаг табуляции>], [<переключатель переноса>]) --> номер символа
<символьная строка> | - строка символов или memo-поле. |
<длина строки> | - определяет количество символов в строке. |
<шаг табуляции> | - определяет размер шага табуляции. Если аргумент не |
задан, по умолчанию величина шага принимается равной 4. Если значение | |
аргумента <шаг табуляции> больше или равно значению аргумента <длина | |
строки>, то тогда размер шага табуляции принимается равным значению | |
выражения (<длина строки> - 1). | |
<переключатель переноса> | - переключает (включает и выключает) режим |
переноса слов. Если его значение "истина" (.T.) - режим включен, если | |
"ложь" (.F.) - режим отключен. Если аргумент не задан, по умолчанию | |
его значение - "истина" (.T.). |
MLPOS() возвращает номер символа аргумента <символьная строка> начала подстроки с порядковым номером, равным значению аргумента <номер строки>, в виде целого числа. Если значение аргумента <номер строки> больше, чем количество строк в заданной символьной строке, MLPOS() возвращает длину всей символьной строки.
Этот пример демонстрирует использование функции MLPOS() для определения в текстовом файле номера символа начала пятой строки, при длине строк 40 символов: cString = MEMOREAD("Temp.txt") nLinelength = 40 nLine = 5 nPosition = MLPOS(cString, nLinelength, nLine) ? SUBSTR(cString, nPosition, 12)
MPOSTOLC(<символьная строка>,<длина строки>,<номер позиции>, [<шаг табуляции>], [<перенос разрешен>]) --> массив
<символьная строка> | - символьная строка для просмотра. |
<длина строки> | - длина форматированной строки. |
<номер позиции> | - номер позиции в байтах в тексте; отсчитывается от 1. |
<шаг табуляции> | - определяет размер шага табуляции. Если аргумент не |
задан, по умолчанию величина шага принимается равной 4. | |
<перенос разрешен> | - логическое значение, определяющее разрешение |
переноса слов. Если аргумент не задан, по умолчанию его значение - | |
"истина" (.T.). |
MPOSTOLC() возвращает массив, содержащий значения строки и колонки для заданного <номер позиции>.
MPOSTOLC() - функция работы с MEMO-полями, определяющая номер строки и колонки в отформатированном тексте, соответствующие позиции в байтах в строке. Возвращаемый номер строки отсчитывается от единицы, а номер колонки - от нуля, что соответствует правилам для функцией MEMOEDIT(). Возвращаемый <номер позиции> - отсчитывается от единицы, это делает удобным использование функции MPOSTOLC() с AT(), RAT() или другими строковыми функциями.
В этом примере для тринадцатого символа строки текста определяется номер строки и колонки при форматировании строки на длину 8 символов. Тринадцатый символ текста - буква "т" в слове "сторону". При заданном форматировании, три первых слова располагаются на отдельных строках. Слово "сторону" будет располагаться, начиная с самой левой колонки третьей строки отформатированного текста, следовательно, возвращаемое значение - {3,1}: cText := "Пометим ту сторону, где хлеб намазан маслом" // aLC := MPOSTOLC(cText, 8, 13,) // Результат: {3, 1}
PADL( <выражение>,<длина>,[<символ-заполнитель>]) --> дополненная строка. PADC(<выражение>,<длина>,[<символ-заполнитель>]) --> дополненная строка PADR(<выражение>,<длина>,[<символ-заполнитель>]) --> дополненная строка
PADL(), PADC(), PADR() возвращают символьную строку, которая представляет собой <выражение>, дополненное <символом-заполнителем> до величины, заданной в аргументе <длина>.
PADL(), PADC(), PADR() - функции обработки символов, которые дополняют выражения типа CHARACTER, DATE и NUMERIC символом-заполнителем, создавая новую символьную строку заданной длины. Функция PADC() центрирует значение, заданное в аргументе <выражение>, дополняя его до заданной длины символом-заполнителем и с левой, и с правой стороны.
PADL() дополняет строку символом-заполнителем с левой стороны; PADR() дополняет строку символом-заполнителем с правой стороны.
Если длина результирующей строки, определенной аргументом <выражение>, превосходит значение аргумента <длина>, то все функции PAD() укорачивают возвращаемую символьную строку до значения аргумента <длина>.
Функции PADL(), PADC(), PADR() используются для выдачи на дисплей строк переменной длины внутри фиксированной области. Они могут быть использованы, например, для форматирования вывода информации командами последовательного вывода (??). Если есть уверенность, что предыдущий текст полностью переписан, эти функции можно использовать на дисплее внутри фиксированной области.
Функции PADL(), PADC(), PADR() являются обратными по отношению к функциям ALLTRIM(), LTRIM() и RTRIM(), которые удаляют пробелы в начале и конце символьной строки.
В этом примере функция PADR() используется для форматирования вывода на дисплей количества записей в строке статуса путем заполнения свободного пространства пробелами: IF EOF() @ 23, 45 PADR("EOF/" + LTRIM(STR(LASTREC())), 20) ELSEIF BOF() @ 23, 45 PADR("BOF/" + LTRIM(STR(LASTREC())), 20) ELSE @ 23, 45 SAY PADR("Record" + LTRIM(STR(RECNO()) + "/" + ; LTRIM(STR(LASTREC())), 20) ENDIF
RAT(<подстрока поиска>, <строка>) --> номер позиции
RAT() возвращает позицию подстроки, заданной аргументом <подстрока поиска> внутри строки, заданной аргументом <строка> в виде целого числа. Если подстрока поиска не найдена, то RAT() возвращает ноль.
RAT() - это символьная функция, которая возвращает позицию последнего вхождения символьной подстроки в другую символьную строку. Поиск вхождения осуществляется просмотром справа. RAT() похожа на функцию AT(), которая возвращает позицию первого вхождения подстроки в другую строку. RAT() похожа также на оператор $, который определяет, содержится ли подстрока в строке.
Обе функции - и RAT(), и AT(), используют в сочетании с функциями SUBSTR(), LEFT() и RIGHT() для выделения подстрок.
Этот пример иллюстрирует создание функции пользователя FilePath(), которая выделяет маршрут доступа из спецификации файла. Если маршрут не задан, FilePath() возвращает пустую строку (""): ? FilePath("C:\DBF\Sales.dbf") //Результат: C:\DBF\ FUNCTION FilePath(cFile) LOCAL nPos, cFilePath IF (nPos := RAT("\", cFile)) != 0 cFilePath=SUBSTR(cFile, 1, nPos) ELSE cFilePath = "" ENDIF RETURN cFilePath
REPLICATE(<строка символов>, <к-во повторений>) --> новая строка символов
REPLICATE() возвращает символьную строку длиной до 65 535 (64К) байтов. При количестве повторений, равном нулю,функция возвращает строку нулевой длины ("").
REPLICATE() - это функция обработки символьных строк, которая используется для многократной выдачи на экран, вывода на печать или заполнения буфера клавиатуры одним или более символами. REPLICATE() подобна SPACE(), возвращающей заданное количество пробелов.
Эти примеры демонстрируют возможности функции REPLICATE(): ? REPLICATE("*", 5) // Результат: ***** ? REPLICATE("Hi ", 2) // Результат: Hi Hi ? REPLICATE(CHR(42), 5) // Результат: ***** Этот пример использует REPLICATE() для имитации нажатия на клавиатуре двадцати пяти раз клавиши <стрелка вниз>: #include "Inkey.ch" KEYBOARD REPLICATE(CHR(K_DN), 25)
RIGHT(<строка символов>, <к-во символов>) -> подстрока
RIGHT() возвращает подстроку длиной, равной количеству символов, заданному в аргументе <к-во символов>. Подстрока выбирается от конца строки, заданной в аргументе <строка символов>. Если значение аргумента <к-во символов> отрицательно или ноль, то RIGHT() возвращает строку нулевой длины (""). Если значение аргумента <к-во символов> больше длины символьной строки, то RIGHT() полностью возвращает строку, заданную в аргументе <строка символов>. Максимальный размер строки - 65535 (64К) байт.
RIGHT() - функция обработки символьных строк, которая выделяет подстроку, начиная с самого правого символа аргумента <строка символов>. Ее действие аналогично действию выражения
SUBSTR(<строка символов>,-<к-во символов>).
Например, RIGHT("ABC", 1) - это то же самое, что и SUBSTR("ABC", -1). Функция RIGHT() похожа на функцию LEFT(), которая извлекает подстроку, начиная с самого левого символа аргумента <строка символов>.
Функции RIGHT(), LEFT() и SUBSTR() часто используют в сочетании с функциями AT() и RAT(), определяющими первую и/или последнюю позицию подстроки до ее извлечения.
В этом примере показывается связь меду функциями RIGHT() и SUBSTR(): ? RIGHT("ABCDEF", 3) // Результат: DEF ? SUBSTR("ABCDEF", -3) // Результат: DEF В этом примере извлекается подстрока от конца строки до запятой: LOCAL cName := "Джейн,Томас" ? RIGHT(cName,; LEN(cName) - RAT(",", cName) -1) // Результат: Томас
[R]TRIM(<символьная строка>) --> усеченная символьная строка
RTRIM() возвращает строку, являющуюся копией аргумента <символьная строка> с удаленными справа пробелами. Если значение аргумента <символьная строка> - строка нулевой длины ("") или состоит из одних пробелов, то RTRIM() возвращает строку нулевой длины ("").
RTRIM() - функция обработки символьных строк, которая используется для форматирования символьных строк, имеющих на конце пробелы. Она полезна, когда нужно удалить конечные пробелы при конкатенации строк. Такая ситуация типична для файлов баз данных, хранящихся в форматах с фиксированной длиной.
Например, можно использовать RTRIM() для конкатенации имен первого и последнего полей, чтобы создать имя в виде строки.
RTRIM() схожа с LTRIM(), которая удаляет начальные пробелы из символьной строки, и ALLTRIM(), которая удаляет пробелы и в начале, и в конце строки. Обратными для этих функций являются функции PADC(), PADR() и PADL(), которые центрируют и выравнивают по краю символьные строки, заполняя их символами-заполнителями.
Этот пример демонстрирует функцию пользователя, которая использует RTRIM() для форматирования полей CITY, STATE и ZIP. FUNCTION CityState( cCity, cState, cZip) RETURN RTRIM(cCity) + ", " + RTRIM(cState) + " " + cZip Этот пример использует CityState() для вывода записи из Customer.dbf USE Customer INDEX CustName NEW SEEK "Kate" ? CityState(City,State,ZipCode) // Результат: Athens, GA 10066
SEARCH(<sPattern>, <sString>, [@aReg], [<nFrom>], [<nRange>]) --> TRUE || FALSE
Возвращает TRUE в случае успешного поиска.
SEARCH() ищет подстроку в строке <sString> по регулярному выражению <sPattern> начиная с позиции <nFrom> и с учетом значения <nRange>. Результат поиска будет записан в <aReg>, если этот параметр передан в функцию.
<nRange> это значение сдвигов, при которых проверяется совпадение относительно <nFrom>. Если <nRange>==0 - проверяется только позиция <nFrom>; если <nRange>==1 - проверяются позиции <nFrom> и <nFrom>+1; если <nRange>==-1 - проверяются позиции <nFrom> и <nFrom>-1.
Каждый элемент <aReg> это массив из 3-х элементов: 1-й элемент - начальная позиция найденной подстроки; 2-й элемент - конечная позиция подстроки; 3-й - длина найденной подстроки.
str := "int clip_SEARCH(ClipMachine * mp)" reg := {} if SEARCH("clip_[_A-Z]*", str, @reg) qout("start :" +str(reg[1][1])) qout("end :" +str(reg[1][2])) qout("length:" +str(reg[1][3])) else qout("Regular expression not found!") endif
SOUNDEX(<строка символов>) --> строка в форме А999
SOUNDEX() возвращает четырехзначную символьную строку в форме A999
SOUNDEX() является символьной функцией, используемой для индексирования и поиска звуковых или фонетических соответствий. Она применяется тогда, когда неизвестна точная орфография написания символьных строк или же существует реальная опасность неправильного написания имен. Неправильное орфографическое написание является распространенным в интерактивных системах реального времени, где оператор, вводящий данные, получает информацию по телефону. SOUNDEX() работает путем сведения похожих по произношению символов с символами с одинаковым значением. Следует однако отметить, что звуковой метод не является совершенным. Символы, являющиеся совершенно различными, могут иметь одинаковое звуковое значение.
Этот пример показывает построение индекса путем использования SOUNDEX() для создания значений ключей. Затем она ищет значение, найденное в поле Salesman: USE Sales INDEX ON SOUNDEX(Salesman) TO Salesman SEEK SOUNDEX("Smith") ? FOUND(), Salesman // Результат: .T. Smith Этот пример осуществляет поиск того же значения, что и предыдущий, но с другим написанием: SEEK SOUNDEX("Smythe") ? FOUND(), Salesman // Результат: .T. Smith
SPACE(<число пробелов>) --> строка пробелов
SPACE() возвращает символьную строку. Если значение аргумента <число пробелов> равно нулю, SPACE() возвращает строку нулевой длины ("").
SPACE() является функцией обработки символьных строк, используемой для возврата строки, состоящей из заданного числа пробелов. Ее действие подобно действию функции REPLICATE(" ",<количество байтов>).
SPACE() используется для инициализации символьной переменной перед ее использованием в команде GET. Кроме того, SPACE() используется для заполнения строк либо начальными, либо конечными пробелами. Однако следует отметить, что применение функций PADC(), PADL() и PADR() для этой цели более эффективно.
Этот пример показывает использование SPACE() для инициализации переменной при вводе данных: USE Customer NEW MEMVAR->Name = SPACE(LEN(Customer->Name)) @ 10, 10 SAY "Имя покупателя:" GET MEMVAR->Name READ
STR(<число>, [<длина строки>], [<дробная часть>]) --> число в виде строки
STR() возвращает значение аргумента <число>, преобразованное в строку символов. Если необязательные аргументы длины и величины дробной части не заданы, STR() возвращает символьную строку в соответствии с правилами.
STR() является арифметической функцией, которая преобразует числовые значения в символьные строки. Она обычно используется при конкатенации числовых значений с символьными строками. STR() применяется при выведении на дисплей чисел, создании кодов, являющихся частью числового значения и создания новых индексных ключей, которые объединяют числовые и символьные данные.
STR() подобна функции TRANSFORM(), которая форматирует числовые значения в виде символьных строк, используя маску вместо спецификаций длины и дробной части. Поскольку TRANSFORM() использует маску, она может вставлять такие форматирующие символы, как запятые, знаки доллара и круглые скобки.
Обратной для STR() является функция VAL(), которая преобразует строки символов в целые числа.
Этот пример показывает диапазон значений, возвращаемых с помощью STR() в зависимости от заданных значений аргументов: nNumber = 123.45 ? STR(nNumber) // Результат: 123.45 ? STR(nNumber, 4) // Результат: 123 ? STR(nNumber, 2) // Результат: ** ? STR(nNumber * 10, 7, 2) // Результат: 1234.50 ? STR(nNumber * 10, 12, 4) // Результат: 1234.5000 ? STR(nNumber, 10, 1) // Результат: 1234.5 Этот пример показывает использование STR() для создания индекса с составным ключом номеров заказов и фамилий клиентов: USE Customer NEW INDEX ON STR(NumOrders, 9) + CustName TO CustOrd
STR2VAR(<sUucodeStr>) --> <vData>
Возвращает исходные данные, соответствующие uucode строке <sUucodeStr>.
STR2VAR() производит обратное преобразование uucode строки <sUucodeStr> в исходные данные и возвращает их. Функция обратна функции VAR2STR()
f1 := fopen("test.txt") f2 := fcreare("test_uucode.txt") do while !feof(f1) uStr := VAR2STR(fGet(f1, 1024)) fwrite(f2, uStr, len(uStr)) enddo fclose(f2) fclose(f1) f1 := fopen("test_uucode.txt") do while !feof(f1) uStr := fGet(f1, 1024) ? STR2VAR(uStr) ? enddo fclose(f1)
Не зависит от платформ
STRTRAN(<строка символов>, <замещаемая подстрока>,[<замещающая подстрока>], [<начало замены>], [<число замен>]) --> новая строка символов
<строка символов> | является символьной строкой или memo-полем, в |
котором производится поиск. | |
<замещаемая подстрока> | - последовательность символов, которую нужно |
установить. | |
<замещающая подстрока> | - последовательность символов, которыми |
нужно заменить значение аргумента <замещаемая подстрока>. Если этот | |
аргумент не задан, найденные экземпляры аргумента поиска заменяются | |
строкой нулевой длины (""). | |
<начало замены> | - является номером первого экземпляра аргумента |
<замещаемая строка> | , подлежащего замене. Если этот аргумент опущен, |
то по умолчанию принимается (1). | |
<число замен> | - число экземпляров аргумента <замещаемая подстрока>, |
которые должны заменяться. Если он опущен, то по умолчанию заменяются | |
все. |
STRTRAN() возвращает новую символьную строку с заданными экземплярами <замещаемая подстрока>, замененными на значение аргумента <замещающая подстрока>.
STRTRAN() является функцией обработки символьных строк, которая выполняет стандартный поиск подстроки внутри символьной строки. Когда она находит соответствие, она заменяет строку поиска заданной строкой замены. Если не заданы аргументы <начало замены> и <число замен>, все экземпляры подстрок, совпадающие со значением аргумента <замещаемая подстрока> заменяются на значение аргумента <замещающая подстрока>. Следует отметить, что STRTRAN() заменяет подстроки и, следовательно, не отвечает за целые слова.
Этот пример показывает использование STRTRAN() для установления современного аналога известной цитаты староанглийского периода: cString = "Вычислять или не вычислять ?" ? STRTRAN(cString, "вычислять", "быть") // Результат : быть или не быть ?
STUFF(<строка символов>, <начало замены>, <к-во удаляемых символов>, <вставляемая подстрока>) --> новая строка символов
STUFF() возвращает копию аргумента <строка символов> с удаленными символами и вставленной строкой, значение которой задано аргументом <вставляемая подстрока>.
STUFF() является функцией обработки символьных строк, удаляющей символы, количество которых задано в аргументе <к-во удаляемых символов>, из аргумента <строка символов>, начиная с позиции, заданной аргументом <начало замены>. Затем она вставляет значение аргумента <вставляемая подстрока> в полученную строку, начиная с символа, номер которого определен в аргументе <начало замены>, и формирует возвращаемую строку. При этом STUFF() может выполнять шесть следующих операций:
Вставка. Если значение аргумента <к-во удаляемых символов> равно нулю, из аргумента <строка символов> символы не удаляются. Значение аргумента <вставляемая подстрока> вставляется, начиная с позиции, заданной аргументом <начало замены>, после чего строка возвращается. Например:
STUFF("My dog has fleas" , 12, 0, "no")
возвратит: "My dog has no fleas".
Замена. Если значение аргумента <вставляемая подстрока> имеет ту же длину, что и значение аргумента <к-во удаляемых символов>, значение аргумента <вставляемая строка> заменяет символы, начиная с позиции, заданной аргументом <начало замены>. Удаляется то же число символов, что и вставляется, и полученная строка имеет такую же длину, что и первоначальная. Например:
STUFF("My dog has fleas", 12, 5, "bones")
возвращает: "My dog has bones".
Удаление. Если значение аргумента <вставляемая подстрока> является строкой с нулевой длиной (""), из строки, заданной аргументом <строка символов>, удаляется число символов, заданное аргументом <к-во удаляемых символов>, и строка возвращается без каких-либо добавленных символов. Например:
STUFF("My dog has fleas", 1, 3, "")
возвратит: "dog has fleas".
Замена и вставка. Если значение аргумента <вставляемая подстрока> больше, чем значение аргумента <к-во удаляемых символов>, все символы, начиная с позиции, установленной аргументом <начало замены>, в соответствии со значением аргумента <к-во удаляемых символов>, удаляются, а затем значение аргумента <вставляемая подстрока> вставляется в строку. Поскольку вставляется больше символов, чем удаляется, полученная строка всегда длиннее первоначальной. Например:
STUFF("My dog has fleas", 8, 3, "does not have")
возвратит: "My dog does not have fleas".
Замена и удаление. Если длина аргумента <вставляемая подстрока> меньше, чем значение аргумента <к-во удаляемых символов>,лишние символы будут удалены, а затем произойдет вставка. Результирующая строка при этом будет короче исходной. Например:
STUFF ("My dog has fleas", 8, 3, "is")
возвратит: "My dog is fleas".
Замена и удаление оставшихся символов. Если значение аргумента <к-во удаляемых символов> больше или равно числу оставшихся символов, начиная с позиции ,заданной аргументом <начало замены>, аргумента <строка символов>, все эти оставшиеся символы удаляются перед вставкой значения аргумента <вставляемая подстрока>. Например:
STUFF("My dog has fleas", 8, 10, "is")
возвратит "My dog is".
Этот пример демонстрирует шесть основных операций STUFF(): // Вставка ? STUFF("ABCDEF", 2, 0, "xyz") // Результат: AxyzBCDEF // // Замена ? STUFF("ABCDEF", 2, 3, "xyz") // Результат: AxyzEF // // Удаление ? STUFF("ABCDEF", 2, 2, "") // Результат: ADEF // // Замена со вставкой ? STUFF("ABCDEF", 2, 1, "xyz") // Результат: AxyzCDEF // // Замена с удалением ? STUFF("ABCDEF", 2, 4, "xyz") // Результат: AxyzF // // Замена с удалением оставшихся символов ? STUFF("ABCDEF", 2, 10, "xyz") // Результат: Axyz
SUBSTR(<строка символов>, <начальная позиция>, [<к-во символов>]) --> подстрока
<строка символов> | - символьная строка, из которой должна быть |
выделена подстрока. Ее длина не должна превышать 65 535 (64К) байтов, | |
что равняется максимальному размеру символьной строки в xClipper. | |
<начальная позиция> | - начальная позиция в строке, заданной аргументом |
<строка символов> | . Если значение аргумента <начальная позиция> |
положительное, то отсчет ведется от крайнего слева символа в | |
аргументе <строке символов>. | |
Если же значение аргумента <начальная позиция> - отрицательное, то | |
от крайнего справа символа. | |
<к-во символов> | - является числом выделяемых символов. Если аргумент |
опущен, подстрока начинается со значения аргумента <начальная | |
позиция> и продолжается до конца строки. Если значение аргумента | |
<к-во символов> | больше числа символов, отсчитываемых от значения |
аргумента <начальная позиция> до конца строки, определенной | |
аргументом <строка символов>, то излишек игнорируется. |
SUBSTR() возвращает выделенную символьную подстроку.
SUBSTR() является функцией обработки символьных строк, которая выделяет подстроку из другой символьной строки или memo-поля. SUBSTR() сходна с функциями LEFT() и RIGHT(), которые выделяют подстроки, начиная с крайнего слева или крайнего справа символов аргумента <строка символов>.
Функции SUBSTR(), RIGHT() и LEFT() часто используются в сочетании с функциями AT() и RAT() для определения первой и (или) последней позиции подстроки до ее выделения. Они также используются для вывода на дисплей или принтер только части символьной строки.
В данных примерах показано выделение имени и файмилии из переменной: cName = "Biff Styvesent" ? SUBSTR(cName, 1, 4) // Результат: Biff ? SUBSTR(cName, 6) // Результат: Styvesent ? SUBSTR(cName, LEN(cName) + 2) // Результат: Нулевая строка ? SUBSTR(cName, -9) // Результат: Styvesent ? SUBSTR(cName, -9, 3) // Результат: Sty Этот пример показывает использование SUBSTR() в сочетании с AT() и RAT() для создания функции пользователя, выделяющей имена файлов из их спецификации: ? FileBase("C:\PRG\MYFILE.OBJ") // Результат: MYFILE.OBJ FUNCTION FileBase( cFile ) LOCAL nPos IF (nPos := RAT("\", cFile)) != 0 RETURN SUBSTR( cFile, nPos + 1) ELSEIF (nPos := AT(":", cFile)) != 0 RETURN SUBSTR( cFile, nPos + 1) ELSE RETURN cFile ENDIF
TRIM(<cString>) --> cTrimString
TRIM() returns a copy of <cString> with the trailing spaces removed. If <cString> is a null string ("") or all spaces, TRIM() returns a null string ("").
TRIM() is a character function that formats character strings. It is useful when you want to delete trailing spaces while concatenating strings. This is typically the case with database fields which are stored in fixed-width format. For example, you can use TRIM() to concatenate first and last name fields to form a name string.
TRIM() is related to LTRIM(), which removes leading spaces, and ALLTRIM(), which removes both leading and trailing spaces. The inverse of ALLTRIM(), LTRIM(), and RTRIM() are the PADC(), PADR(), and PADL() functions which center, right-justify, or left-justify character strings by padding them with fill characters.
This is a user-defined function in which TRIM() formats city, state, and zip code fields for labels or form letters: FUNCTION CityState(cCity, cState, cZip) RETURN TRIM(cCity) + ", " ; + TRIM(cState) + " " + cZip In this example the user-defined function, CityState(), displays a record from Customer.dbf: USE Customer INDEX CustName NEW SEEK "Kate" ? CityState(City, State, ZipCode) // Result: Athens, GA 10066
UPPER(<символьная строка>) --> символьная строка в верхнем регистре
UPPER() returns a copy of <cString> with all alphabetical characters converted to uppercase. All other characters remain the same as in the original string.
UPPER() - функция обработки символьных строк. Используется для преобразования строк с символами в нижнем и верхнем регистрах в строки символов верхнего регистра. Она связана с функцией LOWER(), которая преобразует строки символов верхнего регистра и смешанные строки в строки символов нижнего регистра. Функция UPPER() также связана с функциями ISUPPER() и ISLOWER(), которые определяют, начинается ли строка с буквы верхнего или нижнего регистров.
UPPER() обычно используется для форматирования символьных строк. Однако UPPER() может быть полезна для создания индексных ключей, независимых от значений регистра.
Следующий пример иллюстрирует эффект от применения UPPER(): ? UPPER("строка") // Результат: СТРОКА ? UPPER("123 буква =<>") // Результат: 123 БУКВА =<> Этот пример использует UPPER() как часть условия, независимого от регистра: USE Customer INDEX CustName NEW LIST CustNum FOR "KATE" $ UPPER(Customer) UPPER() также полезна для создания индексных ключевых выражений, независимых от значения регистра: USE Customer NEW INDEX ON UPPER(last) TO CustLst Далее, используйте также выражения для преобразования Customer: MEMVAR->Last = SPACE(15) @ 10, 10 GET MEMVAR->Last READ SEEK UPPER(MEMVAR->Last)
VAL (<число в символьной форме>) --> число
VAL() возвращает значение аргумента <число в символьной форме> преобразованное в числовое значение, включая дробную часть.
VAL() - функция преобразования символов, которая преобразует строку символов, содержащую цифры, в числовое значение. Функция VAL() просматривает значение аргумента <число в символьной форме> до тех пор, пока не встретится вторая десятичная точка, нечисловой символ или конец выражения. Лидирующие пробелы игнорируются. Если SET FIXED установлено в режим ON, число возвращаемых функцией десятичных знаков определяется установкой команды SET DECIMALS, округляя полученное значение аргумента <число в символьной форме>, если в нем значащих цифр больше, чем определено командой SET DECIMALS. При значениях округляемой дробной части от 0 до 4 не происходит переноса 1 в старший разряд, а при значениях от 5 до 9 такой перенос происходит.
Если SET FIXED установлено в режим OFF, то VAL() возвращает число десятичных знаков такое же, как и в аргументе <число в символьной форме>.
VAL() - функция, обратная STR() и TRANSFORM(), которые преобразуют числовые значения в символьные строки.
Следующие примеры иллюстрируют функцию VAL() c SET FIXED ON и SET DECIMALS TO 2. SET DECIMALS TO 2 SET FIXED ON // ? VAL ("12.1234") // Результат: 12.12 ? VAL ("12.1256") // Результат: 12.13 ? VAL ("12A12") // Результат: 12.00 ? VAL ("A1212") // Результат: 0.00 ? VAL (SPACE (0)) // Результат: 0.00 ? VAL (SPACE (1)) // Результат: 0.00 ? VAL (" 12.12") // Результат: 12.12 ? VAL ("12 .12") // Результат: 12.00
VAR2STR(<vData>) --> <sUucodeStr>
Возвращает uucode строку <sUucodeStr>.
VAR2STR() возвращает исходную строку <vData> в uucode строку <sUucodeStr> и возвращает ее.
f1 := fopen("test.txt") f2 := fcreare("test_uucode.txt") do while !feof(f1) uStr := VAR2STR(str) fwrite(f2, uStr, len(uStr)) enddo fclose(f2) fclose(f1)
Не зависит от платформ
Пред. | Начало | След. |
INFO | Уровень выше | NUMERIC |