22 | 11 | 2017

-------------------------------------------------------------------
AADD() Добавить новый элемент в конец массива
-------------------------------------------------------------------

AADD(<массив>, <выраж.>) --> значение

Аргументы

<массив> массив,в который будет добавлен новый элемент.

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

Возвращает

AADD() вычисляет <выраж.> и возвращает его значение. Если <выраж.>
не указано, AADD() возвращает NIL.

Описание

AADD() увеличивает действительную размерность массива на единицу.
Новому элементу массива присваивается значение, определяемое
аргументом <выраж.>.

AADD() используется для динамического роста массива. Это
используется для построения динамических списков или очередей.
Хорошим примером этого служит массив GetList, используемый системой
Get для управления Get об'ектами.

AADD() в отличии от ASIZE() добавляет только один элемент; ASIZE()
может увеличивать(уменьшать) массив на указанный размер. При
использовании функции AADD() имеется возможность присвоить некоторое
значение новому элементу, что не позволяет функция ASIZE(). AADD()
отличается от функции AINS(), которая не изменяет размерности
массива.

--------------------------------------------------------------------
Внимание

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

Пример использования

aArray := {} // Результат: aArray пустой массив
AADD(aArray, 5) // Результат: aArray содержит { 5 }
AADD(aArray, 10) // Результат: aArray содержит { 5, 10 }
AADD(aArray, { 12, 10 }) // Результат: aArray содержит
// { 5, 10, { 12, 10 } }

Library: CLIPPER.LIB.


134


-------------------------------------------------------------------
ABS() Вычисление абсолютного значения выражения
-------------------------------------------------------------------

ABS (<вырN>) --> вырN

Аргументы:

<вырN> - вычисляемое числовое выражение.

Результаты:

Функция ABS() возвращает положительное число или ноль для любого
аргумента вида числового выражения, независимо от того отрицательно
оно или положительно.

Применение:

Функция ABS() используется когда нужно определить амплитуду
числового выражения. Это поэволяет оценивать разницу между двумя
числами, когда знак результата не важен.

Пример использования:
a = 100
b = 150
? a - b // Результат: -50
? ABS(a - b) // Результат: 50
? ABS(-12) // Результат: 12
? ABS(0) // Результат: 0

-------------------------------------------------------------------
ACHOICE() Выполнение открывающегося меню из символьной строки
-------------------------------------------------------------------


ACHOICE(<вырN1>, <вырN2>, <вырN3>, <вырN4>,
<массив1>,
[<массив2> | <массив2>],
[<вырС>],
[<вырN5>],
[<вырN6>]) --> вырN

^ bАргументы

<вырN1...вырN4> - координаты верхнего левого угла и правого нижнего
угла окна, соответственно.

<массив1> - массив символьных строк, который отображается в виде
альтернатив меню.

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


135


аргумент, как одно логическое значение и меню будет обрабатываться,
как будто был задан массив, заполненный этим значением. Это важно,
когда желательно чтобы все альтернативы были доступны или
недоступны.

<вырC> - определяемая пользователем функция (пользовательская
функция), которая выполняется в общем случае, когда нажата
исключительная клавиша. Убедитесь, что имя функции задано без
скобочных суффиксов и аргументов. Заметим, что поведение функции
ACHOICE() подвергается изменению при присутствии этого аргумента. В
деталях это обсуждается ниже.

<вырN5> - элемент с начальной альтернативрой. Если не задан, то
начальная альтернатива по умолчанию первый элемент <массива1>.

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

Результаты

ACHOICE возвращает позицию альтернативы меню в массиве альтернатив.
После выбора происходит выход из команды и при этом возвращается
текущая позиция элемента массива <массив1>. При аварийном завершении
команды возвращается нуль.

Применение

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

Клавиши задействованные в ACHOICE().
-----------------------------------------------------
Клавиша Действие
-----------------------------------------------------
Вверх Вверх на один элемент
Вниз Вниз на один элемент
Home Первый элемент
End Последний элемент
PgUp Вверх на количество элементов, определенных
в окне меню на туже относительную позицию
PgDn Вниз на количество элементов, определенных
в окне меню на туже относительную позицию
Сtrl-PgDn Первый элемент
Сtrl-PgUp Последний элемент
Return Выбор элемента, возвращение позиции
Esc Прекращение выбора, возвращение ноля
Влево Прекращение выбора, возвращение ноля
Вправо Прекращение выбора, возвращение ноля
Первый Следующий элемент с таким же первым


136


символ символом
-----------------------------------------------------

Если количество элементов в массиве <массив1> превышает число строк
в окне меню, то при попытке сдвига за нижний или верхний края окна
происходит сдвиг элементов выбора по экрану. Помните, что светящаяся
линия выбора не циклически не сдвигается, когда вы достигаете верха
или низа окна меню. Нажатие клавиши, соответствующей первому символу
элемента выбора, однако, перемещает линию выбора внутри списка
выбора, если, конечно, клавиша соответствует первому символу
элемента.

Пользовательские функции: Если вы укажете пользовательскую функцию,
то поведение функции ACHOICE() в некоторой степени изменяется.
Первоначально, несколько клавиш автоматически не выполняются в
функции ACHOICE и управление передается на функцию, где вы можете
обрабатывать нажатие клавиши и выбирать соответствующие действие. В
следующем списке приводятся клавиши, которые ACHOICE() выполняет при
указании пользовательской функции. Эти клавиши генерируют режим 0
(не задействованы) в то время, как все другие клавиши составляют
исключение (режим 3).

Задействованные в ACHOICE() клавиши пользовательской функции.
-----------------------------------------------------
Клавиша Действие
-----------------------------------------------------
Вверх Вверх на один элемент
Вниз Вниз на один элемент
Ctrl-Home Первый элемент
Ctrl-End Последний элемент
PgUp Вверх на количество элементов, определенных
в окне меню на туже относительную позицию
PgDn Вниз на количество элементов, определенных
в окне меню на туже относительную позицию
Сtrl-PgDn Первый элемент
Сtrl-PgUp Последний элемент
-----------------------------------------------------

Заметьте, что клавиши Home, End, Return и Esc теперь относятся к
клавишам "исключениям" (режим 3).

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

Режимы функции ACHOICE()
_________________________________________________________
Режим Achoice.ch Описание
_________________________________________________________
0 AC_IDLE Клавиша не задействована


137


1 AC_HITTOP Курсор вышел за верх списка
2 AC_HITBOTTOM Курсор вышел за конец списка
3 AC_EXEPT Нажата клавиша, составляющая
исключение
4 AC_NOITEM Выбор элемента не сделан
_________________________________________________________

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

Значения, возвращаемые в ACHOICE() пользовательской функцией.
________________________________________________________________

Значение Achoice.ch Действие
________________________________________________________________

0 AC_ABORT Прервать выбор, вернуть 0
1 AC_SELECT Сделать выбор, вернуть элемент курсора
2 AC_CONT Продолжить процесс выбора
3 AC_GOTO Перейти не следующий элемент, чей первый
символ соответствует последней нажатой
клавиши
__________________________________________________________________

Цвета: Элементы выбора выводятся в стандартном цвете, светящаяся
линия выбора в выделенном цвете, а не выбранные элементы выбора
выводятся в не выбранном цвете. Например, следующие предложение
цвета:

SET COLOR TO W+/N,BG+/B,,,W/N

выводят меню в белом на черном цвете, линия выбора светло-голубой на
синем, а не выбранные элементы меню серые на черном.

Вложенность: Вы можете вызывать несколько копий ACHOICE() внутри
ACHOICE(), что позволяет вам создавать вложенные или иерархические
меню.

Пример использования

Пример использования двух массивов для определения элементов меню и
критериев выбора. После того как пользователь сделает выбор
выводится имя выбранного элемента меню:

acMenuItems = {Один, Два, "", Три}
alSelectableItems = {.T., .T., .F., .T.}
nPosition = ACHOICE(10, 10, 12, 15, acMenuItems, alSelectableItems)
? acMenuItems[nPosition]

В следующем примере определяется массив, условие выбора для одного


138


элемента меню и пользовательская функция:

FUNCTION MyMenu
LOCAL acMenuItems[4], alSelectableItems[4], cUserFunction := "DoIt"
//
acMenuItems[1] = " Добавить "
acMenuItems[2] = " Редактировать"
acMenuItems[3] = " Удалить "
acMenuItems[4] = " Обновить "
//
alSelectableItems[1] = .T.
alSelectableItems[2] = .T.
alSelectableItems[3] = .T.
alSelectableItems[4] = "!UPDATED()" // условие выбора
RETURN ACHOICE(10, 10, 12, 15, acMenuItems,;
alSelectableItems, cUserFunction)

Library: EXTEND.LIB; Файлы заголовков: Achoice.ch и Inkey.ch.

-------------------------------------------------------------------
ACLONE() Дублирование вложенных массивов
-------------------------------------------------------------------


ACLONE(<массив1>) --> массив2

Аргументы

<массив1> массив для дублирования.

Результат

ACLONE() возвращает скопированный массив <массив2>.

Применение

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

Пример использования

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}
// aTwo - {1, 2, 3}

Library: CLIPPER.LIB.

139


-------------------------------------------------------------------
ACOPY() Копирование элементов массива из одного в другой
-------------------------------------------------------------------


ACOPY(<массив1>,<массив2> [,<вырN1> [,<вырN2> [,<вырN3>]]]) --> массив2

Аргументы

<массив1> - входный массив.

<массив2> - выходной массив.

<вырN1> - индекс начального элемента в входном массиве.

<вырN2> - количество элементов копируемых из входного массива,
начиная с элемента с номером <вырN1>.

<вырN3> - индекс начального элемента в выходном массиве, начиная
с которого распологается копируемое.

Результаты

ACOPY() возвращает ссылку на выходной массив.

Применение

ACOPY() копирует элементы из <массив1> в <массив2>. <массив2> должен
уже существовать. Если <массив1> имеет большую длину, чем <массив2>,
то последние элементы не будут скопированы. ACOPY() не копирует
вложенные массивы.

Пример использования

LOCAL nCount := 2, nStart := 1, aOne, aTwo
aOne := { 1, 1, 1 }
aTwo := { 2, 2, 2 }
ACOPY(aOne, aTwo, nStart, nCount) // Результат: aTwo - { 1, 1, 2 }

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ADEL() Удаление элемента массива
-------------------------------------------------------------------


ADEL(<массив>,<вырN>) -->массив

Аргументы

<массив> - имя массива из которого надо удалить элемент.

<вырN> - индекс удаляемого элемента.


140

Результаты

ADEL() возвращает ссылку на массив, указанный в качестве аргумента
функции.

Применение

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

------------------------------------------------------------------
Внимание

Если массив содержит массивы, то ADEL() удалит эти массивы, если они
входят в указанный диапазон удаляемых элементов.
---------------------------------------------------------------------

Пример использования

LOCAL aArray
aArray := { 1, 2, 3 } // Результат: aArray - { 1, 2, 3 }
ADEL(aArray, 2) // Результат: aArray - { 1, 3, NIL }

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ADIR()* Заполнение массивов информацией из каталога о указанных файлах
-------------------------------------------------------------------


ADIR(<шаблон каталога>
[<массив1>,]
[<массив2>,]
[<массив3>,]
[<массив4>,]
[<массив5>]) --> вырN

Аргументы

<шаблон каталога> - маска с шаблонными символами. Поддерживаются
стандартные символы шаблона (* и ?). Умолчание - "*.*".

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

<массив2> - имя массива, заполняемого размерами соответствующих
файлов <массива1>. Каждый элемент имеет числовой тип.

<массив3> - имя массива, заполняемого датами создания


141


соответствующих файлов <массива1>. Каждый элемент имеет числовой
тип.

<массив4> - имя массива, заполняемого временем создания
соответствующих файлов <массива1>. Каждый элемент имеет числовой
тип.

<массив5> - имя массива, заполняемого атрибутами соответствующих
файлов <массива1>. Каждый элемент имеет символьный тип.

Результаты

ADIR() возвращает количество файлов, соответствующих шаблону. Если
необязательное имя массива указано, то элементы массива заполняются
именами файлов, по одному в каждый элемент пока не будут найдены все
соответствующие шаблону файлы или не используются все элементы
массива.

Применение

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

ADIR() - совместимая функция и поэтому не рекомендована. Она
заменяется функцией DIRECTORY(), которая возвращает файловую
информацию во вложенные массивы.

Пример использования

LOCAL aFiles[ADIR("*.TXT")]
ADIR("*.TXT", aFiles)
AEVAL(aFiles, { |element| QOUT(element) })

^Library: EXTEND.LIB.

-------------------------------------------------------------------
AEVAL() Выполняет блок для каждого элемента в массиве
-------------------------------------------------------------------


AEVAL(<массив>, <блок>, [<вырN1>], [<вырN2>]) --> массив

Аргументы

<массив> массив для обработки.

<блок> блок для выполнения каждым элементом массива.

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

142


<вырN2> число элементов для обработки, начиная с элемента
<вырN1>. Если не указано, по умолчанию - все элементы.

Результаты

AEVAL() возвращает ссылку на <массив>.

Применение

AEVAL() выполняет блок для каждого элемента массива, передавая
значение элемента массива как параметр блока. Возвращаемое значение
блока игнорируется. AEVAL() подобна DBEVAL(), которая применяет блок
для каждой записи файла базы данных.

Пример использования

Пример использования AEVAL() для построения списка, содержащего
выбранные элементы из вложенных массивов:

