Igp протокол. Динамическая маршрутизация. Протоколы и работа. Полезные команды для траблшутинга

15.03.2019

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

Для работы с содержимым файла программа должна его открыть . Открывая файл, мы указываем, что именно мы хотим с ним делать: читать или писать. Результатом открытия является так называемый файловый дескриптор - скалярное значение, хранящее сведения о текущем состоянии процесса чтения или записи. Операции чтения, записи и прочие операции ввода вывода в дальнейшем осуществляются через дескриптор.

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

Perl

my $file ; open $file , "<" , "MyFile.txt" ; открытие для чтения

Мы обожаем совмещать объявление переменной для дескриптора с вызовом процедуры open:

Perl

open my $file , "<" , "MyFile.txt" ;

Значение "<" , переданное как второй параметр, символизирует чтение. Знак «меньше», повернувшийся спиной к имени файла, как бы намекает нам, что готовится извлечение информации из файла. Угадайте, как открыть файл для записи? Конечно же так:

Perl

open my $file , ">" , "MyFile.txt" ; открытие для записи

В примерах использования процедуры open указывалось относительное имя файла - по отношению к директории, являющейся для данной программы текущей. Сразу после запуска программы это та директория, из которой запущена программа. Но текущая директория может быть изменена процедурой chdir:

Perl

chdir "/" ;

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

Perl

open my $passwd , "<" , "/etc/passwd" ;

В некоторых операционных системах, в полных именах файлов применяется другой разделитель директорий. Например, в Microsoft DOS и Microsoft Windows вместо слэша / применяется разделитель бэкслэш \ . Тем не менее, задавая полное имя в программе на Perl при открытии, следует использовать слэш: "/c:/dos/autoexec.bat" .

Интуиция подсказывает нам, что всё, что открывается, должно быть рано или поздно закрыто. Это верно и для файлов. Любой сценарий ввода/вывода устроен одинаково: открытие, собственно ввод или вывод, и, наконец, закрытие

Закрытие файла освобождает ресурсы операционной системы, занятые при открытии, и гарантирует, что данные, записанные в файл, дойдут по назначению. После закрытия переменная-дескриптор теряет актуальность и не может быть использована для ввода/вывода.

Для закрытия файлов служит встроенная процедура close:

Perl

close $file ;

Не стоит ожидать, что открытие файла всегда будет успешным. Есть много причин, которые могут помешать. Среди них:

отсутствие нужного файла;
отсутствие прав на чтение или запись;
неполадки с носителем: испорченный диск или флешка, перебои с сетью в случае сетевых файлов.

В этих и подобных случаях все дальнейшие операции с файлом потеряют всякий смысл и лишь приведут Perl в ярость. Однако процедура open в своём возвращаемом значении сообщает об итоге операции: при успехе возвращает истинное значение, а при неудаче - ложное. Хорошо написанная программа должна проверять это значение, и действовать в зависимости от него. Например, при неудачном открытии завершить работу программы с выдачей соответствующего сообщения:

Perl

if (open … ) { работа с файлом и последующее закрытие } else { die ; }

Обратите внимание на специальную переменную $! . В случае возникновения ошибки в эту переменную автоматически помещается текст, объясняющий причину ошибки, например, Нет такого файла или каталога или Отказано в доступе или что-то ещё. Текст в $! , в зависимости от системных настроек, может быть на другом языке.

Гораздо изящней выглядит следующая идиома:

Perl

open … or die "Невозможно открыть файл: $!\n" ;

В этом логическом выражении два операнда. Если первый (то, что возвращает open) принимает истинное значение, то в вычислении второго нет нужды, так как всё выражение уже заведомо истинно. Если же open возвратит ложное значение, то значение всего выражения определяется по второму операнду, который в этом случае должен быть вычислен. Для вычисления будет вызвана процедура die со всеми вытекающими последствиями.

Конечно, программа не обязана завершать работу при неудачном открытии файла. Например, если предполагается обработка нескольких файлов, можно просто перейти к следующему, сообщив об ошибке при помощи процедуры warn:

Perl

for (@fileNames ) { open my $file , "<" , $_ or warn "Невозможно открыть файл $_: $!" and next ; работа с очередным файлом и последующее его закрытие }

Имеется два способа чтения из дескриптора: побайтное/посимвольное и построчное.

При побайтном/посимвольном чтении файла программа запрашивает у открытого дескриптора очередную порцию данных нужного размера и предоставляет скалярную переменную для запрошенных данных. Для чтения служит встроенная процедура read:

Perl

read $file , $buffer , 16 ;

Можно представлять себе файл, открытый для чтения, как последовательность байтов. Воображаемый указатель отделяет уже прочитанную часть последовательности от ещё непрочитанной. Операция чтения приводит, помимо прочего, к сдвигу указателя к концу файла. За счёт этого следующая команда чтения получит доступ к новой порции данных. Дескриптор файла хранит в себе разнообразную информацию об открытом файле, и, в том числе, этот указатель - номер первого непрочитанного байта. Сразу после открытия указатель равен нулю.

Что же будет, если запросить при чтении больше байт, чем размер непрочитанной части файла? Ничего страшного, компьютер не сломается. Просто в переменную-буфер отправится меньше байт, чем было запрошено. Контролировать это явление удобно, пользуясь возвращаемым значением процедуры read - это количество байт, которое удалось прочесть. Широко распространена при программировании на Perl такая идиома:

Perl

while (read $file , $buffer , $size ) { сделать что-то с $buffer }

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

В отличие от побайтного/посимвольного чтения, когда запрашивается заданное количество байтов или символов, при построчном чтении размер прочитанного заранее не оговаривается. Вместо этого считывается строка - последовательность байтов или символов вплоть до символа или символов, обозначающих конец строки.

Построчное чтение осуществляется оператором <…> . Код <$file > приводит к считыванию очередной строки из дескриптора $file в переменную по умолчанию $_ .

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

Perl

