Как записать в файл делфи. Запись в текстовый файл Delphi. Чтение из входного файла
Когда речь идет о работе программы с текстовым файлом, подразумеваются процедуры ввода данных из файла в программу или, наоборот, запись этих данных в файл программой. Для текстового файла допустима простая работа с файлом без особых дополнительных механизмов, которые применяются для работы со специализированными файлами, такими как при загрузке данных из Excel или работе программы с базой данных . Разумеется, Delphi располагает возможностями работать с файлами с использованием компонентов. Но в данной статье рассматривается механизм прямой работы с текстовым файлом без использования дополнительных компонентов.
Итак, в общем виде, работа с файлом заключается в следующих этапах:
1. подключение к файлу – связь с внешним файлом, указание режима подключения;
2. выполнение операций записи в файл или чтения из файла;
3. завершение работы с файлом.
Подключение к файлу
Для связи программы с файлом используется специальная переменная – "Файловая переменная". Объявляется она так же как и любая переменная в Delphi. Тип это переменной может быть File для типизированных (хранящих данные определенного типа) файлов, а можно указать TextFile , что будет означать тип обычного текстового файла. Объявление переменной:
var
f: TextFile;
В исполняемом коде программы выполняется подключение к внешнему файлу:
AssignFile(f, "input.txt" );
Команда AssignFile , выполняет связь файловой переменной с внешним файлом. Вторым параметром указывается адрес файла. Он может быть задан относительным или абсолютным. Если указать только имя файла, то программа будет пытаться обнаружить его в той же директории, где она сама и находится. Абсолютный путь указывается от корневого диска:
AssignFile(f, "C:\myprog\input.txt" );
Использование относительной директории дает возможность не привязываться к конкретным дискам и адресам. Например:
AssignFile(f, "data\input.txt"
); // во вложенной папке относительно директории с программой
AssignFile(f, "..\input.txt"
); // на уровень выше директории с программой
AssignFile(f, "..\data\input.txt"
); // во вложенной папке на уровень выше директории с программой
После того как выполнено подключение, выполняется процедура, устанавливающая режим работы с файлом. В основном это режим чтения или записи. Эти режимы назначаются процедурами Reset() (для чтения) и rewrite() (для записи):
Reset(f);
Rewrite(f);
* Для команды Rewrite() следует учитывать, что при ее выполнении, она либо создает файл, указанный в файловой переменной, либо если он уже есть перезаписывает файл заново, удаляя старый без какого-то предупреждения.
Любую из указанных команд можно использовать без команды AssignFile() . Для этого достаточно вторым параметром указать путь к файлу. Таким образом, она сразу выполнит привязку файла к файловой переменной и назначит режим работы с этим файлом:
Reset(f, "C:\myprog\input.txt"
); // чтение
Rewrite(f, "C:\myprog\input.txt"
); // запись
Операции с файлами
Для чтения из файла, необходимо назначить режим чтения и использовать команду Readln() , которая будет вводить в строковую переменную по одной строке из файла. Затем с этой переменой можно выполнить необходимые действия.
Readln(f, s);
Обычно для загрузки всех строк из файла используется оператор цикла. Для того, чтобы определить, что файл закончился используется функция EOF() (End Of File). Таким образом получается цикл, в котором последовательно в строковую переменную вводятся все строки файла и завершающийся после окончания фала:
Readln(f, s);
end
;
Для записи, назначение режим записи в файл и командой Writeln() производится запись по строкам.
Writeln(f, "text" );
Закрытие файла
По завершении работы с файлами, особенно в случае записи в них данных, необходимо корректно завершить работу с файловой переменной. Это делается для того, чтобы сохранить все внесенные в файл изменения.
CloseFile(f);
Примеры работы с текстовыми файлами в Delphi
Чтение в переменную одного значения из файла:
var
f: TextFile;
s: String;
begin
AssignFile(f, "input.txt"
);
Reset(f);
Readln(f, s);
CloseFile(f);
end
;
Загрузить все строки файла в компонент Memo:
var
f: TextFile;
s: String;
begin
AssignFile(f, "input.txt"
);
Reset(f);
while
(not
EOF(f)) do begin
Readln(f, s);
myMemo.Lines.Add(s);
end
;
CloseFile(f);
end
;
Следует отметить, что для этой задачи проще воспользоваться командой самого компонента Memo LoadFromFile() .
myMemo.Lines.LoadFromFile("input.txt" );
Записать строку в файл:
var
f: TextFile;
begin
AssignFile(f, "input.txt"
);
Rewrite(f);
Writeln(f, "My text" );
CloseFile(f);
end
;
Записать в текстовый файл все строки из компонента Memo:
var
f: TextFile;
i: Integer;
begin
AssignFile(f, "input.txt"
);
Rewrite(f);
for
i:= 0 to
myMemo.Lines.Count - 1 do
Writeln(f, myMemo.Lines[i]);
CloseFile(f);
end
;
Как и для чтения из файла в Memo, так и здесь, имеется специальная команда:
myMemo.Lines.SaveToFile("input.txt" );
Поименованная область памяти на внешнем носителе (диске) называется файлом . У любого файла есть имя . Информация , которая хранится в файле, представляет собой множество элементов одного типа. Размер файла, как правило, ограничен только емкостью устройства, на котором он хранится, что позволяет обрабатывать большие объемы информации.
Способ объявления файла зависит от его типа. Различают три типа файлов:
текстовые ;
типизированные ;
нетипизированные .
Текстовый файл , состоит из последовательности любых символов. Символы образуют строки, каждая из которых заканчивается символом «конец строки». Конец самого файла обозначается символом «конец файла». При записи информации в текстовый файл, все данные преобразуются к символьному типу и хранятся в таком виде. Просмотреть текстовый файл можно с помощью любого текстового редактора .
Описание текстового файла :
var имя_переменной: TextFile;
Типизированный файл состоит из элементов одного типа, число которых заранее не определено и может быть любым. Он так же заканчивается символом «конец файла». Данные в типизированном файле хранятся в двоичных кодах и не просматриваются текстовыми редакторами. Объявление таких файлов имеет вид:
имя_переменной: file of тип;
В нетипизированных файлах информация считывается и записывается в виде блоков определенного размера, в них могут храниться данные любого вида и структуры. Описание нетипизированного файла:
var имя_переменной: file;
Для доступа к файлам используют специальную файловую переменную .
Например:
c:file of integer;
Для связи файловой переменной с файлом на диске примняют процедуру:
AssignFile(переменная, имя_файла);
здесь переменная – имя переменной любого файлового типа, имя_файла – строка символов, содержащая полное имя файла (если путь к файлу не указан, подразумевается, что он находится в текущем каталоге).
Например:
S:=’text.txt’;
assign (f,’d:\tp\tmp\abc.dat’);
Для открытия существующего файла используют процедуру:
Reset(файловая_переменная);
После открытия файла доступен его первый компонент.
Для создания нового файла или удаления информации из существующеего применяют процедуру:
Rewrite(файловая_переменная);
После выполнения различных операций файл должен быть закрыт . Для этого применяют процедуру
CloseFile(файловая_переменная);
Запись данных в текстовый файл осуществляется процедурами
Write(переменная, список_выражений);
Writeln(переменная,список_выражений);
где список_выражений – выражения символьного, целочисленного, вещественного, строкового или логического типов, которые будут записаны в файл, связанный с файловой переменной.
Процедура Writeln в конце каждой строки добавляет символ «окончание строки».
ПРИМЕР. Подпрограмма, которая создает на диске D файл abc.txt и записывает в него таблицу умножения.
var f:TextFile; i,j:byte;
assignFile(f,"d:\abc.txt");
for i:=2 to 9 do
for j:= 2 to 9 do
write(f,i,"*",j,"=",i*j," ");
Чтение данных из файла осуществляется последовательно от начала файла процедурой
Readln(переменная,список_переменных);
здесь в списоке_переменных перечисляются переменные, в которые будут записаны данные прочитанные из файла, связанного с файловой переменной.
Процедура Readln после чтения из файла очередного элемента переходит к следующей строке.
Обращение к следующей подпрограмме приведет к тому, что на форме в окне редактирования появится текст из файла D:\abc.txt :
procedure TForm1.Button1Click(Sender: TObject);
a:string; i:integer;
AssignFile(f1,"D:\abc.txt");
for i:=1 to 8 do
Memo1.Lines.Add(a);
Для типизированных файлов так же применимы процедуры чтения и записи
Read(переменная,список_переменных);
Write(переменная,список_выражений);
только типы выражений при записи и чтении должны соответствовать объявленному типу файла. Процедуры Writeln и Readln к типизированным файлам не применяют.
Для перемещения по типизированному файлу используют процедуру:
Seek(переменная, номер);
Эта процедура позволяет перейти к элементу с указанным номером, то есть осуществляет прямой доступ к компонентам файла . При прямом доступе компоненты файла нумеруются от 0 до n-1, где n – число компонентов в файле.
Так же для прямого доступа к компонентам типизированного файла можно применять функции:
filesize(переменная) – возвращает число реальных компонентов в открытом файле, связанном с файловой_переменной (для пустого файла функция вернет 0);
filepos(переменная) – возвращает значение текущей позиции в открытом файле, связанном с файловой переменной (если файл только что открылся, то функция вернет ноль, после прочтения последнего компонента из файла значение функции совпадает со значением filesize, что указывает на достижение конца файла).
Процедура Seek и функции filesize и filepos с текстовыми файлами не работают. Следующие подпрограммы работают как с типизированными, так и с текстовыми файлами:
Rename(переменная,имя_файла)
переименовывает закрытый файл, связанный с файловой переменной, в соответствии с именем указанным в строке имя файла;
Erase(переменная) – удаляет закрытый файла, связанный с файловой переменной;
Eof(переменная) принимает значение истина (true), если достигнут конец файла, связанного с файловой_переменной, и ложь (false) в противном случае;
ПРИМЕР. Подпрограмма, приведенная ниже, работает так. Открывается вещественный файл d:\abc.dat и в него записывается определенное количество вещественных чисел, вычисленных по формуле. Просмотреть созданный файл не возможно, так как информация в нем представлена в двоичных кодах.
procedure TForm1.Button1Click(Sender: TObject);
AssignFile(f,"d:\abc.dat");
n:=StrToInt(Edit1.Text);
for i:=1 to n do
a:= sqr(i)/sqrt(i);
Чтобы убедиться, что запись в файл d:\abc.dat произошла успешно, выведем его значения в окно редактирования:
procedure TForm1.Button1Click(Sender: TObject);
f1:file of real;
AssignFile(f1,"D:\abc.dat");
while not eof (f1) do
Memo1.Lines.Add(FloatToStr(a));
ЗАДАЧА. На диске Е есть файл целых чисел аbc.int , поменять местами его максимальный и минимальный элементы.
Приведенная далее программа работает так. Компоненты файла считываются в массив. Элементы массива выводятся в поле Memo1. Затем происходит поиск минимального и максимального элементов массива и их индексов. Максимальный и минимальный компоненты перезаписываются в файл на соответствующие позиции.
В заключении элементы преобразованного файла выводятся в поле Memo2.
procedure TForm1.Button1Click(Sender: TObject);
f:file of integer;
a:array of integer;
i,nmax,nmin:byte; max,min:integer;
AssignFile(f,"e:\abc.int");
for i:=0 to filesize(f)-1 do
Memo1.Lines.Add(FloatToStr(a[i]));
max:=a; nmax:=0;
min:=a; nmin:=0;
for i:=1 to filesize(f)-1 do
if a[i]>max then
if a[i] for i:=0 to filesize(f)-1 do Memo2.Lines.Add(FloatToStr(a[i])); Несмотря на то, что в Delphi существует несколько методов, позволяющих взаимодействовать с файлами, технология работы подразумевает под собой соблюдение определенного порядка действий: 1. Файл обязательно должен быть открыт. Другие приложения не должны мешать работе с файлом, за этим тщательно следит система. Одновременно с этим система определяет, для каких целей открывается файл. Здесь существует несколько вариантов: для чтения или для внесения изменений. После того, как документ будет создан или открыт, в систему поступает специальный идентификатор, который во всех последующих процедурах обработки будет использоваться в качестве указателя на данный файл. 3. После того, как все необходимые действия будут выполнены и запись в файл осуществится, документ закрывается. С этого момента он становится доступным для других приложений совершенно без ограничений. Стоит отметить, что закрытие файла является гарантией того, что все внесенные корректировки будут сохранены. Таким образом, запись в файл Delphi необходимых данных успешно завершена
. Если данная задача кажется достаточно сложной, то можно обратиться за помощью к профессионалам, которые помимо Delphi знают все необходимое про администрирование linux. Для работы с текстовыми документами применяется тип TextFile, который записывается так: Var
Переменная: Тип TextFile;
Технология работы с файлами
в системе Delphi
требует определённого порядка действий: Var F:
File
;
Описанная таким образом файловая переменная считается нетипизированной
, и позволяет работать
с файлами с неизвестной структурой. Данные считываются и записываются побайтно блоками, размер которых указывается при открытии файла, вплоть от
1 байт. Но чаще используются файлы, состоящие из последовательности одинаковых записей. Для описания такого файла к предыдущему описанию
добавляется указание типа записи: Var F:
File of
тип_записи ;
В качестве типа могут использоваться базовае типы, или создаваться свои. Важно только, чтобы для типа был точно известен фиксированный
размер в байтах, поэтому, например, тип String
в чистом виде применяться не может, а только в виде String[N]
, как указывалось в
уроке Delphi 5 . Данные, считанные из файла или записываемые в файл, содержатся в обычной переменной, которая должна быть того же типа, что и файловая. Поэтому
сначала в программе лично я описываю нужный тип, а затем ввожу две переменные этого типа - файловую и обычную: Для текстовых файлов отдельно укажу, что тип файловой переменной в этом случае TextFile
, а тип обычной - String
. Для открытия файла нужно указать, где он расположен. Для этого файловая переменная должна быть ассоциирована с нужным файлом, который определяется его адресом. Адрес файла может быть абсолютным, с указанием диска и каталогов ("C:\Мои документы\Мои рисунки\FileName.ini"), или относительным, тогда он создаётся в папке с .exe
файлом программы. Для задания относительного адреса достаточно указать имя файла с нужным расширением. Делается это оператором AssignFile:
AssignFile(SaveF, "C:\Мои документы\Мои рисунки\FileName.ini"); Теперь файл должен быть открыт. Rewrite(SaveF); Каждый из этих операторов может иметь второй необязательный параметр, имеющий смысл для нетипизированных файлов, и указывающий длину записи нетипизированного файла в байтах: Rewrite(SaveF, 1); Чтение файла производится оператором Read:
Read(SaveF, SaveV); Запись в файл производится оператором Write:
Write(SaveF, SaveV); При этом чтение и запись производится с текущей позиции указателя, затем указатель устанавливается на следующую запись. Можно проверить, существует ли нужный файл, оператором FileExists:
if
FileExists("FileName.ini") Принудительно установить указатель на нужную запись можно оператором Seek(SaveF, N)
, где N - номер нужной записи, который, как и почти всё в программировании, отсчитывается от нуля: Seek(SaveF, 49); - установка указателя на 50-ю запись. При последовательном чтении из файла рано или поздно будет достигнут конец файла, и при дальнейшем чтении произойдёт ошибка. Проверить, не достигнут ли конец файла, можно оператором EOF
(аббревиатура E
nd O
f F
ile), который равен true
, если прочитана последняя запись и указатель находится в конце файла: while
(not EOF(SaveF)) do
Для текстовых файлов вместо Read
и Write
используются операторы Readln
и Writeln
, умеющие определять конец строки. В коментариях приведена процедура чтения текстового файла. Оператор Truncate(SaveF)
позволяет отсечь (стереть или, если хотите, удалить!) все записи файла, начиная от текущей позиции указателя, и до конца файла. В конце работы с файлом его необходимо закрыть. Это делается оператором CloseFile(SaveF) ;
Теперь можно изменить программу из первой части урока, запоминающую своё положение на экране. Описание переменных опускаю, оно приведено на рисунке выше. Создаём обработчик события Формы OnCreate
со следующим содержимым: procedure
TForm1.FormCreate(Sender: TObject) ; Теперь необходимо создать обработчик события OnClose:
procedure
TForm1.FormClose(Sender: TObject; var Action: TCloseAction) ; В данном случае файл считывается и записывается туда, куда мы ему указали. Но необходимо также уметь выбрать нужный файл в работающей программе.
Описание этого - в Файл
– это именованная структура данных, представляющая собой последовательность элементов данных одного типа расположенных на диске или любом другом внешнем носителе. Для файла существует понятие текущей позиции. Она показывает номер элемента, который будет прочитан или записан при очередном обращении к файлу. Чтение-запись каждого элемента продвигает текущую позицию на единицу вперед. Для большинства файлов можно менять текущую позицию чтения-записи, выполняя прямой доступ к его элементам. В зависимости от типа элементов различают три вида файла: – файл из элементов определенного типа (типизированные файлы); – файл из элементов, тип которых не указан (нетипизированный файл); – текстовый файл, т.е. элементами являются текстовые строки. Для работы с файлом в программе объявляется файловая переменная (логический файл) в разделе описания переменных: имя_файла:
file
of тип_элементов_файлов;
Файл, компонентами которого являются данные символьного типа, называется символьным, или текстовым: имя_файла:
TextFile;
После объявления файловой переменной, которая задает тип компонентов файла, необходимо указать конкретный файл, т.е. связать файловую переменную с физическим файлом. Для этого используется процедура: AssignFile(var
f, имя_файла:
String);
Функции и процедуры для работы с файлами:
1.
Открытие файла для записи
– перезапись (запись нового файла поверх существующего или создание нового файла) – используется процедура rewrite
(файловая_переменная)
– добавление в конец файла – используется процедура append
(файловая_переменная)
1. Запись в файл
Write
Writeln
(файловая_переменная, список_переменных)
Различие между инструкциями в том, что инструкция writeln после вывода всех значений, записывает в файл символ «новая строка». 2. Закрытие файла.
Перед завершением работы все открытые файлы необходимо закрыть с помощью процедуры CloseFile
(файловая_переменная)
3. Открытие файла для чтения.
Используется процедура Reset(файловая_переменная)
4. Чтение данных из файла
read
(файловая_переменная, список_переменных)
readln
(файловая_переменная, список_переменных)
Отличие между этими процедурами в том, что при вызове инструкции readln указатель чтения из файла автоматически перемещается в начало следующей строки файла. 5. Определение конца файла.
Используется функция EOF
(файловая_переменная). Значение функции равно false, если прочитанный элемент данных не является последним в файле, т.е. возможно дальнейшее чтение. Если прочитанный элемент файла является последним, то значение EOF равно true. While not eof(f) do begin … end;
6. Rename
(var F; NewName: string)
– переименовывает неоткрытый файл F любого типа. Новое имя задается в NewName. 7. Seek
(
var F; NumRec: Longint)
– устанавливает позицию чтения-записи на элемент с номером NumRec; F – типизированный или нетипизированный файл. 8. IOResult
: Integ
er – возвращает код, характеризующий результат (была ошибка или нет) последней операции ввода-вывода. 9. FilePos
(var F): Longint
– возвращает для файла F текущую файловую позицию (номер элемента, на которую она установлена, считая от нуля). Не используется с текстовыми файлами. 10. FileSize
(var F): Longint
– возвращает число компонент в файле F. Не используется с текстовыми файлами. Для работы с файлами можно использовать следующие визуальные компоненты:
– {SITELINK-S102}OpenDialog{/SITELINK}; – {SITELINK-S103}SaveDialog{/SITELINK} и др, которые находятся на вкладке Dialogs.Запись в текстовый файл Delphi
В Delphi файл представляется в виде последовательности однотипных данных. Иначе говоря, это достаточно большой массив, размер которого практически ничем не ограничен. Для того чтобы облегчить запись в текстовый файл Delphi, каждый документ представлен в виде файловой переменной.
Для получения доступа к файлу следует воспользоваться процедурой AssignFile()
. После того, как доступ к файлу получен, его можно открыть при помощи процедур Reset, Rewrite
. Если говорить более подробно, то процедура Reset()
открывает ранее созданный документ, а процедура Rewrite()
позволяет создать новый файл или же очистить существующий. Закрывается файл при помощи специальной процедуры CloseFile. Осуществить запись в текстовый файл Delphi можно при помощи таких процедур, как Write или WriteLn.Запись в excel
В том случае, если необходимо выполнить запись в excel Delphi, нужно воспользоваться определенным алгоритмом действий. Для начала создается вариантный массив, затем в этот массив заносятся данные и при помощи одной операции весь этот массив записывается в файл excel. Стоит отметить тот факт, что запись в excel очень актуальна в последнее время, так как именно этот редактор широко используется и для разработки различных отчетов и печатных форм.
В Delphi
реализовано несколько способов работы с файлами
. Познакомимся со классическим способом, связанным с использованием
файловых переменных
. Файловая переменная вводится для указания на файл. Делается это с помощью ключевого слова File
:
AssignFile(SaveF, "FileName.ini");
Открытие файла оператором Rewrite
приведёт воссозданию файла заново, т.е. существующий файл будет без предупреждения
уничтожен, и на его месте будет создан новый пустой файл заданного типа, готовый к записи данных. Если же файла не было, то он будет создан.
Открытие файла оператором Reset
откроет существующий файл к считыванию или записи данных, и его указатель будет установлен на начало файла :
Reset(SaveF);
Reset(SaveF, 1);
then
Read(SaveF, SaveV);
Read(SaveF, SaveV);
begin
AssignFile(SaveF, "Init.ini") ;
if
FileExists("Init.ini") then
begin
Reset(SaveF) ;
Read(SaveF, SaveV) ;
Form1.Left:= SaveV.X ;
Form1.Top:= SaveV.Y ;
Form1.Caption:=SaveV.Caption ; //Наши переменные дополнительно сохраняют заголовок Формы!
end ;
end ;
begin
Rewrite(SaveF) ; //Нет необходимости проверять наличие файла, создадим его заново!
SaveV.X:= Form1.Left ;
SaveV.Y:= Form1.Top ;
SaveV.Caption:= Form1.Caption ;
Write(SaveF, SaveV) ;
CloseFile(SaveF) ;
end ;