#include "Directry.ch"
//
LOCAL aFiles := DIRECTORY("*.dbf"), aNames := {}
AEVAL(aFiles,;
{ | file | AADD(aNames, file[F_NAME]) };


Library: CLIPPER.LIB.

-------------------------------------------------------------------
AFIELDS()* Заполнение массивов информацией о полях базы данных
-------------------------------------------------------------------


AFIELD([<массив1> [,<массив2>], [<массив3>], [<массив4>]) -->вырN

Аргументы

<массив1> - массив для заполнения именами полей. Каждый элемент
символьного типа.

<массив2> - массив для заполнения типами полей, указанных в
массиве1. Каждый элемент символьного типа.

<массив3> - массив длинны полей. Каждый элемент числового типа.

<массив4> - массив длинны дробной части полей, определенных в
массиве1. Каждый элемент числового типа. Если поле не числового
типа, то соответствующий элемент массива принимает значение 0.

Результаты

AFIELDS() возвращает количество полей или длину наименьшего массива
из аргументов. Если не указаны параметры, то AFIELDS() возвращает 0.


143

Применение

AFIELDS заполняет несколько массивов атрибутами полей текущей
рабочей области и возвращает количество элементов, заполненных
информацией о полях. Если нет баз данных, указанных в команде USE,
то AFIELDS() возвращает 0. Передаваемые как аргументы массивы
соответствуют имени поле, типу полей, длинной полей и длинной
дробной части для полей числового типа. AFIELDS() работает также как
и ADIR(). Для того, чтобы применить AFIELDS() необходимо
предварительно создать массивы с числом элементов, равным количеству
полей в файле базы данных (используйте FCOUNT() ).

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

Пример использования

Следующий пример демонстрирует, как применять AFIELDS() и ACHOICE()
для создания списка полей и выбора из него.

USE Sales NEW
PRIVATE aFields[FCOUNT()]
AFIELDS(aFields)
@ 1, 0 TO 10, 10 DOUBLE
nChoice = ACHOICE(2, 1, 9, 9, aFields)
@ 12, 0 SAY IF(nChoice != 0, aFields[nChoice], "Нет выбора")
RETURN

Применение AFIELDS() с алиасным выражением для заполнения
массивов информацией о файле Sales.dbf, открытым в другой рабочей
области:

LOCAL aFieldNames, aTypes, aWidths, aDecimals
USE Sales NEW
USE Customer NEW
//
aFieldNames := Sales->(ARRAY(FCOUNT())
aTypes := Sales->(ARRAY(FCOUNT())
aWidths := Sales->(ARRAY(FCOUNT())
aDecimals := Sales->(ARRAY(FCOUNT())
//
Sales->(AFIELDS(aFieldNames, aTypes, aWidths, aDecimals))

Library: EXTEND.LIB.

-------------------------------------------------------------------
AFILL() Заполнение массива указанным значением
-------------------------------------------------------------------


144


AFILL(<массив>,<выр>, [<вырN1>], [<вырN2>]) --> массив

Аргументы

<массив> - заполняемый массив.

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

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

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

Результаты

AFILL() возвращает ссылку на заполняемый массив.

Применение

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

---------------------------------------------------------------------
Внимание

AFILL() не может быть использована для заполнения вложенных массивов.
---------------------------------------------------------------------

Пример использования

LOCAL aLogic[3] // Результат: aLogic - { NIL, NIL, NIL }
AFILL(aLogic, .F.) // Результат: aLogic - { .F., .F., .F. }
AFILL(aLogic, .T., 2, 2) // Результат: aLogic - { .F., .T., .T. }

Library: CLIPPER.LIB.

-------------------------------------------------------------------
AINS() Вставка нового элемента в массив
-------------------------------------------------------------------


AINS(<массив>,<вырN>) -->массив

Аргументы

<массив> - массив.

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


145

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

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

Результаты

AINS() возвращает ссылку на массив.

Применение

AFILL() вставляет новый элемент в указанный массив. Новый элемент
будет пустым, пока ему не будет присвоено значение. После вставки
элемента, последний элемент массива отбрасывается и все элементы
передвигаются на одну позицию.

---------------------------------------------------------------------
Внимание

Будьте осторожны при использовании AINS() с вложенными массивами.
Можно потерять внутренний последний массив. Перед вставкой нового
элемента добавьте элемент функцией AADD().
---------------------------------------------------------------------

Пример использования

LOCAL aArray
aArray := { 1, 2, 3 } // Результат: aArray - { 1, 2, 3 }
AINS(aArray, 2) // Результат: aArray - { 1, NIL, 2 }

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ALIAS() Выдает имя псевдонима рабочей области
-------------------------------------------------------------------


ALIAS([<вырN>]) --> вырN

Аргументы

<вырN> - номер заданной рабочей области.

Результаты

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

146


Применение

ALIAS() используется для определения псевдонима рабочей области.
Когда открывается файл коммандой USE имя рабочей области
присваивается псевдониму (алиасу).

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ALLTRIM() Выбрасывает все промежуточные и ведущие пробелы в строке
-------------------------------------------------------------------


ALLTRIM(<вырС>) --> вырС

Аргументы

<вырС> - символьная строка для удаления пробелов.

Результаты

Функция ALLTRIM() возвращает строку без ведущих и оконечных пробелов
и является эквивалентом выражения LTRIM(RTRIM(<вырС>).


Применение

ALLTRIM() удаляет промежуточные и ведущие пробелы в строке. Она
подобна LTRIM() и RTRIM(), которые удаляет ведущие и промежуточные
пробелы соответственно слева и справа.

Пример использования

cString = SPACE(10) + "string" + SPACE(10)
? LEN(cString) // Результат: 26
? LEN(ALLTRIM(cString)) // Результат: 6

Library: EXTEND.LIB.

-------------------------------------------------------------------
ALTD() Вызов отладчика
-------------------------------------------------------------------


ALTD([<вырN>]) --> NIL

Аргументы

<вырN> устанавливает состояние по нажатию клавиши Alt-D в
соответствии с таблицей:

147


Аргументы функции ALTD()
-----------------------------------------------------
Аргумент Действие
-----------------------------------------------------
Нет Вызывает Отладчик, если это возможно
0 Запрещает использование Alt-D
1 Разрешает использование Alt-D
Другие Не действует
-----------------------------------------------------

Результат

ALTD() всегда возвращает NIL.

Применение

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


Пример использования

#define ALTD_DISABLE 0
#define ALTD_ENABLE 1
//
ALTD(ALTD_ENABLE)

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ARRAY() Создание массива указанной длины
-------------------------------------------------------------------


ARRAY(<вырN> [, <вырN>...]) --> массив

Аргументы

<вырN> - число элементов в указанном массиве. Максимальное число
элементов в массиве 4096. Число массивов не ограничено.

Результат

ARRAY() возвращает массив указанного размера.

Применение

ARRAY() возвращает не инициализированный массив с указанным числом
элементов. Если указывается более чем один аргумент <вырN>,
создается вложенный массив с числом элементов, равных аргументу,
указанному в <вырN>.

В Клиппер 5.0 существует несколько способов для создания массивов.


148


Вы можете определить массив используя комманды LOCATE или STATIC; вы
можете создать массив, используя комманды PRIVATE и PUBLIC; вы
можете назначить буквенный массив существующей переменной; или вы
можете использовать функцию 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) }

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ASC() Выдает значение кода ASCII для самого левого символа строки
-------------------------------------------------------------------


ASC(<вырС> -->вырN

Аргументы

<вырC> - символьное выражение преобразуемое в число.

Результаты

Целое числовое значение в диапазоне от 0 до 255.

Применение

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

Пример использования

? ASC("A") // Результат: 65
? ASC("Apple") // Результат: 65
? ASC("a") // Результат: 97
? ASC("Z") - ASC("A") // Результат: 25
? ASC("") // Результат: 0

Library: CLIPPER.LIB.


149


-------------------------------------------------------------------
ASCAN() Поиск указанного значения среди элементов массива
-------------------------------------------------------------------


ASCAN(<массив>,<выр>, [<вырN1>], [<вырN2>]) -->вырN

Аргументы

<массив> - массив в котором производится поиск.

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

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

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

Результаты

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

Применение

Функция ASCAN() работает также, как SEEK и FIND когда производит
поиск. Условие поиска <выр> проверяется для каждого элемента
массива, начиная с самого левого символа элемента, и продолжает пока
не окажется символов слева в <выр>. Если соответствия нет, то
обрабатывает таким же образом следующий элемент массива. Помните,
что функция ASCAN() использует оператор равенства (=) для сравнения,
что учитывается в режиме команды EXACT. Если установлено EXACT ON,
то элемент массива должен соответствовать результату <выр> символ в
символ.

Если <выр> является кодовым блоком, ASCAN() осуществляет поиск в
<массив>, выполняя блок для каждого доступного элемента.

Пример использования

Следующий пример демонстрирует поиск в массиве из трех элементов
используя значение и блок как критерий поиска:

aArray := { "Tom", "Mary", "Sue" }
? ASCAN(aArray, "Mary") // Ре оно ил оно или положительно.br /br //ppи положительно.br /br /gt;]) --/pзультат: 2
? ASCAN(aArray, "mary") // Результат: 0
//


150


? ASCAN(aArray, { |x| UPPER(x) == "MARY" }) // Результат: 2

Пример продолжения поиска для выполнения нескольких требований к
аргументу поиска:

LOCAL aArray := { "Tom", "Mary", "Sue", "Mary" }, nStart := 1
//
// Взять позицию последнего элемента
nAtEnd := LEN(myArray)
DO WHILE (nPos := ASCAN(aArray, "Mary", nStart)) > 0
? nPos, aArray[nPos]
//
// Взять новую стартовую позицию и проверить граничное условие
IF (nStart := ++nPos) > nAtEnd
EXIT
ENDIF
ENDDO

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ASIZE() Увеличить или уменьшить массив
-------------------------------------------------------------------


ASIZE(<массив>, <вырN>) --> массив

Аргументы

<массив> массив для увеличения или уменьшения.

<вырN> - новый размер массива.

Результат

ASIZE() возвращает ссылку на указанный массив.

Применение

ASIZE() меняет длину указанного массива. Массив сжимается или
удлиняется. Если массив сжимается, последний элемент массива
теряется. Если массив удлиняется, добавляется новый элемент в конец
массива и ему назначается NIL.

ASIZE() идентична ADD(), которая добавляет элемент массива в конец
массива и присваивает ему значение. Но AINS() и ADEL() отличаются от
ASIZE() тем, что не меняют длин массива.

Пример использования


aArray := { 1 } // Результат: aArray - { 1 }
ASIZE(aArray, 3) // Результат: aArray - { 1, NIL, NIL }


151


ASIZE(aArray, 1) // Результат: aArray - { 1 }

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ASORT() Сортировка элементов массива по возрастанию значений
-------------------------------------------------------------------


ASORT(<массив>, [<вырN1>], [<вырN2>]] [блок]) -->массив

Аргументы

<массив> - массив, который сортируется.

<вырN1> - индекс начального элемента для сортировки. Если этот
аргумент отсутствует, то сортировка начинается с индекса 1.

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

<блок> - блок для определения порядка сортировки. Если не указан, по
умолчанию - сортировка по возрастанию.

Результаты

ASORT() возвращает ссылку на указанный массив.

Применение

ASORT() сортирует весь или часть указанного массива. Могут
сортироваться данные любого типа, включая символы, даты, логические
и числовые величины. Все элементы сортируемого массива должны
быть одного и того же типа. Если <блок> указан, то он определяет
порядок сортировки. Блок возвращает значение истина (.T.), если
элементы отсортированы в этом порядке.

Символы сортируются в порядке кодов ASCII; логические значения
сортируются с (.F.) как низший уровень; даты сортируются в
хронологическом порядке; числа сортируются по значению.

---------------------------------------------------------------------
Внимание

ASORT() не будет непосредственно сортировать вложенный массив. Для
сортировки вложенных массивов вы должны снабдить блок управлением
вложенного массива.
---------------------------------------------------------------------

Пример использования

Пример создания массива из пяти элементов, сортировки элементов по


152


возрастанию, использование блока для сортировки по убыванию:

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 := { "Fred", Kate", "ALVIN", "friend" }
ASORT(aArray,,, { |x, y| UPPER(x) < UPPER(y) })

Пример сортировки вложенного массива:


aKids := { {"Mary", 14}, {"Joe", 23}, {"Art", 16} }
aSortKids := ASORT(aKids,,, { |x, y| x[2] < y[2] })

Результат:

{ {"Mary", 14}, {"Art", 16}, {"Joe", 23} }

Library: EXTEND.LIB.

-------------------------------------------------------------------
AT() Выдает позицию вхождения подстроки в строку
-------------------------------------------------------------------


AT(<вырC1>,<вырC2>) -->вырN

Аргументы

<вырC1> - строка символов, которую надо найти.

<вырC2> - строка символов в которой производится поиск.

Результаты

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

Применение

Функция AT() применяется для манипуляций с строками. В основном, она
применяется для определения позиции, с которой подстрока входит в
строку в числовом результате. Если же вы хотите только знать
содержится ли подстрока в строке, то лучше использовать оператор $.

Пример использования

153


Пример основного использования AT():

? AT("a", "abcde") // Результат: 1
? AT("bcd", "abcde") // Результат: 2
? AT("a", "bcde") // Результат: 0

Пример разбиения символьной строки:

cTarget = "Langtree, Lilly"
? SUBSTR(cTarget, 1, AT(",", cTarget) - 1) // Результат: Langtree
? SUBSTR(cTarget, AT(",", cTarget) + 2) // Результат: Lilly


Library: CLIPPER.LIB.

-------------------------------------------------------------------
BIN2I() Преобразует символьную строку в формате 16 битового числа
-------------------------------------------------------------------


BIN2I(<вырС>) -->вырN

Аргументы

<вырС> - двух байтная строка в форме 16 битового целого числа со
знаком. Если указано больше, чем 2 символа, то остальные
игнорируются.

Результаты

BIN2I() возвращает целое числовое значение.

Применение

Функция BIN2I() используется в комбинации с функциями FREAD() или
для преобразования двух байтовой строки в формате целого числа в
числовое значение Clipper'а. Это наиболее полезно когда вы хотите
считать файл типа отличного от формата Клиппер и будете обрабатывать
в форме представления целых чисел Clipper.

Пример использования

Этот пример открывает файл базы данных низкоуровневыми функциями
ввода/вывода и считывает дату последней корректировки (байты 1-3).
Результат такой же, как при использовании функции LUPDATE().

#include "Fileio.ch"
//
nHandle = FOPEN("Sales.dbf", FO_READ)
//
// Указать на байт 1 в файле
FSEEK(nHandle, 1, FS_SET)
//


154


// Читать дату последнего обновления
nYear = BIN2I(FREADSTR(nHandle, 1) + CHR(0))
nMonth = BIN2I(FREADSTR(nHandle, 1) + CHR(0))
nDay = BIN2I(FREADSTR(nHandle, 1) + CHR(0))
//
? LTRIM(STR(nMonth)), LTRIM(STR(nDay)), LTRIM(STR(nYear))
FCLOSE(nHandle)

Library: EXTEND.LIB; Исходный текст: EXAMPLEA.ASM.

-------------------------------------------------------------------
BIN2L() Преобразует символьную строку в формате 32 битового числа
-------------------------------------------------------------------


BIN2L(<вырС>) -->вырN

Аргументы

<вырС> - четырех байтовая строка в форме 32 битового целого числа со
знаком. Если указано больше, чем 4 символа, то остальные
игнорируются.

Результаты

BIN2L() возвращает целое числовое значение.

Применение

Функция BIN2L() используется в комбинации с функциями FREAD() для
преобразования четырех байтовой строки в формате целого числа в
числовое значение Clipper'а. Это наиболее полезно когда вы хотите
считать файл типа отличного от формата Clipper'а, и будете
обрабатывать в форме представления целых чисел Clipper'а.

Пример использования

Этот пример открывает файл базы данных низкоуровневыми функциями
ввода/вывода и считывает количество записей (байты 4-7). Такой же
результат выдает функция LASTREC().

#include "Fileio.ch"
//
nHandle = FOPEN("Sales.dbf", FO_READ)
//
// Указать на байт 4
FSEEK(nHandle, 4, FS_SET)
//
// Читать число записей
cRecords = SPACE(4)
FREAD(nHandle, @cRecords, 4)
//
? LTRIM(STR(BIN2L(cRecords))) // Результат: 84


155


FCLOSE(nHandle)

Library: EXTEND.LIB; Исходный текст: EXAMPLEA.ASM.

-------------------------------------------------------------------
BIN2W() Преобразование строки в формате 16 битового целого в число
-------------------------------------------------------------------


BIN2W(<вырС>) -->вырN

Аргументы

<вырС> - двух байтовая строка в форме 16 битового целого числа без
знака. Если указано больше, чем 2 символа, то остальные
игнорируются.

Результаты

BIN2W() возвращает целое числовое значение.

Применение

Функция BIN2W() используется в комбинации с функцией FREAD() для
преобразования двух байтовой строки в формате целого числа без знака
числовое значение Clipper'а. Это наиболее полезно когда вы хотите
считать файл типа отличного от формата Clipper'а, и будете
обрабатывать в форме представления целых чисел Clipper'а.

Пример использования

Этот пример открывает файл базы данных низкоуровневыми функциями
ввода/вывода и считывает количество байт в записи (байты 10-11).
Такой же результат выдает функция RECSIZE().

#include "Fileio.ch"
//
nHandle = FOPEN("Sales.dbf", FO_READ)
//
// Указать на байт 10, размер первой записи
FSEEK(nHandle, 10, FS_SET)
//
// Читать размер записи
cRecSize = SPACE(2)
FREAD(nHandle, @cRecSize, 2)
//
? LTRIM(STR(BIN2W(cRecSize))) // Результат: 124
FCLOSE(nHandle)

Library: EXTEND.LIB; Исходный текст: EXAMPLEA.ASM.

156

-------------------------------------------------------------------
BOF() Указывает на начало файла
-------------------------------------------------------------------
BOF() --> вырL

Результаты

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

Заметьте, что команда SKIP перемещает указатель записи и не может
установить BOF() в значение "истина".

Применение

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

Пример использования

Пример использования BOF() при попытке движения указателя записи за
первую запись:

USE Sales NEW
? RECNO(), BOF() // Результат: 1 .F.
SKIP -1
? RECNO(), BOF() // Результат: 1 .T.

Пример использование алиасного выражения в BOF():

USE Sales NEW
USE Customer NEW
USE Invoices NEW
? Sales->(BOF()), Customer->(BOF())

Library CLIPPER.LIB.

-------------------------------------------------------------------
BREAK() Прерывание в конструкции BEGIN SEQUENCE...END
-------------------------------------------------------------------


157

BREAK(<выр>) --> NIL

Аргументы

<выр> значение передаваемое предложению RECOVER, если он существует.
Указание <выр> не обязательно.

Результаты

BREAK() всегда возвращает NIL.

Применение

BREAK() подобна оператору BREAK. Функция должна выполняться в
SEQUENCE.

Пример использования

Пример использования прерывания из блока в SEQUENCE :

bSave := ERRORBLOCK( {|x| BREAK(x)} )

BEGIN SEQUENCE
.
.
RECOVER USING objError
.
.
END

ERRORBLOCK(bSave)

Library: CLIPPER.LIB.

-------------------------------------------------------------------
BROWSE() Просмотр записей внутри окна
-------------------------------------------------------------------


BROWSE([<вырN1>], [<вырN2>], [<вырN3>], [<вырN4>]) --> NIL

Аргументы

<вырN1>, <вырN2>, <вырN3>, и <вырN4> определяют координаты окна.
Если не указаны, по умолчанию координаты окна - от 1,0 до MAXROW(),
MAXCOL().

Результат

BROWSE() всегда возвращает NIL.

Применение


158


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

Замечания

Строка статуса: BROWSE() выводит строку статуса в верхнем правом
углу окна просмотра и содержит следующее:

--------------------------------------------------------------
Сообщение Действие
--------------------------------------------------------------
<new> Режим добавление
<bof> Начало файла
<delete> Текущая запись удаляется
Record Номер выводимой записи
--------------------------------------------------------------

Режимы: BROWSE() имеет три режима работы:

Просмотр: Этот режим определен для BROWSE() по умолчанию. При
нажатии клавиш, которые также используются в DBEDIT() происходит
передвижение светящейся строки.

Редактирование поля: При нажатии Return на любом поле выполняется
режим редактирования поля используя GET. При повторном нажатии
Return, редактирование заканчивается с сохранением изменений. Esc
заканчивает редактирование без сохранения изменений. При
редактировании действую все клавиши для комманды READ.

Добавление: Встать в конец файла и затем нажать клавишу Dnarrow
(вниз) и осуществится переход в режим добавления с выводом сообщения
"<new>" на строке статуса. При нажатии Uparrow (вверх) режим
добавления заканчивается с сохранением новых записей. Если данные не
были введены, новая запись не сохраняется. Library:EXTEND.LIB;
Исходный текст: Examplep.prg.

-------------------------------------------------------------------
CDOW() Выдает имя дня недели по номеру
-------------------------------------------------------------------


CDOW(<вырD>) -->вырD

Аргумент

<вырD> - преобразуемое значение даты.

Результаты

CDOW() возвращает название дня недели с заглавной буквы.


159

Максимальная длина возвращаемой строки символов девять символов (для
слова "Wednesday"). Нулевая дата - выдает нулевую строку ("").

Применение

Функция CDOW полезна сама по себе или как часть выражений в формате
даты для отчетов, визиток и экранов.

Пример использования

? DATE() // Результат: 09/01/90
? CDOW(DATE()) // Результат: Friday
? CDOW(DATE() + 7) // Результат: Friday
? CDOW(CTOD("06/12/90")) // Результат: Monday

-------------------------------------------------------------------
CHR() Выдает символ для указанного кода ASCII
-------------------------------------------------------------------


CHR(<вырN>) -->вырC

Аргумент

<вырN> - код расширенного набора символов IBM, который возвращается,
в диапазоне от 0 до 255.

Результаты

CHR() возвращает символ соответствующий коду ASCII.

Применение

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

Более разумное применение функции это контроль клавиатуры. Обычно,
функция USE используется с командой KEYBOARD для заполнения буфера
клавиатуры кодом определенных клавиш. В некоторых случаях, будет
полезным создать переменные памяти с кодами клавиш, присвоением им
значений функцией CHR(). Далее, вы можете сравнивать результат
выражения CHR(INKEY) c содержимым этих переменных памяти.

Замечание: CHR(0) имеет теперь длину в один символ и трактуется как
любой другой символ. Это позволяет вам послать этот символ на
принтер или включить в файл базы данных.

Пример использования

160

Пример использования CHR() с различными аргументами:

? CHR(72) // Результат: H
? CHR(ASC("A") + 32) // Результат: a
? CHR(7) // Результат: звук

Две различные строки линии These two lines of code show the
difference between a null string and the null character:

? LEN("") // Result: 0
? LEN(CHR(0)) // Result: 1

Library: CLIPPER.LIB.

-------------------------------------------------------------------
CMONTH() Преобразует значение даты в строку название месяца
-------------------------------------------------------------------


CMONTH(<вырD>) -->вырС

Аргумент

<вырD> - преобразуемое значение даты.

Результаты

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

Применение

Функция CMONTH() полезна при образовании форматированных строк с
датами для отчетов, визиток и экранов.

Пример использования

? CMONTH(DATE()) // Результат: September
? CMONTH(DATE() + 45) // Результат: October
? SUBSTR(CMONTH(DATE()), 1, 3) +;
STR(DAY(DATE())) // Результат: Sep 29

Library: CLIPPER.LIB.

-------------------------------------------------------------------
COL() Выдает текущую колонку курсора
-------------------------------------------------------------------


COL() -->вырN
Результаты

161

COL() возвращает целое числовое значение в диапазоне от 0 до MAXCOL().

Применение

COL() используется когда вы хотите позиционировать курсор на экране
относительно текущих координат. COL, в основном, применяется вместе
с функцией ROW() и другими вариациями в команде @. Особенно, в
процедурах создания экрана координатно независимого с параметрами
левого верхнего угла. COL() автоматически устанавливается в 0 при
выполнении комманд CLEAR, CLEAR SCREEN или CLS.

Пример использования

USE Sales NEW
@ 1, 10 SAY "Customer Name: " + TRIM(Customer)
@ ROW(), COL() + 1 SAY "Account status: " + Status


-------------------------------------------------------------------
CTOD() Преобразовывает символьную строку в значения типа даты
-------------------------------------------------------------------


CTOD(<вырС>) -->вырС

Аргументы

<вырС> - символьная строка, содержащая номера месяца, дня и года
разделенные символом разделителем (отличным от цифр). При передачи
строки с датой производится вычисление месяца, дня и года в
соответствии с установкой SET DATE. По умолчанию AMERICAN
("mm/dd/yy"). Если цифры года не указаны, то дата определяется по
правилу, указанному в комманде SET EPOCH.

Результаты

CTOD() возвращает значение даты. Если <вырС> не указано,
возвращается пустая дата.

Применение

CTOD() преобразует символьную строку в дату. Для инициализации
пустой даты укажите в <вырС> пустую строку (""), SPACE(8), " / / ".

Функция CTOD() полезна там, где вы хотите использовать символьную
строку в значении даты. Несколько таких ситуаций:

Инициализация переменных памяти как даты.

Указание символьной даты как аргумент фразы RANGE в команде @...GET.

Указание символьной строки даты для арифметических действий с датой.


162


Сравнение результата выражения даты с символьной строкой даты.

Замена поля даты символьной строкой даты.

Пример использования

Пример использования CTOD() для инициализации переменных типа дата.
Затем, одна переменная используется в GET, а другая в предложении
RANGE:

SET CENTURY ON
dBegin = CTOD("01-26-1876")
dCurrent = CTOD("")
@ 10, 10 SAY "Enter date:" GET dCurrent RANGE dBegin, DATE()
READ

Пример использования CTOD() для создания даты в условии FOR:

USE Inventory NEW
REPLACE ALL Inventory->Price WITH Inventory->Price * 1.1;
FOR Inventory->InvDate < CTOD("10/10/90")

Library: CLIPPER.LIB.

-------------------------------------------------------------------
CURDIR() Выдает строку маршрута для текущего каталога для дисковода
-------------------------------------------------------------------


CURDIR([<вырС>]) -->вырС

Аргументы

<вырС> - символ имени дисковода (A,B,...). Если не указан, то
предполагается текущий дисковод.

Результат

CURDIR() возвращает для указанного дисковода маршрут каталога ДОСа.
Нулевая строка означает либо возникновение ошибки, либо указывает на
корневой каталог текущего дисковода.

Пример использования

Пример простейшего использования CURDIR():

? CURDIR("E:") // Результат: пустая строка--корневой директорий
? CURDIR("C") // Результат: CLIPPER5\SOURCE
? CURDIR("C:") // Результат: CLIPPER5\SOURCE
? CURDIR() // Результат: пустая строка--корневой директорий
? CURDIR("A") // Результат: пустая строка--устройство не готово


163


Пример изменения текущего директория:

IF CURDIR("C:") != "CLIPPER5\SOURCE"
RUN CD \CLIPPER5\SOURCE
ENDIF

Library: EXTEND.LIB; Исходный текст: EXAMPLEA.ASM.

-------------------------------------------------------------------
DATE() Выдает системную дату
-------------------------------------------------------------------


DATE() -->вырС

Результаты

DATE() возвращает значение системной даты.


Применение

DATE() возвращает системную дату в формате установленном комбинацией
команд SET DATE и SET CENTURY. По умолчанию AMERICAN и SET CENTURY
OFF ("mm/dd/yy").

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

Пример использования

? DATE() // Результат: 09/01/90
? DATE() + 30 // Результат: 10/01/90
? DATE() - 30 // Результат: 08/02/90
dDate = DATE()
? CMONTH(dDate) // Результат: September

Library: CLIPPER.LIB.

-------------------------------------------------------------------
DAY() Преобразование даты в номер дня недели
-------------------------------------------------------------------


DAY(<вырD>) --> вырN

Аргументы

<вырD> - значение даты для преобразования.

164

Результаты

DAY() возвращает число в диапазоне от 0 до 31 в зависимости от
количества дней в месяце. Если месяц "февраль", то по году
вычисляется какое число возвращать 28 или 29. В Клиппер сделано так,
если аргумент имеет число 29 февраля для не високосного года, то
возвращается 0. Если аргумент пустой, тоже возвращается 0.

Применение

DAY() полезна когда вы хотите производить вычисления с днями месяца.

Пример использования

Пример простейшего использования DAY():

? DATE() // Результат: 09/01/87
? DAY(DATE) // Результат: 1
? DAY(DATE) + 1 // Результат: 2
? DAY(CTOD("")) // Результат: 0

Пример использования DAY() в комбинации с CMONTH() и YEAR() для
изменения формата даты:

? CMONTH(DATE()) + STR(DAY(DATE())) +;
"," + STR(YEAR(DATE())) // Результат: June 15, 1990

Library: CLIPPER.LIB.

-------------------------------------------------------------------
DBCREATE() Создание файла базы данных из массива структуры базы данных
-------------------------------------------------------------------


DBCREATE(<вырС>, <массив>) --> NIL

Аргументы

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

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

-----------------------------------------------------------------
Позиция Метасимвол Dbstruct.ch
-----------------------------------------------------------------
1 cName DBS_NAME
2 cType DBS_TYPE


165

3 nLength DBS_LEN
4 nDecimals DBS_DEC
-----------------------------------------------------------------

Результат

DBCREATE() всегда возвращает NIL.

Применение

DBCREATE() создает файл базы данных из массива, содержащего
структуру файла. Массив может быть создан программным путем или с
помощью DSTRUCT(). DBCREATE() подобна комманде CREATE FROM, которая
создает новый файл базы данных из файла структуры. Файл структуры
создается также коммандой CREATE или коммандой COPY STRUCTURE
EXTENDED.

Перед использованием DBCREATE(), необходимо создать <массив> и
заполнить его массивами полей. При создании массива определения поля
существуют некоторые правила :

Все атрибуты полей должны быть указаны со значением типа данных
атрибутов. Атрибут точности (Decimal) должен указываться и для не
числовых полей. Если поле не использует атрибут точности (Decimal),
то его значение равно 0.

Тип атрибутов должен указываться первой буквой типа данных,
допускается и полное определение типа данных. Например, "C" и
"Character" используется для определения символьных полей.

В Clipper, символьные поля могут иметь длину до 64,000 символов. В
отличие от комманды CREATE FROM, DBCREATE() не использует атрибут
точности (Decimals) для указания части длины поля.

Для определения ссылок на различные элементы подмассивов полей
используется файл заголовка Dbstruct.ch, который содержит директивы
#define для назначения имени позиции массива для каждого атрибута
поля. Он размещается в \CLIPPER5\INCLUDE.

Пример использования

Пример создания пустого массива и затем добавление подмассивов полей
с помощью функции AADD() перед созданием файла People.dbf:

aDbf := {}
AADD(aDbf, { "Name", "C", 25, 0 })
AADD(aDbf, { "Address", "C", 1024, 0 })
AADD(aDbf, { "Phone", "N", 13, 0 })
//
DBCREATE("People", aDbf)

Пример выполняет эти же действия, но определяет массив кавложенный:


166


#include "Dbstruct.ch"
//
LOCAL aDbf[1][4]
aDbf[1][ DBS_NAME ] := "Name"
aDbf[1][ DBS_TYPE ] := "Character"
aDbf[1][ DBS_LEN ] := 25
aDbf[1][ DBS_DEC ] := 0
//
DBCREATE("Name", aDbf)

Library: CLIPPER.LIB; Файл заголовка: Dbstruct.ch.

-------------------------------------------------------------------
DBEDIT()* Вывод и редактирование записей в полноэкранном режиме
-------------------------------------------------------------------


DBEDIT([<вырN1>], [<вырN2>],
[<вырN3>], [<вырN4>],
[<массив1>],
[<вырС>],
[<массив2> | <вырС> ]
[<массив3> | <вырС> ]
[<массив4> | <вырС> ]
[<массив5> | <вырС> ]
[<массив6> | <вырС> ]
[<массив7> | <вырС> ] -->NIL

Аргументы

<вырN1>...<вырN4> - границы окна редактирования, соответственно:
верхняя, левая, нижняя и правая граница окна. Любой или все
аргументы могут быть указаны.

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

<вырС> - имя определенной пользователем функции, что выполняется при
нажатии специальных клавиш. Указывается имя функции без скобок и
списка аргументов. Помните, что присутствие этого аргумента изменяет
поведение функции DBEDIT. Смотри описание далее для полной
информации.

<массив2> - массив, используемый как строка форматирования для
колонок. <вырС> используется для форматирования всех колонок.

<массив3> - массив, содержащий заголовки колонок. <вырС> дает
заголовок всем колонкам. Для того, чтобы сделать заголовок в
несколько строк используйте "," в месте переноса строки заголовка.
Если заголовки не указаны, то для заголовков используется <массив1>


167

с именами поле базы данных.

<массив4> - массив, используется для рисования линий, разделяющих
заголовки и область вывода полей. Применение <вырС> вместо
массива, применяет данный символ для разделителя заголовка от полей.

<массив5> - массив для рисования линий, разделяющих колонки.
Применение <вырС> вместо массива, применяет данный символ для
разделителя колонок.

<массив6> - массив для рисования линий, отделяющих нижнюю часть
экрана от полей. Применение <вырС> вместо массива, применяет
данный символ для разделителя полей и нижней части экрана.

<массив7> - массив для вывода сносок для каждой колонки. Для вывода
сносок в несколько строк вставте точку с запятой в том месте строки,
где должна делиться линия. Определение <вырС> вместо массива,
создаст сноски с одинаковым данным значением для всех колонок.

Результаты

DBEDIT() всегда возвращает NIL.

Применение

DBEDIT() позволяет производить полноэкранное редактирование одного
или более полей базы данных. Формат вывода соответствует координатам
окна и массиву полей. Все клавиши перемещения курсора задействованы
в DBEDIT(). Это клавиши: PgUp, PgDn, Home, End, четыре стрелки и
допустимые комбинации Ctrl-клавиша - осуществляют перемещение
курсора. Следующая таблица показывает все активные клавиши DBEDIT().


-----------------------------------------------------------------
Клавиша Действие
-----------------------------------------------------------------
Вверх Вверх на один ряд
Вниз Вниз на один ряд
Влево На колонку влево
Rightarrow На колонку вправо
Ctrl-Leftarrow Встать на левую сторону колонки
Ctrl-Rightarrow Встать на правую сторону колонки
Home Самая левая колонка текущего экрана
End Самая правая колонка текущего экрана
Ctrl-Home Самая левая колонка
Ctrl-End Самая правая колонка
PgUp Предыдущий экран
PgDn Следующий экран
Ctrl-PgUp Первый ряд текущей колонки
Ctrl-PgDn Последний ряд текущей колонки
Return Закончить DBEDIT()
Esc Закончить DBEDIT()


168

-----------------------------------------------------------------

Если указана пользовательская функции, то DBEDIT вызывает ее,
передавая в качестве параметров текущий режим DBEDIT() и текущий
индекс массива полей. Пользовательская функция должна проверять
режим, переданный ей, и значение последней нажатой клавиши (Функцией
LASTKEY()) для выбора соответствующего действия. и затем вернуть
значение в функцию DBEDIT(). Также возможно возвращать значение
нажатой клавиши в DBEDIT() командой KEYBOARD().

Режимы DBEDIT()
__________________________________________________________________

Режим Dbedit.ch Описание
__________________________________________________________________

0 DE_IDLE Игнорируется, обработана клавиша перемещения
курсора и нажатие клавиш не закончено.
1 DE_HITTOP Попытка перехода курсора за начало файла.
2 DE_HITBOTTOM Попытка перехода курсора за конец файла.
3 DE_ EMPTY Файл базы данных пустой.
4 DE_EXEPT Нажата клавиша для дальнейшей обработки

___________________________________________________________________


Значения, возвращаемые в DBEDIT() из пользовательской функции.
____________________________________________________________________

Значение Dbedit.ch Описание
____________________________________________________________________

0 DE_ABOBORT Закончить DBEDIT.
1 DE_CONT Продолжить DBEDIT.
2 DE_REFRECH Заставить перечитать данные (перерисовать
экран) и продолжить DBEDIT
_____________________________________________________________________

Вложенность: Вы можете вызывать несколько копий DBEDIT из каждой
копии. Поэтому, возможно создание множество окон на экране для
DBEDIT.

DBEDIT() совместимая функция и поэтому не рекомендована для
выполнения других действий, кроме просмотра.

Пример использования

Пример вызова DBEDIT() с пользовательской функцией:

USE Customer INDEX Customer NEW
USE Sales INDEX Sales NEW
SET RELATION TO CustNum INTO Customer


169

//
acColumns = {"Branch", "Salesman", "Amount", "Customer->Customer"}
DBEDIT(4, 0, 22, 79, acColumns, "UserFunc")

Library: EXTEND.LIB; Файлы заголовков:Dbedit.ch и Inkey.ch.

-------------------------------------------------------------------
DBEVAL() Вычисляет блок для записей
-------------------------------------------------------------------


DBEVAL(<блок>,
[<условие1>],
[<условие2>],
[<вырN1>],
[<вырN2>],
[<вырL>]) --> NIL

Аргументы

<блок> блок для выполнения для каждой записи.

<условие1> необязательное условие, указывается как блок, который
вычисляется для каждой записи в диапазоне. Выполняется как условие
FOR в коммандах обработки записей.

<условие2> необязательное условие, указывается как блок, который
вычисляется для каждой записи пока условие не станет ложным (.F.).
Выполняется как условие WHILE в коммандах обработки записей.

<вырN1> число, которое определяет сколько записей обрабатывать,
начиная с текущей записи. Это то же самое как NEXT в коммандах
обработки записей.

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

<вырL> логическое значение, которое определяет обработку всех
записей или начиная с текущей до конца файла. Этот аргумент
соответствует предложениям REST и ALL. Если указанное выражение
"истинно" (.T.), то выполняется REST; в противном случае - ALL. Если
аргумент не указан, то по умолчанию - ALL.

Результат

DBEVAL() всегда возвращает NIL.

Применение

DBEVAL() вычисляет поростейший блок для каждой записи внутри текущей
области, которая указывается условием или диапазоном.


170


По умолчанию DBEVAL() выполняется в текущей рабочей области. Для
указания другой рабочей области укажите алиас.

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

Пример использования

Пример использования DBEVAL() для реализации Count():

// Определение комманды диапазона (Scope):
#command CREATE SCOPE <aScope> [FOR <for>] [WHILE <while>];
[NEXT <next>] [RECORD <rec>] [<rest:REST>] [ALL];
=>;
<aScope> := { <{for}>, <{while}>, <next>, <rec>, <.rest.> }
//
// Определение констант
#define FOR_COND 1
#define WHILE_COND 2
#define NEXT_SCOPE 3
#define REC_SCOPE 4
#define REST_SCOPE 5
//
// Создание диапазона и подсчет записей
LOCAL mySet, myCount
USE Customer NEW
CREATE SCOPE mySet FOR Customer = "Smith" WHILE Zip > "90000"
myCount = Count( mySet )
RETURN

FUNCTION Count( aScope )
LOCAL nCount := 0
DBEVAL( {|| nCount++},;
aScope[ FOR_COND ],;
aScope[ WHILE_COND ],;
aScope[ NEXT_SCOPE ],;
aScope[ REC_SCOPE ],;
aScope[ REST_SCOPE ];
)
RETURN nCount

Library: CLIPPER.LIB.

-------------------------------------------------------------------
DBF()* Возвращает имя текущего псевдонима
-------------------------------------------------------------------


DBF() --> вырС


171


Результат

DBF() возвращает псевдоним текущей рабочей области как символьную
строку. Если в текущей рабочей области нет активных файлов, то DBF()
возвращает пустую строку ("").

Применение

DBF() совместимая функция, используемая для замены функции DBF() в
dBASE III PLUS. В Клиппер эти же действия выполняет функция ALIAS()
без аргументов.

Library: EXTEND.LIB; Исходный текст: Examplep.prg

-------------------------------------------------------------------
DBFILTER() Указывает выражение для текущего фильтра
-------------------------------------------------------------------


DBFILTER() --> вырС

Результат

DBFILTER() возвращает условие для фильтра в виде символьной строки.
Если фильтр не установлен командой SET FILTER, то DBFILTER()
возвращает нулевую строку ("").

Применение

DBFILTER() используется для сохранения и перереустановки активного
фильтра путем возврата выражения фильтра как символьной строки.
Используется вместе с DBRELATION() и DBRSELRCT().

DBFILTER() возвращает условие фильтра текущей рабочей области, для
возврата фильтра другой рабочей области, используйте алиас.

Пример использования

В этом примере открывается два файла базы данных, устанавливает два
фильтра, и затем выводит выражения фильтра для обеих областей:

USE Customer INDEX Customer NEW
SET FILTER TO Last = "Smith"
USE Invoices INDEX Invoices NEW
SET FILTER TO CustId = "Smi001"
SELECT Customer
//
? DBFILTER() // Результат: Last = "Smith"
? Invoices->(DBFILTER()) // Результат: Custid = "Smi001"

Пользовательская функция CreateQry() использует DBFILTER() для


172

создания файла памяти, содержащий выражение текущего фильтра в
переменной cFilter:

FUNCTION CreateQry( cQryName )
PRIVATE cFilter := DBFILTER()
SAVE ALL LIKE cFilter TO (cQryName + ".qwy")
RETURN NIL

Library: CLIPPER.LIB.

-------------------------------------------------------------------
DBRELATION() Указывает связывающее выражение для данного отношения
-------------------------------------------------------------------


DBRELATION(<вырN>) -->вырС

Аргументы

<вырN> - порядковый номер отношения в списке определений отношений.

Результат

DBRELATION() возвращает символьную строку, содержащую выражение
отношений на которую указывает <вырN> в списке отношений. Если для
<вырN> не установленных отношений, то возвращается нулевая строка
("").

Применение

DBRELATION() используется в комбинации с DBRSELECT() для определения
связывающего отношения для существующей рабочей области, созданного
по комманде SET RELATION.

DBRELATION() возвращает выражение, определенное предложением TO.
DBRSELECT() возвращает выражение, определенное предложением INTO.

Пример использования

В этом примере открывается три файла базы данных, устанавливается
два отношения и затем выводятся выражения отношений:

USE Invoices INDEX Invoices NEW
USE BackOrder INDEX BackOrder NEW
USE Customer INDEX Customer NEW
SET RELATION TO CustNum INTO Invoices, OrderNum INTO BackOrder
//
? DBRELATION(2) // Результат: OrderNum

Пример пользовательской функции Relation(), которая возвращает
результаты DBRELATION() и DBRSELECT() как массив:

173

FUNCTION Relation( nRelation )
RETURN { DBRELATION(nRelation), ALIAS(DBRSELECT(nRelation)) }

Library: CLIPPER.LIB.

-------------------------------------------------------------------
DBRSELECT() Определяет номер области с которой определено отношение
-------------------------------------------------------------------


DBRSELECT(<вырN>) -->вырN

Аргументы

<вырN> - порядковый номер в списке определенных отношений.

Результат

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

Применение

Функция DBRSELECT() используется в комбинации с DBRELATION() для
определения состояния рабочей области и связывающего выражения для
существующего отношения.

DBRELATION() возвращает выражение, определенное предложением TO.
DBRSELECT() возвращает выражение, определенное предложением INTO.

Вы можете инициализировать эти функции для определения состояния
окружения.

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

Пример использования

Пример открытия трех файлов базы данных, установки двух отношений и
затем вывод выражений отношений:

USE Invoices INDEX Invoices NEW
USE BackOrder INDEX BackOrder NEW
USE Customer INDEX Customer NEW
SET RELATION TO CustNum INTO Customer, OrderNum INTO BackOrder
//
? DBRELATION(2), DBRSELECT(2) // Результат: OrderNum 3
? ALIAS(DBRSELECT(2)) // Result: BACKORDER

Позднее вы можете получить информацию о других рабочих областях,
используя алиасеое выражение:


174


USE Archive NEW
? Customer->(DBRELATION(2)) // Результат: OrderNum
? Customer->(DBRSELECT(2)) // Результат: 3


Library: CLIPPER.LIB.

-------------------------------------------------------------------
DBSTRUCT() Создание массива, содержащего структуру файла базы данных
-------------------------------------------------------------------


DBSTRUCT() --> массив

Результат

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

-----------------------------------------------------------------
Позиция Метасимвол Dbstruct.ch
-----------------------------------------------------------------
1 cName DBS_NAME
2 cType DBS_TYPE
3 nLength DBS_LEN
4 nDecimals DBS_DEC
-----------------------------------------------------------------

Применение

DBSTRUCT() аналогична комманде COPY STRUCTURE EXTENDED . Она создает
массив структуры файла базы данных.

По умолчанию DBSTRUCT() действует в текущей рабочей области. Для
ссылок на другую рабочую область используйте алиасное выражение.

Dbstruct.ch является файлом заголовка, находящийся в
\CLIPPER5\INCLUDE. Он содержит константы для определения атрибутов
каждого поля.

Пример использования

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

#include "Dbstruct.ch"
//
LOCAL aStruct


175

USE Customer NEW
USE Invoices NEW
//
aStruct := Customer->(DBSTRUCT())
AEVAL( aStruct, {|aField| QOUT(aField[DBS_NAME])} )


Library: CLIPPER.LIB; Файл заголовка: Dbstruct.ch.

-------------------------------------------------------------------
DELETED() Возвращает состояние удаления текущей записи
-------------------------------------------------------------------


DELETED() --> вырL

Результат

DELETED() возвращает "истинно" (.T.), если текущая запись помечена
для удаления; в противном случае, возвращает "ложно" (.F.). Если нет
открытых файлов базы данных с помощью комманды USE, то функция
возвращает "ложно"(.F.).

Применение

DELETED() определяет помечена ли на удаление текущая запись
активного файла.

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

Пример использования

Пример использования DELETED() в текущей области и в другой
области с использованием алиасного выражения:

USE Customer NEW
USE Sales NEW
? DELETED() // Результат: .F.
DELETE
? DELETED() // Результат: .T.
? Customer->(DELETED()) // Результат: .F.

Пример использования DELETED() для вывода на экран и в отчет
сообщений о записях помеченных на удаление:

@ 1, 65 SAY IF(DELETED(), "Активна", "Не активна")

Library: CLIPPER.LIB.

176

-------------------------------------------------------------------
DESCEND() Создает поиск в индексных файлах в убывающем порядке
-------------------------------------------------------------------


DESCEND(<выр>) -->выр

Аргументы

<выр> выражение любого типа данных.

Результат

Функция DESCEND() возвращает данные того же типа что и <выр> в форме
дополнения.

Применение

DESCEND() разработана для использования в комбинации с командами
INDEX и SEEK и позволяет создавать и обрабатывать индексы в
убывающем порядке.

Пример использования

Пример использования DESCEND() в выражении INDEX для создания дат в
убывающем порядке:

USE Sales NEW
INDEX ON DESCEND(OrdDate) TO SalesDate

Позднее, DESCEND() может быть использована в SEEK :

SEEK DESCEND(dFindDate)

Пример создания индексации в убывающем порядке, используя более, чем
один тип данных:

USE Sales NEW
INDEX ON STR(DESCEND(SaleDate)) + Salesman TO LastSale

Library: EXTEND.LIB.

-------------------------------------------------------------------
DEVOUT() Запись значения текущего устройства EA
-------------------------------------------------------------------


DEVOUT(<выр>) --> NIL

Аргументы

<выр> значение для вывода.


177


Результат

DEVOUT() всегда возвращает NIL.

Применение

DEVOUT() записывает значение выражения на текущее устройство с
текущей позиции курсора или позиции принтера. DEVOUT() используется
в комбинации с DEVPOS() в STD.CH для выполнения комманд @...SAY.

Пример использования

Пример показывает связь между DEVOUT() и коммандой @...SAY:

DEVPOS(10, 10)
DEVOUT("Вам Привет")
//
@ 10, 10 SAY "Вам Привет"

Library: CLIPPER.LIB.

-------------------------------------------------------------------
DEVPOS() Передвигает курсор или печатающую головку на новую позицию
-------------------------------------------------------------------


DEVPOS(<вырN1>, <вырN2>) --> NIL

Аргументы

<вырN1> и <вырN2> - новые позиции ряда и колонки курсора или
печатающей головки.

Результат

DEVPOS() всегда возвращает NIL.

Применение

DEVPOS() передвигает курсор или печатающую головку. в зависимости от
текущего устройства (DEVICE). Если указано SET DEVICE TO SCREEN,
DEVPOS() также как и SETPOS(), передвинет курсор на указанное место
и обновит функции ROW() и COL() новыми позициями курсора.

Если указано SET DEVICE TO PRINTER, DEVPOS() передвинет печатающую
головку, затем PROW() и PCOL() примут новые значения. Печатающая
головка передвигается в соответствии со следующими правилами:

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


178


Если <вырN2>, включая текущее значение SET MARGIN, меньше, чем
PCOL(), пропускается строка и затем требуемая позиция
устанавливается на принтере.

Используйте SETPRC() для установки PROW() и PCOL() в новые значения
перед использованием DEVPOS().

Library: CLIPPER.LIB.

-------------------------------------------------------------------
DIRECTORY() Создает массив, содержащий директорий и информацию о файлах
-------------------------------------------------------------------


DIRECTORY(<вырС1>, [<вырС2>]) --> массив

Аргументы

<вырС1> указывает устройство, директорий и спецификацию файла для
поиска директория. Если <вырС1> опущено, то по умолчанию - *.*.

<вырС2> указывает какие специальные атрибуты файла будут включены в
файловую информацию. <вырС2> содержит одну или несколько
характеристик, представленных в следующей таблице:

----------------------------------------------------------------------
Атрибуты Значение
----------------------------------------------------------------------
H Включает скрытые файлы
S Включает системные файлы
D Включает директории
V Поиск для DOS меток тома и исключить все
другие файлы
----------------------------------------------------------------------

Файлы всегда включаются в поиск, если не указано V.

Результат

DIRECTORY() возвращает массив из подмассивов, каждый подмассив
содержит информацию о каждом файле в соответствии с <вырС1>.
Подмассивы имеют следующую структуру:

----------------------------------------------------------------------
Позиция Метасимвол Directry.ch
----------------------------------------------------------------------
1 cName F_NAME
2 cSize F_SIZE
3 dDate F_DATE
4 cTime F_TIME

179

5 cAttributes F_ATT
----------------------------------------------------------------------

Если в директории нет файлов или неправильно указан маршрут, то
DIRECTORY() возвращает пустой массив ({}).

Применение

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

DIRECTORY() может быть использована для выполнения действий над
группами файлов. В комбинации с AEVAL(), вы можете определить блок,
который может быть применен ко всем файлам,указанным <вырС1>.

Directry.ch - файл заголовка, содержащий константы для определения
атрибутов фалов и находящийся в \CLIPPER5\INCLUDE.

Пример использования

#include "Directry.ch"
//
aDirectory := DIRECTORY("*.*", "D")
AEVAL( aDirectory, {|aFile| QOUT(aFile[F_NAME])} )

Library: CLIPPER.LIB; Файл заголовка: Directry.ch.

-------------------------------------------------------------------
DISKSPACE() Определяет количество свободного места на диске
-------------------------------------------------------------------


DISKSPACE([<вырN>]) --> вырN

Аргументы

<вырN> - номер диска к которому производится обращение, где один
диск A:, 2 - B:, 3 - C: и так далее. По умолчанию, если не указан
аргумент, текущий рабочий диск.

Результат

DICKSPACE() возвращает количество свободного места на указанном
диске в байтах. Если вызов осуществляется без аргументов, то
DISKSPACE() возвращает размер свободного пространства на диске
используемым по умолчанию (установленному по команде SET DEFAULT TO).

Применение

Эта функция применяется когда производится сортировка или


180

копирование файлов (SORT и COPY) на другой и вам необходимо
определить, имеется ли свободное место для выполнения этих операций.
Вариации совместного использования функций DISKSPACE() RECSIZE() и
RECCOUNT() позволяют написать процедуру создания архивных копий
файлов.

Пример использования

В примере приводится текст определенной пользователем функции,
демонстрирующей использование функции DISKSPACE() для создания
архивной копии файлов на другом диске:

FUNCTION BackUp( cTargetFile, cTargetDrive )
LOCAL nSpaceNeeded, nTargetDrive
//
nSpaceNeeded := INT((RECSIZE() * LASTREC()) + HEADER() + 1)
nTargetDrive := ASC(UPPER(cTargetDrive)) - 64
//
IF DISKSPACE(nTargetDrive) < nSpaceNeeded
RETURN .F.
ENDIF
COPY TO (cTargetDrive + ":" + cTargetFile)
//
RETURN .T.

Library: EXTEND.LIB; Исходный текст: EXAMPLEC.C.


-------------------------------------------------------------------
DISPOUT() Вывод значений
-------------------------------------------------------------------

DISPOUT(<выр>) --> NIL

Аргументы

<выр> значение для вывода.

Результат

DISPOUT() всегда возвращает NIL.

Применение

DISPOUT() выводит указанные выражения с текущей позиции курсора.
Вывод всегда осуществляется на экран.

Пример использования

Следующий пример взят из Getsys.prg и показывает как DISPOUT() может
быть использована для выполнения полно-экранного вывода без
установки SET DEVICE. Заметьте как сохраняются позиции курсора с


181

помощью ROW(), COL(), и SETPOS():

STATIC PROCEDURE ShowScoreboard
LOCAL nRow, nCol
IF ( SET(_SET_SCOREBOARD) )
nRow := ROW()
nCol := COL()
SETPOS( SCORE_ROW, SCORE_COL )
DISPOUT( IF(SET(_SET_INSERT), "Ins", " ") )
SETPOS(nRow, nCol)
ENDIF
RETURN

Library: CLIPPER.LIB.

-------------------------------------------------------------------
DOSERROR() Определяет номер последней ошибки DOS
-------------------------------------------------------------------

DOSERROR() -->вырN

Результаты

DOSERROR() возвращает ошибку DOS как целое числовое значение.

Применение

DOSERROR() возвращает код последней ошибки DOS. Значение функции
сохраняется до тех пор, пока не возникнет другая ошибка. Если
ошибочных ситуаций не было DOSERROR() возвращает 0.

Library: CLIPPER.LIB.

-------------------------------------------------------------------
DOW() Преобразование даты в номер дня недели
-------------------------------------------------------------------

DOW(<вырD>) -->вырN

Аргументы

<вырD> - значение даты для преобразования.

Результаты

DOW() возвращает число от 0 до 7. Первый день недели воскресенье,
последний седьмой - суббота. Если в качестве аргумента указана
пустая дата, то возвращается 0.

Применение

DOW() полезна для вычислений дат на основе дней недели.


182


Пример использования


Пример использования CDOW() и связь с DOW():

? DATE() // Результат: 09/01/89
? DOW(DATE()) // Результат: 3
? CDOW(DATE()) // Результат: Tuesday
? DOW(DATE() - 2) // Результат: 1
? CDOW(DATE() - 2) // Результат: Sunday

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

FUNCTION LastMonday(dDate)
RETURN (dDate - DOW(dDate) + 2)

Library: CLIPPER.LIB.

-------------------------------------------------------------------
DTOC() Преобразует дату в символьную строку
-------------------------------------------------------------------

DTOC(<вырD>) -->вырС

Аргументы

<вырD> - значение даты для преобразования.

Результаты

DTOC() возвращает символьную строку соответствующую дате и
учитывающую установки SET DATE и CENTURY. По умолчанию строка
выдается в формате "mm/dd/yy". Нулевая дата возвращает строку из 8
или 10 символов, в зависимости от установки SET CENTURY.

Применение

DTOC() полезна для форматирования дат при выводе на экран даты в
символьном формате, когда это требуется (например, в командах LABEL
FORM). Если вам требуется специальный формат даты, то вы можете
функцией TRANSFORM преобразовать ее в требуемое выражение.

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

Пример использования

? DATE() // Результат: 09/01/87
? DTOC(DATE) // Результат: 09/01/87
? "Сегодня дата:" + DTOC(DATE) // Результат: Сегодня дата: 09/01/87


183

-------------------------------------------------------------------
DTOS() Преобразование значения даты в формат символьной строки
-------------------------------------------------------------------

DTOS(<вырD>) -->вырС

Аргументы

<вырD> - значение даты для преобразования.

Результаты

DTOS() возвращает символьную строку 8 символов длинной в формате
"yyyymmdd". Нулевая дата возвращает строку из 8 пробелов.

Применение

DTOS() применяется для создания индексных ключей на основе поля
даты, независящие от SET DATE и SET CENTURY, в обратном порядке.

Пример использования

Пример использования DTOS() вместе с другими функциями:

? DATE() // Результат: 09/01/90
? DTOS(DATE()) // Результат: 19900901
? LEN(DTOS(CTOD(""))) // Результат: 8

Пример создания индексного файла, используя DTOS():

USE Sales NEW
INDEX ON DTOS(Date) + Salesman TO DateName

Library: CLIPPER.LIB.

-------------------------------------------------------------------
EMPTY() Определяет пустой ли результат выражения
-------------------------------------------------------------------

EMPTY(<выр>) -->вырL

Аргументы

<выр> - выражение любого типа данных.

Результаты

EMPTY() возвращает значение "истинно" (.T.), если результаты
выражения имеют пустые значения; в противном случае EMPTY()
возвращает "ложно" (.F.). Критерии определения пустых значений


184

зависят от типа данных и соответствуют следующим правилам:

Список пустых значений.
-----------------------------------------------------
Тип данных Содержание
-----------------------------------------------------
Массив 0-длина
Символ Нулевой или все пробелы
Число 0
Дата Нулевая(Null(CTOD(""))
Логическое .F.
NIL NIL
-----------------------------------------------------

Применение

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

Пример использования

Пример использования EMPTY() с различными типами данных:

? EMPTY(SPACE(5)), EMPTY("") // Результат: .T. .T.
? EMPTY(0), EMPTY(CTOD("")) // Результат: .T. .T.
? EMPTY(.F.), EMPTY(NIL) // Результат: .T. .T.

Пример использования EMPTY() для определения вводимых пользователем
значений в Get перед их записью в файл базы данных:

USE Sales NEW
LOCAL cCust := SPACE(15), nAmount := 0
@ 10, 10 GET cCust
@ 11, 10 GET nAmount PICTURE "999.99"
READ
//
IF !EMPTY(cCust)
APPEND BLANK
REPLACE Sales->Cust WITH cCust, nAmount WITH Sales->Amount
ENDIF

Пример использования EMPTY() как части предложения VALID :

LOCAL cCode := SPACE(5)
@ 2, 5 SAY "Enter code" GET cCode VALID !EMPTY(cCode)
READ

Library: CLIPPER.LIB.


185


-------------------------------------------------------------------
EOF() Возвращает "истинно" при попытке продвижения за конец файла
-------------------------------------------------------------------

EOF() -->вырL

Результаты

EOF() возвращает "истинно" (.T.) если вы попытались передвинуть
указатель записи за последнюю запись файла. При значении EOF()
"истинно", указатель записи указывает на запись с номером LASTREC()
+ 1. Это не зависит от команд активизации фильтра SET FILTER и SET
DELETED(). Другие попытки передвинуть указатель дальше LASTREC() + 1
выдают тот же результат без ошибки.

Если текущий файл базы данных не имеет записей, то EOF() принимает
значение "истинно" (.T.).

Применение

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

Пример использования

Пример использования EOF() при перемещении указателя записи:

USE Sales
GO BOTTOM
? EOF() // Результат: .F.
SKIP
? EOF() // Результат: .T.

Пример использования алиасного выражения :

USE Sales NEW
USE Customer NEW
? Sales->(EOF())
? Customer->(EOF())

Пример использования EOF() как части условия для выполнения операций
над файлом базы данных:

USE Sales INDEX CustNum NEW
DO WHILE !EOF()
nOldCust = Sales->CustNum
nTotalAmount := 0
DO WHILE nOldCust = Sales->CustNum .AND. (!EOF())
? Sales->CustNum, Sales->Description, Sales->SaleAmount
nTotalAmount += Sales->SaleAmount
SKIP


186

ENDDO
? "Всего: ", nTotalAmount
ENDDO

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ERRORBLOCK() Посылает блок для выполнения, когда случается ошибка
-------------------------------------------------------------------

ERRORBLOCK([<блок1>]) --> блок2

Аргументы

<блок1> блок для выполнения, когда происходит ошибка выполнения.

Результат

ERRORBLOCK() возвращает текущий блок управления ошибкой.

Применение

ERRORBLOCK() определяет управление ошибкой, когда она возникает.
Управление ошибкой указывается как блок следующей формы:

{ |<объект ошибки>| <список выражений>,... }

<объект ошибки> - объект ошибки, содержащий информацию об ошибке.
Внутри блока могут быть посланы сообщения в объект ошибки, чтобы
получить информацию об ошибке.

Управление блоком может быть определено как выражение или вызов
пользовательской функции. Лучше всего использовать вызов
пользовательской функции, так как здесь вы можете использовать
комманды управления Clip--------------------gt; выражение любого /p типа данных.Library: CLIPPER.LIB.-----------------------------------------------Library: CLIPPER.LIB.per. Блоки управления ошибками могут быть
использованы в комбинации с управлАргументыяющей структурой BEGIN SEQUENSE
... END.

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

Пример использования

Пример фрагмента, показывающий блок управления ошибки, который может
быть послан и затем вызван когда возникает ошибка внутри конструкции
BEGIN SEQUENCE:

LOCAL bErrorHandler, bLastHandler, objErr
bErrorHandler := { |objError| MyErrorHandler(objError) }
//


187

bLastHandler := ERRORBLOCK(bErrorHandler) // Сохранить текущее управление
//
BEGIN SEQUENCE
.
. <команды управления>
.
RECOVER USING objErrorInfo // Получение объекта ошибки из BREAK
.
. <комманды>
.
END
ERRORBLOCK(bLastHandler) // Восстановить управление
RETURN

FUNCTION MyErrorHandler( objError )
//
BREAK objError // Возвратить объект ошибки в RECOVER
RETURN NIL

Library: CLIPPER.LIB.

-------------------------------------------------------------------
ERRORLEVEL() Выдает уровень ошибки DOS
-------------------------------------------------------------------

ERRORLEVEL([<вырN>]) --> вырN


Аргументы

<вырN> - новый устанавливаемый уровень ошибки DOS. Это может быть
величина от 0 до 255.

Результат

ERRORLEVEL() возвращает текущий установленный уровень ошибки DOS. Если
указана без аргументов, то возвращает 0.

Применение

ERRORLEVEL() возвращает текущий установленный уровень ошибки DOS и
может установить уровень ошибки DOS на новую величину.

Код возврата устанавливается процессом "сыном" так, что
"родительский" процесс может проверить состояние окончания процесса
"сына". Обычно, "родительским" процессом является DOS, а процессом
"сыном" является прикладная программа. Код возврата может быть
восстановлен коммандой ERRORLEVEL, являющейся коммандой DOS.

Когда заканчивается программа Клиппер код возврата устанавливается в
1 и процесс завершается с фатальной ошибкой. Если процесс завершился
нормально, код возврата устанавливается равным 0 и последняя


188

ERRORLEVEL() устанавливается в программе.

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

Пример использования

Пример сохранения текущего кода возврата Клиппер и установка новых
значений:

nOldCode = ERRORLEVEL() // Сохранение
ERRORLEVEL(1) // Установка нового уровня ошибки

Пример установки кода возврата и проверки его в "родительском
процессе:"

#define ERR_FILE_MISSING 255
#define ERR_POST_INCOMPLETE 254
//
IF !FILE("Sysfile.dbf")
@ 0, 0
@ 1, 0
@ 0, 0 SAY "Fatal error: System file is missing...quitting"
ERRORLEVEL(ERR_FILE_MISSING)
QUIT
ENDIF

Library: CLIPPER.LIB.

-------------------------------------------------------------------
EVAL() Вычисляет блок
-------------------------------------------------------------------

EVAL(<блок>, [<список аргументов блока>]) --> значение блока

Аргументы

<блок> блок для вычисления.

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

Результат

EVAL() возвращает значение последнего выражения внутри блока. Блок
может возвратить значение любого типа.

Применение

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


189

Блок является специальным значением данных, и ссылается на часть
скомпилированного программного кода.

Для того, чтобы выполнить блок или вычислить его, вы можете вызвать
EVAL() со значением блока и любыми параметрами. Параметры заменяются
блоком, когда он вычисляется и возвращается значение последнего
выражения блока.

Пример использования

Пример создания блока, который увеличивает число и затем вычисляет
блок:

bBlock := { |nArg| nArg + 1 }
? EVAL(bBlock, 1) // Результат: 2

Пример использования макро оператора для комиляции блока:


bBlock := &("{ |nArg| nArg + 1 }") // Компиляция строки в блок
? EVAL(bBlock, 1) // Вычисление блока

Library: CLIPPER.LIB.

-------------------------------------------------------------------
EXP() Вычисляет экспоненту
-------------------------------------------------------------------

EXP(<вырN>) -->вырN

Аргументы

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

Результаты

EXP() возвращает значение по формату, установленному командами SET
DECIMALS и SET FIXED.

Применение

Применяется для вычисления "е" в степени "х". EXP() является обратной
функцией для LOG().

Пример использования

? EXP(1) // Результат: 2.72
SET DECIMALS TO 10
? EXP(1) // Результат: 2.7182818285
? LOG(EXP(1)) // Результат: 1.0000000000

190

Library: CLIPPER.LIB.

-------------------------------------------------------------------
FCLOSE() Закрыть файл DOS и записать буфер на диск
-------------------------------------------------------------------


FCLOSE(<вырN>) -->вырL

Аргументы

<вырN> - дискриптор файла, полученный из команды FOPEN() или
FCREATE().

Результаты

FCLOSE() возвращает значение "ложно" (.F.) если при записи произошла
ошибка, иначе возвращает "истинно" (.T.).

Применение

FCLOSE() используется для закрытия файлов и записи буфера DOS на диск.

-----------------------------------------------------------------------
ВНИМАНИЕ

Эта функция осуществляет низкоуровневый доступ к файлам и устройс-
твам DOS. Поэтому, используйте эту функцию внимательно и при хоро-
ших знаниях операционной системы.
-----------------------------------------------------------------------

Пример использования

Пример использования FCLOSE() для закрытия вновь созданного файла и
вывода сообщений, если файл закрылся с ошибкой:

#include "Fileio.ch"
//
nHandle = FCREATE("Testfile", FC_NORMAL)
IF !FCLOSE(nHandle)
? "Ошибка закрытия файла, номер ошибки: ", FERROR()
ENDIF

Library: CLIPPER.LIB.

-------------------------------------------------------------------
FCOUNT() Возвращает количество полей в структуре текущей базы данных
-------------------------------------------------------------------


FCOUNT() -->вырN

191

Результаты

FCOUNT() возвращает число полей файла базы данных, открытом в
текущей рабочей области, как целое число. Если нет открытого файла
базы данных, FCOUNT() возвращает 0.

Применение

FCOUNT() полезна для создания независимых от данных программ,
которые работают с любым файлом базы данных. Это, в основном,
программы обмена данными и вывода отчетов по базе. Обычно, с помощью
функции FCOUNT(), вы можете установить верхний предел в цикле
FOR/NEXT или DO WHILE для циклической обработки записей.

Для использования файла, открытого в в другой рабочей области,
используйте алиасное выражение.

Пример использования

Применение FCOUNT() в текущей рабочей области и в другой рабочей
области:

USE Sales NEW
USE Customer NEW
? FCOUNT() // Результат: 5
? Sales->(FCOUNT()) // Результат: 8

Применение FCOUNT() для создания массива с информацией о полях:

LOCAL aFields := ARRAY(FCOUNT())
AFIELDS(aFields)

Применение FCOUNT() в цикле FOR:

LOCAL nField
USE Sales NEW
FOR nField := 1 TO FCOUNT()
? FIELD(nField)
NEXT

Library: CLIPPER.LIB.

-------------------------------------------------------------------
FCREATE() Создает новый файл или обрезает существующий до нулевой длины
-------------------------------------------------------------------

FCREATE(<вырС>[,<вырN>]) -->вырN

Аргументы

<вырС> - имя создаваемого файла.

192

<вырN> - атрибуты DOS для файла.

Атрибуты файла для DOS.
____________________________________________________________________

Значение Fileio.ch Атрибут Описание
____________________________________________________________________

0 FC_NORMAL Нормальный Создать файл с чтение/запись
(по умолчанию)
1 FC_READONLY На чтение Создать файл только на чтение
2 FC_HIDDEN Спрятан Создать скрытый файл
3 FC_SYSTEM Системный Создать системный файл
_____________________________________________________________________

Результаты

FCREATE возвращает дискриптор файла в диапазоне от 0 до 63 535.
Если возникла ошибка выдает -1.

Применение

При успешном выполнении создает новый файл. Открывается файл на
чтение/запись.

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

FCREATE() создает файл в текущем каталоге. Команды SET DEFAULT и SET
PATH ее не учитываются и на ее работу не влияют.

-----------------------------------------------------------------------
ВНИМАНИЕ

Эта функция осуществляет низкоуровневый доступ к файлам и устройс-
твам DOS. Поэтому, используйте эту функцию внимательно и при хоро-
ших знаниях операционной системы.
-----------------------------------------------------------------------

Пример использования

Пример создания файла Testfile и открытия его на чтение и запись:

#include "Fileio.ch"
//
IF (nHandle := FCREATE("Testfile", FC_NORMAL)) = -1
? "Файл не может быть создан:" FERROR()
BREAK
ELSE
FWRITE(nHandle, "Привет Вам")
FCLOSE(nHandle)


193

ENDIF

Library: CLIPPER.LIB; Файл заголовка: Fileio.ch.

-------------------------------------------------------------------
FERASE() Удалить файл с диска
-------------------------------------------------------------------


FERASE(<выС>) --> вырN

Аргументы

<вырС> имя файла для удаления с диска. Имя файла должно быть
указано с расширением и может содержать маршрут.

Результат

FERASE() возвращает -1, если операция закончилась неуспешно и
возвращает 0, при успешном выполнении. FERROR() может быть
использована для определения ошибки.

Применение

FERASE() удаляет указанный файл с диска. FERASE() аналогична комманде
ERASE, но возвращает значение и может использоваться внутри
выражения. При вызове FERASE() удаляется указанный файл, если он
находится в текущем директории DOS или перед именем файла указан
маршрут. FERASE() не использует комманды SET DEFAULT или SET PATH.

-----------------------------------------------------------------------
Внимание

Файл должен быть закрыт перед использованием FERASE().
-----------------------------------------------------------------------

Пример использования

Пример удаления файлов:

#include "Directry.ch"
AEVAL(DIRECTORY("*.BAK"), { |aFile| FERASE(aFile[F_NAME]) })

Пример удаления файлов и вывода сообщений:

IF FERASE("AFile.txt") = -1
? "Ошибка удаления файла:", FERROR()
BREAK
ENDIF

Library: CLIPPER.LIB.

194

-------------------------------------------------------------------
FERROR() Проверяет ошибки DOS после окончания операции с DOS
-------------------------------------------------------------------


FERROR() --> вырN

Результаты

FERROR() возвращает ошибку DOS, появившуюся при последнем обращении
к DOS. Если ошибок нет, то возвращается ноль.

Значения, возвращаемые FERROR()
-----------------------------------------------------------------
Ошибка Действие
-----------------------------------------------------------------
0 Успешное выполнение
2 Файл не найден
3 Путь не найден
4 Слишком много файлов открыто
5 Отказ доступа
6 Неправильное управление
8 Недостаточно памяти
15 Неправильное указание устройства
19 Попытка записи при защите на запись
21 Устройство не готово
23 Ошибка данных CRC
29 Ошибка записи
30 Ошибка чтения
32 Нарушение совместного доступа в сети
33 Нарушение блокировки в сети
-----------------------------------------------------------------

Применение

FERROR() используется для выявления ошибок DOS после выполнения
файловых функций ( FCLOSE(), FCREATE(), FERASE(), FOPEN(), FREAD(),
FREADSTR(), и FRENAME(),FERROR() ), сохраняющих свое значение до тех
пор, пока не выполнится следующая файловая функция.

-----------------------------------------------------------------------
ВНИМАНИЕ

Эта функция осуществляет низкоуровневый доступ к файлам и устройс-
твам DOS. Поэтому, используйте эту функцию внимательно и при хоро-
ших знаниях операционной системы.
-----------------------------------------------------------------------

Пример использования

Применение FERROR() для проверки создания файла и вывода
сообщения, если произошла ошибка:


195


#include "Fileio.ch"
//
nHandle = FCREATE("Temp.txt", FC_NORMAL)
IF FERROR() != 0
? "Нельзя создать файл, ошибка DOS ", FERROR()
ENDIF

Library: CLIPPER.LIB.

-------------------------------------------------------------------
FIELD() Возвращает имя определенного поля в текущей базе данных
-------------------------------------------------------------------


FIELD(<вырN>) -->вырС

Аргументы

<вырN> - порядковый номер поля в структуре базы данных.

Результаты

Если номер <вырN> не содержится в структуре базы данных, то
возвращается нулевая строка ("").


Применение

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

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

LEN(SUBSTR(STR(<имя поля>),RAT(".", STR(<имя поля>)+1)

Для получения более подробной информации о полях используйте функцию
AFIELDS() или комманду COPY STRUCTURE EXTENDED.

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

Пример использования

Применение FIELD() с различными аргументами:

USE Sales


196

? FIELD(1) // Результат: BRANCH
? FCOUNT() // Результат: 5
? LEN(FIELD(0)) // Результат: 0
? LEN(FIELD(40)) // Результат: 0

Применение FIELD() при выводе списка полей в Customer.dbf:

USE Customer NEW
FOR nField := 1 TO FCOUNT()
? PADR(FIELD(nField), 10), VALTYPE(&(FIELD(nField)))
NEXT

Пример использования алиасного выражения:

USE Sales NEW
USE Customer NEW
USE Invoices NEW
//
? Sales->(FIELD(1)) // Результат: SALENUM
? Customer->(FIELD(1)) // Результат: CUSTNUM

Library: CLIPPER.LIB.

-------------------------------------------------------------------
FIELDBLOCK() Возвращает установленный блок для переменной поля EA
-------------------------------------------------------------------


FIELDBLOCK(<вырС>) --> блок

Аргументы

<вырС> имя поля в установленном блоке.

Результат

FIELDBLOCK() возвращает блок, когда происходит назначение или
переопределение значения поля. Если <вырС> не существует в указанной
рабочей области, FIELDBLOCK() возвращает NIL.

Применение

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

Эти же действия можно выполнить, используя макро-оператор.

Замечание

Рабочая область: Блок, возвращенный FIELDBLOCK() устанавливает или


197

принимает значение указанного поля в любой рабочей области, когда
выполняется блок. Например, две рабочие области (1 и 2) содержат
поле FName:

SELECT 1
FName:= "Kate"
SELECT 2
FName := "Cindy"

bFName := FIELDBLOCK("FName")

SELECT 1
? EVAL(bFName) // "Kate"
SELECT 2
? EVAL(bFName) // "Cindy"

Функция FIELDWBLOCK() выполняет установку или получает значения
блока в указанной рабочей области.


Пример использования

Пример сравнения создания блока макро-оператором и FIELDBLOCK().
Заметьте, что используя FIELDBLOCK() получается более компактная
запись:

// Установка блока, определенного макро-оператором
bSetGet := &( "{ |setVal| IF( setVal == NIL, FName, FName := setVal ) }" )

// Установка блока, используя FIELDBLOCK()
bSetGet := FIELDBLOCK("FName")

Library: CLIPPER.LIB.

-------------------------------------------------------------------
FIELDGET() Поиск значения переменной поля
-------------------------------------------------------------------


FIELDGET(<вырN>) -->выр

Аргументы

<вырN>- позиция поля в структуре записей текущей рабочей области.

Результат

FIELDGET() возвращает значение указанного поля. Если <вырN> не
соответствует позиции поля текущего файла базы данных, FIELDGET()
возвращает NIL.

Применение


198


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

Пример использования

Пример использования FIELDGET() и макро-оператора:

LOCAL nField := 1, FName, FVal
USE Customer NEW
//
// Применение макро-оператора
FName := FIELD( nField ) // Получить имя поля
FVal := &FName // Получить значение поля

// Применение FIELDGET()
FVal := FIELDGET( nField ) // Получить значение поля

Library: CLIPPER.LIB.

-------------------------------------------------------------------
FIELDPUT() Установить значение переменной поля EA
-------------------------------------------------------------------


FIELDPUT(<вырN>, <выр>) --> значение

Аргументы

<вырN> - порядковый номер поля в структуре базы данных.

<выр> значение, которое будет назначаться полю. Тип данных должен
соответствовать тиу поля.

Результат

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

Применение

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

Пример использования

Пример использования FIELDPUT() и макро-оператора:

// Применение макро-оператора


199

FName := FIELD(nField) // Получить имя поля
FIELD->&FName := FVal // Установить значение

// Using FIELDPUT()
FIELDPUT(nField, FVal) // Установить значение поля

Library: CLIPPER.LIB.

-------------------------------------------------------------------
FIELDWBLOCK() Возвратить блок для поля в рабочую область
-------------------------------------------------------------------


FIELDWBLOCK(<вырС>, <вырN>) --> блок

Аргументы

<вырС> - имя установленного блока поля, указывается символьной
строкой.

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

Результат

FIELDWBLOCK() возвращает блок, который назначает или получает
значение поля в указанной рабочей области. Если <вырС> в рабочей
области не существует FIELDWBLOCK() возвращает NIL.

Применение

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

Замечание

FIELDWBLOCK() аналогична FIELDBLOCK(), отличие в том, что
FIELDBLOCK() не имеет привязки к конкретной рабочей области.

Пример использования

Пример использования FIELDWBLOCK() и макро-оператора:

// Установить блок для рабочей области 1, определенный макро-оператором
bSetGet := &( "{ |setVal| IF( setVal == NIL, ;
1->FName, 1->FName := setVal ) }" )

// Установить блок, определенный FIELDWBLOCK()<R>


200

// bSetGet created here is the functional equivalent of bSetGet above
bSetGet := FIELDWBLOCK("FName", 1)

Другой прмер FIELDWBLOCK() может быть найден в TbDemo.prg,
(простейшая программа включенная в Клиппер 5.0, размещена в
\CLIPPER5\SOURCE).

Library: CLIPPER.LIB.

-------------------------------------------------------------------
FILE() Возвращает "истинно" при существовании указанного файла
-------------------------------------------------------------------


FILE(<вырС>) -->вырL

Аргументы

<вырС> - имя файла для поиска, включая расширение.

Если файл находится не в рабочей каталоге, то осуществляется его
поиск по установленному маршруту. Поиск по маршрутам, установленным
в DOS не осуществляется. Если вы не производили установку маршрута
поиска для Клиппер командой SET PATH, то вы должны указать маршрут,
включая устройство, как часть имени файла.

Результаты

Если файл существует, то FILE() возвращает значение "истинно" (.T.),
в противном случае - "ложно" (.F.).

Применение

FILE() полезна для определения существования файла с данным именем
файла перед запоминанием информации в нем или для определения
существования необходимого файла.

Пример использования

Пример поиска файла Sales.dbf в директории, отличном от директория
Clipper:

? FILE("Sales.dbf") // Результат: .F.
? FILE("\APPS\DBF\Sales.dbf") // Результат: .T.
//
SET PATH TO \APPS\DBF
? FILE("Sales.dbf") // Результат: .T.
//
SET PATH TO
SET DEFAULT TO \APPS\DBF\
? FILE("Sales.dbf") // Результат: .T.
? FILE("*.dbf") // Результат: .T.


201


Library: CLIPPER.LIB.

-------------------------------------------------------------------
FKLABEL()* Возвращает имя функциональной клавиши
-------------------------------------------------------------------


FKLABEL(<вырN>) --> вырC

Результат

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

Применение

FKLABEL() - совместимая функция и используется для замены функции
dBASE III PLUS FKLABEL().

Применение этой функции в Клиппер не рекомендовано.

Library: CLIPPER.LIB; Исходный текст: Examplep.prg.

-------------------------------------------------------------------
FKMAX()* Возвращает номер функциональной клавиши как константу
-------------------------------------------------------------------


FKMAX() --> вырN

Применение

FKMAX() - совместимая функция для замены функции dBASE III PLUS
FKMAX().

Применение в Клиппер не рекомендовано.

Library: EXTEND.LIB; Исходный текст: Examplep.prg.

-------------------------------------------------------------------
FLOCK() Блокирует файл используемый в режиме разделения
-------------------------------------------------------------------


FLOCK() --> вырL

Результаты

Если попытка блокировки файла базы данных, используемого в текущей


202

рабочей области осуществилась удачно, то функция возвращает значение
"истинно" (.T.), иначе "ложно" (.F.).

Применение

Заблокированный файл остается в таком состоянии до тех пор, пока вы
не выполните команды UNLOCK, CLOSE DATABASE или RLOCK().

Пример использования

Пример использования алиасного выражения для блокировки файла в
другой рабочей области:

USE Sales NEW
USE Customer NEW
//
IF Sales->(FLOCK())
? "Файл заблокирован"
ENDIF

Library: CLIPPER.LIB.

-------------------------------------------------------------------
FOPEN() Открывает файл
-------------------------------------------------------------------


FOPEN(<вырС>, [<вырN>]) -->вырN

Аргументы

<вырС> - имя файла, который будет открываться.

<вырN> - запрашиваемые из DOS режимы доступа к файлу при открытии.
По умолчанию - режим 0 (только чтение).

Режимы доступа к файлам.
----------------------------------------------------
Режим открытия Fileio.ch Действия
----------------------------------------------------
0 FO_READ Только чтение
1 FO_WRITE Только запись
2 FO_READWRITE Чтение/запись
----------------------------------------------------

Результаты

FOPEN() возвращает дискриптор открытого файла в диапазоне от 0 до 65
535. При ошибке открытия выдает значение -1.

Применение

203

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

Доступ к файлам в других каталогах. Функция FOPEN() не повинуется
командам SET DEFAULT и SET PATH, устанавливающим пути поиска.
Напротив, она производит поиск только в текущем каталоге, если
установлены этими командами пути поиска.


-----------------------------------------------------------------------
ВНИМАНИЕ

Эта функция осуществляет низкоуровневый доступ к файлам и устройс-
твам DOS. Поэтому, используйте эту функцию внимательно и при хоро-
ших знаниях операционной системы.
-----------------------------------------------------------------------

Пример использования

Пример использования FOPEN() для открытия файла на чтение/запись и
вывод сообщений об ошибке открытия:

#include "Fileio.ch"
//
nHandle = FOPEN("Temp.txt", FO_READWRITE)
IF FERROR() != 0
? "Нельзя открыть файл, DOS ошибка ", FERROR()
BREAK
ENDIF

Library: CLIPPER.LIB; Файл заголовка: Fileio.ch.

-------------------------------------------------------------------
FOUND() Определяет успех операций поиска записей
-------------------------------------------------------------------


FOUND() -->вырL

Результаты

FOUND() возвращает значение (.T.) если последняя команда поиска была
успешной.

Каждая рабочая область имеет свой флаг для функции FOUND(). Это
означает, что, если рабочая область имеет установленные со
вспомогательной рабочей областью отношения, то запрос FOUND() во
вспомогательной рабочей области выдает значение (.T.) при
соответствии ключевого значения текущей связи из основной рабочей
области.


204


Помните, что все другие команды поиска изменяют значение функции
FOUND() на "ложно" (.F.). Это означает, что команда SKIP не может
использоваться вместе с FOUND().

Применение

Функция FOUND() полезна для определения результата поиска перед
выполнением следующего шага программы.

Пример использования

Пример использования FOUND() для проверки поиска:

USE Sales INDEX Sales
? INDEXKEY(0) // Result: SALESMAN
SEEK "1000"
? FOUND() // Result: .F.
SEEK "100"
? FOUND() // Result: .T.
SKIP
? FOUND() // Result: .F.

Пример использования FOUND() с указанием алиасного выражения для
доступа к другой рабочей области:

USE Sales INDEX Sales NEW
USE Customer INDEX Customer NEW
SET RELATION TO CustNum INTO Sales
//
SEEK "Smith"
? FOUND(), Sales->(FOUND())

Пример обработки записей в файле Customer со значением
"Smith":

USE Customer INDEX Customer NEW
SEEK "Smith"
DO WHILE FOUND()
.
. <комманды>
.
SKIP
LOCATE REST WHILE Name = "Smith"
ENDDO

Library: CLIPPER.LIB.

-------------------------------------------------------------------
FREAD() Читает символы из файла в переменную памяти символьного типа
-------------------------------------------------------------------

205


FREAD(<вырN1>,@<перемС>,<вырN2>) -->вырN

Аргументы

<вырN1> - дискриптор файла, полученный при открытии файла функциями
FOPEN(), FCREATE() или определенный в DOS.

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

<вырN2> - количество байтов для чтения в буфер начиная с текущего
указателя DOS места чтения файла. Значение, возвращаемое функцией
FREAD() при успешном чтении должно равняться значению <вырN2>.

Результаты

FREAD() возвращает количество реально считанных байтов. Нулевое
значение выдается при обнаружении конца файла или ошибки чтения.

Применение

Функция FREAD() читает файл с текущего положения указателя места
чтения файла. Помните, что FREAD() читает все символы из файла,
включая управляющие, ноль и графические (свыше CHR(127)).

Для перемещения указателя места чтения файла используйте функцию
FSEEK().

-----------------------------------------------------------------------
ВНИМАНИЕ

Эта функция осуществляет низкоуровневый доступ к файлам и устройс-
твам DOS. Поэтому, используйте эту функцию внимательно и при хоро-
ших знаниях операционной системы.
-----------------------------------------------------------------------

Пример использования

Пример использования FREAD() после успешного открытия файла на
чтение с 128 байтами в области буфера:

#define F_BLOCK 128
//
cBuffer = SPACE(F_BLOCK)
nHandle = FOPEN("Temp.txt")
//
IF FERROR() != 0
? "Ошибка открытия файла, ошибка:", FERROR()
ELSE
IF FREAD(nHandle, @cBuffer, F_BLOCK) <> F_BLOCK


206

? "Ошибка чтения Temp.txt"
ENDIF
ENDIF

Library: CLIPPER.LIB.

-------------------------------------------------------------------
FREADSTR() Читает символы из файла DOS
-----------------pbr /p--------------------------------------------------


FREAbr /br /DSTR(<вырN1>,<вырN2>) -->вырС

Аргументы

<вырN1> - дискриптор файла, полученный при открытии файла функциями
FOPEN(), FCREATE() или определенный в DOS.

<вырN2> - количество байт для чтения, начиная с текущей позиции
указателя места чтения файла. Значение может быть положительным или
отрицательным в зависимости от направления (вперед или назад) чтения
от указателя места чтения.

Результаты

FREADSTR() возвращает строку длинной до 65 535 (64 Кб) байт. Нулевая
строка означает конец файла или ошибки чтения.

Применение

Функция FREADSTR() читает с текущего положения указателя места
чтения файла количество <вырN2> байт или пока не обнаружит нулевой
символ (код ASCII - 0). Также, как FREAD() будут считываться все
символы, включая управляющие.

-----------------------------------------------------------------------
ВНИМАНИЕ

Эта функция осуществляет низкоуровневый доступ к файлам и устройс-
твам DOS. Поэтому, используйте эту функцию внимательно и при хоро-
ших знаниях операционной системы.
-----------------------------------------------------------------------

Пример использования

Следующий пример выводит на экран коды ASCII 16 первых байтов файла с
именем New.txt:

#include "Fileio.ch"
//
nHandle = FOPEN("New.txt", FC_NORMAL)
IF FERROR() != 0


207

? "Ошибка открытия файла:" FERROR()
BREAK
ELSE
cString = FREADSTR(nHandle, 16)
? cString
FCLOSE(nHandle)
ENDIF

Library: CLIPPER.LIB.

-------------------------------------------------------------------
FRENAME() Изменяет имя файла
-------------------------------------------------------------------


FRENAME(<вырС1>, <вырС2>) --> вырN

Аргументы

<вырC1> старое имя файла для переименования, включая расширение.
Маршрут для поиска может быть указан как часть имени.

<вырС2> новое имя файла, включая расширение. Возможно указание
маршрута как части имени.

Результат

FRENAME() возвращает -1, если операция закончилась с ошибкой и
возвращает 0, если операция закончилась успешно. В этом случае с
помощью FERROR() можно определить ошибку.

Применение

FRENAME() изменяет имя указанного файла на новое имя и выполняется
аналогично комманде RENAME. FRENAME() ищет файлы в текущем каталоге
или по указанным маршрутам и не использует комманды SET DEFAULT или
SET PATH. Если уже существует файл с именем <вырС2> или он открыт
возникает ошибка, и функция возвращает -1.

-----------------------------------------------------------------------
ВНИМАНИЕ

Файлы должны быть ЗАКРЫТЫ перед переименованием.
-----------------------------------------------------------------------

Пример использования

Пример переименования файла:

IF FRENAME("OldFile.txt", "NewFile.txt") = -1
? "File error:", FERROR()
BREAK


208

ENDIF

Library: CLIPPER.LIB.

-------------------------------------------------------------------
FSEEK() Устанавливает указатель места чтения файла на новую позицию
-------------------------------------------------------------------


FSEEK(<вырN1>,<вырN2>,[<вырN3>]) -->вырN

Аргументы

<вырN1> - дискриптор файла, полученный при открытии файла функциями
FOPEN(), FCREATE() или определенный в DOS.

<вырN2> - количество байтов для перемещения указателя начиная с
текущей как определено аргументом <вырN3>. Оно может быть положи-
тельным или отрицательным в зависимости от направления перемещения
указателя.

<вырN3> - определяет способ перемещения указателя и может принимать
следующие значения:

Способы перемещения указателя места чтения файла.
--------------------------------------------------
Способ Fileio.ch Описание
--------------------------------------------------
0 FS_SET Начало файла
1 FS_RELATIVE Текущая позиция
2 FS_END Конец файла
--------------------------------------------------

По умолчанию применяется способ 0.

Результаты

FSEEK() возвращает новую позицию указателя относительно начала файла.


Применение

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

-----------------------------------------------------------------------
ВНИМАНИЕ

Эта функция осуществляет низкоуровневый доступ к файлам и устройс-
твам DOS. Поэтому, используйте эту функцию внимательно и при хоро-
ших знаниях операционной системы.


209

-----------------------------------------------------------------------

Пример использования

Применение FSEEK() для определения длины файла:

#include "Fileio.ch"
//
// Открыть файл только на чтение
IF (nHandle := FOPEN("Temp.txt")) >= 0
//
// Получить длину файла
nLength := FSEEK(nHandle, 0, FS_END)
//
// Установить указатель в начало файла
FSEEK(nHandle, 0)
ELSE
? "Ошибка открытия файла:", FERROR()
BREAK
ENDIF

Library: CLIPPER.LIB.; Файл заголовка : Fileio.ch.

-------------------------------------------------------------------
FWRITE() Записывает буферизированную переменную в заданный файл DOS
-------------------------------------------------------------------


FWRITE(<вырN1>,<перемС>[,<вырN2>]) -->вырN

Аргументы

<вырN1> - дискриптор файла, полученный при открытии файла функциями
FOPEN(), FCREATE() или определенный в DOS.

<перемС> - имя существующей символьной переменной памяти
используемой как буфер вывода.

<вырN2> - количество байтов для записи из буфера начиная с текущей
позиции указателя места записи в файл. Если этот аргумент опущен, то
записывается все содержимое переменной <перемС>.

Результаты

FWRITE() возвращает количество записанных байтов. Если выдается 0,
то, значит, переполнен диск или возникла ошибка записи. Проверьте
возникшую ошибку функцией FERROR(). При успешной записи,
возвращаемое значение должно равняться значению <вырN2>.

Применение

FWRITE() используется для записи данных в открытый файл из буфера. Вы


210

можете записать часть или весь буфер.
-----------------------------------------------------------------------
ВНИМАНИЕ

Эта функция осуществляет низкоуровневый доступ к файлам и устройс-
твам DOS. Поэтому, используйте эту функцию внимательно и при хоро-
ших знаниях операционной системы.
-----------------------------------------------------------------------

Пример использования

Пример копирования содержимого файла в другой файл:

#include "Fileio.ch"
#define F_BLOCK 512
//
cBuffer = SPACE(F_BLOCK)
nInfile = FOPEN("Temp.txt", FO_READ)
nOutfile = FCREATE("Newfile.txt", FC_NORMAL)
lDone = .F.
//
DO WHILE !lDone
nBytesRead = FREAD(nInfile, @cBuffer, F_BLOCK)

IF FWRITE(nOutfile, cBuffer, nBytesRead) < nBytesRead
? "Ошибка записи: ", FERROR()
lDone = .T.
ELSE
lDone = (nBytesRead == 0)
ENDIF
ENDDO
//
FCLOSE(nInfile)
FCLOSE(nOutfile)

Library: CLIPPER.LIB.

-------------------------------------------------------------------
GETACTIVE() Возвращает текущий активный Get объект EA
-------------------------------------------------------------------


GETACTIVE() --> Getобъект

Результат

GETACTIVE() возвращает текущий активный Get объект внутри текущего
READ. Если READ не активен при вызове GETACTIVE(), возвращается NIL.

Применение

GETACTIVE() обеспечивает доступ к активному GET объекту во время


211

выполнения READ.

Пример использования

@ 10, 10 GET x
@ 11, 10 GET y WHEN MyReader()
@ 12, 10 GET z
READ

//
FUNCTION MyReader
LOCAL objGet // Активный Get
objGet := GETACTIVE() // Поиск текущего активного Get
BarCodeRead( objGet )
RETURN (.F.) // Пропуск Get в READ

Library: CLIPPER.LIB.; Исходный текст: Getsys.prg.

-------------------------------------------------------------------
GETENV() Поиск содержимого переменной окружения DOS
-------------------------------------------------------------------


GETENV(<вырС>) --> вырС

Аргументы

<вырС> имя переменной среды DOS . Когда указан этот аргумент,
вы можете использовать любую комбинацию комбинацию из букв верхнего и
нижнего регистра.

Результат

GETENV() возвращает содержимое указанной переменной среды DOS как
символьную строку. Если переменная не найдена, GETENV() возвращает
пустую строку ("").

Применение

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

Замечание

Пустое возвращаемое значение: Если вы уверены, что переменная среды
DOS существует, но GETENV() возвратила нулевую строку (""),
проверьте написание комманды DOS SET.

Совместимость: В предыдущих версиях Clipper, эта функция называлась
GETE().

212

Пример использования

Пример поиска текущей установки DOS PATH :

cPath = GETENV("PATH")
SET PATH TO (cPath)

Пример использования переменных среды для указания спецификации
файлов:

SET LOC_DBF=<database file path>
SET LOC_NTX=<index file path>
SET LOC_RPT=<report file path>

В программе можно присвоить значение переменных окружения другим
переменным для дальнейшего использования в программе:

cDdfDirectory = GETENV("LOC_DBF")
USE (cDdfDirectory + "Invoices")

Library: CLIPPER.LIB.
-------------------------------------------------------------------
HARDCR() Замена "мягких" символов перевода строки на "твердые"
-------------------------------------------------------------------


HARDCR(<вырC>) -->вырС

Аргументы

<вырС> - символьная строка или поле памяти для преобразования.

Результаты

HARDCR() возвращает строку длинной до 65 535 (64 Кб) символов.

Применение

Полезна для вывода полей памяти с автоматическим переносом слов,
отформатированных функцией MEMOEDIT.

Пример использования

USE Sales NEW
? HARDCR(Sales->Notes)

Library: CLIPPER.LIB.

-------------------------------------------------------------------
HEADER() Определяет размер области заголовка файла базы данных
-------------------------------------------------------------------

213


HEADER() -->вырN

Результаты

HEADER() возвращает количество байтов заголовка текущего файла базы
данных.

Применение

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

Пример использования

USE Sales NEW
? HEADER() // Результат: 258

Library: CLIPPER.LIB.