STRING

Name

STRING -- 

Function

<sResString>        ADDSLASHES(<sString>)
cTrimString         ALLTRIM(<cString>)
nCode               ASC(<cExp>)
nPosition           AT(<cSearch>, <cTarget>)
TRUE || FALSE       BETWEEN(<TargetData>, <FirstData>, <SecondData>)
cResult             bUnZip2(<cData>)
cResult             bZip2(<cData> [,<nLevel>])
cChar               CHR(<nCode>)
<nCount>            CSCOUNT(<сChar>, <sString>)
<nValue>            DSTRTON(<sString>)
lEmpty              EMPTY(<exp>)
<nValue>            FSTRTON(<sString>)
nPos                FT_AT2( <cSearch>, <cTarget> [, <nOccurs> [, <lCaseSens> ] ] )
cByte               FT_BITCLR( <cByte>, <nBitPos> )
cByte               FT_BITSET( <cByte>, <nBitPos> )
cByte               FT_BYTEAND( <cByte1>, <cByte2> )
cNewByte            FT_BYTENEG( <cByte> )
cNewByte            FT_BYTENOT( <cByte> )
cNewByte            FT_BYTEOR( <cByte1>, <cByte2> )
cNewByte            FT_BYTEXOR( <cByte1>, <cByte2> )
<nStringPosition>   FT_FINDITH( <cCheckFor>, <cCheckIn>, <nWhichOccurrence> ; [, <lIgnoreCase> ] )
lResult             FT_ISBIT( <cByte>, <nBitPos> )
lResult             FT_ISBITON( <nNumber>, <nBit> )
cMetaPhone          FT_METAPH( <cName> [, <nSize> ] )
<nOccurrences>      FT_NOOCCUR( <cCheckFor>, <cCheckIn> ; [, <lIgnoreCase> ] )
<cPrinterFormat>    FT_PCHR( <cString> )
TRUE || FALSE       GLOB(<sString>, <sReg>, [<lIgnoreCase>])
cResult             gUnZip(<cData>)
cResult             gZip(<cData> [,<nLevel>])
cConvertedString    HARDCR(<cString>)
<sStr>              HASHNAME(<nHashCode>)
<nHashCode>         HASHSTR(<sStr>)
lBoolean            ISALPHA(<cString>)
lBoolean            ISDIGIT(<cString>)
lBoolean            ISLOWER(<cString>)
lBoolean            ISUPPER(<cString>)
cSubString          LEFT(<cString>, <nCount>)
nCount              LEN(<cString> | <aTarget>)
TRUE || FALSE       LIKE(<sMask>, <sString>)
cLowerString        LOWER(<cString>)
cTrimString         LTRIM(<cString>)
cTextBuffer         MEMOEDIT([<cString>], [<nTop>], [<nLeft>], [<nBottom>], [<nRight>], [<lEditMode>], [<cUserFunction>], [<nLineLength>], [<nTabSize>], [<nTextBufferRow>], [<nTextBufferColumn>], [<nWindowRow>], [<nWindowColumn>])
cLine               MEMOLINE(<cString>,[<nLineLength>],[<nLineNumber>], [<nTabSize>],[<lWrap>])
cString             MEMOREAD(<cFile>)
cNewString          MEMOTRAN(<cString>,[<cReplaceHardCR>],[<cReplaceSoftCR>])
lSuccess            MEMOWRIT(<cFile>, <cString>)
nLines              MLCOUNT(<cString>, [<nLineLength>],[<nTabSize>], [<lWrap>])
nPosition           MLCTOPOS(<cText>, <nWidth>, <nLine>, <nCol>, [<nTabSize>], [<lWrap>])
nPosition           MLPOS(<cString>, <nLineLength>, <nLine>, [<nTabSize>], [<lWrap>])
aLineColumn         MPOSTOLC(<cText>, <nWidth>, <nPos>, [<nTabSize>], [<lWrap>])
cPaddedString       PADL(<exp>, <nLength>, [<cFillChar>]) --> cPaddedString PADC(<exp>, <nLength>, [<cFillChar>]) --> cPaddedString PADR(<exp>, <nLength>, [<cFillChar>])
NIL                 QOUT([<exp list>]) --> NIL QQOUT([<exp list>])
nPosition           RAT(<cSearch>, <cTarget>)
cRepeatedString     REPLICATE(<cString>, <nCount>)
cSubString          RIGHT(<cString>, <nCount>)
cTrimString         [R]TRIM(<cString>)
TRUE || FALSE       SEARCH(<sPattern>, <sString>, [@aReg], [<nFrom>], [<nRange>])
cSoundexString      SOUNDEX(<cString>)
cSpaces             SPACE(<nCount>)
cNumber             STR(<nNumber>, [<nLength>], [<nDecimals>])
<vData>             STR2VAR(<sUucodeStr>)
cNewString          STRTRAN(<cString>, <cSearch>,[<cReplace>], [<nStart>], [<nCount>])
cNewString          STUFF(<cString>, <nStart>,	<nDelete>, <cInsert>)
cSubstring          SUBSTR(<cString>, <nStart>, [<nCount>])
cFormatString       TRANSFORM(<exp>, <cSayPicture>)
cTrimString         TRIM(<cString>)
cType               TYPE(<cExp>)
cUpperString        UPPER(<cString>)
nNumber             VAL(<cNumber>)
cType               VALTYPE(<exp>)
<sUucodeStr>        VAR2STR(<vData>)
<nCode>             WEIGHTASC(<sString>)
<sTable>            WEIGHTTABLE()