open my $file , "<" , "file.txt" or die "Невозможно открыть файл: $!\n" ; while (<$file >) { print ; }

Здесь читатель справедливо задаётся вопросом: что именно печатает процедура print в теле цикла? Переменную по умолчанию, конечно. Можно было бы написать print $_ , но вряд ли это добавит ясности.

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

Perl

my $sum =0 ; while (<$file >) { chomp ; $sum +=$_ ; } print "$sum\n" ;

Команда chomp необходима вот по какой причине. Оператор <…> вместе со строкой считывает и завершающий строку символ, который создаст проблему, если считанная строка впоследствии будет участвовать в арифметическом выражении. Встроенная процедура chomp удаляет этот символ, если строка заканчивается им. Если же последний символ другой, процедура ничего не делает. такая предосторожность нужна на тот случай, если, к несчастью, файл не заканчивается символом конца строки. Тогда и последняя прочитанная из файла строка закончится чем-то другим. Имеется также процедура chop , которая удаляет и возвращает последний символ строки независимо от того, какой он. Обе процедуры, chop и chomp , работают со строкой, переданной как параметр, но в отсутствие параметра - с переменной $_ .

Не следует думать, что с оператором построчного чтения мы обречены на использование переменной $_ . Если требуется читать в другую переменную, используем присваивание:

Perl

$s =<$file >;

Самое время сообщить об одной особенности оператора построчного чтения. Его смысл немного меняется, если оператор поместить в списочный контекст, то есть туда, где должен быть список. Например, если присвоить массиву:

Perl

@s =<$file >;

В этом случае все строки, прочитанный из файла, заполнят массив. Ещё можно организовать переборный цикл:

Perl

print for <$file >;

Этот код, как и приведённый выше цикл while , печатает строки файла на экран. К тому же результату приведёт код

Perl

print <$file >;

(здесь пропущено слово for ). Но мы не рекомендуем такой подход, поскольку здесь сначала прочитываются все строки из файла, а затем передаются как список параметров в процедуру print . При этом все строки без всякой необходимости занимают память, а при большом файле объём памяти может быть очень велик.

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

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

Для записи в дескриптор применяется давно знакомая нам процедура print , но не совсем так, как мы привыкли:

Perl

print $file $string ;

Здесь содержимое строки $string записывается в открытый дескриптор $file . Обратите особое внимание на отсутствие запятой после первого параметра $file . С запятой смысл команды будет другим: в дескриптор ничего не запишется, а вместо этого программа выведет на экран строковое представление значений обеих переменных $file и $string:

GLOB(0x989e830)Привет!

(шестнадцатеричное число в скобках, скорее всего, будет другим, ну и вместо слова Привет! может оказаться другой текст). Число это нам ни о чём не говорит, как и загадочное слово GLOB вместе со скобками. Итак, если все параметры процедуры print разделены запятыми, все они печатаются на экран. Если после первого параметра нет запятой, этот параметр должен быть дескриптором, открытым для записи, а остальные параметры записываются в него:

Perl

print $file "Hello, " , $user ;

Можно все параметры после дескриптора заключить в скобки:

Perl

print $file ("Hello, " , $user );

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

Perl

print {$file } "Hello, " , $user ;

Программисты часто встречаются с ситуацией, когда требуется в шаблонный текст в определённых местах поместить изменяющиеся фрагменты. Perl хорошо приспособлен для решения таких задач. Изменяющиеся части текста очень удобно поместить в переменную, а имя переменной вставить в нужное место в строку, заключённую в двойные кавычки:

Perl

print "Уважаемый $name! Вы задолжали $duty рублей. Уплатите до $date, иначе $punishment.\n" ;

Таким способом можно вставлять в шаблон и строки, и числа. Что касается чисел, в каких-то ситуациях может потребоваться их особое форматирование. Числа перед включением в шаблон может потребоваться округлить до нужного количества десятичных цифр после точки, дополнить слева нужным количеством нулей или пробелов, чтобы число хорошо смотрелось в таблице. Может потребоваться вставить число в двоичном или шестнадцатеричном формате.

В таких ситуациях на помощь приходят встроенные процедуры printf и sprintf . Первый параметр в обеих процедурах - так называемая форматная строка . Это шаблонный текст, в который с определённые места должны быть вставлены остальные параметры. Места вставки параметров и желательный формат специальным образом помечаются. Метка представляет собой знак процента, за которым следует обозначение формата. Остальные параметры процедуры вставляются на места форматных меток в соответствующем формате. Процедура printf выводит результат в дескриптор подобно процедуре print , а sprintf возвращает полученную после всех вставок строку для какого-то иного использования. В принципе, если бы не было printf , её можно было бы легко запрограммировать: вызов printf (…) равносилен print (sprintf (…)) .

Теперь подробнее о форматных строках и форматных метках.

Шестнадцатеричный формат с дополнением нулями до трёх цифр:

Использование знака процента как признака метки лишает нас возможности использовать его в форматной строке как таковой. Эта трудность не новая для нас, и разрешается она уже хорошо знакомым способом. Комбинация из двух знаков процента означает одиночный знак процента (подобно тому, как \\ внутри "" -строк означает один бэкслэш):

Perl

$p =38 ; $x =43 ; printf "%d%% от %d равно %d\n" , $p , $x , $p /100 *$x ;

38% от 43 равно 16

Точно так же, как и print , процедура printf может осуществлять вывод не только на экран, но и дескриптор файла, открытого для записи или для добавления:

Perl

printf {$file } … ;

