<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()
ADDSLASHES(<sString>) --> <sResString>
ADDSLASHES() возвращает строку <sResString> с обратными слэш перед символами, нуждающимися в экранировании, например в запросах к БД. Это такие символы, как одиночная кавычка ('), двойная кавычка ("), обратный слэш (\) и NUL (нулевой символ).
ALLTRIM(<символьное выражение>) --> строка символов
ALLTRIM() - функция работы с символьными строками, которая удаляет ведущие и завершающие пробелы из строки. Она выполняет действие сразу двух функций - LTRIM() и RTRIM(), которые удаляют из строки ведущие и заключающие пробелы соответственно. Функции ALLTRIM(), LTRIM() и RTRIM() являются противоположными по действию функциям PADC(), PADR() и PADL(), которые центрируют строки, выравнивают их справа или слева, добавляя в них пробелы.
ASC(<символьное выражение>) --> значение кода ASCII
ASC() - это функция преобразования символов, которая возвращает значение кода ASCII самого первого символа в строке. ASC() в основном используется с выражениями, в которых ведутся арифметические расчеты над числовыми значениями кодов ASCII символов. CHR() и ASC() - это функции, противоположные по действию друг другу.
AT(<подстрока поиска>,<строка>) --> номер позиции
AT() - функция работы с символьными строками, которая определяет позицию первого появления символьной подстроки <подстрока поиска> в строке <строка>. Для определения последнего появления подстроки в строку, используется функция RAT().
<подстрока поиска> | - символьная подстрока для поиска. |
<строка> | - символьная строка, в которой ведется поиск. |
Returns : | AT() возвращает номер позиции первого появления подстроки <подстрока поиска> в строке <строка> в виде арифметического значения. Если подстрока <подстрока поиска> не найдена, AT() возвращает нуль. |
See also : | RAT() STRTRAN() SUBSTR() |
BETWEEN(<TargetData>, <FirstData>, <SecondData>) --> TRUE || FALSE
BETWEEN() сравнивает исходное значение <TargetData> с <FirstData> и <SecondData>. Если <TargetData> находится в границах между <FirstData> и <SecondData>, BETWEEN() возвращает TRUE.
Все сравниваемые значения должны принадлежать какому-либо одному типу (строка, число, дата, ...).
CHR(<код ASCII>) --> символ
CHR() - функция преобразования чисел, которая преобразует код ASCII в символ. Она противоположна по действию функции ASC(). Эта многоплановая функция полезна в часто используемых задачах, таких как:
Посылка управляющих кодов или графических символов на экран или принтер.
Включение звонка.
Преобразование кодов, возвращаемых функцией INKEY(), в символы.
Заполнение буфера клавиатуры.
CSCOUNT(<сChar>, <sString>) --> <nCount>
CSCOUNT() возвращает количество символов <cChar> в строке <sString>.
DSTRTON(<sString>) --> <nValue>
DSTRTON() преобразует строку <sString> в число и возвращает его.
FSTRTON(<sString>) --> <nValue>
FSTRTON() преобразует строку <sString> в число и возвращает его.
FT_AT2( <cSearch>, <cTarget> [, <nOccurs> [, <lCaseSens> ] ] ) --> nPos
This function will find the nth occurrence of a substring within a string.
<cSearch> | is the character substring to search for. |
<cTarget> | is the character string to search. |
<nOccurs> | is the occurrence of cSearch to look for, defaults to 1. |
<lCaseSens> | is a logical value denoting case sensitivity. If .F., then search is NOT sensitive to case, defaults to .T. |
Returns : | The position of the nth occurrence of a substring |
See also : | FT_FINDITH() |
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.
<cByte> | is a character from CHR(0) to CHR(255). |
<nBitPos> | is a number from 0 to 7 conforming to standard right-to-left bit numbering convention and representing the position of the bit within the byte. |
Returns : | Returns new byte, with designated bit cleared (reset). If parameters are faulty, returns NIL. |
See also : | FT_BITSET() FT_ISBIT() |
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.
<cByte> | is a character from CHR(0) to CHR(255). |
<nBitPos> | is a number from 0 to 7 conforming to standard right-to-left bit numbering convention and representing the position of the bit within the byte. |
Returns : | Returns new byte, with designated bit set. If parameters are faulty, returns NIL. |
See also : | FT_BITCLR() FT_ISBIT() |
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.
<cByte1> | and <cByte2> are characters from CHR(0) TO CHR(255). May be passed in CHR() form, as character literals, or as expressions evaluating to CHR() values. |
Returns : | Returns resulting byte, in CHR() form. If parameters are faulty, returns NIL. |
See also : | FT_BYTEOR() FT_BYTEXOR() FT_BYTENOT() 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.
<cByte> | is a character from CHR(0) to CHR(255). May be passed in CHR() form, as character literal, or as expression evaluating to CHR() value. |
Returns : | Returns resulting byte, in CHR() form. If parameters are faulty, returns NIL. |
See also : | FT_BYTEOR() FT_BYTEXOR() FT_BYTENOT() FT_BYTEAND() |
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.
<cByte> | is a character from CHR(0) to CHR(255). May be passed in CHR() form, as character literal, or as expression evaluating to CHR() value. |
Returns : | Returns resulting byte, in CHR() form. If parameters are faulty, returns NIL. |
See also : | FT_BYTEOR() FT_BYTEXOR() FT_BYTENEG() FT_BYTEAND() |
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.
<cByte1> | and <cByte2> are characters from CHR(0) TO CHR(255). May be passed in CHR() form, as character literals, or as expressions evaluating to CHR() values. |
Returns : | Returns resulting byte, in CHR() form. If parameters are faulty, returns NIL. |
See also : | FT_BYTEXOR() FT_BYTENOT() FT_BYTENEG() FT_BYTEAND() |
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.
<cByte1> | and <cByte2> are characters from CHR(0) to CHR(255). May be passed in CHR() form, as character literals, or as expressions evaluating to CHR() values. |
Returns : | Returns resulting byte, in CHR() form. If parameters are faulty, returns NIL. |
See also : | FT_BYTEOR() FT_BYTENOT() FT_BYTENEG() FT_BYTEAND() |
FT_FINDITH( <cCheckFor>, <cCheckIn>, <nWhichOccurrence> ; [, <lIgnoreCase> ] ) --> <nStringPosition>
This function finds the position in a string of the "ith" time another string appears in it.
<cCheckFor> | is the string to search for. |
<cCheckIn> | is the string to search. |
<nWhichOccurrence> | is the number of the occurrence to find. |
<lIgnoreCase> | is a logical indicating if the search is to be case sensitive. The default is no case sensitivity (.F.). |
Returns : | The position in the string cCheckIn of the ith occurrence of cCheckFor. |
See also : | FT_AT2() |
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.
<cByte> | is a character from CHR(0) to CHR(255) |
<nBitPos> | is a number from 0 to 7 conforming to standard right-to-left bit-numbering convention and representing the position of the bit within the byte. |
Returns : | .T. if designated bit is set (1), .F. if not set (0), NIL if invalid parameters. |
See also : | FT_BITSET() FT_BITCLR() |
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.
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.
FT_NOOCCUR( <cCheckFor>, <cCheckIn> ; [, <lIgnoreCase> ] ) --> <nOccurrences>
This function finds the number of times a string occurs in a second string.
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
GLOB(<sString>, <sReg>, [<lIgnoreCase>]) --> TRUE || FALSE
GLOB() возвращает TRUE, если строка соответствует регулярному выражению. Выражение <sReg> это простое регулярное выражение, принятое в DOS.
HARDCR(<строка>) --> преобразованная строка
HARDCR() - это функция обработки memo-полей, которая заменяет все мягкие возвраты каретки (CHR(141)) жесткими возвратами каретки (CHR(13)). Она используется для вывода длинных символьных строк и memo-полей, содержащих мягкие возвраты каретки с помощью консольных команд. В xClipper консольные команды ( включая REPORT и LABEL FORM) не выполняют автоматического преобразования мягких возвратов каретки в жесткие, вынуждая вас делать эти преобразования. Мягкие возвраты каретки добавляются в memo-поля функцией MEMOEDIT() при переносе строк.
<строка> | - это символьная строка или memo-поле, которое должно быть преобразовано. |
Returns : | HARDCR() возвращает символьную строку длиной до 65 535 (64К) символов. |
See also : | MEMOTRAN() STRTRAN() |
HASHNAME(<nHashCode>) --> <sStr>
HASHNAME() возвращает исходную строку, из которой был получен хэш-код <nHashCode>.
<nHashCode> | Numeric, исходный хэш-код. |
Returns : | Возвращает строку, из которой был сгенерирован хэш-код. |
See also : | HASHSTR() |
HASHSTR(<sStr>) --> <nHashCode>
HASHSTR() вычисляет хэш-код для строки <sStr> и возвращает его в виде числа. Хэш-код имеет уникальное значение в пределах от 1000000 до MAX_LONG.
<sStr> | String, исходная строка |
Returns : | Возвращает числовое значение - хэш-код, сконвертированное из строки. |
See also : | HASHNAME() |
ISALPHA(<строка символов>) --> признак буквы
ISALPHA() - это функция обработки символьных строк, определяющая, начинается ли заданная строка с буквенного символа. Буквенный символ - это любая буква от А до Z верхнего или нижнего регистра. ISALPHA() возвращает значение "ложь" (.F.), если строка начинается с цифры или какого-либо другого символа.
ISDIGIT(<символьная строка>) --> признак цифры
ISDIGIT() является функцией обработки символьных строк, которая определяет, является ли первый символ аргумента <символьная строка> цифрой от 0 до 9. Если первый символ является любым другим символом, то функция возвратит значение "ложь" (.F.).
ISDIGIT() используется тогда, когда необходимо определить, является ли текущая символьная строка числом перед тем, как превратить ее в числовую величину функцией VAL().
ISLOWER(<символьная строка>) --> признак строчной буквы
ISLOWER() является функцией обработки символьных строк, которая определяет, является ли первый символ в строке строчной буквой. Эта функция противоположна функции ISUPPER(), которая определяет, является ли первый символ в строке прописной буквой.
Функции ISLOWER() и ISUPPER() связаны с функциями LOWER() и UPPER(), которые переводят символы из верхнего регистра в нижний и наоборот.
ISUPPER(<символьная строка>) --> признак заглавной буквы
ISUPPER() является функцией обработки символьных строк, которая определяет, является ли первый символ в строке прописной буквой. Эта функция противоположна функции ISLOWER(), которая определяет, является ли первый символ в строке строчной буквой.
Функции ISUPPER() и ISLOWER() связаны с функциями UPPER() и LOWER(), которые переводят символы из нижнего регистра в верхний и наоборот.
LEFT( <символьная строка>, <длина подстроки>) --> символьная подстрока
LEFT() является функцией обработки символьных строк, которая возвращает подстроку, выделенную из заданной символьной строки. Она аналогична функции SUBSTR(<символьная строка>, 1, <длина подстроки>). LEFT() сходна с RIGHT(), которая возвращает подстроку, начиная с последнего символа в строке.
LEFT(), RIGHT() и SUBSTR() часто используются совместно с функциями AT() и RAT() для определения первой и/или последней позиции подстроки в строке перед ее выделением.
<символьная строка> | - символьная строка, из которой выделяется подстрока. Наибольший размер символьной строки - 65535 ( 64К ) байт. |
<длина подстроки> | - длина выделяемой подстроки. |
Returns : | LEFT() возвращает заданное число символов, начиная с первого символа в строке, в виде символьной подстроки. Если значение аргумента <длина подстроки>- отрицательное или ноль, LEFT() возвращает пустую строку (""). Если значение аргумента <длина подстроки> больше длины исходной строки, LEFT() возвращает всю строку. |
See also : | AT() LTRIM() RAT() RIGHT() RTRIM() STUFF() SUBSTR() |
LIKE(<sMask>, <sString>) --> TRUE || FALSE
LIKE() возвращает TRUE, если строка соответствует маске. Строка <sMask> может содержать специальные символы: <?>, <*>, <.>
LOWER(<символьная строка>) --> символьная строка
LOWER() - функция обработки символьных строк, используемая для преобразования буквенных символов из верхнего регистра в нижний. Она связана с UPPER(), которая преобразует строки из нижнего регистра в верхний. LOWER() также связана с ISLOWER() и ISUPPER(), которые определяют, с какой буквы начинается строка - со строчной или прописной.
LOWER() обычно используют для форматирования символьных строк при выводе на экран. Она также может использоваться для приведения строк к одному виду (прописные или строчные) без учета регистра или в целях индексирования.
<символьная строка> | - символьная строка. |
Returns : | LOWER() возвращает копию аргумента <символьной строки>, в которой все буквенные символы верхнего регистра преобразованы в буквенные символы нижнего регистра (прописные буквы - в строчные). Все остальные символы остаются без изменений. |
See also : | ISLOWER() ISUPPER() UPPER() |
LTRIM(<символьная строка>) --> символьная строка
LTRIM() является функцией обработки символьных строк, используемой для форматирования символьных строк с начальными пробелами. Ими могут быть, например, числа, преобразуемые в символьные строки функцией STR().
LTRIM() сходна с функцией RTRIM(), которая удаляет конечные пробелы. Обратными к функциям ALLTRIM(), LTRIM() и RTRIM() являются функции PADC(), PADR() и PADL(), которые центрируют, сдвигают вправо или влево символьные строки путем добавления к ним символов-заполнителей.
<символьная строка> | - символьная строка. |
Returns : | LTRIM() возвращает копию аргумента <символьная строка> с удаленными начальными пробелами. Если <символьная строка> является нулевой строкой ("") или строкой, состоящей только из пробелов, LTRIM() возвращает нулевую строку (""). |
See also : | ALLTRIM() PAD() RTRIM() STR() SUBSTR() TRIM() |
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() |
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() |
MEMOREAD(<имя файла>) --> строка символов
MEMOREAD() - функция обработки memo-полей, считывающая содержимое дискового файла в память, где оно может быть обработано как символьная строка или memo-поле. MEMOREAD() используется в сочетании с функциями MEMOEDIT() и MEMOWRIT() для чтения дисковых файлов, их редактирования и записи на диск. MEMOREAD() ищет файл с именем, заданным в аргументе <имя файла>, начиная с текущей директории; если искомый файл не обнаружен, то поиск продолжается в директориях, определенных командой PATH операционной системы DOS. В процессе поиска файла, заданного аргументом <имя файла>, функция MEMOREAD() не использует установок команд xClipper SET DEFAULT и SET PATH.
В сетях MEMOREAD() пытается открыть файл для совместного использования и только для чтения. Если файл уже захвачен другим процессом для индивидуального пользования, MEMOREAD() возвращает нулевую строку ("").
<имя файла> | - имя считываемого с диска файла. Если имя файла содержит расширение, оно должно быть указано. Задание маршрута доступа не обязательно. |
Returns : | MEMOREAD() возвращает содержимое текстового файла как символьную строку. Максимальный размер файла, который может быть считан - 65 535 символов (64K) - это максимальный размер символьной переменной. Если файл с именем, указанным в аргументе <имя файла>, не может быть найден, MEMOREAD() возвращает строку нулевой длины (""). |
See also : | MEMOEDIT() MEMOWRIT() |
MEMOTRAN( <символьная строка>,[<замещающий символ 1>], <замещающий символ 2>]) --> новая символьная строка.
MEMOTRAN() - функция обработки memo-полей, которая изменяет длинные символьные строки или memo-поля, содержащие жесткий или мягкий возврат каретки/перевод строки, в форму, удобную для выдачи на дисплей. Эти две символьные комбинации используются функцией MEMOEDIT() как форматирующие признаки конца строки. Мягкий возврат каретки (CHR(141)) ставится в том случае, когда длина строки больше, чем размер окна MEMOEDIT(). Жесткий возврат каретки (CHR(13)) ставится при нажатии клавиши <Enter>.
Функция MEMOTRAN() бывает особенно полезна при выдаче memo-поля командой REPORT FORM, которая не делает переносов, когда встречается мягкий возврат каретки. MEMOTRAN() устраняет этот недостаток, замещая мягкий возврат каретки пробелом. Заметим, что если вы запускаете REPORT FORM, который использует MEMOTRAN(), и при этом MEMOTRAN() нигде больше в программе не встречается, то необходимо при помощи команды EXTERNAL объявить MEMOTRAN() как внешнюю функцию.
<символьная строка> | - строка символов или memo-поле. [<замещающий символ 1>] - символ, замещающий пару символов "жесткий возврат каретки/перевод строки". По умолчанию - точка с запятой (;). [<замещающий символ 2>] - символ, заменяющий пару : "мягкий возврат каретки/перевод строки". По умолчанию - пробел. |
Returns : | MEMOTRAN() возвращает копию <символьной строки> с замещенными парами символов "возврат каретки/перевод строки" |
See also : | STRTRAN() |
MEMOWRIT()(<имя файла>,<символьная строка>) --> признак завершения
MEMOWRIT() - функция обработки memo-полей, которая записывает символьную строку или memo-поле в дисковый файл. Если в аргументе <имя файла> не задан маршрут доступа, MEMOWRIT() записывает файл в текущую директорию DOS. Установки команды SET DEFAULT TO не влияют на работу функции. Если файл с именем, указанным в аргументе <имя файла>, уже существует, то он переписывается.
MEMOWRIT() обычно используется в сочетании с функцией MEMOREAD() для загрузки текстовых файлов в память, и затем они могут быть отредактированы, выведены на консоль и потом записаны обратно на диск.
MEMOWRIT() можно также использовать как быстрый путь экспорта memo-поля в текстовый файл.
<имя файла> | - имя дискового файла адресата, должно явно содержать расширение имени. Допускается задание маршрута доступа. |
<символьная строка> | - строка символов или memo-поле, записываемые в файл с именем указанным в аргументе <имя файла>. |
Returns : | MEMOWRIT() возвращает значение "истина" (.T.), если операция записи в файл прошла успешно, в противном случае возвращает значение "ложь" (.F.). |
See also : | MEMOEDIT() MEMOREAD() |
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() |
MLPOS(<символьная строка>,<длина строки>, <номер строки>, <номер колонки>, [<шаг табуляции>], [<перенос разрешен>]) --> номер позиции
MLCTOPOS() - функция для работы с MEMO-полями, определяющая номер позиции в байтах, соответствующий конкретным строке и колонке внутри отформатированного текста. Номер строки считается от единицы, а номер колонки - от нуля, что совместимо с функцией MEMOEDIT(). Возвращаемое значение считается от единицы, это делает удобным использование функции MLCTOPOS() внутри SUBSTR() или других строковых функций.
<символьная строка> | - символьная строка для просмотра. |
<длина строки> | - длина форматированной строки. |
<номер строки> | - номер строки; отсчитывается от 1. |
<номер колонки> | - номер колонки; отсчитывается от 0. |
<шаг табуляции> | - определяет размер шага табуляции. Если аргумент не задан, по умолчанию величина шага принимается равной 4. |
<перенос разрешен> | - логическое значение, определяющее разрешение переноса слов. Если аргумент не задан, по умолчанию его значение - "истина" (.T.). |
Returns : | MLCTOPOS() возвращает позицию в байтах внутри <символьная строка>, считая от 1. |
See also : | MEMOEDIT() MLPOS() MPOSTOLC() |
MLPOS(<символьная строка>,<длина строки>,<номер строки>, [<шаг табуляции>], [<переключатель переноса>]) --> номер символа
<символьная строка> | - строка символов или memo-поле. |
<длина строки> | - определяет количество символов в строке. |
<шаг табуляции> | - определяет размер шага табуляции. Если аргумент не задан, по умолчанию величина шага принимается равной 4. Если значение аргумента <шаг табуляции> больше или равно значению аргумента <длина строки>, то тогда размер шага табуляции принимается равным значению выражения (<длина строки> - 1). |
<переключатель переноса> | - переключает (включает и выключает) режим переноса слов. Если его значение "истина" (.T.) - режим включен, если "ложь" (.F.) - режим отключен. Если аргумент не задан, по умолчанию его значение - "истина" (.T.). |
Returns : | MLPOS() возвращает номер символа аргумента <символьная строка> начала подстроки с порядковым номером, равным значению аргумента <номер строки>, в виде целого числа. Если значение аргумента <номер строки> больше, чем количество строк в заданной символьной строке, MLPOS() возвращает длину всей символьной строки. |
See also : | MEMOLINE() MEMOTRAN() MLCOUNT() |
MPOSTOLC(<символьная строка>,<длина строки>,<номер позиции>, [<шаг табуляции>], [<перенос разрешен>]) --> массив
MPOSTOLC() - функция работы с MEMO-полями, определяющая номер строки и колонки в отформатированном тексте, соответствующие позиции в байтах в строке. Возвращаемый номер строки отсчитывается от единицы, а номер колонки - от нуля, что соответствует правилам для функцией MEMOEDIT(). Возвращаемый <номер позиции> - отсчитывается от единицы, это делает удобным использование функции MPOSTOLC() с AT(), RAT() или другими строковыми функциями.
<символьная строка> | - символьная строка для просмотра. |
<длина строки> | - длина форматированной строки. |
<номер позиции> | - номер позиции в байтах в тексте; отсчитывается от 1. |
<шаг табуляции> | - определяет размер шага табуляции. Если аргумент не задан, по умолчанию величина шага принимается равной 4. |
<перенос разрешен> | - логическое значение, определяющее разрешение переноса слов. Если аргумент не задан, по умолчанию его значение - "истина" (.T.). |
Returns : | MPOSTOLC() возвращает массив, содержащий значения строки и колонки для заданного <номер позиции>. |
See also : | MEMOEDIT() MLCTOPOS() MLPOS() |
PADL( <выражение>,<длина>,[<символ-заполнитель>]) --> дополненная строка. PADC(<выражение>,<длина>,[<символ-заполнитель>]) --> дополненная строка PADR(<выражение>,<длина>,[<символ-заполнитель>]) --> дополненная строка
PADL(), PADC(), PADR() - функции обработки символов, которые дополняют выражения типа CHARACTER, DATE и NUMERIC символом-заполнителем, создавая новую символьную строку заданной длины. Функция PADC() центрирует значение, заданное в аргументе <выражение>, дополняя его до заданной длины символом-заполнителем и с левой, и с правой стороны.
PADL() дополняет строку символом-заполнителем с левой стороны; PADR() дополняет строку символом-заполнителем с правой стороны.
Если длина результирующей строки, определенной аргументом <выражение>, превосходит значение аргумента <длина>, то все функции PAD() укорачивают возвращаемую символьную строку до значения аргумента <длина>.
Функции PADL(), PADC(), PADR() используются для выдачи на дисплей строк переменной длины внутри фиксированной области. Они могут быть использованы, например, для форматирования вывода информации командами последовательного вывода (??). Если есть уверенность, что предыдущий текст полностью переписан, эти функции можно использовать на дисплее внутри фиксированной области.
Функции PADL(), PADC(), PADR() являются обратными по отношению к функциям ALLTRIM(), LTRIM() и RTRIM(), которые удаляют пробелы в начале и конце символьной строки.
<выражение> | - выражение типа CHARACTER, NUMERIC или DATE, дополняемое символом-заполнителем. |
<длина> | - длина возвращаемой символьной строки. |
<символ-заполнитель> | - символ, которым дополняется <выражение>. Если он не задан, по умолчанию принимается пробел. |
Returns : | PADL(), PADC(), PADR() возвращают символьную строку, которая представляет собой <выражение>, дополненное <символом-заполнителем> до величины, заданной в аргументе <длина>. |
See also : | RTRIM() ALLTRIM() LTRIM() |
RAT(<подстрока поиска>, <строка>) --> номер позиции
RAT() - это символьная функция, которая возвращает позицию последнего вхождения символьной подстроки в другую символьную строку. Поиск вхождения осуществляется просмотром справа. RAT() похожа на функцию AT(), которая возвращает позицию первого вхождения подстроки в другую строку. RAT() похожа также на оператор $, который определяет, содержится ли подстрока в строке.
Обе функции - и RAT(), и AT(), используют в сочетании с функциями SUBSTR(), LEFT() и RIGHT() для выделения подстрок.
<подстрока поиска> | - это символьная строка, месторасположение которой нужно определить. |
<строка> | - это символьная строка, в которой осуществляется поиск. |
Returns : | RAT() возвращает позицию подстроки, заданной аргументом <подстрока поиска> внутри строки, заданной аргументом <строка> в виде целого числа. Если подстрока поиска не найдена, то RAT() возвращает ноль. |
See also : | RIGHT() STRTRAN() SUBSTR() AT() LEFT() |
REPLICATE(<строка символов>, <к-во повторений>) --> новая строка символов
REPLICATE() - это функция обработки символьных строк, которая используется для многократной выдачи на экран, вывода на печать или заполнения буфера клавиатуры одним или более символами. REPLICATE() подобна SPACE(), возвращающей заданное количество пробелов.
<строка символов> | - повторяемая символьная строка. |
<к-во повторений> | - количество повторений строки, заданной в аргументе <строка символов>. |
Returns : | REPLICATE() возвращает символьную строку длиной до 65 535 (64К) байтов. При количестве повторений, равном нулю,функция возвращает строку нулевой длины (""). |
See also : | SPACE() |
RIGHT(<строка символов>, <к-во символов>) -> подстрока
RIGHT() - функция обработки символьных строк, которая выделяет подстроку, начиная с самого правого символа аргумента <строка символов>. Ее действие аналогично действию выражения
SUBSTR(<строка символов>,-<к-во символов>).
Например, RIGHT("ABC", 1) - это то же самое, что и SUBSTR("ABC", -1). Функция RIGHT() похожа на функцию LEFT(), которая извлекает подстроку, начиная с самого левого символа аргумента <строка символов>.
Функции RIGHT(), LEFT() и SUBSTR() часто используют в сочетании с функциями AT() и RAT(), определяющими первую и/или последнюю позицию подстроки до ее извлечения.
<строка символов> | - символьная строка, из которой выделяется подстрока. |
<к-во символов> | - количество символов, которое необходимо выделить. |
Returns : | RIGHT() возвращает подстроку длиной, равной количеству символов, заданному в аргументе <к-во символов>. Подстрока выбирается от конца строки, заданной в аргументе <строка символов>. Если значение аргумента <к-во символов> отрицательно или ноль, то RIGHT() возвращает строку нулевой длины (""). Если значение аргумента <к-во символов> больше длины символьной строки, то RIGHT() полностью возвращает строку, заданную в аргументе <строка символов>. Максимальный размер строки - 65535 (64К) байт. |
See also : | RTRIM() STUFF() SUBSTR() LEFT() LTRIM() |
[R]TRIM(<символьная строка>) --> усеченная символьная строка
RTRIM() - функция обработки символьных строк, которая используется для форматирования символьных строк, имеющих на конце пробелы. Она полезна, когда нужно удалить конечные пробелы при конкатенации строк. Такая ситуация типична для файлов баз данных, хранящихся в форматах с фиксированной длиной.
Например, можно использовать RTRIM() для конкатенации имен первого и последнего полей, чтобы создать имя в виде строки.
RTRIM() схожа с LTRIM(), которая удаляет начальные пробелы из символьной строки, и ALLTRIM(), которая удаляет пробелы и в начале, и в конце строки. Обратными для этих функций являются функции PADC(), PADR() и PADL(), которые центрируют и выравнивают по краю символьные строки, заполняя их символами-заполнителями.
<символьная строка> | - символьная строка, из которой удаляются пробелы. |
Returns : | RTRIM() возвращает строку, являющуюся копией аргумента <символьная строка> с удаленными справа пробелами. Если значение аргумента <символьная строка> - строка нулевой длины ("") или состоит из одних пробелов, то RTRIM() возвращает строку нулевой длины (""). |
See also : | PAD() SUBSTR() TRIM() ALLTRIM() LTRIM() |
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-й - длина найденной подстроки.
SOUNDEX(<строка символов>) --> строка в форме А999
SOUNDEX() является символьной функцией, используемой для индексирования и поиска звуковых или фонетических соответствий. Она применяется тогда, когда неизвестна точная орфография написания символьных строк или же существует реальная опасность неправильного написания имен. Неправильное орфографическое написание является распространенным в интерактивных системах реального времени, где оператор, вводящий данные, получает информацию по телефону. SOUNDEX() работает путем сведения похожих по произношению символов с символами с одинаковым значением. Следует однако отметить, что звуковой метод не является совершенным. Символы, являющиеся совершенно различными, могут иметь одинаковое звуковое значение.
SPACE(<число пробелов>) --> строка пробелов
SPACE() является функцией обработки символьных строк, используемой для возврата строки, состоящей из заданного числа пробелов. Ее действие подобно действию функции REPLICATE(" ",<количество байтов>).
SPACE() используется для инициализации символьной переменной перед ее использованием в команде GET. Кроме того, SPACE() используется для заполнения строк либо начальными, либо конечными пробелами. Однако следует отметить, что применение функций PADC(), PADL() и PADR() для этой цели более эффективно.
<число пробелов> | - число пробелов для построения строки. Максимум - 65535 (64К). |
Returns : | SPACE() возвращает символьную строку. Если значение аргумента <число пробелов> равно нулю, SPACE() возвращает строку нулевой длины (""). |
See also : | PAD() REPLICATE() |
STR(<число>, [<длина строки>], [<дробная часть>]) --> число в виде строки
STR() является арифметической функцией, которая преобразует числовые значения в символьные строки. Она обычно используется при конкатенации числовых значений с символьными строками. STR() применяется при выведении на дисплей чисел, создании кодов, являющихся частью числового значения и создания новых индексных ключей, которые объединяют числовые и символьные данные.
STR() подобна функции TRANSFORM(), которая форматирует числовые значения в виде символьных строк, используя маску вместо спецификаций длины и дробной части. Поскольку TRANSFORM() использует маску, она может вставлять такие форматирующие символы, как запятые, знаки доллара и круглые скобки.
Обратной для STR() является функция VAL(), которая преобразует строки символов в целые числа.
<число> | - числовое выражение, подлежащее преобразованию в строку символов. |
<длина строки> | - длина возвращаемой символьной строки, включая дробную часть, десятичную точку и знак. |
<дробная часть> | - число возвращаемых разрядов дробной части. |
Returns : | STR() возвращает значение аргумента <число>, преобразованное в строку символов. Если необязательные аргументы длины и величины дробной части не заданы, STR() возвращает символьную строку в соответствии с правилами. |
See also : | TRANSFORM() VAL() |
STR2VAR(<sUucodeStr>) --> <vData>
STR2VAR() производит обратное преобразование uucode строки <sUucodeStr> в исходные данные и возвращает их. Функция обратна функции VAR2STR()
<sUucodeStr> | String, исходная uucode строка. |
Returns : | Возвращает исходные данные, соответствующие uucode строке <sUucodeStr>. |
See also : | STR2VAR() |
STRTRAN(<строка символов>, <замещаемая подстрока>,[<замещающая подстрока>], [<начало замены>], [<число замен>]) --> новая строка символов
STRTRAN() является функцией обработки символьных строк, которая выполняет стандартный поиск подстроки внутри символьной строки. Когда она находит соответствие, она заменяет строку поиска заданной строкой замены. Если не заданы аргументы <начало замены> и <число замен>, все экземпляры подстрок, совпадающие со значением аргумента <замещаемая подстрока> заменяются на значение аргумента <замещающая подстрока>. Следует отметить, что STRTRAN() заменяет подстроки и, следовательно, не отвечает за целые слова.
<строка символов> | является символьной строкой или memo-полем, в котором производится поиск. |
<замещаемая подстрока> | - последовательность символов, которую нужно установить. |
<замещающая подстрока> | - последовательность символов, которыми нужно заменить значение аргумента <замещаемая подстрока>. Если этот аргумент не задан, найденные экземпляры аргумента поиска заменяются строкой нулевой длины (""). |
<начало замены> | - является номером первого экземпляра аргумента |
<замещаемая строка> | , подлежащего замене. Если этот аргумент опущен, то по умолчанию принимается (1). |
<число замен> | - число экземпляров аргумента <замещаемая подстрока>, которые должны заменяться. Если он опущен, то по умолчанию заменяются все. |
Returns : | STRTRAN() возвращает новую символьную строку с заданными экземплярами <замещаемая подстрока>, замененными на значение аргумента <замещающая подстрока>. |
See also : | RAT() STUFF() SUBSTR() AT() |
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".
<строка символов> | - символьная строка, в которую вставляются или из которой удаляются символы. |
<начало замены> | - начальная позиция в строке, с которой происходит вставка (удаление). |
<к-во удаляемых символов> | - число символов, подлежащих удалению. |
<вставляемая подстрока> | - вставляемая строка. |
Returns : | STUFF() возвращает копию аргумента <строка символов> с удаленными символами и вставленной строкой, значение которой задано аргументом <вставляемая подстрока>. |
See also : | RAT() RIGHT() STRTRAN() SUBSTR() AT() LEFT() |
SUBSTR(<строка символов>, <начальная позиция>, [<к-во символов>]) --> подстрока
SUBSTR() является функцией обработки символьных строк, которая выделяет подстроку из другой символьной строки или memo-поля. SUBSTR() сходна с функциями LEFT() и RIGHT(), которые выделяют подстроки, начиная с крайнего слева или крайнего справа символов аргумента <строка символов>.
Функции SUBSTR(), RIGHT() и LEFT() часто используются в сочетании с функциями AT() и RAT() для определения первой и (или) последней позиции подстроки до ее выделения. Они также используются для вывода на дисплей или принтер только части символьной строки.
<строка символов> | - символьная строка, из которой должна быть выделена подстрока. Ее длина не должна превышать 65 535 (64К) байтов, что равняется максимальному размеру символьной строки в xClipper. |
<начальная позиция> | - начальная позиция в строке, заданной аргументом |
<строка символов> | . Если значение аргумента <начальная позиция> положительное, то отсчет ведется от крайнего слева символа в аргументе <строке символов>. Если же значение аргумента <начальная позиция> - отрицательное, то от крайнего справа символа. |
<к-во символов> | - является числом выделяемых символов. Если аргумент опущен, подстрока начинается со значения аргумента <начальная позиция> и продолжается до конца строки. Если значение аргумента |
<к-во символов> | больше числа символов, отсчитываемых от значения аргумента <начальная позиция> до конца строки, определенной аргументом <строка символов>, то излишек игнорируется. |
Returns : | SUBSTR() возвращает выделенную символьную подстроку. |
See also : | RAT() RIGHT() STR() AT() LEFT() |
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.
UPPER(<символьная строка>) --> символьная строка в верхнем регистре
UPPER() - функция обработки символьных строк. Используется для преобразования строк с символами в нижнем и верхнем регистрах в строки символов верхнего регистра. Она связана с функцией LOWER(), которая преобразует строки символов верхнего регистра и смешанные строки в строки символов нижнего регистра. Функция UPPER() также связана с функциями ISUPPER() и ISLOWER(), которые определяют, начинается ли строка с буквы верхнего или нижнего регистров.
UPPER() обычно используется для форматирования символьных строк. Однако UPPER() может быть полезна для создания индексных ключей, независимых от значений регистра.
VAL (<число в символьной форме>) --> число
VAL() - функция преобразования символов, которая преобразует строку символов, содержащую цифры, в числовое значение. Функция VAL() просматривает значение аргумента <число в символьной форме> до тех пор, пока не встретится вторая десятичная точка, нечисловой символ или конец выражения. Лидирующие пробелы игнорируются. Если SET FIXED установлено в режим ON, число возвращаемых функцией десятичных знаков определяется установкой команды SET DECIMALS, округляя полученное значение аргумента <число в символьной форме>, если в нем значащих цифр больше, чем определено командой SET DECIMALS. При значениях округляемой дробной части от 0 до 4 не происходит переноса 1 в старший разряд, а при значениях от 5 до 9 такой перенос происходит.
Если SET FIXED установлено в режим OFF, то VAL() возвращает число десятичных знаков такое же, как и в аргументе <число в символьной форме>.
VAL() - функция, обратная STR() и TRANSFORM(), которые преобразуют числовые значения в символьные строки.
<число в символьной форме> | - преобразуемое символьное выражение. |
Returns : | VAL() возвращает значение аргумента <число в символьной форме> преобразованное в числовое значение, включая дробную часть. |
See also : | ROUND() STR() TRANSFORM() |
VAR2STR(<vData>) --> <sUucodeStr>
VAR2STR() возвращает исходную строку <vData> в uucode строку <sUucodeStr> и возвращает ее.
<vData> | Данные для преобразования. |
Returns : | Возвращает uucode строку <sUucodeStr>. |
See also : | STR2VAR() |
Пред. | Начало | След. |
INFO | Уровень выше | NUMERIC |