Description

Function ADDSLASHES()

  ADDSLASHES(<sString>) 	--> <sResString>
 

ADDSLASHES() возвращает строку <sResString> с обратными слэш перед символами, нуждающимися в экранировании, например в запросах к БД. Это такие символы, как одиночная кавычка ('), двойная кавычка ("), обратный слэш (\) и NUL (нулевой символ).

Function ALLTRIM()

 ALLTRIM(<символьное выражение>) --> строка символов

ALLTRIM() - функция работы с символьными строками, которая удаляет ведущие и завершающие пробелы из строки. Она выполняет действие сразу двух функций - LTRIM() и RTRIM(), которые удаляют из строки ведущие и заключающие пробелы соответственно. Функции ALLTRIM(), LTRIM() и RTRIM() являются противоположными по действию функциям PADC(), PADR() и PADL(), которые центрируют строки, выравнивают их справа или слева, добавляя в них пробелы.

Function ASC()

 ASC(<символьное выражение>) --> значение кода ASCII

ASC() - это функция преобразования символов, которая возвращает значение кода ASCII самого первого символа в строке. ASC() в основном используется с выражениями, в которых ведутся арифметические расчеты над числовыми значениями кодов ASCII символов. CHR() и ASC() - это функции, противоположные по действию друг другу.

Function AT()

 AT(<подстрока поиска>,<строка>) --> номер позиции

AT() - функция работы с символьными строками, которая определяет позицию первого появления символьной подстроки <подстрока поиска> в строке <строка>. Для определения последнего появления подстроки в строку, используется функция RAT().

Function BETWEEN()

 BETWEEN(<TargetData>, <FirstData>, <SecondData>) 	--> TRUE || FALSE

BETWEEN() сравнивает исходное значение <TargetData> с <FirstData> и <SecondData>. Если <TargetData> находится в границах между <FirstData> и <SecondData>, BETWEEN() возвращает TRUE.

Все сравниваемые значения должны принадлежать какому-либо одному типу (строка, число, дата, ...).

Function CHR()

 CHR(<код ASCII>) --> символ

CHR() - функция преобразования чисел, которая преобразует код ASCII в символ. Она противоположна по действию функции ASC(). Эта многоплановая функция полезна в часто используемых задачах, таких как:

Посылка управляющих кодов или графических символов на экран или принтер.

Включение звонка.

Преобразование кодов, возвращаемых функцией INKEY(), в символы.

Заполнение буфера клавиатуры.

Function CSCOUNT()

 CSCOUNT(<сChar>, <sString>) 	--> <nCount>

CSCOUNT() возвращает количество символов <cChar> в строке <sString>.

Function DSTRTON()

 DSTRTON(<sString>) 	--> <nValue>

DSTRTON() преобразует строку <sString> в число и возвращает его.

Function FSTRTON()

 FSTRTON(<sString>) 	--> <nValue>

FSTRTON() преобразует строку <sString> в число и возвращает его.

Function FT_AT2()

 FT_AT2( <cSearch>, <cTarget> [, <nOccurs> [, <lCaseSens> ] ] ) --> nPos

This function will find the nth occurrence of a substring within a string.

Function FT_BITCLR()

 FT_BITCLR( <cByte>, <nBitPos> ) --> cByte

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.

Function FT_BITSET()

 FT_BITSET( <cByte>, <nBitPos> ) --> cByte

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.

Function FT_BYTEAND()

 FT_BYTEAND( <cByte1>, <cByte2> ) --> cByte

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.

Function FT_BYTENEG()

 FT_BYTENEG( <cByte> ) --> cNewByte

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.

Function FT_BYTENOT()

 FT_BYTENOT( <cByte> ) --> cNewByte

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.

Function FT_BYTEOR()

 FT_BYTEOR( <cByte1>, <cByte2> ) --> cNewByte

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.

Function FT_BYTEXOR()

 FT_BYTEXOR( <cByte1>, <cByte2> ) --> cNewByte

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.

Function FT_FINDITH()

 FT_FINDITH( <cCheckFor>, <cCheckIn>, <nWhichOccurrence> ;
 [, <lIgnoreCase> ] ) --> <nStringPosition>

This function finds the position in a string of the "ith" time another string appears in it.

Function FT_ISBIT()

 FT_ISBIT( <cByte>, <nBitPos> ) --> lResult

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.

Function FT_ISBITON()

 FT_ISBITON( <nNumber>, <nBit> ) --> lResult

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.

Function FT_METAPH()

 FT_METAPH( <cName> [, <nSize> ] ) --> cMetaPhone

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.

Function FT_NOOCCUR()

 FT_NOOCCUR( <cCheckFor>, <cCheckIn> ;
 [, <lIgnoreCase> ] )     --> <nOccurrences>

This function finds the number of times a string occurs in a second string.

Function FT_PCHR()

 FT_PCHR( <cString> ) -->  <cPrinterFormat>

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

Function GLOB()

 GLOB(<sString>, <sReg>, [<lIgnoreCase>]) 	--> TRUE || FALSE

GLOB() возвращает TRUE, если строка соответствует регулярному выражению. Выражение <sReg> это простое регулярное выражение, принятое в DOS.

Function HARDCR()

 HARDCR(<строка>) --> преобразованная строка

HARDCR() - это функция обработки memo-полей, которая заменяет все мягкие возвраты каретки (CHR(141)) жесткими возвратами каретки (CHR(13)). Она используется для вывода длинных символьных строк и memo-полей, содержащих мягкие возвраты каретки с помощью консольных команд. В xClipper консольные команды ( включая REPORT и LABEL FORM) не выполняют автоматического преобразования мягких возвратов каретки в жесткие, вынуждая вас делать эти преобразования. Мягкие возвраты каретки добавляются в memo-поля функцией MEMOEDIT() при переносе строк.

Function HASHNAME()

  HASHNAME(<nHashCode>) 	--> <sStr>
 

HASHNAME() возвращает исходную строку, из которой был получен хэш-код <nHashCode>.

Function HASHSTR()

 HASHSTR(<sStr>) 	--> <nHashCode>

HASHSTR() вычисляет хэш-код для строки <sStr> и возвращает его в виде числа. Хэш-код имеет уникальное значение в пределах от 1000000 до MAX_LONG.

Function ISALPHA()

 ISALPHA(<строка символов>) --> признак буквы

ISALPHA() - это функция обработки символьных строк, определяющая, начинается ли заданная строка с буквенного символа. Буквенный символ - это любая буква от А до Z верхнего или нижнего регистра. ISALPHA() возвращает значение "ложь" (.F.), если строка начинается с цифры или какого-либо другого символа.

Function ISDIGIT()

 ISDIGIT(<символьная строка>) --> признак цифры

ISDIGIT() является функцией обработки символьных строк, которая определяет, является ли первый символ аргумента <символьная строка> цифрой от 0 до 9. Если первый символ является любым другим символом, то функция возвратит значение "ложь" (.F.).

ISDIGIT() используется тогда, когда необходимо определить, является ли текущая символьная строка числом перед тем, как превратить ее в числовую величину функцией VAL().

Function ISLOWER()

 ISLOWER(<символьная строка>) --> признак строчной буквы

ISLOWER() является функцией обработки символьных строк, которая определяет, является ли первый символ в строке строчной буквой. Эта функция противоположна функции ISUPPER(), которая определяет, является ли первый символ в строке прописной буквой.

Функции ISLOWER() и ISUPPER() связаны с функциями LOWER() и UPPER(), которые переводят символы из верхнего регистра в нижний и наоборот.

Function ISUPPER()

 ISUPPER(<символьная строка>) --> признак заглавной буквы

ISUPPER() является функцией обработки символьных строк, которая определяет, является ли первый символ в строке прописной буквой. Эта функция противоположна функции ISLOWER(), которая определяет, является ли первый символ в строке строчной буквой.

Функции ISUPPER() и ISLOWER() связаны с функциями UPPER() и LOWER(), которые переводят символы из нижнего регистра в верхний и наоборот.

Function LEFT()

 LEFT( <символьная строка>, <длина подстроки>) --> символьная подстрока

LEFT() является функцией обработки символьных строк, которая возвращает подстроку, выделенную из заданной символьной строки. Она аналогична функции SUBSTR(<символьная строка>, 1, <длина подстроки>). LEFT() сходна с RIGHT(), которая возвращает подстроку, начиная с последнего символа в строке.

LEFT(), RIGHT() и SUBSTR() часто используются совместно с функциями AT() и RAT() для определения первой и/или последней позиции подстроки в строке перед ее выделением.

Function LIKE()

 LIKE(<sMask>, <sString>) 	--> TRUE || FALSE

LIKE() возвращает TRUE, если строка соответствует маске. Строка <sMask> может содержать специальные символы: <?>, <*>, <.>

Function LOWER()

 LOWER(<символьная строка>) --> символьная строка

LOWER() - функция обработки символьных строк, используемая для преобразования буквенных символов из верхнего регистра в нижний. Она связана с UPPER(), которая преобразует строки из нижнего регистра в верхний. LOWER() также связана с ISLOWER() и ISUPPER(), которые определяют, с какой буквы начинается строка - со строчной или прописной.

LOWER() обычно используют для форматирования символьных строк при выводе на экран. Она также может использоваться для приведения строк к одному виду (прописные или строчные) без учета регистра или в целях индексирования.

Function LTRIM()

 LTRIM(<символьная строка>) --> символьная строка

LTRIM() является функцией обработки символьных строк, используемой для форматирования символьных строк с начальными пробелами. Ими могут быть, например, числа, преобразуемые в символьные строки функцией STR().

LTRIM() сходна с функцией RTRIM(), которая удаляет конечные пробелы. Обратными к функциям ALLTRIM(), LTRIM() и RTRIM() являются функции PADC(), PADR() и PADL(), которые центрируют, сдвигают вправо или влево символьные строки путем добавления к ним символов-заполнителей.

Function MEMOEDIT()

 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(). Значения строки и колонки начинаются с ноля. Если аргументы не заданы, начальная позиция курсора в окне - нулевая строка и текущая колонка.

Returns :

MEMOEDIT() возвращает текстовый буфер, если пользователь прерывает редактирование нажатием <Ctrl>-<W>, или копию введенной исходной строки при нажатии клавиши <Esc>.

See also : LASTKEY() MEMOLINE() MEMOREAD() MEMOTRAN() MEMOWRIT()

Function MEMOLINE()

 MEMOLINE(<символьная строка>,[<длина строки>],
 [<номер строки>], [<шаг табуляции>],
 [<переключатель переноса>]) --> символьная строка

MEMOLINE() - функция работы с memo-полями, которая обычно используется в сочетании с MLCOUNT() для выделения строк текста из memo-полей и символьных строк, основываясь на заданном количестве символов в строке.

Способ действия заключается в том, что сначала с помощью MLCOUNT() в memo-поле или символьной строке с учетом наличия режима переноса и табуляции определяется количество строк. Применяя это значение как верхнюю границу для оператора цикла FOR...NEXT, каждую подстроку memo-поля или символьной строки можно извлечь с помощью функции MEMOLINE() и использовать в любой комбинации команд и функций.

<символьная строка>

- memo-поле или строка символов, из которой выделяется строка текста.

<длина строки>

- определяет количество символов в выделяемой строке и может принимать значения от 4 до 254. По умолчанию - 79.

<номер строки>

- определяет номер строки для выделения. По умолчанию принимается 1.

<шаг табуляции>

- определяет размер табуляции. Если он не определен, то по умолчанию принимается 4. Если <шаг табуляции> больше, чем значение параметра <длина строки>, то шаг табуляции автоматически принимается равным значению параметра <длина строки> - 1.

<переключатель переноса>

- включает или выключает режим переноса слов. Если его значение "истина" (.T.) - режим включен; значение "ложь"(.F.) - означает, что режим отключен. По умолчанию принимается значение "истина" (.T.)

Returns :

MEMOLINE() возвращает подстроку текста с номером <номер строки>, длиной <длина строки> из заданной аргументом <символьная строка> строки. Если в заданной строке меньше символов, чем указано в аргументе <длина строки>, то результирующая строка дополняется пробелами. Если значение аргумента <номер строки> больше, чем количество строк в аргументе <символьная строка>, то MEMOLINE() возвращает пустую строку (""). Если значение аргумента <переключатель переноса> равно "истина" (.T.) и конец строки попадает внутрь слова, то это слово переносится на следующую строку (ее начало). Если значение аргумента <переключатель переноса> имеет значение "ложь" (.F.), MEMOLINE() возвращает то количество символов, которое определено в аргументе <длина строки>. Следующая строка начинается с символа, следующего за символом "жесткий возврат каретки". Это означает, что промежуточные символы отбрасываются.

See also : MEMOEDIT() MLCOUNT() MLPOS()

Function MEMOREAD()

 MEMOREAD(<имя файла>) --> строка символов

MEMOREAD() - функция обработки memo-полей, считывающая содержимое дискового файла в память, где оно может быть обработано как символьная строка или memo-поле. MEMOREAD() используется в сочетании с функциями MEMOEDIT() и MEMOWRIT() для чтения дисковых файлов, их редактирования и записи на диск. MEMOREAD() ищет файл с именем, заданным в аргументе <имя файла>, начиная с текущей директории; если искомый файл не обнаружен, то поиск продолжается в директориях, определенных командой PATH операционной системы DOS. В процессе поиска файла, заданного аргументом <имя файла>, функция MEMOREAD() не использует установок команд xClipper SET DEFAULT и SET PATH.

В сетях MEMOREAD() пытается открыть файл для совместного использования и только для чтения. Если файл уже захвачен другим процессом для индивидуального пользования, MEMOREAD() возвращает нулевую строку ("").

Function MEMOTRAN()

 MEMOTRAN( <символьная строка>,[<замещающий символ 1>],
 <замещающий символ 2>]) --> новая символьная строка.