В Perl реализовано два набора функций для осуществления операций чтения/записи в файл. Функции одного набора используют буфер - некоторую область памяти - для накопления читаемой/записываемой в файл информации, после заполнения которого или закрытия файла осуществляется физическая запись данных буфера на диск или их пересылка в программу. Эти функции, к которым относятся print , readline, <>, read , getc , seek и tell , по существу, представляют собой интерфейсные функции к процедурам буферизованной библиотеки ввода-вывода stdio языка С. Использование буферизованных операций ввода-вывода ускоряет чтение/запись данных в файлы. Функции второго набора, к которым относятся sysread, syswrite и sysseek, обращаются непосредственно к функциям ввода-вывода операционной системы, осуществляя прямые физические операции чтения/записи данных без накопления их в промежуточном буфере. Открывать файл для доступа как буферизованными, так и небуферизованными функциями можно любой из двух функций - open () или sysopen() - при открытии файла не регламентируется, каким набором функций следует обрабатывать содержащуюся в нем информацию. Единственное требование заключается в том, что не рекомендуется смешивать эти два подхода для одного файла в одном сеансе открытия, так как это может привести к непредсказуемым результатам.

ВНИМАНИЕ При работе с одним и тем же файлом не следует смешивать вызовы буферизованных и небуферизованных функций ввода-вывода. Подобная практика может приводить к непредсказуемым коллизиям. Если требуется, например, использовать небуферизованных функции чтения/записи, а информация из файла уже читалась буферизованной операцией о, то следует закрыть файл, снова его открыть и использовать для работы с ним небуферизованные функции.

Буферизованный ввод-вывод

Чаще всего в программе осуществляется обработка текстовых файлов. Операция <>, операндом которой является дескриптор файла, читает информацию из файла целыми «записями», которые обычно представляют строки текстового файла. Примененная в скалярном контексте, она читает текущую запись файла, увеличивая на единицу специальную переменную $., отслеживающую количество прочитанных записей. В списковом контексте эта же операция прочитает все записи файла, если она выполняется для этого файла первой, или оставшиеся записи, если до нее были выполнены другие операции чтения из файла, и возвращает список, элементами которого являются прочитанные записи файла. Более точно можно сказать, что операция <> в списковом контексте читает оставшиеся записи файла, начиная с текущей его позиции, которая неявно изменяется при каждой операции чтения, а может быть изменена и явным способом с помощью функции seek (), c которой мы познакомимся чуть позже. Забегая вперед, скажем, что все файлы в Perl не имеют никакой структуры, а представляются, как и в С, потоком байтов. Разделитель записей хранится в специальной переменной $/, и по умолчанию им является символ новой строки \n. Таким образом, если пользователь не устанавливал собственный разделитель записей, то под записью файла в операции <> подразумевается строка текстового файла. Задание другого разделителя записей осуществляется обычной операцией присваивания переменной $/ нового символа или последовательности символов разделителя записей. В листинге 6.9 демонстрируются некоторые приемы чтения из файла операцией <>. Листинг 6.9. Чтение из файла операцией <> #! perl -w open (F1, "in.dat") or die "Ошибка открытия файла: $!"; open(F2, "out.dat") or die "Ошибка открытия файла: $!"; $line1 = ; # Первая запись файла in.dat $line2 = ; # Вторая запись файла in.dat @rest = ; # Оставшиеся записи файла in.flat $/ = ">"; # Задание другого разделителя записей @f2 = ; # Печать прочитанных записей файла out.dat for($i=0; $i<=$#f2; $i++) { print "Запись ".($i+1).": $f2[$i]\n"; } $/ = "\n"; # Восстановление разделителя по умолчании close (Fl) or die $!; close(F2) or die $!; open(F3, "out.dat") or die "Ошибка открытия файла: $!"; print ; # Печать всего файла close(F3) or die $!; Несколько комментариев к программе из листинга 6.9. В переменные $line1 и $line2 читаются соответственно первая и вторая строки файла in.dat, так как используется умалчиваемый разделитель записей \n. Элементы массива @rest хранят строки с третьей по последнюю этого же файла, так как в операторе присваивания операция чтения выполняется в списковом контексте. Перед чтением записей файла out.dat устанавливается новый разделитель записей - символ >. Если файл out.dat, например, содержит только одну строку Иванов> Петров> Сидоров> Конец то элементы массива @f2 будут содержать следующие значения: $f2 = "Иванов>" $f2[l] = "Петров>" $f2 = "Сидоров>" $f2 = "Конец"

ПРИМЕЧАНИЕ Если при создании файла out.dat его единственная строка завершена переходом на новую строку (нажата клавиша Enter), то $f2 будет содержать строку "Конец\n".

