perlfunc

СОДЕРЖАНИЕ

ИМЯ
ОПИСАНИЕ

ИМЯ

perlfunc - встроенные функции Perl

ОПИСАНИЕ

Функции в этом разделе могут использоваться в выражениях. Они делятся на две основные категории: операторы списков и именованные унарные операторы. Они различаются по отношению к приоритета с последующей запятой. (См. таблицу приоритетов в perlop.) Операторы списков принимают более одного аргумента, а унарные операторы никогда не принимают более одного аргумента. Таким образом, запятая завершает аргумент унарного оператора, но просто разделяет аргументы оператора списка. Унарный оператор обычно предоставляет скалярный контекст своему аргументу, а оператор списка может предоставлять либо скалярный, либо списковый контексты для своих аргументов. Если он делает и то, и другое, скалярные аргументы идут первыми, а аргументы списка следуют за ними, и может быть только один такой аргумент списка. Например, splice имеет три скалярных аргумента, за которыми следует список, тогда как gethostbyname имеет четыре скалярных аргумента.

В синтаксических описаниях, которые следуют далее, операторы списков, которые ожидают список (и предоставляют списковый контекст для элементов списка), показаны с аргументом LIST. Такой список может состоять из любой комбинации скалярных аргументов или значений списков; значения списка будут включены в список так, как если бы каждый отдельный элемент был интерполирован в этом месте в списке, образуя более длинное одномерное значение списка. Запятые должны разделять буквальные элементы LIST.

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

print 1+2+4;      # Prints 7.
print(1+2) + 4;   # Prints 3.
print (1+2)+4;    # Also prints 3!
print +(1+2)+4;   # Prints 7.
print ((1+2)+4);  # Prints 7.

Если вы запускаете Perl с прагмой use warnings, она может предупредить вас об этом. Например, третья строка выше приводит к:

print (...) interpreted as function at - line 1.
Useless use of integer addition in void context at - line 1.

Некоторые функции вообще не принимают аргументов и поэтому не являются ни унарными, ни операторами списка. К ним относятся такие функции, как time и endpwent. Например, time+86_400 всегда означает time() + 86_400.

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

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

Именованный массив в скалярном контексте существенно отличается от того, что, на первый взгляд, может показаться списком в скалярном контексте. Вы не можете получить список, подобный (1,2,3) в скалярном контексте, потому что компилятор знает контекст во время компиляции. Он сгенерирует скалярный оператор запятой, а не версию конкатенации списка запятой. Это означает, что это никогда не был список с самого начала.

В целом, функции в Perl, которые служат оболочками для системных вызовов (сисколов) с тем же именем (например, chown(2), fork(2), closedir(2) и т. д.) возвращают true, если они выполнились успешно, и undef в противном случае, как обычно упоминается в описаниях ниже. Это отличается от интерфейсов C, которые возвращают -1 при ошибке. Исключениями из этого правила являются wait, waitpid и syscall. Системные вызовы также устанавливают специальную переменную $! при ошибке. Другие функции не делают этого, за исключением случайностей.

Модули расширения также могут подключиться к парсеру Perl для определения новых типов выражений с ключевыми словами. Они могут выглядеть как функции, но могут также выглядеть совершенно по-другому. Синтаксис после ключевого слова определяется полностью расширением. Если вы разработчик, см. "PL_keyword_plugin" в perlapi для механизма. Если вы используете такой модуль, см. документацию модуля для получения подробностей о синтаксисе, который он определяет.

Функции Perl по категориям

Вот функции Perl (включая вещи, которые выглядят как функции, такие как некоторые ключевые слова и именованные операторы), расположенные по категориям. Некоторые функции встречаются более чем в одном месте. Любые предупреждения, включая предупреждения, генерируемые ключевыми словами, описаны в perldiag и warnings.

Функции для SCALAR или строк

chomp, chop, chr, crypt, fc, hex, index, lc, lcfirst, length, oct, ord, pack, q//, qq//, reverse, rindex, sprintf, substr, tr///, uc, ucfirst, y///

fc доступна только если включена функция "fc" или если она префиксна CORE::. Функция "fc" автоматически включается с объявлением use v5.16 (или выше) в текущем пространстве имён.

Регулярные выражения и сопоставление с шаблоном

m//, pos, qr//, quotemeta, s///, split, study

Числовые функции

abs, atan2, cos, exp, hex, int, log, oct, rand, sin, sqrt, srand

Функции для массивов @ARRAY

each, keys, pop, push, shift, splice, unshift, values

Функции для данных списков

grep, join, map, qw//, reverse, sort, unpack

Функции для ассоциативных массивов %HASH

delete, each, exists, keys, values

Функции ввода-вывода

binmode, close, closedir, dbmclose, dbmopen, die, eof, fileno, flock, format, getc, print, printf, read, readdir, readline, rewinddir, say, seek, seekdir, select, syscall, sysread, sysseek, syswrite, tell, telldir, truncate, warn, write

say доступна только если включена функция "say" или если она префиксна CORE::. Функция "say" автоматически включается с объявлением use v5.10 (или выше) в текущем пространстве имён.

Функции для данных или записей фиксированной длины

pack, read, syscall, sysread, sysseek, syswrite, unpack, vec

Функции для дескрипторов файлов, файлов или каталогов

-X, chdir, chmod, chown, chroot, fcntl, glob, ioctl, link, lstat, mkdir, open, opendir, readlink, rename, rmdir, select, stat, symlink, sysopen, umask, unlink, utime

Ключевые слова, связанные с управлением потоком вашей программы Perl

break, caller, continue, die, do, dump, eval, evalbytes, exit, __FILE__, goto, last, __LINE__, next, __PACKAGE__, redo, return, sub, __SUB__, wantarray

break доступно только при включении экспериментальной функции "switch" или использовании префикса CORE::. Функция "switch" также включает инструкции default, given и when, которые описаны в "Switch Statements" в perlsyn. Функция "switch" автоматически включается с объявлением use v5.10 (или выше) в текущем объёме. В Perl v5.14 и более ранних версиях, continue требовала "switch", как и другие ключевые слова.

evalbytes доступно только с функцией "evalbytes" (см. feature) или с префиксом CORE::. __SUB__ доступно только с "current_sub" или с префиксом CORE::. Обе функции "evalbytes" и "current_sub" включаются автоматически с объявлением use v5.16 (или выше) в текущем объёме.

Ключевые слова, связанные со сферой видимости

caller, import, local, my, our, package, state, use

state доступно только при включенной функции "state" или с префиксом CORE::. Функция "state" автоматически включается с объявлением use v5.10 (или выше) в текущем объёме.

Разные функции

defined, formline, lock, prototype, reset, scalar, undef

Функции для процессов и групп процессов

alarm, exec, fork, getpgrp, getppid, getpriority, kill, pipe, qx//, readpipe, setpgrp, setpriority, sleep, system, times, wait, waitpid

Ключевые слова, связанные с модулями Perl

do, import, no, package, require, use

Ключевые слова, связанные с классами и объектно-ориентированным программированием

bless, dbmclose, dbmopen, package, ref, tie, tied, untie, use

Функции низкого уровня для сокетов

accept, bind, connect, getpeername, getsockname, getsockopt, listen, recv, send, setsockopt, shutdown, socket, socketpair

Функции межпроцессного взаимодействия System V

msgctl, msgget, msgrcv, msgsnd, semctl, semget, semop, shmctl, shmget, shmread, shmwrite

Получение информации о пользователях и группах

endgrent, endhostent, endnetent, endpwent, getgrent, getgrgid, getgrnam, getlogin, getpwent, getpwnam, getpwuid, setgrent, setpwent

Получение сетевой информации

endprotoent, endservent, gethostbyaddr, gethostbyname, gethostent, getnetbyaddr, getnetbyname, getnetent, getprotobyname, getprotobynumber, getprotoent, getservbyname, getservbyport, getservent, sethostent, setnetent, setprotoent, setservent

Функции, связанные со временем

gmtime, localtime, time, times

Ключевые слова, не являющиеся функциями

and, AUTOLOAD, BEGIN, CHECK, cmp, CORE, __DATA__, default, DESTROY, else, elseif, elsif, END, __END__, eq, for, foreach, ge, given, gt, if, INIT, le, lt, ne, not, or, UNITCHECK, unless, until, when, while, x, xor

Переносимость

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

-X, binmode, chmod, chown, chroot, crypt, dbmclose, dbmopen, dump, endgrent, endhostent, endnetent, endprotoent, endpwent, endservent, exec, fcntl, flock, fork, getgrent, getgrgid, gethostbyname, gethostent, getlogin, getnetbyaddr, getnetbyname, getnetent, getppid, getpgrp, getpriority, getprotobynumber, getprotoent, getpwent, getpwnam, getpwuid, getservbyport, getservent, getsockopt, glob, ioctl, kill, link, lstat, msgctl, msgget, msgrcv, msgsnd, open, pipe, readlink, rename, select, semctl, semget, semop, setgrent, sethostent, setnetent, setpgrp, setpriority, setprotoent, setpwent, setservent, setsockopt, shmctl, shmget, shmread, shmwrite, socket, socketpair, stat, symlink, syscall, sysopen, system, times, truncate, umask, unlink, utime, wait, waitpid

Для получения дополнительной информации о переносимости этих функций, см. perlport и другую документацию, специфичную для платформы.

Алфавитный список функций Perl

-X FILEHANDLE

-X EXPR

-X DIRHANDLE

-X

Тест файла, где X — одна из перечисленных ниже букв. Этот унарный оператор принимает один аргумент: имя файла, дескриптор файла или дескриптор каталога, и проверяет связанный файл, чтобы определить, истинно ли что-то о нём. Если аргумент опущен, проверяется $_, за исключением -t, который проверяет STDIN. Если не указано иное, возвращает 1 для истинного значения и '' для ложного. Если файл не существует или не может быть проверен, возвращает undef и устанавливает $! (errno). За исключением теста -l, все они следуют за символическими ссылками, так как используют stat(), а не lstat() (поэтому висячие символические ссылки не могут быть проверены и, следовательно, сообщат об ошибке).

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

-r  File is readable by effective uid/gid.
-w  File is writable by effective uid/gid.
-x  File is executable by effective uid/gid.
-o  File is owned by effective uid.

-R  File is readable by real uid/gid.
-W  File is writable by real uid/gid.
-X  File is executable by real uid/gid.
-O  File is owned by real uid.

-e  File exists.
-z  File has zero size (is empty).
-s  File has nonzero size (returns size in bytes).

-f  File is a plain file.
-d  File is a directory.
-l  File is a symbolic link (false if symlinks aren't
    supported by the file system).
-p  File is a named pipe (FIFO), or Filehandle is a pipe.
-S  File is a socket.
-b  File is a block special file.
-c  File is a character special file.
-t  Filehandle is opened to a tty.

-u  File has setuid bit set.
-g  File has setgid bit set.
-k  File has sticky bit set.

-T  File is an ASCII or UTF-8 text file (heuristic guess).
-B  File is a "binary" file (opposite of -T).

-M  Script start time minus file modification time, in days.
-A  Same for access time.
-C  Same for inode change time (Unix, may differ for other
    platforms)

Пример:

while (<>) {
    chomp;
    next unless -f $_;  # ignore specials
    #...
}

Обратите внимание, что -s/a/b/ не выполняет отрицательную подстановку. Однако -exp($foo) по-прежнему работает как ожидается: только одиночные буквы, следующие за знаком минус, интерпретируются как тесты файлов.

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

-s($file) + 1024   # probably wrong; same as -s($file + 1024)
(-s $file) + 1024  # correct

Интерпретация операторов проверки разрешений на доступ к файлу -r, -R, -w, -W, -x и -X по умолчанию основана исключительно на режиме файла и идентификаторах пользователя и группы. Могут быть и другие причины, по которым вы не можете прочитать, записать или выполнить файл: например, системные ограничения доступа к сетевым файловым системам, ACL (списки управления доступом), файловые системы только для чтения и нераспознанные форматы исполняемых файлов. Обратите внимание, что использование этих шести конкретных операторов для проверки возможности выполнения какой-либо операции обычно является ошибкой, так как это может привести к проблемам с конкурентным доступом.

Также обратите внимание, что для суперпользователя в локальных файловых системах тесты -r, -R, -w и -W всегда возвращают 1, а -x и -X возвращают 1, если в режиме установлен какой-либо бит выполнения. Таким образом, скрипты, выполняемые суперпользователем, могут потребовать выполнить stat для определения фактического режима файла или временно изменить свой фактический идентификатор пользователя на что-то другое.

Если вы используете ACL, существует прагма под названием filetest, которая может давать более точные результаты, чем простые биты режима stat. В среде use filetest 'access', упомянутые выше тесты файлов проверяют, может ли разрешение быть предоставлено с помощью семейства системных вызовов access(2). Также обратите внимание, что тесты -x и -X в этой прагме могут возвращать true даже если нет установленных битов разрешения на выполнение (или дополнительных ACL разрешений на выполнение). Эта странность связана с определениями базовых системных вызовов. Также обратите внимание, что из-за реализации use filetest 'access', специальный дескриптор файла _ не будет кэшировать результаты тестов файла, когда эта прагма активна. Для получения дополнительной информации ознакомьтесь с документацией прагмы filetest.

Тесты -T и -B работают следующим образом. Первый блок или часть файла проверяется на соответствие допустимому кодированию UTF-8, включающему символы, отличные от ASCII. Если это так, это -T файл. В противном случае та же часть файла проверяется на наличие нестандартных символов, таких как необычные управляющие коды или символы с установленным старшим битом. Если более трети символов необычны, это -B файл; в противном случае это -T файл. Кроме того, любой файл, содержащий нулевой байт в проверенной части, считается бинарным файлом. (Если выполняется в рамках use locale, включающего LC_CTYPE, необычные символы — это всё, что не является печатным символом или пробелом в текущем локали.) Если -T или -B используется с дескриптором файла, проверяется текущий буфер ввода-вывода, а не первый блок. Оба -T и -B возвращают true для пустого файла или файла в конце файла при тестировании дескриптора файла. Поскольку для проверки -T необходимо читать файл, в большинстве случаев вы сначала хотите использовать -f для файла, как в next unless -f $file && -T $file.

Если любой из тестов файлов (или операторы stat или lstat) получает специальный дескриптор файла, состоящий из одиночной подчёркивающей черты, то используется структура stat предыдущего теста файла (или оператора stat), что экономит системный вызов. (Это не работает с -t, и вам нужно помнить, что lstat и -l оставляют значения в структуре stat для символической ссылки, а не для реального файла.) (Кроме того, если буфер stat был заполнен вызовом lstat, -T и -B перезапишут его результатами stat _). Пример:

print "Can do.\n" if -r $a || -w _ || -x _;

stat($filename);
print "Readable\n" if -r _;
print "Writable\n" if -w _;
print "Executable\n" if -x _;
print "Setuid\n" if -u _;
print "Setgid\n" if -g _;
print "Sticky\n" if -k _;
print "Text\n" if -T _;
print "Binary\n" if -B _;

Начиная с Perl 5.10.0, как форма чисто синтаксического сахара, вы можете объединять операторы проверки файлов таким образом, что -f -w -x $file эквивалентно -x $file && -w _ && -f _. (Это просто синтаксический прием: если вы используете возвращаемое значение -f $file как аргумент другому оператору проверки файла, никакого специального волшебства не произойдёт.)

Проблемы с переносимостью: "-X" в perlport.

Чтобы избежать путаницы у будущих пользователей вашего кода с таинственными синтаксическими ошибками, поместите что-то вроде этого в начало вашего скрипта:

use 5.010;  # so filetest ops can stack

abs VALUE

abs

Возвращает абсолютное значение своего аргумента. Если VALUE опущен, используется $_.

accept NEWSOCKET,GENERICSOCKET

Принимает входящее соединение сокета, как и accept(2). Возвращает упакованный адрес, если успешно, иначе false. Смотрите пример в "Sockets: Client/Server Communication" в perlipc.

В системах, которые поддерживают флаг закрытия при exec для файлов, этот флаг будет установлен для вновь открытого дескриптора файла, как определено значением $^F. Смотрите "$^F" в perlvar.

alarm SECONDS

alarm

Задает процесс, который получит SIGALRM, после того как пройдет указанное количество секунд реального времени. Если SECONDS не указан, используется значение, сохранённое в $_. (К сожалению, в некоторых машинах время, которое прошло, может быть на одну секунду меньше или больше, чем вы указали, из-за того, как учитываются секунды, и планировщик задач может еще больше задерживать доставку сигнала.)

Одновременно может работать только один таймер. Каждый вызов отключает предыдущий таймер, и в качестве аргумента можно передать 0, чтобы отменить предыдущий таймер, не запуская новый. Возвращаемое значение — оставшееся время на предыдущем таймере.

Для задержек с большей точностью, чем одна секунда, модуль Time::HiRes (из CPAN и начиная с Perl 5.8, входит в стандартное распределение) предоставляет ualarm. Вы также можете использовать четырёх-аргументную версию Perl select с оставленными первыми тремя аргументами неопределенными, или вы можете использовать интерфейс syscall для доступа к setitimer(2), если ваша система его поддерживает. Подробности см. в perlfaq8.

Обычно ошибочно смешивать вызовы alarm и sleep, потому что sleep на вашей системе может быть реализовано с помощью alarm.

Если вы хотите использовать alarm для ограничения системного вызова, вам необходимо использовать пару eval/die. Вы не можете полагаться на то, что сигнал вызовет ошибку системного вызова с установленным $! в EINTR, потому что Perl устанавливает обработчики сигналов для повторного запуска системных вызовов на некоторых системах. Использование eval/die всегда работает, с оговорками, указанными в "Signals" в perlipc.

eval {
    local $SIG{ALRM} = sub { die "alarm\n" }; # NB: \n required
    alarm $timeout;
    my $nread = sysread $socket, $buffer, $size;
    alarm 0;
};
if ($@) {
    die unless $@ eq "alarm\n";   # propagate unexpected errors
    # timed out
}
else {
    # didn't
}

Для получения дополнительной информации см. perlipc.

Проблемы с переносимостью: "alarm" в perlport.

atan2 Y,X

Возвращает арктангенс Y/X в диапазоне от -PI до PI.

Для операции тангенса вы можете использовать функцию Math::Trig::tan или использовать привычное соотношение:

sub tan { sin($_[0]) / cos($_[0])  }

Возвращаемое значение для atan2(0,0) определяется реализацией; обратитесь к странице справки atan2(3) для получения дополнительной информации.

Проблемы с переносимостью: "atan2" в perlport.

bind SOCKET,NAME

Привязывает сетевой адрес к сокету, как и bind(2). Возвращает true, если успешно, иначе false. NAME должен быть упакованным адресом соответствующего типа для сокета. Смотрите примеры в "Sockets: Client/Server Communication" в perlipc.

binmode FILEHANDLE, LAYER

binmode FILEHANDLE

Настраивает FILEHANDLE для чтения или записи в режиме «двоичный» или «текстовый» на системах, где runtime-библиотеки различают двоичные и текстовые файлы. Если FILEHANDLE является выражением, значение принимается как имя файлового дескриптора. Возвращает true при успехе, иначе возвращает undef и устанавливает $! (errno).

На некоторых системах (в основном на системах DOS и Windows) binmode необходимо, когда вы работаете не с текстовым файлом. Для обеспечения переносимости рекомендуется всегда использовать его, когда это уместно, и никогда не использовать его, когда это неуместно. Также пользователи могут установить своё ввод-вывод по умолчанию с кодировкой UTF8-Unicode, а не байтами.

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

Если LAYER присутствует, это строка, но может содержать несколько директив. Директивы изменяют поведение файлового дескриптора. При наличии LAYER использование binmode для текстового файла имеет смысл.

Если LAYER отсутствует или указан как :raw, файловый дескриптор делается пригодным для передачи двоичных данных. Это включает отключение возможного преобразования CRLF и маркировку его как байтов (а не символов Unicode). Обратите внимание, что, несмотря на то, что может подразумеваться в «Programming Perl» (Camel, 3-е издание) или где-либо ещё, :raw не просто обратное значение :crlf. Также отключаются другие слои, которые влияли бы на двоичный характер потока. См. PerlIO, perlrun и обсуждение переменной среды PERLIO.

:bytes, :crlf, :utf8, и любые другие директивы в форме :..., называются слоями ввода-вывода.

Параметр LAYER функции binmode описан как «ДИСЦИПЛИНА» в «Programming Perl, 3-е издание». Однако с момента публикации этой книги, известной многим как «Camel III», общепринятое название этой функциональности изменилось с «дисциплина» на «слой». Поэтому вся документация этой версии Perl относится к «слоям», а не к «дисциплинам». Теперь вернёмся к обычному документированию…

Для обозначения FILEHANDLE как UTF-8 используйте :utf8 или :encoding(UTF-8). :utf8 просто помечает данные как UTF-8 без дальнейшей проверки, а :encoding(UTF-8) проверяет данные на соответствие действительной валидной кодировке UTF-8. Более подробную информацию можно найти в PerlIO::encoding.

В общем случае, binmode следует вызывать после open, но перед любыми операциями ввода-вывода с файловым дескриптором. Вызов binmode обычно сбрасывает любые ожидающие буферизованные данные вывода (и, возможно, ожидающие входные данные) в дескрипторе. Исключением из этого правила является слой :encoding, который изменяет кодировку символов по умолчанию для дескриптора. Слою :encoding иногда нужно вызывать посреди потока, и он не сбрасывает поток. :encoding также неявно подкладывает на себя слой :utf8, потому что внутренне Perl работает с символами Unicode, закодированными в UTF8.

Операционная система, драйверы устройств, библиотеки C и система выполнения Perl объединяют свои усилия, чтобы программист мог обрабатывать отдельный символ (\n) как терминатор строки, независимо от внешнего представления. На многих операционных системах родное текстовое представление файла соответствует внутреннему представлению, но на некоторых платформах внешнее представление \n состоит из более чем одного символа.

Все варианты Unix, Mac OS (старые и новые), и файлы Stream_LF на VMS используют один символ для завершения каждой строки во внешнем представлении текста (даже если этот единственный символ — возврат каретки на старых, додарвиновских вариантах Mac OS и перевод строки на Unix и большинстве файлов VMS). На других системах, таких как OS/2, DOS и различных вариантах MS Windows, ваша программа видит \n как простой \cJ, но в текстовых файлах хранятся два символа \cM\cJ. Это означает, что если вы не используете binmode на этих системах, последовательности \cM\cJ в диске будут преобразованы в \n при вводе, а любые \n в вашей программе будут преобразованы обратно в \cM\cJ на выходе. Это необходимо для текстовых файлов, но может быть катастрофичным для двоичных файлов.

Ещё одним следствием использования binmode (на некоторых системах) является то, что специальные маркеры конца файла будут восприниматься как часть потока данных. Для систем семейства Microsoft это означает, что если ваши двоичные данные содержат \cZ, система ввода-вывода будет рассматривать это как конец файла, если вы не используете binmode.

binmode важно не только для операций readline и print, но и при использовании read, seek, sysread, syswrite и tell (см. perlport для более подробной информации). См. переменные $/ и $\ в perlvar для того, как вручную установить последовательности завершения строки для ввода и вывода.

Проблемы переносимости: "binmode" в perlport.

bless REF,CLASSNAME

bless REF

Эта функция сообщает сущности, на которую ссылается REF, что она теперь является объектом в пакете CLASSNAME. Если CLASSNAME пустая строка, она интерпретируется как ссылка на main пакет. Если CLASSNAME опущена, используется текущий пакет. Поскольку bless часто является последней операцией в конструкторе, она возвращает ссылку для удобства. Всегда используйте версию с двумя аргументами, если производный класс может унаследовать метод, выполняющий благословение. См. perlobj для получения более подробной информации о благословении (и благословениях) объектов.

Подумайте о том, чтобы всегда благословлять объекты в CLASSNAME с смешанным регистром. Имена пространств имён со строчными буквами считаются зарезервированными для Perl-псевдонимов. Встроенные типы имеют имена с прописными буквами. Чтобы избежать путаницы, вы также можете избежать таких имён пакетов. Рекомендуется избегать имени класса 0, потому что много кода ошибочно использует результат ref как булево значение.

См. "Perl Modules" в perlmod.

break

Прервать выполнение блока given.

break доступен только если включена функция "switch" или если он предваряется CORE::. Функция "switch" включается автоматически с объявлением use v5.10 (или выше) в текущем области видимости.

caller EXPR

caller

Возвращает контекст текущего вызова подпрограммы на чистом Perl. В скалярном контексте возвращает имя пакета вызывающего, если есть вызывающий (то есть, если мы находимся в подпрограмме или eval или require), и значение undef в противном случае. caller никогда не возвращает подпрограммы XS, и они пропускаются. Следующая подпрограмма на чистом Perl будет отображаться вместо подпрограммы XS в значениях возвращаемого caller. В списочном контексте caller возвращает

   # 0         1          2
my ($package, $filename, $line) = caller;

С EXPR, возвращает некоторую дополнительную информацию, которую отладчик использует для вывода трассировки стека. Значение EXPR указывает, на сколько кадров вызова вернуться назад до текущего.

   #  0         1          2      3            4
my ($package, $filename, $line, $subroutine, $hasargs,

   #  5          6          7            8       9         10
   $wantarray, $evaltext, $is_require, $hints, $bitmask, $hinthash)
 = caller($i);

Здесь $subroutine — это функция, которую вызывающий вызвал (а не функция, содержащая вызывающий). Обратите внимание, что $subroutine может быть (eval) если кадр не является вызовом подпрограммы, а eval. В таком случае устанавливаются дополнительные элементы $evaltext и $is_require: $is_require истинно, если кадр создан оператором require или use, $evaltext содержит текст оператора eval EXPR. В частности, для оператора eval BLOCK, $subroutine является (eval), но $evaltext имеет значение undef. (Обратите также внимание, что каждый оператор use создаёт кадр require внутри кадра eval EXPR.) $subroutine также может быть (unknown) если эта конкретная подпрограмма была удалена из таблицы символов. $hasargs истинно, если для кадра был создан новый экземпляр @_. $hints и $bitmask содержат прагматические подсказки, с которыми был скомпилирован вызывающий. $hints и $bitmask соответствуют $^H и ${^WARNING_BITS} соответственно. Значения $hints и $bitmask могут меняться между версиями Perl и не предназначены для внешнего использования.

$hinthash — ссылка на хэш, содержащий значение %^H при компиляции вызывающего, или undef, если %^H пусто. Не изменяйте значения этого хэша, так как они являются фактическими значениями, хранящимися в optree.

Кроме того, при вызове из пакета DB в списочном контексте и с аргументом, caller возвращает более подробную информацию: он устанавливает списочную переменную @DB::args в качестве аргументов, с которыми была вызвана подпрограмма.

Обратите внимание, что оптимизатор может оптимизировать кадры вызова, прежде чем caller получит информацию. Это означает, что caller(N) может не вернуть информацию о кадре вызова, который вы ожидаете, N > 1. В частности, @DB::args может содержать информацию с предыдущего вызова caller.

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

chdir EXPR

chdir FILEHANDLE

chdir DIRHANDLE

chdir

Изменяет текущую рабочую директорию на EXPR, если это возможно. Если EXPR опущен, изменяет на директорию, указанную в $ENV{HOME}, если она установлена; в противном случае, изменяет на директорию, указанную в $ENV{LOGDIR}. (Под VMS также проверяется переменная $ENV{'SYS$LOGIN'}, и используется, если она установлена.) Если ни одна не установлена, chdir ничего не делает и завершается с ошибкой. Возвращает true при успехе, false в противном случае. Смотрите пример в die.

На системах, поддерживающих fchdir(2), вы можете передать дескриптор файла или каталога в качестве аргумента. На системах, которые не поддерживают fchdir(2), передача дескрипторов вызывает исключение.

chmod LIST

Изменяет разрешения списка файлов. Первый элемент списка должен быть числовым режимом, который, вероятно, должен быть восьмеричным числом, и который определённо не должен быть строкой восьмеричных цифр: 0644 подходит, но "0644" — нет. Возвращает количество успешно изменённых файлов. Смотрите также oct, если у вас есть только строка.

my $cnt = chmod 0755, "foo", "bar";
chmod 0755, @executables;
my $mode = "0644"; chmod $mode, "foo";      # !!! sets mode to
                                            # --w----r-T
my $mode = "0644"; chmod oct($mode), "foo"; # this is better
my $mode = 0644;   chmod $mode, "foo";      # this is best

На системах, которые поддерживают fchmod(2), вы можете передавать дескрипторы файлов среди файлов. На системах, которые не поддерживают fchmod(2), передача дескрипторов вызывает исключение. Дескрипторы файлов должны передаваться как глобы или ссылки на глобы, чтобы распознаваться; слова без кавычек рассматриваются как имена файлов.

open(my $fh, "<", "foo");
my $perm = (stat $fh)[2] & 07777;
chmod($perm | 0600, $fh);

Вы также можете импортировать символьные S_I* константы из модуля Fcntl:

use Fcntl qw( :mode );
chmod S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH, @executables;
# Identical to the chmod 0755 of the example above.

Проблемы с переносимостью: "chmod" в perlport.

chomp VARIABLE

chomp( LIST )

chomp

Эта более безопасная версия chop удаляет любые хвостовые строки, соответствующие текущему значению $/ (также известное как $INPUT_RECORD_SEPARATOR в модуле English). Она возвращает общее количество удалённых символов из всех аргументов. Часто используется для удаления символа новой строки с конца входной записи, когда вы беспокоитесь о том, что в последней записи может отсутствовать символ новой строки. В режиме абзаца ($/ = '') удаляет все хвостовые символы новой строки из строки. В режиме slurp ($/ = undef) или режиме записей фиксированной длины ($/ является ссылкой на целое число или подобное; см. perlvar) chomp ничего не удалит. Если VARIABLE опущен, он удаляет символы новой строки с конца $_. Пример:

while (<>) {
    chomp;  # avoid \n on last field
    my @array = split(/:/);
    # ...
}

Если VARIABLE является хэшем, он удаляет символы новой строки из значений хэша, но не из его ключей, при этом сбрасывая итератор each.

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

chomp(my $cwd = `pwd`);
chomp(my $answer = <STDIN>);

Если вы применяете chomp к списку, каждый элемент обрабатывается, и возвращается общее количество удалённых символов.

Обратите внимание, что скобки необходимы, когда вы применяете chomp к чему-либо, что не является простой переменной. Это связано с тем, что chomp $cwd = `pwd`; интерпретируется как (chomp $cwd) = `pwd`;, а не как chomp( $cwd = `pwd` ), как вы могли бы ожидать. Аналогично, chomp $a, $b интерпретируется как chomp($a), $b, а не как chomp($a, $b).

chop VARIABLE

chop( LIST )

chop

Обрезает последний символ строки и возвращает обрезной символ. Он намного эффективнее, чем s/.$//s потому что не сканирует и не копирует строку. Если VARIABLE опущен, обрезает $_. Если VARIABLE является хэшем, он обрезает значения хэша, но не его ключи, при этом сбрасывая итератор each.

Вы можете фактически обрезать что-либо, что является lvalue, включая присваивание.

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

Обратите внимание, что chop возвращает последний символ. Чтобы вернуть все, кроме последнего символа, используйте substr($string, 0, -1).

См. также chomp.

chown LIST

Изменяет владельца (и группу) списка файлов. Первые два элемента списка должны быть числовыми uid и gid в указанном порядке. Значение -1 в любой позиции интерпретируется большинством систем как сохранение текущего значения. Возвращает количество успешно изменённых файлов.

my $cnt = chown $uid, $gid, 'foo', 'bar';
chown $uid, $gid, @filenames;

На системах, поддерживающих fchown(2), вы можете передавать дескрипторы файлов среди файлов. На системах, которые не поддерживают fchown(2), передача дескрипторов вызывает исключение. Дескрипторы файлов должны передаваться как глобы или ссылки на глобы, чтобы распознаваться; слова без кавычек рассматриваются как имена файлов.

Вот пример, который ищет нечисловые uid в файле passwd:

print "User: ";
chomp(my $user = <STDIN>);
print "Files: ";
chomp(my $pattern = <STDIN>);

my ($login,$pass,$uid,$gid) = getpwnam($user)
    or die "$user not in passwd file";

my @ary = glob($pattern);  # expand filenames
chown $uid, $gid, @ary;

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

use POSIX qw(sysconf _PC_CHOWN_RESTRICTED);
my $can_chown_giveaway = ! sysconf(_PC_CHOWN_RESTRICTED);

Проблемы с переносимостью: "chown" в perlport.

chr NUMBER

chr

Возвращает символ, представленный данным числом в наборе символов. Например, chr(65) — это "A" как в ASCII, так и в Unicode, а chr(0x263a) — это смайлик Unicode.

Отрицательные значения возвращают заполнитель Unicode (chr(0xfffd)), за исключением использования псевдонима bytes, где используются низшие восемь битов значения (округлённые до целого числа).

Если число NUMBER опущено, используется $_.

Для обратной операции используйте ord.

Обратите внимание, что символы с 128 по 255 включительно по умолчанию не кодируются как UTF-8 в целях обратной совместимости.

Дополнительную информацию об Unicode см. в perlunicode.

chroot FILENAME

chroot

Эта функция работает как одноимённая системная вызов: она устанавливает указанную директорию в качестве новой корневой директории для всех последующих путей, начинающихся с / в вашем процессе и всех его дочерних процессах. (Она не изменяет текущую рабочую директорию, которая не затрагивается.) По соображениям безопасности этот вызов ограничен для суперпользователя. Если FILENAME опущено, выполняется chroot до $_.

ПРИМЕЧАНИЕ: В целях безопасности рекомендуется выполнить chdir("/") (chdir в корневую директорию) сразу после chroot.

Проблемы с переносимостью: "chroot" в perlport.

close FILEHANDLE

close

Закрывает файл или канал, связанный с файловым дескриптором, сбрасывает буферы ввода-вывода и закрывает системный дескриптор файла. Возвращает true, если эти операции выполнены успешно и не было сообщений об ошибках со стороны любого слоя PerlIO. Закрывает текущий выбранный файловый дескриптор, если аргумент опущен.

Вам не нужно закрывать FILEHANDLE, если вы сразу же собираетесь выполнить другой open на нём, потому что open закрывает его за вас. (См. open.) Однако явное close входного файла сбрасывает счётчик строк ($.), в то время как неявное закрытие, выполняемое open, этого не делает.

Если файловый дескриптор был получен при помощи команды open, close возвращает false, если одна из других системных вызовов завершилась ошибкой или если программа завершилась с ненулевым кодом возврата. Если единственной проблемой было то, что программа завершилась с ненулевым кодом возврата, $! будет установлено в 0. Закрытие канала также ожидает завершения процесса, выполняющегося на канале, — в случае если вы хотите посмотреть на вывод канала после этого — и неявно помещает значение кода возврата этой команды в $? и ${^CHILD_ERROR_NATIVE}.

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

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

Пример:

open(OUTPUT, '|sort >foo')  # pipe to sort
    or die "Can't start sort: $!";
#...                        # print stuff to output
close OUTPUT                # wait for sort to finish
    or warn $! ? "Error closing sort pipe: $!"
               : "Exit status $? from sort";
open(INPUT, 'foo')          # get sort's results
    or die "Can't open 'foo' for input: $!";

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

closedir DIRHANDLE

Закрывает директорию, открытую с помощью opendir, и возвращает результат выполнения этой системной вызова.

connect SOCKET,NAME

Пытается подключиться к удалённому сокету, как и connect(2). Возвращает true, если подключение удалось, и false в противном случае. NAME должен быть упакованным адресом соответствующего типа для сокета. См. примеры в "Sockets: Client/Server Communication" в perlipc.

continue BLOCK

continue

Когда за ним следует BLOCK, continue является инструкцией управления потоком, а не функцией. Если существует continue BLOCK, присоединённый к BLOCK (обычно в while или foreach), он всегда выполняется непосредственно перед тем, как условное выражение будет снова оценено, как и третья часть цикла for в C. Таким образом, его можно использовать для инкрементирования переменной цикла, даже если цикл был продолжен с помощью инструкции next (что аналогично оператору C continue).

last, next или redo могут появляться внутри блока continue; last и redo ведут себя так, как будто они были выполнены внутри основного блока. То же касается и next, но так как он выполнит блок continue, это может быть более интересным.

while (EXPR) {
    ### redo always comes here
    do_something;
} continue {
    ### next always comes here
    do_something_else;
    # then back the top to re-check EXPR
}
### last always comes here

Опускание раздела continue эквивалентно использованию пустого, что логично, поэтому next возвращается непосредственно для проверки условия в начале цикла.

Если блока нет, continue — это функция, которая пропускает текущий when или default блок вместо итерации динамически вложенного foreach или выхода из лексически вложенного given. В Perl 5.14 и ранее эта форма continue была доступна только при включенном "switch" режиме. См. feature и "Switch Statements" в perlsyn для получения дополнительной информации.

cos EXPR

cos

Возвращает косинус EXPR (в радианах). Если EXPR опущен, берётся косинус $_.

Для обратной операции по вычислению косинуса вы можете использовать функцию Math::Trig::acos или воспользоваться этим соотношением:

sub acos { atan2( sqrt(1 - $_[0] * $_[0]), $_[0] ) }

crypt PLAINTEXT,SALT

Создаёт строку хэша точно так же, как функция crypt(3) в библиотеке C (при условии, что у вас есть версия, которая не была исключена как потенциальное средство поражения).

crypt — это односторонняя функция хэширования. PLAINTEXT и SALT преобразуются в короткую строку, называемую хэшем, которая и возвращается. Одинаковые PLAINTEXT и SALT всегда будут возвращать одну и ту же строку, но нет (известного) способа получить исходный PLAINTEXT из хэша. Незначительные изменения в PLAINTEXT или SALT приведут к существенным изменениям в хэше.

Функции дешифровки нет. Эта функция не очень полезна для криптографии (для этого используйте модули Crypt на вашем ближайшем зеркале CPAN), и название «crypt» немного неточно. В основном она используется для проверки того, одинаковы ли два текста, не передавая и не храня текст сам по себе. Например, для проверки правильности введённого пароля. Хэш пароля хранится, а не сам пароль. Пользователь вводит пароль, который подвергается хэшированию с тем же солью, что и сохранённый хэш. Если два хэша совпадают, пароль верный.

При проверке существующей строки хэша вы должны использовать хэш как соль (как crypt($plain, $digest) eq $digest). Соль, используемая для создания хэша, видна как часть хэша. Это гарантирует, что crypt будет хэшировать новую строку с той же солью, что и хэш. Это позволяет вашему коду работать с стандартным crypt и с более экзотическими реализациями. Другими словами, не делайте предположений о возвращаемой строке, а также о том, сколько байт соли может иметь значение.

Традиционно результат представляет собой строку из 13 байтов: первые два байта соли, за которыми следуют 11 байтов из набора [./0-9A-Za-z], и только первые восемь байтов PLAINTEXT имели значение. Но альтернативные схемы хэширования (например, MD5), схемы повышенной безопасности (например, C2) и реализации на платформах, отличных от Unix, могут возвращать разные строки.

При выборе новой соли создайте случайную строку из двух символов, символы которой взяты из набора [./0-9A-Za-z] (как join '', ('.', '/', 0..9, 'A'..'Z', 'a'..'z')[rand 64, rand 64]). Этот набор символов — всего лишь рекомендация; разрешённые символы в соли зависят только от библиотеки crypt вашей системы, и Perl не может ограничивать, какие соли crypt принимает.

Вот пример, который гарантирует, что тот, кто выполняет эту программу, знает свой пароль:

my $pwd = (getpwuid($<))[1];

system "stty -echo";
print "Password: ";
chomp(my $word = <STDIN>);
print "\n";
system "stty echo";

if (crypt($word, $pwd) ne $pwd) {
    die "Sorry...\n";
} else {
    print "ok\n";
}

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

Функция crypt не подходит для хэширования больших объёмов данных, не в последнюю очередь потому, что вы не можете получить информацию обратно. Используйте модуль Digest для более надёжных алгоритмов.

Если использовать crypt для строки Unicode (которая потенциально содержит символы с кодами больше 255), Perl пытается понять ситуацию, преобразуя (копию) строки в строку байтов с 8 битами перед вызовом crypt (на этой копии). Если это сработает, хорошо. Если нет, crypt завершится с ошибкой Wide character in crypt.

Проблемы с переносимостью: "crypt" в perlport.

dbmclose HASH

[Функция в значительной степени заменена функцией untie.]

Разрывает связь между файлом DBM и хэш-таблицей.

Проблемы с переносимостью: "dbmclose" в perlport.

dbmopen HASH,DBNAME,MASK

[Функция в значительной степени устарела, её заменила функция tie.]

Эта функция связывает файл dbm(3), ndbm(3), sdbm(3), gdbm(3) или Berkeley DB с хэш-таблицей. HASH — имя хэш-таблицы. (В отличие от обычной функции open, первый аргумент не является дескриптором файла, хотя и выглядит как таковой). DBNAME — имя базы данных (без расширения .dir или .pag, если таковые имеются). Если база данных не существует, она создаётся с защитой, заданной параметром MASK (как модифицировано параметром umask). Чтобы предотвратить создание базы данных, если она не существует, можно задать MODE равным 0, и функция вернёт false, если не найдёт существующей базы данных. Если ваша система поддерживает только более старые функции DBM, в вашей программе может быть только один вызов dbmopen. В более старых версиях Perl, если ваша система не имела ни DBM, ни ndbm, вызов dbmopen приводил к ошибке; сейчас происходит откат к sdbm(3).

Если у вас нет права на запись в файл DBM, вы можете только читать переменные хэш-таблицы, а не устанавливать их. Если вы хотите проверить, есть ли у вас право на запись, используйте тесты файлов или попробуйте установить пустой элемент хэша внутри eval для перехвата ошибки.

Обратите внимание, что функции, такие как keys и values, могут возвращать огромные списки при работе с большими файлами DBM. Для итерации по большим файлам DBM лучше использовать функцию each. Пример:

# print out history file offsets
dbmopen(%HIST,'/usr/lib/news/history',0666);
while (($key,$val) = each %HIST) {
    print $key, ' = ', unpack('L',$val), "\n";
}
dbmclose(%HIST);

См. также AnyDBM_File для более подробного описания плюсов и минусов различных подходов к dbm, а также DB_File для особенно богатой реализации.

Вы можете управлять тем, какая библиотека DBM используется, загрузив эту библиотеку перед вызовом dbmopen:

use DB_File;
dbmopen(%NS_Hist, "$ENV{HOME}/.netscape/history.db")
    or die "Can't open netscape history file: $!";

Проблемы с переносимостью: "dbmopen" в perlport.

defined EXPR

defined

Возвращает булево значение, определяющее, имеет ли EXPR значение, отличное от неопределённого значения undef. Если EXPR отсутствует, проверяется $_.

Многие операции возвращают undef для обозначения ошибки, конца файла, системной ошибки, неинициализированной переменной и других исключительных ситуаций. Эта функция позволяет отличить undef от других значений. (Простой булев тест не позволит отличить undef, ноль, пустую строку и "0", которые все равно ложны.) Обратите внимание, что поскольку undef является допустимым скаляром, его наличие не обязательно указывает на исключительную ситуацию: pop возвращает undef, когда её аргумент — пустой массив, или когда элемент для возвращения — undef.

Вы также можете использовать defined(&func) для проверки, была ли когда-либо определена подпрограмма func. Возвращаемое значение не зависит от каких-либо предварительных объявлений func. Подпрограмма, которая не определена, всё равно может быть вызвана: её пакет может иметь метод AUTOLOAD, который заставляет её появиться в первый раз при вызове; см. perlsub.

Использование defined для агрегатов (хэшей и массивов) больше не поддерживается. Раньше оно сообщало, выделялась ли память для этого агрегата. Вместо этого следует использовать простой тест на размер:

if (@an_array) { print "has array elements\n" }
if (%a_hash)   { print "has hash members\n"   }

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

Примеры:

print if defined $switch{D};
print "$val\n" while defined($val = pop(@ary));
die "Can't readlink $sym: $!"
    unless defined($value = readlink $sym);
sub foo { defined &$bar ? $bar->(@_) : die "No bar"; }
$debugging = 0 unless defined $debugging;

Примечание: Многие люди склонны злоупотреблять defined и затем удивляются, обнаружив, что число 0 и "" (строка нулевой длины) являются, на самом деле, определёнными значениями. Например, если вы говорите

"ab" =~ /a(.*)b/;

Совпадение шаблона происходит, и $1 определено, хотя оно совпало с «ничем». На самом деле, оно не провалило совпадение с чем-либо. Скорее, оно совпало с чем-то, что оказалось нулевой длины. Всё это вполне легально и честно. Когда функция возвращает неопределённое значение, это признание того, что она не могла дать вам честного ответа. Поэтому вы должны использовать defined только тогда, когда ставите под сомнение целостность того, что вы пытаетесь сделать. В других случаях простое сравнение с 0 или "" — то, что вам нужно.

См. также undef, exists, ref.

delete EXPR

Учитывая выражение, которое определяет элемент или срез хэша, delete удаляет указанные элементы из этого хэша, так что exists для этого элемента больше не возвращает true. Установка элемента хэша в неопределённое значение не удаляет его ключ, но удаление — да; см. exists.

В контексте списка обычно возвращает удалённое(ые) значение(я) или последний такой элемент в скалярном контексте. Длина возвращаемого списка соответствует длине списка аргументов: удаление несуществующих элементов возвращает неопределённое значение в соответствующих позициях. При передаче среза ключа/значения хэша в delete, возвращаемое значение — список пар ключ/значение (два элемента для каждого удалённого из хэша элемента).

delete также может быть использован для массивов и срезов массивов, но его поведение менее прямолинейно. Хотя exists вернёт false для удалённых записей, удаление элементов массива никогда не меняет индексов существующих значений; используйте shift или splice для этого. Однако, если какие-либо удалённые элементы находятся в конце массива, размер массива уменьшается до позиции самого высокого элемента, который всё ещё даёт true для exists, или до 0, если таковых нет. Другими словами, в массиве не будет хвостовых несуществующих элементов после удаления.

ПРЕДУПРЕЖДЕНИЕ: Вызов delete для значений массивов категорически не рекомендуется. Понятие удаления или проверки существования элементов массива Perl не является концептуально последовательным и может привести к неожиданному поведению.

Удаление из %ENV изменяет среду. Удаление из хэша, привязанного к файлу DBM, удаляет запись из файла DBM. Удаление из tied хэша или массива может не возвращать ничего; это зависит от реализации метода DELETE пакета tied, который может делать что угодно.

Конструкция delete local EXPR локализует удаление внутри текущего блока во время выполнения. До выхода из блока удалённые локально элементы временно больше не существуют. См. "Локализованное удаление элементов составных типов" в perlsub.

my %hash = (foo => 11, bar => 22, baz => 33);
my $scalar = delete $hash{foo};         # $scalar is 11
$scalar = delete @hash{qw(foo bar)}; # $scalar is 22
my @array  = delete @hash{qw(foo baz)}; # @array  is (undef,33)

Следующее (неэффективно) удаляет все значения %HASH и @ARRAY:

foreach my $key (keys %HASH) {
    delete $HASH{$key};
}

foreach my $index (0 .. $#ARRAY) {
    delete $ARRAY[$index];
}

И эти тоже:

delete @HASH{keys %HASH};

delete @ARRAY[0 .. $#ARRAY];

Но оба медленнее, чем присвоение пустого списка или удаление определения %HASH или @ARRAY, что является обычным способом очистки агрегата:

%HASH = ();     # completely empty %HASH
undef %HASH;    # forget %HASH ever existed

@ARRAY = ();    # completely empty @ARRAY
undef @ARRAY;   # forget @ARRAY ever existed

Выражение EXPR может быть произвольно сложным, при условии, что его последняя операция — элемент или срез агрегата:

delete $ref->[$x][$y]{$key};
delete @{$ref->[$x][$y]}{$key1, $key2, @morekeys};

delete $ref->[$x][$y][$index];
delete @{$ref->[$x][$y]}[$index1, $index2, @moreindices];

die LIST

die вызывает исключение. Внутри eval исключение помещается в $@, а eval завершается с неопределённым значением. Если исключение находится вне всех окружающих eval, то неперехваченное исключение выводится в STDERR и Perl завершается с кодом выхода, указывающим на ошибку. Если вам нужно завершить процесс с определённым кодом выхода, см. exit.

Примеры эквивалентности:

die "Can't cd to spool: $!\n" unless chdir '/usr/spool/news';
chdir '/usr/spool/news' or die "Can't cd to spool: $!\n"

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

Если строковое исключение не заканчивается новой строкой, к нему добавляется текущий номер строки скрипта, номер строки входных данных (если таковой имеется) и новая строка. Обратите внимание, что «номер строки входных данных» (также известный как «блок») зависит от текущего представления «строки» и также доступен в виде специальной переменной $.. См. "$/" в perlvar и "$." в perlvar.

Подсказка: иногда добавление ", stopped" к вашему сообщению позволит ему быть более понятным, когда добавляется строка "at foo line 123". Предположим, что вы запускаете скрипт «canasta».

die "/etc/games is no good";
die "/etc/games is no good, stopped";

соответственно дадут

/etc/games is no good at canasta line 123.
/etc/games is no good, stopped at canasta line 123.

Если список был пустым или преобразован в пустую строку, и $@ уже содержит значение исключения (как правило, из предыдущего eval), то это значение повторно используется после добавления "\t...propagated". Это полезно для распространения исключений:

eval { ... };
die unless $@ =~ /Expected exception/;

Если список был пустым или преобразован в пустую строку, и $@ содержит ссылку на объект, имеющий метод PROPAGATE, этот метод будет вызван с дополнительными параметрами файла и номера строки. Возвращаемое значение заменяет значение в $@; то есть, как если бы вызвался $@ = eval { $@->PROPAGATE(__FILE__, __LINE__) };.

Если список был пустым или преобразован в пустую строку, и $@ также пуст, то используется строка "Died".

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

Поскольку Perl приводит неперехваченные сообщения об ошибках к строковому виду перед отображением, вам, вероятно, захочется перегрузить операции приведения к строковому виду для объектов исключений. Подробности об этом см. в overload. Сообщение в строковом виде должно быть непустым и заканчиваться новой строкой, чтобы соответствовать обработке строковых исключений. Кроме того, поскольку ссылка на объект исключения не может быть приведена к строковому виду без её уничтожения, Perl не пытается добавить информацию о местоположении или другую информацию к исключению-ссылке. Если вам нужна информация о местоположении для сложного объекта исключения, вам нужно самостоятельно добавить эту информацию в объект.

Поскольку $@ — глобальная переменная, будьте осторожны, чтобы анализ исключения, перехваченного eval, не заменил ссылку в глобальной переменной. Проще всего сделать локальную копию ссылки перед любыми манипуляциями. Вот пример:

use Scalar::Util "blessed";

eval { ... ; die Some::Module::Exception->new( FOO => "bar" ) };
if (my $ev_err = $@) {
    if (blessed($ev_err)
        && $ev_err->isa("Some::Module::Exception")) {
        # handle Some::Module::Exception
    }
    else {
        # handle all other possible exceptions
    }
}

Если неперехваченное исключение приводит к завершению интерпретатора, код выхода определяется из значений $! и $? с этим псевдокодом:

exit $! if $!;              # errno
exit $? >> 8 if $? >> 8;    # child exit status
exit 255;                   # last resort

Как и с exit, $? устанавливается перед разворачиванием стека вызовов; любые обработчики DESTROY или END могут затем изменить это значение и, таким образом, код выхода Perl.

Цель — поместить как можно больше информации о вероятной причине в ограниченное пространство кода выхода системы. Однако, поскольку $! является значением errno C, которое может быть установлено любым системным вызовом, это означает, что значение кода выхода, используемого die, может быть непредсказуемым, поэтому на него не следует полагаться, кроме как на то, что он не равен нулю.

Вы можете организовать вызов обратного вызова непосредственно перед тем, как die выполнит свою работу, установив обработчик $SIG{__DIE__}. Соответствующий обработчик вызывается со значением исключения в качестве аргумента и может изменить исключение, если посчитает нужным, вызвав die снова. Подробности о настройке записей %SIG см. в "%SIG" в perlvar, а примеры см. в eval. Хотя эта функция должна выполняться только непосредственно перед завершением вашей программы, это не так: обработчик $SIG{__DIE__} вызывается даже внутри блоков/строк, заключенных в eval! Если вы хотите, чтобы обработчик ничего не делал в таких ситуациях, вставьте

die @_ if $^S;

в первую строку обработчика (см. "$^S" в perlvar). Поскольку это способствует странному действию на расстоянии, эта неинтуитивная работа может быть исправлена в будущих выпусках.

См. также exit, warn и модуль Carp.

do БЛОК

Не совсем функция. Возвращает значение последней команды в последовательности команд, указанных в БЛОКЕ. При использовании модификатора цикла while или until выполняет БЛОК один раз до проверки условия цикла. (Для других операторов модификаторы цикла сначала проверяют условие.)

do BLOCK не является циклом, поэтому операторы управления циклом next, last или redo не могут быть использованы для выхода из блока или его перезапуска. См. perlsyn для альтернативных стратегий.

do ВЫРАЖЕНИЕ

Использует значение ВЫРАЖЕНИЯ в качестве имени файла и выполняет содержимое файла как скрипт Perl:

# load the exact specified file (./ and ../ special-cased)
do '/foo/stat.pl';
do './stat.pl';
do '../foo/stat.pl';

# search for the named file within @INC
do 'stat.pl';
do 'foo/stat.pl';

do './stat.pl' в основном похоже на

eval `cat stat.pl`;

за исключением того, что оно более краткое, не запускает внешние процессы и отслеживает текущее имя файла для сообщений об ошибках. Оно также отличается тем, что код, оценённый с помощью do FILE, не может видеть лексические переменные в окружающем пространстве; eval STRING может. Однако они одинаковы в том, что они повторно парсят файл каждый раз при вызове, поэтому, вероятно, не стоит делать это внутри цикла.

Использование do с относительным путём (за исключением ./ и ../), например

do 'foo/stat.pl';

будет искать в каталогах @INC и обновлять %INC, если файл найден. См. "@INC" в perlvar и "%INC" в perlvar для этих переменных. В частности, обратите внимание, что, хотя исторически @INC содержал '.' (текущий каталог), делая эти два случая эквивалентными, это больше не обязательно так, так как '.' по умолчанию не включён в @INC в версиях Perl 5.26.0 и выше. Вместо этого Perl выведет предупреждение:

do "stat.pl" failed, '.' is no longer in @INC;
did you mean do "./stat.pl"?

Если do может прочитать файл, но не может его скомпилировать, он возвращает undef и устанавливает сообщение об ошибке в $@. Если do не может прочитать файл, он возвращает undef и устанавливает $! на ошибку. Всегда сначала проверяйте $@, так как компиляция может завершиться ошибкой, которая также установит $!. Если файл успешно скомпилирован, do возвращает значение последнего вычисленного выражения.

Включение модулей библиотек лучше выполнять с помощью операторов use и require, которые также выполняют автоматическую проверку ошибок и генерируют исключение в случае возникновения проблем.

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

# Read in config files: system first, then user.
# Beware of using relative pathnames here.
for $file ("/share/prog/defaults.rc",
           "$ENV{HOME}/.someprogrc")
{
    unless ($return = do $file) {
        warn "couldn't parse $file: $@" if $@;
        warn "couldn't do $file: $!"    unless defined $return;
        warn "couldn't run $file"       unless $return;
    }
}

dump Метка

dump ВЫРАЖЕНИЕ

dump

Эта функция вызывает немедленный дамп ядра. Также см. командную строку -u в perlrun, которая выполняет то же самое. В основном это необходимо для того, чтобы вы могли использовать программу undump (не поставляется) для преобразования дампа ядра в исполняемый двоичный файл после инициализации всех переменных в начале программы. При выполнении нового двоичного файла он начнёт с выполнения goto LABEL (со всеми ограничениями, которые накладываются на goto). Подумайте об этом как о goto с промежуточным дампом ядра и реинкарнацией. Если LABEL пропущено, программа перезапускается с самого начала. Форма dump EXPR, доступная начиная с Perl 5.18.0, позволяет вычислять имя во время выполнения, будучи в остальном идентичной dump LABEL.

ПРЕДУПРЕЖДЕНИЕ: Любые файлы, открытые на момент дампа, не будут открыты при реинкарнации программы, что может привести к путанице со стороны Perl.

Эта функция теперь в значительной степени устарела, главным образом потому, что очень сложно преобразовать дамп ядра в исполняемый файл. Начиная с Perl 5.30, она должна вызываться как CORE::dump().

В отличие от большинства именованных операторов, у него такой же приоритет, как у присваивания. Он также освобождается от правила, похожего на функцию, поэтому dump ("foo")."bar" приведет к тому, что «bar» будет частью аргумента dump.

Проблемы с переносимостью: "dump" в perlport.

each ХЭШ

each МАССИВ

При вызове на хеше в контексте списка возвращает список из 2 элементов, содержащий ключ и значение для следующего элемента хеша. В Perl 5.12 и более поздних версиях он также вернёт индекс и значение для следующего элемента массива, чтобы вы могли итерировать по нему; более старые версии Perl рассматривают это как синтаксическую ошибку. При вызове в скалярном контексте возвращает только ключ (не значение) в хеше или индекс в массиве.

Элементы хеша возвращаются в, по-видимому, случайном порядке. Фактический случайный порядок специфичен для данного хеша; абсолютно одинаковые последовательности операций над двумя хешами могут привести к разному порядку для каждого хеша. Любая вставка в хеш может изменить порядок, как и любое удаление, за исключением того, что последний ключ, возвращённый функцией each или keys, может быть удалён без изменения порядка. До тех пор, пока хеш не изменён, вы можете полагаться на keys, values и each, чтобы они возвращали тот же порядок. Подробности о том, почему порядок хеша случайный, см. в разделе "Атаки на вычисление сложности алгоритма" в perlsec. Помимо гарантий, указанных здесь, точные детали алгоритма хеширования Perl и порядок обхода хеша могут меняться в любой версии Perl.

После того, как each вернул все элементы из хеша или массива, следующий вызов each возвращает пустой список в контексте списка и undef в скалярном контексте; следующий вызов после этого возобновляет итерацию. Каждый хеш или массив имеет свой внутренний итератор, доступный через each, keys и values. Итератор неявно сбрасывается, когда each достиг конца, как описано выше; его можно явно сбросить, вызвав keys или values для хеша или массива или сославшись на хеш (но не массив) в контексте списка. Если вы добавляете или удаляете элементы хеша во время итерации по нему, влияние на итератор не определено; например, записи могут быть пропущены или дублированы — поэтому этого делать не следует. Исключение: всегда безопасно удалять элемент, последний возвращённый each, поэтому следующий код работает правильно:

while (my ($key, $value) = each %hash) {
    print $key, "\n";
    delete $hash{$key};   # This is safe
}

Связанные хеши могут иметь другое поведение упорядочивания по сравнению с реализацией хешей в Perl.

Итератор, используемый each , прикреплён к хешу или массиву и общий для всех операций итерации, применяемых к одному и тому же хешу или массиву. Таким образом, все использования each для одного хеша или массива перемещают положение одного и того же итератора. Все использования each также подвержены сбросу итератора любым использованием keys или values для того же хеша или массива или со ссылкой на хеш (но не массив) в контексте списка. Это делает циклы, основанные на each, довольно хрупкими: легко получить такой цикл, у которого итератор уже находится где-то в середине объекта, или случайно испортить состояние итератора во время выполнения тела цикла. Достаточно легко явно сбросить итератор перед началом цикла, но нет способа изолировать состояние итератора, используемое циклом, от состояния итератора, используемого чем-либо ещё, что может выполняться во время тела цикла. Чтобы избежать этих проблем, используйте цикл foreach вместо цикла while-each.

Это выводит ваше окружение, как и программа printenv(1), но в другом порядке:

while (my ($key,$value) = each %ENV) {
    print "$key=$value\n";
}

Начиная с Perl 5.14, экспериментальная функция позволяла each принимать скалярное выражение. Этот эксперимент признан неудачным и был удалён с версии Perl 5.24.

Начиная с Perl 5.18, вы можете использовать просто each в цикле while, который установит $_ на каждой итерации. Если используется выражение each или явное присваивание выражения each скаляру в качестве условия цикла while/for, то условие фактически проверяет определённость значения выражения, а не его истинное значение.

while (each %ENV) {
    print "$_=$ENV{$_}\n";
}

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

use 5.012;  # so keys/values/each work on arrays
use 5.018;  # so each assigns to $_ in a lone while test

См. также keys, values и sort.

eof FILEHANDLE

eof ()

eof

Возвращает 1, если следующее чтение в FILEHANDLE вернёт конец файла или если FILEHANDLE не открыт. FILEHANDLE может быть выражением, значение которого даёт реальную дескриптор файла. (Обратите внимание, что эта функция фактически считывает символ, а затем ungetc его, поэтому она не полезна в интерактивном контексте.) Не читайте из файла терминала (или не вызывайте eof(FILEHANDLE) для него) после достижения конца файла. Типы файлов, такие как терминалы, могут потерять состояние конца файла, если вы это сделаете.

Функция eof без аргумента использует последний прочитанный файл. Использование eof() с пустыми скобками отличается. Она относится к псевдофайлу, сформированному из файлов, перечисленных в командной строке и доступных через оператор <>. Поскольку <> не открыт явно, как обычный дескриптор файла, eof() до того, как <> был использован, заставит Perl проверить @ARGV для определения наличия ввода. Аналогично, eof() после того, как <> вернул конец файла, предположит, что вы обрабатываете другой список @ARGV, и если вы не задали @ARGV, будет читать ввод из STDIN; см. "Операторы ввода/вывода" в perlop.

В цикле while (<>), eof или eof(ARGV) можно использовать для обнаружения конца каждого файла, а eof() — для обнаружения конца только последнего файла. Примеры:

# reset line numbering on each input file
while (<>) {
    next if /^\s*#/;  # skip comments
    print "$.\t$_";
} continue {
    close ARGV if eof;  # Not eof()!
}

# insert dashes just before last line of last file
while (<>) {
    if (eof()) {  # check for end of last file
        print "--------------\n";
    }
    print;
    last if eof();     # needed if we're reading from a terminal
}

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

eval EXPR

eval BLOCK

eval

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

Обычная eval без аргумента — это просто eval EXPR, где выражение понимается как содержащееся в $_. Таким образом, существует только две реальные eval формы; ту с EXPR часто называют "строковым eval". В строковом eval значение выражения (которое само по себе определяется в скалярном контексте) сначала анализируется, и если ошибок нет, выполняется как блок в лексическом контексте текущей Perl-программы. Эта форма обычно используется для отсрочки анализа и последующего выполнения текста EXPR до времени выполнения. Обратите внимание, что значение анализируется каждый раз, когда eval выполняется.

Другая форма называется "блочным eval". Она менее универсальна, чем строковый eval, но код внутри BLOCK анализируется только один раз (в то же время, что и код, окружающий eval) и выполняется в контексте текущей Perl-программы. Эта форма обычно используется для более эффективного перехвата исключений, чем первая, а также обеспечивает преимущество проверки кода внутри BLOCK на этапе компиляции. BLOCK анализируется и компилируется только один раз. Поскольку ошибки перехватываются, часто используется для проверки доступности определённой функции.

В обеих формах возвращаемое значение — значение последнего вычисленного выражения внутри мини-программы; инструкция return также может быть использована, точно так же, как и с подпрограммами. Выражение, предоставляющее возвращаемое значение, вычисляется в пустом, скалярном или списковом контексте, в зависимости от контекста eval само по себе. См. wantarray для получения дополнительной информации о том, как можно определить контекст вычисления.

Если возникает синтаксическая ошибка, ошибка во время выполнения или выполняется инструкция die, eval возвращает undef в скалярном контексте или пустой список в списковом контексте, и $@ устанавливается в сообщение об ошибке. (До версии 5.16 ошибка приводила к возврату undef в списковом контексте при синтаксических ошибках, но не при ошибках во время выполнения.) Если ошибки не было, $@ устанавливается в пустую строку. Оператор управления потоком, например, last или goto, может обойти установку $@. Следует помнить, что использование eval не подавляет Perl от вывода предупреждений в STDERR, ни не помещает текст сообщений об ошибках в $@. Для этого нужно использовать механизм $SIG{__WARN__} или отключить предупреждения внутри блока BLOCK или EXPR с помощью no warnings 'all'. См. warn, perlvar и warnings.

Обратите внимание, что, поскольку eval перехватывает иначе фатальные ошибки, это полезно для определения того, реализована ли определённая функция (например, symlink) или socket). Это также механизм перехвата исключений Perl, где оператор die используется для поднятия исключений.

До Perl 5.14 присвоение $@ происходило до восстановления локализованных переменных, что означает, что для работы вашего кода в более старых версиях требуется временная переменная, если вы хотите замаскировать некоторые, но не все ошибки:

# alter $@ on nefarious repugnancy only
{
   my $e;
   {
     local $@; # protect existing $@
     eval { test_repugnancy() };
     # $@ =~ /nefarious/ and die $@; # Perl 5.14 and higher only
     $@ =~ /nefarious/ and $e = $@;
   }
   die $e if defined $e
}

Существуют некоторые различия в рассмотрении каждой формы:

Строковый eval

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

Под "unicode_eval"

Если эта функция включена (что по умолчанию при объявлении use 5.16 или выше), EXPR считается в той же кодировке, что и окружающая программа. Таким образом, если use utf8 активен, строка будет обрабатываться как закодированная в UTF-8. В противном случае строка рассматривается как последовательность независимых байтов. Байты, соответствующие кодам символов диапазона ASCII, будут иметь свои обычные значения для операторов в строке. Обработка других байтов зависит от того, если ли функция 'unicode_strings" включена.

В обычном eval без аргумента EXPR, нахождение в use utf8 или нет — не имеет значения; UTF-8-ность самого $_ определяет поведение.

Любые use utf8 или no utf8 объявления внутри строки не имеют никакого эффекта, и фильтры исходного текста запрещены. (unicode_strings, однако, может появляться внутри строки.) См. также оператор evalbytes, который корректно работает с фильтрами исходного кода.

Переменные, определённые вне eval и используемые внутри него, сохраняют свою исходную UTF-8-ность. Всё внутри строки следует обычным правилам для Perl-программы с заданным состоянием use utf8.

Вне функции "unicode_eval"

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

Он может потерять отслеживание того, должна ли что-то кодироваться в UTF-8 или нет.
Активные внутри eval фильтры исходного кода "утекают" в текущую область видимости файла, который компилируется. В качестве примера с модулем CPAN Semi::Semicolons:
```
BEGIN { eval "use Semi::Semicolons; # not filtered" }
# filtered here!
```
evalbytes исправляет это, чтобы работать так, как ожидалось:
```
use feature "evalbytes";
BEGIN { evalbytes "use Semi::Semicolons; # filtered" }
# not filtered
```

Проблемы могут возникнуть, если строка расширяет скаляр, содержащий число с плавающей точкой. Этот скаляр может расширяться до букв, таких как "NaN" или "Infinity"; или в рамках use locale, символ десятичной точки может быть другим, чем точка (например, запятая). Ни одно из этих значений не будет проанализировано так, как вы ожидаете.

Вы должны быть особенно осторожны, помня, что рассматривается, когда:

eval $x;        # CASE 1
eval "$x";      # CASE 2

eval '$x';      # CASE 3
eval { $x };    # CASE 4

eval "\$$x++";  # CASE 5
$$x++;          # CASE 6

Случаи 1 и 2 ведут себя идентично: они выполняют код, содержащийся в переменной $x. (Хотя случай 2 имеет вводящие в заблуждение двойные кавычки, заставляющие читателя задаться вопросом, что ещё происходит (ничего не происходит).) Случаи 3 и 4 также ведут себя одинаково: они выполняют код '$x', который ничего не делает, кроме возвращения значения $x. (Случай 4 предпочтительнее по чисто визуальным причинам, но у него также есть преимущество компиляции на этапе компиляции, а не во время выполнения.) Случай 5 — это место, где обычно вы хотели бы использовать двойные кавычки, но в этой конкретной ситуации вы можете использовать символические ссылки вместо этого, как в случае 6.

eval '' , выполняемый внутри подпрограммы, определённой в DB пакете, не видит обычную окружающую лексическую область, а видит область первой не-DB части кода, которая его вызвала. Обычно не нужно беспокоиться об этом, если вы не пишете отладчик Perl.

Если присутствует заключительная точка с запятой, она может быть опущена из значения EXPR.

Блочный eval

Если исполняемый код не меняется, вы можете использовать eval-BLOCK форму для перехвата ошибок во время выполнения без наложения штрафа за компиляцию каждый раз. Ошибка, если она есть, всё ещё возвращается в $@. Примеры:

# make divide-by-zero nonfatal
eval { $answer = $a / $b; }; warn $@ if $@;

# same thing, but less efficient
eval '$answer = $a / $b'; warn $@ if $@;

# a compile-time error
eval { $answer = }; # WRONG

# a run-time error
eval '$answer =';   # sets $@

Если вы хотите перехватить ошибки при загрузке модуля XS, некоторые проблемы с двоичным интерфейсом (например, несовместимость версий Perl) могут быть фатальными даже с eval, если $ENV{PERL_DL_NONLAZY} не задано. См. perlrun.

Использование eval {} формы в качестве перехвата исключений в библиотеках имеет некоторые проблемы. Из-за, возможно, повреждённого состояния __DIE__ хуков, вы можете не захотеть вызывать любые __DIE__ хуки, которые может установить пользовательский код. Для этой цели можно использовать конструкцию local $SIG{__DIE__}, как показано в этом примере:

# a private exception trap for divide-by-zero
eval { local $SIG{'__DIE__'}; $answer = $a / $b; };
warn $@ if $@;

Это особенно важно, учитывая, что __DIE__ хуки могут вызывать die снова, что изменяет их сообщения об ошибках:

# __DIE__ hooks may modify error messages
{
   local $SIG{'__DIE__'} =
          sub { (my $x = $_[0]) =~ s/foo/bar/g; die $x };
   eval { die "foo lives here" };
   print $@ if $@;                # prints "bar lives here"
}

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

eval BLOCK не считается циклом, поэтому операторы управления циклом next, last или redo не могут быть использованы для выхода или перезапуска блока.

Если присутствует заключительная точка с запятой, она может быть опущена внутри BLOCK.

evalbytes EXPR

evalbytes

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

Если вызывается, когда use utf8 активен, строка будет предполагаться закодированной в UTF-8, а evalbytes создаст временную копию для работы, понизив кодировку до не-UTF-8. Если это невозможно (потому что один или несколько символов в ней требуют UTF-8), evalbytes завершится ошибкой, сохранённой в $@.

Байты, соответствующие кодовым точкам диапазона ASCII, будут иметь своё обычное значение для операторов в строке. Обработка других байтов зависит от того, включена ли функция 'unicode_strings".

Конечно, переменные, которые являются UTF-8 и упоминаются в строке, сохраняют это свойство:

my $a = "\x{100}";
evalbytes 'print ord $a, "\n"';

выводит

и $@ пусто.

Фильтры источников, активированные в вычисляемом коде, применяются к самому коду.

evalbytes доступна начиная с Perl v5.16. Для её доступа необходимо указать CORE::evalbytes, но вы можете опустить CORE::, если функция "evalbytes" включена. Она автоматически включается с объявлением use v5.16 (или выше) в текущем пространстве имён.

exec LIST

exec PROGRAM LIST

Функция exec выполняет системную команду и никогда не возвращается; используйте system вместо exec, если вы хотите, чтобы она вернула значение. Она возвращает false только в случае, если команда не существует и она выполняется напрямую, а не через командную оболочку вашей системы (см. ниже).

Поскольку использование exec вместо system является распространённой ошибкой, Perl предупреждает вас, если exec вызывается в пустом контексте и если за ним следует оператор, не являющийся die, warn или exit (если включены предупреждения — но вы всегда это делаете, верно?). Если вы действительно хотите выполнить оператор, следующую за exec, вы можете использовать один из этих стилей, чтобы избежать предупреждения:

exec ('foo')   or print STDERR "couldn't exec foo: $!";
{ exec ('foo') }; print STDERR "couldn't exec foo: $!";

Если в LIST более одного аргумента, это вызов execvp(3) с аргументами из LIST. Если в LIST только один элемент, аргумент проверяется на наличие метасимволов оболочки, и если они есть, весь аргумент передаётся командной оболочке системы для анализа (это /bin/sh -c в Unix-системах, но на других платформах может отличаться). Если в аргументе нет метасимволов оболочки, он разбивается на слова и передаётся напрямую в execvp, что более эффективно. Примеры:

exec '/bin/echo', 'Your arguments are: ', @ARGV;
exec "sort $outfile | uniq";

Если вы не хотите фактически выполнить первый аргумент, но хотите обмануть выполняемую программу относительно её собственного имени, вы можете указать программу, которую вы хотите запустить, как "косвенный объект" (без запятой) перед LIST, как в exec PROGRAM LIST. (Это всегда вынуждает интерпретацию LIST как многозначного списка, даже если в списке есть только один скаляр.) Пример:

my $shell = '/bin/csh';
exec $shell '-sh';    # pretend it's a login shell

или, более прямо,

exec {'/bin/csh'} '-sh';  # pretend it's a login shell

Когда аргументы выполняются через командную оболочку, результаты зависят от её особенностей и возможностей. Подробности см. в "`STRING`" в perlop.

Использование косвенного объекта с exec или system также более безопасно. Это использование (которое также работает с system) вынуждает интерпретацию аргументов как многозначного списка, даже если в списке был только один аргумент. Таким образом, вы защищены от расширения оболочкой шаблонов или разделения слов с пробелами.

my @args = ( "echo surprise" );

exec @args;               # subject to shell escapes
                            # if @args == 1
exec { $args[0] } @args;  # safe even with one-arg list

В первом варианте, без косвенного объекта, запускалась программа echo, передавая ей "surprise" аргумент. Во втором варианте этого не происходило; она пыталась запустить программу с именем "echo surprise", не нашла её и установила $? в ненулевое значение, указывающее на ошибку.

В Windows только синтаксис exec PROGRAM LIST косвенного объекта надёжно избежит использования оболочки; exec LIST, даже с несколькими элементами, вернётся к оболочке, если первое создание процесса завершится ошибкой.

Perl пытается очистить все файлы, открытые для вывода, перед выполнением exec, но это может не поддерживаться на некоторых платформах (см. perlport). Для безопасности вам может потребоваться установить $| ($AUTOFLUSH в English) или вызвать метод autoflush объекта IO::Handle для всех открытых дескрипторов, чтобы избежать потери вывода.

Обратите внимание, что exec не вызовет ваши END блоки, также как и не вызовет DESTROY методы ваших объектов.

Проблемы совместимости: "exec" в perlport.

exists EXPR

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

print "Exists\n"    if exists $hash{$key};
print "Defined\n"   if defined $hash{$key};
print "True\n"      if $hash{$key};

exists также может вызываться для элементов массивов, но его поведение менее очевидно и тесно связано с использованием delete в массивах.

ПРЕДУПРЕЖДЕНИЕ: Вызов exists для значений массивов настоятельно не рекомендуется. Понятие удаления или проверки существования элементов Perl-массива не является концептуально последовательным и может привести к неожиданному поведению.

print "Exists\n"    if exists $array[$index];
print "Defined\n"   if defined $array[$index];
print "True\n"      if $array[$index];

Элемент хеша или массива может быть истинным только если он определён, а определён только если существует, но обратное не обязательно верно.

При задании имени подпрограммы, возвращает true, если указанная подпрограмма когда-либо была объявлена, даже если она не определена. Упоминание имени подпрограммы в exists или defined не считается её объявлением. Обратите внимание, что подпрограмма, которая не существует, всё ещё может быть вызываемой: её пакет может иметь метод AUTOLOAD, который делает её доступной в первый раз при вызове; см. perlsub.

print "Exists\n"  if exists &subroutine;
print "Defined\n" if defined &subroutine;

Обратите внимание, что EXPR может быть сколь угодно сложным, пока конечная операция — это поиск ключа в хеше или массиве или имя подпрограммы:

if (exists $ref->{A}->{B}->{$key})  { }
if (exists $hash{A}{B}{$key})       { }

if (exists $ref->{A}->{B}->[$ix])   { }
if (exists $hash{A}{B}[$ix])        { }

if (exists &{$ref->{A}{B}{$key}})   { }

Хотя наиболее глубоко вложенный элемент массива или хеша не появится просто потому, что его существование было проверено, все промежуточные элементы появятся. Таким образом, $ref->{"A"} и $ref->{"A"}->{"B"} появятся из-за проверки существования элемента $key выше. Это происходит везде, где используется оператор стрелки, включая и здесь:

undef $ref;
if (exists $ref->{"Some key"})    { }
print $ref;  # prints HASH(0x80d3d5c)

Использование вызова подпрограммы, а не имени подпрограммы, в качестве аргумента exists является ошибкой.

exists &sub;    # OK
exists &sub();  # Error

exit EXPR

exit

Вычисляет EXPR и немедленно завершает выполнение программы с этим значением. Пример:

my $ans = <STDIN>;
exit 0 if $ans =~ /^[Xx]/;

См. также die. Если EXPR опущен, завершает выполнение с кодом 0 состояния. Единственно универсально распознаваемые значения для EXPR — 0 для успеха и 1 для ошибки; другие значения интерпретируются в зависимости от среды выполнения программы Perl. Например, завершение с 69 (EX_UNAVAILABLE) из фильтра входящей почты sendmail заставит почтового клиента вернуть сообщение как недоставленное, но это не везде так.

Не используйте exit для прерывания подпрограммы, если есть вероятность, что кто-то захочет перехватить произошедшую ошибку. Используйте die вместо этого, который может быть перехвачен с помощью eval.

Функция exit не всегда завершает выполнение немедленно. Она сначала вызывает все определённые END функции, но эти END функции сами по себе могут не прервать выполнение. Аналогично, вызываются деструкторы любых объектов, которые необходимо вызвать перед фактическим завершением. END функции и деструкторы могут изменить код возврата, изменив $?. Если это проблема, вы можете вызвать POSIX::_exit($status), чтобы избежать обработки END и деструкторов. Подробности см. в perlmod.

Проблемы совместимости: "exit" в perlport.

exp EXPR

exp

Возвращает e (основание натурального логарифма) в степени EXPR. Если EXPR опущен, возвращает exp($_).

fc EXPR

fc

Возвращает результат применения операции сгибания регистра к EXPR. Это внутренняя функция, реализующая операцию \F экранирования в строках с двойными кавычками.

Сгибание регистра — это процесс преобразования строк в форму, где различия в регистре игнорируются; сравнение двух строк в форме сгибания регистра фактически означает проверку, равны ли эти строки независимо от регистра.

Грубо говоря, если вы когда-либо писали вот так

lc($this) eq lc($that)    # Wrong!
    # or
uc($this) eq uc($that)    # Also wrong!
    # or
$this =~ /^\Q$that\E\z/i  # Right!

Теперь вы можете написать

fc($this) eq fc($that)

И получить правильные результаты.

Perl реализует только полную форму сгибания регистра, но вы можете получить доступ к простым формам сгибания, используя "casefold()" в Unicode::UCD и "prop_invmap()" в Unicode::UCD. Для получения дополнительной информации о сгибании регистра обратитесь к стандарту Unicode, в частности, к разделам 3.13 Default Case Operations, 4.2 Case-Normative, и 5.18 Case Mappings, доступным по адресу http://www.unicode.org/versions/latest/, а также к таблицам сгибания регистра по адресу http://www.unicode.org/charts/case/.

Если EXPR опущено, используется $_.

Эта функция ведет себя одинаково при различных прагмах, таких как внутри "use feature 'unicode_strings", как и lc, за исключением одного случая: fc символа ЗАГЛАВНАЯ БУКВА С ОСТРЫМ ШАРП-S (U+1E9E) в рамках use locale. Сгибание регистра этого символа обычно "ss", но, как объяснено в разделе lc, изменения регистра, пересекающие границу 255/256, проблемны в локализованных средах и поэтому запрещены. Поэтому эта функция в локализованной среде возвращает вместо этого строку "\x{17F}\x{17F}", которая является символом МАЛЕНЬКАЯ БУКВА ДЛИННОЕ S. Поскольку этот символ сам сгибается к "s", строка из двух таких символов должна быть эквивалентна одиночному U+1E9E при сгибании регистра.

Хотя стандарт Unicode определяет две дополнительные формы сгибания регистра, одну для тюркских языков и одну, которая никогда не отображает один символ в несколько символов, эти формы не предоставляются ядром Perl. Однако модуль CPAN Unicode::Casing может быть использован для реализации.

fc доступен только если включен "fc" параметр или если он имеет префикс CORE::. "fc" параметр автоматически включается с use v5.16 (или выше) объявлением в текущем пространстве имен.

fcntl FILEHANDLE,FUNCTION,SCALAR

Реализует функцию fcntl(2). Вам, вероятно, сначала нужно будет сказать

use Fcntl;

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

use Fcntl;
my $flags = fcntl($filehandle, F_GETFL, 0)
    or die "Can't fcntl F_GETFL: $!";

Вам не нужно проверять defined на возвращаемом значении из fcntl. Как и ioctl, она отображает значение 0 возвращаемое системным вызовом, в "0 but true" в Perl. Эта строка истинна в контексте булевых значений и 0 в контексте числовых значений. Она также исключается из стандартных Argument "..." isn't numeric предупреждений о некорректных числовых преобразованиях.

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

Вот пример установки файлового дескриптора под именем $REMOTE как неблокирующего на системном уровне. Однако вам нужно будет самостоятельно договориться о $|.

use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);

my $flags = fcntl($REMOTE, F_GETFL, 0)
    or die "Can't get flags for the socket: $!\n";

fcntl($REMOTE, F_SETFL, $flags | O_NONBLOCK)
    or die "Can't set flags for the socket: $!\n";

Проблемы с переносимостью: "fcntl" в perlport.

__FILE__

Специальный токен, возвращающий имя файла, в котором он встречается.

fileno FILEHANDLE

fileno DIRHANDLE

Возвращает дескриптор файла для файлового или каталожного дескриптора, или undefined, если файловый дескриптор не открыт. Если на уровне ОС нет реального дескриптора файла, как это может произойти с файловыми дескрипторами, подключенными к объектам памяти через open со ссылкой в качестве третьего аргумента, возвращается -1.

Это в основном полезно для построения битовых карт для select и операций с низким уровнем управления терминалами POSIX. Если FILEHANDLE — выражение, значение принимается как косвенный файловый дескриптор, обычно его имя.

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

if (fileno($this) != -1 && fileno($this) == fileno($that)) {
    print "\$this and \$that are dups\n";
} elsif (fileno($this) != -1 && fileno($that) != -1) {
    print "\$this and \$that have different " .
        "underlying file descriptors\n";
} else {
    print "At least one of \$this and \$that does " .
        "not have a real file descriptor\n";
}

Поведение fileno для каталожного дескриптора зависит от операционной системы. На системах с dirfd(3) или аналогичной поддержкой, fileno для каталожного дескриптора возвращает базовый дескриптор файла, связанный с дескриптором; на системах без такой поддержки возвращает undefined и устанавливает $! (errno).

flock FILEHANDLE,OPERATION

Вызывает flock(2) или его эмуляцию для FILEHANDLE. Возвращает true при успехе, false при ошибке. Вызывает фатальную ошибку, если используется на машине, которая не поддерживает flock(2), блокировку fcntl(2) или lockf(3). flock — это портативный интерфейс блокировки файлов Perl, хотя он блокирует только целые файлы, а не записи.

Два потенциально неявных, но традиционных flock семантики заключаются в том, что он ожидает неопределенно долго, пока блокировка не будет предоставлена, и что его блокировки являются просто рекомендательными. Такие дискреционные блокировки более гибкие, но предоставляют меньше гарантий. Это означает, что программы, которые также не используют flock, могут изменять файлы, заблокированные с помощью flock. См. perlport, документацию вашей платформы и страницы справки вашей системы для получения подробностей. Лучше всего предположить традиционное поведение при написании переносимых программ. (Но если вы этого не делаете, вы, как всегда, совершенно свободны писать для особенностей вашей системы (иногда называемых «функциями»). Рабское следование переносимости не должно мешать вам выполнять свою работу.)

OPERATION — это одно из значений LOCK_SH, LOCK_EX или LOCK_UN, возможно, совместно с LOCK_NB. Эти константы традиционно имеют значения 1, 2, 8 и 4, но вы можете использовать символические имена, если импортируете их из модуля Fcntl, как по отдельности, так и в группе, используя тег :flock . LOCK_SH запрашивает общую блокировку, LOCK_EX запрашивает эксклюзивную блокировку, а LOCK_UN освобождает ранее запрошенную блокировку. Если LOCK_NB побитово-илируется с LOCK_SH или LOCK_EX, то flock возвращает значение сразу, а не ожидая блокировку; проверьте результат, чтобы увидеть, получили вы ее или нет.

Для предотвращения возможных несогласованностей, Perl теперь сбрасывает FILEHANDLE перед блокировкой или разблокировкой.

Обратите внимание, что эмуляция, реализованная с помощью lockf(3), не предоставляет общих блокировок, и она требует, чтобы FILEHANDLE был открыт со значением write intent. Именно эти семантики реализует lockf(3). Большинство, если не все системы, реализуют lockf(3) в терминах блокировки fcntl(2), поэтому различия в семантике не должны сильно повлиять на многих людей.

Обратите внимание, что эмуляция flock(3) с помощью fcntl(2) требует, чтобы FILEHANDLE был открыт со значением read intent для использования LOCK_SH и требует, чтобы он был открыт со значением write intent для использования LOCK_EX.

Также обратите внимание, что некоторые версии flock не могут блокировать вещи через сеть; вам нужно будет использовать более специфичный для системы fcntl для этого. Если хотите, вы можете заставить Perl проигнорировать функцию flock(2) вашей системы, тем самым обеспечив свою собственную эмуляцию на основе fcntl(2), передав переключатель -Ud_flock программе Configure при настройке и сборке нового Perl.

Вот пример приложения для добавления в почтовый ящик для систем BSD.

# import LOCK_* and SEEK_END constants
use Fcntl qw(:flock SEEK_END);

sub lock {
    my ($fh) = @_;
    flock($fh, LOCK_EX) or die "Cannot lock mailbox - $!\n";
    # and, in case we're running on a very old UNIX
    # variant without the modern O_APPEND semantics...
    seek($fh, 0, SEEK_END) or die "Cannot seek - $!\n";
}

sub unlock {
    my ($fh) = @_;
    flock($fh, LOCK_UN) or die "Cannot unlock mailbox - $!\n";
}

open(my $mbox, ">>", "/usr/spool/mail/$ENV{'USER'}")
    or die "Can't open mailbox: $!";

lock($mbox);
print $mbox $msg,"\n\n";
unlock($mbox);

На системах, поддерживающих реальную функцию flock(2), блокировки наследуются через вызовы fork, в то время как те, которые должны использовать более прихотливую функцию fcntl(2), теряют свои блокировки, что существенно затрудняет создание серверов.

См. также DB_File для других примеров использования flock.

Проблемы с переносимостью: "flock" в perlport.

fork

Выполняет системный вызов fork(2) для создания нового процесса, выполняющего ту же программу в той же точке. Он возвращает идентификатор процесса (pid) дочернего процесса родительскому процессу, 0 дочернему процессу или undef, если вызов fork неудался. Дескрипторы файлов (и иногда блокировки на этих дескрипторах) разделяются, а всё остальное копируется. На большинстве систем, поддерживающих fork(2), уделено большое внимание его высокой эффективности (например, используется технология copy-on-write для страниц данных), что сделало его доминирующей парадигмой для многозадачности за последние несколько десятилетий.

Perl пытается очистить все файлы, открытые для вывода, перед созданием дочернего процесса с помощью fork, но это может не поддерживаться на некоторых платформах (см. perlport). Для безопасности можно установить $| ($AUTOFLUSH на английском языке) или вызвать метод autoflush объекта IO::Handle для любых открытых дескрипторов, чтобы избежать дублирования вывода.

Если вы вызываете fork без ожидания завершения дочерних процессов, вы получите накопление зомби-процессов. На некоторых системах можно избежать этого, установив $SIG{CHLD} в значение "IGNORE". См. также perlipc для получения дополнительных примеров создания и сбора мертвых дочерних процессов.

Обратите внимание, что если созданный дочерний процесс наследует системные дескрипторы, такие как STDIN и STDOUT, которые фактически подключены к пайпу или сокету, даже если вы завершите программу, удалённый сервер (например, CGI-скрипт или запущенная на заднем плане задача из удалённой оболочки) не поймёт, что вы закончили. Вам следует повторно открыть эти дескрипторы на /dev/null, если это проблема.

На некоторых платформах, таких как Windows, где системный вызов fork(2) недоступен, Perl можно скомпилировать с эмуляцией fork в интерпретаторе Perl. Эмуляция на уровне программы Perl разработана для максимальной совместимости с "Unix" fork(2). Однако она имеет ограничения, которые следует учитывать в переносимом коде. Подробнее см. perlfork.

Проблемы переносимости: "fork" в perlport.

format

Объявляет формат изображения для использования функцией write. Например:

format Something =
    Test: @<<<<<<<< @||||| @>>>>>
          $str,     $%,    '$' . int($num)
.

$str = "widget";
$num = $cost/$quantity;
$~ = 'Something';
write;

См. perlform для получения подробной информации и примеров.

formline PICTURE,LIST

Это внутренняя функция, используемая функциями format, хотя вы можете её вызывать. Она форматирует (см. perlform) список значений в соответствии с содержимым PICTURE, размещая вывод в накопитель формата вывода $^A (или $ACCUMULATOR на английском языке). В конечном итоге, когда завершается функция write, содержимое $^A записывается в некоторый дескриптор файла. Вы также можете прочитать $^A и затем установить $^A обратно в "". Обратите внимание, что формат обычно выполняет одну операцию formline на строку формата, но функция formline сама по себе не учитывает, сколько символов новой строки содержится в PICTURE. Это означает, что токены ~ и ~~ обрабатывают всё содержимое PICTURE как одну строку. Таким образом, вам может потребоваться использовать несколько функций formline для реализации формата одного записываемого блока данных, так же, как делает компилятор format.

Будьте осторожны, если вы помещаете двойные кавычки вокруг изображения, так как символ @ может быть воспринят как начало имени массива. formline всегда возвращает true. Смотрите примеры в perlform.

Если вы пытаетесь использовать это вместо write для захвата вывода, вам может быть проще открыть дескриптор файла в скаляре (open my $fh, ">", \$output) и писать в него.

getc FILEHANDLE

getc

Возвращает следующий символ из входного файла, связанного с FILEHANDLE, или значение undefined в конце файла или при возникновении ошибки (в последнем случае устанавливается $!). Если FILEHANDLE опущен, читает из STDIN. Это не особенно эффективно. Однако его нельзя использовать для извлечения отдельных символов без ожидания нажатия пользователем клавиши ввода. Попробуйте что-нибудь вроде:

if ($BSD_STYLE) {
    system "stty cbreak </dev/tty >/dev/tty 2>&1";
}
else {
    system "stty", '-icanon', 'eol', "\001";
}

my $key = getc(STDIN);

if ($BSD_STYLE) {
    system "stty -cbreak </dev/tty >/dev/tty 2>&1";
}
else {
    system 'stty', 'icanon', 'eol', '^@'; # ASCII NUL
}
print "\n";

Решение о том, должно ли устанавливаться значение $BSD_STYLE, предоставляется читателю.

Функция POSIX::getattr может сделать это более переносимым на системах, претендующих на соответствие POSIX. См. также модуль Term::ReadKey на CPAN.

getlogin

Реализует функцию C-библиотеки с тем же именем, которая на большинстве систем возвращает текущий логин из /etc/utmp, если таковой имеется. Если возвращает пустую строку, используйте getpwuid.

my $login = getlogin || getpwuid($<) || "Kilroy";

Не используйте getlogin для аутентификации: она не так безопасна, как getpwuid.

Проблемы переносимости: "getlogin" в perlport.

getpeername SOCKET

Возвращает упакованный адрес sockaddr другого конца соединения SOCKET.

use Socket;
my $hersockaddr    = getpeername($sock);
my ($port, $iaddr) = sockaddr_in($hersockaddr);
my $herhostname    = gethostbyaddr($iaddr, AF_INET);
my $herstraddr     = inet_ntoa($iaddr);

getpgrp PID

Возвращает текущую группу процессов для указанного PID. Используйте PID 0 для получения текущей группы процессов для текущего процесса. Вызовет исключение, если используется на машине, не реализующей getpgrp(2). Если PID опущен, возвращает группу процессов текущего процесса. Обратите внимание, что POSIX-версия getpgrp не принимает аргумент PID, поэтому только PID==0 является полностью переносимой.

Проблемы переносимости: "getpgrp" в perlport.

getppid

Возвращает идентификатор процесса родительского процесса.

Примечание для пользователей Linux: между версиями 5.8.1 и 5.16.0 Perl обходил не-POSIX семантику потоков в меньшинстве систем Linux (и системах Debian GNU/kFreeBSD), которые использовали LinuxThreads, эта эмуляция с тех пор была удалена. См. документацию для $$ для получения подробностей.

Проблемы переносимости: "getppid" в perlport.

getpriority WHICH,WHO

Возвращает текущий приоритет процесса, группы процессов или пользователя. (См. getpriority(2).) Вызовет фатальное исключение, если используется на машине, не реализующей getpriority(2).

WHICH может быть любым из PRIO_PROCESS, PRIO_PGRP или PRIO_USER из "RESOURCE CONSTANTS" в POSIX.

Проблемы переносимости: "getpriority" в perlport.

getpwnam NAME

getgrnam NAME

gethostbyname NAME

getnetbyname NAME

getprotobyname NAME

getpwuid UID

getgrgid GID

getservbyname NAME,PROTO

gethostbyaddr ADDR,ADDRTYPE

getnetbyaddr ADDR,ADDRTYPE

getprotobynumber NUMBER

getservbyport PORT,PROTO

getpwent

getgrent

gethostent

getnetent

getprotoent

getservent

setpwent

setgrent

sethostent STAYOPEN

setnetent STAYOPEN

setprotoent STAYOPEN

setservent STAYOPEN

endpwent

endgrent

endhostent

endnetent

endprotoent

endservent

END_OF_DOCUMENT_MARKER

Эти функции идентичны своим аналогам в системной библиотеке C. В контексте списка возвращаемые значения из различных функций get следующие:

#    0        1          2           3         4
my ( $name,   $passwd,   $gid,       $members  ) = getgr*
my ( $name,   $aliases,  $addrtype,  $net      ) = getnet*
my ( $name,   $aliases,  $port,      $proto    ) = getserv*
my ( $name,   $aliases,  $proto                ) = getproto*
my ( $name,   $aliases,  $addrtype,  $length,  @addrs ) = gethost*
my ( $name,   $passwd,   $uid,       $gid,     $quota,
   $comment,  $gcos,     $dir,       $shell,   $expire ) = getpw*
#    5        6          7           8         9

(Если записи не существует, возвращаемое значение — единственное бессмысленное истинное значение.)

Точное значение поля $gcos варьируется, но обычно оно содержит настоящее имя пользователя (в отличие от имени входа) и другую информацию, относящуюся к пользователю. Однако будьте осторожны, так как во многих системах пользователи могут изменять эту информацию, поэтому ей нельзя доверять, и поэтому $gcos является заражённым (см. perlsec). $passwd и $shell, зашифрованный пароль пользователя и оболочка входа, также заражены по той же причине.

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

my $uid   = getpwnam($name);
my $name  = getpwuid($num);
my $name  = getpwent();
my $gid   = getgrnam($name);
my $name  = getgrgid($num);
my $name  = getgrent();
# etc.

В функциях getpw*() поля $quota, $comment и $expire являются специальными, так как они не поддерживаются во многих системах. Если $quota не поддерживается, это пустой скаляр. Если он поддерживается, то обычно кодирует квоту на диск. Если поле $comment не поддерживается, это пустой скаляр. Если он поддерживается, то обычно кодирует административный комментарий о пользователе. В некоторых системах поле $quota может быть $change или $age, поля, связанные с обновлением паролей. В некоторых системах поле $comment может быть $class. Поле $expire, если оно присутствует, кодирует срок действия учётной записи или пароля. Для получения информации о доступности и точном значении этих полей в вашей системе, пожалуйста, обратитесь к getpwnam(3) и файлу pwd.h вашей системы. Вы также можете узнать, что означают поля $quota и $comment и есть ли поле $expire в Perl, используя модуль Config и значения d_pwquota, d_pwage, d_pwchange, d_pwcomment, и d_pwexpire. Файлы паролей shadow поддерживаются только в том случае, если ваш поставщик реализовал их интуитивно, то есть при вызове обычных функций библиотеки C вы получаете версии shadow, если вы выполняетесь с привилегиями, или если существуют функции shadow(3), как в System V (включая Solaris и Linux). Системы, которые реализуют собственную функцию shadow, вряд ли будут поддерживаться.

Значение $members, возвращаемое функцией getgr*(), представляет собой список имён входа участников группы, разделённый пробелами.

Для функций gethost*(), если переменная h_errno поддерживается в C, она будет возвращена вам через $? в случае ошибки вызова функции. Значение @addrs , возвращённое успешным вызовом, — это список исходных адресов, возвращаемых соответствующим вызовом библиотеки. В домене Интернета каждый адрес имеет длину четыре байта; вы можете распаковать его, сказав что-то вроде:

my ($w,$x,$y,$z) = unpack('W4',$addr[0]);

Библиотека Socket делает это немного проще:

use Socket;
my $iaddr = inet_aton("127.1"); # or whatever address
my $name  = gethostbyaddr($iaddr, AF_INET);

# or going the other way
my $straddr = inet_ntoa($iaddr);

В противоположность этому, для разрешения имени хоста до IP-адреса можно написать так:

use Socket;
my $packed_ip = gethostbyname("www.perl.org");
my $ip_address;
if (defined $packed_ip) {
    $ip_address = inet_ntoa($packed_ip);
}

Убедитесь, что функция gethostbyname вызывается в скалярном контексте и что её возвращаемое значение проверяется на определённость.

Функция getprotobynumber, хотя и принимает только один аргумент, имеет приоритет оператора списка, поэтому будьте внимательны:

getprotobynumber $number eq 'icmp'   # WRONG
getprotobynumber($number eq 'icmp')  # actually means this
getprotobynumber($number) eq 'icmp'  # better this way

Если вам надоело запоминать, какой элемент возвращаемого списка содержит какое возвращаемое значение, в стандартных модулях предоставляются интерфейсы по именам: File::stat, Net::hostent, Net::netent, Net::protoent, Net::servent, Time::gmtime, Time::localtime и User::grent. Эти модули переопределяют стандартные встроенные функции, предоставляя версии, возвращающие объекты с соответствующими именами для каждого поля. Например:

use File::stat;
use User::pwent;
my $is_his = (stat($filename)->uid == pwent($whoever)->uid);

Несмотря на то, что они выглядят как одинаковые вызовы методов (uid), они таковыми не являются, потому что объект File::stat отличается от объекта User::pwent.

Многие из этих функций небезопасны в многопоточной среде, где более одного потока могут их использовать. В частности, функции, такие как getpwent(), итерации по процессам, а не по потокам, поэтому, если два потока одновременно итерируют, ни один из них не получит все записи.

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

Проблемы с переносимостью: "getpwnam" в perlport до "endservent" в perlport.

getsockname SOCKET

Возвращает упакованный адрес sockaddr для этого конца соединения SOCKET в случае, если вы не знаете адрес, потому что у вас несколько разных IP-адресов, на которые может быть установлено соединение.

use Socket;
my $mysockaddr = getsockname($sock);
my ($port, $myaddr) = sockaddr_in($mysockaddr);
printf "Connect to %s [%s]\n",
   scalar gethostbyaddr($myaddr, AF_INET),
   inet_ntoa($myaddr);

getsockopt SOCKET,LEVEL,OPTNAME

Запрашивает опцию с именем OPTNAME, связанную с SOCKET на заданном уровне LEVEL. Опции могут существовать на нескольких уровнях протокола в зависимости от типа сокета, но по крайней мере, самый верхний уровень сокета SOL_SOCKET (определённый в модуле Socket) будет существовать. Чтобы запросить опции на другом уровне, нужно указать номер протокола соответствующего протокола, управляющего опцией. Например, чтобы указать, что опция должна интерпретироваться протоколом TCP, LEVEL должен быть установлен на номер протокола TCP, который вы можете получить с помощью getprotobyname.

Функция возвращает упакованную строку, представляющую запрашиваемую опцию сокета, или undef в случае ошибки, при этом причина ошибки помещается в $!. То, что находится в упакованной строке, зависит от LEVEL и OPTNAME; для получения подробной информации см. getsockopt(2). Часто опция — это целое число, в этом случае результат — упакованное целое число, которое вы можете декодировать, используя unpack с форматом i (или I).

Вот пример проверки того, включён ли алгоритм Nagle для сокета:

use Socket qw(:all);

defined(my $tcp = getprotobyname("tcp"))
    or die "Could not determine the protocol number for tcp";
# my $tcp = IPPROTO_TCP; # Alternative
my $packed = getsockopt($socket, $tcp, TCP_NODELAY)
    or die "getsockopt TCP_NODELAY: $!";
my $nodelay = unpack("I", $packed);
print "Nagle's algorithm is turned ",
       $nodelay ? "off\n" : "on\n";

Проблемы с переносимостью: "getsockopt" в perlport.

glob EXPR

glob

В контексте списка возвращает (возможно, пустой) список расширений имён файлов по значению EXPR, как это делает стандартная оболочка Unix /bin/csh. В скалярном контексте glob итерирует по таким расширениям имён файлов, возвращая undef, когда список исчерпан. Это внутренняя функция, реализующая оператор <*.c>, но вы можете использовать её напрямую. Если EXPR опущено, используется $_. Оператор <*.c> рассматривается более подробно в "Операторы ввода/вывода" в perlop.

Обратите внимание, что glob разделяет свои аргументы по пробелам и обрабатывает каждый фрагмент как отдельный шаблон. Таким образом, glob("*.c *.h") соответствует всем файлам с расширением .c или .h. Выражение glob(".* *") соответствует всем файлам в текущей рабочей директории. Если вам нужно расширять имена файлов, которые могут содержать пробелы, вам нужно использовать дополнительные кавычки вокруг имени файла с пробелами для защиты его. Например, для расширения имён файлов, имеющих e, за которым следует пробел, за которым следует f, используйте один из следующих вариантов:

my @spacies = <"*e f*">;
my @spacies = glob '"*e f*"';
my @spacies = glob q("*e f*");

Если вам нужно было получить переменную, вы могли бы сделать это так:

my @spacies = glob "'*${var}e f*'";
my @spacies = glob qq("*${var}e f*");

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

my @many = glob "{apple,tomato,cherry}={green,yellow,red}";

Этот оператор реализован с помощью стандартного расширения File::Glob. Подробности, включая bsd_glob, который не обрабатывает пробелы как разделители шаблонов, см. в File::Glob.

Если выражение glob используется в качестве условия цикла while или for, оно неявно присваивается $_. Если выражение glob или явное присваивание выражения glob скаляру используется в качестве условия while/for, условие фактически проверяет определённость значения выражения, а не его обычное истинностное значение.

Проблемы с переносимостью: "glob" в perlport.

gmtime EXPR

gmtime

Работает точно так же, как localtime, но возвращаемые значения локализованы для стандартной временной зоны Гринвич.

Примечание: когда вызывается в контексте списка, $isdst, последнее возвращаемое значение gmtime, всегда 0. В GMT нет летнего времени.

Проблемы с переносимостью: "gmtime" в perlport.

goto LABEL

goto EXPR

goto &NAME

Форма goto LABEL находит оператор, помеченный меткой LABEL, и возобновляет выполнение там. Она не может использоваться для выхода из блока или подпрограммы, предоставленной sort. Она может быть использована для перехода почти в любую другую точку в пределах динамической области видимости, включая выход из подпрограмм, но обычно лучше использовать другие конструкции, такие как last или die. Автор Perl никогда не чувствовал необходимости использовать эту форму goto (в Perl, это; C — другой вопрос). (Разница заключается в том, что C не предлагает именованные циклы в сочетании с управлением циклами. Perl делает, и это заменяет большинство структурированных применений goto в других языках.)

Форма goto EXPR ожидает вычисления EXPR до кодового указателя или имени метки. Если она вычисляется до кодового указателя, он будет обрабатываться как goto &NAME, ниже. Это особенно полезно для реализации хвостовой рекурсии с помощью goto __SUB__.

Если выражение вычисляется до имени метки, её область видимости будет разрешена динамически. Это позволяет использовать вычисленные goto по типу FORTRAN, но не обязательно рекомендуется, если вы оптимизируете под поддерживаемость:

goto ("FOO", "BAR", "GLARCH")[$i];

Как показано в этом примере, goto EXPR освобождено от правила "выглядит как функция". Пара скобок, следующая за ним, не (не обязательно) ограничивает его аргумент. goto("NE")."XT" эквивалентно goto NEXT. Кроме того, в отличие от большинства именованных операторов, у него тот же приоритет, что и у присваивания.

Использование goto LABEL или goto EXPR для перехода в конструкцию устарело и вызовет предупреждение. Даже тогда, это не может быть использовано для перехода в любую конструкцию, требующую инициализации, такую как подпрограмма, цикл foreach или блок given. В общем случае, оно не может использоваться для перехода в параметр бинарного или спискового оператора, но может быть использовано для перехода в первый параметр бинарного оператора. (Первый операнд оператора присваивания = — это его правый операнд.) Также нельзя переходить в конструкцию, оптимизированную для пропущения.

Форма goto &NAME существенно отличается от других форм goto. Фактически, это не переход goto в обычном смысле и не имеет негативного отпечатка, связанного с другими goto. Вместо этого, он выходит из текущей подпрограммы (теряя любые изменения, установленные local) и немедленно вызывает указанную подпрограмму, используя текущее значение @_. Это используется подпрограммами AUTOLOAD, которые хотят загрузить другую подпрограмму и затем предположить, что другая подпрограмма была вызвана в первую очередь (кроме того, что любые изменения в @_ в текущей подпрограмме распространяются на другую подпрограмму.) После goto, даже caller не сможет сказать, что эта процедура была вызвана первой.

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

grep BLOCK LIST

grep EXPR,LIST

Это схоже по духу, но не то же самое, что grep(1) и его аналоги. В частности, он не ограничен использованием регулярных выражений.

Вычисляет блок BLOCK или EXPR для каждого элемента LIST (локально устанавливая $_ для каждого элемента) и возвращает значение списка, состоящее из тех элементов, для которых выражение вычислялось в истинное значение. В скалярном контексте возвращает количество раз, когда выражение было истинным.

my @foo = grep(!/^#/, @bar);    # weed out comments

или, что эквивалентно,

my @foo = grep {!/^#/} @bar;    # weed out comments

Обратите внимание, что $_ является псевдонимом для значения списка, поэтому он может использоваться для изменения элементов LIST. Хотя это полезно и поддерживается, это может привести к странным результатам, если элементы LIST не являются переменными. Аналогично, grep возвращает псевдонимы в исходный список, так же, как индекс переменной цикла for псевдонимизирует элементы списка. То есть, изменение элемента списка, возвращенного grep (например, в foreach, map или другом grep), фактически изменяет элемент в исходном списке. Это обычно следует избегать при написании ясного кода.

См. также map для списка, составленного из результатов блока BLOCK или выражения EXPR.

hex EXPR

hex

Интерпретирует EXPR как шестнадцатеричную строку и возвращает соответствующее числовое значение. Если EXPR пропущено, используется $_.

print hex '0xAf'; # prints '175'
print hex 'aF';   # same
$valid_input =~ /\A(?:0?[xX])?(?:_?[0-9a-fA-F])*\z/

Шестнадцатеричная строка состоит из шестнадцатеричных цифр и необязательного 0x или x префикса. Каждая шестнадцатеричная цифра может быть предваряема одиночной чертой подчеркивания, которая будет пропущена. Любой другой символ вызывает предупреждение и заставляет игнорировать остальную часть строки (даже начальные пробелы, в отличие от oct). Могут быть представлены только целые числа, а переполнение целых чисел вызывает предупреждение.

Для преобразования строк, которые могут начинаться с любого из 0, 0x, или 0b, см. oct. Для представления чего-либо в шестнадцатеричном формате, см. printf, sprintf и unpack.

import LIST

Встроенной функции import нет. Это просто обычный метод (подпрограмма), определенный (или унаследованный) модулями, которые хотят экспортировать имена в другой модуль. Функция use вызывает метод import для используемого пакета. См. также use, perlmod и Exporter.

index STR,SUBSTR,POSITION

index STR,SUBSTR

Функция index ищет одну строку внутри другой, но без поведения с подстановкой, как в полном регулярном выражении. Она возвращает позицию первого вхождения SUBSTR в STR начиная с POSITION. Если POSITION пропущена, поиск начинается с начала строки. POSITION перед началом строки или после её конца обрабатываются так, как если бы это было начало или конец соответственно. POSITION и возвращаемое значение основаны на нуле. Если подстрока не найдена, index возвращает -1.

int EXPR

int

Возвращает целую часть EXPR. Если EXPR пропущена, используется $_. Не следует использовать эту функцию для округления: во-первых, потому что она обрезает в сторону 0, и, во-вторых, потому что машинные представления чисел с плавающей точкой иногда могут давать неинтуитивные результаты. Например, int(-6.725/0.025) производит -268 вместо правильного -269; это потому, что это фактически больше похоже на -268.99999999999994315658 вместо. Обычно функции sprintf, printf, или функции POSIX::floor и POSIX::ceil будут служить вам лучше, чем int.

ioctl FILEHANDLE,FUNCTION,SCALAR

Реализует функцию ioctl(2). Вероятно, сначала вам нужно сказать

require "sys/ioctl.ph";  # probably in
                         # $Config{archlib}/sys/ioctl.ph

чтобы получить правильные определения функций. Если sys/ioctl.ph не существует или не содержит правильных определений, вам придётся разработать свои собственные, опираясь на ваши заголовочные файлы C, такие как <sys/ioctl.h>. (В комплекте Perl есть скрипт под названием h2ph, который может вам помочь, но это нетривиально.) SCALAR будет считываться и/или записываться в зависимости от FUNCTION; указатель C на строковое значение SCALAR будет передан в качестве третьего аргумента фактического вызова ioctl. (Если SCALAR не имеет строкового значения, но имеет числовое значение, это значение будет передано вместо указателя на строковое значение. Чтобы гарантировать это, добавьте 0 к скаляру перед использованием.) Функции pack и unpack могут понадобиться для обработки значений структур, используемых ioctl.

Возвращаемое значение ioctl (и fcntl) таково:

if OS returns:      then Perl returns:
    -1               undefined value
     0              string "0 but true"
anything else           that number

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

my $retval = ioctl(...) || -1;
printf "System returned %d\n", $retval;

Специальная строка "0 but true" исключена из Argument "..." isn't numeric предупреждений при ненадлежащем преобразовании чисел.

Проблемы совместимости: "ioctl" в perlport.

join EXPR,LIST

Объединяет отдельные строки LIST в одну строку, разделяя поля значением EXPR, и возвращает эту новую строку. Пример:

my $rec = join(':', $login,$passwd,$uid,$gid,$gcos,$home,$shell);

Обратите внимание, что в отличие от split, join не принимает шаблон в качестве первого аргумента. Сравните split.

keys HASH

keys ARRAY

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

Записи хэша возвращаются в, казалось бы, случайном порядке. Фактический случайный порядок специфичен для данного хэша; абсолютно одинаковая серия операций над двумя хэшами может привести к разному порядку для каждого хэша. Любое добавление в хэш может изменить порядок, как и любое удаление, за исключением самого последнего ключа, возвращенного функциями each или keys, который может быть удален без изменения порядка. До тех пор, пока хэш не изменен, вы можете полагаться на keys, values и each для многократного возвращения одного и того же порядка. Подробности о том, почему порядок хэша случайный, см. в разделе «Атаки на основе алгоритмической сложности» в файле perlsec.

В качестве побочного эффекта, вызов keys сбрасывает внутренний итератор хэша или массива (см. each) перед возвращением ключей. В частности, вызов keys в контексте «пусто» сбрасывает итератор без дополнительной нагрузки.

Вот еще один способ вывести данные вашей среды:

my @keys = keys %ENV;
my @values = values %ENV;
while (@keys) {
    print pop(@keys), '=', pop(@values), "\n";
}

Или, как насчет сортировки по ключу:

foreach my $key (sort(keys %ENV)) {
    print $key, '=', $ENV{$key}, "\n";
}

Возвращаемые значения являются копиями исходных ключей в хэше, поэтому их изменение не повлияет на исходный хэш. Сравните с values.

Чтобы отсортировать хэш по значению, вам нужно использовать функцию sort. Вот сортировка хэша по значениям в порядке убывания:

foreach my $key (sort { $hash{$b} <=> $hash{$a} } keys %hash) {
    printf "%4d %s\n", $hash{$key}, $key;
}

Используемый в левой части оператора присваивания, keys позволяет увеличить количество корзин хэша, выделенных для данного хэша. Это может обеспечить эффективность, если вы знаете, что хэш будет большим. (Это аналогично предварительному расширению массива путем присвоения большего числа к $#array.) Если вы скажете

keys %hash = 200;

тогда %hash будет выделено как минимум 200 корзин — фактически 256, поскольку она округляется до ближайшей степени двойки. Эти корзины сохранятся даже если вы %hash = (), используете undef %hash если хотите освободить память, пока %hash все еще в области действия. Вы не можете уменьшить количество выделенных корзин хэша с помощью keys таким образом (но вам не нужно беспокоиться об этом случайно, так как попытка не оказывает никакого эффекта). keys @array в контексте левой части оператора присваивания — это синтаксическая ошибка.

Начиная с Perl 5.14, экспериментальная функция позволяла keys принимать скалярное выражение. Этот эксперимент был признан неудачным и был удален в Perl 5.24.

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

use 5.012;  # so keys/values/each work on arrays

См. также each, values и sort.

kill SIGNAL, LIST

kill SIGNAL

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

my $cnt = kill 'HUP', $child1, $child2;
kill 'KILL', @goners;

SIGNAL может быть либо именем сигнала (строкой), либо номером сигнала. Имя сигнала может начинаться с префикса SIG, таким образом, FOO и SIGFOO ссылаются на один и тот же сигнал. Рекомендуется использовать строковую форму SIGNAL для обеспечения переносимости, так как один и тот же сигнал может иметь разные номера в разных операционных системах.

Список имен сигналов, поддерживаемых текущей платформой, можно найти в $Config{sig_name}, который предоставляется модулем Config. Дополнительные сведения см. в разделе Config.

Отрицательное имя сигнала эквивалентно отрицательному номеру сигнала, убивая группы процессов вместо отдельных процессов. Например, kill '-KILL', $pgrp и kill -9, $pgrp отправят SIGKILL всей указанной группе процессов. Это означает, что обычно нужно использовать положительные, а не отрицательные сигналы.

Если SIGNAL равно либо числу 0, либо строке ZERO (или SIGZERO), сигнал не отправляется процессу, но kill проверяет, возможно ли отправить сигнал процессу (это означает, что процесс принадлежит тому же пользователю или мы являемся суперпользователем). Это полезно для проверки того, что дочерний процесс все еще жив (даже если только как зомби) и не изменил свой UID. См. perlport для примечаний по переносимости этой конструкции.

Поведение kill, когда номер PROCESS равен нулю или отрицательному, зависит от операционной системы. Например, в соответствии с POSIX, ноль будет сигнализировать текущей группе процессов, -1 — всем процессам, а любой другой отрицательный номер PROCESS будет действовать как отрицательный номер сигнала и убивать всю указанную группу процессов.

Если и SIGNAL, и PROCESS отрицательны, результаты не определены. В будущих версиях может быть выведено предупреждение.

Дополнительные сведения см. в разделе «Сигналы» в perlipc.

На некоторых платформах, таких как Windows, где системный вызов fork(2) недоступен, Perl может быть скомпилирован для эмуляции fork на уровне интерпретатора. Эта эмуляция имеет ограничения, связанные с kill, которые необходимо учитывать при работе на Windows и при написании переносимого кода.

См. perlfork для получения дополнительных сведений.

Если нет списка LIST процессов, сигнал не отправляется, а возвращаемое значение равно 0. Тем не менее, эта форма иногда используется, так как она вызывает проверку на загрязнение.

Проблемы переносимости: "kill" в perlport.

last LABEL

last EXPR

last

Команда last аналогична оператору break в C (как используется в циклах); она немедленно завершает цикл. Если LABEL опущен, команда относится к самому внутреннему вложенному циклу. Форма last EXPR, доступная начиная с Perl 5.18.0, позволяет вычислять имя метки во время выполнения, и в остальном она идентична last LABEL. Блок continue, если таковой имеется, не выполняется:

LINE: while (<STDIN>) {
    last LINE if /^$/;  # exit when done with header
    #...
}

last не может возвращать значение из блока, который обычно возвращает значение, например eval {}, sub {}, или do {}. Она выполняет свою функцию управления потоком, что исключает любое возвращаемое значение. Ее не следует использовать для выхода из операции grep или map.

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

См. также continue для иллюстрации того, как работают last, next и redo.

В отличие от большинства именованных операторов, она имеет ту же приоритетность, что и оператор присваивания. Она также освобождена от правила «выглядит как функция», поэтому last ("foo")."bar" приведет к тому, что «bar» станет частью аргумента для last.

lc EXPR

lc

Возвращает строку EXPR в нижнем регистре. Это внутренняя функция, реализующая escape \L в строках с двойными кавычками.

Если EXPR опущено, используется $_.

Возвращаемое значение зависит от нескольких факторов:

Если use bytes включен:

Результаты следуют правилам ASCII. Только символы A-Z изменяются на a-z соответственно.

В противном случае, если use locale для LC_CTYPE включен:

Учитывается текущий LC_CTYPE локали для кодовых точек < 256; и используются правила Unicode для оставшихся кодовых точек (последнее возможно только если установлен флаг UTF8). См. perllocale.

Начиная с версии 5.20, Perl использует полные правила Unicode, если локализация UTF-8. В противном случае в этом механизме есть недостаток, заключающийся в том, что изменения регистра, пересекающие границу 255/256, не определены однозначно. Например, строчная форма символа LATIN CAPITAL LETTER SHARP S (U+1E9E) в правилах Unicode — U+00DF (на платформах ASCII). Но в use locale (до версии 5.20 или в локализации не UTF-8) строчная форма U+1E9E — это сам символ, потому что 0xDF может не быть LATIN SMALL LETTER SHARP S в текущей локали, и Perl не может знать, существует ли этот символ в локали и, тем более, какой у него кодовой точкой. Perl возвращает результат, который превышает 255 (почти всегда исходный символ без изменений), во всех случаях (а их не много), когда в противном случае была бы пересечена граница 255/256; и начиная с версии 5.22, выводится предупреждение locale.

В противном случае, если у EXPR установлен флаг UTF8:

Используются правила Unicode для изменения регистра.

В противном случае, если use feature 'unicode_strings' или use locale ':not_characters' включены:

Используются правила Unicode для изменения регистра.

В противном случае:

Используются правила ASCII для изменения регистра. Строчная форма любого символа за пределами диапазона ASCII — это сам символ.

lcfirst EXPR

lcfirst

Возвращает значение EXPR с первым символом в нижнем регистре. Это внутренняя функция, реализующая \l escape в строках с двойными кавычками.

Если EXPR опущено, используется $_.

Эта функция ведет себя одинаково при различных параметрах, таких как в локали, как lc.

length EXPR

length

Возвращает длину значения EXPR в символах. Если EXPR опущено, возвращает длину $_. Если EXPR неопределено, возвращает undef.

Эта функция не может быть использована для определения количества элементов в массиве или хэше. Для этого используйте scalar @array и scalar keys %hash, соответственно.

Как и все операции Perl над символами, length обычно работает с логическими символами, а не с физическими байтами. Для определения количества байтов, занимаемых строкой, закодированной в UTF-8, используйте length(Encode::encode('UTF-8', EXPR)) (вам нужно будет use Encode предварительно). См. Encode и perlunicode.

__LINE__

Специальный токен, который компилируется в текущий номер строки.

link OLDFILE,NEWFILE

Создаёт новый файл, связанный со старым именем файла. Возвращает true в случае успеха, false в противном случае.

Проблемы переносимости: "link" в perlport.

listen SOCKET,QUEUESIZE

Выполняет то же, что и системный вызов listen(2). Возвращает true в случае успеха, false в противном случае. См. пример в "Sockets: Клиент/серверное взаимодействие" в perlipc.

local EXPR

Вероятно, вам нужно использовать my вместо local, потому что local не то, что большинство людей понимают под "локальным". Подробности см. в "Переменные, приватные с помощью my()" в perlsub.

local изменяет перечисленные переменные, чтобы они были локальными для вложенного блока, файла или eval. Если указано более одного значения, список должен быть помещён в скобки. Подробности, в том числе проблемы с связанными массивами и хэшами, см. в "Временные значения с помощью local()" в perlsub.

Конструкцию delete local EXPR также можно использовать для локализации удаления элементов массива/хэша в текущем блоке. См. "Локализация удаления элементов составных типов" в perlsub.

localtime EXPR

localtime

Преобразует время, возвращённое функцией time, в список из 9 элементов с анализом времени по местному часовому поясу. Обычно используется следующим образом:

#     0    1    2     3     4    5     6     7     8
my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
                                            localtime(time);

Все элементы списка — числовые и взяты напрямую из C `struct tm'. $sec, $min, и $hour — секунды, минуты и часы указанного времени.

$mday — день месяца, а $mon — месяц в диапазоне 0..11, где 0 — январь, а 11 — декабрь. Это упрощает получение названия месяца из списка:

my @abbr = qw(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec);
print "$abbr[$mon] $mday";
# $mon=9, $mday=18 gives "Oct 18"

$year содержит количество лет с 1900 года. Чтобы получить 4-значный год, напишите:

$year += 1900;

Чтобы получить последние две цифры года (например, "01" в 2001 году), сделайте так:

$year = sprintf("%02d", $year % 100);

$wday — день недели, где 0 — воскресенье, а 3 — среда. $yday — день года в диапазоне 0..364 (или 0..365 в високосные годы).

$isdst равно true, если указанное время попадает на летнее время, и false в противном случае.

Если EXPR опущено, localtime использует текущее время (как возвращает time).

В скалярном контексте localtime возвращает значение ctime(3):

my $now_string = localtime;  # e.g., "Thu Oct 13 04:54:34 1994"

Формат этого скалярного значения не зависит от локали, а встроен в Perl. Для получения GMT вместо местного времени используйте встроенную функцию gmtime. См. также модуль Time::Local (для преобразования секунд, минут, часов и т. д. обратно в целое значение, возвращаемое time) и функции strftime и mktime модуля POSIX.

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

use POSIX qw(strftime);
my $now_string = strftime "%a %b %e %H:%M:%S %Y", localtime;
# or for GMT formatted appropriately for your locale:
my $now_string = strftime "%a %b %e %H:%M:%S %Y", gmtime;

Обратите внимание, что %a и %b, короткие формы дня недели и месяца, могут не обязательно иметь ширину в три символа.

Модули Time::gmtime и Time::localtime предоставляют удобный механизм доступа по имени к функциям gmtime и localtime, соответственно.

Для комплексного представления дат и времени см. модуль DateTime в CPAN.

Проблемы переносимости: "localtime" в perlport.

lock THING

Эта функция размещает консультативный замок на общей переменной или объекте, на который ссылается THING, до тех пор, пока замок не выйдет из области видимости.

Возвращаемое значение — сам скаляр, если аргумент — скаляр, или ссылка, если аргумент — хэш, массив или подпрограмма.

lock — «слабый ключевой» элемент; это означает, что если вы определили функцию с таким именем (до любого вызова), эта функция будет вызвана вместо неё. Если вы не под use threads::shared это ничего не делает. См. threads::shared.

log EXPR

log

Возвращает натуральный логарифм (основание e) EXPR. Если EXPR опущено, возвращает логарифм $_. Для получения логарифма по другому основанию используйте элементарную алгебру: логарифм по основанию N числа равен натуральному логарифму этого числа, делённому на натуральный логарифм N. Например:

sub log10 {
    my $n = shift;
    return log($n)/log(10);
}

См. также exp для обратной операции.

lstat FILEHANDLE

lstat EXPR

lstat DIRHANDLE

lstat

Делает то же, что и функция stat (включая установку специального _ файлового дескриптора), но получает статистическую информацию о символической ссылке, а не о файле, на который она ссылается. Если символические ссылки не поддерживаются на вашей системе, выполняется обычная stat. Более подробная информация приведена в документации для stat.

Если EXPR опущено, получает статистическую информацию о $_.

Проблемы переносимости: "lstat" в perlport.

m//

Оператор совпадения. См. "Операторы regexp-типа-цитирования" в perlop.

map BLOCK LIST

map EXPR,LIST

Оценивает блок BLOCK или EXPR для каждого элемента списка LIST (локально устанавливая $_ для каждого элемента) и формирует список результатов каждой такой оценки. Каждый элемент LIST может генерировать ноль, один или несколько элементов в сгенерированном списке, поэтому количество элементов в сгенерированном списке может отличаться от количества элементов в LIST. В скалярном контексте возвращает общее количество сгенерированных элементов. В списочном контексте возвращает сгенерированный список.

my @chars = map(chr, @numbers);

преобразует список чисел в соответствующие символы.

my @squares = map { $_ * $_ } @numbers;

преобразует список чисел в их квадраты.

my @squares = map { $_ > 5 ? ($_ * $_) : () } @numbers;

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

my @squares = map { $_ * $_ } grep { $_ > 5 } @numbers;

что делает намерение более ясным.

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

my %hash = map { get_a_key_for($_) => $_ } @array;

просто забавный способ написать

my %hash;
foreach (@array) {
    $hash{get_a_key_for($_)} = $_;
}

Обратите внимание, что $_ является псевдонимом для значения списка, поэтому его можно использовать для изменения элементов LIST. Хотя это полезно и поддерживается, это может привести к странным результатам, если элементы LIST не являются переменными. В большинстве случаев использование обычного цикла foreach было бы более понятным. См. также grep для списка, состоящего из тех элементов исходного списка, для которых блок BLOCK или EXPR вычисляется как истинное.

{ запускает как ссылки на хэши, так и блоки, поэтому map { ... может быть началом map BLOCK LIST или map EXPR, LIST. Поскольку Perl не смотрит вперед на закрывающий } он должен угадать, с чем имеет дело, основываясь на том, что он находит сразу после {. Обычно он угадывает правильно, но если нет, он не поймет, что что-то не так, пока не доберется до } и не встретит отсутствующую (или неожиданную) запятую. Ошибка синтаксиса будет сообщена около }, но вам нужно будет изменить что-то около {, например, использовать унарный + или точку с запятой, чтобы помочь Perl:

my %hash = map {  "\L$_" => 1  } @array # perl guesses EXPR. wrong
my %hash = map { +"\L$_" => 1  } @array # perl guesses BLOCK. right
my %hash = map {; "\L$_" => 1  } @array # this also works
my %hash = map { ("\L$_" => 1) } @array # as does this
my %hash = map {  lc($_) => 1  } @array # and this.
my %hash = map +( lc($_) => 1 ), @array # this is EXPR and works!

my %hash = map  ( lc($_), 1 ),   @array # evaluates to (1, @array)

или для принудительной работы с конструктором анонимного хэша используйте +{:

my @hashes = map +{ lc($_) => 1 }, @array # EXPR, so needs
                                          # comma at end

чтобы получить список анонимных хэшей, каждый из которых содержит только одну запись.

mkdir FILENAME,MODE

mkdir FILENAME

mkdir

Создает директорию, указанную FILENAME, с правами доступа, указанными MODE (как модифицированные umask). Если операция прошла успешно, возвращает true; в противном случае возвращает false и устанавливает $! (errno). MODE по умолчанию равен 0777, если он опущен, а FILENAME по умолчанию равен $_, если он опущен.

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

Обратите внимание, что в соответствии с POSIX 1003.1-1996 FILENAME может иметь любое количество конечных слешей. Некоторые операционные системы и файловые системы не следуют этому правилу, поэтому Perl автоматически удаляет все конечные слеши, чтобы всем было комфортно.

Для рекурсивного создания структуры каталогов посмотрите функцию make_path модуля File::Path.

msgctl ID,CMD,ARG

Вызывает функцию системной IPC msgctl(2). Вероятно, вам сначала нужно сказать

use IPC::SysV;

чтобы получить правильные определения констант. Если CMD - IPC_STAT, то ARG должен быть переменной, которая будет содержать возвращаемую msqid_ds структуру. Возвращает, как и ioctl: значение undef для ошибки, "0 but true" для нуля или фактическое возвращаемое значение в противном случае. См. также "SysV IPC" в perlipc и документацию для IPC::SysV и IPC::Semaphore.

Проблемы с переносимостью: "msgctl" в perlport.

msgget KEY,FLAGS

Вызывает функцию системной IPC msgget(2). Возвращает идентификатор очереди сообщений или undef в случае ошибки. См. также "SysV IPC" в perlipc и документацию для IPC::SysV и IPC::Msg.

Проблемы с переносимостью: "msgget" в perlport.

msgrcv ID,VAR,SIZE,TYPE,FLAGS

Вызывает функцию системной IPC msgrcv для получения сообщения из очереди сообщений ID в переменную VAR с максимальным размером сообщения SIZE. Обратите внимание, что при получении сообщения тип сообщения как целое число по умолчанию будет первым элементом в VAR, за ним следует само сообщение. Это упаковывание можно открыть с помощью unpack("l! a*"). Объект переменной отмечается. Возвращает true при успехе, false при ошибке. См. также "SysV IPC" в perlipc и документацию для IPC::SysV и IPC::Msg.

Проблемы с переносимостью: "msgrcv" в perlport.

msgsnd ID,MSG,FLAGS

Вызывает функцию системной IPC msgsnd для отправки сообщения MSG в очередь сообщений ID. MSG должен начинаться с целого числа типа сообщения по умолчанию, за которым следует длина фактического сообщения, а затем само сообщение. Этого рода упаковку можно достичь с помощью pack("l! a*", $type, $message). Возвращает true при успехе, false при ошибке. См. также "SysV IPC" в perlipc и документацию для IPC::SysV и IPC::Msg.

Проблемы с переносимостью: "msgsnd" в perlport.

my VARLIST

my TYPE VARLIST

my VARLIST : ATTRS

my TYPE VARLIST : ATTRS

Оператор my объявляет перечисленные переменные локальными (лексически) для содержащего блока, файла или eval. Если перечисляется более одной переменной, список должен быть заключен в скобки.

Точные семантика и интерфейс TYPE и ATTRS все еще развиваются. TYPE может быть обычным словом, константой, объявленной с помощью use constant, или __PACKAGE__. В настоящее время он связан с использованием псевдонима fields, а атрибуты обрабатываются с помощью псевдонима attributes, или начиная с Perl 5.8.0, также через модуль Attribute::Handlers. Подробности см. в "Private Variables via my()" in perlsub.

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

my ( undef, $min, $hour ) = localtime;

next LABEL

next EXPR

next

Команда next похожа на оператор continue в C; она запускает следующую итерацию цикла:

LINE: while (<STDIN>) {
    next LINE if /^#/;  # discard comments
    #...
}

Обратите внимание, что если бы у нас был блок continue в вышеприведенном примере, он был бы выполнен даже для отброшенных строк. Если LABEL опущено, команда относится к самому внутреннему содержащему циклу. Форма next EXPR, доступная начиная с Perl 5.18.0, позволяет имени метки вычисляться во время выполнения, оставаясь при этом идентичной next LABEL.

next не может вернуть значение из блока, который обычно возвращает значение, например eval {}, sub {}, или do {}. Она выполнит свое поведение управления потоком, что исключает возвращаемое значение. Не следует использовать для выхода из операции grep или map.

Обратите внимание, что сам блок по смыслу идентичен циклу, который выполняется один раз. Таким образом, next завершит такой блок раньше.

См. также continue для иллюстрации того, как работают last, next и redo.

В отличие от большинства именованных операторов, он имеет тот же приоритет, что и присвоение. Он также освобожден от правила "выглядит как функция", поэтому next ("foo")."bar" приведет к тому, что "bar" станет частью аргумента для next.

no MODULE VERSION LIST

no MODULE VERSION

no MODULE LIST

no MODULE

no VERSION

См. функцию use, обратной к no.

oct EXPR

oct

Интерпретирует EXPR как восьмеричную строку и возвращает соответствующее значение. (Если EXPR случайно начинается с 0x, интерпретирует его как шестнадцатеричную строку. Если EXPR начинается с 0b, он интерпретируется как двоичная строка. Пробелы в начале игнорируются во всех трех случаях.) Следующее обработает десятичные, двоичные, восьмеричные и шестнадцатеричные числа в стандартной нотации Perl:

$val = oct($val) if $val =~ /^0/;

Если EXPR опущен, используется $_. Чтобы сделать обратное (получить число в восьмеричном виде), используйте sprintf или printf:

my $dec_perms = (stat("filename"))[2] & 07777;
my $oct_perm_str = sprintf "%o", $perms;

Функция oct обычно используется, когда строка, такая как 644, должна быть преобразована в режим файла, например. Хотя Perl автоматически преобразует строки в числа по мере необходимости, это автоматическое преобразование предполагает основание 10.

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

open FILEHANDLE,EXPR

open FILEHANDLE,MODE,EXPR

open FILEHANDLE,MODE,EXPR,LIST

open FILEHANDLE,MODE,REFERENCE

open FILEHANDLE

Открывает файл с именем, заданным EXPR, и связывает его с FILEHANDLE.

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

open(my $fh, "<", "input.txt")
    or die "Can't open < input.txt: $!";

и для записи:

open(my $fh, ">", "output.txt")
    or die "Can't open > output.txt: $!";

(Следующее — исчерпывающая справка по open; для более лёгкого ознакомления вы можете обратиться к perlopentut.)

Если FILEHANDLE — неопределённая скалярная переменная (или элемент массива или хеша), создаётся новый файловый дескриптор, означающий, что переменной присваивается ссылка на новый выделенный анонимный файловый дескриптор. В противном случае, если FILEHANDLE — выражение, его значение — реальный файловый дескриптор. (Это считается символической ссылкой, поэтому use strict "refs" не должна быть активна.)

Если указано три (или более) аргумента, режим открытия (включая необязательное кодирование) во втором аргументе отличается от имени файла в третьем. Если MODE — < или пусто, файл открывается для чтения. Если MODE — >, файл открывается для записи, при этом существующие файлы сначала усекаются («перезаписываются»), а не существующие файлы создаются. Если MODE — >>, файл открывается для добавления, при необходимости создаваясь.

Можно поместить + перед > или < для указания того, что вы хотите получить доступ для чтения и записи к файлу; таким образом, +< почти всегда предпочтительнее для обновления чтения/записи — режим +> сначала перезапишет файл. Обычно нельзя использовать режим чтения/записи для обновления текстовых файлов, так как они имеют записи переменной длины. Обратитесь к переключателю -i в perlrun для лучшего подхода. Файл создаётся с разрешениями 0666 с учётом значения маски процесса umask.

Эти различные префиксы соответствуют режимам fopen(3) r, r+, w, w+, a, и a+.

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

Для трёх и более аргументов, если MODE — |-, имя файла интерпретируется как команда, для которой будет направлен вывод, а если MODE — -|, имя файла интерпретируется как команда, которая направить вывод к нам. В двухаргументном (и одноаргументном) формате тире (-) должно быть заменено командой. См. "Using open() for IPC" в perlipc для получения дополнительных примеров этого. (Вам не разрешается open к команде, которая направляет и вход, и выход, но см. IPC::Open2, IPC::Open3 и "Bidirectional Communication with Another Process" в perlipc для альтернатив.)

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

В двухаргументном (и одноаргументном) формате открытие <- или - открывает STDIN, а открытие >- открывает STDOUT.

Можно (и обычно нужно) использовать трёх-аргументный формат open для указания уровней ВВОД/ВЫВОД (иногда называемых «дисциплинами»), которые применяются к дескриптору, влияя на обработку ввода и вывода (подробнее см. open и PerlIO). Например:

open(my $fh, "<:encoding(UTF-8)", $filename)
  || die "Can't open UTF-8 encoded $filename: $!";

открывает закодированный в UTF8 файл, содержащий символы Unicode; см. perluniintro. Обратите внимание, что если слои указаны в трёх-аргументном формате, то слои по умолчанию, хранящиеся в ${^OPEN} (см. perlvar; обычно задаваемые прагмой open или переключателем -CioD), игнорируются. Эти слои также игнорируются, если вы указываете двоеточие без последующего имени. В этом случае используется слой по умолчанию для операционной системы (:raw в Unix, :crlf в Windows).

Open возвращает ненулевое значение при успехе, и неопределённое значение в противном случае. Если open включал канал, возвращаемое значение оказывается pid дочернего процесса.

В некоторых системах (в целом, системах DOS и Windows) binmode необходимо, когда вы работаете не с текстовым файлом. Для обеспечения переносимости рекомендуется всегда использовать его, когда это необходимо, и никогда не использовать, когда это не требуется. Также, люди могут установить свой ввод/вывод по умолчанию в формате закодированных символов Unicode UTF8, а не байтов.

При открытии файла редко бывает хорошей идеей продолжать, если запрос завершился неудачно, поэтому open часто используется с die. Даже если die не выполнит желаемое действие (скажем, в сценарии CGI, где требуется отформатировать подходящее сообщение об ошибке (но есть модули, которые могут помочь с этой проблемой)), всегда проверяйте возвращаемое значение при открытии файла.

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

close($handle)
   || warn "close failed: $!";

Более старый стиль заключается в использовании слова-метки в качестве файлового дескриптора, как в

open(FH, "<", "input.txt")
   or die "Can't open < input.txt: $!";

Тогда вы можете использовать FH в качестве файлового дескриптора в close FH и <FH> и так далее. Обратите внимание, что это глобальная переменная, поэтому такой формат не рекомендуется в новом коде.

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

$ARTICLE = 100;
open(ARTICLE) or die "Can't find article $ARTICLE: $!\n";

Здесь $ARTICLE должна быть глобальной (пакетной) скалярной переменной — не переменной, объявленной с my или state.

В качестве специального случая трёх-аргументный формат с режимом чтения/записи и третьим аргументом, являющимся undef:

open(my $tmp, "+>", undef) or die ...

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

Perl по умолчанию построен с использованием PerlIO. Если вы этого не изменили (например, если Perl был скомпилирован с Configure -Uuseperlio), вы можете открыть файловые дескрипторы напрямую к скалярам Perl через:

open(my $fh, ">", \$variable) || ..

Для (повторного) открытия STDOUT или STDERR как файлом в памяти, закройте его сначала:

close STDOUT;
open(STDOUT, ">", \$variable)
    or die "Can't open STDOUT: $!";

Скаляры для файлов в памяти обрабатываются как строки октетов: если файл не открывается с усечением, скаляр может не содержать каких-либо кодовых точек свыше 0xFF.

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

См. perliol для получения подробной информации о PerlIO.

Общие примеры:

open(my $log, ">>", "/usr/spool/news/twitlog");
# if the open fails, output is discarded

open(my $dbase, "+<", "dbase.mine")      # open for update
    or die "Can't open 'dbase.mine' for update: $!";

open(my $dbase, "+<dbase.mine")          # ditto
    or die "Can't open 'dbase.mine' for update: $!";

open(my $article_fh, "-|", "caesar <$article")  # decrypt
                                                # article
    or die "Can't start caesar: $!";

open(my $article_fh, "caesar <$article |")      # ditto
    or die "Can't start caesar: $!";

open(my $out_fh, "|-", "sort >Tmp$$")    # $$ is our process id
    or die "Can't start sort: $!";

# in-memory files
open(my $memory, ">", \$var)
    or die "Can't open memory file: $!";
print $memory "foo!\n";              # output will appear in $var

Также вы можете, в стиле Bourne shell, указать EXPR, начинающийся с >&, в этом случае остальная часть строки интерпретируется как имя файлового дескриптора (или файлового дескриптора, если он числовой), который будет дублироваться (как в dup(2)) и открываться. Вы можете использовать & после >, >>, <, +>, +>>, и +<. Указанный вами режим должен соответствовать режиму исходного файлового дескриптора. (Дублирование файлового дескриптора не учитывает никаких имеющихся содержимого буферов ВВОД/ВЫВОД.) Если вы используете трёх-аргументный формат, то вы можете передать число, имя файлового дескриптора или обычную «ссылку на глобальную переменную».

Вот сценарий, который сохраняет, перенаправляет и восстанавливает STDOUT и STDERR с помощью различных методов:

#!/usr/bin/perl
open(my $oldout, ">&STDOUT")     or die "Can't dup STDOUT: $!";
open(OLDERR,     ">&", \*STDERR) or die "Can't dup STDERR: $!";

open(STDOUT, '>', "foo.out") or die "Can't redirect STDOUT: $!";
open(STDERR, ">&STDOUT")     or die "Can't dup STDOUT: $!";

select STDERR; $| = 1;  # make unbuffered
select STDOUT; $| = 1;  # make unbuffered

print STDOUT "stdout 1\n";  # this works for
print STDERR "stderr 1\n";  # subprocesses too

open(STDOUT, ">&", $oldout) or die "Can't dup \$oldout: $!";
open(STDERR, ">&OLDERR")    or die "Can't dup OLDERR: $!";

print STDOUT "stdout 2\n";
print STDERR "stderr 2\n";

Если вы указываете '<&=X', где X — номер файлового дескриптора или файловый дескриптор, то Perl выполнит эквивалент C's fdopen(3) этого файлового дескриптора (и не вызовет dup(2)); это более бережливое использование файловых дескрипторов. Например:

# open for input, reusing the fileno of $fd
open(my $fh, "<&=", $fd)

или

open(my $fh, "<&=$fd")

или

# open for append, using the fileno of $oldfh
open(my $fh, ">>&=", $oldfh)

Бережливость файловых дескрипторов также полезна (кроме бережливости) например, когда что-то зависит от файловых дескрипторов, например, при блокировке с использованием flock. Если вы сделаете только open(my $A, ">>&", $B), файловый дескриптор $A не будет иметь того же файлового дескриптора, что и $B, и поэтому flock($A) не будет flock($B) и наоборот. Но с open(my $A, ">>&=", $B), файловые дескрипторы будут разделять один и тот же системный файловый дескриптор.

Обратите внимание, что в Perl-версиях, более ранних 5.8.0, Perl использует стандартную C-библиотеку's fdopen(3) для реализации функциональности =. Во многих Unix-системах fdopen(3) завершается неудачей, когда файловые дескрипторы превышают определённое значение, обычно 255. Для Perl 5.8.0 и более поздних версий PerlIO является (чаще всего) по умолчанию.

Вы можете узнать, был ли ваш Perl скомпилирован с PerlIO, выполнив perl -V:useperlio. Если он возвращает 'define', у вас PerlIO; в противном случае — нет.

Если вы открываете канал по команде - (то есть, указываете либо |- или -| в одно- или двухаргументных формах open), происходит неявное fork, поэтому open возвращает дважды: в родительском процессе он возвращает pid дочернего процесса, а в дочернем процессе он возвращает (определённое) 0. Используйте defined($pid) или // для определения того, был ли открыт доступ успешно.

Например, используйте либо

my $child_pid = open(my $from_kid, "-|") // die "Can't fork: $!";

или

my $child_pid = open(my $to_kid,   "|-") // die "Can't fork: $!";

последующее

if ($child_pid) {
    # am the parent:
    # either write $to_kid or else read $from_kid
    ...
   waitpid $child_pid, 0;
} else {
    # am the child; use STDIN/STDOUT normally
    ...
    exit;
}

Обработчик файла ведет себя нормально для родительского процесса, но ввод/вывод для этого обработчика файла перенаправляется из/в стандартный вывод/ввод дочернего процесса. В дочернем процессе обработчик файла не открывается – ввод/вывод происходит из/в новый стандартный вывод/ввод. Обычно это используется как обычный перенаправленный открытый файл, когда требуется больший контроль над тем, как выполняется команда перенаправления, например, при запуске setuid, чтобы не приходилось сканировать командные строки на метасимволы.

Следующие блоки в большей или меньшей степени эквивалентны:

open(my $fh, "|tr '[a-z]' '[A-Z]'");
open(my $fh, "|-", "tr '[a-z]' '[A-Z]'");
open(my $fh, "|-") || exec 'tr', '[a-z]', '[A-Z]';
open(my $fh, "|-", "tr", '[a-z]', '[A-Z]');

open(my $fh, "cat -n '$file'|");
open(my $fh, "-|", "cat -n '$file'");
open(my $fh, "-|") || exec "cat", "-n", $file;
open(my $fh, "-|", "cat", "-n", $file);

Последние два примера в каждом блоке показывают перенаправление в «списочной форме», которое пока не поддерживается на всех платформах. Хорошее эмпирическое правило состоит в том, что если ваша платформа имеет реальный fork (другими словами, если ваша платформа – Unix, включая Linux и macOS X), вы можете использовать списочную форму. Вы хотите использовать списочную форму перенаправления, чтобы вы могли передавать буквальные аргументы команде без риска интерпретации оболочкой метасимволов оболочки в них. Однако это также запрещает вам открывать перенаправления на команды, которые намеренно содержат метасимволы оболочки, такие как:

open(my $fh, "|cat -n | expand -4 | lpr")
    || die "Can't open pipeline to lpr: $!";

См. "Безопасные открытия перенаправлений" в perlipc для получения дополнительных примеров.

Perl попытается очистить все открытые для вывода файлы перед любой операцией, которая может вызвать вилку, но это может не поддерживаться на некоторых платформах (см. perlport). Для безопасности может потребоваться установить $| ($AUTOFLUSH в English) или вызвать метод autoflush объекта IO::Handle для любого открытого обработчика.

В системах, поддерживающих флаг close-on-exec для файлов, флаг будет установлен для нового открытого дескриптора файла, как определено значением $^F. См. "$^F" в perlvar.

Закрытие любого перенаправленного обработчика файла заставляет родительский процесс ожидать завершения дочернего процесса, а затем возвращает значение состояния в $? и ${^CHILD_ERROR_NATIVE}.

Имя файла, переданное в одно- и двухаргументные формы open, будет иметь удаленные начальные и конечные пробелы и учтены обычные символы перенаправления. Это свойство, известное как «магическое открытие», часто может быть использовано с пользой. Пользователь может указать имя файла «rsh cat file |», или вы можете по мере необходимости изменить некоторые имена файлов:

$filename =~ s/(.*\.gz)\s*$/gzip -dc < $1|/;
open(my $fh, $filename) or die "Can't open $filename: $!";

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

open(my $fh, "<", $file)
    || die "Can't open $file: $!";

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

$file =~ s#^(\s)#./$1#;
open(my $fh, "< $file\0")
    || die "Can't open $file: $!";

(это может не сработать на некоторых странных файловых системах). Следует сознательно выбирать между магической и трехаргументной формой open:

open(my $in, $ARGV[0]) || die "Can't open $ARGV[0]: $!";

позволит пользователю указать аргумент в формате "rsh cat file |", но не будет работать с именем файла, которое случайно имеет конечный пробел, в то время как

open(my $in, "<", $ARGV[0])
    || die "Can't open $ARGV[0]: $!";

будет иметь точно противоположные ограничения. (Однако некоторые оболочки поддерживают синтаксис perl your_program.pl <( rsh cat file ), который генерирует имя файла, которое можно открыть обычным образом.)

Если вам нужен «реальный» C open(2), то вы должны использовать функцию sysopen, которая не включает в себя такую магию (но использует разные режимы файлов, чем Perl open, что соответствует C fopen(3)). Это еще один способ защиты имен файлов от интерпретации. Например:

use IO::Handle;
sysopen(my $fh, $path, O_RDWR|O_CREAT|O_EXCL)
    or die "Can't open $path: $!";
$fh->autoflush(1);
print $fh "stuff $$\n";
seek($fh, 0, 0);
print "File contains: ", readline($fh);

См. seek для получения некоторых подробностей о смешанном чтении и записи.

Проблемы совместимости: "open" в perlport.

opendir DIRHANDLE,EXPR

Открывает директорию с именем EXPR для обработки функциями readdir, telldir, seekdir, rewinddir и closedir. Возвращает true, если операция выполнена успешно. DIRHANDLE может быть выражением, значение которого может использоваться как косвенный обработчик каталога, обычно фактическое имя обработчика каталога. Если DIRHANDLE является неопределенной скалярной переменной (или элементом массива или хеша), переменная получает ссылку на новый анонимный обработчик каталога; то есть, она автоинициализируется. Обработчики каталогов – это те же объекты, что и обработчики файлов; объект ввода/вывода может быть открыт только как один из этих типов обработчиков одновременно.

См. пример в readdir.

ord EXPR

ord

Возвращает числовое значение первого символа EXPR. Если EXPR – пустая строка, возвращает 0. Если EXPR опущено, используется $_. (Обратите внимание на символ, а не байт.)

Для обратного преобразования см. chr. См. perlunicode для получения дополнительной информации об Юникоде.

our VARLIST

our TYPE VARLIST

our VARLIST : ATTRS

our TYPE VARLIST : ATTRS

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

our имеет те же правила области действия, что и my или state, что означает, что она действительна только в рамках лексического пространства имен. В отличие от my и state, которые оба объявляют новые (лексические) переменные, our создает только псевдоним к существующей переменной: переменной пакета с тем же именем.

Это означает, что когда use strict 'vars' активна, our позволяет вам использовать переменную пакета без указания имени пакета, но только в рамках лексического пространства имен объявления our. Это применяется немедленно – даже в рамках одного и того же оператора.

package Foo;
use strict;

$Foo::foo = 23;

{
    our $foo;   # alias to $Foo::foo
    print $foo; # prints 23
}

print $Foo::foo; # prints 23

print $foo; # ERROR: requires explicit package name

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

package Foo;
use strict;

our $foo = 23;   # just like $Foo::foo = 23

print $Foo::foo; # prints 23

Поскольку переменная становится допустимой сразу при use strict 'vars', пока нет переменной с этим именем в области видимости, вы можете снова обратиться к переменной пакета даже в рамках одного и того же оператора.

package Foo;
use strict;

my  $foo = $foo; # error, undeclared $foo on right-hand side
our $foo = $foo; # no errors

Если перечислено несколько переменных, список должен быть помещен в скобки.

our($bar, $baz);

Объявление our объявляет псевдоним к переменной пакета, который будет виден во всем его лексическом пространстве имен, даже через границы пакетов. Пакет, в котором вводится переменная, определяется в момент объявления, а не в момент использования. Это означает, что сохраняется следующее поведение:

package Foo;
our $bar;      # declares $Foo::bar for rest of lexical scope
$bar = 20;

package Bar;
print $bar;    # prints 20, as it refers to $Foo::bar

Различные объявления our с одинаковым именем в одном лексическом пространстве имен разрешены, если они находятся в разных пакетах. Если они находятся в одном пакете, Perl выведет предупреждения, если вы их запросили, так же, как и при нескольких объявлениях my. В отличие от второго объявления my, которое свяжет имя с новой переменной, второе объявление our в том же пакете, в том же пространстве имен, просто избыточно.

use warnings;
package Foo;
our $bar;      # declares $Foo::bar for rest of lexical scope
$bar = 20;

package Bar;
our $bar = 30; # declares $Bar::bar for rest of lexical scope
print $bar;    # prints 30

our $bar;      # emits warning but has no other effect
print $bar;    # still prints 30

Объявление our также может иметь список атрибутов, связанных с ним.

Точные семантика и интерфейс TYPE и ATTRS все еще развиваются. В настоящее время TYPE связан с использованием pragmy fields, а атрибуты обрабатываются с помощью pragmy attributes или, начиная с Perl 5.8.0, также с помощью модуля Attribute::Handlers. См. "Приватные переменные через my()" в perlsub для получения подробностей.

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

our ( undef, $min, $hour ) = localtime;

our отличается от use vars, которое позволяет использовать неквалифицированное имя только внутри затронутого пакета, но в разных областях видимости.

pack TEMPLATE,LIST

Принимает список значений и преобразует его в строку, используя правила, заданные TEMPLATE. Результирующая строка представляет собой конкатенацию преобразованных значений. Обычно каждое преобразованное значение выглядит как его представление на уровне машины. Например, на 32-битных машинах целое число может быть представлено последовательностью из 4 байтов, что в Perl будет представлено как строка длиной 4 символа.

См. perlpacktut для введения в эту функцию.

TEMPLATE – это последовательность символов, задающих порядок и тип значений, как показано ниже:

a  A string with arbitrary binary data, will be null padded.
A  A text (ASCII) string, will be space padded.
Z  A null-terminated (ASCIZ) string, will be null padded.

b  A bit string (ascending bit order inside each byte,
   like vec()).
B  A bit string (descending bit order inside each byte).
h  A hex string (low nybble first).
H  A hex string (high nybble first).

c  A signed char (8-bit) value.
C  An unsigned char (octet) value.
W  An unsigned char value (can be greater than 255).

s  A signed short (16-bit) value.
S  An unsigned short value.

l  A signed long (32-bit) value.
L  An unsigned long value.

q  A signed quad (64-bit) value.
Q  An unsigned quad value.
     (Quads are available only if your system supports 64-bit
      integer values _and_ if Perl has been compiled to support
      those.  Raises an exception otherwise.)

i  A signed integer value.
I  An unsigned integer value.
     (This 'integer' is _at_least_ 32 bits wide.  Its exact
      size depends on what a local C compiler calls 'int'.)

n  An unsigned short (16-bit) in "network" (big-endian) order.
N  An unsigned long (32-bit) in "network" (big-endian) order.
v  An unsigned short (16-bit) in "VAX" (little-endian) order.
V  An unsigned long (32-bit) in "VAX" (little-endian) order.

j  A Perl internal signed integer value (IV).
J  A Perl internal unsigned integer value (UV).

f  A single-precision float in native format.
d  A double-precision float in native format.

F  A Perl internal floating-point value (NV) in native format
D  A float of long-double precision in native format.
     (Long doubles are available only if your system supports
      long double values _and_ if Perl has been compiled to
      support those.  Raises an exception otherwise.
      Note that there are different long double formats.)

p  A pointer to a null-terminated string.
P  A pointer to a structure (fixed-length string).

u  A uuencoded string.
U  A Unicode character number.  Encodes to a character in char-
   acter mode and UTF-8 (or UTF-EBCDIC in EBCDIC platforms) in
   byte mode.

w  A BER compressed integer (not an ASN.1 BER, see perlpacktut
   for details).  Its bytes represent an unsigned integer in
   base 128, most significant digit first, with as few digits
   as possible.  Bit eight (the high bit) is set on each byte
   except the last.

x  A null byte (a.k.a ASCII NUL, "\000", chr(0))
X  Back up a byte.
@  Null-fill or truncate to absolute position, counted from the
   start of the innermost ()-group.
.  Null-fill or truncate to absolute position specified by
   the value.
(  Start of a ()-group.

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

!   sSlLiI     Forces native (short, long, int) sizes instead
               of fixed (16-/32-bit) sizes.

!   xX         Make x and X act as alignment commands.

!   nNvV       Treat integers as signed instead of unsigned.

!   @.         Specify position as byte offset in the internal
               representation of the packed string.  Efficient
               but dangerous.

>   sSiIlLqQ   Force big-endian byte-order on the type.
    jJfFdDpP   (The "big end" touches the construct.)

<   sSiIlLqQ   Force little-endian byte-order on the type.
    jJfFdDpP   (The "little end" touches the construct.)

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

Применяются следующие правила:

Каждый символ может быть необязательно последован числом, указывающим количество повторений. Числовое количество повторений может быть необязательно заключено в скобки, как в pack("C[80]", @arr). Количество повторений потребляет столько же значений из СПИСКА, когда используется со всеми типами форматов, кроме a, A, Z, b, B, h, H, @, ., x, X, и P, где оно имеет другое значение, описанное ниже. Предоставление * для количества повторений вместо числа означает использование всех оставшихся элементов, за исключением:
- @, x, и X, где оно эквивалентно 0.
- <.>, где это относится к началу строки.
- u, где это эквивалентно 1 (или 45, что здесь эквивалентно).
Можно заменить числовое количество повторений символом шаблона в скобках, чтобы использовать упакованную длину байтов скобочного шаблона для количества повторений.

Например, шаблон x[L] пропускает столько байтов, сколько в упакованном длинном целом числе, а шаблон "$t X[$t] $t" распаковывает вдвое больше, чем $t (при переменном расширении) распаковывает. Если шаблон в скобках содержит команды выравнивания (такие как x![d]), его упакованная длина вычисляется так, как если бы начало шаблона имело максимальное возможное выравнивание.

При использовании с Z, * в качестве количества повторений гарантирует добавление завершающего нулевого байта, поэтому результирующая строка всегда на один байт длиннее, чем длина байтов самого элемента.

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

При использовании с ., количество повторений определяет начальную позицию для вычисления смещения значения следующим образом:
- Если количество повторений 0, оно относительное к текущей позиции.
- Если количество повторений *, смещение относительно начала упакованной строки.
- И если это целое число n, смещение относительно начала n-го самого внутреннего ( ) блока или начала строки, если n больше уровня блока.
Количество повторений для u интерпретируется как максимальное количество байтов для кодирования за строку вывода, при этом 0, 1 и 2 заменяются 45. Количество повторений не должно превышать 65.
Типы a, A, и Z потребляют только одно значение, но упаковывают его как строку длиной count, заполняя нулями или пробелами по мере необходимости. При распаковке A удаляет хвостовые пробелы и нули, Z удаляет все после первого нуля, а a возвращает данные без удаления.

Если значение для упаковки слишком длинное, результат усекается. Если оно слишком длинное и указано явное количество, Z упаковывает только $count-1 байтов, за которыми следует нулевой байт. Таким образом, Z всегда упаковывает завершающий нуль, за исключением случая, когда count равен 0.
Аналогичным образом, форматы b и B упаковывают строку, длина которой указана в битах. Каждый такой формат генерирует 1 бит результата. За ними обычно следует количество повторений, например B8 или B64.

Каждый результирующий бит основан на младшем бите соответствующего входного символа, т. е. на ord($char)%2. В частности, символы "0" и "1" генерируют биты 0 и 1, как и символы "\000" и "\001".

Начиная с начала входной строки, каждая 8-ка символов преобразуется в 1 символ вывода. С форматом b, первый символ 8-ки определяет младший бит символа; с форматом B, он определяет старший бит символа.

Если длина входной строки не делится на 8 без остатка, остаток упаковывается так, как если бы входная строка дополнялась нулевыми символами в конце. Аналогично, "лишние" биты игнорируются при распаковке.

Если входная строка длиннее, чем необходимо, оставшиеся символы игнорируются.

* для количества повторений использует все символы входного поля. При распаковке биты преобразуются в строку из 0 и 1.
Форматы h и H упаковывают строку длиной в столько же нибблов (группы по 4 бита, представимые шестнадцатеричными цифрами, "0".."9" "a".."f").

Для каждого такого формата pack генерирует 4 бита результата. При использовании небуквенных символов результат основан на 4 младших битах входного символа, т. е. на ord($char)%16. В частности, символы "0" и "1" генерируют нибблы 0 и 1, как и байты "\000" и "\001". Для символов "a".."f" и "A".."F" результат совместим с обычными шестнадцатеричными цифрами, так что "a" и "A" оба генерируют ниббл 0xA==10. Используйте только эти конкретные шестнадцатеричные символы с этим форматом.

Начиная с начала шаблона до pack, каждая пара символов преобразуется в 1 символ вывода. С форматом h, первый символ пары определяет младший ниббл символа вывода; с форматом H, он определяет старший ниббл.

Если длина входной строки нечетная, она обрабатывается как дополненная нулевым символом в конце. Аналогично, "лишние" нибблы игнорируются при распаковке.

Если входная строка длиннее, чем необходимо, лишние символы игнорируются.

* для количества повторений использует все символы входного поля. Для unpack нибблы преобразуются в строку шестнадцатеричных цифр.
Формат p упаковывает указатель на завершающуюся нулём строку. Вы несете ответственность за обеспечение того, что строка не является временной величиной, так как это может привести к её освобождению до того, как вы успеете использовать упакованный результат. Формат P упаковывает указатель на структуру указанного размера. Нулевой указатель создается, если соответствующее значение для p или P является undef; аналогично с unpack, где нулевой указатель распаковывается в undef.

Если на вашей системе странный размер указателя (то есть указатель ни так велик, как int, ни так велик, как long), возможно, не удастся упаковать или распаковать указатели в порядке байтов big- или little-endian. Попытка сделать это вызовет исключение.
Символ шаблона / позволяет упаковывать и распаковывать последовательность элементов, где упакованная структура содержит упакованное количество элементов, за которым следуют сами упакованные элементы. Это полезно, когда структура, которую вы распаковываете, закодировала размеры или количества повторений некоторых своих полей внутри самой структуры как отдельных полей.

Для pack, вы пишете length-item/sequence-item, и length-item описывает, как упаковывается значение длины. Форматы, которые, вероятно, будут наиболее полезны, - это целочисленные форматы упаковки, такие как n для строк Java, w для ASN.1 или SNMP и N для Sun XDR.

Для pack, sequence-item может иметь количество повторений, в этом случае минимум из него и числа доступных элементов используется как аргумент для length-item. Если он не имеет количества повторений или использует '*', используется количество доступных элементов.

Для unpack используется внутренний стек целых аргументов, распакованных до сих пор. Вы пишете /sequence-item, и количество повторений получается путём извлечения последнего элемента из стека. sequence-item не должен иметь количества повторений.

Если sequence-item относится к типу строки ("A", "a", или "Z"), length-item — это длина строки, а не количество строк. При явном количестве повторений для упаковки упакованная строка корректируется до этой длины. Например:
```
This code:                             gives this result:

unpack("W/a", "\004Gurusamy")          ("Guru")
unpack("a3/A A*", "007 Bond  J ")      (" Bond", "J")
unpack("a3 x2 /A A*", "007: Bond, J.") ("Bond, J", ".")

pack("n/a* w/a","hello,","world")     "\000\006hello,\005world"
pack("a/W2", ord("a") .. ord("z"))    "2ab"
```
length-item не возвращается явно из unpack.

Предоставление счётчика формату length-item полезно только с A, a, или Z. Упаковка с length-item a или Z может привести к появлению символов "\000", которые Perl не считает допустимыми в числовых строках.
Целочисленные типы s, S, l, и L могут быть последовань модификатором ! для указания родных коротких или длинных целых чисел. Как показано в примере выше, чистый l означает ровно 32 бита, хотя родной long, как видит локальный компилятор C, может быть больше. Это в основном проблема на 64-разрядных платформах. Вы можете увидеть, влияет ли использование ! на это так:
```
printf "format s is %d, s! is %d\n",
    length pack("s"), length pack("s!");

printf "format l is %d, l! is %d\n",
    length pack("l"), length pack("l!");
```
i! и I! также разрешены, но только для полноты: они идентичны i и I.

Фактические размеры (в байтах) родных коротких, целых, длинных целых и очень длинных целых чисел на платформе, где был построен Perl, также доступны из командной строки:
```
$ perl -V:{short,int,long{,long}}size
shortsize='2';
intsize='4';
longsize='4';
longlongsize='8';
```
или программно через модуль Config:
```
use Config;
print $Config{shortsize},    "\n";
print $Config{intsize},      "\n";
print $Config{longsize},     "\n";
print $Config{longlongsize}, "\n";
```
$Config{longlongsize} не определено на системах без поддержки очень длинных целых чисел.

Целочисленные форматы s, S, i, I, l, L, j, и J изначально непереносимы между процессорами и операционными системами, потому что они подчиняются порядку байтов и эндианности. Например, целое число 4 байта 0x12345678 (305419896 десятично) будет упорядочено нативно (упорядочено в и обрабатывается регистрами процессора) в байты как
```
0x12 0x34 0x56 0x78  # big-endian
0x78 0x56 0x34 0x12  # little-endian
```
В основном, процессоры Intel и VAX — little-endian, а все остальные, включая Motorola m68k/88k, PPC, Sparc, HP PA, Power и Cray, — big-endian. Alpha и MIPS могут быть любыми: Digital/Compaq использует (ну, использовал) их в режиме little-endian, но SGI/Cray использует их в режиме big-endian.

Названия big-endian и little-endian — это комические ссылки на привычки поедания яиц у малорослых лиллипутианцев и у великорослых блефускудцев из классической сатиры Джонатана Свифта «Путешествия Гулливера». Это вошло в компьютерный жаргон благодаря статье «О священных войнах и призыве к миру» Дэниела Коэна, USC/ISI IEN 137, 1 апреля 1980 года.

Некоторые системы могут иметь даже более странные порядки байтов, такие как
```
0x56 0x78 0x12 0x34
0x34 0x12 0x78 0x56
```
Они называются mid-endian, middle-endian, mixed-endian или просто странными.

Вы можете определить эндианность вашей системы с помощью этого заклинания:
```
printf("%#02x ", $_) for unpack("W*", pack L=>0x12345678);
```
Порядок байтов на платформе, где был построен Perl, также доступен через Config:
```
use Config;
print "$Config{byteorder}\n";
```
или из командной строки:
```
$ perl -V:byteorder
```
Порядки байтов "1234" и "12345678" — little-endian; "4321" и "87654321" — big-endian. Системы с многоархитектурными двоичными файлами будут иметь "ffff", что означает, что статическая информация не работает, необходимо использовать проверку во время выполнения.

Для переносимых упакованных целых чисел используйте форматы n, N, v, и V, или используйте модификаторы > и <, описанные непосредственно ниже. См. также perlport.
Также числа с плавающей запятой имеют эндианность. Обычно (но не всегда) это согласуется с эндианностью целых чисел. Несмотря на то, что большинство платформ в наши дни используют двоичный формат IEEE 754, есть различия, особенно если дело касается long double. Вы можете увидеть переменные Config doublekind и longdblkind (также doublesize, longdblsize) — значения "kind" являются перечислениями, в отличие от byteorder.

С точки зрения переносимости наилучшим вариантом, вероятно, является использование 64-битных двойных чисел IEEE 754 и согласованной эндианности. Другой вариант — формат "%a") printf.
Начиная с Perl 5.10.0, форматы целых чисел и чисел с плавающей запятой, вместе с форматами p и P и группами (), могут быть дополнены модификаторами эндианности > или < для принудительного использования big- или little-endian порядка байтов соответственно. Эти модификаторы особенно полезны, учитывая, как n, N, v, и V не охватывают знаковые целые числа, 64-битные целые числа или значения с плавающей запятой.

Вот некоторые моменты, которые следует учитывать при использовании модификатора эндианности:
- Обмен знаковыми целыми числами между разными платформами работает только в том случае, если все платформы хранят их в одном формате. Большинство платформ хранят знакомые целые числа в дополнительном коде, поэтому обычно это не проблема.
- Модификаторы > или < могут использоваться только с форматами чисел с плавающей запятой на машинах с big- или little-endian. В противном случае попытка их использования вызывает исключение.
- Принудительное использование big- или little-endian порядка байтов для значений с плавающей запятой при обмене данными может работать только в том случае, если все платформы используют одно и то же двоичное представление, например, представление чисел с плавающей запятой IEEE. Даже если все платформы используют IEEE, могут быть небольшие различия. Возможность использования > или < для значений с плавающей запятой может быть полезной, но также опасной, если вы не знаете, что делаете. Это не универсальный способ переносимого хранения значений с плавающей запятой.
- При использовании > или < в группе (), это влияет на все типы внутри группы, которые принимают модификаторы порядка байтов, включая все подгруппы. Для всех других типов это игнорируется без ошибок. Вы не можете переопределить порядок байтов внутри группы, которая уже имеет суффикс модификатора порядка байтов.
Вещественные числа (числа с плавающей запятой и double) имеют формат, который зависит от архитектуры компьютера. Из-за множественности форматов чисел с плавающей запятой и отсутствия стандартного «сетевого» представления для них не было создано средства обмена. Это означает, что упакованные данные с плавающей запятой, записанные на одной машине, могут быть нечитаемы на другой, даже если обе используют арифметику чисел с плавающей запятой IEEE (поскольку эндианность представления памяти не является частью спецификации IEEE). См. также perlport.

Если вы точно знаете, что делаете, вы можете использовать модификаторы > или < для принудительного использования big- или little-endian порядка байтов для значений с плавающей запятой.

Поскольку Perl использует double (или long double, если настроено) во всех числовых вычислениях, преобразование из double в float и обратно в double теряет точность, поэтому unpack("f", pack("f", $foo)) вообще не будет равно $foo.
Pack и unpack могут работать в двух режимах: в режиме символов (C0 режим), где упакованная строка обрабатывается по символам, и в режиме байтов UTF-8 (U0 режим), где упакованная строка обрабатывается в ее кодировке Unicode UTF-8 на основе байтов. Режим символов является по умолчанию, если только строка формата не начинается с U. Вы всегда можете переключиться между режимами внутри формата с явным C0 или U0 в формате. Этот режим остается в силе до следующего изменения режима или до конца группы () (к которой он (непосредственно) относится).

Использование C0 для получения символов Unicode, используя U0 для получения байтов не Unicode, не обязательно очевидно. Вероятно, вам нужен только первый из них:
```
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
  perl -CS -ne 'printf "%v04X\n", $_ for unpack("C0A*", $_)'
03B1.03C9
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
  perl -CS -ne 'printf "%v02X\n", $_ for unpack("U0A*", $_)'
CE.B1.CF.89
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
  perl -C0 -ne 'printf "%v02X\n", $_ for unpack("C0A*", $_)'
CE.B1.CF.89
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
  perl -C0 -ne 'printf "%v02X\n", $_ for unpack("U0A*", $_)'
C3.8E.C2.B1.C3.8F.C2.89
```
Эти примеры также показывают, что вы не должны пытаться использовать pack/unpack как замену модулю Encode.
Вы должны сами выполнять выравнивание или заполнение, вставляя, например, достаточно "x" во время упаковки. pack и unpack не могут знать, куда будут идти или откуда будут приходить символы, поэтому они обрабатывают свой вывод и вход как плоские последовательности символов.
Группа () — это вложенный шаблон, заключенный в скобки. Группа может принимать количество повторений как постфикс, или для unpack, также через символ шаблона /. В каждом повторении группы позиционирование с @ начинается заново с 0. Поэтому результатом
```
pack("@1A((@2A)@3A)", qw[X Y Z])
```
является строка "\0X\0\0YZ".
x и X принимают модификатор ! для выполнения команд выравнивания: они переходят вперед или назад к ближайшей позиции, выровненной по кратному значению count символов. Например, для pack или unpack структуры C, например
```
struct {
    char   c;    /* one signed, 8-bit character */
    double d;
    char   cc[2];
}
```
может потребоваться использовать шаблон c x![d] d c[2]. Предполагается, что значения double должны выравниваться по размеру double.

Для команд выравнивания count 0 эквивалентно count 1; оба являются инструкциями без действия.
n, N, v и V принимают модификатор ! для представления знаковых 16-/32-битных целых чисел в big-/little-endian порядке. Это переносимо только тогда, когда все платформы, обменивающиеся упакованными данными, используют одно и то же двоичное представление для знаковых целых чисел; например, когда все платформы используют дополнительный код.
Комментарии могут быть встроены в TEMPLATE с помощью # до конца строки. Пробелы могут отделять коды pack друг от друга, но модификаторы и повторяющиеся значения должны следовать сразу за ними. Разделение сложных шаблонов на отдельные компоненты по строкам с соответствующими аннотациями может улучшить читаемость и поддерживаемость форматов pack/unpack так же, как /x может улучшить сложные сопоставления шаблонов.
Если TEMPLATE требует больше аргументов, чем pack предоставляет, pack предполагает дополнительные "" аргументы. Если TEMPLATE требует меньше аргументов, чем предоставлено, лишние аргументы игнорируются.
Попытка упаковать специальные значения чисел с плавающей запятой Inf и NaN (бесконечность, также отрицательная, и не число) в упакованные значения целых чисел (например, "L") является фатальной ошибкой. Причина в том, что для этих специальных значений просто нет разумного отображения в целые числа.

Примеры:

$foo = pack("WWWW",65,66,67,68);
# foo eq "ABCD"
$foo = pack("W4",65,66,67,68);
# same thing
$foo = pack("W4",0x24b6,0x24b7,0x24b8,0x24b9);
# same thing with Unicode circled letters.
$foo = pack("U4",0x24b6,0x24b7,0x24b8,0x24b9);
# same thing with Unicode circled letters.  You don't get the
# UTF-8 bytes because the U at the start of the format caused
# a switch to U0-mode, so the UTF-8 bytes get joined into
# characters
$foo = pack("C0U4",0x24b6,0x24b7,0x24b8,0x24b9);
# foo eq "\xe2\x92\xb6\xe2\x92\xb7\xe2\x92\xb8\xe2\x92\xb9"
# This is the UTF-8 encoding of the string in the
# previous example

$foo = pack("ccxxcc",65,66,67,68);
# foo eq "AB\0\0CD"

# NOTE: The examples above featuring "W" and "c" are true
# only on ASCII and ASCII-derived systems such as ISO Latin 1
# and UTF-8.  On EBCDIC systems, the first example would be
#      $foo = pack("WWWW",193,194,195,196);

$foo = pack("s2",1,2);
# "\001\000\002\000" on little-endian
# "\000\001\000\002" on big-endian

$foo = pack("a4","abcd","x","y","z");
# "abcd"

$foo = pack("aaaa","abcd","x","y","z");
# "axyz"

$foo = pack("a14","abcdefg");
# "abcdefg\0\0\0\0\0\0\0"

$foo = pack("i9pl", gmtime);
# a real struct tm (on my system anyway)

$utmp_template = "Z8 Z8 Z16 L";
$utmp = pack($utmp_template, @utmp1);
# a struct utmp (BSDish)

@utmp2 = unpack($utmp_template, $utmp);
# "@utmp1" eq "@utmp2"

sub bintodec {
    unpack("N", pack("B32", substr("0" x 32 . shift, -32)));
}

$foo = pack('sx2l', 12, 34);
# short 12, two zero bytes padding, long 34
$bar = pack('s@4l', 12, 34);
# short 12, zero fill to position 4, long 34
# $foo eq $bar
$baz = pack('s.l', 12, 4, 34);
# short 12, zero fill to position 4, long 34

$foo = pack('nN', 42, 4711);
# pack big-endian 16- and 32-bit unsigned integers
$foo = pack('S>L>', 42, 4711);
# exactly the same
$foo = pack('s<l<', -42, 4711);
# pack little-endian 16- and 32-bit signed integers
$foo = pack('(sl)<', -42, 4711);
# exactly the same

Тот же шаблон, как правило, также может быть использован в unpack.

package NAMESPACE

package NAMESPACE VERSION

package NAMESPACE BLOCK

package NAMESPACE VERSION BLOCK

Объявляет блок или остальную часть единицы компиляции как находящуюся в заданном пространстве имен. Область действия объявления пакета — это предоставленный код БЛОК или, в отсутствие БЛОКа, от самого объявления до конца текущей области видимости (включающего блок, файл или eval). То есть формы без БЛОКа действуют до конца текущей области видимости, подобно операторам my, state и our. Все неуточнённые динамические идентификаторы в этой области видимости будут находиться в заданном пространстве имен, за исключением случаев переопределения другим объявлением package или когда они являются одним из специальных идентификаторов, квалифицирующихся в main::, например STDOUT, ARGV, ENV, и переменные с пунктуацией.

Оператор пакета влияет только на динамические переменные, включая те, на которых вы использовали local, но не переменные со сферой видимости по местоположению, которые создаются с my, state или our. Обычно это первое объявление в файле, включённом с помощью require или use. Вы можете переключиться в пакет более чем в одном месте, так как это только определяет, какую таблицу символов по умолчанию использует компилятор для остальной части блока. Вы можете ссылаться на идентификаторы в других пакетах, кроме текущего, предваряя идентификатор именем пакета и двойным двоеточием, как в $SomePack::var или ThatPack::INPUT_HANDLE. Если имя пакета опущено, предполагается пакет main. То есть, $::sail эквивалентно $main::sail (а также $main'sail, что до сих пор встречается в древнем коде, в основном из Perl 4).

Если VERSION указан, package устанавливает переменную $VERSION в заданном пространстве имен на объект версии с предоставленным VERSION. VERSION должен быть номером версии в формате «строго», как определено модулем version: положительным десятичным числом (целым или дробным) без экспоненты или строкой с точкой и десятичными знаками, начинающейся с символа 'v' и содержащей как минимум три компонента. Вы должны установить $VERSION только один раз для каждого пакета.

См. "Пакеты" в perlmod для получения дополнительной информации о пакетах, модулях и классах. См. perlsub для других вопросов области видимости.

__PACKAGE__

Специальный токен, который возвращает имя пакета, в котором он встречается.

pipe READHANDLE,WRITEHANDLE

Открывает пару соединённых труб, как соответствующая системная вызов. Обратите внимание, что если вы организуете цикл связанных процессов через трубы, может возникнуть тупик, если вы не будете очень осторожны. Кроме того, обратите внимание, что в Perl трубы используют буферизацию ввода-вывода, поэтому вам может потребоваться установить $| для сброса WRITEHANDLE после каждой команды, в зависимости от приложения.

Возвращает true в случае успеха.

См. IPC::Open2, IPC::Open3 и "Взаимодействие с другим процессом" в perlipc для примеров подобных действий.

В системах, поддерживающих флаг close-on-exec для файлов, этот флаг устанавливается для всех вновь открытых дескрипторов файлов, чьи fileno больше, чем текущее значение $^F (по умолчанию 2 для STDERR). См. "$^F" в perlvar.

pop ARRAY

pop

Извлекает и возвращает последнее значение массива, уменьшая массив на один элемент.

Возвращает неопределённое значение, если массив пуст, хотя это также может произойти и в других случаях. Если ARRAY опущен, извлекает из массива @ARGV в основной программе, но из массива @_ в подпрограммах, как и shift.

Начиная с Perl 5.14, экспериментальная функция позволяла pop принимать скалярное выражение. Этот эксперимент признан неудачным и был удалён с версии Perl 5.24.

pos SCALAR

pos

Возвращает смещение, до которого остановился последний поиск m//g в рассматриваемой переменной ($_ используется, когда переменная не указана). Это смещение в символах, если не используется (не рекомендуемый) use bytes псевдоним, в этом случае смещение в байтах. Обратите внимание, что 0 — это допустимое смещение совпадения. undef указывает, что позиция поиска сброшена (обычно из-за неудачи совпадения, но также и потому, что над скаляром ещё не проводился поиск совпадения).

pos напрямую обращается к месту, используемому движком регулярных выражений для хранения смещения, поэтому присвоение pos изменит это смещение и, следовательно, повлияет на \G утверждение нулевой длины в регулярных выражениях. Оба эти эффекта имеют место для следующего совпадения, поэтому вы не можете повлиять на позицию с помощью pos во время текущего совпадения, например, в (?{pos() = 5}) или s//pos() = 5/e.

Установка pos также сбрасывает флаг совпадение нулевой длины, описанный в "Повторные шаблоны сопоставления подстроки нулевой длины" в perlre.

Поскольку неудачное m//gc сопоставление не сбрасывает смещение, возвращаемое значение pos в этом случае не изменится. См. perlre и perlop.

print FILEHANDLE LIST

print FILEHANDLE

print LIST

print

Выводит строку или список строк. Возвращает true, если успешно. FILEHANDLE может быть скалярной переменной, содержащей имя или ссылку на файловый дескриптор, тем самым вводя один уровень косвенности. (ПРИМЕЧАНИЕ: если FILEHANDLE является переменной, и следующим токеном является термин, он может быть неправильно истолкован как оператор, если вы не вставите + или не поместите скобки вокруг аргументов.) Если FILEHANDLE опущен, выводит в последний выбранный (см. select) выходной дескриптор. Если LIST опущен, выводит $_ в текущий выбранный выходной дескриптор. Чтобы использовать только FILEHANDLE для вывода содержимого $_ в него, вы должны использовать имя файлового дескриптора без префикса, как FH, а не косвенное, как $fh. Для установки дескриптора вывода по умолчанию на значение отличное от STDOUT, используйте операцию select.

Текущее значение $, (если есть) выводится между каждым элементом LIST. Текущее значение $\ (если есть) выводится после того, как весь LIST был выведен. Поскольку print принимает LIST, всё в LIST оценивается в контексте списка, включая любые подпрограммы, списки возвращаемых значений которых вы передаёте в print. Будьте осторожны, не следуйте за ключевым словом print левой скобкой, если не хотите, чтобы соответствующая правая скобка завершала аргументы print; поместите скобки вокруг всех аргументов (или вставьте +, но это не выглядит так хорошо).

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

print { $files[$i] } "stuff\n";
print { $OK ? *STDOUT : *STDERR } "stuff\n";

Вывод в закрытую трубу или сокет сгенерирует сигнал SIGPIPE. См. perlipc для получения дополнительной информации об обработке сигналов.

printf FILEHANDLE FORMAT, LIST

printf FILEHANDLE

printf FORMAT, LIST

printf

Эквивалентно print FILEHANDLE sprintf(FORMAT, LIST), за исключением того, что $\ (разделитель записей вывода) не добавляется. FORMAT и LIST фактически анализируются как один список. Первый аргумент списка будет интерпретирован как формат printf. Это означает, что printf(@_) будет использовать $_[0] в качестве формата. См. sprintf для объяснения аргумента формата. Если use locale (включая use locale ':not_characters') в силе и POSIX::setlocale был вызван, символ, используемый в качестве разделителя десятичных знаков в формате чисел с плавающей точкой, зависит от настройки локали LC_NUMERIC. См. perllocale и POSIX.

По историческим причинам, если вы опустите список, $_ используется в качестве формата; чтобы использовать FILEHANDLE без списка, вы должны использовать имя файлового дескриптора без префикса, как FH, а не косвенное, как $fh. Однако, это редко выполнит то, что вам нужно; если $_ содержит коды форматирования, они будут заменены пустой строкой, и будет выведено сообщение об ошибке, если включены предупреждения. Используйте print, если вы хотите вывести содержимое $_.

Не попадайтесь в ловушку использования printf, когда достаточно простого print. print более эффективен и менее подвержен ошибкам.

prototype FUNCTION

prototype

Возвращает прототип функции в виде строки (или undef, если у функции нет прототипа). FUNCTION — ссылка на или имя функции, прототип которой нужно получить. Если FUNCTION опущен, используется $_.

Если FUNCTION является строкой, начинающейся с CORE::, остальная часть интерпретируется как имя встроенной функции Perl. Если аргументы встроенной функции не могут быть адекватно выражены прототипом (например, system), prototype возвращает undef, поскольку встроенная функция не ведет себя как обычная Perl-функция. В противном случае возвращается строка, описывающая соответствующий прототип.

push ARRAY,LIST

Обращается с ARRAY как со стеком, добавляя значения LIST в конец ARRAY. Длина ARRAY увеличивается на длину LIST. Имеет тот же эффект, что и

for my $value (LIST) {
    $ARRAY[++$#ARRAY] = $value;
}

но более эффективна. Возвращает количество элементов в массиве после завершения push.

Начиная с Perl 5.14, экспериментальная функция позволяла push принимать скалярное выражение. Этот эксперимент признан неудачным и был удалён в Perl 5.24.

q/STRING/

qq/STRING/

qw/STRING/

qx/STRING/

Обобщённые кавычки. См. "Quote-Like Operators" в perlop.

qr/STRING/

Оператор кавычек для регулярных выражений. См. "Regexp Quote-Like Operators" в perlop.

quotemeta EXPR

quotemeta

Возвращает значение EXPR, в котором все ASCII-символы, не являющиеся "словными", экранированы обратным слэшем. (То есть все ASCII-символы, не соответствующие /[A-Za-z_0-9]/ будут предваряться обратным слэшем в возвращаемой строке, независимо от настроек локали.) Это внутренняя функция, реализующая экранирование \Q в строках с двойными кавычками. (См. поведение для символов с кодами больше ASCII ниже.)

Если EXPR опущен, используется $_.

quotemeta (и \Q ... \E) полезны при интерполяции строк в регулярные выражения, так как по умолчанию интерполированная переменная рассматривается как мини-регулярное выражение. Например:

my $sentence = 'The quick brown fox jumped over the lazy dog';
my $substring = 'quick.*?fox';
$sentence =~ s{$substring}{big bad wolf};

приведёт к тому, что $sentence станет 'The big bad wolf jumped over...'.

С другой стороны:

my $sentence = 'The quick brown fox jumped over the lazy dog';
my $substring = 'quick.*?fox';
$sentence =~ s{\Q$substring\E}{big bad wolf};

Или:

my $sentence = 'The quick brown fox jumped over the lazy dog';
my $substring = 'quick.*?fox';
my $quoted_substring = quotemeta($substring);
$sentence =~ s{$quoted_substring}{big bad wolf};

оба оставят предложение без изменений. Как правило, при приёме литеральных строковых данных от пользователя необходимо использовать quotemeta или \Q.

В Perl v5.14 все символы с кодами больше ASCII экранируются в строках, не закодированных в UTF-8, но не экранируются в строках UTF-8.

Начиная с Perl v5.16, Perl использует стратегию кодирования, основанную на Unicode, для экранирования символов с кодами больше ASCII; экранирование ASCII-символов не изменилось.

Также не изменилось экранирование строк, не закодированных в UTF-8, вне контекста use feature 'unicode_strings', которое предполагает экранирование всех символов из расширенного набора Latin-1. Это обеспечивает полную обратную совместимость со старыми программами, не использующими Unicode. (Обратите внимание, что unicode_strings автоматически включен в контексте use v5.12 или выше.)

В контексте use locale все символы Latin-1 с кодами больше ASCII экранируются, независимо от того, закодирована ли строка в UTF-8 или нет. Как упоминалось выше, локализация не влияет на экранирование ASCII-символов. Это защищает от ситуаций, когда в некоторых локалях символы, такие как "|" рассматриваются как слова.

В противном случае Perl экранирует символы с кодами больше ASCII с использованием адаптации из Unicode (см. http://www.unicode.org/reports/tr31/). Экранируются только символы, у которых есть какое-либо из свойств Unicode: Pattern_Syntax, Pattern_White_Space, White_Space, Default_Ignorable_Code_Point или General_Category=Control.

Из этих свойств важными являются Pattern_Syntax и Pattern_White_Space. Они были определены Unicode именно для того, чтобы определить, какие символы в шаблоне регулярного выражения должны экранироваться. Ни один символ, который может использоваться в идентификаторе, не обладает этими свойствами.

Perl гарантирует, что если мы когда-либо добавим метасимволы регулярных выражений к уже определённому дюжине (\ | ( ) [ { ^ $ * + ? .), то будем использовать только те, которые обладают свойством Pattern_Syntax. Perl также гарантирует, что если мы когда-либо добавим символы, которые считаются пробелами в регулярных выражениях (в настоящее время в основном затрагиваемые /x), то они все будут обладать свойством Pattern_White_Space.

Unicode гарантирует, что набор символов с этими двумя свойствами никогда не изменится, поэтому то, что не экранируется в версии v5.16, никогда не потребуется экранировать в будущих релизах Perl. (Не все символы, соответствующие Pattern_Syntax, на самом деле были назначены; поэтому есть место для расширения, но они экранируются, независимо от того, назначены ли им символы или нет. Perl, конечно, никогда не будет использовать неназначенный символ в качестве фактического метасимвола.)

Экранирование символов, обладающих другими 3 свойствами, осуществляется для повышения читаемости регулярного выражения, а не потому, что они фактически должны экранироваться для целей регулярных выражений (символы со свойством White_Space, скорее всего, будут неотличимы на странице или экране от символов со свойством Pattern_White_Space; а другие два свойства содержат непечатаемые символы).

rand EXPR

rand

Возвращает случайное дробное число, большее или равное 0 и меньшее значения EXPR. (EXPR должен быть положительным.) Если EXPR опущен, используется значение 1. В настоящее время EXPR со значением 0 также обрабатывается особым образом как 1 (это не было задокументировано до Perl 5.8.0 и может измениться в будущих версиях Perl). Автоматически вызывает srand, если srand ещё не был вызван. См. также srand.

Применяйте int к значению, возвращённому rand, если вам нужны случайные целые числа, а не случайные дробные числа. Например,

int(rand(10))

возвращает случайное целое число между 0 и 9, включительно.

(Примечание: Если функция rand постоянно возвращает числа, которые слишком большие или слишком маленькие, то, вероятно, ваша версия Perl была скомпилирована с неправильным числом RANDBITS.)

rand не является криптографически безопасным. Не следует полагаться на него в критически важных для безопасности ситуациях. На данный момент ряд модулей CPAN от сторонних разработчиков предлагают генераторы случайных чисел, предназначенные их авторами как криптографически безопасные, включая: Data::Entropy, Crypt::Random, Math::Random::Secure и Math::TrulyRandom.

read FILEHANDLE,SCALAR,LENGTH,OFFSET

read FILEHANDLE,SCALAR,LENGTH

Пытается прочитать LENGTH символов данных в переменную SCALAR из указанного FILEHANDLE. Возвращает количество фактически прочитанных символов, 0 в конце файла или undef, если произошла ошибка (в последнем случае $! также устанавливается). SCALAR будет увеличен или уменьшен так, чтобы последний фактически прочитанный символ был последним символом скаляра после чтения.

Можно указать OFFSET для размещения прочитанных данных в некоторой позиции в строке, отличной от начала. Отрицательный OFFSET указывает позицию на это количество символов, считая назад от конца строки. Положительный OFFSET, превышающий длину SCALAR, приводит к дополнению строки до требуемого размера байтами "\0" перед добавлением результата чтения.

Вызов реализован с использованием либо функции Perl, либо вашей системной родной функции fread(3). Чтобы получить истинный вызов системного read(2), используйте sysread.

Обратите внимание на символы: в зависимости от состояния файлового дескриптора считываются байты или символы. По умолчанию все файловые дескрипторы работают с байтами, но, например, если файловый дескриптор был открыт с использованием :utf8 слоя ввода-вывода (см. open и прагму open), ввод-вывод будет работать с закодированными в UTF8 кодами Unicode, а не с байтами. Аналогично для :encoding слоя: в этом случае могут быть прочитаны практически любые символы.

readdir DIRHANDLE

Возвращает следующую запись каталога для каталога, открытого с помощью opendir. Если используется в контексте списка, возвращает все остальные записи в каталоге. Если больше записей нет, возвращает undef в скалярном контексте и пустой список в контексте списка.

Если вы планируете использовать filetest для результатов из readdir, вам лучше префикснуть рассматриваемый каталог. Иначе, так как мы не chdir там, это будет проверка неверного файла.

opendir(my $dh, $some_dir) || die "Can't opendir $some_dir: $!";
my @dots = grep { /^\./ && -f "$some_dir/$_" } readdir($dh);
closedir $dh;

С Perl 5.12 вы можете использовать неявный readdir в цикле while, который установит $_ на каждой итерации. Если используется выражение readdir или явное присваивание выражения readdir скаляру в качестве условия while/for, то условие на самом деле проверяет определённость значения выражения, а не его обычное булево значение.

opendir(my $dh, $some_dir) || die "Can't open $some_dir: $!";
while (readdir $dh) {
    print "$some_dir/$_\n";
}
closedir $dh;

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

use 5.012; # so readdir assigns to $_ in a lone while test

readline EXPR

readline

Читает из файла, имя которого содержится в EXPR (или из *ARGV если EXPR не указан). В скалярном контексте каждый вызов читает и возвращает следующую строку до достижения конца файла, после чего последующий вызов возвращает undef. В списочном контексте читает до конца файла и возвращает список строк. Обратите внимание, что понятие "строки" здесь определяется тем, что вы определили с помощью $/ (или $INPUT_RECORD_SEPARATOR в английском языке). См. "$/" в perlvar.

Когда $/ установлено в undef, когда readline используется в скалярном контексте (т.е., режим "слияния файла"), и когда читается пустой файл, он возвращает '' в первый раз, а затем undef в последующие.

Это внутренняя функция, реализующая оператор <EXPR>, но вы можете использовать её напрямую. Оператор <EXPR> более подробно описан в "Операторы ввода-вывода" в perlop.

my $line = <STDIN>;
my $line = readline(STDIN);    # same thing

Если readline сталкивается с ошибкой операционной системы, $! будет установлено с соответствующим сообщением об ошибке. Это может быть полезно для проверки $!, когда вы читаете из дескрипторов файлов, которым не доверяете, таких как tty или сокет. В следующем примере используется операторная форма readline и выводится ошибка, если результат не определён.

while ( ! eof($fh) ) {
    defined( $_ = readline $fh ) or die "readline failed: $!";
    ...
}

Обратите внимание, что вы не можете обработать ошибки readline таким образом с файловым дескриптором ARGV. В этом случае вам нужно открыть каждый элемент @ARGV самостоятельно, так как eof обрабатывает ARGV по-другому.

foreach my $arg (@ARGV) {
    open(my $fh, $arg) or warn "Can't open $arg: $!";

    while ( ! eof($fh) ) {
        defined( $_ = readline $fh )
            or die "readline failed for $arg: $!";
        ...
    }
}

Подобно оператору <EXPR>, если выражение readline используется в качестве условия цикла while или for, то оно неявно будет присвоено $_. Если используется либо выражение readline, либо явное присвоение выражения readline скаляру в качестве условия while/for, то условие фактически проверяет определённость значения выражения, а не его обычное истинностное значение.

readlink EXPR

readlink

Возвращает значение символической ссылки, если символические ссылки реализованы. Если нет, генерирует исключение. Если возникла системная ошибка, возвращает неопределённое значение и устанавливает $! (errno). Если EXPR опущен, используется $_.

Проблемы переносимости: "readlink" в perlport.

readpipe EXPR

readpipe

EXPR выполняется как системная команда. Собраный стандартный вывод команды возвращается. В скалярном контексте он возвращается как одна (возможно, многострочная) строка. В списочном контексте возвращает список строк (как вы определили строки с помощью $/ (или $INPUT_RECORD_SEPARATOR в английском языке)). Это внутренняя функция, реализующая оператор qx/EXPR/, но вы можете использовать её напрямую. Оператор qx/EXPR/ более подробно описан в "Операторы ввода-вывода" в perlop. Если EXPR опущен, используется $_.

recv SOCKET,SCALAR,LENGTH,FLAGS

Принимает сообщение по сокету. Попытка принять LENGTH символов данных в переменную SCALAR из указанного файлового дескриптора SOCKET. SCALAR будет увеличен или уменьшен до фактической длины чтения. Принимает те же флаги, что и системный вызов с таким же именем. Возвращает адрес отправителя, если протокол SOCKET это поддерживает; в противном случае возвращает пустую строку. При ошибке возвращает неопределённое значение. Этот вызов фактически реализован через системный вызов recvfrom(2). Примеры см. в разделе "UDP: Передача сообщений" в perlipc.

Обратите внимание, что если сокет помечен как :utf8, recv выбросит исключение. Уровень :encoding(...) неявно вводит уровень :utf8. См. binmode.

redo LABEL

redo EXPR

redo

Команда redo перезапускает блок цикла, не вычисляя условие повторно. Блок continue, если он есть, не выполняется. Если LABEL опущен, команда относится к самому внутреннему вложенному циклу. Форма redo EXPR, доступная начиная с Perl 5.18.0, позволяет вычислять имя метки во время выполнения и в остальном идентична redo LABEL. Программы, которые хотят солгать себе о том, что только что было введено, обычно используют эту команду:

# a simpleminded Pascal comment stripper
# (warning: assumes no { or } in strings)
LINE: while (<STDIN>) {
    while (s|({.*}.*){.*}|$1 |) {}
    s|{.*}| |;
    if (s|{.*| |) {
        my $front = $_;
        while (<STDIN>) {
            if (/}/) {  # end of comment?
                s|^|$front\{|;
                redo LINE;
            }
        }
    }
    print;
}

redo не может возвращать значение из блока, который обычно возвращает значение, такого как eval {}, sub {}, или do {}. Она выполнит своё поведение управления потоком, что исключает любое возвращаемое значение. Не следует использовать её для выхода из операции grep или map.

Обратите внимание, что сам блок по смыслу идентичен циклу, который выполняется один раз. Таким образом, redo внутри такого блока эффективно превратит его в циклический конструкт.

См. также continue для иллюстрации того, как работают last, next и redo.

В отличие от большинства именованных операторов, она имеет тот же приоритет, что и присвоение. Она также освобождена от правила "выглядит как функция", поэтому redo ("foo")."bar" приведет к тому, что "bar" станет частью аргумента для redo.

ref EXPR

ref

Изучает значение EXPR, ожидая, что это ссылка, и возвращает строку, предоставляющую информацию о ссылке и типе референта. Если EXPR не указан, используется $_.

Если операнд не ссылка, то возвращается пустая строка. Пустая строка будет возвращена только в этой ситуации. ref часто бывает полезно просто для проверки, является ли значение ссылкой, что можно сделать, сравнивая результат с пустой строкой. Частая ошибка — использование результата ref непосредственно как истинностного значения: это неправильно, потому что 0 (ложь) может быть возвращена для ссылки.

Если операнд — ссылка на освящённый объект, то возвращается имя класса, в который освящён референт. ref не заботится о физическом типе референта; благословение имеет приоритет над такими соображениями. Следите за тем, что точное сравнение результатов ref с именем класса не выполняет проверку принадлежности к классу: члены класса также включают объекты, освящённые в подклассы, для которых ref вернёт имя подкласса. Также будьте осторожны, так как имена классов могут совпадать с именами встроенных типов (описанных ниже).

Если операнд — ссылка на не освящённый объект, то возвращаемое значение указывает тип объекта. Если не освящённый референт не скаляр, то возвращаемое значение будет одной из строк ARRAY, HASH, CODE, FORMAT, или IO, указывающей только на тип объекта. Если не освящённый референт — скаляр, то возвращаемое значение будет одной из строк SCALAR, VSTRING, REF, GLOB, LVALUE, или REGEXP, в зависимости от типа значения, которым сейчас обладает скаляр. Но обратите внимание, что qr// скаляры создаются уже освящёнными, поэтому ref qr/.../, вероятно, вернёт Regexp. Будьте осторожны, так как эти имена встроенных типов также могут использоваться как имена классов, поэтому ref возвращающее одно из этих имён не однозначно указывает, что референт является такого типа.

Неясность между именами встроенных типов и именами классов существенно ограничивает полезность ref. Для получения чёткой информации используйте Scalar::Util::blessed() для информации об освящении и Scalar::Util::reftype() для информации о физических типах. Используйте метод isa для проверки принадлежности к классу, хотя необходимо убедиться в благословении перед попыткой вызова метода.

См. также perlref и perlobj.

rename OLDNAME,NEWNAME

Изменяет имя файла; существующий файл NEWNAME будет перезаписан. Возвращает true при успехе, false в противном случае.

Поведение этой функции сильно варьируется в зависимости от реализации вашей системы. Например, она обычно не будет работать через границы файловой системы, даже если команда системы mv иногда компенсирует это. Другие ограничения включают, работает ли она с каталогами, открытыми файлами или существующими файлами. Проверьте perlport и либо страницу справки rename(2), либо соответствующую системную документацию для получения подробностей.

Для платформенно-независимой функции move обратитесь к модулю File::Copy.

Проблемы переносимости: "rename" в perlport.

require VERSION

require EXPR

require

Требует версии Perl, указанной в VERSION, или требует определённой семантики, заданной EXPR, или $_, если EXPR не указан.

VERSION может быть либо литералом, таким как v5.24.1, который будет сравниваться с $^V (или $PERL_VERSION на английском), либо числовым аргументом вида 5.024001, который будет сравниваться с $]. Если VERSION больше, чем версия текущего интерпретатора Perl, возникает исключение. Сравните с use, который может выполнить подобную проверку на этапе компиляции.

Использование VERSION в виде числового аргумента, такого как 5.024001, следует избегать, так как это устаревший и менее читаемый синтаксис по сравнению с v5.24.1. До Perl 5.8.0 (выпущен в 2002 году) более объёмный числовой формат был единственным поддерживаемым синтаксисом, поэтому вы можете встретить его в более старом коде.

require v5.24.1;    # run time version check
require 5.24.1;     # ditto
require 5.024_001;  # ditto; older syntax compatible
                      with perl 5.6

В противном случае, require требует включения файла библиотеки, если он ещё не включён. Файл включается с помощью механизма do-FILE, который по сути является разновидностью eval с оговоркой, что лексические переменные в вызывающем скрипте будут невидимы для включённого кода. Если бы это было реализовано на чистом Perl, оно имело бы семантику, аналогичную следующей:

use Carp 'croak';
use version;

sub require {
    my ($filename) = @_;
    if ( my $version = eval { version->parse($filename) } ) {
        if ( $version > $^V ) {
           my $vn = $version->normal;
           croak "Perl $vn required--this is only $^V, stopped";
        }
        return 1;
    }

    if (exists $INC{$filename}) {
        return 1 if $INC{$filename};
        croak "Compilation failed in require";
    }

    foreach $prefix (@INC) {
        if (ref($prefix)) {
            #... do other stuff - see text below ....
        }
        # (see text below about possible appending of .pmc
        # suffix to $filename)
        my $realfilename = "$prefix/$filename";
        next if ! -e $realfilename || -d _ || -b _;
        $INC{$filename} = $realfilename;
        my $result = do($realfilename);
                     # but run in caller's namespace

        if (!defined $result) {
            $INC{$filename} = undef;
            croak $@ ? "$@Compilation failed in require"
                     : "Can't locate $filename: $!\n";
        }
        if (!$result) {
            delete $INC{$filename};
            croak "$filename did not return true value";
        }
        $! = 0;
        return $result;
    }
    croak "Can't locate $filename in \@INC ...";
}

Обратите внимание, что файл не будет включён дважды под тем же заданным именем.

Файл должен вернуть true в качестве последней инструкции, чтобы указать успешное выполнение любого кода инициализации, поэтому обычно такой файл завершается 1; , если вы не уверены, что он вернёт true иначе. Но лучше просто указать 1;, на случай, если вы добавите дополнительные инструкции.

Если EXPR является идентификатором, require предполагает расширение .pm и заменяет :: на / в имени файла, чтобы облегчить загрузку стандартных модулей. Этот способ загрузки модулей не рискует изменить ваше пространство имён, однако он автоматически создаст хранилище (stash) для требуемого модуля.

Другими словами, если вы попробуете это:

require Foo::Bar;     # a splendid bareword

Функция require фактически будет искать файл Foo/Bar.pm в каталогах, указанных в массиве @INC, и она автоматически создаст хранилище Foo::Bar:: для модуля во время компиляции.

Но если вы попробуете это:

    my $class = 'Foo::Bar';
    require $class;       # $class is not a bareword
#or
    require "Foo::Bar";   # not a bareword because of the ""

Функция require будет искать файл Foo::Bar в массиве @INC и сообщит об отсутствии файла Foo::Bar там. В этом случае вы можете сделать так:

eval "require $class";

или вы можете сделать так

require "Foo/Bar.pm";

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

Теперь, когда вы понимаете, как require ищет файлы с аргументом-идентификатором, имеется дополнительная функциональность, работающая за кулисами. Перед тем как require будет искать расширение .pm, она сначала будет искать аналогичное имя файла с расширением .pmc. Если такой файл найден, он будет загружен вместо любого файла с расширением .pm. Это относится как к явной require "Foo/Bar.pm"; форме, так и к require Foo::Bar; форме.

Вы также можете вставить в систему импорта собственный код Perl, поместив его напрямую в массив @INC. Существует три формы хуков: ссылки на подпрограммы, ссылки на массивы и освящённые объекты.

Ссылки на подпрограммы являются самым простым случаем. Когда система включения проходит через @INC и сталкивается с подпрограммой, эта подпрограмма вызывается с двумя параметрами: первым параметром является ссылка на себя, а вторым — имя включаемого файла (например, Foo/Bar.pm). Подпрограмма должна вернуть либо ничего, либо список из не более чем четырёх значений в следующем порядке:

Ссылка на скаляр, содержащий исходный код, который нужно добавить перед файлом или выходными данными генератора.
Дескриптор файла, из которого будет читаться файл.
Ссылка на подпрограмму. Если нет дескриптора файла (предыдущий пункт), тогда эта подпрограмма ожидает генерировать одну строку исходного кода на вызов, записывая строку в $_ и возвращая 1, а затем в конце файла возвращая 0. Если есть дескриптор файла, то подпрограмма будет вызвана, чтобы действовать как простой фильтр исходного кода, считывая строку из $_. Опять же, возвращать 1 для каждой допустимой строки и 0 после возврата всех строк. По историческим причинам подпрограмма получит бессмысленный аргумент (на самом деле всегда числовое значение ноль) в виде $_[0].
Необязательное состояние для подпрограммы. Состояние передаётся как $_[1].

Если возвращён пустой список, undef, или ничего, что соответствует первым 3 значениям выше, то require обращается к остальным элементам @INC. Обратите внимание, что этот дескриптор файла должен быть реальным дескриптором файла (строго говоря, типглоб или ссылка на типглоб, освящённый или нет); привязанные дескрипторы файлов будут игнорироваться, и обработка остановится на этом.

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

Другими словами, вы можете написать:

push @INC, \&my_sub;
sub my_sub {
    my ($coderef, $filename) = @_;  # $coderef is \&my_sub
    ...
}

или:

push @INC, [ \&my_sub, $x, $y, ... ];
sub my_sub {
    my ($arrayref, $filename) = @_;
    # Retrieve $x, $y, ...
    my (undef, @parameters) = @$arrayref;
    ...
}

Если хук является объектом, он должен предоставить метод INC, который будет вызываться как описано выше, первым параметром будучи сам объект. (Обратите внимание, что вы должны полностью квалифицировать имя подпрограммы, так как неквалифицированный INC всегда принудительно помещается в пакет main.) Вот типичная структура кода:

# In Foo.pm
package Foo;
sub new { ... }
sub Foo::INC {
    my ($self, $filename) = @_;
    ...
}

# In the main program
push @INC, Foo->new(...);

Эти хуки также разрешено устанавливать запись %INC соответствующую загруженным файлам. См. "%INC" в perlvar.

Для ещё более мощной системы импорта см. use и perlmod.

reset EXPR

reset

Обычно используется в блоке continue в конце цикла для очистки переменных и сброса m?pattern? поисков, чтобы они снова работали. Выражение интерпретируется как список одиночных символов (разрешены тире для диапазонов). Все переменные (скаляры, массивы и хэши) в текущем пакете, начинающиеся с одной из этих букв, сбрасываются до исходного состояния. Если выражение опущено, поиски с одним соответствием (m?pattern?) сбрасываются, чтобы соответствовать снова. Сбрасываются только переменные или поиски в текущем пакете. Всегда возвращает 1. Примеры:

reset 'X';      # reset all X variables
reset 'a-z';    # reset lower case variables
reset;          # just reset m?one-time? searches

Сброс "A-Z" не рекомендуется, потому что вы очистите массивы @ARGV и @INC и хэш %ENV.

Сбрасываются только переменные пакета; лексические переменные не затрагиваются, но они всё равно очищаются при выходе из области видимости, поэтому, вероятно, вы захотите использовать их вместо этого. См. my.

return EXPR

return

Возвращает значение из подпрограммы, eval, do FILE, блока sort или блока eval с регулярными выражениями (но не блока grep или map) со значением, заданным в EXPR. Вычисление EXPR может быть в списковом, скалярном или пустом контексте, в зависимости от того, как будет использовано возвращаемое значение, и контекст может меняться от одного выполнения к другому (см. wantarray). Если EXPR не указан, возвращается пустой список в списковом контексте, неопределённое значение в скалярном контексте и (конечно) ничего в пустом контексте.

(При отсутствии явного return, подпрограмма, eval или do FILE автоматически возвращает значение последнего вычисленного выражения.)

В отличие от большинства именованных операторов, это также освобождено от правила, похожего на функцию, поэтому return ("foo")."bar" заставит "bar" стать частью аргумента для return.

reverse LIST

В списковом контексте возвращает список элементов LIST в обратном порядке. В скалярном контексте конкатенирует элементы LIST и возвращает строковое значение со всеми символами в обратном порядке.

print join(", ", reverse "world", "Hello"); # Hello, world

print scalar reverse "dlrow ,", "olleH";    # Hello, world

Используемый без аргументов в скалярном контексте, reverse переворачивает $_.

$_ = "dlrow ,olleH";
print reverse;                         # No output, list context
print scalar reverse;                  # Hello, world

Обратите внимание, что обращение массива к самому себе (как в @a = reverse @a) сохранит несуществующие элементы, когда это возможно; т.е. для не-магических массивов или для массивов с привязкой с методами EXISTS и DELETE.

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

my %by_name = reverse %by_address;  # Invert the hash

rewinddir DIRHANDLE

Устанавливает текущую позицию в начало каталога для процедуры readdir в DIRHANDLE.

Вопросы совместимости: "rewinddir" в perlport.

rindex STR,SUBSTR,POSITION

rindex STR,SUBSTR

Работает так же, как index, за исключением того, что возвращает позицию последнего вхождения SUBSTR в STR. Если POSITION указан, возвращает последнее вхождение, начиная с позиции или ранее её.

rmdir FILENAME

rmdir

Удаляет директорию, указанную FILENAME, если она пуста. В случае успеха возвращает true; иначе возвращает false и устанавливает $! (errno). Если FILENAME опущено, используется $_.

Для рекурсивного удаления древовидной структуры директорий (rm -rf в Unix) обратитесь к функции rmtree модуля File::Path.

s///

Оператор подстановки. Смотрите "Regexp Quote-Like Operators" в perlop.

say FILEHANDLE LIST

say FILEHANDLE

say LIST

say

Точно так же, как print, но неявно добавляет символ новой строки. say LIST — это просто сокращение для { local $\ = "\n"; print LIST }. Чтобы использовать FILEHANDLE без LIST для вывода содержимого $_ в него, вы должны использовать имя файла без посредников, например FH, а не косвенное, как $fh.

say доступно только если включен "say" feature или если он указан с префиксом CORE::. "say" feature автоматически включается с декларацией use v5.10 (или выше) в текущей области видимости.

scalar EXPR

Принуждает EXPR к интерпретации в скалярном контексте и возвращает значение EXPR.

my @counts = ( scalar @a, scalar @b, scalar @c );

Нет эквивалентного оператора для принуждения выражения к интерпретации в списочном контексте, поскольку на практике это никогда не требуется. Если вам действительно нужно это сделать, вы можете использовать конструкцию @{[ (some expression) ]}, но обычно достаточно простого (some expression).

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

Следующая единственная строка:

print uc(scalar(foo(), $bar)), $baz;

является моральным эквивалентом этих двух:

foo();
print(uc($bar), $baz);

См. perlop для получения дополнительной информации об унарных операторах и операторе запятой, и perldata для получения информации об оценке хэша в скалярном контексте.

seek FILEHANDLE,POSITION,WHENCE

Устанавливает позицию FILEHANDLE, как и вызов fseek(3) из C stdio. FILEHANDLE может быть выражением, значение которого даёт имя файлового дескриптора. Значения для WHENCE 0 установить новую позицию в байтах в POSITION; 1 установить её в текущую позицию плюс POSITION; и 2 установить её в EOF плюс POSITION, обычно отрицательное значение. Для WHENCE вы можете использовать константы SEEK_SET, SEEK_CUR, и SEEK_END (начало файла, текущая позиция, конец файла) из модуля Fcntl. Возвращает 1 при успехе, false в противном случае.

Обратите внимание на акцент на байтах: даже если файловый дескриптор был настроен для работы с символами (например, с помощью :encoding(UTF-8) уровня ввода-вывода), функции seek, tell и sysseek используют байтовые смещения, а не смещения символов, так как перемещение к смещению символа было бы очень медленным в файле UTF-8.

Если вы хотите установить позицию файла для sysread или syswrite, не используйте seek, так как буферизация делает её влияние на позицию чтения/записи файла непредсказуемым и не переносимым. Используйте sysseek вместо этого.

Из-за правил и строгих требований ANSI C на некоторых системах вам необходимо выполнять перемещение при переключении между чтением и записью. Среди прочего, это может привести к вызову clearerr(3) stdio.

WHENCE значение 1 (SEEK_CUR) полезно, чтобы не перемещать позицию файла:

seek($fh, 0, 1);

Это также полезно для приложений, эмулирующих tail -f. После достижения EOF при чтении и ожидании некоторого времени вам (вероятно) нужно вставить фиктивное seek, чтобы сбросить вещи. seek не изменяет позицию, но очищает состояние конца файла в обработчике, так что следующий readline FILE заставляет Perl попытаться прочитать что-то снова. (Надеюсь.)

Если это не работает (некоторые реализации ввода-вывода особенно капризны), вам может потребоваться что-то вроде этого:

for (;;) {
    for ($curpos = tell($fh); $_ = readline($fh);
         $curpos = tell($fh)) {
        # search for some stuff and put it into files
    }
    sleep($for_a_while);
    seek($fh, $curpos, 0);
}

seekdir DIRHANDLE,POS

Устанавливает текущую позицию для процедуры readdir в DIRHANDLE. POS должно быть значением, возвращённым функцией telldir. seekdir также имеет те же замечания о возможной уплотнении каталога, что и соответствующая системная библиотечная функция.

select FILEHANDLE

select

Возвращает текущий выбранный файловый дескриптор. Если FILEHANDLE задан, устанавливает новый текущий стандартный файловый дескриптор для вывода. Это имеет два эффекта: во-первых, write или print без файлового дескриптора по умолчанию используют этот FILEHANDLE. Во-вторых, ссылки на переменные, связанные с выводом, будут ссылаться на этот канал вывода.

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

select(REPORT1);
$^ = 'report1_top';
select(REPORT2);
$^ = 'report2_top';

FILEHANDLE может быть выражением, значение которого даёт имя фактического файлового дескриптора. Таким образом:

my $oldfh = select(STDERR); $| = 1; select($oldfh);

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

STDERR->autoflush(1);

(Перед Perl версии 5.14 вы должны use IO::Handle; явно это сделать.)

Проблемы с переносимостью: "select" в perlport.

select RBITS,WBITS,EBITS,TIMEOUT

Это вызывает системный вызов select(2) с указанными битовыми масками, которые можно создать с помощью fileno и vec, примерно так:

my $rin = my $win = my $ein = '';
vec($rin, fileno(STDIN),  1) = 1;
vec($win, fileno(STDOUT), 1) = 1;
$ein = $rin | $win;

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

sub fhbits {
    my @fhlist = @_;
    my $bits = "";
    for my $fh (@fhlist) {
        vec($bits, fileno($fh), 1) = 1;
    }
    return $bits;
}
my $rin = fhbits(\*STDIN, $tty, $mysock);

Обычный стиль:

my ($nfound, $timeleft) =
  select(my $rout = $rin, my $wout = $win, my $eout = $ein,
                                                         $timeout);

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

my $nfound =
  select(my $rout = $rin, my $wout = $win, my $eout = $ein, undef);

Большинство систем не утруждают себя возвратом чего-то полезного в $timeleft, поэтому вызов select в скалярном контексте просто возвращает $nfound.

Любая из битовых масок также может быть undef. Время ожидания, если указано, задаётся в секундах, которые могут быть дробными. Примечание: не все реализации способны вернуть $timeleft. Если нет, они всегда возвращают $timeleft, равное указанному $timeout.

Вы можете вызвать задержку на 250 миллисекунд так:

select(undef, undef, undef, 0.25);

Обратите внимание, что select перезапускается после сигналов (скажем, SIGALRM) зависит от реализации. Смотрите также perlport для замечаний о переносимости select.

При ошибке select ведёт себя так же, как select(2): она возвращает -1 и устанавливает $!.

На некоторых Unixes, select(2) может сообщать о сокете как «готовом для чтения» даже если данные недоступны, и поэтому последующий read заблокируется. Этого можно избежать, если всегда использовать O_NONBLOCK для сокета. См. select(2) и fcntl(2) для получения дополнительной информации.

Стандартный модуль IO::Select предоставляет более удобный интерфейс к select, в основном, потому что он выполняет всю работу с битовыми масками за вас.

ПРЕДУПРЕЖДЕНИЕ: Не следует пытаться смешивать буферизованный ввод-вывод (например, read или readline) с select, за исключением случаев, разрешённых POSIX, и даже тогда только на системах POSIX. Вместо этого используйте sysread.

Проблемы с переносимостью: "select" в perlport.

semctl ID,SEMNUM,CMD,ARG

Вызывает системную функцию IPC System V semctl(2). Вероятно, вам придётся сказать

use IPC::SysV;

сначала, чтобы получить правильные определения констант. Если CMD — IPC_STAT или GETALL, то ARG должен быть переменной, которая будет содержать возвращаемую структуру semid_ds или массив значений семафоров. Возвращает как ioctl: неопределённое значение для ошибки, "0 but true" для нуля или фактическое возвращаемое значение в противном случае. ARG должен состоять из вектора нативных целых чисел со знаком, которые могут быть созданы с помощью pack("s!",(0)x$nsem). См. также "SysV IPC" в perlipc и документацию для IPC::SysV и IPC::Semaphore.

Проблемы с переносимостью: "semctl" в perlport.

semget KEY,NSEMS,FLAGS

Вызывает системную функцию System V IPC semget(2). Возвращает идентификатор семафора или неопределенное значение при ошибке. См. также "SysV IPC" в perlipc и документацию для IPC::SysV и IPC::Semaphore.

Проблемы совместимости: "semget" в perlport.

semop KEY,OPSTRING

Вызывает системную функцию System V IPC semop(2) для операций с семафорами, таких как сигнализация и ожидание. OPSTRING должен быть упакованным массивом структур semop. Каждая структура semop может быть сгенерирована с помощью pack("s!3", $semnum, $semop, $semflag). Длина OPSTRING подразумевает количество операций с семафором. Возвращает true при успехе, false при ошибке. Например, следующий код ожидает на семафоре $semnum с идентификатором семафора $semid:

my $semop = pack("s!3", $semnum, -1, 0);
die "Semaphore trouble: $!\n" unless semop($semid, $semop);

Для сигнализации семафора замените -1 на 1. См. также "SysV IPC" в perlipc и документацию для IPC::SysV и IPC::Semaphore.

Проблемы совместимости: "semop" в perlport.

send SOCKET,MSG,FLAGS,TO

send SOCKET,MSG,FLAGS

Отправляет сообщение по сокету. Попытка отправить скаляр MSG по файловому дескриптору SOCKET. Принимает те же флаги, что и системный вызов с таким же именем. Для неподключенных сокетов необходимо указать пункт назначения, в этом случае выполняется вызов sendto(2). Возвращает количество отправленных символов или неопределенное значение при ошибке. Системный вызов sendmsg(2) в настоящее время не реализован. См. "UDP: Передача сообщений" в perlipc для примеров.

Обратите внимание, что если сокет был помечен как :utf8, send выбросит исключение. Уровень :encoding(...) неявно вводит уровень :utf8. См. binmode.

setpgrp PID,PGRP

Устанавливает текущую группу процессов для указанного PID, 0 для текущего процесса. Вызывает исключение при использовании на машине, которая не реализует POSIX setpgid(2) или BSD setpgrp(2). Если аргументы опущены, используется значение по умолчанию 0,0. Обратите внимание, что BSD 4.2 версия setpgrp не принимает аргументы, поэтому только setpgrp(0,0) является портативным. См. также POSIX::setsid().

Проблемы совместимости: "setpgrp" в perlport.

setpriority WHICH,WHO,PRIORITY

Устанавливает текущий приоритет для процесса, группы процессов или пользователя. (См. setpriority(2).) Вызывает исключение при использовании на машине, которая не реализует setpriority(2).

WHICH может быть любым из PRIO_PROCESS, PRIO_PGRP или PRIO_USER импортированных из "RESOURCE CONSTANTS" в POSIX.

Проблемы совместимости: "setpriority" в perlport.

setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL

Устанавливает запрашиваемый параметр сокета. Возвращает undef при ошибке. Используйте целочисленные константы, предоставляемые модулем Socket для LEVEL и OPNAME. Значения для LEVEL также могут быть получены из getprotobyname. OPTVAL может быть либо упакованной строкой, либо целым числом. Целочисленный OPTVAL — это сокращение для pack("i", OPTVAL).

Пример отключения алгоритма Nagle для сокета:

use Socket qw(IPPROTO_TCP TCP_NODELAY);
setsockopt($socket, IPPROTO_TCP, TCP_NODELAY, 1);

Проблемы совместимости: "setsockopt" в perlport.

shift ARRAY

shift

Сдвигает первое значение массива и возвращает его, укорачивая массив на 1 и перемещая все элементы вниз. Если в массиве нет элементов, возвращает неопределенное значение. Если ARRAY опущен, сдвигает массив @_ в лексическом пространстве подпрограмм и форматов, а массив @ARGV вне подпрограммы и также в лексических пространствах, созданных конструкциями eval STRING, BEGIN {}, INIT {}, CHECK {}, UNITCHECK {}, и END {}.

Начиная с Perl 5.14, экспериментальная функция позволяла shift принимать скалярное выражение. Этот эксперимент признан неудачным и был удалён в Perl 5.24.

См. также unshift, push и pop. shift и unshift делают то же самое с левым концом массива, что pop и push делают с правым концом.

shmctl ID,CMD,ARG

Вызывает системную функцию System V IPC shmctl. Вероятно, вам нужно будет сказать

use IPC::SysV;

сначала, чтобы получить правильные определения констант. Если CMD — IPC_STAT, то ARG должен быть переменной, которая будет содержать возвращаемую shmid_ds структуру. Возвращает, как ioctl: undef для ошибки; "0 но true" для нуля; и фактическое возвращаемое значение в противном случае. См. также "SysV IPC" в perlipc и документацию для IPC::SysV.

Проблемы совместимости: "shmctl" в perlport.

shmget KEY,SIZE,FLAGS

Вызывает системную функцию System V IPC shmget. Возвращает идентификатор сегмента общей памяти или undef при ошибке. См. также "SysV IPC" в perlipc и документацию для IPC::SysV.

Проблемы совместимости: "shmget" в perlport.

shmread ID,VAR,POS,SIZE

shmwrite ID,STRING,POS,SIZE

Читает или записывает сегмент общей памяти System V с идентификатором ID, начиная с позиции POS и размером SIZE, подключаясь к нему, копируя в/из него и отключаясь от него. При чтении VAR должна быть переменной, которая будет хранить считанные данные. При записи, если STRING слишком длинный, используется только SIZE байтов; если STRING слишком короткий, записываются нули для заполнения SIZE байтов. Возвращает true при успехе, false при ошибке. shmread загрязняет переменную. См. также "SysV IPC" в perlipc и документацию для IPC::SysV и модуля IPC::Shareable из CPAN.

Проблемы совместимости: "shmread" в perlport и "shmwrite" в perlport.

shutdown SOCKET,HOW

Завершает соединение сокета указанным способом HOW, который интерпретируется так же, как и в системном вызове с таким же именем.

shutdown($socket, 0);    # I/we have stopped reading data
shutdown($socket, 1);    # I/we have stopped writing data
shutdown($socket, 2);    # I/we have stopped using this socket

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

Возвращает 1 при успехе; при ошибке возвращает undef, если первый аргумент не является допустимым файловым дескриптором, или возвращает 0 и устанавливает $! при любой другой ошибке.

sin EXPR

sin

Возвращает синус EXPR (выраженный в радианах). Если EXPR опущен, возвращает синус $_.

Для обратной операции синуса можно использовать функцию Math::Trig::asin, или использовать следующее соотношение:

sub asin { atan2($_[0], sqrt(1 - $_[0] * $_[0])) }

sleep EXPR

sleep

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

Может быть прерван, если процесс получает сигнал, такой как SIGALRM.

eval {
    local $SIG{ALRM} = sub { die "Alarm!\n" };
    sleep;
};
die $@ unless $@ eq "Alarm!\n";

Вероятно, вы не можете смешивать вызовы alarm и sleep, так как sleep часто реализуется с использованием alarm.

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

Для задержек с более высокой точностью, чем одна секунда, модуль Time::HiRes (из CPAN и начиная с Perl 5.8, входит в стандартное распределение) предоставляет usleep. Вы также можете использовать четырёх-аргументный вариант Perl select, оставляя первые три аргумента неопределенными, или вы можете использовать интерфейс syscall для доступа к setitimer(2), если ваша система её поддерживает. Подробности смотрите в perlfaq8.

См. также функцию POSIX модуля pause.

socket SOCKET,DOMAIN,TYPE,PROTOCOL

Открывает сокет указанного типа и привязывает его к дескриптору файла SOCKET. DOMAIN, TYPE и PROTOCOL задаются так же, как и для системного вызова с таким же именем. Сначала необходимо use Socket, чтобы получить соответствующие определения. См. примеры в "Sockets: Client/Server Communication" в perlipc.

На системах, поддерживающих флаг close-on-exec для файлов, флаг будет установлен для вновь открытого дескриптора файла, как определено значением $^F. См. "$^F" в perlvar.

socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL

Создаёт неупомянутую пару сокетов в указанном домене, определённого типа. DOMAIN, TYPE и PROTOCOL задаются так же, как и для системного вызова с таким же именем. Если не реализовано, поднимает исключение. Возвращает true в случае успеха.

На системах, поддерживающих флаг close-on-exec для файлов, флаг будет установлен для вновь открытых дескрипторов файлов, как определено значением $^F. См. "$^F" в perlvar.

Некоторые системы определяют pipe в терминах socketpair, в котором вызов pipe($rdr, $wtr) по существу:

use Socket;
socketpair(my $rdr, my $wtr, AF_UNIX, SOCK_STREAM, PF_UNSPEC);
shutdown($rdr, 1);        # no more writing for reader
shutdown($wtr, 0);        # no more reading for writer

См. perlipc для примера использования socketpair. Perl 5.8 и более поздние версии будут эмулировать socketpair с использованием IP-сокетов к localhost, если ваша система реализует сокеты, но не socketpair.

Проблемы с переносимостью: "socketpair" в perlport.

sort SUBNAME LIST

sort BLOCK LIST

sort LIST

В контексте списка это сортирует LIST и возвращает отсортированный список. В скалярном контексте поведение sort не определено.

Если SUBNAME или BLOCK опушены, sort сортирует элементы в стандартном порядке сравнения строк. Если SUBNAME указан, он задаёт имя подпрограммы, которая возвращает целое число меньше, равно или больше 0, в зависимости от того, как должны быть упорядочены элементы списка. (Операторы <=> и cmp очень полезны в таких процедурах.) SUBNAME может быть именем скалярной переменной (без индексации), в этом случае значение предоставляет имя (или ссылку на) фактическую подпрограмму для использования. Вместо SUBNAME можно указать BLOCK как анонимную, встроенную подпрограмму сортировки.

Если прототип подпрограммы ($$), элементы для сравнения передаются по ссылке в @_, как и для обычной подпрограммы. Это медленнее, чем нетипизированные подпрограммы, где элементы для сравнения передаются в подпрограмму как пакетные глобальные переменные $a и $b (см. пример ниже).

Если подпрограмма является XSUB, элементы для сравнения помещаются в стек, как обычно передаются аргументы в XSUB. $a и $b не устанавливаются.

Элементы для сравнения всегда передаются по ссылке и не должны изменяться.

Вы также не можете выйти из блока сортировки или подпрограммы, используя какие-либо операторы управления циклом, описанные в perlsyn, или с помощью goto.

Когда use locale (но не use locale ':not_characters') активен, sort LIST сортирует LIST в соответствии с текущей локалью сортировки. См. perllocale.

sort возвращает псевдонимы в исходный список, так же, как и индексная переменная цикла for. То есть, изменение элемента списка, возвращённого sort (например, в foreach, map или grep) фактически изменяет элемент в исходном списке. Это обычно следует избегать при написании ясного кода.

Исторически Perl по-разному определял, является ли сортировка стабильной по умолчанию. Если стабильность важна, её можно явно контролировать, используя прагму sort.

Примеры:

# sort lexically
my @articles = sort @files;

# same thing, but with explicit sort routine
my @articles = sort {$a cmp $b} @files;

# now case-insensitively
my @articles = sort {fc($a) cmp fc($b)} @files;

# same thing in reversed order
my @articles = sort {$b cmp $a} @files;

# sort numerically ascending
my @articles = sort {$a <=> $b} @files;

# sort numerically descending
my @articles = sort {$b <=> $a} @files;

# this sorts the %age hash by value instead of key
# using an in-line function
my @eldest = sort { $age{$b} <=> $age{$a} } keys %age;

# sort using explicit subroutine name
sub byage {
    $age{$a} <=> $age{$b};  # presuming numeric
}
my @sortedclass = sort byage @class;

sub backwards { $b cmp $a }
my @harry  = qw(dog cat x Cain Abel);
my @george = qw(gone chased yz Punished Axed);
print sort @harry;
    # prints AbelCaincatdogx
print sort backwards @harry;
    # prints xdogcatCainAbel
print sort @george, 'to', @harry;
    # prints AbelAxedCainPunishedcatchaseddoggonetoxyz

# inefficiently sort by descending numeric compare using
# the first integer after the first = sign, or the
# whole record case-insensitively otherwise

my @new = sort {
    ($b =~ /=(\d+)/)[0] <=> ($a =~ /=(\d+)/)[0]
                        ||
                fc($a)  cmp  fc($b)
} @old;

# same thing, but much more efficiently;
# we'll build auxiliary indices instead
# for speed
my (@nums, @caps);
for (@old) {
    push @nums, ( /=(\d+)/ ? $1 : undef );
    push @caps, fc($_);
}

my @new = @old[ sort {
                       $nums[$b] <=> $nums[$a]
                                ||
                       $caps[$a] cmp $caps[$b]
                     } 0..$#old
              ];

# same thing, but without any temps
my @new = map { $_->[0] }
       sort { $b->[1] <=> $a->[1]
                       ||
              $a->[2] cmp $b->[2]
       } map { [$_, /=(\d+)/, fc($_)] } @old;

# using a prototype allows you to use any comparison subroutine
# as a sort subroutine (including other package's subroutines)
package Other;
sub backwards ($$) { $_[1] cmp $_[0]; }  # $a and $b are
                                         # not set here
package main;
my @new = sort Other::backwards @old;

# guarantee stability
use sort 'stable';
my @new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;

Предупреждение: требуется внимание к синтаксису при сортировке списка, возвращённого функцией. Если вы хотите отсортировать список, возвращённый вызовом функции find_records(@key), вы можете использовать:

my @contact = sort { $a cmp $b } find_records @key;
my @contact = sort +find_records(@key);
my @contact = sort &find_records(@key);
my @contact = sort(find_records(@key));

Если вместо этого вы хотите отсортировать массив @key с помощью функции сравнения find_records(), вы можете использовать:

my @contact = sort { find_records() } @key;
my @contact = sort find_records(@key);
my @contact = sort(find_records @key);
my @contact = sort(find_records (@key));

$a и $b устанавливаются как глобальные переменные пакета в пакете, из которого вызывается sort(). Это означает $main::a и $main::b (или $::a и $::b) в пакете main, $FooPack::a и $FooPack::b в пакете FooPack и т. д. Если блок сортировки находится в области действия объявления my или state для $a и/или $b, вы обязательно должны указать полное имя переменных в блоке сортировки:

package main;
my $a = "C"; # DANGER, Will Robinson, DANGER !!!

print sort { $a cmp $b }               qw(A C E G B D F H);
                                       # WRONG
sub badlexi { $a cmp $b }
print sort badlexi                     qw(A C E G B D F H);
                                       # WRONG
# the above prints BACFEDGH or some other incorrect ordering

print sort { $::a cmp $::b }           qw(A C E G B D F H);
                                       # OK
print sort { our $a cmp our $b }       qw(A C E G B D F H);
                                       # also OK
print sort { our ($a, $b); $a cmp $b } qw(A C E G B D F H);
                                       # also OK
sub lexi { our $a cmp our $b }
print sort lexi                        qw(A C E G B D F H);
                                       # also OK
# the above print ABCDEFGH

При надлежащем внимании вы можете смешивать пакетные и my (или state) $a и/или $b:

my $a = {
   tiny   => -2,
   small  => -1,
   normal => 0,
   big    => 1,
   huge   => 2
};

say sort { $a->{our $a} <=> $a->{our $b} }
    qw{ huge normal tiny small big};

# prints tinysmallnormalbighuge

$a и $b неявным образом локальны для выполнения sort() и восстанавливают свои предыдущие значения по завершении сортировки.

Подпрограммы сортировки, написанные с использованием $a и $b, привязаны к своему вызывающему пакету. Возможно, но малоинтересно, определить их в другом пакете, так как подпрограмма всё равно должна ссылаться на $a и $b вызывающего пакета:

package Foo;
sub lexi { $Bar::a cmp $Bar::b }
package Bar;
... sort Foo::lexi ...

Используйте типизированные версии (см. выше) для более универсальной альтернативы.

Функция сравнения должна корректно работать. Если она возвращает несогласованные результаты (иногда говорит, что $x[1] меньше $x[2], а иногда наоборот, например), результаты не определены.

Поскольку <=> возвращает undef, когда один из операндов NaN (не число), будьте осторожны при сортировке с функцией сравнения, такой как $a <=> $b, любых списков, которые могут содержать NaN. Следующий пример использует это, чтобы исключить все NaN из входного списка.

my @result = sort { $a <=> $b } grep { $_ == $_ } @input;

splice ARRAY,OFFSET,LENGTH,LIST

splice ARRAY,OFFSET,LENGTH

splice ARRAY,OFFSET

splice ARRAY

Удаляет элементы, обозначенные OFFSET и LENGTH из массива, и заменяет их элементами LIST, если таковые имеются. В контексте списка возвращает удалённые элементы массива. В скалярном контексте возвращает последний удалённый элемент или undef, если элементы не удалены. Массив увеличивается или уменьшается по мере необходимости. Если OFFSET отрицателен, он начинается на этом расстоянии от конца массива. Если LENGTH опущен, удаляет все элементы с OFFSET и далее. Если LENGTH отрицателен, удаляет элементы с OFFSET и далее, за исключением -LENGTH элементов в конце массива. Если оба OFFSET и LENGTH опущены, удаляет все элементы. Если OFFSET выходит за пределы массива, а LENGTH был указан, Perl выводит предупреждение и выполняет splice в конце массива.

Следующие эквивалентности имеют место (при условии $#a >= $i )

push(@a,$x,$y)      splice(@a,@a,0,$x,$y)
pop(@a)             splice(@a,-1)
shift(@a)           splice(@a,0,1)
unshift(@a,$x,$y)   splice(@a,0,0,$x,$y)
$a[$i] = $y         splice(@a,$i,1,$y)

splice может быть использован, например, для реализации обработки очереди n-арного типа:

sub nary_print {
  my $n = shift;
  while (my @next_n = splice @_, 0, $n) {
    say join q{ -- }, @next_n;
  }
}

nary_print(3, qw(a b c d e f g h));
# prints:
#   a -- b -- c
#   d -- e -- f
#   g -- h

Начиная с Perl 5.14, экспериментальная возможность позволяла splice принимать скалярное выражение. Этот эксперимент признан неудачным и был удалён в Perl 5.24.

split /PATTERN/,EXPR,LIMIT

split /PATTERN/,EXPR

split /PATTERN/

split

Разделяет строку EXPR на список строк и возвращает список в контексте списка или размер списка в скалярном контексте. (До Perl 5.11 она также перезаписывала @_ списком в пустом и скалярном контексте. Если вы используете старые версии Perl, будьте осторожны.)

Если указан только PATTERN, EXPR по умолчанию равен $_.

Любой фрагмент в EXPR, который соответствует PATTERN, рассматривается как разделитель, разделяющий EXPR на подстроки (называемые «полями»), которые не включают разделитель. Обратите внимание, что разделитель может быть длиннее одного символа или даже не содержать символов вообще (пустая строка, которая является соответствием нулевой ширины).

PATTERN не обязательно должен быть константой; можно использовать выражение для задания шаблона, который меняется во время выполнения.

Если PATTERN соответствует пустой строке, EXPR разделяется в позиции совпадения (между символами). Например:

print join(':', split(/b/, 'abc')), "\n";

использует b в 'abc' в качестве разделителя для получения результата a:c. Однако это:

print join(':', split(//, 'abc')), "\n";

использует совпадения пустой строки в качестве разделителей для получения результата a:b:c; таким образом, пустая строка может использоваться для разделения EXPR на список его составных символов.

В качестве специального случая для split пустой шаблон, указанный в синтаксисе оператора сопоставления (//) конкретно соответствует пустой строке, что противоречит его обычному толкованию как последнего успешного совпадения.

Если PATTERN равно /^/, то он обрабатывается так, как будто используется модификатор многострочности (/^/m), поскольку в противном случае он мало пригоден.

/m и любые другие модификаторы шаблонов, допустимые для qr (подробности в "qr/STRING/msixpodualn" в perlop) могут быть указаны явно.

В качестве еще одного специального случая, split эмулирует стандартное поведение утилиты командной строки awk, когда PATTERN опущен или представляет собой строку, состоящую из одного пробела (например, ' ' или "\x20", но не, например, / /). В этом случае любые начальные пробелы в EXPR удаляются перед выполнением разделения, и PATTERN вместо этого обрабатывается так, как будто он был /\s+/; в частности, это означает, что любые смежные пробелы (а не только один символ пробела) используются в качестве разделителя. Однако можно избежать этого специального поведения, указав шаблон / / вместо строки " ", тем самым позволяя только одному символу пробела быть разделителем. В более ранних версиях Perl этот специальный случай был ограничен использованием простого " " в качестве аргумента шаблона для split; в Perl 5.18.0 и более поздних версиях этот специальный случай активируется любым выражением, которое оценивается как простая строка " ".

Начиная с Perl 5.28, это специальное поведение разделения по пробелам работает как ожидается в контексте "use feature 'unicode_strings". В предыдущих версиях и вне этого контекста это проявляет "Unicode-ошибку" в perlunicode: символы, являющиеся пробелами согласно правилам Unicode, но не согласно правилам ASCII, могут обрабатываться как часть полей, а не как разделители полей, в зависимости от кодировки строки.

Если PATTERN опущен, он по умолчанию равен одному пробелу, " ", что активирует описанную ранее эмуляцию awk.

Если LIMIT указан и положителен, он представляет максимальное количество полей, на которые может быть разделен EXPR; другими словами, LIMIT на единицу больше максимального числа разбиений EXPR. Таким образом, значение LIMIT 1 означает, что EXPR может быть разделен максимум ноль раз, получив максимум одно поле (а именно, всё значение EXPR). Например:

print join(':', split(//, 'abc', 1)), "\n";

производит вывод abc, и это:

print join(':', split(//, 'abc', 2)), "\n";

производит вывод a:bc, и каждое из этих:

print join(':', split(//, 'abc', 3)), "\n";
print join(':', split(//, 'abc', 4)), "\n";

производит вывод a:b:c.

Если LIMIT отрицателен, он обрабатывается так, как будто он был произвольно большим; генерируется как можно больше полей.

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

print join(':', split(/,/, 'a,b,c,,,')), "\n";

производит вывод a:b:c, но следующее:

print join(':', split(/,/, 'a,b,c,,,', -1)), "\n";

производит вывод a:b:c:::.

В приложениях с критическим временем полезно избегать разделения на большее количество полей, чем необходимо. Таким образом, при присваивании списку, если LIMIT опущен (или равен нулю), то LIMIT обрабатывается как на единицу больше, чем количество переменных в списке; для следующего LIMIT неявно равен 3:

my ($login, $passwd) = split(/:/);

Обратите внимание, что разделение EXPR, который оценивается как пустая строка, всегда производит ноль полей независимо от указанного LIMIT.

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

print join(':', split(/ /, ' abc')), "\n";

производит вывод :abc. Однако совпадение нулевой ширины в начале EXPR никогда не создает пустого поля, поэтому:

print join(':', split(//, ' abc'));

производит вывод :a:b:c (а не : :a:b:c).

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

print join(':', split(//, ' abc', -1)), "\n";

производит вывод :a:b:c:.

Если PATTERN содержит группы захвата, то для каждого разделителя создается дополнительное поле для каждой подстроки, захваченной группой (в порядке указания групп, как и в обратных ссылках); если какая-либо группа не соответствует, то она захватывает значение undef вместо подстроки. Также обратите внимание, что любое такое дополнительное поле генерируется всякий раз, когда имеется разделитель (то есть, когда происходит разделение), и такое дополнительное поле не учитывается при подсчете LIMIT. Рассмотрим следующие выражения, вычисленные в контексте списка (каждый возвращенный список указан в соответствующем комментарии):

split(/-|,/, "1-10,20", 3)
# ('1', '10', '20')

split(/(-|,)/, "1-10,20", 3)
# ('1', '-', '10', ',', '20')

split(/-|(,)/, "1-10,20", 3)
# ('1', undef, '10', ',', '20')

split(/(-)|,/, "1-10,20", 3)
# ('1', '-', '10', undef, '20')

split(/(-)|(,)/, "1-10,20", 3)
# ('1', '-', undef, '10', undef, ',', '20')

sprintf FORMAT, LIST

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

Например:

# Format number with up to 8 leading zeroes
my $result = sprintf("%08d", $number);

# Round number to 3 digits after decimal point
my $rounded = sprintf("%.3f", $number);

Perl использует собственную систему форматирования sprintf: она эмулирует функцию C sprintf(3), но не использует её, кроме обработки чисел с плавающей точкой, и даже в этом случае допускаются только стандартные модификаторы. Нестандартные расширения из вашей локальной sprintf(3) поэтому недоступны в Perl.

В отличие от printf, sprintf не делает того, что вы, вероятно, ожидаете, если передать массив в качестве первого аргумента. Массив интерпретируется в скалярном контексте, и вместо использования нулевого элемента массива в качестве формата, Perl использует количество элементов в массиве, что практически никогда не бывает полезным.

Perl's sprintf поддерживает следующие общеизвестные преобразования:

%%    a percent sign
%c    a character with the given number
%s    a string
%d    a signed integer, in decimal
%u    an unsigned integer, in decimal
%o    an unsigned integer, in octal
%x    an unsigned integer, in hexadecimal
%e    a floating-point number, in scientific notation
%f    a floating-point number, in fixed decimal notation
%g    a floating-point number, in %e or %f notation

Кроме того, Perl поддерживает следующие широко поддерживаемые преобразования:

%X    like %x, but using upper-case letters
%E    like %e, but using an upper-case "E"
%G    like %g, but with an upper-case "E" (if applicable)
%b    an unsigned integer, in binary
%B    like %b, but using an upper-case "B" with the # flag
%p    a pointer (outputs the Perl value's address in hexadecimal)
%n    special: *stores* the number of characters output so far
      into the next argument in the parameter list
%a    hexadecimal floating point
%A    like %a, but using upper-case letters

Наконец, для обратной совместимости (и мы имеем в виду "обратную") Perl поддерживает эти ненужные, но широко поддерживаемые преобразования:

%i    a synonym for %d
%D    a synonym for %ld
%U    a synonym for %lu
%O    a synonym for %lo
%F    a synonym for %f

Обратите внимание, что количество цифр экспоненты в научной записи, генерируемой %e, %E, %g и %G для чисел с модулем экспоненты меньше 100, зависит от системы: это может быть три или меньше (с нулевым дополнением, если необходимо). Другими словами, 1,23 умножить на десять в девяносто девятой степени может быть представлено как "1.23e99" или "1.23e099". Точно так же для %a и %A экспонента или шестнадцатеричные цифры могут смещаться: особенно опция конфигурации Perl "long doubles" может привести к неожиданным результатам.

Между % и символом формата вы можете указать несколько дополнительных атрибутов, контролирующих интерпретацию формата. В порядке следования:

индекс параметра формата

Явный индекс параметра формата, например, 2$. По умолчанию sprintf форматирует следующий неиспользуемый аргумент в списке, но это позволяет вам изменять порядок аргументов:

printf '%2$d %1$d', 12, 34;      # prints "34 12"
printf '%3$d %d %1$d', 1, 2, 3;  # prints "3 1 1"

флаги

один или несколько из:

space   prefix non-negative number with a space
+       prefix non-negative number with a plus sign
-       left-justify within the field
0       use zeros, not spaces, to right-justify
#       ensure the leading "0" for any octal,
        prefix non-zero hexadecimal with "0x" or "0X",
        prefix non-zero binary with "0b" or "0B"

Например:

printf '<% d>',  12;   # prints "< 12>"
printf '<% d>',   0;   # prints "< 0>"
printf '<% d>', -12;   # prints "<-12>"
printf '<%+d>',  12;   # prints "<+12>"
printf '<%+d>',   0;   # prints "<+0>"
printf '<%+d>', -12;   # prints "<-12>"
printf '<%6s>',  12;   # prints "<    12>"
printf '<%-6s>', 12;   # prints "<12    >"
printf '<%06s>', 12;   # prints "<000012>"
printf '<%#o>',  12;   # prints "<014>"
printf '<%#x>',  12;   # prints "<0xc>"
printf '<%#X>',  12;   # prints "<0XC>"
printf '<%#b>',  12;   # prints "<0b1100>"
printf '<%#B>',  12;   # prints "<0B1100>"

Когда пробел и знак плюс задаются в качестве флагов одновременно, пробел игнорируется.

printf '<%+ d>', 12;   # prints "<+12>"
printf '<% +d>', 12;   # prints "<+12>"

Когда флаг # и точность заданы в преобразовании %o, точность увеличивается, если это необходимо для ведущего "0".

printf '<%#.5o>', 012;      # prints "<00012>"
printf '<%#.5o>', 012345;   # prints "<012345>"
printf '<%#.0o>', 0;        # prints "<0>"

флаг вектора

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

printf "%vd", "AB\x{100}";           # prints "65.66.256"
printf "version is v%vd\n", $^V;     # Perl's version

Поместите звездочку * перед v чтобы переопределить строку для разделения чисел:

printf "address is %*vX\n", ":", $addr;   # IPv6 address
printf "bits are %0*v8b\n", " ", $bits;   # random bitstring

Вы также можете явно указать номер аргумента, используемого для строки соединения, например, *2$v; например:

printf '%*4$vX %*4$vX %*4$vX',       # 3 IPv6 addresses
        @addr[1..3], ":";

(минимальная) ширина

Аргументы обычно форматируются только с необходимой шириной для отображения значения. Вы можете переопределить ширину, указав число, или получить ширину из следующего аргумента (с *) или из указанного аргумента (например, с *2$):

printf "<%s>", "a";       # prints "<a>"
printf "<%6s>", "a";      # prints "<     a>"
printf "<%*s>", 6, "a";   # prints "<     a>"
printf '<%*2$s>', "a", 6; # prints "<     a>"
printf "<%2s>", "long";   # prints "<long>" (does not truncate)

Если ширина поля, полученная через *, отрицательная, она имеет тот же эффект, что и флаг -: выравнивание влево.

точность или максимальная ширина

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

# these examples are subject to system-specific variation
printf '<%f>', 1;    # prints "<1.000000>"
printf '<%.1f>', 1;  # prints "<1.0>"
printf '<%.0f>', 1;  # prints "<1>"
printf '<%e>', 10;   # prints "<1.000000e+01>"
printf '<%.1e>', 10; # prints "<1.0e+01>"

Для "g" и "G" это определяет максимальное количество значащих цифр для отображения; например:

# These examples are subject to system-specific variation.
printf '<%g>', 1;        # prints "<1>"
printf '<%.10g>', 1;     # prints "<1>"
printf '<%g>', 100;      # prints "<100>"
printf '<%.1g>', 100;    # prints "<1e+02>"
printf '<%.2g>', 100.01; # prints "<1e+02>"
printf '<%.5g>', 100.01; # prints "<100.01>"
printf '<%.4g>', 100.01; # prints "<100>"
printf '<%.1g>', 0.0111; # prints "<0.01>"
printf '<%.2g>', 0.0111; # prints "<0.011>"
printf '<%.3g>', 0.0111; # prints "<0.0111>"

Для целочисленных преобразований, указание точности подразумевает, что вывод числа будет дополнен нулями до этой ширины, при этом флаг 0 игнорируется:

printf '<%.6d>', 1;      # prints "<000001>"
printf '<%+.6d>', 1;     # prints "<+000001>"
printf '<%-10.6d>', 1;   # prints "<000001    >"
printf '<%10.6d>', 1;    # prints "<    000001>"
printf '<%010.6d>', 1;   # prints "<    000001>"
printf '<%+10.6d>', 1;   # prints "<   +000001>"

printf '<%.6x>', 1;      # prints "<000001>"
printf '<%#.6x>', 1;     # prints "<0x000001>"
printf '<%-10.6x>', 1;   # prints "<000001    >"
printf '<%10.6x>', 1;    # prints "<    000001>"
printf '<%010.6x>', 1;   # prints "<    000001>"
printf '<%#10.6x>', 1;   # prints "<  0x000001>"

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

printf '<%.5s>', "truncated";   # prints "<trunc>"
printf '<%10.5s>', "truncated"; # prints "<     trunc>"

Вы также можете получить точность из следующего аргумента, используя .*, или из указанного аргумента (например, с .*2$):

printf '<%.6x>', 1;       # prints "<000001>"
printf '<%.*x>', 6, 1;    # prints "<000001>"

printf '<%.*2$x>', 1, 6;  # prints "<000001>"

printf '<%6.*2$x>', 1, 4; # prints "<  0001>"

Если точность, полученная через *, отрицательная, она считается отсутствием точности.

printf '<%.*s>',  7, "string";   # prints "<string>"
printf '<%.*s>',  3, "string";   # prints "<str>"
printf '<%.*s>',  0, "string";   # prints "<>"
printf '<%.*s>', -1, "string";   # prints "<string>"

printf '<%.*d>',  1, 0;   # prints "<0>"
printf '<%.*d>',  0, 0;   # prints "<>"
printf '<%.*d>', -1, 0;   # prints "<0>"

размер

Для числовых преобразований вы можете указать размер, интерпретируя число с помощью l, h, V, q, L, или ll. Для целочисленных преобразований (d u o x X b i D U O), числа обычно предполагаются размером по умолчанию для целых чисел на вашей платформе (обычно 32 или 64 бита), но вы можете переопределить это, используя один из стандартных типов C, поддерживаемых компилятором, используемым для построения Perl:

hh          interpret integer as C type "char" or "unsigned
            char" on Perl 5.14 or later
h           interpret integer as C type "short" or
            "unsigned short"
j           interpret integer as C type "intmax_t" on Perl
            5.14 or later; and prior to Perl 5.30, only with
            a C99 compiler (unportable)
l           interpret integer as C type "long" or
            "unsigned long"
q, L, or ll interpret integer as C type "long long",
            "unsigned long long", or "quad" (typically
            64-bit integers)
t           interpret integer as C type "ptrdiff_t" on Perl
            5.14 or later
z           interpret integer as C type "size_t" on Perl 5.14
            or later

Начиная с версии 5.14, ни один из этих вариантов не вызывает исключение, если он не поддерживается на вашей платформе. Однако, если включены предупреждения, выдаётся предупреждение класса предупреждений printf для недопустимого флага преобразования. Если вы предпочитаете исключение, сделайте так:

use warnings FATAL => "printf";

Если вы хотите узнать о зависимости от версии перед запуском программы, поместите что-то подобное в её начало:

use 5.014;  # for hh/j/t/z/ printf modifiers

Вы можете узнать, поддерживает ли ваш Perl квадриплеты через Config:

use Config;
if ($Config{use64bitint} eq "define"
    || $Config{longsize} >= 8) {
    print "Nice quads!\n";
}

Для преобразований чисел с плавающей точкой (e f g E F G), числа обычно предполагаются размером по умолчанию для чисел с плавающей точкой на вашей платформе (double или long double), но вы можете принудительно использовать "long double" с q, L, или ll если ваша платформа их поддерживает. Вы можете узнать, поддерживает ли ваш Perl long doubles через Config:

use Config;
print "long doubles\n" if $Config{d_longdbl} eq "define";

Вы можете узнать, считает ли Perl "long double" значением по умолчанию для чисел с плавающей точкой на вашей платформе, через Config:

use Config;
if ($Config{uselongdouble} eq "define") {
    print "long doubles by default\n";
}

Также может быть, что long doubles и doubles — одно и то же:

use Config;
($Config{doublesize} == $Config{longdblsize}) &&
        print "doubles are long doubles\n";

Спецификатор размера V не влияет на код Perl, но поддерживается для совместимости с кодом XS. Он означает "использовать стандартный размер для целого или числа с плавающей точкой Perl", что является значением по умолчанию.

порядок аргументов

Обычно sprintf использует следующий неиспользуемый аргумент как значение для форматирования для каждого спецификатора формата. Если спецификатор формата использует * для требования дополнительных аргументов, они потребляются из списка аргументов в порядке их появления в спецификаторе формата до значения для форматирования. В случае, когда аргумент указан явным индексом, это не влияет на нормальный порядок аргументов, даже когда явно указанный индекс соответствовал бы следующему аргументу.

Например:

printf "<%*.*s>", $a, $b, $c;

использует $a для ширины, $b для точности и $c в качестве значения для форматирования; в то время как:

printf '<%*1$.*s>', $a, $b;

использует $a для ширины и точности, а $b как значение для форматирования.

Вот ещё несколько примеров; обратите внимание, что при использовании явного индекса $ может потребоваться экранирование:

printf "%2\$d %d\n",      12, 34;     # will print "34 12\n"
printf "%2\$d %d %d\n",   12, 34;     # will print "34 12 34\n"
printf "%3\$d %d %d\n",   12, 34, 56; # will print "56 12 34\n"
printf "%2\$*3\$d %d\n",  12, 34,  3; # will print " 34 12\n"
printf "%*1\$.*f\n",       4,  5, 10; # will print "5.0000\n"

Если use locale (включая use locale ':not_characters') и POSIX::setlocale были вызваны, символ, используемый в качестве разделителя десятичных знаков в отформатированных числах с плавающей точкой, зависит от локалей LC_NUMERIC. Смотрите perllocale и POSIX.

sqrt EXPR

sqrt

Возвращает положительный квадратный корень из EXPR. Если EXPR опущен, используется $_. Работает только с неотрицательными операндами, если не загружен модуль Math::Complex.

use Math::Complex;
print sqrt(-4);    # prints 2i

srand EXPR

srand

Устанавливает и возвращает начальное значение генератора случайных чисел для оператора rand.

Цель этой функции — «засеять» функцию rand, чтобы rand каждый раз при выполнении программы генерировала разные последовательности. При вызове с параметром srand использует этот параметр в качестве начального значения; в противном случае она (полу)случайным образом выбирает начальное значение. В любом случае, начиная с Perl 5.14, она возвращает начальное значение.

Чтобы указать, что ваш код будет работать только с последними версиями Perl:

use 5.014;  # so srand returns the seed

Если srand не вызывается явно, она вызывается неявно без параметра при первом использовании оператора rand. Однако есть несколько ситуаций, когда программы, вероятно, захотят вызвать srand. Одна из них — для генерации предсказуемых результатов, как правило, для тестирования или отладки. В этом случае вы используете srand($seed), с тем же $seed каждый раз. Другой случай — вы можете вызвать srand после fork, чтобы избежать того, что дочерние процессы используют то же значение начального значения, что и родительский процесс (и, следовательно, друг друга).

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

Большинство реализаций srand принимают целое число и молча отбрасывают десятичные числа. Это означает, что srand(42) обычно даст те же результаты, что и srand(42.1). Для безопасности всегда передавайте srand целое число.

Типичное применение возвращаемого начального значения — для тестовой программы, у которой слишком много комбинаций, чтобы её полностью протестировать за доступное время каждого запуска. Она может тестировать случайную подвыборку каждый раз и, если произойдёт ошибка, записывать используемое начальное значение для этого запуска, чтобы в дальнейшем воспроизвести те же результаты.

rand не является криптографически безопасным. Не следует полагаться на него в критически важных для безопасности ситуациях. На момент написания этой документации ряд сторонних модулей CPAN предлагают генераторы случайных чисел, предназначенные авторами для криптографической безопасности, включая: Data::Entropy, Crypt::Random, Math::Random::Secure и Math::TrulyRandom.

stat FILEHANDLE

stat EXPR

stat DIRHANDLE

stat

Возвращает список из 13 элементов, содержащих информацию о статусе файла, либо файла, открытого через FILEHANDLE или DIRHANDLE, либо именованного с помощью EXPR. Если EXPR опущен, то выполняется stat для $_ (а не _!). Возвращает пустой список, если stat завершается неудачно. Обычно используется следующим образом:

my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
    $atime,$mtime,$ctime,$blksize,$blocks)
       = stat($filename);

Не все поля поддерживаются на всех типах файловых систем. Вот значения полей:

 0 dev      device number of filesystem
 1 ino      inode number
 2 mode     file mode  (type and permissions)
 3 nlink    number of (hard) links to the file
 4 uid      numeric user ID of file's owner
 5 gid      numeric group ID of file's owner
 6 rdev     the device identifier (special files only)
 7 size     total size of file, in bytes
 8 atime    last access time in seconds since the epoch
 9 mtime    last modify time in seconds since the epoch
10 ctime    inode change time in seconds since the epoch (*)
11 blksize  preferred I/O size in bytes for interacting with the
            file (may vary from file to file)
12 blocks   actual number of system-specific blocks allocated
            on disk (often, but not always, 512 bytes each)

(Эпоха была 00:00 1 января 1970 г. по Гринвичу.)

(*) Не все поля поддерживаются на всех типах файловых систем. В частности, поле ctime не переносимо. В частности, вы не можете ожидать, что это будет «время создания»; см. "Файлы и файловые системы" в perlport для получения подробной информации.

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

if (-x $file && (($d) = stat(_)) && $d < 0) {
    print "$file is executable NFS file\n";
}

(Это работает только на машинах, для которых номер устройства отрицателен в NFS.)

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

Поскольку режим содержит как тип файла, так и его разрешения, вы должны замаскировать часть типа файла и использовать "%o" в (s)printf, если хотите увидеть реальные разрешения.

my $mode = (stat($filename))[2];
printf "Permissions are %04o\n", $mode & 07777;

В скалярном контексте stat возвращает булево значение, указывающее на успешность или неудачу, и, если успешно, устанавливает информацию, связанную со специальным дескриптором файла _.

Модуль File::stat предоставляет удобный механизм доступа по имени:

use File::stat;
my $sb = stat($filename);
printf "File is %s, size is %s, perm %04o, mtime %s\n",
       $filename, $sb->size, $sb->mode & 07777,
       scalar localtime $sb->mtime;

Можно импортировать символические константы режима (S_IF*) и функции (S_IS*) из модуля Fcntl:

use Fcntl ':mode';

my $mode = (stat($filename))[2];

my $user_rwx      = ($mode & S_IRWXU) >> 6;
my $group_read    = ($mode & S_IRGRP) >> 3;
my $other_execute =  $mode & S_IXOTH;

printf "Permissions are %04o\n", S_IMODE($mode), "\n";

my $is_setuid     =  $mode & S_ISUID;
my $is_directory  =  S_ISDIR($mode);

Последние два можно было бы записать с помощью операторов -u и -d. Обычно доступные константы S_IF*:

# Permissions: read, write, execute, for user, group, others.

S_IRWXU S_IRUSR S_IWUSR S_IXUSR
S_IRWXG S_IRGRP S_IWGRP S_IXGRP
S_IRWXO S_IROTH S_IWOTH S_IXOTH

# Setuid/Setgid/Stickiness/SaveText.
# Note that the exact meaning of these is system-dependent.

S_ISUID S_ISGID S_ISVTX S_ISTXT

# File types.  Not all are necessarily available on
# your system.

S_IFREG S_IFDIR S_IFLNK S_IFBLK S_IFCHR
S_IFIFO S_IFSOCK S_IFWHT S_ENFMT

# The following are compatibility aliases for S_IRUSR,
# S_IWUSR, and S_IXUSR.

S_IREAD S_IWRITE S_IEXEC

и функции S_IF*

S_IMODE($mode)    the part of $mode containing the permission
                  bits and the setuid/setgid/sticky bits

S_IFMT($mode)     the part of $mode containing the file type
                  which can be bit-anded with (for example)
                  S_IFREG or with the following functions

# The operators -f, -d, -l, -b, -c, -p, and -S.

S_ISREG($mode) S_ISDIR($mode) S_ISLNK($mode)
S_ISBLK($mode) S_ISCHR($mode) S_ISFIFO($mode) S_ISSOCK($mode)

# No direct -X operator counterpart, but for the first one
# the -g operator is often equivalent.  The ENFMT stands for
# record flocking enforcement, a platform-dependent feature.

S_ISENFMT($mode) S_ISWHT($mode)

См. документацию по chmod(2) и stat(2) для получения более подробной информации о константах S_*. Чтобы получить информацию о статусе символической ссылки, а не целевого файла за ссылкой, используйте функцию lstat.

Проблемы переносимости: "stat" в perlport.

state VARLIST

state TYPE VARLIST

state VARLIST : ATTRS

state TYPE VARLIST : ATTRS

state объявляет лексическую переменную, как и my. Однако эти переменные никогда не будут повторно инициализированы, в отличие от лексических переменных, которые инициализируются каждый раз при входе в их окружающий блок. См. "Постоянные частные переменные" в perlsub для получения подробной информации.

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

state доступна только если "state" функция включена или если она имеет префикс CORE::. "state" функция автоматически включается с объявлением use v5.10 (или выше) в текущем области видимости.

study SCALAR

study

На данный момент study ничего не делает. Это может измениться в будущем.

До версии Perl 5.16 она создавала инвертированный индекс всех символов, которые встречались в заданном SCALAR (или $_, если не указано иное). При сопоставлении шаблона наиболее редкий символ из шаблона искался в этом индексе. Редкость основывалась на некоторых статических таблицах частот, созданных на основе некоторых C-программ и английских текстов.

sub NAME BLOCK

sub NAME (PROTO) BLOCK

sub NAME : ATTRS BLOCK

sub NAME (PROTO) : ATTRS BLOCK

Это определение подпрограммы, а не собственно функция. Без BLOCK это просто объявление вперёд. Без NAME это объявление анонимной функции, поэтому возвращает значение: CODE-ссылку только что созданного замыкания.

См. perlsub и perlref для получения подробной информации о подпрограммах и ссылках; см. attributes и Attribute::Handlers для получения более подробной информации об атрибутах.

__SUB__

Специальный токен, который возвращает ссылку на текущую подпрограмму или undef вне подпрограммы.

Поведение __SUB__ внутри блока кода регулярного выражения (например, /(?{...})/) может меняться.

Этот токен доступен только в use v5.16 или "current_sub" функции. См. feature.

substr EXPR,OFFSET,LENGTH,REPLACEMENT

substr EXPR,OFFSET,LENGTH

substr EXPR,OFFSET

Извлекает подстроку из EXPR и возвращает её. Первый символ имеет смещение ноль. Если OFFSET отрицательный, поиск начинается за указанным количеством символов от конца строки. Если LENGTH опущено, возвращается вся строка до конца. Если LENGTH отрицательный, отбрасывается указанное количество символов от конца строки.

my $s = "The black cat climbed the green tree";
my $color  = substr $s, 4, 5;      # black
my $middle = substr $s, 4, -11;    # black cat climbed the
my $end    = substr $s, 14;        # climbed the green tree
my $tail   = substr $s, -4;        # tree
my $z      = substr $s, -4, 2;     # tr

Можно использовать функцию substr в качестве lvalue, в этом случае EXPR также должно быть lvalue. Если присваивается значение короче LENGTH, строка уменьшится, а если длиннее — строка увеличится, чтобы вместить его. Для сохранения длины строки может потребоваться дополнение или обрезка значения с помощью sprintf.

Если OFFSET и LENGTH задают подстроку, частично выходящую за пределы строки, возвращается только часть, находящаяся внутри строки. Если подстрока выходит за пределы обоих концов строки, substr возвращает значение undefined и выводит предупреждение. При использовании в качестве lvalue, указание подстроки, полностью выходящей за пределы строки, вызывает исключение. Вот пример, демонстрирующий поведение в пограничных случаях:

my $name = 'fred';
substr($name, 4) = 'dy';         # $name is now 'freddy'
my $null = substr $name, 6, 2;   # returns "" (no warning)
my $oops = substr $name, 7;      # returns undef, with warning
substr($name, 7) = 'gap';        # raises an exception

Альтернативой использованию substr в качестве lvalue является указание строки замены в качестве 4-го аргумента. Это позволяет заменить части EXPR и вернуть то, что было до этого, за одну операцию, точно так же, как это можно сделать с splice.

my $s = "The black cat climbed the green tree";
my $z = substr $s, 14, 7, "jumped from";    # climbed
# $s is now "The black cat jumped from the green tree"

Обратите внимание, что lvalue, возвращаемое трехаргументной версией substr, действует как «волшебная пуля»; каждый раз, когда она присваивается, она запоминает, какая часть исходной строки изменяется; например:

my $x = '1234';
for (substr($x,1,2)) {
    $_ = 'a';   print $x,"\n";    # prints 1a4
    $_ = 'xyz'; print $x,"\n";    # prints 1xyz4
    $x = '56789';
    $_ = 'pq';  print $x,"\n";    # prints 5pq9
}

С отрицательными смещениями она запоминает своё положение от конца строки, когда целевая строка изменяется:

my $x = '1234';
for (substr($x, -3, 2)) {
    $_ = 'a';   print $x,"\n";    # prints 1a4, as above
    $x = 'abcdefg';
    print $_,"\n";                # prints f
}

До версии Perl 5.10 результат многократного использования lvalue был неопределённым. До версии 5.16 результат с отрицательными смещениями был неопределённым.

symlink OLDFILE,NEWFILE

Создаёт новое имя файла, символически связанное со старым именем файла. Возвращает 1 при успехе, 0 в противном случае. На системах, не поддерживающих символические ссылки, возникает исключение. Для проверки этого используйте eval:

my $symlink_exists = eval { symlink("",""); 1 };

Проблемы с переносимостью: "symlink" в perlport.

syscall NUMBER, LIST

Вызывает системный вызов, указанный как первый элемент списка, передавая оставшиеся элементы как аргументы системному вызову. Если не реализовано, вызывает исключение. Аргументы интерпретируются следующим образом: если данный аргумент числовой, аргумент передаётся как целое число. Если нет, передаётся указатель на строковое значение. Вы несёте ответственность за то, чтобы строка была предварительно расширена достаточно для приёма любого результата, который может быть записан в строку. Вы не можете использовать строковую литерал (или другую неизменяемую строку) в качестве аргумента для syscall, потому что Perl должен предполагать, что любой указатель на строку может быть изменён. Если ваши целочисленные аргументы не являются литералами и никогда не интерпретировались в числовом контексте, вам может потребоваться добавить 0 к ним, чтобы заставить их выглядеть как числа. Это эмулирует функцию syswrite (или наоборот):

require 'syscall.ph';        # may need to run h2ph
my $s = "hi there\n";
syscall(SYS_write(), fileno(STDOUT), $s, length $s);

Обратите внимание, что Perl поддерживает передачу максимум 14 аргументов вашему системному вызову, чего обычно достаточно.

Syscall возвращает значение, возвращённое системным вызовом. Если системный вызов завершается неудачей, syscall возвращает -1 и устанавливает $! (errno). Обратите внимание, что некоторые системные вызовы могут законно вернуть -1. Правильный способ обработки таких вызовов — присвоить $! = 0 перед вызовом, а затем проверить значение $!, если syscall возвращает -1.

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

Проблемы с переносимостью: "syscall" в perlport.

sysopen FILEHANDLE,FILENAME,MODE

sysopen FILEHANDLE,FILENAME,MODE,PERMS

Открывает файл с именем FILENAME и связывает его с FILEHANDLE. Если FILEHANDLE — выражение, его значение используется как фактический файловый дескриптор; неопределённая скалярная переменная будет подходящим образом автоматизирована. Эта функция вызывает функцию системного вызова open(2) с параметрами FILENAME, MODE и PERMS.

Возвращает true при успехе и undef в противном случае.

Возможные значения и флаги параметра MODE зависят от системы; они доступны через стандартный модуль Fcntl. Смотрите документацию системного вызова open(2) вашей операционной системы, чтобы увидеть доступные значения и флаги. Можно комбинировать несколько флагов с помощью оператора |.

Некоторые из наиболее распространённых значений: O_RDONLY для открытия файла в режиме только для чтения, O_WRONLY для открытия файла в режиме только для записи и O_RDWR для открытия файла в режиме чтения/записи.

По историческим причинам некоторые значения работают практически на каждой системе, поддерживаемой Perl: 0 означает только для чтения, 1 означает только для записи, а 2 означает чтение/запись. Мы знаем, что эти значения не работают под OS/390 и на Macintosh; в новом коде их лучше не использовать.

Если файл с именем FILENAME не существует и вызов open создаёт его (обычно потому, что MODE включает флаг O_CREAT), тогда значение PERMS определяет разрешения вновь созданного файла. Если вы опустите аргумент PERMS в sysopen, Perl использует восьмеричное значение 0666. Эти значения разрешений должны быть восьмеричными и модифицируются текущим umask процесса.

Во многих системах доступен флаг O_EXCL для открытия файлов в эксклюзивном режиме. Это не блокировка: эксклюзивность здесь означает, что если файл уже существует, sysopen завершается неудачей. O_EXCL может не работать с файловыми системами сети и не имеет эффекта, если не установлен также флаг O_CREAT. Установка флага O_CREAT|O_EXCL предотвращает открытие файла, если это символическая ссылка. Это не защищает от символических ссылок в пути файла.

Иногда может потребоваться обнулить уже существующий файл. Это можно сделать с помощью флага O_TRUNC. Поведение O_TRUNC с O_RDONLY является неопределённым.

Вы редко, если вообще когда-либо, должны использовать 0644 в качестве аргумента для sysopen, потому что это лишает пользователя возможности иметь более либеральный umask. Лучше его опустить. Смотрите umask для более подробной информации об этом.

Обратите внимание, что в Perl-версиях старше 5.8.0 sysopen зависит от функции C библиотеки fdopen(3). На многих Unix-системах fdopen(3) может завершиться неудачей, когда дескрипторы файлов превышают определённое значение, обычно 255. Если вам нужны дескрипторы файлов больше этого значения, рассмотрите использование функции POSIX::open. Для Perl 5.8.0 и более поздних версий PerlIO (чаще всего) является значением по умолчанию.

Смотрите perlopentut для более подробного объяснения открытия файлов.

Проблемы с переносимостью: "sysopen" в perlport.

sysread FILEHANDLE,SCALAR,LENGTH,OFFSET

sysread FILEHANDLE,SCALAR,LENGTH

Пытается прочитать LENGTH байт данных в переменную SCALAR из указанного FILEHANDLE, используя read(2). Она обходит буферизованный ввод-вывод, поэтому смешивание этого с другими видами чтений, print, write, seek, tell или eof может вызвать путаницу, потому что слои perlio или stdio обычно буферизуют данные. Возвращает количество реально прочитанных байтов, 0 в конце файла или undef, если произошла ошибка (в последнем случае $! также устанавливается). SCALAR будет увеличен или уменьшен так, чтобы последний реально прочитанный байт был последним байтом скаляра после чтения.

OFFSET может быть указан, чтобы разместить прочитанные данные в какой-то точке в строке, кроме начала. Отрицательный OFFSET указывает размещение за указанным количеством символов от конца строки. Положительный OFFSET, превышающий длину SCALAR, приводит к расширению строки до необходимого размера с помощью "\0" байтов перед добавлением результата чтения.

Функции syseof() не существует, что нормально, так как eof и так не работает хорошо с файлами устройств (например, терминалами). Используйте sysread и проверьте возвращаемое значение на 0, чтобы решить, закончили вы или нет.

Обратите внимание, что если файловый дескриптор был помечен как :utf8, sysread выбросит исключение. Слой :encoding(...) неявно включает слой :utf8. Смотрите binmode, open и прагму open.

sysseek FILEHANDLE,POSITION,WHENCE

Устанавливает системную позицию FILEHANDLE в байтах, используя lseek(2). FILEHANDLE может быть выражением, значение которого даёт имя файлового дескриптора. Значения для WHENCE — 0 для установки новой позиции в POSITION; 1 для установки её на текущую позицию плюс POSITION; и 2 для установки её на конец файла плюс POSITION, обычно отрицательное значение.

Обратите внимание на акцент на байтах: даже если файловый дескриптор настроен на работу с символами (например, с помощью слоя ввода-вывода :encoding(UTF-8)), семейство функций seek, tell и sysseek использует смещения в байтах, а не в символах, потому что поиск по смещениям символов был бы очень медленным в файле UTF-8.

sysseek обходит обычный буферизованный ввод-вывод, поэтому смешивание его с чтениями, отличными от sysread (например, readline или read), print, write, seek, tell или eof может привести к путанице.

Для WHENCE можно также использовать константы SEEK_SET, SEEK_CUR, и SEEK_END (начало файла, текущая позиция, конец файла) из модуля Fcntl. Использование констант также более переносимо, чем полагание на 0, 1 и 2. Например, для определения функции "systell":

use Fcntl 'SEEK_CUR';
sub systell { sysseek($_[0], 0, SEEK_CUR) }

Возвращает новую позицию или неопределённое значение при ошибке. Позиция 0 возвращается в виде строки "0 but true"; таким образом sysseek возвращает true при успехе и false при ошибке, но вы всё равно можете легко определить новую позицию.

system LIST

system PROGRAM LIST

Делает ровно то же самое, что и exec, за исключением того, что сначала выполняется вилка, а родительский процесс ждёт завершения дочернего процесса. Обратите внимание, что обработка аргументов варьируется в зависимости от количества аргументов. Если в LIST более одного аргумента или если LIST — массив с более чем одним значением, запускает программу, заданную первым элементом списка, с аргументами, заданными остальными элементами списка. Если аргумент — единственный скаляр, аргумент проверяется на наличие метасимволов оболочки, и если таковые имеются, весь аргумент передаётся оболочке системы для анализа (это /bin/sh -c на платформах Unix, но варьируется на других платформах). Если в аргументе нет метасимволов оболочки, он разбивается на слова и передаётся непосредственно в execvp, что более эффективно. В Windows только синтаксис system PROGRAM LIST надёжно избежит использования оболочки; system LIST, даже с несколькими элементами, вернётся к оболочке, если первый запуск не удался.

Perl пытается сбросить все открытые для вывода файлы перед любой операцией, которая может выполнить вилку, но это может быть не поддерживается на некоторых платформах (см. perlport). Для безопасности вам может потребоваться установить $| ($AUTOFLUSH в English) или вызвать метод autoflush объекта IO::Handle для любого открытого дескриптора.

Возвращаемое значение — код завершения программы, возвращённый вызовом wait. Чтобы получить фактическое выходное значение, сместите его вправо на восемь бит (см. ниже). См. также exec. Это не то, что нужно использовать для захвата вывода команды; для этого следует использовать обратные кавычки или qx//, как описано в "`STRING`" в perlop. Возвращаемое значение -1 указывает на неудачный запуск программы или ошибку системного вызова wait(2) (просмотрите $! для причины).

Если вы хотите, чтобы system (и многие другие части Perl) вызывали исключение при ошибке, взгляните на псевдоним autodie.

Как и exec, system позволяет вам врать программе о её имени, если вы используете синтаксис system PROGRAM LIST. Опять же, см. exec.

Поскольку SIGINT и SIGQUIT игнорируются во время выполнения system, если вы ожидаете, что ваша программа завершится при получении этих сигналов, вам нужно будет организовать это самостоятельно на основе возвращаемого значения.

my @args = ("command", "arg1", "arg2");
system(@args) == 0
    or die "system @args failed: $?";

Если вы хотите вручную проверить неудачу system, вы можете проверить все возможные режимы ошибок, просмотрев $? следующим образом:

if ($? == -1) {
    print "failed to execute: $!\n";
}
elsif ($? & 127) {
    printf "child died with signal %d, %s coredump\n",
        ($? & 127),  ($? & 128) ? 'with' : 'without';
}
else {
    printf "child exited with value %d\n", $? >> 8;
}

Альтернативно, можно просмотреть значение ${^CHILD_ERROR_NATIVE} с помощью вызовов W*() из модуля POSIX.

Когда аргументы system выполняются косвенно оболочкой, результаты и коды возврата зависят от её особенностей. См. "`STRING`" в perlop и exec для получения подробностей.

Так как system выполняет fork и wait, это может повлиять на обработчик SIGCHLD. См. perlipc для подробностей.

Проблемы переносимости: "system" в perlport.

syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET

syswrite FILEHANDLE,SCALAR,LENGTH

syswrite FILEHANDLE,SCALAR

Попытка записать LENGTH байтов данных из переменной SCALAR в указанный FILEHANDLE, используя write(2). Если LENGTH не указан, записывает всю SCALAR. Она обходит буферизованный ввод-вывод, поэтому смешивание её с чтениями (кроме sysread)), print, write, seek, tell или eof может привести к путанице, потому что слои perlio и stdio обычно буферизуют данные. Возвращает количество байтов, фактически записанных, или undef в случае ошибки (в этом случае переменная errno $! также устанавливается). Если LENGTH больше, чем доступные данные в SCALAR после OFFSET, записываются только доступные данные.

OFFSET может быть указан для записи данных из части строки, отличной от начала. Отрицательный OFFSET указывает запись данных с учётом символов с конца строки. Если длина SCALAR равна нулю, можно использовать только OFFSET 0.

ПРЕДУПРЕЖДЕНИЕ: Если файловый дескриптор помечен как :utf8, syswrite вызовет исключение. Слой :encoding(...) неявно вводит слой :utf8. В противном случае, если дескриптор не помечен кодировкой, но вы пытаетесь записать символы с кодовыми точками свыше 255, возникнет исключение. См. binmode, open и псевдоним open.

tell FILEHANDLE

tell

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

Возвращаемое значение tell для стандартных потоков, таких как STDIN, зависит от операционной системы: оно может вернуть -1 или что-то другое. tell для каналов, FIFO и сокетов обычно возвращает -1.

Функции systell не существует. Используйте sysseek($fh, 0, 1) для этого.

Не используйте tell (или другие операции буферизованного ввода-вывода) с файловым дескриптором, обработанным с помощью sysread, syswrite или sysseek. Эти функции игнорируют буферизацию, а tell — нет.

telldir DIRHANDLE

Возвращает текущую позицию функций readdir для DIRHANDLE. Значение может быть передано в seekdir для доступа к определённому расположению в каталоге. telldir имеет те же оговорки по поводу возможного сжатия каталога, что и соответствующая системная библиотечная функция.

tie VARIABLE,CLASSNAME,LIST

Эта функция связывает переменную с классом пакета, который предоставит реализацию для переменной. VARIABLE — имя переменной, которую нужно связать. CLASSNAME — имя класса, реализующего объекты нужного типа. Любые дополнительные аргументы передаются соответствующему методу конструктора класса (то есть TIESCALAR, TIEHANDLE, TIEARRAY, или TIEHASH). Как правило, это аргументы, которые могут быть переданы функции dbm_open(3) языка C. Объект, возвращаемый конструктором, также возвращается функцией tie, что может быть полезно, если вы хотите получить доступ к другим методам в CLASSNAME.

Обратите внимание, что такие функции, как keys и values, могут возвращать огромные списки при использовании с большими объектами, такими как файлы DBM. Возможно, вам будет удобнее использовать функцию each для итерации по таким спискам. Пример:

# print out history file offsets
use NDBM_File;
tie(my %HIST, 'NDBM_File', '/usr/lib/news/history', 1, 0);
while (my ($key,$val) = each %HIST) {
    print $key, ' = ', unpack('L', $val), "\n";
}

Класс, реализующий хеш, должен иметь следующие методы:

TIEHASH classname, LIST
FETCH this, key
STORE this, key, value
DELETE this, key
CLEAR this
EXISTS this, key
FIRSTKEY this
NEXTKEY this, lastkey
SCALAR this
DESTROY this
UNTIE this

Класс, реализующий обычный массив, должен иметь следующие методы:

TIEARRAY classname, LIST
FETCH this, key
STORE this, key, value
FETCHSIZE this
STORESIZE this, count
CLEAR this
PUSH this, LIST
POP this
SHIFT this
UNSHIFT this, LIST
SPLICE this, offset, length, LIST
EXTEND this, count
DELETE this, key
EXISTS this, key
DESTROY this
UNTIE this

Класс, реализующий дескриптор файла, должен иметь следующие методы:

TIEHANDLE classname, LIST
READ this, scalar, length, offset
READLINE this
GETC this
WRITE this, scalar, length, offset
PRINT this, LIST
PRINTF this, format, LIST
BINMODE this
EOF this
FILENO this
SEEK this, position, whence
TELL this
OPEN this, mode, LIST
CLOSE this
DESTROY this
UNTIE this

Не все указанные выше методы необходимо реализовывать. См. perltie, Tie::Hash, Tie::Array, Tie::Scalar и Tie::Handle.

В отличие от dbmopen, функция tie не будет use или require модуля за вас; вы должны сделать это явно сами. См. DB_File или модуль Config для интересных реализаций tie.

Для получения дополнительной информации см. perltie, tied.

tied VARIABLE

Возвращает ссылку на объект, лежащий в основе VARIABLE (тот же самый значение, что и первоначально возвращалось вызовом tie, который связывал переменную с пакетом). Возвращает значение undef, если VARIABLE не привязано к пакету.

time

Возвращает количество невисокосных секунд, прошедших с момента, который система считает началом отсчёта времени, подходящее для передачи в gmtime и localtime. На большинстве систем началом отсчёта является 00:00:00 UTC, 1 января 1970 года; заметным исключением является Mac OS Classic, которая использует 00:00:00, 1 января 1904 года в текущей местном часовом поясе в качестве начальной точки отсчёта.

Для измерения времени с большей точностью, чем одна секунда, используйте модуль Time::HiRes из Perl 5.8 и выше (или из CPAN до этого момента), или, если у вас есть gettimeofday(2), вы можете использовать интерфейс syscall Perl. Подробности см. в perlfaq8.

Для обработки дат и времени смотрите множество связанных модулей в CPAN. Для комплексного представления дат и времени посмотрите на модуль DateTime.

times

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

my ($user,$system,$cuser,$csystem) = times;

В скалярном контексте times возвращает $user.

Время дочерних процессов учитывается только для завершённых дочерних процессов.

Вопросы переносимости: "times" в perlport.

tr///

Оператор транслитерации. То же, что и y///. См. "Quote-Like Operators" в perlop.

truncate FILEHANDLE,LENGTH

truncate EXPR,LENGTH

Укорачивает файл, открытый в FILEHANDLE или именованный EXPR, до указанной длины. Вызывает исключение, если truncate не реализован на вашей системе. Возвращает true при успехе, undef при ошибке.

Поведение не определено, если LENGTH больше длины файла.

Позиция в файле FILEHANDLE остаётся неизменной. Возможно, вам потребуется вызвать seek перед записью в файл.

Вопросы переносимости: "truncate" в perlport.

uc EXPR

uc

Возвращает версию EXPR в верхнем регистре. Это внутренняя функция, реализующая escape \U в строках с двойными кавычками. Она не пытается выполнить преобразование в заглавные буквы начальных букв. См. ucfirst для этого.

Если EXPR опущен, используется $_.

Эта функция ведет себя одинаково при различных прагмах, например, в локали, как и lc.

ucfirst EXPR

ucfirst

Возвращает значение EXPR с первой буквой в верхнем регистре (заглавные буквы в Юникоде). Это внутренняя функция, реализующая escape \u в строках с двойными кавычками.

Если EXPR опущен, используется $_.

Эта функция ведет себя одинаково при различных прагмах, например, в локали, как и lc.

umask EXPR

umask

Устанавливает umask для процесса в EXPR и возвращает предыдущее значение. Если EXPR опущен, просто возвращает текущий umask.

Разрешения Unix rwxr-x--- представлены тремя наборами по три бита или тремя восьмеричными цифрами: 0750 (ведущая 0 указывает на восьмеричный формат и не является одной из цифр). Значение umask — это такое число, представляющее отключённые биты разрешений. Значения разрешений (или «режима»), которые вы передаёте mkdir или sysopen, модифицируются вашим umask, поэтому даже если вы говорите sysopen создать файл с разрешениями 0777, если ваш umask равен 0022, то файл фактически будет создан с разрешениями 0755. Если ваш umask был 0027 (группа не может писать; другие не могут читать, писать или выполнять), то передача sysopen 0666 создаст файл с режимом 0640 (потому что 0666 &~ 027 равно 0640).

Вот совет: укажите режим создания 0666 для обычных файлов (в sysopen) и один из 0777 для каталогов (в mkdir) и исполняемых файлов. Это даёт пользователям свободу выбора: если они хотят защищённые файлы, они могут выбрать маски umask процесса 022, 027, или даже особенно антиобщественную маску 077. Программы редко, если вообще, должны принимать решения об политике, которые лучше оставить пользователю. Исключением из этого являются случаи записи файлов, которые должны храниться в тайне: файлы электронной почты, файлы cookie веб-браузера, файлы .rhosts и т. д.

Если umask(2) не реализован на вашей системе, и вы пытаетесь ограничить доступ для себя (т.е., (EXPR & 0700) > 0), возникает исключение. Если umask(2) не реализован, и вы не пытаетесь ограничить доступ для себя, возвращает undef.

Помните, что umask — это число, обычно в восьмеричном формате; это не строка восьмеричных цифр. См. также oct, если у вас есть только строка.

Вопросы переносимости: "umask" в perlport.

undef EXPR

undef

Сбрасывает значение EXPR, которое должно быть lvalue. Используйте только для скалярного значения, массива (используя @), хеша (используя %), подпрограммы (используя &) или typeglob (используя *). undef $hash{$key} скорее всего, не сделает того, что вы ожидаете, для большинства предварительно определённых переменных или значений списков DBM, поэтому не делайте этого; см. delete. Всегда возвращает значение undef. Вы можете опустить EXPR, в этом случае ничего не будет сброшено, но вы всё равно получите значение undef, которое вы можете, например, вернуть из подпрограммы, присвоить переменной или передать в качестве параметра. Примеры:

undef $foo;
undef $bar{'blurfl'};      # Compare to: delete $bar{'blurfl'};
undef @ary;
undef %hash;
undef &mysub;
undef *xyz;       # destroys $xyz, @xyz, %xyz, &xyz, etc.
return (wantarray ? (undef, $errmsg) : undef) if $they_blew_it;
select undef, undef, undef, 0.25;
my ($x, $y, undef, $z) = foo();    # Ignore third value returned

Обратите внимание, что это унарный оператор, а не оператор списка.

unlink LIST

unlink

Удаляет список файлов. При успехе возвращает количество успешно удалённых файлов. При неудаче возвращает false и устанавливает $! (errno):

my $unlinked = unlink 'a', 'b', 'c';
unlink @goners;
unlink glob "*.bak";

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

foreach my $file ( @goners ) {
    unlink $file or warn "Could not unlink $file: $!";
}

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

Если LIST опущен, unlink использует $_.

unpack TEMPLATE,EXPR

unpack TEMPLATE

unpack выполняет обратную операцию по отношению к pack: она принимает строку и разворачивает её в список значений. (В скалярном контексте она возвращает только первое произведённое значение.)

Если EXPR опущено, то происходит распаковка строки $_. Обратитесь к perlpacktut для введения в эту функцию.

Строка разбивается на части, описанные шаблоном TEMPLATE. Каждая часть преобразуется в отдельное значение. Обычно строка является результатом работы pack, или символы строки представляют собой структуру данных C.

Шаблон TEMPLATE имеет тот же формат, что и в функции pack. Вот подпрограмма, выполняющая подстрочную операцию:

sub substr {
    my ($what, $where, $howmuch) = @_;
    unpack("x$where a$howmuch", $what);
}

и затем есть

sub ordinal { unpack("W",$_[0]); } # same as ord()

В дополнение к полям, разрешённым в pack, вы можете добавить префикс %<число> к полю, чтобы указать, что вы хотите вычислить контрольную сумму из <число> битов элементов, вместо самих элементов. По умолчанию используется контрольная сумма из 16 бит. Контрольная сумма рассчитывается путём суммирования числовых значений расширенных значений (для строковых полей берётся сумма ord($char); для полей бит – сумма нулей и единиц).

Например, следующее вычисляет то же число, что и программа System V sum:

my $checksum = do {
    local $/;  # slurp!
    unpack("%32W*", readline) % 65535;
};

Следующее эффективно подсчитывает количество установленных битов в битовой последовательности:

my $setbits = unpack("%32b*", $selectmask);

Форматы p и P следует использовать с осторожностью. Поскольку Perl не имеет способа проверить, соответствует ли значение, переданное unpack, валидному адресу памяти, передача значения указателя, которое не известно как валидное, может привести к катастрофическим последствиям.

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

См. pack для получения дополнительных примеров и заметок.

unshift ARRAY,LIST

Выполняет обратную операцию по отношению к shift. Или обратную операцию по отношению к push, в зависимости от того, как вы на это смотрите. Добавляет список в начало массива и возвращает новое количество элементов в массиве.

unshift(@ARGV, '-e') unless $ARGV[0] =~ /^-/;

Обратите внимание, что список LIST добавляется целиком, а не по одному элементу за раз, поэтому добавленные элементы сохраняют порядок. Используйте reverse для обратного порядка.

Начиная с Perl 5.14, экспериментальная возможность позволяла unshift принимать скалярное выражение. Этот эксперимент признан неудачным и был удалён в Perl 5.24.

untie VARIABLE

Разрывает связь между переменной и пакетом. (См. tie.) Не оказывает никакого влияния, если переменная не связана.

use Module VERSION LIST

use Module VERSION

use Module LIST

use Module

use VERSION

Импортирует некоторые семантики в текущий пакет из указанного модуля, обычно путём алиасирования определённых подпрограмм или переменных в ваш пакет. Это точно эквивалентно

BEGIN { require Module; Module->import( LIST ); }

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

В форме use VERSION, VERSION может быть либо строкой типа v5.24.1, которая будет сравниваться с $^V (также $PERL_VERSION), либо числовым аргументом типа 5.024001, который будет сравниваться с $]. Если VERSION больше версии текущего интерпретатора Perl, возникает исключение; Perl не будет пытаться проанализировать остальную часть файла. Сравните с require, которое может выполнить аналогичную проверку во время выполнения. Симметрично, no VERSION позволяет указать, что вы хотите версию Perl старше указанной.

Указание VERSION числовым аргументом типа 5.024001 следует в целом избегать как более устаревшего и менее читабельного синтаксиса по сравнению с v5.24.1. До выпуска perl 5.8.0 в 2002 году более объёмный числовой формат был единственным поддерживаемым синтаксисом, поэтому вы можете встретить его в

use v5.24.1;    # compile time version check
use 5.24.1;     # ditto
use 5.024_001;  # ditto; older syntax compatible with perl 5.6

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

use VERSION также лексически включает все функции, доступные в запрошенной версии, как определено в прагме feature, отключая любые функции, отсутствующие в наборе функций запрошенной версии. См. feature. Аналогично, если указанная версия Perl больше или равна 5.12.0, лексически включаются строгие директивы, как с use strict. Любое явное использование use strict или no strict переопределяет use VERSION, даже если оно стоит раньше. Более позднее использование use VERSION переопределит всё поведение предыдущего use VERSION, возможно удалив strict и feature добавленные use VERSION. use VERSION не загружает файлы feature.pm или strict.pm.

BEGIN вынуждает require и import произойти во время компиляции. require убеждается, что модуль загружен в память, если он ещё не был загружен. import не является встроенной функцией; это просто обычный статический вызов метода в пакет Module для указания модулю импортировать список функций обратно в текущий пакет. Модуль может реализовать метод import как ему угодно, хотя большинство модулей просто выбирают выводить метод import через наследование от класса Exporter, определённого в модуле Exporter. См. Exporter. Если метод import не найден, то вызов пропускается, даже если есть метод AUTOLOAD.

Если вы не хотите вызывать метод пакета import (например, чтобы предотвратить изменение вашего пространства имён), явно укажите пустой список:

use Module ();

Это точно эквивалентно

BEGIN { require Module }

Если аргумент VERSION присутствует между Module и LIST, то use вызовет метод VERSION в классе Module с заданной версией в качестве аргумента:

use Module 12.34;

эквивалентно:

BEGIN { require Module; Module->VERSION(12.34) }

Метод VERSION по умолчанию, унаследованный от класса UNIVERSAL, выдаёт ошибку, если указанная версия больше значения переменной $Module::VERSION.

Аргумент VERSION не может быть произвольным выражением. Он считается аргументом VERSION только если это литерал версии, начинающийся либо с цифры, либо с v и за которым следует цифра. Всё, что не похоже на литерал версии, будет распарсировано как начало LIST. Тем не менее, многие попытки использовать произвольное выражение в качестве аргумента VERSION могут показаться работающими, поскольку метод import из Exporter обрабатывает числовые аргументы специально, выполняя проверки версий, а не рассматривая их как вещи для экспорта.

Опять же, есть различие между опущением LIST (import вызывается без аргументов) и явным пустым LIST () (import не вызывается). Обратите внимание, что за VERSION нет запятой!

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

use constant;
use diagnostics;
use integer;
use sigtrap  qw(SEGV BUS);
use strict   qw(subs vars refs);
use subs     qw(afunc blurfl);
use warnings qw(all);
use sort     qw(stable);

Некоторые из этих псевдомодулей импортируют семантику в текущую область видимости блока (например, strict или integer, в отличие от обычных модулей, которые импортируют символы в текущий пакет (они действуют до конца файла).

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

use if $] < 5.008, "utf8";
use if WANT_WARNINGS, warnings => qw(all);

Существует соответствующее объявление no, которое аннулирует значения, импортированные с помощью use, то есть вызывает Module->unimport(LIST) вместо import. Оно ведёт себя так же, как import с VERSION, пропущенным или пустым LIST, или если метод unimport не найден.

no integer;
no strict 'refs';
no warnings;

Следует проявлять осторожность при использовании формы no VERSION no. Она только предназначена для утверждения того, что выполняемый Perl имеет более раннюю версию, чем его аргумент, а не для отмены эффектов включения функций с помощью use VERSION.

См. perlmodlib для списка стандартных модулей и прагм. См. perlrun для -M и -m параметров командной строки Perl, предоставляющих функциональность use из командной строки.

utime LIST

Изменяет время доступа и изменения для каждого файла в списке файлов. Первые два элемента списка должны быть ЧИСЛОВЫМИ временем доступа и изменения, соответственно. Возвращает количество файлов, успешно изменённых. Время изменения inode каждого файла устанавливается на текущее время. Например, этот код имеет тот же эффект, что и команда Unix touch(1), когда файлы уже существуют и принадлежат пользователю, запускающему программу:

#!/usr/bin/perl
my $atime = my $mtime = time;
utime $atime, $mtime, @ARGV;

Начиная с Perl 5.8.0, если первые два элемента списка — undef, вызывается системный вызов utime(2) из вашей библиотеки C с нулевым вторым аргументом. На большинстве систем это установит время доступа и изменения файла на текущее время (т.е. эквивалентно примеру выше) и будет работать даже для файлов, которые вам не принадлежат, при условии наличия прав записи:

for my $file (@ARGV) {
    utime(undef, undef, $file)
        || warn "Couldn't touch $file: $!";
}

В среде NFS это будет использовать время сервера NFS, а не время локальной машины. Если есть проблема синхронизации времени, у сервера NFS и локальной машины будут разные времена. Команда Unix touch(1) фактически обычно использует этот формат вместо показанного в первом примере.

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

На системах, поддерживающих futimes(2), вы можете передавать дескрипторы файлов среди файлов. На системах, которые не поддерживают futimes(2), передача дескрипторов файлов вызывает исключение. Дескрипторы файлов должны передаваться как шаблоны или ссылки на шаблоны, чтобы быть распознанными; отдельные слова рассматриваются как имена файлов.

Проблемы с переносимостью: "utime" в perlport.

values HASH

values ARRAY

В контексте списка возвращает список, состоящий из всех значений именованного хэша. В Perl 5.12 или более поздних версиях также вернет список значений массива; до этого выпуска попытка использования массива в качестве аргумента приведёт к синтаксической ошибке. В скалярном контексте возвращает количество значений.

Элементы хэша возвращаются в кажущемся случайном порядке. Фактический случайный порядок специфичен для данного хэша; совершенно одинаковые последовательности операций над двумя хэшами могут привести к разному порядку для каждого хэша. Любая вставка в хэш может изменить порядок, как и любое удаление, за исключением того, что последний ключ, возвращённый функцией each или keys, может быть удалён без изменения порядка. Пока данный хэш не изменён, вы можете полагаться на keys, values и each для последовательного возвращения того же порядка друг относительно друга. См. "Algorithmic Complexity Attacks" в perlsec для получения подробной информации о том, почему порядок хэшей случайный. Помимо гарантий, предоставленных здесь, точные детали алгоритма хэширования Perl и порядок обхода хэша могут изменяться в любой версии Perl. Связанные хэши могут вести себя по-другому по сравнению со стандартными хэшами Perl в отношении изменений порядка при вставке и удалении элементов.

В качестве побочного эффекта, вызов values сбрасывает внутренний итератор хэша или массива (см. each) перед предоставлением значений. В частности, вызов values в контексте void сбрасывает итератор без дополнительной нагрузки.

Помимо сброса итератора, values @array в контексте списка то же самое, что и обычное @array. (Мы рекомендуем использовать контекст void keys @array для этого, но сочли, что удаление values @array потребует больше документации, чем его сохранение.)

Обратите внимание, что значения не копируются, что означает, что их изменение изменит содержимое хэша:

for (values %hash)      { s/foo/bar/g }  # modifies %hash values
for (@hash{keys %hash}) { s/foo/bar/g }  # same

Начиная с Perl 5.14, экспериментальная функция позволила values принимать скалярное выражение. Этот эксперимент был признан неудачным и был удалён в Perl 5.24.

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

use 5.012;  # so keys/values/each work on arrays

См. также keys, each и sort.

vec EXPR,OFFSET,BITS

Обрабатывает строку в EXPR как битовую строку, состоящую из элементов шириной BITS, и возвращает значение элемента, указанного OFFSET, как целое без знака. BITS, таким образом, определяет количество битов, зарезервированных для каждого элемента в битовой строке. Это должно быть степень двойки от 1 до 32 (или 64, если ваша платформа это поддерживает).

Если BITS равно 8, «элементы» совпадают с байтами входной строки.

Если BITS равно 16 или более, байты входной строки группируются в блоки размером BITS/8, и каждый блок преобразуется в число как в pack/unpack с форматами с порядком байтов сверху вниз n/N (и аналогично для BITS==64). См. pack для получения подробностей.

Если bits равно 4 или меньше, строка разбивается на байты, а затем биты каждого байта разбиваются на группы 8/BITS. Бит каждого байта нумеруются в стиле little-endian, как в 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80. Например, разбивка одного входного байта chr(0x36) на две группы даёт список (0x6, 0x3); разбивка на 4 группы даёт (0x2, 0x1, 0x3, 0x0).

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

vec($image, $max_x * $x + $y, 8) = 3;

Если выбранный элемент находится вне строки, возвращается значение 0. Если элемент за пределами строки записан, Perl сначала расширит строку на достаточное количество нулевых байтов. Попытка записи за начало строки (т.е. отрицательный OFFSET) является ошибкой.

Если строка закодирована в UTF-8 (и, следовательно, установлен флаг UTF8), vec пытается преобразовать её в внутреннее представление с одним байтом на символ. Однако, если строка содержит символы со значениями 256 или более, это преобразование потерпит неудачу, и будет выведено сообщение об устаревании. В этой ситуации, vec будет работать с базовым буфером независимо, в его внутреннем представлении UTF-8. В Perl 5.32 это будет фатальной ошибкой.

Строки, созданные с помощью vec, также могут быть обработаны логическими операторами |, &, ^, и ~. Эти операторы предположат, что желаема операция с битовой строкой, когда оба операнда являются строками. См. "Bitwise String Operators" в perlop.

Следующий код создаст строку ASCII, обозначающую 'PerlPerlPerl'. Комментарии показывают строку после каждого шага. Обратите внимание, что этот код работает одинаково на машинах с big-endian или little-endian архитектурой.

my $foo = '';
vec($foo,  0, 32) = 0x5065726C; # 'Perl'

# $foo eq "Perl" eq "\x50\x65\x72\x6C", 32 bits
print vec($foo, 0, 8);  # prints 80 == 0x50 == ord('P')

vec($foo,  2, 16) = 0x5065; # 'PerlPe'
vec($foo,  3, 16) = 0x726C; # 'PerlPerl'
vec($foo,  8,  8) = 0x50;   # 'PerlPerlP'
vec($foo,  9,  8) = 0x65;   # 'PerlPerlPe'
vec($foo, 20,  4) = 2;      # 'PerlPerlPe'   . "\x02"
vec($foo, 21,  4) = 7;      # 'PerlPerlPer'
                               # 'r' is "\x72"
vec($foo, 45,  2) = 3;      # 'PerlPerlPer'  . "\x0c"
vec($foo, 93,  1) = 1;      # 'PerlPerlPer'  . "\x2c"
vec($foo, 94,  1) = 1;      # 'PerlPerlPerl'
                               # 'l' is "\x6c"

Для преобразования битовой строки в строку или список из 0 и 1 используйте следующие функции:

my $bits = unpack("b*", $vector);
my @bits = split(//, unpack("b*", $vector));

Если вы знаете точную длину в битах, она может быть использована вместо *.

Вот пример, иллюстрирующий, как биты фактически располагаются:

#!/usr/bin/perl -wl

print <<'EOT';
                                  0         1         2         3
                   unpack("V",$_) 01234567890123456789012345678901
------------------------------------------------------------------
EOT

for $w (0..3) {
    $width = 2**$w;
    for ($shift=0; $shift < $width; ++$shift) {
        for ($off=0; $off < 32/$width; ++$off) {
            $str = pack("B*", "0"x32);
            $bits = (1<<$shift);
            vec($str, $off, $width) = $bits;
            $res = unpack("b*",$str);
            $val = unpack("V", $str);
            write;
        }
    }
}

format STDOUT =
vec($_,@#,@#) = @<< == @######### @>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
$off, $width, $bits, $val, $res
.
__END__

Независимо от архитектуры машины, на которой он работает, пример выше должен вывести следующую таблицу:

                                  0         1         2         3
                   unpack("V",$_) 01234567890123456789012345678901
------------------------------------------------------------------
vec($_, 0, 1) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 1) = 1   ==          2 01000000000000000000000000000000
vec($_, 2, 1) = 1   ==          4 00100000000000000000000000000000
vec($_, 3, 1) = 1   ==          8 00010000000000000000000000000000
vec($_, 4, 1) = 1   ==         16 00001000000000000000000000000000
vec($_, 5, 1) = 1   ==         32 00000100000000000000000000000000
vec($_, 6, 1) = 1   ==         64 00000010000000000000000000000000
vec($_, 7, 1) = 1   ==        128 00000001000000000000000000000000
vec($_, 8, 1) = 1   ==        256 00000000100000000000000000000000
vec($_, 9, 1) = 1   ==        512 00000000010000000000000000000000
vec($_,10, 1) = 1   ==       1024 00000000001000000000000000000000
vec($_,11, 1) = 1   ==       2048 00000000000100000000000000000000
vec($_,12, 1) = 1   ==       4096 00000000000010000000000000000000
vec($_,13, 1) = 1   ==       8192 00000000000001000000000000000000
vec($_,14, 1) = 1   ==      16384 00000000000000100000000000000000
vec($_,15, 1) = 1   ==      32768 00000000000000010000000000000000
vec($_,16, 1) = 1   ==      65536 00000000000000001000000000000000
vec($_,17, 1) = 1   ==     131072 00000000000000000100000000000000
vec($_,18, 1) = 1   ==     262144 00000000000000000010000000000000
vec($_,19, 1) = 1   ==     524288 00000000000000000001000000000000
vec($_,20, 1) = 1   ==    1048576 00000000000000000000100000000000
vec($_,21, 1) = 1   ==    2097152 00000000000000000000010000000000
vec($_,22, 1) = 1   ==    4194304 00000000000000000000001000000000
vec($_,23, 1) = 1   ==    8388608 00000000000000000000000100000000
vec($_,24, 1) = 1   ==   16777216 00000000000000000000000010000000
vec($_,25, 1) = 1   ==   33554432 00000000000000000000000001000000
vec($_,26, 1) = 1   ==   67108864 00000000000000000000000000100000
vec($_,27, 1) = 1   ==  134217728 00000000000000000000000000010000
vec($_,28, 1) = 1   ==  268435456 00000000000000000000000000001000
vec($_,29, 1) = 1   ==  536870912 00000000000000000000000000000100
vec($_,30, 1) = 1   == 1073741824 00000000000000000000000000000010
vec($_,31, 1) = 1   == 2147483648 00000000000000000000000000000001
vec($_, 0, 2) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 2) = 1   ==          4 00100000000000000000000000000000
vec($_, 2, 2) = 1   ==         16 00001000000000000000000000000000
vec($_, 3, 2) = 1   ==         64 00000010000000000000000000000000
vec($_, 4, 2) = 1   ==        256 00000000100000000000000000000000
vec($_, 5, 2) = 1   ==       1024 00000000001000000000000000000000
vec($_, 6, 2) = 1   ==       4096 00000000000010000000000000000000
vec($_, 7, 2) = 1   ==      16384 00000000000000100000000000000000
vec($_, 8, 2) = 1   ==      65536 00000000000000001000000000000000
vec($_, 9, 2) = 1   ==     262144 00000000000000000010000000000000
vec($_,10, 2) = 1   ==    1048576 00000000000000000000100000000000
vec($_,11, 2) = 1   ==    4194304 00000000000000000000001000000000
vec($_,12, 2) = 1   ==   16777216 00000000000000000000000010000000
vec($_,13, 2) = 1   ==   67108864 00000000000000000000000000100000
vec($_,14, 2) = 1   ==  268435456 00000000000000000000000000001000
vec($_,15, 2) = 1   == 1073741824 00000000000000000000000000000010
vec($_, 0, 2) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 2) = 2   ==          8 00010000000000000000000000000000
vec($_, 2, 2) = 2   ==         32 00000100000000000000000000000000
vec($_, 3, 2) = 2   ==        128 00000001000000000000000000000000
vec($_, 4, 2) = 2   ==        512 00000000010000000000000000000000
vec($_, 5, 2) = 2   ==       2048 00000000000100000000000000000000
vec($_, 6, 2) = 2   ==       8192 00000000000001000000000000000000
vec($_, 7, 2) = 2   ==      32768 00000000000000010000000000000000
vec($_, 8, 2) = 2   ==     131072 00000000000000000100000000000000
vec($_, 9, 2) = 2   ==     524288 00000000000000000001000000000000
vec($_,10, 2) = 2   ==    2097152 00000000000000000000010000000000
vec($_,11, 2) = 2   ==    8388608 00000000000000000000000100000000
vec($_,12, 2) = 2   ==   33554432 00000000000000000000000001000000
vec($_,13, 2) = 2   ==  134217728 00000000000000000000000000010000
vec($_,14, 2) = 2   ==  536870912 00000000000000000000000000000100
vec($_,15, 2) = 2   == 2147483648 00000000000000000000000000000001
vec($_, 0, 4) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 4) = 1   ==         16 00001000000000000000000000000000
vec($_, 2, 4) = 1   ==        256 00000000100000000000000000000000
vec($_, 3, 4) = 1   ==       4096 00000000000010000000000000000000
vec($_, 4, 4) = 1   ==      65536 00000000000000001000000000000000
vec($_, 5, 4) = 1   ==    1048576 00000000000000000000100000000000
vec($_, 6, 4) = 1   ==   16777216 00000000000000000000000010000000
vec($_, 7, 4) = 1   ==  268435456 00000000000000000000000000001000
vec($_, 0, 4) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 4) = 2   ==         32 00000100000000000000000000000000
vec($_, 2, 4) = 2   ==        512 00000000010000000000000000000000
vec($_, 3, 4) = 2   ==       8192 00000000000001000000000000000000
vec($_, 4, 4) = 2   ==     131072 00000000000000000100000000000000
vec($_, 5, 4) = 2   ==    2097152 00000000000000000000010000000000
vec($_, 6, 4) = 2   ==   33554432 00000000000000000000000001000000
vec($_, 7, 4) = 2   ==  536870912 00000000000000000000000000000100
vec($_, 0, 4) = 4   ==          4 00100000000000000000000000000000
vec($_, 1, 4) = 4   ==         64 00000010000000000000000000000000
vec($_, 2, 4) = 4   ==       1024 00000000001000000000000000000000
vec($_, 3, 4) = 4   ==      16384 00000000000000100000000000000000
vec($_, 4, 4) = 4   ==     262144 00000000000000000010000000000000
vec($_, 5, 4) = 4   ==    4194304 00000000000000000000001000000000
vec($_, 6, 4) = 4   ==   67108864 00000000000000000000000000100000
vec($_, 7, 4) = 4   == 1073741824 00000000000000000000000000000010
vec($_, 0, 4) = 8   ==          8 00010000000000000000000000000000
vec($_, 1, 4) = 8   ==        128 00000001000000000000000000000000
vec($_, 2, 4) = 8   ==       2048 00000000000100000000000000000000
vec($_, 3, 4) = 8   ==      32768 00000000000000010000000000000000
vec($_, 4, 4) = 8   ==     524288 00000000000000000001000000000000
vec($_, 5, 4) = 8   ==    8388608 00000000000000000000000100000000
vec($_, 6, 4) = 8   ==  134217728 00000000000000000000000000010000
vec($_, 7, 4) = 8   == 2147483648 00000000000000000000000000000001
vec($_, 0, 8) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 8) = 1   ==        256 00000000100000000000000000000000
vec($_, 2, 8) = 1   ==      65536 00000000000000001000000000000000
vec($_, 3, 8) = 1   ==   16777216 00000000000000000000000010000000
vec($_, 0, 8) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 8) = 2   ==        512 00000000010000000000000000000000
vec($_, 2, 8) = 2   ==     131072 00000000000000000100000000000000
vec($_, 3, 8) = 2   ==   33554432 00000000000000000000000001000000
vec($_, 0, 8) = 4   ==          4 00100000000000000000000000000000
vec($_, 1, 8) = 4   ==       1024 00000000001000000000000000000000
vec($_, 2, 8) = 4   ==     262144 00000000000000000010000000000000
vec($_, 3, 8) = 4   ==   67108864 00000000000000000000000000100000
vec($_, 0, 8) = 8   ==          8 00010000000000000000000000000000
vec($_, 1, 8) = 8   ==       2048 00000000000100000000000000000000
vec($_, 2, 8) = 8   ==     524288 00000000000000000001000000000000
vec($_, 3, 8) = 8   ==  134217728 00000000000000000000000000010000
vec($_, 0, 8) = 16  ==         16 00001000000000000000000000000000
vec($_, 1, 8) = 16  ==       4096 00000000000010000000000000000000
vec($_, 2, 8) = 16  ==    1048576 00000000000000000000100000000000
vec($_, 3, 8) = 16  ==  268435456 00000000000000000000000000001000
vec($_, 0, 8) = 32  ==         32 00000100000000000000000000000000
vec($_, 1, 8) = 32  ==       8192 00000000000001000000000000000000
vec($_, 2, 8) = 32  ==    2097152 00000000000000000000010000000000
vec($_, 3, 8) = 32  ==  536870912 00000000000000000000000000000100
vec($_, 0, 8) = 64  ==         64 00000010000000000000000000000000
vec($_, 1, 8) = 64  ==      16384 00000000000000100000000000000000
vec($_, 2, 8) = 64  ==    4194304 00000000000000000000001000000000
vec($_, 3, 8) = 64  == 1073741824 00000000000000000000000000000010
vec($_, 0, 8) = 128 ==        128 00000001000000000000000000000000
vec($_, 1, 8) = 128 ==      32768 00000000000000010000000000000000
vec($_, 2, 8) = 128 ==    8388608 00000000000000000000000100000000
vec($_, 3, 8) = 128 == 2147483648 00000000000000000000000000000001

wait

Ведёт себя как wait(2) на вашей системе: ждёт завершения дочернего процесса и возвращает PID умершего процесса, или -1 если нет дочерних процессов. Статус возвращается в $? и ${^CHILD_ERROR_NATIVE}. Обратите внимание, что возвращаемое значение -1 может означать, что дочерние процессы собираются автоматически, как описано в perlipc.

Если вы используете wait в своём обработчике для $SIG{CHLD}, вы можете случайно дождаться дочернего процесса, созданного qx или system. См. perlipc для получения подробностей.

Проблемы с переносимостью: "wait" в perlport.

waitpid PID,FLAGS

Ждёт завершения конкретного дочернего процесса и возвращает PID умершего процесса, или -1 если такого дочернего процесса нет. Неблокирующее ожидание (с WNOHANG в FLAGS) может вернуть 0, если есть дочерние процессы, соответствующие PID, но ни один из них ещё не завершился. Статус возвращается в $? и ${^CHILD_ERROR_NATIVE}.

PID со значением 0 указывает на ожидание любого дочернего процесса, групповой идентификатор которого равен идентификатору группы текущего процесса. PID меньше -1 указывает на ожидание любого дочернего процесса, групповой идентификатор которого равен -PID. PID со значением -1 указывает на ожидание любого дочернего процесса.

Если вы говорите

use POSIX ":sys_wait_h";

my $kid;
do {
    $kid = waitpid(-1, WNOHANG);
} while $kid > 0;

или

1 while waitpid(-1, WNOHANG) > 0;

тогда вы можете выполнить неблокирующее ожидание всех ожидающих процессов-зомби (см. "WAIT" в POSIX). Неблокирующее ожидание доступно на машинах, поддерживающих либо системный вызов waitpid(2), либо wait4(2). Однако, ожидание конкретного pid с флагами 0 реализовано повсеместно. (Perl эмулирует системный вызов, запоминая значения статуса процессов, которые завершились, но не были собраны скриптом Perl.)

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

Проблемы с переносимостью: "waitpid" в perlport.

wantarray

Возвращает true, если контекст текущей выполняемой подпрограммы или eval ожидает значение списка. Возвращает false, если контекст ожидает скалярное значение. Возвращает undef, если контекст ожидает отсутствие значения (пустой контекст).

return unless defined wantarray; # don't bother doing more
my @a = complex_calculation();
return wantarray ? @a : "@a";

wantarray результат неопределён в главном уровне файла, в BEGIN, UNITCHECK, CHECK, INIT или END блоках, или в методе DESTROY.

Эта функция должна была называться wantlist().

warn LIST

Выводит предупреждение, обычно выведя его в STDERR. warn интерпретирует свой операнд LIST так же, как die, но отличается в том, что по умолчанию делает, когда LIST пустой или создает пустую строку. Если он пуст, и $@ уже содержит значение исключения, то это значение используется после добавления "\t...caught". Если он пуст и $@ также пуст, используется строка "Warning: Something's wrong".

По умолчанию исключение, полученное от операнда LIST, строит в строку и выводит на STDERR. Это поведение можно изменить, установив обработчик $SIG{__WARN__}. Если такой обработчик есть, то сообщение автоматически не выводится; обработчик отвечает за обработку исключения по своему усмотрению (например, преобразование его в die). Поэтому большинство обработчиков должны организовать фактическое отображение предупреждений, с которыми они не готовы справиться, снова вызвав warn в обработчике. Обратите внимание, что это достаточно безопасно и не приведет к бесконечной петле, так как __WARN__ хуки не вызываются изнутри одного.

Вы обнаружите, что это поведение немного отличается от поведения обработчиков $SIG{__DIE__} (которые не подавляют текст ошибки, но могут вместо этого вызвать die снова, чтобы изменить его).

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

# wipe out *all* compile-time warnings
BEGIN { $SIG{'__WARN__'} = sub { warn $_[0] if $DOWARN } }
my $foo = 10;
my $foo = 20;          # no warning about duplicate my $foo,
                       # but hey, you asked for it!
# no compile-time or run-time warnings before here
$DOWARN = 1;

# run-time warnings enabled after here
warn "\$foo is alive and $foo!";     # does show up

Дополнительные сведения о настройке записей %SIG и дополнительные примеры см. в perlvar. См. модуль Carp для других типов предупреждений с использованием его функций carp и cluck.

write FILEHANDLE

write EXPR

write

Записывает отформатированный запис (возможно, многострочный) в указанный FILEHANDLE, используя формат, связанный с этим файлом. По умолчанию формат файла - это тот, который имеет такое же имя, как FILEHANDLE, но формат текущего выходного канала (см. функцию select) может быть задан явно, назначив имя формата переменной $~.

Обработка верхнего уровня формы выполняется автоматически: если на текущей странице недостаточно места для отформатированного записы, страница продвигается путём записи символа перевода страницы и специального формата верхнего уровня страницы используется для форматирования нового заголовка страницы до записи записы. По умолчанию формат верхнего уровня страницы имеет имя FILEHANDLE с добавленным _TOP или top в текущем пакете, если первый не существует. Это создавало бы проблему с автоматически инициализируемыми FILEHANDLE, но это может быть динамически задано в формат по вашему выбору путём присвоения имени переменной $^, пока этот FILEHANDLE выбран. Количество оставшихся строк на текущей странице содержится в переменной $-, которая может быть установлена в 0 для принудительной перехода на новую страницу.

Если FILEHANDLE не указан, вывод направляется в текущий выходной канал по умолчанию, который изначально является STDOUT, но может быть изменён оператором select. Если FILEHANDLE является EXPR, то выражение оценивается, и полученная строка используется для поиска имени FILEHANDLE во время выполнения. Дополнительную информацию о форматах см. в perlform.

Обратите внимание, что write не является противоположностью read. К сожалению.

y///

Оператор транслитерации. Одинаково с tr///. См. "Операторы типа цитирования" в perlop.

Ключевые слова, не являющиеся функциями, по ссылкам перекрестной

perldata

__DATA__
__END__: Эти ключевые слова описаны в "Специальные литералы" в perldata.

perlmod

BEGIN
CHECK
END
INIT
UNITCHECK: Эти ключевые слова фазы компиляции описаны в "BEGIN, UNITCHECK, CHECK, INIT и END" в perlmod.

perlobj

DESTROY: Это ключевое слово метода описано в "Деструкторы" в perlobj.

perlop

and
cmp
eq
ge
gt
le
lt
ne
not
or
x
xor: Эти операторы описаны в perlop.

perlsub

AUTOLOAD: Это ключевое слово описано в "Автозагрузка" в perlsub.

perlsyn

else

elsif

for

foreach

if

unless

until

while

Эти ключевые слова управления потоком описаны в "Составные операторы" в perlsyn.

elseif

Ключевое слово «else if» пишется как elsif в Perl. Также нет elif или else if. Оно elseif разбирается, но только для вывода предупреждения о его отсутствии.

См. документацию по ключевым словам управления потоком в "Составные операторы" в perlsyn.

default
given
when: Эти ключевые слова управления потоком, связанные с экспериментальной функцией переключения, описаны в "Операторы переключения" в perlsyn.

© 1993–2020 Larry Wall and others
Licensed under the GNU General Public License version 1 or later, or the Artistic License.
The Perl logo is a trademark of the Perl Foundation.
https://perldoc.perl.org/5.30.3/perlfunc