MEMOTRAN() - функция обработки memo-полей, которая изменяет длинные символьные строки или memo-поля, содержащие жесткий или мягкий возврат каретки/перевод строки, в форму, удобную для выдачи на дисплей. Эти две символьные комбинации используются функцией MEMOEDIT() как форматирующие признаки конца строки. Мягкий возврат каретки (CHR(141)) ставится в том случае, когда длина строки больше, чем размер окна MEMOEDIT(). Жесткий возврат каретки (CHR(13)) ставится при нажатии клавиши <Enter>.

Функция MEMOTRAN() бывает особенно полезна при выдаче memo-поля командой REPORT FORM, которая не делает переносов, когда встречается мягкий возврат каретки. MEMOTRAN() устраняет этот недостаток, замещая мягкий возврат каретки пробелом. Заметим, что если вы запускаете REPORT FORM, который использует MEMOTRAN(), и при этом MEMOTRAN() нигде больше в программе не встречается, то необходимо при помощи команды EXTERNAL объявить MEMOTRAN() как внешнюю функцию.

Function MEMOWRIT()

 MEMOWRIT()(<имя файла>,<символьная строка>) --> признак завершения

MEMOWRIT() - функция обработки memo-полей, которая записывает символьную строку или memo-поле в дисковый файл. Если в аргументе <имя файла> не задан маршрут доступа, MEMOWRIT() записывает файл в текущую директорию DOS. Установки команды SET DEFAULT TO не влияют на работу функции. Если файл с именем, указанным в аргументе <имя файла>, уже существует, то он переписывается.