В последнем операторе печати программы из листинга 6.9 операция выполняется в списковом контексте, так как функция print() является списковой операцией и ей требуется список значений. Если же мы захотели бы при выводе на печать предварить каждую запись каким-либо текстом и предполагали бы для этого использовать следующий оператор: print "Запись:".; то получили бы распечатку только первой строки файла, так как в этом случае операция будет выполняться в скалярном контексте, создаваемом операцией конкатенации строк (.). Чтобы получить требуемый результат, следовало бы воспользоваться циклом while: while() { print "Запись: ".$_; # Печать очередной строки связанного # с дескриптором F3 файла } Напомним, что если результат операции <> не присваивается никакой переменной, то результат ее выполнения сохраняется в специальной переменной S_. Фактически операция чтения записей <> в Perl реализуется встроенной функцией readline(), которую можно вызывать и непосредственно. Единственным ее параметром является ссылка на дескриптор файла, а так как дескриптор не принадлежит ни к одному из допустимых типов данных (скаляр, массив скаляров или хэш-массив), то следует использовать ссылку на специальный внутренний тип данных Perl typeglob. Для этого достаточно поставить перед дескриптором файла префикс *: readline *ДЕСКРИПТОР; Например, следующие два оператора полностью эквивалентны: $line = ; $line = readline *STDIN; Естественно, все, что говорилось о символах разделения записей, хранящихся в специальной переменной $/, относится и к операции readline(). Запись в файл, открытый в режиме записи или добавления, осуществляется функцией print() с первым параметром, являющимся дескриптором файла: print ДЕСКРИПТОР СПИСОК_ВЫВОДА; Эта операция записывает содержимое элементов списка в том порядке, в котором они определены в вызове функции, и не добавляет в конец списка никакого разделителя записей или символа перехода на новую строку. Об этом должен позаботиться сам программист, либо явно добавляя в конец списка вывода символ разделителя записей или новой строки, либо воспользовавшись возможностью, предоставляемой специальной переменной $\. Функция print добавляет в конец своего списка вывода содержимое этой специальной переменной, которая по умолчанию содержит пустую строку: # Явное задание разделителя записей print F1 @recl1, "\n"; $\ = "\n"; # Установка разделителя записей # Теперь разделитель записей будет выводиться неявно # каждой следующей функцией print print F1 @rесl2;

ВНИМАНИЕ Между дескриптором файла и первым элементом списка вывода не должно быть запятой. Если такое случится, то интерпретатор perl выдаст ошибку: No comma allowed after filehandle.

При записи информации в файл функцией print() можно воспользоваться еще одной полезной возможностью. Если задано значение специальной переменной $, то оно вставляется между элементами списка вывода. Например, если мы хотим, чтобы значения элементов списка выводились не сплошным потоком символов, а были разделены пробелом, то следует установить значение этой специальной переменной равным пробелу: $var1 = "11111"; Svar2 = "22222"; print $var1, $var2, "\n"; $, = " "; print $var1, $var2, "\n"; Первый оператор print напечатает: 1111122222 Тогда как при выполнении второго оператора print мы получим строку: 11111 22222

ВНИМАНИЕ При установке значений специальных переменных $\ и $, их действие распространяется на все последующие вызовы функции print().

Если в функции print не указан дескриптор файла, то по умолчанию вывод осуществляется в стандартный файл вывода с дескриптором STDOUT, а если не задан список вывода, то выводится содержимое специальной переменной $_. Установку дескриптора функции print() по умолчанию можно изменить стандартной функцией select (). Вызванная без параметров, она возвращает текущий дескриптор файла вывода по умолчанию для функций print() и write(). Если ей передается единственный параметр, то этот параметр должен быть дескриптором файла. В этом случае она также возвращает текущий дескриптор по умолчанию и меняет его на дескриптор, определенный переданным ей параметром. Пример использования функции select() приведен ниже. # Сохранение текущего дескриптора по умолчанию и назначение # F1 новым умалчиваемым дескриптором $oldfilehandle = select (Fl); # Вывод в файл, ассоциированный с дескриптором Fl print $line; # Восстановление старого дескриптора по умолчанию select($oldfilehandle); # Вывод в файл, ассоциированный со старым дескриптором print $line; Как уже отмечалось, файлы в Perl интерпретируются как неструктурированные потоки байтов. То, что с помощью операции <> и функции print() мы соответственно читаем или записываем целую последовательность байтов, которую мы называем «записью», ни в коем случае не связано с какой-то определенной структурой файла. Просто эти операции так организованы, что одна читает, а вторая записывает последовательности байтов. В действительности мы можем читать и записывать информацию в файл побайтно. Для каждого открытого файла создается системная переменная, которая отслеживает его текущую позицию, то есть место в файле, начиная с которого функции чтения читают, а функции записи записывают информацию. Следовательно, мы можем говорить, что операции чтения/записи выполняются с текущей позиции файла. При выполнении любой операции чтения/записи указатель текущей позиции файла перемещается на количество прочитанных или записанных байтов. Если, например, была прочитана запись длиной 80 байт с самого начала файла, то следующая операция чтения или записи начнется с позиции 81 байта файла. Для определения текущей позиции в файле используется функция tell(), единственным параметром которой может быть дескриптор файла. Она возвращает текущую позицию в ассоциированном с заданным дескриптором файле. Эта же функция без параметра возвращает текущую позицию в файле, для которого была в программе выполнена последняя операция чтения. Текущая позиция в файле автоматически изменяется в соответствии с выполненными операциями чтения/записи, но ее можно менять и явным образом с помощью функции seek(), которой передаются в качестве параметров дескриптор файла, смещение и точка отсчета. Для связанного с дескриптором файла устанавливается новая текущая позиция, смещенная на заданное параметром СМЕЩЕНИЕ число байтов относительно точки отсчета: seek ДЕСКРИПТОР, СМЕЩЕНИЕ, ТОЧКА__ОТСЧЁТА; Параметр ТОЧКА_ОТСЧЕТА может принимать одно из трех значений: 0 - начало файла, 1 - текущая позиция, 2 - конец файла. Смещение может быть как положительным, так и отрицательным. Оно отрицательно относительно конца файла, положительно относительно начала файла и может быть как положительным, так и отрицательным относительно текущей позиции. Задать точки отсчета можно так же с помощью именованных констант SEEK_SET, SEEK_CUR и SEEK_END, определенных в поставляемом с Perl пакете IO::Seekable, что делает программу лучше читаемой. Эти константы в том порядке, как мы их перечислили, соответствуют началу файла, текущей позиции и концу файла. Для использования указанных именованных констант, естественно, необходимо подключить в программе этот модуль с помощью ключевого слова use . Например, следующие операторы устанавливают одинаковые текущие позиции в файлах: use IO::Seekable: seek FILE1, 5, 0; seek FILE2, 5, SEEK_SET; В языке нет специальных функций перехода в начало или конец файла. Если необходимо позиционировать файл в начало или конец, следует использовать нулевое смещение относительно соответствующих точек отсчета при вызове функции seek(): seek FILE1, 0, 0; # Переход в начало файла seek FILE1, 0, 2; # Переход в конец файла Кроме уже знакомых нам операций чтения записей файла <> и readline(), Perl предоставляет еще две функции чтения содержимого файлов - getc() и read(). Первая читает один байт из файла, тогда как вторая читает записи заданной длины, то есть последовательность байтов определенной длины. Функция getc() читает и возвращает символ в текущей позиции файла, дескриптор которого передан ей в качестве параметра, или неопределенное значение в случае достижения конца файла либо возникновения ошибки. Если функция вызывается без параметра, то она читает символ из стандартного файла ввода STDIN. getc; # Чтение символа из STDIN getc F1; # Чтение символа в текущей позиции файла с # дескриптором F1 Функция read() читает определенное число байтов, начиная с его текущей позиции. Она может вызываться с тремя или четырьмя параметрами, и ее вызов имеет вид: read ДЕСКРИПТОР, ПЕРЕМЕННАЯ, ДЛИНА [,СМЕЩЕНИЕ]; Эта функция читает количество байтов, определенное целым значением параметра ДЛИНА, в скалярную переменную, определяемую параметром ПЕРЕМЕННАЯ, из файла с дескриптором, заданным первым параметром ДЕСКРИПТОР. Возвращаемое значение - действительное количество прочитанных байтов, 0 при попытке чтения в позиции конца файла и неопределенное значение в случае возникновения других ошибок. Необязательный параметр СМЕЩЕНИЕ определяет, после какого байта содержимого переменной ПЕРЕМЕННАЯ будет сохранена прочитанная из файла запись. Он может иметь и отрицательное значение смещения -n (n - целое число). Это означает, что из содержимого переменной ПЕРЕМЕННАЯ отбрасываются последние n байтов и к оставшейся строке добавляется запись, прочитанная из файла. Листинг 6.10 демонстрирует чтение записей определенной длины из файла in.dat, содержащего три строки данных: ******** * PERL * ******** Листинг 6.10. Чтение записей определенной длины #! perl -w open(F1, "in.dat") or die "Ошибка открытия файла: $!"; $str = "1234567890"; read F1, $str, 9; # Чтение девяти байтов в # переменную $str без смещения print $str,"\n"; # $str = "********\n" read F1, $str, 8, length ($str); print $str,"\n"; # $str - "*******\n* PERL *" В программе из листинга 6.10 функция length() используется для определения количества символов (байтов), содержащихся в скалярной переменной. После выполнения первой операции чтения содержимое переменной $str было уничтожено, так как эта функция read () вызывалась без смешения. При втором чтении хранившиеся данные в переменной $str были полностью сохранены. Обратите внимание, что символ перехода на новую строку, содержащийся в первой строке файла in.dat, также учитывается при чтении функцией read() записей определенной длины. Следует не забывать об этом обстоятельстве при чтении информации из «многострочного» файла функцией read().

Небуферизованный ввод-вывод

Функции чтения из файла sysread(), записи в файл syswrite() и установки указателя текущей позиции файла sysseek() являются аналогами рассмотренных нами функций read(),print() и seek(), но, в отличие от последних, они напрямую обращаются к соответствующим функциям операций системы, а не к функциям стандартной библиотеки ввода-вывода С, минуя тем самым создаваемый этими функциями буфер для выполнения операций чтения и записи в файл. Заметим, что аналога буферизованной функции tell () не существует, ее функциональность реализуется функцией sysseek(). При вызове функций небуферизованного чтения и записи им передается одинаковый набор параметров, полностью соответствующий параметрам функции read: sysread ДЕСКРИПТОР, ПЕРЕМЕННАЯ, ДЛИНА [,СМЕЩЕНИЕ]; syswrite ДЕСКРИПТОР, ПЕРЕМЕННАЯ, ДЛИНА [,СМЕЩЕНИЕ]; Возвращаемым значением этих функций является истинное количество соответственно прочитанных или записанных в файл байтов, 0 в случае достижения конца файла или undef при возникновении ошибки. Соответственно набор параметров функции sysseek() полностью соответствует передаваемым параметрам в функцию seek(): sysseek ДЕСКРИПТОР, СМЕЩЕНИЕ, ТОЧКА_ОТСЧЕТА; Все сказанное относительно использования функции seek() полностью переносится и на ее небуферизованный аналог. Функциональность буферизованной операции tell() реализуется следующим вызовом функции sysseek(): $position = sysseek Fl, 0, 1; # Текущая позиция указателя файла Программа демонстрирует использование небуферизованных функций ввода-вывода для обработки содержимого файла. #! perl -w use Fcntl; # Открытие файла в режиме чтение/запись sysopen F1, "in.dat", O_RDWR; # Чтение блока в 14 байтов $read = sysread F1, $string, 14; warn "Прочитано $read байтов вместо 14\n" if $read != 14; # Установка текущей позиции (на 15 байтов) $position = sysseek Fl, 0, 1; die "Ошибка позиционирования: $!\n" unless defined $position; # Запись строки в текущей позиции $string = "Новое Значение"; $written = syswrite F1, $string, length ($string); die "Ошибка записи: $!\n" if $written != length($string); # Закрытие файла close F1 or die $!; При работе с небуферизованными функциями ввода-вывода следует всегда проверять завершение операции чтения, записи или позиционирования. Стандартная система ввода-вывода, через которую реализуется буферизованный ввод-вывод, сама проверяет завершение указанных операций и отвечает за него, если процесс по каким-то причинам был прерван на середине записи. При небуферизованном вводе-выводе об этом должен позаботиться программист.

Perl имеет доступ к тем же основным, помогающим управлять исполнением программ дескрипторам файлов, а именно как: STDIN, STDOUT и STDERR. Более того, возможности для работы с дескрипторами файлов, которые указывают на реальные файлы, в Perl очень обширны и позволяют делать так, чтобы программы обрабатывали файлы любым необходимым образом. С помощью дескрипторов файлов можно открыть файл, передать его в массив, записать информацию в новый файл или даже выполнить все эти операции сразу со многими файлами одновременно.

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

Затем запустите свою программу, указав одно или более имен файлов в командной строке:

# ./myscript.pl filel.txt file2.txt

Это приведет к распечатке содержимого всех указанных файлов, почти так же, как и при использовании команды cat. Такой способ получения доступа к содержимому файлов является удобным и быстрым. Однако он также и достаточно ограниченный; ромбическая операция в принципе представляет собой "вырожденный вариант" истинного дескриптора файла. Давайте рассмотрим несколько заданных должным образом дескрипторов, чтобы увидеть, что они на самом деле могут делать.

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

open (FH,"/path/to/filel.txt");
while ($thisline = )
chomp ($thisline);
print "$i: $thisline\n";

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

open (FH,"/path/to/filel. txt") || die ("Невозможно открыть filel.txt!");

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

open (FH,">/path/to/file2.txt");

print FH $_ foreach (@contents);

open (MAIL,"| /usr/sbin/sendmail -oi -t");
print MAIL "Subject: Важная информация!\n\n";
print MAIL $_ foreach (@contents);

Дескриптор файла передается в качестве аргумента команде print; здесь важно понимать следующее: если только не был указан какой-то другой дескриптор, предполагается, что этим аргументом является встроенный дескриптор файлов (стандартный вывод). Также еще имеется дескриптор (стандартный ввод). Чтобы указать дескриптор устройства ввода-вывода, который должен использоваться по умолчанию, применяйте функцию select(

В таком случае вам не придется все время вводить print FH. Однако вам обязательно нужно будет изменить дескриптор обратно ка STDOUT. когда вы закончите работать с FH.

Для работы с каталогами доступны свои функции: opendir () и readdir (); вы можете открыть каталог и прочитать его содержимое в массив следующим образом:

opendir (DIR,"/path/to/dir");

Perl использует технику, называемую переменную дескриптор файла для работы тип файла.

Чтение или запись данных из файла требует использования дескрипторов файлов.

Ручка файла (дескриптор файла) является наименовании соединений ввода / вывода.

Perl предоставляет три файла ручками: STDIN, STDOUT, STDERR, представляющие стандартный ввод, стандартный вывод и стандартный вывод ошибок.

Perl файлы могут быть открыты в следующих способов:

Open FILEHANDLE, EXPR open FILEHANDLE sysopen FILEHANDLE, FILENAME, MODE, PERMS sysopen FILEHANDLE, FILENAME, MODE

Параметр Описание:

EXPR: имя файла и тип доступа к файлу, состоящий из выражения.
РЕЖИМ: тип файла доступа.
Завивке: доступ Bit (биты прав доступа).

Открытая функция

Мы используем следующую функцию кода, чтобы открыть режим только для чтения (<), чтобы открыть файл file.txt:

Open(DATA, "

<Только для чтения представление.

Код файла DATA Ручка используется для чтения файла, следующий пример будет открыть файл и содержимое файла на выходе:

#!/usr/bin/perl open(DATA, "){ print "$_"; }

Следующий код для записи (>) способ открыть файл file.txt:

Open(DATA, ">file.txt") or die "file.txt 文件无法打开, $!";

> Для режима записи.

Если вам нужно открыть файл в режиме чтения-записи, перед> или <символ знак +, чтобы добавить:

Open(DATA, "+

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

Open DATA, "+>file.txt" or die "file.txt 文件无法打开, $!";

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

Open(DATA,">>

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

Open(DATA,"+>>file.txt") || die "file.txt 文件无法打开, $!";

В следующей таблице перечислены различные режимы доступа:

режим	описание
<Или г
> Или ж
>> Или	Открыть для записи указатель файла в конец файла. Если файл не существует, делается попытка создать.
+ <Или г +
+> Или ш +	Открыть для чтения и записи, указатель файла в заголовок файла и размер файла обрезается до нуля. Если файл не существует, делается попытка создать.
>> + Или +	Открыть для чтения и записи указатель файла в конец файла. Если файл не существует, делается попытка создать.

функция SysOpen

ФункцияSysOpen аналогична открыть функцию, но они не являются такими же формой аргумента.

Следующий пример основан на чтение и запись (+ <имя файла) способ, чтобы открыть файл:

Sysopen(DATA, "file.txt", O_RDWR);

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

Sysopen(DATA, "file.txt", O_RDWR|O_TRUNC);

Вы можете использовать O_CREAT, чтобы создать новый файл, O_WRONLY записи только режим, O_RDONLY режим только чтения.

Параметры завивке восьмеричное значение свойства указывает на то, что права доступа к файлам после создания, по умолчанию0x666.

В следующей таблице перечислены возможные значения режима:

режим	описание
O_RDWR	Открыть для чтения и записи, указатель файла в заголовке файла.
O_RDONLY	Открыть только для чтения указатель файла в заголовке файла.
O_WRONLY	Открыть для записи указатель файла в заголовке файла и размер файла обрезается до нуля. Если файл не существует, делается попытка создать.
O_CREAT	Создайте файл
O_APPEND	Append File
O_TRUNC	Размер файла режется до нуля
O_EXCL	Если вы используете O_CREAT файл существует, он возвращает сообщение об ошибке, он может проверить, существует ли файл
O_NONBLOCK	Неблокирующая операций ввода / вывода, так что мы либо успеха или немедленно возвращает ошибку, не блокирован.

Закрыть функция

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

Close FILEHANDLE close

FILEHANDLE для указанного дескриптора файла, если успешно закрыта возвращается верно.

Close(DATA) || die "无法关闭文件";

Чтение и запись файлов

Чтение и запись информации в файл Есть несколько различных способов:

оператор

Основной метод чтения информации из открытого дескриптора файла является оператор. В скалярном контексте он возвращает одну строку из дескриптора файла. Например:

#!/usr/bin/perl print "本教程网址?\n"; $name = ; print "网址：$name\n";

После реализации описанной выше процедуры следующая информация, мы вводим вывод URL оператор печати:

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

Реализация создает import.txt файл, следующим образом:

$ cat import.txt 1 2 3

#!/usr/bin/perl open(DATA,"; print @lines; # 输出数组内容 close(DATA);

функция ЕОКП

xgetc функция возвращает один символ из указанного FILEHANDLE, если вы не указываете обратный STDIN:

Getc FILEHANDLE getc

В случае возникновения ошибки, или дескриптор файла в конце файла, то она возвращает ФДООН.

функция чтения

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

Эта функция используется для чтения двоичных данных из файла.

Read FILEHANDLE, SCALAR, LENGTH, OFFSET read FILEHANDLE, SCALAR, LENGTH

Параметр Описание:

FILEHANDLE: дескрипторов файлов, используемых для хранения уникального идентификатора для файла.
СКАЛЯР: Начать чтение позиции.
Длина: длина содержимого чтения.
OFFSET: смещение.

В случае успешного возвращения, чтобы прочитать количество прочитанных байтов, возвращает 0, если конец файла, если произошла ошибка возврата UNDEF.

функция печати

Для вся информация считывается из функций дескриптор файла на заднем конце основной функции заключается в написании печати:

Print FILEHANDLE LIST print LIST print

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

Print "Hello World!\n";

копирование файлов

В следующем примере мы открываем существующий файл file1.txt, и читать его каждую строку записывается в файл file2.txt в:

#!/usr/bin/perl # 只读方式打开文件 open(DATA1, "file2.txt"); # 拷贝数据 while() { print DATA2 $_; } close(DATA1); close(DATA2);

Переименовать файл

Ниже приведены примеры, мы уже существующий файл file1.txt переименовать file2.txt, каталог, указанный в / USR / w3big / тест / в:

#!/usr/bin/perl rename ("/usr/w3big/test/file1.txt", "/usr/w3big/test/file2.txt");

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

Удалить файлы

Следующие примеры показывают, как мы используем функциюUNLINK , чтобы удалить этот файл:

#!/usr/bin/perl unlink ("/usr/w3big/test/file1.txt");

Укажите расположение файла

Вы можете использовать функциюСКАЖИТЕ, чтобы получить местоположение файла, а также указать местоположение в файле с помощью функции искать:

скажите функцию

Функция скажите используется для получения местоположения файла:

Tell FILEHANDLE tell

Если FILEHANDLE функция возвращает позицию указателя файла в байтах. Если вы не укажете возврат к умолчанию выбирается ручкой файла.

искать функцию

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

Seek FILEHANDLE, POSITION, WHENCE

Параметр Описание:

FILEHANDLE: дескрипторов файлов, используемых для хранения уникального идентификатора для файла.
ПОЛОЖЕНИЕ: указывает количество байтов дескриптора файла (чтение-запись указателя позиции), чтобы переместить.
ОТКУДА: представляет собой дескриптор файла (для чтения и записи указателей местоположения) начинают, когда начальное положение, вы можете принимать значение 0, 1; обозначают начало файла, текущей позиции и конец файла.

Seek DATA, 256, 0;

информация о файле

Perl файловые операции также может проверить, существует ли файл и читать и писать.

Что я могу создать file1.txt файл, например, в следующем:

$ cat file1.txt www..txt"; my (@description, $size); if (-e $file) { push @description, "是一个二进制文件" if (-B _); push @description, "是一个socket(套接字)" if (-S _); push @description, "是一个文本文件" if (-T _); push @description, "是一个特殊块文件" if (-b _); push @description, "是一个特殊字符文件" if (-c _); push @description, "是一个目录" if (-d _); push @description, "文件存在" if (-x _); push @description, (($size = -s _)) ? "$size 字节" : "空"; print "$file 信息：", join(", ",@description),"\n"; }

Вышеприведенная программа, выход:

File1.txt 信息：是一个文本文件, 15 字节

Файл операторы тестирования в следующей таблице:

операторы	описание
-А	Файл первого обращения времени (единицы: дней)
-B	Является ли это двоичный файл
-С	Файл (индексных дескрипторов) инод время модификации (единицы измерения: дней)
-М	Файл последнего изменения времени (единицы измерения: дней)
-О	Все файлы являются реальными UID
-R	Файл или каталог может быть прочитан реальным UID / GID
-S	Сокет (Socket)
-T	Является ли это текстовый файл
-W	Файл или каталог может быть записан в режиме реального UID / GID
-X	Файлы или каталоги могут быть выполнены в режиме реального UID / GID
-b	Файл блок-специальное (специальный блок) (например, монтирования диска)
-с	Символ-специальное (специальные символы) файл (например, устройства ввода / вывода)
-d	каталог
-е	Имя файла или каталога существует
-f	Обычный файл
-g	Файл или каталог имеет атрибут setgid
-k	Файл или каталог имеет липкий бит
-l	Это является символической ссылкой
-о	Все файлы доступны UID
-p	Файл является именованным каналом (FIFO)
-r	Файлы могут быть эффективно UID / GID чтения
-s	Файл или каталог существует и не 0 (возвращает число байт)
-t	Ручка Файл TTY (функция isatty система () возвращает результат, имя файла не может использовать этот тест)
-u	Файл или каталог имеет атрибут Setuid
-w	Файлы могут быть записаны в действительный UID / GID
-x	Файлы могут быть выполнены эффективно UID / GID
-z	Файл существует, размер 0 (константа каталога ложно), то есть, пуст ли файл,

О том, что такое файл писать я надеюсь ненужно, но думаю нужно подумать над тем, что с ними можно делать, как видно из заголовка статьи, на Perl. Ну, приступим...

В этой статье обсудим:

Манипуляции с файлом
Работа со строками в файле
Что такое файловые манипуляторы, и с чем их едят

Доступ к файлам осуществляется с помощью файловых манипуляторов, которые представляют собой так сказать синоним файла. Они не являются переменными, а поэтому их нельзя непосредственно присваивать другим переменным или передавать в функции (для этого нужно, что называется, пойти другим путем).
Есть и стандартные Перловские файловые манипуляторы. Они называются STDIN (стандартный ввод), STDOUT (стандартный вывод) и STDERR (стандартный поток ошибок). Например параметры скрипту из формы передаются именно через STDIN (при условии использования метода POST).
Если понадобится создать копию файлового манипулятора (не файла, а только манипулятора по которому осуществляется доступ к файлу), то можно воспользоваться функцией open (о ней подробнее поговорим позже).
Пример: open(FILL,"file.txt"); open(FAIL,"<&FILL");
О присваивании переменным файловых манипуляторов:
$handle=*FILL; или передать его в функцию: some_sub(*FILL);
И под конец скажу, что файловые манипуляторы в Perl используются не только для связи с, собственно, файлом. Они могут быть связаны с каким-нибудь процессом, сокетом и т.д. Но это не входит в тематику статьи.
Манипуляции с файлом

Открытие файла осуществляется функцией open.
Open(FFF,"> file.txt");
Разберемся. У функции три параметра: FFF - название файлового манипулятора (его задаете вы), режим доступа ">" и "file.txt" - имя нужного вам файла. Есть три основных режима: ">" - запись,"<"- чтение, ">>"- добавление в файл.
Есть еще функция sysopen. Работа с ней не на много сложнее, чем с open, зато с ее помощью вы сможете более детально "сказать" системе о ваших намерениях (то есть то, что вы хотите сделать с файлом).
В sysopen три обязательных параметра и один необязательный.
Например: sysopen(FH,$name, $flags, $param);
FH - собственно, файловый манипулятор, $name - имя файла в чистом виде (без ">" и др.). В $flags помещаем число, полученное объединением нижеописанных констант через OR (|):

Это, конечно, не полный перечень, но здесь перечислены самые необходимые и часто используемые константы.
И наконец $param. Этот параметр задает маску доступа к файлу и записывается в восьмеричной системе. Обычно используется значение 0666 (значение по умолчанию, то есть если $param опущен), или 0777. Первое значение используется для обычных файлов, второе же для каталогов и исполняемых файлов.
Пример открытия файла для записи (если не найден - создается):
Sysopen(FH,"data.txt",O_WRONLY|O_TRUNC|O_CREATE);
Запись в файл делаем функцией print.
Print(FFF "oppa! Пишем в файл!");
Здесь FFF - имя файлового манипулятора, а строка в кавычках - текст, который мы хотим записать в файл, ассоциированный с FFF.
Если до попытки открытия файла не существовало, то функция open его создаст, а если файл был, и он был не пустой, то после вышеуказанной функции print, в нем ничего не останется от предыдущей информации, а записана будет та ерунда, которую я там вписал.
Как уже было сказано, существуют три стандартных файловых манипулятора, и при опущенном файловом манипуляторе функция print осуществит вывод в STDOUT (то же относится к функциям printf и write). Чтобы изменить направление вывода в Perl предусмотрена функция select (правда не только для этого). Пример:
Open(F1,"> one.txt"); print "Файл открыт! Пишем в STDOUT."; $old_point=select(F1); print "Пишем в файл one.txt"; select($old_point); print "Снова пишем в STDOUT."; close(F1);
Закрываем файл функцией close.
Close(FFF);
Принцип убирать за собой прививается всем с детства. Давайте не забывать об этом и в программировании, хотя при завершении процесса, в котором был открыт данный файл, файл закрывается автоматически.
Блокировка файла
Во-первых для чего? А для того, что если несколько процессов хотят одновременно заполучить доступ к файлу, причем на запись, причем еще и хотят туда что-то писать (кошмар), то представьте, что оказалось бы, если не этот чудный механизм блокировки. Он позволяет, грубо говоря, ставить процессы в очередь. Делаем так:
Open(FIL,"> file.dat"); flock(FIL,2); close(FIL);
О функциях open и close уже говорили, а на flock остановимся немного подробнее. Она получает два параметра - файловый манипулятор и, образно говоря, категорию блокировки.
1 совместная блокировка (для чтения)
2 монопольная блокировка (для записи)
4 асинхронный запрос блокировки
8 снятие блокировки
Про снятие блокировки: блокировка автоматически снимается при завершении процесса, вызванного текущим скриптом, либо при закрытии файлового манипулятора, который "привязан" к заблокированному файлу. Если вы снимаете блокировку вручную, будьте аккуратны - вы даете возможность другому процессу делать с (ВНИМАНИЕ!) не закрытым вами файлом все что ему угодно! Последствия могут быть, мягко говоря, неприятные, а грубо говоря - непредсказуемые (для вас непредсказуемые).
Работа со строками в файле

Так как именно те файлы, которые содержат строковую информацию составляют наибольший интерес для, собственно, человека, то и речь сейчас пойдет именно о них.
Для чтения строк из файла используется файловый манипулятор "поставленный" в <>.
Например:
Open(FIL,"data.txt"); while() { # делаем что-то с каждой строкой файла }
Если не указано иначе, то внутри такого цикла используется стандартная переменная "$_", а номер строки записывается в "$.". Так как конец строки обозначается спецсимволом, например "\n", для получения самой строки (без эдакого "хвоста") нужно ее усечь функцией chomp.
Open(FIL,"data.txt"); while() { chomp; # отрезается спецсимвол от переменной $_ print; # пишем $_ на STDOUT }
@strings=; foreach $line (@strings) { print $list; }
Для передвижения по файлу используются функции tell и seek.
Open(FIL,"data.txt"); $position=tell(FIL); print "Текущая позиция в файле $position. \n"; seek(FIL,$position+10,1); print "А теперь переместились на 10 байт к концу файла от текущей позиции. \n"; $position=tell(FIL); print "Теперь текущая позиция в файле $position. \n";
Результат:
Текущая позиция в файле 0. А теперь переместились на 10 байт к концу файла. Теперь текущая позиция в файле 10.
Функция tell принимает в качестве параметра файловый манипулятор, а seek берет три параметра. Первый - файловый манипулятор, второй - смещение в байтах, третий - направление смещение. Есть три направления смещения: 0 - от начала файла, 1 - от текущей позиции, 2 - с конца файла.
Нельзя сказать, что это все, что нам предлагает Perl для работы с файлами. Будем надеяться, что у меня будет время на то, чтобы написать о том, как работать с каталогами, тонкости при работе с бинарными файлами, объектно-ориентированный подход к управлению файлами и их содержимым.