Техника доступа к информации записанной в файле
Как известно из курса информатики изученного Вами, файл данных представляет собой последовательность компонент. Длиной файла называется число записанных компонент. Файл, не содержащий компонент, называется пустым, его длина равна 0.
Традиционная система программирования разбивает файлы данных на так называемые записи, каждая из которых состоит из одного или нескольких полей. Другими словами, совокупность логически связанных полей данных называется логической записью. Например, в программе с почтовым перечнем имеется три записи:
Имя/фамилия Город Улица Дом Квартира Вклад
____________________________________________________________________________
Иванов И.И. Воронеж Минская 1 12 73 .000
Петров В.В. Москва Строительная 2 2 500.000
Сидоров А.А. Калуга Лесная 6 5 81 0.000
_____________________________________________________________________________
Каждая запись состоит из 6 полей. Обычно делается различие между числовыми и цепочными полями. В этом примере три поля - числовые, остальные - цепочные.
Одна или несколько логических записей образуют блок, являющийся физической единицей данных и называемый иногда физической записью. Операции ввода-вывода выполняются на уровне блоков, а не на уровне логических записей. Процесс объединения логических записей в блок называется блокированием, и, наоборот, процесс разбиения считанного блока на отдельные логические записи называется деблокированием. Область основной памяти, используемая при обмене данными между внешней и оперативной памятью, называется буфером. Совокупность буферов образует буферный пул. Процесс управления буферным пулом, осуществляемый при выполнении операций ввода-вывода, называется буферизацией. Блокирование, деблокирование и буферизация входят в состав функций методов доступа.
К основным методам доступа относятся методы последовательного доступа, прямого доступа и индексно-последовательного доступа. Каждый из них имеет свои преимущества и недостатки, и выбор того или иного вида доступа зависит от конкретных условий задачи. Метод последовательного и прямого доступа рассмотрим применительно к языку Турбо-Бейсик, а для индексно-последовательного доступа рассмотрим основные понятия.
Метод последовательного доступа
Обработка файлов по принципу последовательных наиболее проста. Все данные в этом файле должны содержать текстовую информацию и разделяться стандартными разделителями текста (возврат каретки, запятые и т.п.), в связи с чем этот тип файлов совместим с файлами текстовых редакторов и может легко переноситься на другие типы компьютеров.
Для записи данных в файл необходимо выполнить последовательность:
1. Открыть файл (команда OPEN) в режиме записи (режим OUTPUT - запись в начало или режим APPEND - дозапись в конец).
OUTPUT : если файл не существует, то создается новый файл, в противном случае он стирается и затем файл обрабатывается как новый.
APPEND : если файл не существует, то создается новый файл, в противном случае данные дозаписываются в конец файла.
2. Вывести данные в файл, используя операторы WRITE #, PRINT #, PRINT #, USING.
3. После завершения работы с файлом закрыть его оператором CLOSE.
Для считывания последовательного файла:
1. Открыть файл (оператор OPEN) в режиме чтения (режим INPUT).
2. Считать данные из файла, используя операторы INPUT #, INPUT$, LINE, INPUT#.
3. После завершения работы с файлом закрыть его оператором CLOSE.
Недостаток этого метода заключается в последовательном просмотре записей файла, начиная с первой записи, т.е. если Вы хотите добраться к последней записи файла, состоящего из 23000 записей, то Вы должны прежде просмотреть предыдущие 22999 записи.
Последовательные файлы, поэтому, лучше всего подходят для решения задач последовательной обработки данных или когда все данные могут храниться при обработке в памяти ЭВМ. Это позволит Вам целиком считать весь файл (например в массив), быстро откорректировать его, а затем записать обратно на диск.
Но в то же время этот метод позволяет создавать записи переменной длины, что бывает иногда очень важно. При использовании Turbo-Basic могут создаваться два типа последовательных файлов:
последовательный файл с ограниченным полем, где каждое поле в каждой строке файла ограничивается специальным знаком;
файлы с неограниченным размером поля.
Эти типы создаются операторами WRITE # и PRINT # соответственно.
Способ чтения из этих файлов одинаковый.
Последовательные файлы с ограниченным полем.
При рассмотрении последовательного файла видно, что данные в файле разделяются запятыми и любые цепочки заключаются в двойные кавычки (кавычки предохраняют Вас от хлопот с вкрапленными запятыми в цепочке). Рассмотрим формирование и внутреннее представление последовательного файла ADD.BAS:
OPEN "ADD.BAS" FOR OUTPUT AS #1
String$="This is a string of text"
Integer%=1000
Floating!=30000.1234
WRITE #1,String$,Integer%,Floating!
String$="Appol"
Integer%=-32767
Floating!=12345.54296875
WRITE #1,Integer%,String$,Floating!
CLOSE #1
END
Содержимое файла ADD.BAS:
"This is a string of text",1000,30000.1234
-32767,"Appol",12345.54296875
Самым важным здесь является то, что оператор WRITE # записывает данные в том виде, в котором оператор INPUT # хочет их найти.
Следующая программа считывает данные из последовательного файла:
OPEN "ADD.BAS" FOR INPUT AS #1
String$="":Integer%=0:Floating!=0
INPUT #1,String$,Integer%,Floating!
PRINT String$,Integer%,Floating!
String$="":Integer%=0:Floating!=0
INPUT #1,Integer%,String$,Floating!
PRINT Integer%,String$,Floating!
CLOSE #1
END
Важно заметить,что программа не будет работать правильно,если файл был сформирован с помощью команды PRINT #,а не WRTIE #.
Неограниченные последовательные файлы.
Данные в этих файлах представлены так, как они выглядят на экране дисплея ил после печати:
OPEN "ADD.BAS" FOR OUTPUT AS #1
String$="This is a string of text"
Integer%=1000
Floating!=30000.1234
PRINT #1,String$,Integer%,Floating!
String$="Appol"
Integer%=-32.767
Floating!=12345.54296875
PRINT #1,USING "+##### & ##.##^^^^;Integer%,String$,Floating!
CLOSE #1
END
Содержимое файла ADD.BAS:
This is a string of text 1000 30000.1234
-32767 Appol 12.35E+03
Если Вы попытаетесь считать данные из этого файла с помощью оператора INPUT #1, String$, Integer%, Floating!, то в строковую переменную будет считано слово This, а затем программа попытается считать числовое значение, наткнется на цепочку is и выдаст ошибку. Поэтому прменим здесь другие операторы для считывания:
OPEN "ADD.BAS" FOR INPUT AS #1
String$=""
String$=INPUT$(80,1)
PRINT String$
LINE INPUT #1,String$
PRINT String$
CLOSE #1
END
Сведем операторы и функции Turbo-Basic,управляющие последовательными файлами, в таблицу:
Оператор/функция Операция
CLOSE Оканчивает операции на файле(ах)
EOF Сигнализирует о достижении конца файла
INPUT # Считывает запись (строку текста) в указанную переменную(ые)
INPUT$ Считывает n знаков в цепочную переменную
LINE INPUT # Считывает целую строку в цепочную переменную
OPEN Открывает файл для режима INPUT,OUTPUT,APPEND и присваивает
ему номер
PRINT #, Заносит данные в файл без ограничительных запятых
PRINT # USING
WRITE # Заносит данные в файл без ограничительных запятых
__________________________________________________________________________________
Описание этих операторов представлено ниже
CLOSE Закрывает файл или устройство.
Синтаксис: CLOSE [[#]filenum[, [#]filenum]...]
Комментарии: filenum - номер файла, который надо закрыть.
CLOSE прерывает соответствие между номером файла и файлом, установленное оператором OPEN, и закрывает файл. CLOSE без аргументов закрывает все файлы и устройства.
EOF сигнал достижения конца файла
Синтаксис: EOF(номер_файла)
Комментарии: номер_файла - номер файла из которого происходит считывание данных.
Функция EOF возврщает -1 («истина»), если указатель в файле последовательного доступа дошел до его конца. Эта функция может использоваться для тестирования конца файла при вводе данных - для того, чтобы избежать ошибки.
INPUT# считывает данные из последовательного файла.
Синтаксис: INPUT filenum, variable list
Комментарии filenum - номер, под которым был открыт файл
variable list - одна или несколько разделенных запятыми строковых или числовых переменных, в которые INPUT# считывает данные.
Файл может быть дисковым файлом, последовательным портом COM(n) или клавиатурой KYBD. Данные в файле должны соответствовать типу переменных в variable list и разделяться запятыми или символом возврата каретки (так записывает данные оператор WRITE#).
INPUT$ считывает заданное число символов с клавиатуры или файла.
Синтаксис: s$=INPUT$ (n, [, [#]filenum])
Комментарии: n - число символов, которое необходимо считать из файла
filenum. - номер файла.
Если filenum опущен, происходит ввод с клавиатуры, при этом вводимые знаки отсылаются в строку, а не на экран. Достоинство INPUT$ состоит в том, что он позволяет считывать все знаки, включая и управляющие коды. Но при нажатии клавиши, не имеющей кода а ASCII, возвращается CHR$(0).
LINE INPUT# считывает строку из последовательного файла в строковую переменную, игнорируя ограничители.
Синтаксис: LINE INPUT #filenum,string variable
Комментарии: filenum - номер файла,строка из которого считывается в строковую переменную string variable с игнорированием ограничительных запятых в тексте.
OPEN готовит файл или устройство для считывания или записи.
Синтаксис: OPEN filespec [FOR mode] AS [/] filenum [LEN=record size]
OPEN mode string,[/] filenum,filespec [record size]
Комментарии: mode - один из:
OUTPUT - определяет последовательный файл для записи в него.
INPUT - определяет последовательный файл для считывания из него.
APPEND - определяет последовательный файл для дозаписи в конец файла.
RANDOM - определяет файл прямого считывания для чтения или записи.
BINARY - определяет двоичный файл для чтения или записи.
mode string - строковое выражение, первым знаком в котором (и обычно единственным) служит один из следующих:
O - определяет режим последовательного вывода.
I - определяет режим последовательного ввода.
A - определяет режим последовательного вывода в конец файла.
R - определяет режим случайных входных/выходных сигналов.
B - определяет режим двоичного входа/выхода.
filenum может служить любое целое число. Для изменения этого числа служит оператор FILES в файле CONFIG.SYS в DOS.
filespec - строковое выражение, определяющее спецификацию файла.
record size - целочисленное выражение в пределах от 1 до 32767, определяющее длину записи в файле прямого доступа (умолчание составляет 128 байт).
Оператор OPEN осуществляет связь между числом (filenum) и файлом или физическим устройством и подготовку устройства для считывания или записи. В дальнейшем в операторах и функциях, работающих с файлами, вместо имен файлов используется указанное число (filenum). OPEN указывает на тип файла: с произвольным доступом, двоичный или файл с последовательным доступом (причем для последнего указывается режим работы: чтение или запись). Аннулирует действия оператора OPEN оператор CLOSE, закрывающий файл.
PRINT # и PRINT # USING записывают форматированную информацию в файл.
Синтаксис: PRINT #filenum, [USING format string;]expression list[;]
Комментарии: filenum - номер открытого файла.
format string - необязательная последовательность форматируемых знаков (описаны в операторе PRINT USING).
expression list - последовательность числовых и/или строковых выражений, выводимых в файл.
PRINT # пересылает информацию в файл таким же образом, как PRINT пересылает ее на экран. Т.к. оператор INPUT # требует разделения значений запятой, то в операторе PRINT # надо разделять данные:
PRINT #1,1","2","3
При этом в файле будет записано: 1 , 2 , 3
Оператор WRITE # автоматически разделяет данные, выводимые в файл, запятыми.
WRITE# выводит данные в последовательный файл.
синтаксис WRITE# N_файл, список выражений
Коментарии N_файл - это число, ассоциируемое с устройством или файлом в момент открывания файла.
Список выражений - это последовательность числовых и/или строчных выражений, разделяемых запятыми или точками с запятой.
WRITE# подобно PRINT# за исключением того, что WRITE# вставляет запятые между элементами списка выражений, выдает строчные данные внутри двойных кавычек и не выводит пробел перед положительным числом. WRITE# является предпочтительным способом записи полей данных в последовательный файл, поскольку этот оператор обеспечивает автоматическое разделение переменных запятыми и простановкой кавычек с обеих сторон строк. Это упрощает использование оператора INPUT#, когда осуществляются выписки из файла.
Файлы с произвольным доступом
Этот тип файлов состоит из записей, доступ к которым возможен в любой последовательности. Места под данные эти файлы занимают меньше, т.к. хранимые на диске данные не преобразуются в коды ASCII.
Вообще говоря, файлы с этой организацией более привлекательны для баз данных, чем файлы с последовательным доступом, хотя и они не лишены недостатков: Вы не можете заглянуть внутрь этих файлов с помощью редактора текстов или вывести их на печать, сохраняя при этом смысл файла. Перенос этих файлов на другие компьютеры или языки возможно потребует их дополнительной трансляции. Например, интерпретирующий Basic использует нестандартный формат MICROSOFT для значений с плавающей запятой, а Turbo-Basic - стандартное соглашение IEEE. Поэтому файлы с произвольным доступом Basic и Turbo-Basic не совместимы друг с другом.
Мы имеем четыре специальные функции для решения этой проблемы:
CVMS и CVMD для преобразования числовых полей формата MICROSOFT в числа с одинарной и двойной точностью, и MKMS$ и MKMD$ для превращения значений одинарной и двойной точности в цепочки формата MICROSOFT.
Основным преимуществом файлов с произвольной организацией является свободный доступ к любой записи файла без каких-либо затруднений.
В то же время эти файлы «расточительны» на предмет пространства диска, т.к. размер записей файла устанавливается одинаковым и равным длине самой длинной записи. Но при записи чисел файлы с произвольной выборкой позволяют сэкономить дисковое пространство, т.к. числа одного типа занимают на диске строго определенное пространство, в то время как в файле последовательного доступа числа требуют столько байт, сколько они имеют знаков в коде ASCII.
При работе с файлами произвольного доступа необходимо следовать правилам:
1. Открыть файл и определить длину каждой записи:
OPEN filespec AS [#] filenum LEN = record.size
Параметр LEN указывает, что файл открывается для произвольного доступа. После открытия файла Вы можете читать с него информацию или записывать ее.
2. Выполнить оператор FIELD для определения размеров полей записи:
FIELD filenum,width AS string-var [width AS string-var] ...
По результатам работы оператора FIELD формируется буфер обмена между диском и ОЗУ.
3. Перед записью данных на диск заполните буфер обмена с помощью операторов LSET и RSET. Числа перед этой операцией должны преобразовываться в цепочки с помощью соответствующих функций. После заполнения полей записи используйте оператор PUT для записи данных на диск.
4. Для считывания данных из файла в буфер используйте оператор GET. При выборке данных из буфера преобразуйте числовые данные из цепочной формы.
По окончании работы закройте файл (CLOSE).
Сведем операторы и функции Turbo-Basic, управляющие файлами произвольного доступа в таблицу:
Оператор/функция Операция
CLOSE Оканчивает операции на файле(ах)
CVI,CVL,CVS,CVD Преобразует цепочку знаков в соответствующий числовой тип
FIELD Определяет размеры полей записи
GET Считывает запись
LOC Определяет номер последней считанной записи
LSET,RSET Подготовка поля для записи
MKI$,MKL$,MKS$, Преобразует соответствующие числовые типы в строки
MKD$
MKMS$,MKMD$, Функции трансляции формата MICROSOFT
CVMS,CVMD
OPEN Открывает файл для чтения/записи
PUT Записывает запись
____________________________________________________________________________________
CVI, CVL, CVS, CVD-функции Преобразуют считанные с файлов произвольного доступа строковые данные в числовую форму.
Синтаксис: y%=CVI(2-byte string)
y&=CVL(4-byte string)
y!=CVS(4-byte string)
y#=CVD(8-byte string)
Комментарии: CVI преобразует 2-байтовую цепочку в целое число.
CVL преобразует 4-байтовую цепочку в расширенное целое число.
CVS преобразует 4-байтовую цепочку в значение с одинарной точностью.
CVD преобразует 8-байтовую цепочку в значение с удвоенной точностью.
FIELD Определяет поля в буфере файла с произвольным доступом
Синтаксис: FIELD [ #] filenum, width AS string var [width AS string var] ...
Комментарии: filenum - номер, под которым был открыт файл
width(ширина) - число байт, отводимое в буфере под переменную поля.
string var - сама переменная поля.
FIELD определяет соответствие между строковыми значениями и входным-выходным буфером файла с произвольной выборкой. Использованные в этом операторе строки могут теперь записываться в буфер файла с помощью RSET и LSET.
GET считывает запись с файла произвольной выборки.
Синтаксис: GET [ #] filenum [, [recnum], [ var]]
Комментарии: filenum - номер, под которым был открыт файл
recnum - номер записи, которую надо считать (от 1 до 16777215). Если recnum опущен, то используется следующий за GET или PUT номер записи.
var - переменная, получающая данные из файла. Если указана переменная, то CVD, CVL, CVI, CVS не требуются для преобразования полей записи в числа.
LOC-функция возвращает текущую позицию файла.
Стнтаксис: y=LOC(filenum)
Комментарии: filenum - номер файла.
Поведение LOC зависит от того, в каком режиме открыт файл. Если filenum является файлом с произвольным доступом, то возвращается номер последней считанной или записанной записи. Если filenum является файлом с последовательным доступом, то возвращается номер 128-и байтовых блоков, записанных или считанных с момента открытия файла. Если файл был открыт, но с ним еще не проводились операции чтения или записи, то LOC возвращает 1. Если filenum является двоичным файлом, то LOC возвращает позицию указателя в файле.
LSET помещает строковые данные в буфер файла прямого доступа.
Синтаксис: LSET field variable=strind expression
Комментарии: field variable - переменная поля
strind expression - строковое выражение
LSET и родственный ему оператор RSET пересылают строковую информацию в поле переменных, принадлежащее буферу файла прямого доступа. Если длинна строкового выражения меньше переменной поля, определяемой оператором FIELD,LSET выравнивает это поле по левому краю, дополняя его пробелами, а оператор RSET выравнивает по правому краю, дополняя его пробелами (пробелы добавляются перед первым знаком строкового выражения). Кроме того, LSET и RSET можно использовать для форматирования выходных данных на экран или печать:
a$=space$(20)
RSET a$="Rigth-just"
PRINT a$
RSET Перемещает строчные данные в буфер произвольного файла.
Синтаксис: RSET field variable=strind expression
Комментарии: field variable - переменная поля
strind expression - строковое выражение
RSET и LSET перемещают строчные данные в "переменные поля", которые уже определены в предыдущем заявлении FIELD , как принадлежащие буферу произвольного файла. Если длина строчного выражения меньше размеров переменной поля, специфицируемой в заявлении FIELD, это поле выравнивается заявлением RSET вправо посредством заполнения пробелами. Это означает, что пробелы вставляются перед первой литерой строчного выражения таким образом, что после операции RSET параметр LEN (переменной поля) остается равным ширине, определенной в соответствующим заявлении FIELD. LSET осуществляет левое выравнивание заполнением пробелами (пробелы добавляются после последней литеры строчного выражения). RSET можно также использовать для образования формата вывода на экран или печатающее устройство:
a$ = space$(20)
RSET a$ = "Выравнять вправо"
PRINT a$
MKI$,MKL$,MKS$,MKD$-функции Преобразуют числовые данные в строки (для ввода в файл прямого доступа).
Синтаксис: s$=MKI$(целочисленное выражение)
s$=MKL$(длинное целочисленное выражение)
s$=MKS$(выражение с одинарной точностью)
s$=MKS$(выражение с двойной точностью)
Эти функции являются частью процесса получения численных значений в файлах с произвольной выборкой. Поскольку операторы, записывающие информацию в буфер файла с произвольной выборкой (LSET,RSET), управляют только строками, численные данные следует преобразовать в строковые до пересылки (PUT) в файл. MKI$ возвращает строку из 2 символов,состоящую из 28-битовых значений, которые Turbo-Basic использует для внутреннего представления целочисленных переменных. MKL$ возвращает 4-байтовый строковый эквивалент длинного целого числа. MKS$ возвращает 4-байтовый строковый эквивалент значения с одинарной точностью. MKD$ возвращает 8-байтовый строковый эквивалент значения с двойной точностью. Дополняющие функции CVI,CVL,CVS,CVD предназначены для использования в процессе считывания содержимого файла с произвольной выборкой.
MKMD$,MKMS$-функции Преобразуют численные данные в строки в формате Microsoft (для ввода файла прямого доступа).
Синтаксис: s$=MKMS$(выражение с одинарной точностью)
s$=MKMD$(выражение с двойной точностью)
Эти функции предусмотрены только для совместимости с существующими файлами с произвольной выборкой,в которых содержатся числа с плавающей запятой в Microsoft-формате. MKMS$ формирует 4-байтовую строку с одинарной точностью; MKMD$ формирует 8-байтовую строку с двойной точностью.
CVMD, CVMS-функции Преобразуют строковые значения, считанные с MICROSOFT-форматных файлов с произвольной выборкой в числовую форму.
Синтаксис: y!=CVMS(4-byte string)
y#=CVMD(8-byte string)
CVMD/CVMS преобразует строковую цепочку, представляющую значение одинарной/двойной точности в формате MICROSOFT в значение одинарной/удвоенной точностью в формате IEEE. Обеспечивают совместимость числовых данных в файлах спроизвольным доступом Basic и Turbo-Basic.
PUT вводит запись в файл прямого доступа.
Синтаксис: PUT [#]filenum[,record number]
Коментарии: filenum - значение, определяемое при открытом файле.
record namber - численное выражение, описывающее запись, которую следует записать. Это выражение может находится в пределах от 1 до 16.777.216.
PUT - дополнение к GET. оно осуществляет одну запись в файл с произвольной выборкой. "record number" - не обязателен. Если оно опущено, Turbo Basic использует значение из последнего оператора PUT или GET плюс 1.
Для примера рассмотрим типовую программу обработки файлов с произвольной выборкой:
OPEN "ADD.DTA" AS #1 LEN=81
FIELD #1,25 AS name$,25 AS addres$,15 AS city$,2 AS state$,_
4 AS zip$,2 AS class$,8 AS contrib$
INPUT "Which record do you want to see: ",recnumber
GET #1, recnumber
PRINT "Data for record"recnumber
PRINT "Name: "name$
PRINT "Addres: "addres$
PRINT "City/State/Zip: "city$,state$,CVL(zip$)
PRINT "Class: "CVI(class$)
PRINT "Most recent contrib: "SVL(contrib$)
Примечание: никогда не используйте переменные поля, определенные в операторе FIELD, в операциях присваивания с левой стороны, т.к. тогда они теряют свою связь с буфером. Например, после
zip$=a$
переменная zip$ больше не относится к буферу обмена.
Индексно-последовательные файлы
Наборы данных с индексно-последовательной организацией располагаются в основном на магнитных дисках. Доступ к записям этих наборов осуществляется двояко: прямой доступ по значению ключа и последовательный доступ в порядке возрастания значений их ключей. Можно выполнить последовательную обработку либо всего набора данных, либо его части в пределах заданного диапазона значений ключей.
Рис.2.8 Организация индексно-последовательного файла
Каждая дорожка диска может содержать несколько записей, в каждой из которых в определенном месте (в данном случае в начале) указывается ключ записи. Узлы, непосредственно предшествующие листьям, соответствуют индексу дорожки. Каждой занятой дорожке цилиндра в индексе дорожек соответствует один элемент, содержащий адрес дорожки и значение ключа последней записи на этой дорожке. При заполнении записями очередной дорожки диска происходит формирование нового элемента индекса дорожек и осуществляется переход на следующую дорожку.
После того, как будут составлены элементы индекса для всех дорожек первого цилиндра, составляется индекс цилиндров (аналогично индексу дорожек). Значением элемента индексов цилиндров является адрес цилиндра и значение ключа последней записи на нем. Трудности которые встречаются для этого набора данных следующие:
Если максимальная длина записи превысит длину одной дорожки диска, то возникают трудности, связанные с общей организацией этих данных;
Трудно сформировать набор данных, располагающийся на дисках разного типа;
При большом количестве добавлений в набор данных новых записей значительно усложняется его структура и снижается эффективность поиска и использования пространства памяти.
Бинарные файлы
Turbo-Basice позволяет работать с двоичными файлами, которые часто называют бинарными файлами. Концепция бинарных (двоичных) файлов в Turbo-Basic предоставляет более широкие возможности пользователю по сравнению с интерпретирующим Basic. Бинарный файл рассматривается Turbo-Basic как простой набор байтов, поэтому необходимо позаботиться о том, что и куда писать в файл или записывать в него.
Для поиска нужных данных в файле имеется указатель положения в файле (функция LOC указывает его значение), который передвигается по файлу с помощью функции SEEK.
При работе с файлами произвольного доступа следуйте правилам:
1. Открыть файл в бинарном режиме. Теперь Вы можете читать и/или записывать данные в файл.
2. При считывании данных используйте SEEK для позиционирования в файле, затем используйте GET$ для считывания определенного числа знаков (от 1 до 32.767) в строку.
3. Для записи в файл загрузите строковую переменную нужной информацией и выполните PUT$.
4. По окончанию работы закройте файл (CLOSE).
Сведем операторы и функции Turbo-Basic, управляющие бинарными файлами в таблицу:
Оператор/функция Операция
CLOSE Оканчивает операции на файле(ах)
GET$ Считывает определенное число байтов с установленной позиции
LOC Определяет позицию поиска в файле
LOF Возвращает длину файла
OPEN Открывает файл
PUT$ Записывает определенное число байтов с установленной позиции
SEEK Передвигает указатель позиции
____________________________________________________________________________________
Ниже даются описания операторов, которые не были описаны в предыдущих разделах.
GET$-функция Считывает строку с файла, открытого в двоичном режиме.
Синтаксис: GET$ [ #] filenum [, [count], [string variable]]
Комментарии: count - целочисленное выражение от 0 до 32767, указывающее на количество байт, которое надо считать в строку string variable из файла с номером filenum.
Данные считываются с текущей позиции файла (которая может устанавливаться с помощью SEEK). После считывания текущая позиция перемещается на указанное количество байт. GET$, PUT$ и SEEK обеспечивают самый нижний уровень в обработке файлов.
LOF функция LOF возвращает длину файла.
Синтаксис: y=LOF(filenum)
Комментарии: filenum - номер,под которым открыт файл.
LOF возвращает длину указанного файла в байтах. Для файлов связи LOF предусматривает размер интервала в буфере связи.
PUT$-функция PUT$ записывает строку в файл с режимом двоичного счета.
Синтаксис: PUT$ [#] filenum, string expression
Комментарии: В SEEK позиции файла PUT$ записывает содержимое string expression в файл filenum.Файл filenum следовало бы открыть в режиме BINARY.
SEEK Устанавливает позицию в двоичном файле для заявлений GET$ и PUT$ .
Синтаксис SEEK [#] файл_н, позиция
Коментарии SEEK заявляет, что следующее GET$ или PUT$, выполняемое на файле файл_н будет реализовываться на глубине файла равной позиции байтов. Файл файл_н должен быть открыт в режиме BINARY.
Для возврата текущей SEEK - позиции в двоичном файле необходимо использовать функцию LOG.
Устройства ввода-вывода.
Turbo-Basic имеет так называемые машинные файлы ,т.е. он может общаться с клавиатурой, монитором, принтером как с последовательными файлами. Каждое из устройств имеет свое зарезервированное имя файла:
___________________________________________________________________________________
Имя Функция
___________________________________________________________________________________
KYBD: Клавиатура может открываться для ввода. Считывание происходит подобно использованию INKEY$
SCRN: Экран может открываться для вывода
LPT1-3: Принтеры от 1 до 3 - открываются для вывода
COM1-2 Порты связи 1 и 2
___________________________________________________________________________________
Например:
OPEN "SCRN:" FOR OUTPUT AS #1:PRINT #1,"Hello"
или
OPEN "KYBD:" FOR INPUT AS #1:INPUT #1,a$,b$
Теперь, когда мы обсудили типы файлов рассмотрим принципы работы с ними.
Т.к. Turbo-Basic при работе опирается на DOS, то имена файлов формируются по стандарту DOS: имя файла состоит из двух частей:
filename.ext
где filename представляет собой имя файла и содержит от 1 до 8 знаков, а ext является необязательным расширением типа файла и состоит из 3 знаков. Если имя файла длиннее 8 знаков, то Turbo-Basic автоматически усекает имя до 8 знаков, а остаток отсылает в расширение. Если в предыдущем случае имя уже имеет расширение файла, то лишние символы из имени просто отбрасываются и нигде не фигурируют. Если лишние знаки присутствуют в расширении, то оно тоже усекается до 3 знаков.
В дополнение к операторам создания, записи и считывания файлов Turbo-Basic имеет ряд операторов, выполняющих функции, аналогичные некоторым командам DOS:
оператор NAME переименовывает файлы,
KILL - стирает файлы,
MKDIR - создает каталог,
CHDIR - изменяет активный каталог,
RMDIR - стирает каталог.
Если нет команды COPY (копировать), то вместо этого используйте технику бинарного файла (или используйте SHELL для вызова COMMAND.COM).
Имена файлов, используемые в операторах Turbo-Basic, должны быть представлены в форме цепочки:
KILL "myfile.bak"
или
a$="myfile.bak":KILL a$