MEMOWRIT() обычно используется в сочетании с функцией MEMOREAD() для загрузки текстовых файлов в память, и затем они могут быть отредактированы, выведены на консоль и потом записаны обратно на диск.

MEMOWRIT() можно также использовать как быстрый путь экспорта memo-поля в текстовый файл.

Function MLCOUNT()

 MLCOUNT(<символьная строка>, [<длина строки>],[<шаг табуляции>],
 [<переключатель переноса>]) --> кол-во строк

MLCOUNT() - функция обработки memo-полей, используемая в сочетании с функцией MEMOLINE() для печати символьных строк и memo-полей на основании заданного количества символов в строке. Способ действия заключается в том, что сначала с помощью MLCOUNT() подсчитывают количество строк в memo-поле или символьной строке. Затем, используя MEMOLINE(), выделяют каждую строку, зациклив этот процесс до тех пор, пока не будут выбраны все строки.

Если значение аргумента <переключатель переноса> - "истина" (.T.) и конец строки попадает внутрь слова, то оно переносится на следующую строку.

Если значение аргумента <переключатель переноса> - "ложь" (.F.), то MLCOUNT() подсчитывает количество строк точно в соответствии со значением, определенным в аргументе <длина строки> для каждой строки. Следующая строка начинается с символа, следующего за ближайшим символом твердого или мягкого возврата каретки.

