A2EDIT() | Просмотр двухмерного массива в виде таблицы |
AADD() | Добавляет новый элемент в конец массива. |
ACLONE() | Дублирует вложенный или многомерный массив. |
ACOPY() | Копирует элементы одного массива в другой. |
ADEL() | Удаляет элемент массива. |
AEVAL() | Выполняет блок кода для каждого элемента массива. |
AFILL() | Заполняет массив заданным значением. |
AINS() | Заносит элемент со значением NIL в массив. |
ARRAY() | Создает неинициализированный массив заданной длины. |
ASCAN() | Просмотр массива |
ASIZE() | Увеличивает или уменьшает размер массива. |
ASORT() | Сортирует массив. |
ATAIL() | Возвращает элемент массива с наибольшим номером. |
DIRECTORY() | Создает массив с информацией о каталогах и файлах. |
EMPTY() | Определяет, является ли результат выполнения выражения пустым. |
__FLEDIT() | Отбирает из массива структуры DBStruct() элементы, указанные в списке. |
FT_AADDITION() | Add elements unique of source array to target array |
FT_AAVG() | Average numeric values in an array |
FT_ADESSORT() | Sort an array in descending order |
FT_AEMAXLEN() | Find longest element within an array |
FT_AEMINLEN() | Find shortest element within an array |
FT_AMEDIAN() | Find middle value in array, or average of two middle values |
FT_ANOMATCHES() | Find the number of array elements meeting a condition |
FT_AREDIT() | 2 dimensional array editing function using TBrowse |
FT_ASUM() | Sum the elements of an array |
FT_RESTARR() | Restore a Clipper array from a disc file |
FT_SAVEARR() | Save Clipper array to a disc file. |
LEN() | Определяет длину символьной строки или количество элементов в массиве. |
MAP() | Создает новый пустой объект (ассоциативный массив) |
MAPMODIFY | Включает/отключает режим контроля измений атрибутов. |
TYPE() | Определяет тип выражения. |
VALTYPE() | Определяет тип данных выражения. |
A2EDIT(<nTop>, <nLeft>, <nBottom>, <nRight>, <aData>, <cUserFunc>, <aSay>, <aHeaders>, <aHeadSep>, <aColSep>, <aFootSep>, <aFooters>) --> NIL
<nTop> | Numeric, верхняя координата A2EDIT() окна. |
<nLeft> | Numeric, левая координата. |
<nBottom> | Numeric, нижняя координата. |
<nRight> | Numeric, правая координата. |
<aData> | Array, массив для просмотра. |
<cUserFunc> | String, имя функции пользователя. |
<aSay> | Array, шаблоны для представления содержимого колонок. |
<aHeaders> | Array, заголовки колонок. |
<aHeadSep> | Array or character, разделители колонок заголовков. |
<aColSep> | Array or character, разделители колонок. |
<aFootSep> | Array or character, разделители колонок подвала. |
<aFooters> | Array, строки подписей к колонкам. |
A2EDIT() возвращает NIL.
A2EDIT() - это функция работы с массивом, которая предназначена для просмотра 2-мерного массива.
A2EDIT() это таже DBEDIT(), но только работает с массивом, а не с БД.
arr := {{1,2,3,4,5}{11,22,33,44,55}{111,222,333,444,555}} A2EDIT(0, 0, maxrow(), maxcol(), arr, {"One", "Two", "Three", "Four", "Five"})
Не зависит от платформ
AADD(<имя массива>, <выражение>[, <keyValue>]) --> значение
AADD преобразует <выражение> и возвращает его значение. Если <выражение> не задано, AADD() возвращает NIL.
AADD() - это функция обработки массивов, которая увеличивает текущую длину указанного массива на единицу. Вновь созданному элементу присваивается значение, заданное аргументом <выражение>.
AADD() используется для динамического наращивания массивов. Это полезно для построения динамических списков и очередей. Примером может служить массив Getlist, используемый системой GET для хранения GET- объектов. После команд READ или CLEAR GETS, Getlist становится пустым массивом. Каждый раз, когда выполняется команда @...GET, система GET использует функцию AADD() для добавления нового элемента в конец массива Getlist и затем назначает новый GET-объект новому элементу.
AADD() похожа на ASIZE(), но добавляет только один элемент за вызов; ASIZE() может нарастить или сжать массив до заданного размера. AADD(), однако, имеет то преимущество, что может присваивать значение новому элементу, в то время как ASIZE() этого сделать не может. AADD() так же кажется похожей на функцию AINS(), однако они различны. AINS() перемещает элементы внутри массива, но она не может изменять длину массива.
Примечание. Если аргумент <выражение> - это тоже массив, то новый элемент в указанном массиве будет содержать ссылку на массив, заданный аргументом <выражение>.
Следующие примеры демонстрируют результаты многократных вызовов AADD() для массива. aArray := {} // Результат: aArray - пустой массив AADD(aArray, 5) // Результат: aArray - { 5 } AADD(aArray, 10) // Результат: aArray - {5,10} AADD(aArray, {12,10}) // Результат: aArray - {5,10,{12,10}}
AADD() может принимать в качестве параметра <имя массива> объект. В этом случае <keyValue> это хэш-код нового элемента.
Не зависит от платформ
ACLONE(<массив>) --> дублированный массив
ACLONE() возвращает дубликат массива <массив>.
ACLONE() - это функция обработки массивов, создающая полный дубликат массива <массив>. Если массив <массив> содержит подмассивы, ACLONE() создает соответствующие подмассивы и заполняет их копиями значений подмассивов массива <массив>. ACLONE() подобна ACOPY(), но ACOPY() не может дублировать вложенные массивы.
Этот пример создает массив, и затем дублирует его с помощью функции ACLONE(). Первый массив затем изменяется, но на копию это не влияет: LOCAL aOne, aTwo aOne := { 1, 2, 3 } // Результат: aOne - {1, 2, 3} aTwo := ACLONE(aOne) // Результат: aTwo - {1, 2, 3} aOne[1]:= 99 // Результат: aOne - {99, 2, 3} // а Two по-прежнему { 1, 2, 3}
ACOPY(<исходный массив>,<принимающий массив>, [<начальный элемент>],[<кол-во элементов>], [<нач. элемент принимающего массива>]) --> принимающий массив
<исходный массив> | - массив, из которого копируются элементы. |
<принимающий массив> | - массив, в который копируются элементы. |
<начальный элемент> | - позиция начального элемента в массиве <исходный |
массив>. Если она не определена, то по умолчанию принимается равной | |
единице. | |
<кол-во элементов> | - количество элементов, которое необходимо |
скопировать из массива <исходный массив>, начиная с позиции | |
<начальный элемент> | . Если значение <кол-во элементов> не задано, |
копируются все элементы, начиная со значения <начальный элемент>. | |
<нач. элемент принимающего массива> | - начальная позиция в массиве |
<принимающий массив> | , начиная с которой принимаются копируемые |
элементы. Если не определено, то по умолчанию - с первого элемента. | |
ACOPY() возвращает ссылку на принимающий массив <принимающий массив>.
ACOPY() - это функция работы с массивами, которая копирует элементы массива <исходный массив> в массив <принимающий массив>. Массив <принимающий массив> должен быть создан до начала работы функции и иметь достаточно большой размер, чтобы принять копируемые элементы. Если массив <исходный массив> содержит избыточное количество элементов, лишние элементы не будут копироваться.
ACOPY() копирует все типы данных, включая NIL и блок кода. Если какой-либо элемент массива <исходный массив> является подмассивом, соответствующий элемент массива <принимающий массив> будет содержать ссылку на подмассив. Таким образом, ACOPY() не создает полную копию многомерного массива. Для того, чтобы сделать это, используйте функцию ACLONE().
В этом примере создаются два массива, элементы которых заполнены значениями. Затем два элемента из первого массива копируются во второй массив: LOCAL nCount := 2, nStart := 1, aOne, aTwo aOne := ( 1, 1, 1 ) aTwo := ( 2, 2, 2 ) ACOPY(aOne, aTwo, nStart, aCount) // Результат: aTwo - {1, 1, 2}
ADEL(<принимающий массив>, <номер элемента>) --> принимающий массив
ADEL() возвращает ссылку на указанный <принимающий массив>.
ADEL() - функция обработки массивов удаляет один элемент массива. Значение указанного элемента пропадает и все следующие за ним элементы сдвигаются на одну позицию вверх. Последний элемент массива принимает значение NIL.
--------------------------------------------------------------------- Предупреждение
В xClipper многомерные массивы создаются путем вложения одних массивов в другие. Если массив <принимающий массив> является многомерным, ADEL() удалит весь подмассив, определенный в <номер элемента>. ---------------------------------------------------------------------
Этот пример создает массив констант из трех элементов и затем удаляет второй элемент. Значение третьего элемента перемещается вверх на одну позицию, а новый третий элемент принимает значение NIL: LOCAL aArray := { 1, 2, 3 } // Результат: { 1, 2, 3 } ADEL(aArray, 2) // Результат: { 1, 3, NIL }
AEVAL(<имя массива>, <блок кода>, [<начальный элемент>], [<кол-во элементов>]) --> имя массива
<имя массива> | - имя массива для обработки. |
<блок кода> | - блок кодов, предназначенных для обработки каждого |
элемента массива. | |
<начальный элемент> | - номер первого обрабатываемого элемента массива. |
Если <начальный элемент> не определен, то по умолчанию принимается | |
первый элемент. | |
<кол-во элементов> | - количество элементов, которое необходимо |
обработать начиная с элемента с номером <начальный элемент>. | |
Если <кол-во элементов> не определено, то по умолчанию | |
обрабатываются все элементы. | |
AEVAL() возвращает ссылку на <имя массива>.
AEVAL() - функция работы с массивами, которая выполняет блок кода для каждого элемента массива, передавая этот элемент в блок кода как параметр. Возвращаемое значение блока игнорируется. Если не определены параметры <начальный элемент> и <кол-во элементов>, обрабатываются все элементы массива. AEVAL() работает аналогично функции DBEVAL(), которая обрабатывает блоком кода каждую запись файла базы данных. Подобно DBEVAL(), AEVAL() можно использовать как примитив для построения итерационных команд при обработке массивов с простой и сложной структурами. За более подробной информацией о теории и синтаксисе блоков кода обращайтесь к разделу "Блок кода" в главе "Основные концепции"
В этом примере AEVAL() используется для выдачи на экран массива имен файлов и их размеров, полученных при помощи функции DIRECTORY(): #include "Directry.ch" // LOCAL aFiles := DIRECTORY("*.dbf"), nTotal := 0 AEVAL( aFiles, ; { | aDbfFile |; QOUT(PADR(aDbfFile[F_NAME], 10), aDbfFile[F_SIZE]),; nTotal += aDbfFile[F_SIZE]; }; ) // ? ? "Total Bytes :", nTotal Следующий пример использует AEVAL() для построения списка выбранных значений из многомерного массива: #include "Directry.ch" // LOCAL aFiles := DIRECTORY("*.dbf"), aNames := {} AEVAL(aFiles,; { | file | AADD(aNames, file[F_NAME]) }; )
AFILL(<принимающий массив>, <выражение>,[<начальный элемент>], [<кол-во элементов>]) --> принимающий массив
<принимающий массив> | - массив, подлежащий заполнению. |
<выражение> | - значение, которое заносится в каждый элемент массива |
<принимающий массив> | . Может быть выражением любого допустимого типа. |
<начальный элемент> | - номер первого заполняемого элемента. Если не |
указан, по умолчанию заполняется с первого элемента. | |
<кол-во элементов> | - количество заполняемых элементов, начиная с |
элемента с номером <начальный элемент> и до конца массива. |
AFILL() возвращает ссылку на массив <принимающий массив>.
AFILL() - функция обработки массивов, которая заполняет указанный массив одним значением любого допустимого типа ( включая массивы блоков кода, NIL ) путем присвоения значения <выражение> каждому его элементу в заданных границах.
Предупреждение: AFILL() нельзя использовать для заполнения многомерных массивов. Многомерные массивы в xClipper формируются путем вложения одних массивов в другие. Чтобы использовать функцию AFILL() для многомерных массивов, перепишите подмассивы, используемые для других измерений массива.
В этом примере создается массив из трех элементов. Затем он заполняется значением "ложь" (.F.), после чего элементы на второй и третьей позициях заполняются значением "истина" (.T.): LOCAL aLogic[3] // Результат: { NIL, NIL, NIL } AFILL(aLogic,.F.) // Результат: { .F., .F., .F. } AFILL(aLogic,.T., 2, 2) // Результат: { .F., .T., .T. }
AINS(<принимающий массив>,<номер элемента>) --> принимающий массив
AINS() возвращает ссылку на массив <принимающий массив>.
AINS() - функция обработки массивов, которая заносит новый элемент в указанный массив. Вносимый элемент будет иметь значение NIL, пока ему не присвоят новое значение. После занесения последний элемент массива теряет свое значение, а все элементы после нового сдвигаются на одну позицию вниз.
Предупреждение: При обработке многомерных массивов функцию AINS() следует применять с осторожностью. Многомерные массивы в xClipper строятся путем вложения одного массива в другой. При использовании функции AINS() с многомерными массивами уничтожается последний элемент в заданном массиве, что приводит к потере одного или более измерений. Для включения нового измерения в массив сначала добавьте новый элемент в конец массива, используя функцию AADD() или ASIZE() перед выполнением AINS().
Этот пример демонстрирует эффект использования функции AINS() при обработке массива: LOCAL aArray := { 1, 2, 3 } // Результат: { 1, 2, 3 } AINS(aArray, 2) // Результат: { 1, NIL, 2 }
ARRAY(<кол-во эл. 1> [,<кол-во эл. 2>...]) --> массив
ARRAY() возвращает массив заданной размерности.
ARRAY() - функция работы с массивами, которая возвращает неинициализированный массив с заданным количеством измерений и элементов. Если задано более одного аргумента <кол-во эл.>, создается "вложенный", или многомерный массив с количеством измерений, равным количеству заданных аргументов <кол-во эл.>.
xClipper предусматривает несколько способов создания массивов. Можно создать массив при помощи таких описательных операторов, как LOCAL или STATIC; можно создать массив, используя операторы PUBLIC или PRIVATE; можно присвоить массив литералов созданной переменной или, наконец, использовать функцию ARRAY(). Использование ARRAY() предпочтительнее, поскольку можно создавать массивы, используя выражения или блоки кода.
Этот пример создает одномерный массив из пяти элементов, используя функцию ARRAY() и затем делает то же самое, присваивая переменной массив констант NIL : aArray := ARRAY(5) aArray := { NIL, NIL, NIL, NIL, NIL } Этот пример демонстрирует три различных оператора, которые создают один и тот же многомерный массив : aArray := ARRAY( 3, 2 ) aArray := {{ NIL, NIL },{ NIL, NIL },{ NIL, NIL }} aArray := { ARRAY(2), ARRAY(2), ARRAY(2) }
ASCAN(<aArr>, <Expression>, [<nStart>], [<nCount>], [lBack]) --> <nStoppedAt>
Возвращает числовое значение, соответствующее позиции в массиве последнего просмотренного элемента.
ASCAN() просматривает массив <aArr> до совпадения со значением <Expression> или пока кодовый блок <Expression > возвращает TRUE. ASCAN() использует для сравнения оператор (=).
arr := {"Ann", "Mary", "Jhon", "Suzi"} ASCAN(arr, "Mary") // --> 2
В CLIP добавлен новый параметр <lBack> для просмотра массива с конца.
Не зависит от платформ
ASIZE(<изменяемый массив>,<новый размер>) --> измененный массив
ASIZE() возвращает указатель на массив <изменяемый массив>.
ASIZE() - функция обработки массивов, которая изменяет фактическую длину массива. Массив наращивается или уменьшается до указанного размера. Если массив уменьшается, то конечные его элементы теряются. При увеличении длины массива новые элементы добавляются в его конец и им присваивается значение NIL.
ASIZE() подобна функции AADD(), которая добавляет новый элемент в конец массива и одновременно присваивает ему новое значение. Следует отметить, что ASIZE() отличается от функций AINS() и ADEL(), которые в действительности не изменяют размер массива.
Следующие примеры демонстрируют добавление в массив новых элементов и удаление существующих: aArray := { 1 } // Результат: массив равен { 1 } ASIZE( aArray, 3) // Результат: массив равен { 1, NIL, NIL } ASIZE( aArray, 1) // Результат: массив равнен { 1 }
ASORT(<имя массива>, [<начальный элемент>], [<кол-во элементов>], [<режим сортировки>]) --> имя массива
<имя массива> | - массив для сортировки. |
<начальный элемент> | - номер первого сортируемого элемента. Если |
<начальный элемент> | не задан, по умолчанию принимается первый |
элемент массива. | |
<кол-во элементов> | - количество элементов, которые необходимо |
отсортировать. Если <кол-во элементов> не задано, в сортировке | |
участвуют все элементы, начиная с номера <начальный элемент> и | |
до конца массива. | |
<режим сортировки> | - необязательный блок кода, используемый для |
задания режима сортировки. Если он не определен, то по умолчанию | |
сортировка производится в порядке возрастания значений элементов. |
ASORT() возвращает ссылку на массив <имя массива>.
ASORT() - функция обработки массивов, которая сортирует весь массив, содержащий элементы одного типа, или его часть. Сортировка возможна для массивов, состоящих из данных типа CHARACTER, DATE, LOGICAL и NUMERIC.
Если аргумент <режим сортировки> не определен, то по умолчанию сортировка производится по возрастанию значений. Элемент с наименьшим значением перемещается в начало массива (первый элемент), в то время как элемент с наибольшим значением перемещается в конец массива (последний элемент).
Если аргумент <режим сортировки> определен как блок кода, он явно определяет тип сортировки. В процессе сортировки блоку передается очередная пара сортируемых элементов из массива. Если элементы соответствуют типу сотировки, блок возвращает значение "истина" (.T.). Это средство может быть использовано при задании сортировки по убыванию при сортировке словарей (см. примеры ниже).
При сортировке символьные строки располагаются в соответствии с кодами ASCII, для логических данных считается, что значение "ложь"(.F.) имеет наименьшее значение, данные типа дата сортируются в хронологическом порядке, а числовые данные - в соответствии с их значениями.
Примечание: Так как многомерные массивы в xClipper строятся путем вложения подмассивов в другие массивы, функция ASORT() прямо их не сортирует. Для сортировки вложенного массива следует использовать блок кода, который надлежащим образом управляет подмассивом.
В этом примере создается массив из пяти неотсортированных элементов и производится его сортировка по возрастанию, а затем, с помощью блока кода, по убыванию: aArray := { 3, 5, 1, 2, 4 } ASORT(aArray) // Результат: { 1, 2, 3, 4, 5 } ASORT(aArray,,,{ |x, y| x > y }) // Результат: { 5, 4, 3, 2, 1 } В следующем примере сортируется массив символьных строк по возрастанию независимо оттого, в верхнем или нижнем регистре представлены символы. Это достигается использованием блока кода, который перед сравнением представляет символы в верхнем регистре: aArray := { "Фрэд", "Kэт", "АЛВИН", "друг" } ASORT(aArray,,, { |x, y| UPPER(x) < UPPER(y) } ) В следующем примере производится сортировка каждого второго элемента подмассива: aKids := { {"Мери", 14}, {"Джо", 23}, {"Арт", 16} } aSortKids := ASORT(aKids,,, { |x, y| x[2] < y[2] }) // // Результат : { {"Мери", 14}, {"Арт", 16}, {"Джо", 23} }
ATAIL(<массив>) --> элемент
ATAIL() возвращает значение, которое также может являться ссылкой на массив или объект. Сам массив не изменяется.
ATAIL() - функция обработки массивов, которая возвращает значение элемента массива с наибольшим номером. Она может быть использована как более короткая запись выражения <массив>[LEN(<массив>)], обеспечивающего доступ к последнему элементу массива.
Следующий пример демонстрирует создание литерального массива и получение последнего его элемента. aArray := {"a", "b", "c", "d"} ? ATAIL(aArray) // Результат: d
EMPTY(<выражение>) --> лог. значение признака
EMPTY() возвращает значение "истина" (.T.), если результат выражения имеет пустое значение, в противном случае она возвращает "ложь" (.F.). Критерии, по которым определяется пустое значение, зависят от типа данных выражения <выражение> в соответствии со следующими правилами:
Список пустых значений . --------------------------------------------------------------------- Тип данных Критерий --------------------------------------------------------------------- массив нулевая длина символ пробел, символ табуляции, CR/LF или пустая строка число 0 дата NULL( CTOD("") ) логические "ложь" (.F.) MEMO то же, что и символ NIL NIL ---------------------------------------------------------------------
Функция EMPTY() достаточно универсальна и поэтому имеет несколько применений. Она может быть использована для анализа, когда пользователь вводит значения в GET-объект перед совершением изменений в файле базы данных. Она также может быть использована для анализа, не содержит ли формальный параметр NIL или он не задан. И, наконец, она может быть использована для проверки массива на нулевую длину.
Следующие примеры показывают использование функции EMPTY() для различных целей: ? EMPTY(SPACE(5)), EMPTY("") // Результат: .T. .T. ? EMPTY(0), EMPTY(CTOD("")) // Результат: .T. .T. ? EMPTY(.F.), EMPTY(NIL) // Результат: .T. .T. Этот пример использует функцию EMPTY() для анализа, вводит ли пользователь значение в первый GET-объект перед записью нового значения в файл базы данных : LOCAL cCust := SPACE(15), nAmount := 0 USE Sales NEW @ 10, 10 GET cCust @ 11, 10 GET nAmount PICTURE "999.99" READ // IF !EMPTY(cCust) APPEND BLANK REPLACE Sales->Cust WITH cCust, Sales->nAmount WITH nAmount ENDIF Этот пример использует функцию EMPTY() как часть предложения VALID для усиления контроля пользователя при вводе в GET-объект нового значения: LOCAL cCode := SPACE(5) @ 2, 5 SAY "Введите код" GET cCode VALID !EMPTY(cCode) READ
__Fledit( <aSrc>, <aList>) -> <aSelected>
Массив, содержащий отобранные поля.
__FlEdit ищет соответствие для каждого элемента массива <aList> в массиве <aSrc> по имени (<aList>[1] - DBS_NAME). Если элемент обнаружен, то соответствующий элемент <aSrc> добавляется в возвращаемый массив <aSelected>. Соответствие остальных подэлементов (DBS_TYPE, DBS_LEN, DBS_DEC) не проверяется. Категория TCP представляет собой набор функция для работы с сокетами.
Благодарим Sergio Zayas за помощь в создании функций TCPListen() и TCPAccept().
aList:=GetUserList() //Get user's defined field's list aRealFlds:=__FlEdit(DbStruct(), aList) //and select only correct
Функция __Fledit не документирована (но активно используется) в xClipper.
Евгений Бондарь
Не зависит от платформы
FT_AADDITION( <aList1>, <aList2> [, <lTrimmer> [, <lCaseSens> ] ] ) ; -> aNewArray
<aList1> | is the primary array. |
<aList2> | is the secondary array. |
<lTrimmer> | is a logical value denoting whether leading or |
trailing spaces should be included in the | |
comparison. If .T., then ignores spaces in | |
comparison, defaults to .T., .F. includes spaces. | |
<lCaseSens> | is a logical value denoting case sensitivity. |
If .T., then comparison is sensitive to case, | |
defaults to .T., .F. ignores case. |
An array of the union of aList1 and aList2.
This function will add the elements unique of aList2 with aList1. It returns a new array including all the elements of aList1 plus the unique elements of aList2.
aList1 := {"apple", "orange", "pear"} aList2 := {"apple ", "banana", "PEAR"} FT_AADDITION( aList1, aList2 ) // ignores spaces, sensitive to case // returns {"apple","orange","pear","banana","PEAR"} FT_AADDITION( aList1, aList2, , .F. ) // ignores spaces, not sensitive to case // returns {"apple","orange","pear","banana"} FT_AADDITION( aList1, aList2, .F., .F. ) // sensitive to spaces, not sensitive to case // returns {"apple","orange","pear","apple ","banana"}
FT_AAVG( <aArray> [, <nStartIndex> [, <nEndIndex> ] ] ) -> nAverage
The average of the specified array elements.
This function is used to get a numeric average of selected or all elements of an array.
This routine requires FT_ASUM().
FT_AAVG(aSubTotals) // Get Average of Entire Array FT_AAVG(aSubTotals, 5) // Get Average of 5th Element On FT_AAVG(aSubTotals, , 10) // Get Average of 1st 10 Elements FT_AAVG(aSubTotals, 5, 10) // Get Average of Elements 5-10
FT_ADESSORT( <aArray> [, <nStartIndex> [, <nEndIndex> ] ] ) -> aSorted
The array, sorted in descending order.
This function is used to sort an array in descending order, i.e., Z-A
FT_ADESSORT(aNames) // Sort the Entire Array FT_ADESSORT(aNames, 5) // Sort from the 5th Element On FT_ADESSORT(aNames, , 10) // Sort the 1st 10 Elements FT_ADESSORT(aNames, 5, 10) // Sort Elements 5-10
FT_AEMAXLEN( <aArray> [, <nDimension> [, <nStart> [, <nCount> ] ] ] ) ; -> nMaxlen
<aArray> | is the array containing the elements to be measured. |
<nDimension> | is the array dimension to be measured, |
defaults to first dimension. | |
<nStart> | is the starting array element to include, |
defaults to first array element. | |
<nCount> | is the number of array elements to process from |
from <nStart>, defaults to remaining elements | |
in array. |
The length of the longest size element of an array.
This function will measure each element of an array dimension and return the longest element.
FT_AEMAXLEN(aArray) // Measure the 1st dimension of an Array FT_AEMAXLEN(aArray,2) // Measure the 2nd dimension of an Array FT_AEMAXLEN(aArray,2,,9) // Measure Elements 1-9 of the 2nd dimension or subarray FT_AEMAXLEN(aArray,3,5,9) // Measure Elements 5-9 of the 3rd dimension or subarray FT_AEMAXLEN(aArray,3,5) // Measure Elements 5 to last in the 3rd dimension or subarray
FT_AEMINLEN( <aArray> [, <nDimension> [, <nStart> [, <nCount> ] ] ] ) -> nMinlen
<aArray> | is the array containing the elements to be measured. |
<nDimension> | is the array dimension to be measured, |
defaults to first dimension. | |
<nStart> | is the starting array element to include, |
defaults to first array element. | |
<nCount> | is the number of array elements to process from |
from <nStart>, defaults to remaining elements | |
in array. |
The length of the shortest size element of an array.
This function will measure each element of an array dimension and return the shortest element.
FT_AEMINLEN(aArray) // Measure the 1st dimension of an Array FT_AEMINLEN(aArray,2) // Measure the 2nd dimension of an Array FT_AEMINLEN(aArray,2,,9) // Measure Elements 1-9 of 2nd dimension FT_AEMINLEN(aArray,3,5,9) // Measure Elements 5-9 of 3rd dimension FT_AEMINLEN(aArray,3,5) // Measure Elements 5 to end of 3rd dimension
FT_AMEDIAN( <aArray> [, <nStart> [, <nEnd> ] ] ) -> nMedian
The median average of the array elements
This function sorts the elements of a numeric array and then returns the value in the middle element of the sorted array. If there is no exact middle value, then it returns the average of the two middle values. Half of the elements are > median and half are < median. A median average may more reflect a more useful average when there are extreme values in the set.
FT_AMEDIAN( aArray ) // Return Median for entire array FT_AMEDIAN( aArray, 2) // Return Median for elements from 2 to end FT_AMEDIAN( aArray, ,9) // Return Median for 1st 9 elements FT_AMEDIAN( aArray,8,40 ) // Return Median for elements 8 to 40
FT_ANOMATCHES( <aArray>, <bCompareBlock> ; [, <nStartIndex> [, <nEndIndex> ] ] ) -> nNoOfMatches
<aArray> | is the array to be searched |
<bCompareBlock> | is a code block containing the expression for |
the array elements to be tested with. Each element is passed | |
as a parameter to the block. If the block returns .T., the | |
number of matches will be incremented by one. | |
<nStartIndex> | is the first array item to include in the search, |
defaults to first element. | |
<nEndIndex> | is the last array element to include in the search, |
defaults to all elements. |
The number of elements that cause the code block to return .T.
This function returns the number of array elements that, when passed to the supplied code block, cause that code block to return a .T. value.
// Search the Entire Array FT_ANOMATCHES(aTries, { | x | x <= 100 } ) // Search from the 5th Element On FT_ANOMATCHES(aCodes, { | x | UPPER(x) == cCurrentCode }, 5) // Search the 1st 10 Elements FT_ANOMATCHES(aDates, { | x | IS_BETWEEN(DATE()-7,x,DATE() + 7) }, 10) // Search Elements 5-10 FT_ANOMATCHES(aNames, { | x | x <= cLastGoodName }, 5, 10)
FT_AREDIT( <nTop>, <nLeft>, <nBottom>, <nRight>, <Array Name>, ; <nElem>, <aHeadings>, <aBlocks> [, <bGetFunc> ] ) -> xElement
<nTop> | , <nLeft>, <nBottom>, <nRight> are coordinates for TBrowse |
<Array Name> | is name of 2 dimensional to array edit |
<nElem> | is pointer for element in array |
<aHeadings> | is array of column headings |
<aBlocks> | is array of blocks describing each array element |
[ <bGetFunc> ] is get editing function for handling individual elements |
Value of element positioned on when exit FT_AREDIT() The type of this value depends on what is displayed.
This function allows you to position yourself in an array, add and delete rows with the <F7> and <F8> keys, and pass a UDF with information to edit the individual gets.
FT_AREDIT(3, 5, 18, 75, ar, @nElem, aHeadings, aBlocks) This example will allow you to browse a 2 dimensional array But you can't edit it since there is no GetBlock UDF It allows the user to hit ENTER to select an element or ESC to return 0 * This second example shows how to edit a 2 dimensional array * as might be done to edit an invoice LOCAL i, ar[3, 26], aBlocks[3], aHeadings[3] LOCAL nElem := 1, bGetFunc * Set up two dimensional array "ar" FOR i = 1 TO 26 ar[1, i] := i // 1 -> 26 Numeric ar[2, i] := CHR(i+64) // "A" -> "Z" Character ar[3, i] := CHR(91-i) // "Z" -> "A" Character NEXT i * SET UP aHeadings Array for column headings aHeadings := { "Numbers", "Letters", "Reverse" } * Need to set up individual array blocks for each TBrowse column aBlocks[1] := {|| STR(ar[1, nElem], 2) } // prevent default 10 spaces aBlocks[2] := {|| ar[2, nElem] } aBlocks[3] := {|| ar[3, nElem] } * set up TestGet() as the passed Get Function so FT_ArEdit knows how * to edit the individual gets. bGetFunc := { | b, ar, nDim, nElem | TestGet(b, ar, nDim, nElem) } SetColor( "N/W, W/N, , , W/N" ) CLEAR SCREEN FT_AREDIT(3, 5, 18, 75, ar, @nElem, aHeadings, aBlocks, bGetFunc)
FT_ASUM( <aArray> [, <nStartIndex> [, <nEndIndex> ] ] ) -> nSum
The sum of the elements of the array or the lengths of the elements.
This function is to sum the elements of a numeric array or to sum the lengths of a character array.
FT_ASUM(aSubTotals) // Sum the Entire Array FT_ASUM(aSubTotals, 5) // Sum from the 5th Element On FT_ASUM(aSubTotals, , 10) // Sum the 1st 10 Elements FT_ASUM(aSubTotals, 5, 10) // Sum Elements 5-10
FT_RESTARR( <cFileName>, <nErrorCode> ) -> aArray
Return an array variable.
FT_RESTARR() restores an array which was saved to a disc file using FT_SAVEARR().
[10/1/92 Librarian note:
This function does not appear to work with multi-dimensional arrays. If you'd care to modify it to support this feature, please do and send it to Glenn Scott 71620,1521.]
aArray := { {'Invoice 1',CTOD('04/15/91'),1234.32,.T.},; {'Invoice 2',DATE(),234.98,.F.},; {'Invoice 3',DATE() + 1,0,.T.} } nErrorCode := 0 FT_SAVEARR(aArray,'INVOICE.DAT',@nErrorCode) IF nErrorCode = 0 aSave := FT_RESTARR('INVOICE.DAT',@nErrorCode) IF nErrorCode # 0 ? 'Error restoring array' ENDIF ELSE ? 'Error writing array' ENDIF
FT_SAVEARR( <aArray>, <cFileName>, <nErrorCode> ) -> lRet
.F. if there was a DOS file error or the array contained code blocks, otherwise returns .T.
FT_SAVEARR() saves any Clipper array, except those containing compiled code blocks, to a disc file. The array can be restored from the disc file using FT_RESTARR().
[10/1/92 Librarian note:
This function does not appear to work with multi-dimensional arrays. If you'd care to modify it to support this feature, please do and send it to Glenn Scott 71620,1521.]
aArray := { {'Invoice 1',CTOD('04/15/91'),1234.32,.T.},; {'Invoice 2',DATE(),234.98,.F.},; {'Invoice 3',DATE() + 1,0,.T.} } nErrorCode := 0 FT_SAVEARR(aArray,'INVOICE.DAT',@nErrorCode) IF nErrorCode = 0 aSave := FT_RESTARR('INVOICE.DAT',@nErrorCode) IF nErrorCode # 0 ? 'Error restoring array' ENDIF ELSE ? 'Error writing array' ENDIF
LEN(<символьная строка> | <массив>) --> число
LEN() возвращает длину символьной строки или количество элементов в массиве в виде целого числа. Если символьная строка или массив пустые, то LEN() возвращает ноль.
LEN() является функцией обработки символьных строк и массивов, которая возвращает длину символьной строки или количество элементов в массиве. В символьной строке каждый байт, включая и нулевые символы (CHR(0)), считается как один символ. Длина пустой строки ("") равна 0.
Для любого массива LEN() возвращает число элементов в нем. Если массив является многомерным, то подмассивы считаются как один элемент. Это означает, что для вложенного или многомерного массива LEN() возвращает длину первого измерения. Чтобы определить число элементов в других измерениях, надо использовать LEN() для подмассивов, как показано в примере. Следует отметить, что вложенные массивы в xClipper не обязательно должны иметь одинаковые измерения.
Этот пример демонстрирует работу функции LEN() с различными параметрами: ? LEN("Строка символов") // Результат: 15 ? LEN("") // Результат: 0 ? LEN(CHR(0)) // Результат: 1 // LOCAL aTest[10] ? LEN(aTest) // Результат: 10 Этот пример создает числовой двумерный массив и возвращает число элементов в подмассиве, содержащемся в первом элементе исходного массива: LOCAL aArray:= {{1,2}, {1,2}, {1,2}} ? LEN(aArray) // Результат: 3 ? LEN(aArray[1]) // Результат: 2 Этот пример показывает, как можно перемещаться по элементам массива, используя LEN(): LOCAL aArray := { { 1, 2}, { 1, 2}, { 1, 2} } LOCAL nRow, nColumn, nRowCount, nColumnCount // nRowCount = LEN(aArray) FOR nRow = 1 TO nRowCount nColumnCount = LEN(aArray[nRow]) FOR nColumn = 1 TO nColumnCount ? nRow, nColumn, aArray[nRow][nColumn] NEXT NEXT В этом примере представлена функция, которая возвращает массив числовых величин, описывающих размеры вложенного или многомерного массива. Предполагается, что массив имеет одинаковые измерения: FUNCTION Dimensions( aArray ) LOCAL aDims := {} DO WHILE ( VALTYPE(aArray) == "A" ) AADD( aDims, LEN(aArray) ) aArray := aArray[1] ENDDO RETURN (aDims)
MAP() --> <oObject>
No arguments
Возвращает пустой объект.
Map() создает новый пустой объект (ассоциативный массив) и возвращает его.
aMap := MAP() aMap:Name := "User1" aMap:Phone := "111-11-11" aMap:PhoneCount := 12 PrintInfo(aMap) // Users name: User1 // Phone : 111-11-11 // Count : 13 //////////////// static function PrintInfo( Obj ) qout ("Users name: "+Obj:Name) qout ("Phone : "+Obj:Phone) Obj:PhoneCount ++ qout ("Count : "+str(Obj:PhoneCount, 3)) return .t.
MAPMODIFY(<oObj>, <lMode>) --> <lOldMode>
Возвращает логическое значение - старое значение режима контроля.
MAPMODIFY() включает/отключает режим контроля изменения атрибутов.
Если <lMode> TRUE и объект <oObj> содержит метод <Modify>, то перед изменением значения атрибута будет автоматически вызван метод oObj:Modify(<nHashAttr>, <vNewValue>). Где <nHashAttr> хэш-код изменяемого атрибута, <vNewValue> новое значение атрибута. Метод <Modify> должен вернуть реальное значение, которое будет присвоено модифицируемому атрибуту.
static function modify(selfobj, HashAttr, Val) local ret ret := Val if HashAttr == hashstr("GROUP") ret := Val if Val == NIL ret := "WORKGROUP" endif endif return ret Person := MAP() Person:NAME := "User1" Person:GROUP := "WORKGROUP" Person:PASSWD := "****" Person:MODIFY := @modify() ? Person:GROUP // --> WORKGROUP Person:GROUP := NIL ? Person:GROUP // --> NIL Person:GROUP := "ABC" ? Person:GROUP // --> ABC MAPMODIFY(Person, .T.) Person:GROUP := NIL ? Person:GROUP // --> WORKGROUP
TYPE(<символьное выражение>) --> тип
Функция TYPE() возвращает один из следующих символов:
Возвращаемое значение TYPE(). --------------------------------------------------------------------- Результат Значение --------------------------------------------------------------------- A Массив B Блок C Символ D Дата L Логическое значение M Меню поля N Число O Объект U NIL, LOCAL или STATIC переменная UE Синтаксическая ошибка UI Неопределенная ошибка ---------------------------------------------------------------------
TYPE() - системная функция, возвращающая тип заданного выражения. Она может быть использована для проверки корректности типов выражений в которые могут входить функции библиотеки xCLIPPER.LIB . Однако в выражения не должны включаться ссылки на LOCAL или STATIC переменные, функции пользователя или встроенные функции библиотеки EXTEND.LIB.
Функция TYPE() похожа на функцию VALTYPE(), но отличается использованием оператора макроподстановки (&) для определения типа предмета. Это мешает использовать TYPE() для определения типа LOCAL и STATIC переменных. VALTYPE() вычисляет выражение и определяет тип данных возвращаемых значений. Это позволяет вам определять тип функций пользователя так же, как LOCAL и STATIC переменных.
Следующий пример демонстрирует различные результаты при вызове TYPE(): ? TYPE('SUBSTR("Всем Привет", 4, 5)') // Результат: C ? TYPE("UDF()") // Результат: UI ? TYPE('IF(.T., "истина", 12)') // Результат: C Этот пример показывает два способа проверки существования и типа объявленных параметров: FUNCTION TestParams( cParam1, nParam2 ) IF cParam1 = NIL ? "Параметр не был передан" cParam1 := "Значение по умолчанию" ENDIF // IF VALTYPE(nParam2) !== "N" ? "Параметр не был передан или недопустимый тип" ENDIF . . <операторы> . RETURN NIL
VALTYPE (<выражение>) --> тип
VALTYPE() - возвращает один символ, представляющий собой тип данных результата вычисления выражения, заданного в аргументе <выражение>.
VALTYPE() возвращает один из следующих символов:
Возвращаемые значения VALTYPE() --------------------------------------------------------------------- Результат Значение --------------------------------------------------------------------- А Массив В Блок С Символ D Дата L Логическое значение М Memo-поле N Число О Объект U NIL ---------------------------------------------------------------------
VALTYPE() - системная функция, которая вычисляет значение аргумента и возвращает символ, определяющий тип данных возвращаемого значения.
Функция VALTYPE() похожа на функцию TYPE(), но отличается тем, что вычисляет значение заданного аргумента и определяет тип возвращаемого значения. Благодаря этому можно определить тип LOCAL или STATIC переменных, функций пользователя и функций из библиотеки EXTEND.LIB. Функция TYPE() использует оператор макроподстановки (&) для вычисления значения типа аргумента.
Следующие примеры показывают возвращаемые значения нескольких типов данных: VALTYPE (1) // Результат: N ? VALTYPE("GOOB") // Результат: С ? VALTYPE(NIL) // Результат: U ? VALTYPE(array) // Результат: А ? VALTYPE(block) // Результат: В
Пред. | Начало | След. |
C-API | Уровень выше | LOGICAL |