Символы, попавшие в промежуток, игнорируются.

<символьная строка>

- memo-поле или строка символов, из которой выделяется строка текста.

<длина строки>

- определяет количество символов на строку и может принимать значения от 4 до 254. По умолчанию - 79.

<шаг табуляции>

- определяет размер шага табуляции. Если аргумент не определен, то по умолчанию шаг принимается равным 4. Если значение аргумента <шаг табуляции> больше, чем значение аргумента <длина строки>, то величина шага табуляции автоматически принимается равной значению выражения (<длина строки> - 1).

<переключатель переноса>

- включает и выключает режим переноса слов. Если его значение - "истина" (.T.) - режим включен; если его значение - "ложь" (.F.) - режим отключен. Если аргумент не определен, его значение по умолчанию принимается - "истина" (.T.).

Returns :

MLCOUNT() возвращает число строк аргумента <символьная строка> в зависимости от значений аргументов <длина строки> и <шаг табуляции> и наличия или отсутствия режима переноса слов.

See also : MEMOLINE() MEMOTRAN() MLPOS()

Function MLCTOPOS()

 MLPOS(<символьная строка>,<длина строки>, <номер строки>, <номер колонки>,
 [<шаг табуляции>], [<перенос разрешен>]) --> номер позиции

MLCTOPOS() - функция для работы с MEMO-полями, определяющая номер позиции в байтах, соответствующий конкретным строке и колонке внутри отформатированного текста. Номер строки считается от единицы, а номер колонки - от нуля, что совместимо с функцией MEMOEDIT(). Возвращаемое значение считается от единицы, это делает удобным использование функции MLCTOPOS() внутри SUBSTR() или других строковых функций.

Function MLPOS()

 MLPOS(<символьная строка>,<длина строки>,<номер строки>, [<шаг табуляции>],
 [<переключатель переноса>]) --> номер символа

<символьная строка>

- строка символов или memo-поле.

<длина строки>

- определяет количество символов в строке.

<шаг табуляции>

- определяет размер шага табуляции. Если аргумент не задан, по умолчанию величина шага принимается равной 4. Если значение аргумента <шаг табуляции> больше или равно значению аргумента <длина строки>, то тогда размер шага табуляции принимается равным значению выражения (<длина строки> - 1).

<переключатель переноса>

- переключает (включает и выключает) режим переноса слов. Если его значение "истина" (.T.) - режим включен, если "ложь" (.F.) - режим отключен. Если аргумент не задан, по умолчанию его значение - "истина" (.T.).

Returns :

MLPOS() возвращает номер символа аргумента <символьная строка> начала подстроки с порядковым номером, равным значению аргумента <номер строки>, в виде целого числа. Если значение аргумента <номер строки> больше, чем количество строк в заданной символьной строке, MLPOS() возвращает длину всей символьной строки.

See also : MEMOLINE() MEMOTRAN() MLCOUNT()

Function MPOSTOLC()

 MPOSTOLC(<символьная строка>,<длина строки>,<номер позиции>, [<шаг табуляции>],
 [<перенос разрешен>]) --> массив

MPOSTOLC() - функция работы с MEMO-полями, определяющая номер строки и колонки в отформатированном тексте, соответствующие позиции в байтах в строке. Возвращаемый номер строки отсчитывается от единицы, а номер колонки - от нуля, что соответствует правилам для функцией MEMOEDIT(). Возвращаемый <номер позиции> - отсчитывается от единицы, это делает удобным использование функции MPOSTOLC() с AT(), RAT() или другими строковыми функциями.

Function PAD()

 PADL( <выражение>,<длина>,[<символ-заполнитель>]) --> дополненная строка.
 PADC(<выражение>,<длина>,[<символ-заполнитель>]) --> дополненная строка
 PADR(<выражение>,<длина>,[<символ-заполнитель>]) --> дополненная строка

PADL(), PADC(), PADR() - функции обработки символов, которые дополняют выражения типа CHARACTER, DATE и NUMERIC символом-заполнителем, создавая новую символьную строку заданной длины. Функция PADC() центрирует значение, заданное в аргументе <выражение>, дополняя его до заданной длины символом-заполнителем и с левой, и с правой стороны.

PADL() дополняет строку символом-заполнителем с левой стороны; PADR() дополняет строку символом-заполнителем с правой стороны.

Если длина результирующей строки, определенной аргументом <выражение>, превосходит значение аргумента <длина>, то все функции PAD() укорачивают возвращаемую символьную строку до значения аргумента <длина>.

Функции PADL(), PADC(), PADR() используются для выдачи на дисплей строк переменной длины внутри фиксированной области. Они могут быть использованы, например, для форматирования вывода информации командами последовательного вывода (??). Если есть уверенность, что предыдущий текст полностью переписан, эти функции можно использовать на дисплее внутри фиксированной области.

Функции PADL(), PADC(), PADR() являются обратными по отношению к функциям ALLTRIM(), LTRIM() и RTRIM(), которые удаляют пробелы в начале и конце символьной строки.

Function RAT()

 RAT(<подстрока поиска>, <строка>) --> номер позиции

RAT() - это символьная функция, которая возвращает позицию последнего вхождения символьной подстроки в другую символьную строку. Поиск вхождения осуществляется просмотром справа. RAT() похожа на функцию AT(), которая возвращает позицию первого вхождения подстроки в другую строку. RAT() похожа также на оператор $, который определяет, содержится ли подстрока в строке.

Обе функции - и RAT(), и AT(), используют в сочетании с функциями SUBSTR(), LEFT() и RIGHT() для выделения подстрок.

Function REPLICATE()

 REPLICATE(<строка символов>, <к-во повторений>) --> новая строка символов

REPLICATE() - это функция обработки символьных строк, которая используется для многократной выдачи на экран, вывода на печать или заполнения буфера клавиатуры одним или более символами. REPLICATE() подобна SPACE(), возвращающей заданное количество пробелов.

Function RIGHT()

 RIGHT(<строка символов>, <к-во символов>) -> подстрока

RIGHT() - функция обработки символьных строк, которая выделяет подстроку, начиная с самого правого символа аргумента <строка символов>. Ее действие аналогично действию выражения

SUBSTR(<строка символов>,-<к-во символов>).

Например, RIGHT("ABC", 1) - это то же самое, что и SUBSTR("ABC", -1). Функция RIGHT() похожа на функцию LEFT(), которая извлекает подстроку, начиная с самого левого символа аргумента <строка символов>.

Функции RIGHT(), LEFT() и SUBSTR() часто используют в сочетании с функциями AT() и RAT(), определяющими первую и/или последнюю позицию подстроки до ее извлечения.

Function RTRIM()

 [R]TRIM(<символьная строка>) --> усеченная символьная строка

RTRIM() - функция обработки символьных строк, которая используется для форматирования символьных строк, имеющих на конце пробелы. Она полезна, когда нужно удалить конечные пробелы при конкатенации строк. Такая ситуация типична для файлов баз данных, хранящихся в форматах с фиксированной длиной.

Например, можно использовать RTRIM() для конкатенации имен первого и последнего полей, чтобы создать имя в виде строки.

RTRIM() схожа с LTRIM(), которая удаляет начальные пробелы из символьной строки, и ALLTRIM(), которая удаляет пробелы и в начале, и в конце строки. Обратными для этих функций являются функции PADC(), PADR() и PADL(), которые центрируют и выравнивают по краю символьные строки, заполняя их символами-заполнителями.

Function SEARCH()

 SEARCH(<sPattern>, <sString>, [@aReg], [<nFrom>], [<nRange>]) --> TRUE || FALSE

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-й - длина найденной подстроки.

Function SOUNDEX()

 SOUNDEX(<строка символов>) --> строка в форме А999

SOUNDEX() является символьной функцией, используемой для индексирования и поиска звуковых или фонетических соответствий. Она применяется тогда, когда неизвестна точная орфография написания символьных строк или же существует реальная опасность неправильного написания имен. Неправильное орфографическое написание является распространенным в интерактивных системах реального времени, где оператор, вводящий данные, получает информацию по телефону. SOUNDEX() работает путем сведения похожих по произношению символов с символами с одинаковым значением. Следует однако отметить, что звуковой метод не является совершенным. Символы, являющиеся совершенно различными, могут иметь одинаковое звуковое значение.

Function SPACE()

 SPACE(<число пробелов>) --> строка пробелов

SPACE() является функцией обработки символьных строк, используемой для возврата строки, состоящей из заданного числа пробелов. Ее действие подобно действию функции REPLICATE(" ",<количество байтов>).

SPACE() используется для инициализации символьной переменной перед ее использованием в команде GET. Кроме того, SPACE() используется для заполнения строк либо начальными, либо конечными пробелами. Однако следует отметить, что применение функций PADC(), PADL() и PADR() для этой цели более эффективно.

Function STR()

 STR(<число>, [<длина строки>], [<дробная часть>]) --> число в виде строки

STR() является арифметической функцией, которая преобразует числовые значения в символьные строки. Она обычно используется при конкатенации числовых значений с символьными строками. STR() применяется при выведении на дисплей чисел, создании кодов, являющихся частью числового значения и создания новых индексных ключей, которые объединяют числовые и символьные данные.

STR() подобна функции TRANSFORM(), которая форматирует числовые значения в виде символьных строк, используя маску вместо спецификаций длины и дробной части. Поскольку TRANSFORM() использует маску, она может вставлять такие форматирующие символы, как запятые, знаки доллара и круглые скобки.

Обратной для STR() является функция VAL(), которая преобразует строки символов в целые числа.

Function STR2VAR()

 STR2VAR(<sUucodeStr>) 	--> <vData>

STR2VAR() производит обратное преобразование uucode строки <sUucodeStr> в исходные данные и возвращает их. Функция обратна функции VAR2STR()

Function STRTRAN()

 STRTRAN(<строка символов>, <замещаемая подстрока>,[<замещающая подстрока>], [<начало замены>],
 [<число замен>]) --> новая строка символов

STRTRAN() является функцией обработки символьных строк, которая выполняет стандартный поиск подстроки внутри символьной строки. Когда она находит соответствие, она заменяет строку поиска заданной строкой замены. Если не заданы аргументы <начало замены> и <число замен>, все экземпляры подстрок, совпадающие со значением аргумента <замещаемая подстрока> заменяются на значение аргумента <замещающая подстрока>. Следует отметить, что STRTRAN() заменяет подстроки и, следовательно, не отвечает за целые слова.

<строка символов>

является символьной строкой или memo-полем, в котором производится поиск.

<замещаемая подстрока>

- последовательность символов, которую нужно установить.

<замещающая подстрока>

- последовательность символов, которыми нужно заменить значение аргумента <замещаемая подстрока>. Если этот аргумент не задан, найденные экземпляры аргумента поиска заменяются строкой нулевой длины ("").

<начало замены>

- является номером первого экземпляра аргумента

<замещаемая строка>

, подлежащего замене. Если этот аргумент опущен, то по умолчанию принимается (1).

<число замен>

- число экземпляров аргумента <замещаемая подстрока>, которые должны заменяться. Если он опущен, то по умолчанию заменяются все.

Returns :

STRTRAN() возвращает новую символьную строку с заданными экземплярами <замещаемая подстрока>, замененными на значение аргумента <замещающая подстрока>.

See also : RAT() STUFF() SUBSTR() AT()

Function 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".

Function SUBSTR()

 SUBSTR(<строка символов>, <начальная позиция>, [<к-во символов>]) --> подстрока

SUBSTR() является функцией обработки символьных строк, которая выделяет подстроку из другой символьной строки или memo-поля. SUBSTR() сходна с функциями LEFT() и RIGHT(), которые выделяют подстроки, начиная с крайнего слева или крайнего справа символов аргумента <строка символов>.

Функции SUBSTR(), RIGHT() и LEFT() часто используются в сочетании с функциями AT() и RAT() для определения первой и (или) последней позиции подстроки до ее выделения. Они также используются для вывода на дисплей или принтер только части символьной строки.

<строка символов>

- символьная строка, из которой должна быть выделена подстрока. Ее длина не должна превышать 65 535 (64К) байтов, что равняется максимальному размеру символьной строки в xClipper.

<начальная позиция>

- начальная позиция в строке, заданной аргументом

<строка символов>

. Если значение аргумента <начальная позиция> положительное, то отсчет ведется от крайнего слева символа в аргументе <строке символов>. Если же значение аргумента <начальная позиция> - отрицательное, то от крайнего справа символа.

<к-во символов>

- является числом выделяемых символов. Если аргумент опущен, подстрока начинается со значения аргумента <начальная позиция> и продолжается до конца строки. Если значение аргумента

<к-во символов>

больше числа символов, отсчитываемых от значения аргумента <начальная позиция> до конца строки, определенной аргументом <строка символов>, то излишек игнорируется.

Returns :

SUBSTR() возвращает выделенную символьную подстроку.

See also : RAT() RIGHT() STR() AT() LEFT()

Function TRIM()

 TRIM(<cString>) --> cTrimString

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.

Function UPPER()

 UPPER(<символьная строка>) --> символьная строка в верхнем регистре

UPPER() - функция обработки символьных строк. Используется для преобразования строк с символами в нижнем и верхнем регистрах в строки символов верхнего регистра. Она связана с функцией LOWER(), которая преобразует строки символов верхнего регистра и смешанные строки в строки символов нижнего регистра. Функция UPPER() также связана с функциями ISUPPER() и ISLOWER(), которые определяют, начинается ли строка с буквы верхнего или нижнего регистров.

UPPER() обычно используется для форматирования символьных строк. Однако UPPER() может быть полезна для создания индексных ключей, независимых от значений регистра.

Function VAL()

 VAL (<число в символьной форме>) --> число

VAL() - функция преобразования символов, которая преобразует строку символов, содержащую цифры, в числовое значение. Функция VAL() просматривает значение аргумента <число в символьной форме> до тех пор, пока не встретится вторая десятичная точка, нечисловой символ или конец выражения. Лидирующие пробелы игнорируются. Если SET FIXED установлено в режим ON, число возвращаемых функцией десятичных знаков определяется установкой команды SET DECIMALS, округляя полученное значение аргумента <число в символьной форме>, если в нем значащих цифр больше, чем определено командой SET DECIMALS. При значениях округляемой дробной части от 0 до 4 не происходит переноса 1 в старший разряд, а при значениях от 5 до 9 такой перенос происходит.

Если SET FIXED установлено в режим OFF, то VAL() возвращает число десятичных знаков такое же, как и в аргументе <число в символьной форме>.

VAL() - функция, обратная STR() и TRANSFORM(), которые преобразуют числовые значения в символьные строки.

Function VAR2STR()

 VAR2STR(<vData>) 	--> <sUucodeStr>

VAR2STR() возвращает исходную строку <vData> в uucode строку <sUucodeStr> и возвращает ее.