perlfunc

СОДЕРЖАНИЕ

• НАЗВАНИЕ
• ОПИСАНИЕ
  • Функции Perl по категориям
  • Переносимость
  • Алфавитный список функций Perl
  • Ключевые слова, не являющиеся функциями, по перекрёстным ссылкам
    • perldata
    • perlmod
    • perlobj
    • perlop
    • perlsub
    • perlsyn

НАЗВАНИЕ

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, которые служат оболочками для системных вызовов («syscalls») с тем же именем (например, 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__, method, next, __PACKAGE__, redo, return, sub, __SUB__, wantarray

break доступна только при включении экспериментальной функции "switch" или использовании префикса CORE::. "switch" также включает в себя операторы default, given и when, которые описаны в "Операторы switch" в 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, class, field, 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, class, dbmclose, dbmopen, field, method, 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

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

ADJUST, and, AUTOLOAD, BEGIN, catch, CHECK, cmp, CORE, __DATA__, default, defer, DESTROY, else, elseif, elsif, END, __END__, eq, finally, for, foreach, ge, given, gt, if, INIT, isa, le, lt, ne, not, or, try, 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, существует pragma под названием filetest, которое может давать более точные результаты, чем обычные биты режима stat. При использовании use filetest 'access', вышеупомянутые тесты файлов проверяют, может ли разрешение быть предоставлено с помощью семейства системных вызовов access(2). Также обратите внимание, что тесты -x и -X при использовании данного pragma могут возвращать true, даже если нет установленных битов разрешения на выполнение (и нет дополнительных разрешений на выполнение в ACL). Эта странность обусловлена определениями базовых системных вызовов. Также обратите внимание, что из-за реализации use filetest 'access', специальный дескриптор файла _ не будет кэшировать результаты тестов файлов при активном использовании этого pragma. Прочитайте документацию для pragma filetest для получения дополнительной информации.

Тесты -T и -B работают следующим образом. Первый блок или так далее файла проверяется на наличие допустимого UTF-8, включающего не ASCII-символы. Если это так, то это -T файл. В противном случае та же часть файла проверяется на наличие необычных символов, таких как странные управляющие коды или символы с установленным старшим битом. Если более одной трети символов являются странными, это -B файл; в противном случае это -T файл. Также любой файл, содержащий нулевой байт в проверенной части, считается двоичным файлом. (Если выполняется в контексте use locale, включающем LC_CTYPE, необычными символами являются все символы, которые не являются печатаемыми или пробелами в текущей локали.) Если -T или -B используются с дескриптором файла, проверяется текущий буфер ввода-вывода, а не первый блок. Оба -T и -B возвращают true для пустого файла или файла в конце файла (EOF) при тестировании дескриптора файла. Поскольку для выполнения теста -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 v5.10;  # so filetest ops can stack

abs VALUE

abs

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

accept NEWSOCKET,GENERICSOCKET

Принимает входящее подключение к сокету, так же, как и accept(2). Возвращает упакованный адрес, если операция успешна, в противном случае — ложь. См. пример в "Sockets: Клиент/Сервер-Связь" в perlipc.

В системах, которые поддерживают флаг close-on-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. Вы не можете полагаться на то, что alarm вызовет ошибку системного вызова, с $!, установленным в EINTR, потому что Perl устанавливает обработчики сигналов для перезапуска системных вызовов на некоторых системах. Использование eval/die всегда работает, за исключением оговорок, указанных в "Сигналы" в 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: Клиент/Сервер-Связь" в perlipc.

binmode FILEHANDLE, LAYER

binmode FILEHANDLE

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

На некоторых системах (в основном, системах на базе DOS и Windows) binmode необходимо, когда вы работаете не с текстовым файлом. Ради переносимости рекомендуется всегда использовать его, когда это уместно, и никогда не использовать, когда это неуместно. Кроме того, пользователи могут настроить свой ввод/вывод по умолчанию с кодировкой UTF-8 Unicode, а не байтами.

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

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

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

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

Параметр LAYER функции binmode описывается как «ДИСЦИПЛИНА» в «Программирование на Perl, 3-е издание». Однако с момента публикации этой книги, известной многим как «Верблюд 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 в кодировке UTF-8.

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

Все варианты Unix, Mac OS (старые и новые), и файлы Stream_LF в VMS используют один символ для завершения каждой строки во внешнем представлении текста (даже если этот один символ – возврат каретки в старых версиях Mac OS до Darwin и перевод строки в 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

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

• Благословение связанного элемента в определенный пакет (рекомендуемая форма):

  bless $ref, $package;

  Двухаргументная форма добавляет объект в пакет, указанный во втором аргументе.

• Благословение связанного элемента в пакет main.

  bless $ref, "";

  Если второй аргумент пустая строка, bless добавляет объект в пакет main.

• Благословение связанного элемента в текущий пакет (не наследуется):

  bless $ref;

  Если bless используется без второго аргумента, объект создается в текущем пакете. Второй аргумент всегда должен быть предоставлен, если производный класс может унаследовать метод, выполняющий bless. Из-за потенциальных ошибок использование bless с одним аргументом не рекомендуется.

См. perlobj для более подробной информации о благословении (и благословениях) объектов.

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

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

Также избегайте благословения вещей в имя класса 0; это приведет к тому, что код (по ошибке) проверяющий результат ref, чтобы увидеть, является ли ссылка blessed, завершится неудачей, так как «0», ложное значение, будет возвращено.

См. "Perl Modules" в perlmod для более подробной информации.

break

Прервать блок given.

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

caller EXPR

caller

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

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

Как __FILE__ и __LINE__, имя файла и номер строки, возвращённые здесь, могут быть изменены механизмом, описанным в "Plain Old Comments (Not!)" в perlsyn.

С 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 имеет значение true, если кадр создан оператором require или use, $evaltext содержит текст оператора eval EXPR. В частности, для оператора eval BLOCK, $subroutine равен (eval), но $evaltext не определён. (Обратите также внимание, что каждый оператор use создаёт кадр require внутри кадра eval EXPR.) $subroutine также может быть (unknown) если эта конкретная подпрограмма была удалена из таблицы символов. $hasargs имеет значение true, если для кадра был создан новый экземпляр @_. $hints и $bitmask содержат прагматические подсказки, с которыми была скомпилирована вызывающая сторона. $hints соответствует $^H, а $bitmask соответствует ${^WARNING_BITS}. Значения $hints и $bitmask могут изменяться между версиями Perl и не предназначены для внешнего использования.

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

Обратите внимание, что единственные типы кадров вызова, которые видны, это вызовы подпрограмм и eval. Другие формы контекста, такие как циклы while или foreach или блоки try не считаются интересными для caller, так как они не изменяют поведение выражения return.

Кроме того, при вызове из пакета 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.

Вы можете фактически использовать chomp для любого 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.

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

Если вы используете chop для списка, каждый элемент будет обработан. Возвращается только значение последнего 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)), за исключением случаев использования pragmy bytes, где используются младшие восемь битов значения (округлённые до целого числа).

Если ЧИСЛО опущено, используется $_.

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

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

См. perlunicode для получения дополнительной информации о Unicode.

chroot FILENAME

chroot

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

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

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

class NAMESPACE

class NAMESPACE VERSION

class NAMESPACE BLOCK

class NAMESPACE VERSION BLOCK

Объявляет блок или остальную часть единицы компиляции в заданном пространстве имен, которое реализует класс объекта. Это работает аналогично package, за исключением того, что созданный пакет ведёт себя как класс.

close FILEHANDLE

close

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

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

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

Если работают несколько потоков, close на файловом дескрипторе из открытого канала возвращает 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

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

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 с тем же солью, что и хранящийся дайджест. Если два дайджеста совпадают, пароль правильный.

При проверке существующей строки дайджеста вы должны использовать дайджест в качестве соли (как 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 пытается понять ситуацию, попытавшись понизить (копию) строки до восьмибитной строки байтов перед вызовом 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). Чтобы предотвратить создание базы данных, если она не существует, вы можете указать MASK равным 0, и функция вернёт ложное значение, если не найдёт существующей базы данных. Если ваша система поддерживает только старые функции DBM, вы можете сделать только один вызов dbmopen в вашей программе. В старых версиях Perl, если ваша система не имела ни DBM, ни ndbm, вызов dbmopen приводил к ошибке; сейчас он переключается на sdbm(3).

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

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

# 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 для этого элемента больше не возвращает истинное значение. Установка элемента хеша в неопределённое значение не удаляет его ключ, но удаление его делает; см. exists.

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

delete также может использоваться с массивами и массивами срезов, но его поведение менее очевидно. Хотя exists вернёт ложь для удалённых записей, удаление элементов массива никогда не изменяет индексов существующих значений; используйте shift или splice для этого. Однако, если какие-либо удалённые элементы находятся в конце массива, размер массива уменьшается до позиции самого высокого элемента, который ещё возвращает истинное значение для 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.

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

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

die @_ if $^S;

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

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

do BLOCK

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

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

См. perlsyn для альтернативных стратегий.

do EXPR

Использует значение EXPR в качестве имени файла и выполняет содержимое файла как скрипт 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 содержал '.' (текущий каталог), что делало эти два случая эквивалентными, но это больше не обязательно в версиях Perl 5.26.0 и выше, так как '.' по умолчанию не включается в @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 LABEL

dump EXPR

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 HASH

each ARRAY

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

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

После того, как 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.

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

# loops forever
while (my ($key, $value) = each @{ +{ a => 1 } }) {
    print "$key=$value\n";
}

Это выводит вашу среду, как и программа 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 v5.12;	# so keys/values/each work on arrays
use v5.18;	# 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() перед <> приведет к проверке @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 анализируется и компилируется только один раз. Поскольку ошибки перехватываются, его часто используют для проверки доступности заданного функционала.

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

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

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

Обратите внимание, что когда BEGIN {} блоки встроены внутрь блока eval, содержимое блока будет выполнено немедленно и до выполнения остального кода eval. Вы можете полностью отключить это, выполнив

local ${^MAX_NESTED_EVAL_BEGIN_BLOCKS} = 0;
eval $string;

что приведет к тому, что любые встроенные BEGIN блоки в $string вызовут исключение.

Под функцией "unicode_eval"

Если эта функция включена (что является значением по умолчанию при объявлении use 5.16 или выше), Perl предполагает, что EXPR — это строка символов. Любые use utf8 или no utf8 объявления внутри строки не имеют никакого эффекта. Фильтры исходного кода также запрещены. (unicode_strings, однако, может встречаться внутри строки.)

См. также оператор evalbytes, который правильно работает с фильтрами исходного кода.

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

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

• Внутреннее хранение EXPR в Perl влияет на поведение выполняемого кода. Например:

  my $v = eval "use utf8; '$expr'";

  Если $expr — это "\xc4\x80" (U+0100 в UTF-8), то значение, хранящееся в $v будет зависеть от того, хранит ли Perl $expr «улучшенным» (см. utf8) или нет:

  • Если улучшенным, $v будет "\xc4\x80" (т. е., use utf8 не имеет эффекта.)

  • Если не улучшенным, $v будет "\x{100}".

  Это нежелательно, так как улучшение или нет не должно влиять на поведение строки.

• Активные в 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 пакете, не видит обычного окружающего лексического пространства, а скорее пространство первой части кода, не связанной с отладкой, которая его вызвала. Вам обычно не нужно беспокоиться об этом, если вы не пишете отладчик 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 опущено) как строку байтов. Если строка содержит какие-либо символы с кодами выше 255, то она не может быть строкой байтов, и evalbytes завершится с ошибкой, хранящейся в $@.

use utf8 и no utf8 внутри строки имеют свой обычный эффект.

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

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

exec LIST

exec PROGRAM LIST

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

Так как использование 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

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

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];

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

Принимая выражение, которое указывает имя подпрограммы, возвращает истинное значение, если указанная подпрограмма была когда-либо объявлена, даже если она не определена. Упоминание имени подпрограммы в 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 ⊂    # 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. Это внутренняя функция, реализующая escape \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, доступные по адресу https://www.unicode.org/versions/latest/, а также таблицы преобразования регистра, доступные по адресу https://www.unicode.org/charts/case/.

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

Эта функция ведет себя одинаково при различных пragma, таких как внутри "use feature 'unicode_strings", как и lc, за исключением fc LATIN CAPITAL LETTER SHARP S (U+1E9E) в области use locale. Преобразование к нижнему регистру этого символа обычно будет "ss", но, как объяснено в разделе lc, изменения регистра, пересекающие границу 255/256, являются проблематичными в контексте локалей и запрещены. Поэтому эта функция в локали возвращает вместо этого строку "\x{17F}\x{17F}", которая является LATIN SMALL LETTER LONG 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 предупреждений Perl об ошибочных числовых преобразованиях.

Обратите внимание, что 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__

Специальный токен, возвращающий имя файла, в котором он встречается. Его можно изменить с помощью механизма, описанного в "Plain Old Comments (Not!)" в perlsyn.

field VARNAME

Объявляет новую переменную поля в текущем классе. Методы и ADJUST блоки класса будут иметь доступ к этой переменной так, как будто это лексическая переменная в области видимости в этот момент.

fileno FILEHANDLE

fileno DIRHANDLE

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

Это в основном полезно для создания битовых карт для select и операций с низким уровнем обработки tty 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 для дескриптора каталога возвращает базовый дескриптор файла, связанный с дескриптором; на системах без такой поддержки возвращается неопределённое значение и устанавливается $! (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 был открыт с намерением записи. Это семантика, которую реализует lockf(3). Большинство, если не все системы, реализуют lockf(3) в терминах блокировки fcntl(2), поэтому различающиеся семантики не должны сильно беспокоить многих пользователей.

Обратите внимание, что эмуляция fcntl(2) для flock(3) требует, чтобы FILEHANDLE был открыт для чтения для использования LOCK_SH и для записи для использования 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(2), уделено большое внимание его высокой эффективности (например, используется технология копирования при изменении страниц данных), что сделало её доминирующей парадигмой многозадачности за последние несколько десятилетий.

Perl пытается сбросить все открытые для вывода файлы перед созданием дочернего процесса, но это может не поддерживаться на некоторых платформах (см. perlport). Для безопасности вам может потребоваться установить $| ($AUTOFLUSH в English) или вызвать метод 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 как одну строку. Поэтому может потребоваться использовать несколько форматирующих строк для реализации формата одного записываемого элемента, как в format компиляторе.

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

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

getc FILEHANDLE

getc

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

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: между v5.8.1 и v5.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

Эти подпрограммы идентичны своим аналогам в системной библиотеке 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 вашей системы. Вы также можете узнать в Perl, что означают ваши поля $quota и $comment и есть ли у вас поле $expire, используя модуль 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 Bash. В скалярном контексте glob итерируется по расширениям имён файлов, возвращая undef, когда список исчерпан. Если EXPR опущено, используется $_.

# List context
my @txt_files  = glob("*.txt");
my @perl_files = glob("*.pl *.pm");

# Scalar context
while (my $file = glob("*.mp3")) {
    # Do stuff
}

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

my @txt_files  = <"*.txt">;

Если вам нужна регистронезависимая обработка файлов glob, этого можно добиться, используя параметр :nocase модуля bsd_glob.

    use File::Glob qw(:globally :nocase);

	my @txt = glob("readme*"); # README readme.txt Readme.md

Обратите внимание, что 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, включая bsd_glob, который не обрабатывает пробелы как разделители шаблонов.

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

Подробности реализации:

Это внутренняя функция, реализующая оператор <*.c>, но вы можете использовать её напрямую. Оператор <*.c> более подробно рассматривается в "I/O Operators" в perlop.

Проблемы портируемости: "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.

Поиск символов или строк:

index("Perl is great", "P");     # Returns 0
index("Perl is great", "g");     # Returns 8
index("Perl is great", "great"); # Also returns 8

Попытка найти то, чего нет:

index("Perl is great", "Z");     # Returns -1 (not found)

Использование смещения для поиска второго вхождения:

index("Perl is great", "e", 5);  # Returns 10

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, который поставляется с набором Perl, который может помочь, но это нетривиальная задача.) 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 возвращает true при успехе и false при неудаче, но вы всё ещё можете легко определить фактическое значение, возвращённое операционной системой:

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 для последовательного возвращения одного и того же порядка. Подробности о том, почему порядок хэша случайный, см. в разделе «Algorithmic Complexity Attacks» в perlsec.

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

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

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 v5.12;	# 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 являются отрицательными, результаты не определены. В будущих версиях может быть выведено предупреждение.

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

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

Дополнительные сведения см. в perlfork.

Если список LIST процессов отсутствует, сигнал не отправляется, и возвращаемое значение равно 0. Этот вариант иногда используется, однако, поскольку он вызывает запуск проверок на наличие загрязнённых данных, если ваш Perl поддерживает такие проверки. Но см. раздел «Laundering and Detecting Tainted Data» в perlsec.

Проблемы переносимости: «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 в нижнем регистре. Если EXPR опущено, используется $_.

my $str = lc("Perl is GREAT"); # "perl is great"

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

Если 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, он выдает предупреждение о локали.

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

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

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

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

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

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

Примечание: Это внутренняя функция, реализующая escape-последовательность \L в двойных кавычках.

my $str = "Perl is \LGREAT\E"; # "Perl is great"

lcfirst EXPR

lcfirst

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

Если 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__

Специальный токен, который компилируется в номер текущей строки. Его можно изменить механизмом, описанным в "Plain Old Comments (Not!)" в perlsyn.

link OLDFILE,NEWFILE

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

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

listen SOCKET,QUEUESIZE

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

local EXPR

На самом деле, вам, вероятно, следует использовать my вместо этого, потому что local не является тем, что большинство людей понимают под "локальным". Подробности см. в "Private Variables via my()" в perlsub.

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

Конструкцию delete local EXPR также можно использовать для локализации удаления элементов массива/хэша в текущий блок. См. "Localized deletion of elements of composite types" в 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 года. Чтобы получить полный год, напишите:

$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"

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

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;

C$now_string> будет отформатирован в соответствии с текущей локалью LC_TIME, в которой работает программа или поток. См. perllocale для настройки и изменения этой локали. Обратите внимание, что %a и %b, краткие формы дня недели и месяца, могут не обязательно иметь ширину в три символа.

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

Для всеобъемлющего представления даты и времени см. модуль DateTime на CPAN.

Для получения GMT вместо местного времени используйте встроенную функцию gmtime.

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

Проблемы переносимости: "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 Quote-Like Operators" в perlop.

map BLOCK LIST

map EXPR,LIST

Вычисляет блок или 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 для списка, составленного из тех элементов исходного списка, для которых блок или выражение оцениваются как истинные.

{ начинает как ссылки на хэши, так и блоки, поэтому 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

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

method NAME BLOCK

method NAME : ATTRS BLOCK

Создает новый именованный метод в области видимости класса, в котором он объявлен. Это допустимо только внутри объявления class.

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

Вызывает функцию System V IPC msgctl(2). Вероятно, вам придётся выполнить

use IPC::SysV;

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

Вопросы переносимости: "msgctl" в perlport.

msgget KEY,FLAGS

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

Вопросы переносимости: "msgget" в perlport.

msgrcv ID,VAR,SIZE,TYPE,FLAGS

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

Вопросы переносимости: "msgrcv" в perlport.

msgsnd ID,MSG,FLAGS

Вызывает функцию System V 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. Если перечисляется более одной переменной, список должен быть помещён в скобки.

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

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

Переопределение переменной в том же объёме или операторе «затеняет» предыдущее объявление, создавая новую экземпляцию и препятствуя доступу к предыдущей. Обычно это нежелательно и, если включены предупреждения, приведёт к появлению предупреждения в категории shadow.

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

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 как строку в восьмеричной системе счисления и возвращает соответствующее значение. Восьмеричная строка состоит из восьмеричных цифр и, начиная с Perl 5.33.5, необязательного префикса 0o или o. Каждая восьмеричная цифра может предваряться одиночным символом нижнего подчеркивания, который будет проигнорирован. (Если EXPR начинается с 0x или x, интерпретируется как шестнадцатеричная строка. Если EXPR начинается с 0b или b, интерпретируется как двоичная строка. Пробелы в начале игнорируются во всех трёх случаях.) Следующее обработает десятичные, двоичные, восьмеричные и шестнадцатеричные значения в стандартной нотации 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,MODE,EXPR

open FILEHANDLE,MODE,EXPR,LIST

open FILEHANDLE,MODE,REFERENCE

open FILEHANDLE,EXPR

open FILEHANDLE

Ассоциирует внутренний FILEHANDLE с внешним файлом, указанным EXPR. Этот файловый дескриптор затем позволит выполнять операции ввода-вывода с этим файлом, такие как чтение из него или запись в него.

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

Подробная справка по open приведена ниже. Для более легкого знакомства с основами open, см. также страницу руководства perlopentut.

Работа с файлами

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

Простые примеры

Чтение из файла:

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

# Process every line in input.txt
while (my $line = readline($fh)) {
    #
    # ... do something interesting with $line here ...
    #
}

или запись в него:

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

print $fh "This line gets printed into output.txt.\n";

Для получения сводки общих операций с файловыми дескрипторами, таких как эти, см. "Файлы и ввод-вывод" в perlintro.

О файловых дескрипторах

Первый аргумент open, обозначенный FILEHANDLE в этом справочнике, обычно является скалярной переменной. (Существуют исключения, описанные в разделе «Другие соображения» ниже.) Если вызов open успешен, то выражение, предоставленное в качестве FILEHANDLE, получит присвоенный открытый файловый дескриптор. Этот файловый дескриптор предоставляет внутреннюю ссылку на указанный внешний файл, удобно хранящийся в переменной Perl, и готовый к операциям ввода-вывода, таким как чтение и запись.

О режимах

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

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

Если MODE равен >>, файл открывается для добавления, снова создаётся, если необходимо.

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

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

Дополнительные примеры различных режимов в действии:

# Open a file for concatenation
open(my $log, ">>", "/usr/spool/news/twitlog")
    or warn "Couldn't open log file; discarding input";

# Open a file for reading and writing
open(my $dbase, "+<", "dbase.mine")
    or die "Can't open 'dbase.mine' for update: $!";

Проверка возвращаемого значения

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

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

Указание слоев ввода-вывода в MODE

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

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

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

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

Использование undef для временных файлов

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

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

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

Открытие файлового дескриптора в скаляр памяти

Вы можете открыть файловые дескрипторы непосредственно к скалярам Perl вместо файла или другого ресурса, внешнего для программы. Для этого передайте ссылку на этот скаляр в качестве третьего аргумента open, как показано ниже:

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

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

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

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

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

Технические примечание: Эта функция работает только при компиляции Perl с PerlIO — по умолчанию, за исключением устаревших (до 5.16) установок Perl, которые были сконфигурированы так, чтобы не включать его (например, с помощью Configure -Uuseperlio). Вы можете узнать, была ли ваша версия Perl скомпилирована с PerlIO, выполнив perl -V:useperlio. Если вывод будет 'define', у вас есть PerlIO; в противном случае нет.

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

Открытие файлового дескриптора в команду

Если MODE равен |-, то имя файла интерпретируется как команда, для которой нужно перенаправить вывод, а если MODE равен -|, то имя файла интерпретируется как команда, которая перенаправляет вывод к нам. В форме с двумя (и одним) аргументом следует заменить дефис (-) на команду. См. "Использование open() для IPC" в perlipc для получения дополнительных примеров этого. (Вам не разрешено open в команду, которая перенаправляет как вход, так и вывод, но см. IPC::Open2, IPC::Open3, и "Взаимодействие с другим процессом" в perlipc для альтернатив.)

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: $!";

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

Если вы открываете трубу для команды - (то есть, указываете либо |- или -| с одно- или двухаргументными формами 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, такой как Linux и macOS, вы можете использовать формат списка; он также работает в Windows с Perl 5.22 или более поздними версиями.) Вы захотите использовать список форм трубы, чтобы вы могли передавать буквальные аргументы команде, не рискуя тем, что оболочка интерпретирует какие-либо метасимволы оболочки в них. Однако это также лишает вас возможности открывать трубы для команд, которые намеренно содержат метасимволы оболочки, такие как:

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

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

Дублирование файловых дескрипторов

Вы также можете, следуя традиции 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-библиотеку fdopen(3) для реализации функциональности =. Во многих Unix-системах fdopen(3) завершается неудачей, когда дескрипторы файлов превышают определенное значение, обычно 255. Для Perl 5.8.0 и более поздних версий PerlIO является (чаще всего) значением по умолчанию.

Использование устаревших приёмов

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

Указание режима и имени файла как одного аргумента

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

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

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

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

Вызов open с одним аргументом через глобальные переменные

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

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

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

Присваивание дескриптора файла "головому слову"

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

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

Тогда вы можете использовать FH в качестве дескриптора файла, в close FH и <FH> и так далее. Обратите внимание, что это глобальная переменная, поэтому эта форма не рекомендуется при работе с дескрипторами файлов, отличными от встроенных в Perl (например, STDOUT и STDIN). На самом деле, использование "голого слова" в качестве дескриптора файла является ошибкой, когда функция bareword_filehandles отключена. Эта функция отключена по умолчанию в области действия use v5.36.0 и более поздних версий.

Другие соображения

Автоматическое закрытие дескриптора файла

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

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

Автоматическая очистка канала

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

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

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

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

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

Пробелы и специальные символы в аргументе имени файла

Имя файла, переданное в одно- и двухаргументные формы 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 ), который создаёт имя файла, которое можно открыть нормально.)

Вызов функции open в стиле C

Если вам нужен "настоящий" 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 для получения более подробной информации об Unicode.

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 v5.36;  # which implies "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 v5.36;

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

print $Foo::foo; # prints 23

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

package Foo;
use v5.36;

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 связан с использованием псевдонима fields, а атрибуты обрабатываются с помощью псевдонима attributes или, начиная с Perl 5.8.0, также через модуль Attribute::Handlers. Подробности см. в разделе "Переменные-только-для-пакета с помощью my()" в perlsub.

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

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

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

pack TEMPLATE,LIST

Принимает СПИСОК значений и преобразует его в строку, используя правила, заданные ШАБЛОНОМ. Результирующая строка — это конкатенация преобразованных значений. Обычно каждое преобразованное значение выглядит как его представление на уровне машины. Например, на 32-битных машинах целое число может быть представлено последовательностью из 4 байтов, которая в Perl будет представлена строкой длиной 4 символа.

См. perlpacktut для введения в эту функцию.

ШАБЛОН — это последовательность символов, определяющая порядок и тип значений, как следует:

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. 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.  Also on EBCDIC platforms, the character number will
   be the native EBCDIC value for character numbers below 256.
   This allows most programs using this feature to not have to
   care which type of platform they are running on.

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.

Один или несколько модификаторов ниже могут необязательно следовать за определёнными буквами в ШАБЛОНЕ (во второй колонке указаны буквы, для которых модификатор допустим):

!   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 всегда упаковывает конечный нулевой байт, за исключением случая, когда количество равно 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") long.

  Для каждого такого формата 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-endian или little-endian. Попытка сделать это вызывает исключение.

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

  Для pack вы пишете длина-элемент/последовательность-элемент, и длина-элемент описывает, как упаковывается значение длины. Форматы, которые, скорее всего, будут полезны, — это форматы для упаковки целых чисел, такие как n для строк Java, w для ASN.1 или SNMP и N для Sun XDR.

  Для pack, последовательность-элемент может иметь количество повторений, в этом случае минимум из этого и количества доступных элементов используется в качестве аргумента для длина-элемент. Если у него нет количества повторений или он использует "*", используется количество доступных элементов.

  Для unpack используется внутренний стек целых аргументов, которые были распакованы до сих пор. Вы пишете /последовательность-элемент, и количество повторений получается путём извлечения последнего элемента из стека. Последовательность-элемент не должен иметь количество повторений.

  Если последовательность-элемент относится к типу строки ("A", "a", или "Z"), то длина-элемент — это длина строки, а не количество строк. При явном количестве повторений для упаковки упакованная строка корректируется до этой длины. Например:

  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"

  длина-элемент не возвращается явно из unpack.

  Предоставление счётчика формату длина-элемент полезно только с A, a, или Z. Упаковка с длина-элементом 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 являются комическими отсылками к привычкам поедания яиц у лиллипутианцев из little-endian и blefuscudianцев из big-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, есть различия, особенно если задействованы длинные типы с плавающей запятой. Вы можете увидеть переменные Config doublekind и longdblkind (также doublesize, longdblsize) : значения «типа» — это перечисления, в отличие от byteorder.

  С точки зрения переносимости лучшим вариантом, вероятно, является использование 64-битных чисел с плавающей запятой IEEE 754 с согласованной эндианностью. Другой вариант — формат "%a") printf.

• Начиная с Perl 5.10.0, целочисленные и вещественные форматы, вместе с форматами p и P и группами (), могут быть дополнены модификаторами эндианности > или <, чтобы соответственно установить порядок байтов big-endian или little-endian. Эти модификаторы особенно полезны, учитывая, что n, N, v, и V не охватывают знакомые целые числа, 64-битные целые числа или числа с плавающей запятой.

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

  • Обмен знаковыми целыми числами между различными платформами работает только тогда, когда все платформы хранят их в одном формате. Большинство платформ хранят знакомые целые числа в представлении в дополнительном коде, поэтому обычно это не проблема.

  • Модификаторы > или < могут использоваться только для чисел с плавающей запятой на машинах big-endian или little-endian. В противном случае попытка их использования вызовет исключение.

  • Принудительное использование big-endian или little-endian порядка байтов для чисел с плавающей запятой при обмене данными может сработать только если все платформы используют одно и то же двоичное представление, например, IEEE числа с плавающей запятой. Даже если все платформы используют IEEE, могут существовать небольшие различия. Возможность использования > или < для чисел с плавающей запятой может быть полезной, но также и опасной, если вы точно не знаете, что делаете. Это не универсальный способ переносимого хранения чисел с плавающей запятой.

  • При использовании > или < в группе (), это влияет на все типы внутри группы, которые принимают модификаторы порядка байтов, включая все подгруппы. Для всех других типов это игнорируется. Вам не разрешается переопределять порядок байтов внутри группы, которая уже имеет суффикс модификатора порядка байтов.

• Вещественные числа (числа с плавающей запятой и двойной точности) находятся только в родном формате машины. Из-за множественности форматов чисел с плавающей запятой и отсутствия стандартного «сетевого» представления для них не было создано никаких средств обмена. Это означает, что упакованные данные с плавающей запятой, записанные на одной машине, могут быть нечитаемыми на другой, даже если обе используют арифметику чисел с плавающей запятой IEEE (потому что порядок байтов представления в памяти не входит в спецификацию IEEE). См. также perlport.

  Если вы точно знаете, что делаете, вы можете использовать модификаторы > или < для принудительного задания порядка байтов big-endian или little-endian для чисел с плавающей запятой.

  Поскольку Perl использует числа двойной точности (или длинной двойной точности, если настроено) во всех числовых вычислениях, преобразование из числа двойной точности в число с одинарной точностью и обратно теряет точность, поэтому unpack("f", pack("f", $foo)) вообще не будет равно $foo.

• Функции pack и unpack могут работать в двух режимах: режим символов (C0 режим), где упакованная строка обрабатывается по символам, и режим байтов UTF-8 (U0 режим), где упакованная строка обрабатывается в её UTF-8-кодированной форме Юникода на основе байта за байтом. Режим символов является по умолчанию, если строка формата не начинается с U. Вы всегда можете переключить режим в процессе формирования с явным C0 или U0 в формате. Этот режим остаётся активным до следующего изменения режима или до конца группы (), к которой он (непосредственно) применяется.

  Использование C0 для получения символов Юникода при использовании U0 для получения не-Юникод байтов не обязательно очевидно. Вероятно, только первое из этих действий вам нужно:

  $ 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, также через символ шаблона /. В каждом повторении группы позиционирование с @ начинается с нуля. Следовательно, результатом

  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]. Это предполагает, что числа двойной точности должны быть выровнены по размеру числа двойной точности.

  Для команд выравнивания count значения 0 эквивалентно count значению 1; оба являются операциями-бездействиями.

• n, N, v и V принимают модификатор ! для представления знакомых 16-/32-битных целых чисел в big-/little-endian порядке. Это переносимо только тогда, когда все платформы, обменивающиеся упакованными данными, используют одно и то же двоичное представление для знакомых целых чисел; например, когда все платформы используют представление в дополнительном коде.

• Комментарии могут быть встроены в шаблон с помощью # до конца строки. Пробелы могут отделять коды pack друг от друга, но модификаторы и счётчики повторений должны следовать непосредственно за ними. Разбиение сложных шаблонов на отдельные компоненты по строкам, должным образом аннотированные, может улучшить удобочитаемость и поддерживаемость форматов pack/unpack так же, как /x может улучшить сложные совпадения шаблонов.

• Если шаблон требует больше аргументов, чем предоставлено в pack, pack предполагает дополнительные аргументы "". Если шаблон требует меньше аргументов, чем предоставлено, дополнительные аргументы игнорируются.

• Попытка упаковки специальных значений чисел с плавающей запятой 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

Удаляет и возвращает последний элемент массива, укорачивая массив на один элемент.

my @arr  = ('cat', 'dog', 'mouse');
my $item = pop(@arr); # 'mouse'

# @arr is now ('cat', 'dog')

Возвращает undef если массив пуст.

Примечание: pop также может вернуть undef если последний элемент массива undef.

my @arr  = ('one', 'two', undef);
my $item = pop(@arr); # undef

Если ARRAY опущен, pop работает с массивом @ARGV в основной программе, но с массивом @_ в подпрограммах. pop будет работать с массивом @ARGV в eval STRING, BEGIN {}, INIT {}, CHECK {} блоках.

Начиная с 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.

Текущее значение $, (если есть) выводится между каждым элементом списка. Текущее значение $\ (если есть) выводится после вывода всего списка. Так как print принимает список, всё в списке вычисляется в контексте списка, включая подпрограммы, списки возвращений которых вы передаёте в 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), за исключением того, что $\ (разделитель записей вывода) не добавляется. Формат и список фактически анализируются как единый список. Первый аргумент списка будет интерпретирован как формат printf. Это означает, что printf(@_) будет использовать $_[0] в качестве формата. См. sprintf для объяснения аргумента формата. Если use locale (включая use locale ':not_characters') активен и POSIX::setlocale был вызван, символ, используемый для разделителя десятичных знаков в форматированных числах с плавающей запятой, зависит от настройки локали LC_NUMERIC locale. См. 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

Добавляет один или несколько элементов в конец массива.

my @animals = ("cat");
push(@animals, "mouse"); # ("cat", "mouse")

my @colors = ("red");
push(@colors, ("blue", "green")); # ("red", "blue", "green")

Возвращает количество элементов в массиве после завершения push.

my $color_count = push(@colors, ("yellow", "purple"));

say "There are $color_count colors in the updated array";

Начиная с 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]/, будут предваряться обратной косой чертой в возвращаемой строке независимо от настроек локали.) Это внутренняя функция, реализующая escape-последовательность \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 должны использоваться.

Следует быть осторожным, если вы помещаете литерные обратные косые черты (не внутри интерполированных переменных) между \Q и \E, интерполяция обратных косых черт в стиле двойных кавычек может привести к непонятным результатам. Если вам необходимо использовать литерные обратные косые черты внутри \Q...\E, обратитесь к "Gory details of parsing quoted constructs" в perlop.

Поскольку результат "\Q STRING \E" содержит все метасимволы, помеченные, нет способа вставить литерный символ $ или @ внутри пары \Q\E. Если защищен \, $ будет помечен, превратившись в "\\\$"; в противном случае он интерпретируется как начало интерполированного скаляра.

В Perl v5.14 все символы, не входящие в ASCII, помечены в строках, не закодированных в UTF-8, но не помечены в строках UTF-8.

Начиная с Perl v5.16, Perl принял стратегию кодирования символов, не входящих в Unicode, кодирование символов ASCII осталось без изменений.

Также без изменений осталось кодирование строк, не закодированных в UTF-8, вне области действия use feature 'unicode_strings', а именно — кодирование всех символов в диапазоне верхнего латинского 1. Это обеспечивает полную обратную совместимость со старыми программами, не использующими Unicode. (Обратите внимание, что unicode_strings автоматически включен в области действия use v5.12 или выше.)

В области действия use locale все символы, не входящие в ASCII Latin1, помечены, независимо от того, закодирована ли строка в UTF-8 или нет. Как упоминалось выше, локализация не влияет на кодирование символов в диапазоне ASCII. Это защищает от тех локализации, где символы, такие как "|" считаются "словными" символами.

В противном случае Perl помещает символы, не входящие в ASCII, используя адаптацию из Unicode (см. https://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) через уровни PerlIO, применённые к файловому дескриптору. Чтобы получить истинный вызов системной функции read(2), см. sysread.

Обратите внимание на символы: в зависимости от состояния файлового дескриптора, считываются байты (8-битные) или символы. По умолчанию все файловые дескрипторы работают с байтами, но, например, если файловый дескриптор открыт с :utf8 слоем ввода-вывода (см. open и open прагму), ввод-вывод будет работать с закодированными в UTF-8 символами Unicode, а не с байтами. Аналогично для :encoding слоя: в этом случае можно прочитать практически любые символы.

readdir DIRHANDLE

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

Если вы планируете использовать 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 v5.12; # so readdir assigns to $_ in a lone while test

readline EXPR

readline

Читает из файлового дескриптора, чья typeglob содержится в EXPR (или из *ARGV, если EXPR не указан). В скалярном контексте каждый вызов читает и возвращает следующую строку до достижения конца файла, после чего последующий вызов возвращает undef. В контексте списка читает до конца файла и возвращает список строк. Обратите внимание, что понятие «строка» здесь определяется тем, что вы определили с помощью $/ (или $INPUT_RECORD_SEPARATOR в English). См. "$/" в 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

Возвращает значение символической ссылки, если символические ссылки реализованы. Если нет, генерирует исключение. Если возникает системная ошибка, возвращает значение undefined и устанавливает $! (errno). Если EXPR опущено, используется $_.

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

readpipe EXPR

readpipe

EXPR выполняется как системная команда. Собраный стандартный вывод команды возвращается. В скалярном контексте он возвращается как одна (возможно, многострочная) строка. В контексте списка возвращает список строк (как вы определили строки с $/ (или $INPUT_RECORD_SEPARATOR в English)). Это внутренняя функция, реализующая оператор qx/EXPR/, но вы можете использовать её напрямую. Оператор qx/EXPR/ подробнее описан в "qx/STRING/" в perlop. Если EXPR опущено, используется $_.

recv SOCKET,SCALAR,LENGTH,FLAGS

Принимает сообщение по сокету. Попытка принять LENGTH символов данных в переменную SCALAR из указанного файлового дескриптора SOCKET. SCALAR будет увеличен или уменьшен до длины, фактически прочитанной. Принимает те же флаги, что и системный вызов с таким же именем. Возвращает адрес отправителя, если протокол SOCKET это поддерживает; в противном случае возвращает пустую строку. При ошибке возвращает значение undefined. Этот вызов фактически реализован в терминах системного вызова 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 для проверки принадлежности к классу, но убедитесь в освящении перед выполнением вызова метода. В качестве альтернативы, оператор 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";
    }

    local $INC;
    # this type of loop lets a hook overwrite $INC if they wish
    for($INC = 0; $INC < @INC; $INC++) {
        my $prefix = $INC[$INC];
        if (!defined $prefix) {
            next;
        }
        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;, на случай, если вы добавите больше инструкций. Начиная с версии 5.37.6, это требование может быть избегнуто, включив функцию 'module_true', которая по умолчанию включена в современных сборках. Таким образом, код с use v5.37; больше не нуждается в решении этой проблемы. Смотрите feature для получения дополнительных подробностей. Обратите внимание, что это затрагивает единицу компиляции, в которой используется функция, и использование её до требования модуля не изменит поведение существующих модулей, которые её сами не используют.

Если EXPR является именованным символом, require предполагает расширение .pm и заменяет :: на / в имени файла для вас, чтобы облегчить загрузку стандартных модулей. Этот способ загрузки модулей не рискует изменить ваше пространство имён, однако он автоматически инициализирует хранилище (stash) для требуемого модуля.

Другими словами, если вы попробуете это:

require Foo::Bar;     # a splendid bareword

Функция require фактически будет искать файл Foo/Bar.pm в каталогах, указанных в массиве @INC, и она автоматически инициализирует хранилище (stash) 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 и крючки INCDIR, и есть три формы представления крючка: ссылки на подпрограммы, ссылки на массивы и освящённые объекты.

Ссылки на подпрограммы — это самый простой случай. Когда система включения проходит по @INC и сталкивается с подпрограммой, если эта подпрограмма не освящена и не поддерживает крючок INCDIR, эта подпрограмма будет считаться крючком INC и будет вызвана с двумя параметрами: первым — ссылкой на себя, а вторым — именем файла для включения (например, Foo/Bar.pm). Подпрограмма должна вернуть либо ничего, либо список до четырёх значений в следующем порядке:

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

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

3. Ссылка на подпрограмму. Если нет дескриптора файла (предыдущий пункт), то ожидается, что эта подпрограмма сгенерирует одну строку исходного кода на вызов, запишет строку в $_ и вернёт 1, а затем в конце файла вернёт 0. Если есть дескриптор файла, подпрограмма будет вызвана для работы как простой фильтра исходного кода, со строкой, прочитанной из $_. Снова, возвращайте 1 для каждой корректной строки и 0 после возвращения всех строк. По историческим причинам подпрограмма получит бессмысленный аргумент (на самом деле всегда числовое значение ноль) как $_[0].

4. Необязательное состояние для подпрограммы. Состояние передаётся как $_[1].

AUTOLOAD не может быть использован для разрешения метода INCDIR, INC проверяется первой, и AUTOLOAD бы разрешил это.

Если возвращается пустой список, undef или ничего, что соответствует первым 3 значениям выше, то require обращается к остальным элементам массива @INC. Обратите внимание, что этот дескриптор файла должен быть реальным дескриптором файла (строго говоря, typeglob или ссылка на typeglob, будь то освящённый или неосвящённый); связанные дескрипторы файлов будут игнорироваться, и обработка остановится на этом.

Если крючок является объектом, он должен предоставить метод INC или INCDIR, который будет вызван как описано выше, первым параметром которого будет сам объект. Если он не предоставляет ни одного метода, и объект не является ссылкой на код, будет выброшено исключение, в противном случае он будет просто выполнен как неосвящённая ссылка на код. Обратите внимание, что имя метода необходимо указывать полностью, когда вы объявляете подпрограмму INC (в отличие от подпрограммы INCDIR), так как неопределённый символ INC всегда принудительно помещается в пакет main. Вот типичная структура кода для крючка INC:

# In Foo.pm
package Foo;
sub new { ... }
sub Foo::INC {
    my ($self, $filename) = @_;
    ...
}

# In the main program
push @INC, Foo->new(...);

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

Другими словами, вы можете написать:

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;
    ...
}

или:

push @INC, [ HookObj->new(), $x, $y, ... ];
sub HookObj::INC {
    my ($self, $filename, $arrayref)= @_;
    my (undef, @parameters) = @$arrayref;
    ...
}

Эти крючки также могут установить запись %INC соответствующую загруженным файлам. Смотрите "%INC" в perlvar. Если крючок INC не выполняет это, Perl установит запись %INC в саму ссылку на крючок.

Крючок также может быть использован для перезаписи массива @INC. Хотя это может показаться странным, в некоторых ситуациях это может быть очень полезно. Такие крючки обычно просто возвращают undef и не смешивают фильтрацию и изменения @INC. Хотя в более старых версиях Perl имело место изменение крючка @INC с проблемами и даже могло привести к сбою или утверждению, начиная с 5.37.7, логика стала гораздо более надёжной, и теперь крючок может управлять итерацией цикла, если он этого пожелает.

Теперь есть возможность управлять итератором для обхода массива @INC, который выполняется во время require. Переменная $INC будет инициализирована с индексом текущего выполняемого крючка. После возврата крючка, следующая ячейка в массиве @INC, которая будет проверена, будет целочисленным преемником значения в $INC (или -1, если оно undef).

Например, следующий код

push @INC, sub {
    splice @INC, $INC, 1; # remove this hook from @INC
    unshift @INC, sub { warn "A" };
    undef $INC; # reset the $INC iterator so we
                # execute the newly installed sub
                # immediately.
};

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

До версии 5.37.7 не было способа заставить Perl немедленно использовать недавно установленный крючок или проверить любые изменённые элементы в массиве @INC слева от итератора, поэтому предупреждение генерировалось только при втором вызове require. В более новых версиях Perl наличие последней инструкции, которая делает $INC undef, заставит Perl перезапустить обход массива @INC с самого начала и немедленно выполнить новую установленную подпрограмму.

Любое значение, которое $INC содержало, если таковое имелось, будет восстановлено в конце require. Любые изменения, внесённые в $INC в течение жизни крючка, будут отменены после выхода крючка, и его значение имеет смысл только сразу после выполнения крючка, поэтому установка значения $INC до выполнения крючка require не повлияет на выполнение require вообще.

Начиная с 5.37.7 значения @INC undef будут молча игнорироваться.

Функция require() трудно оборачивается должным образом. Многие модули обращаются к стеку, чтобы найти информацию о своём вызывающем объекте, а вставка новой кадра стека путём обертывания require() часто ломает вещи. Тем не менее, это может быть очень полезно, чтобы иметь возможность выполнять действия до и после require, например, для средств отслеживания, таких как Devel::TraceUse, или для измерения времени загрузки и потребления памяти графом require. Из-за трудностей с безопасным созданием оболочки require() в 5.37.10 мы ввели новый механизм.

Начиная с 5.37.10, перед любыми другими действиями require проверяет, содержит ли ${^HOOK}{require__before} ссылку на код, и если да, вызывается с именем файла загружаемого элемента. Крючок может изменить $_[0] для загрузки другого имени файла или выбросить фатальную ошибку, чтобы вызвать сбой require, который будет обрабатываться так, как если бы сам требуемый код выбросил исключение.

Раздел ${^HOOK}{require__before} может вернуть ссылку на код, в этом случае ссылка на код будет выполнена (в eval с файлом в качестве параметра) после завершения require. Он будет выполнен независимо от того, как завершилась компиляция, и даже если require выбросил фатальную ошибку. Функция может обратиться к %INC, чтобы определить, произошла ли ошибка в require или нет. Например, следующий код выведет некоторые диагностические сообщения перед и после каждой require инструкции. Пример также включает логику для цепочки сигналов, чтобы несколько сигналов могли сотрудничать. Корректные обработчики ${^HOOK}{require__before} всегда должны учитывать это.

{
    use Scalar::Util qw(reftype);
    my $old_hook = ${^HOOK}{require__before};
    local ${^HOOK}{require__before} = sub {
        my ($name) = @_;
        my $old_hook_ret;
        $old_hook_ret = $old_hook->($name) if $old_hook;
        warn "Requiring: $name\n";
        return sub {
            $old_hook_ret->() if ref($old_hook_ret)
                              && reftype($old_hook_ret) eq "CODE";
            warn sprintf "Finished requiring %s: %s\n",
                    $name, $INC{$name} ? "loaded" :"failed";
        };
    };
    require Whatever;
}

Этот обработчик выполняется для ВСЕХ require инструкций, в отличие от INC и INCDIR обработчиков, которые выполняются только для относительных имён файлов, и он выполняется первым до любого другого специального поведения внутри require. Обратите внимание, что начальный обработчик в ${^HOOK}{require__before} *не* выполняется внутри eval, а выброс исключения остановит дальнейшую обработку, но обработчик после возврата может быть выполнен внутри eval, и любые исключения, которые он выбросит, будут молча проигнорированы. Это происходит потому, что он выполняется в рамках логики очистки области видимости, которая запускается после завершения require, и исключение в этот момент не остановит загрузку модуля и т. д.

Существует аналогичный обработчик, который запускается после завершения require, ${^HOOK}{require__after}, который будет вызываться после завершения каждой инструкции require, либо через исключение, либо успешно. Он будет вызываться с именем файла последней выполненной инструкции require. Он выполняется в eval и никоим образом не повлияет на выполнение.

Для ещё более мощной системы импорта, построенной вокруг require, см. 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 или do BLOCK) со значением, указанным в 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" in 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" in perlop.

say FILEHANDLE LIST

say FILEHANDLE

say LIST

say

Точно так же, как print, но неявно добавляет перевод строки в конце LIST вместо любого значения, которое $\ мог бы иметь. Чтобы использовать FILEHANDLE без LIST для вывода содержимого $_ в него, необходимо использовать простое имя файла, например, FH, а не косвенное, например, $fh.

say доступен только если функция "say" включена или если она префикс CORE::. Функция "say" включается автоматически с инструкцией 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 или say без файлового дескриптора по умолчанию используют этот 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 для временного "захвата" вывода print вот так:

{
    my $old_handle = select $new_handle;

    # This goes to $new_handle:
    print "ok 1\n";
    ...

    select $old_handle;
}

Вам может быть проще локально изменить typeglob вместо этого:

{
    local *STDOUT = $new_handle;

    print "ok 1\n";
    ...
}

Эти два варианта не совсем эквивалентны, но последний может быть более понятным и восстановит STDOUT, если обернутый код завершится ошибкой. Разница в том, что в первом случае исходный STDOUT всё ещё доступен, если его явно использовать в print операторе (как print STDOUT ...), тогда как во втором случае само значение файлового дескриптора STDOUT временно изменяется.

Проблемы переносимости: "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 и устанавливает $!.

На некоторых Unix-системах 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 semctl(2). Вероятно, вам нужно будет сказать

use IPC::SysV;

сначала, чтобы получить правильные определения констант. Если CMD равен IPC_STAT или GETALL, то ARG должен быть переменной, которая будет содержать возвращаемую структуру semid_ds или массив значений семафоров. Возвращает, как и ioctl: неопределённое значение при ошибке, "0 but true" для нуля или фактическое возвращаемое значение в противном случае. ARG должен состоять из вектора целых чисел типа short, которые можно создать с помощью pack("s!",(0)x$nsem). Смотрите также "SysV IPC" в perlipc и документацию для IPC::SysV и IPC::Semaphore.

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

semget KEY,NSEMS,FLAGS

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

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

semop KEY,OPSTRING

Вызывает системную функцию 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

Удаляет и возвращает первый элемент массива. Массив уменьшается на один элемент, а все остальные элементы сдвигаются вниз.

my @arr  = ('cat', 'dog');
my $item = shift(@arr); # 'cat'

# @arr is now ('dog');

Возвращает undef если массив пуст.

Примечание: shift может также вернуть undef если первый элемент массива undef.

my @arr  = (undef, 'two', 'three');
my $item = shift(@arr); # undef

Если ARRAY опущен, shift работает с массивом @ARGV в основной программе и массивом @_ в подпрограммах. shift будет работать с массивом @ARGV в eval STRING, BEGIN {}, INIT {}, CHECK {} блоках.

Начиная с 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

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

Возвращает 1 для успеха; при ошибке возвращает undef, если первый аргумент не является допустимым дескриптором файла, или возвращает 0 и устанавливает $! для любой другой ошибки.

sin EXPR

sin

Возвращает синус EXPR (выраженный в радианах). Если EXPR опущен, возвращает синус $_.

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

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

sleep EXPR

sleep

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

EXPR должен быть положительным целым числом. Если вызван с отрицательным целым числом, sleep не спит, но вместо этого выводит предупреждение, устанавливает $! (errno) и возвращает ноль.

Если вызван с нецелым числом, дробная часть игнорируется.

sleep 0 разрешено, но вызов реализации платформы всё ещё происходит, с любыми побочными эффектами, которые могут быть. sleep 0 поэтому не точно идентичен полному отсутствию сна.

Может быть прерван, если процесс получает сигнал, такой как 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: Клиент/Серверное общение" в 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

В контексте списка функция сортирует СПИСОК и возвращает отсортированный список значений. В скалярном контексте поведение 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 сортирует СПИСОК в соответствии с текущим языковым стандартом сортировки. См. 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;

## using a prototype with function signature
use feature 'signatures';
sub function_with_signature :prototype($$) ($one, $two) {
    return $one <=> $two
}

my @new = sort function_with_signature @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

При надлежащем уходе вы можете смешивать пакетные и мои (или 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;

В этой версии perl функция sort реализована с помощью алгоритма слияния.

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 выдает предупреждение и выполняет срез в конце массива.

Следующие эквивалентности выполняются (предполагая $#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 разделяется в позиции совпадения (между символами). Например, следующее:

my @x = split(/b/, "abc"); # ("a", "c")

использует b в 'abc' в качестве разделителя, чтобы получить список ("a", "c"). Однако, это:

my @x = split(//, "abc"); # ("a", "b", "c")

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

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

Если PATTERN равен /^/, то он обрабатывается так, как будто использует модификатор многострочности (/^/m), так как в противном случае он мало пригоден.

/m и любые другие модификаторы шаблонов, допустимые для qr (подробно описанные в "qr/STRING/msixpodualn" в perlop) могут быть явно указаны.

В качестве еще одного специального случая split эмулирует стандартное поведение командной утилиты awk, когда PATTERN отсутствует или является строкой, состоящей из одного пробела (например, ' ' или "\x20", но не, например, / /). В этом случае любые начальные пробелы в EXPR удаляются перед разделением, а PATTERN вместо этого обрабатывается так, как будто он был /\s+/; в частности, это означает, что любые последовательные пробелы (а не только один пробел) используются в качестве разделителей.

my @x = split(" ", "  Quick brown fox\n");
# ("Quick", "brown", "fox")

my @x = split(" ", "RED\tGREEN\tBLUE");
# ("RED", "GREEN", "BLUE")

Использование split таким образом очень похоже на то, как работает qw//.

Однако, это специальное обращение можно избежать, указав шаблон / / вместо строки " ", тем самым разрешая в качестве разделителя только один пробел. В более ранних версиях 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). Например:

my @x = split(//, "abc", 1); # ("abc")
my @x = split(//, "abc", 2); # ("a", "bc")
my @x = split(//, "abc", 3); # ("a", "b", "c")
my @x = split(//, "abc", 4); # ("a", "b", "c")

Если LIMIT отрицательный, он обрабатывается так, как будто он был произвольно большим; производится как можно больше полей.

Если LIMIT опущен (или равен нулю), то он обычно обрабатывается так, как будто он был отрицательным, но с исключением, что trailing пустые поля удаляются (leading пустые поля всегда сохраняются); если все поля пустые, то все поля считаются trailing (и удаляются в этом случае). Таким образом, следующее:

my @x = split(/,/, "a,b,c,,,"); # ("a", "b", "c")

возвращает только список из трех элементов.

my @x = split(/,/, "a,b,c,,,", -1); # ("a", "b", "c", "", "", "")

возвращает список из шести элементов.

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

my ($login, $passwd) = split(/:/);

Обратите внимание, что разделение EXPR, равного пустой строке, всегда приводит к нулю полей, независимо от указанного LIMIT.

Пустое leading поле создается, когда есть совпадение положительной ширины в начале EXPR. Например:

my @x = split(/ /, " abc"); # ("", "abc")

разделяется на два элемента. Однако, совпадение нулевой ширины в начале EXPR никогда не создает пустое поле, поэтому:

my @x = split(//, " abc"); # (" ", "a", "b", "c")

разделяется на четыре элемента вместо пяти.

Пустое trailing поле, с другой стороны, создается, когда есть совпадение в конце EXPR, независимо от длины совпадения (конечно, если не задан ненулевой LIMIT, такие поля удаляются, как в последнем примере). Таким образом:

my @x = split(//, " abc", -1); # (" ", "a", "b", "c", "")

Если PATTERN содержит группы захвата, то для каждого разделителя создается дополнительное поле для каждой подстроки, захваченной группой (в порядке указания групп, как в обратных ссылках); если какая-либо группа не соответствует, то она захватывает значение undef вместо подстроки. Также обратите внимание, что любое такое дополнительное поле создается всякий раз, когда есть разделитель (то есть, когда происходит разделение), и такое дополнительное поле не учитывается в LIMIT. Рассмотрим следующие выражения, вычисленные в контексте списка (каждый возвращаемый список представлен в соответствующем комментарии):

my @x = split(/-|,/    , "1-10,20", 3);
# ("1", "10", "20")

my @x = split(/(-|,)/  , "1-10,20", 3);
# ("1", "-", "10", ",", "20")

my @x = split(/-|(,)/  , "1-10,20", 3);
# ("1", undef, "10", ",", "20")

my @x = split(/(-)|,/  , "1-10,20", 3);
# ("1", "-", "10", undef, "20")

my @x = 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 на десять в степени 99 может быть представлено как "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 types "size_t" or
            "ssize_t" on Perl 5.14 or later

Обратите внимание, что в общем случае использование модификатора l (например, при написании "%ld" или "%lu" вместо "%d" и "%u") не требуется при использовании из кода Perl. Более того, это может быть вредно, например, в 64-битной Windows, где long составляет 32 бита.

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

use warnings FATAL => "printf";

Если вы хотите узнать о зависимости от версии до начала выполнения программы, поместите что-то вроде этого в её начало:

use v5.14;  # for hh/j/t/z/ printf modifiers

Вы можете узнать, поддерживает ли ваш Perl quads, с помощью 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 double и double — одно и то же:

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 v5.14;	# so srand returns the seed

Если srand не вызывается явно, она вызывается неявно без параметра при первом использовании оператора rand. Однако есть несколько ситуаций, в которых программы могут захотеть вызвать srand. Одна из них — для генерации предсказуемых результатов, обычно для тестирования или отладки. В этом случае вы используете srand($seed), с тем же $seed каждый раз. Другой случай — вы можете вызвать srand после fork, чтобы избежать совместного использования дочерними процессами того же значения начального значения, что и родительским (и, следовательно, друг с другом).

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

Большинство реализаций srand принимают целое число и молча обрезают десятичные числа. Это означает, что srand(42) обычно дает те же результаты, что и srand(42.1). Для безопасности всегда передавайте srand целое число.

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

Если переменная среды PERL_RAND_SEED установлена в неотрицательное целое число во время запуска процесса, то вызовы srand() без аргументов инициализируют генератор случайных чисел Perl с постоянным начальным значением каждый раз, когда он вызывается, независимо от того, вызывается ли он явно без аргументов или неявно через использование rand(). Точное начальное значение, которое произведёт данный PERL_RAND_SEED, преднамеренно не специфицируется, но использование разных значений для PERL_RAND_SEED должно давать разные результаты. Это предназначено для отладки и анализа производительности и гарантирует согласованные результаты между вызовами одной и той же исполняемой программы Perl, выполняющей один и тот же код, когда все остальные факторы одинаковы. Переменная среды читается только один раз во время запуска процесса, а изменение её во время выполнения программы не повлияет на текущий запущенный процесс. Более подробную информацию см. в perlrun.

rand не является криптографически безопасным. Не следует полагаться на него в ситуациях, чувствительных к безопасности. На момент написания этого текста ряд сторонних модулей CPAN предлагают генераторы случайных чисел, которые по мнению их авторов, являются криптографически безопасными, включая: Data::Entropy, Crypt::Random, Math::Random::Secure и Math::TrulyRandom.

stat FILEHANDLE

stat EXPR

stat DIRHANDLE

stat

Возвращает список из 13 элементов, содержащий информацию о состоянии файла, либо файла, открытого через FILEHANDLE или DIRHANDLE, либо указанного EXPR. Если EXPR опущен, она получает состояние $_ (не _!). Возвращает пустой список, если 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, lstat или filetest. Пример:

if (-x $file && (($d) = stat(_)) && $d < 0) {
    print "$file is executable NFS file\n";
}

(Это работает только на машинах, для которых номер устройства отрицательный в NFS.)

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

Поскольку режим содержит как тип файла, так и его разрешения, вам следует скрыть часть типа файла и использовать "%o", если вы хотите увидеть реальные разрешения.

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

Если перечислено более одной переменной, список должен быть помещён в скобки. С помещённым в скобки списком, undef может использоваться в качестве метки-заполнителя. Однако, поскольку инициализация переменных state в таких списках в настоящее время невозможна, это не будет иметь смысла.

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

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

Это определение подпрограммы, а не настоящая функция как таковая. Без блока — это просто объявление вперёд. Без имени — это объявление анонимной функции, поэтому возвращает значение: ссылку на код только что созданного замыкания.

См. 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 в качестве левостороннего значения, в этом случае EXPR должен быть левосторонним значением. Если вы присваиваете значение короче LENGTH, строка уменьшится, а если длиннее, строка увеличится, чтобы вместить его. Чтобы сохранить длину строки, вам может потребоваться дополнить или укоротить ваше значение с помощью sprintf.

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

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 в качестве левостороннего значения является указание строки REPLACEMENT в качестве четвёртого аргумента. Это позволяет заменить части 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"

Обратите внимание, что левостороннее значение, возвращаемое трёхаргументной версией 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 результат использования левостороннего значения несколько раз был неопределённым. До версии 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 в противном случае.

PerlIO слои будут применены к дескриптору так же, как и при вызове open, который не указывает слои. То есть, текущее значение ${^OPEN}, установленное прагмой open в лексическом пространстве, или параметр командной строки -C или переменная окружения PERL_UNICODE в основном пространстве программы, с отступлением к значениям по умолчанию платформы, как описано в "Значения по умолчанию и как их переопределить" в PerlIO. Если вы хотите удалить все слои, которые могут преобразовать поток байтов, используйте binmode после открытия.

Возможные значения и флаги параметра MODE зависят от системы; они доступны через стандартный модуль Fcntl. См. документацию системного вызова open(2) вашей операционной системы, чтобы увидеть, какие значения и флаги доступны. Вы можете объединить несколько флагов с помощью оператора |.

Некоторые из наиболее распространённых значений — O_RDONLY для открытия файла только для чтения, O_WRONLY для открытия файла только для записи и O_RDWR для открытия файла для чтения и записи.

По историческим причинам некоторые значения работают практически на всех системах, поддерживаемых Perl: 0 означает только чтение, 1 означает только запись, а 2 означает чтение/запись. Нам известно, что эти значения не работают в OS/390; вы, вероятно, не захотите использовать их в новом коде.

Если файл с именем 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 для получения дополнительной информации об этом.

Эта функция не имеет прямой связи с использованием sysread, syswrite или sysseek. Дескриптор файла, открытый с помощью этой функции, может использоваться с буферизованным вводом/выводом так же, как и открытый с open может использоваться с небуферизованным вводом/выводом.

Обратите внимание, что в Perl-версиях, более старых, чем 5.8.0, sysopen зависит от функции fdopen(3) C-библиотеки. На многих 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). Она опускает все слои PerlIO, включая буферизованный ввод-вывод (но учитывает наличие слоя :utf8, как описано позже), поэтому смешивание этого с другими видами чтения, print, write, seek, tell или eof может вызвать путаницу, потому что слои :perlio или :crlf обычно буферизуют данные. Возвращает количество фактически прочитанных байтов, 0 в конце файла, или undef, если произошла ошибка (в последнем случае $! также устанавливается). SCALAR будет увеличен или уменьшен так, чтобы последний фактически прочитанный байт был последним байтом скаляра после чтения.

Можно указать OFFSET для размещения прочитанных данных в определённой позиции строки, а не в начале. Отрицательный OFFSET указывает на позицию, отсчитываемую назад от конца строки на указанное число символов. Положительный OFFSET, больший длины SCALAR, приводит к дополнению строки до необходимой длины символами "\0" перед добавлением результата чтения.

Функции syseof() не существует, что нормально, так как eof не работает хорошо с файлами устройств (например, ttys). Используйте 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) }

Возвращает новую позицию или undefined при ошибке. Позиция 0 возвращается как строка "0 but true"; таким образом sysseek возвращает true при успехе и false при ошибке, но вы всё ещё можете легко определить новую позицию.

system LIST

system PROGRAM LIST

Делает ровно то же, что и exec, за исключением того, что сначала выполняется fork, и родительский процесс ожидает завершения дочернего процесса. Обратите внимание, что обработка аргументов зависит от количества аргументов. Если в LIST более одного аргумента, или если LIST — массив с более чем одним значением, запускает программу, указанную первым элементом списка, с аргументами, заданными остальными элементами списка. Если аргументом является только один скаляр, аргумент проверяется на наличие метасимволов оболочки, и если они есть, весь аргумент передаётся командной оболочке системы для анализа (это /bin/sh -c на Unix-платформах, но отличается на других платформах). Если в аргументе нет метасимволов оболочки, он разбивается на слова и передаётся непосредственно в execvp, что более эффективно. В Windows только синтаксис system PROGRAM LIST надёжно избежит использования оболочки; system LIST, даже с несколькими элементами, вернётся к оболочке, если первый запуск неудачен.

Perl попытается сбросить все файлы, открытые для вывода, перед любой операцией, которая может выполнить fork, но это может быть не поддерживается на некоторых платформах (см. 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" in perlport.

syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET

syswrite FILEHANDLE,SCALAR,LENGTH

syswrite FILEHANDLE,SCALAR

Попытка записи LENGTH байтов данных из переменной SCALAR в указанный FILEHANDLE, используя write(2). Если LENGTH не указан, записывается весь SCALAR. Она опускает все слои PerlIO, включая буферизованный ввод-вывод (но учитывает наличие слоя :utf8 как описано позже), поэтому смешивание этого с чтениями (кроме sysread)), print, write, seek, tell или eof может вызвать путаницу, потому что слои :perlio и :crlf обычно буферизуют данные. Возвращает количество фактически записанных байтов или undef при ошибке (в этом случае переменная errno $! также устанавливается). Если LENGTH больше, чем доступных данных в SCALAR после OFFSET, записывается только доступное количество данных.

Можно указать OFFSET для записи данных из определённой части строки, а не из начала. Отрицательный OFFSET указывает на позицию, отсчитываемую назад от конца строки на указанное число символов. Если SCALAR имеет длину 0, можно использовать только OFFSET 0.

ПРЕДУПРЕЖДЕНИЕ: Если файловый дескриптор помечен как :utf8, syswrite выбросит исключение. Слой :encoding(...) неявно вводит слой :utf8. В противном случае, если для дескриптора не задан кодировщик, но вы пытаетесь записать символы с кодами больше 255, вызовет исключение. См. binmode, open и прагму open.

tell FILEHANDLE

tell

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

Обратите внимание на акцент на байтах: даже если файловый дескриптор настроен на работу с символами (например, с помощью :encoding(UTF-8)) слоя ввода-вывода, seek, tell и sysseek семейство функций используют смещения в байтах, а не в символах, так как поиск по смещению в символах был бы очень медленным в файле UTF-8.

Значение возвращаемое 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, который связал переменную с пакетом.) Возвращает неопределённое значение, если 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 в верхнем регистре. Если EXPR опущен, используется $_.

my $str = uc("Perl is GREAT"); # "PERL IS GREAT"

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

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

Примечание: Это внутренняя функция, реализующая escape \U в строках с двойными кавычками.

my $str = "Perl is \Ugreat\E"; # "Perl is GREAT"

ucfirst EXPR

ucfirst

Возвращает значение EXPR с первой буквой в верхнем регистре (Unicode называет это заглавным). Если EXPR опущен, ucfirst использует $_.

my $str = ucfirst("hello world!"); # "Hello world!"

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

Примечание: Это внутренняя функция, реализующая escape \u в строках с двойными кавычками.

my $str = "\uperl\E is great"; # "Perl is great"

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. Всегда возвращает неопределённое значение. Вы можете опустить EXPR, в этом случае ничего не будет определено, но вы всё равно получите неопределённое значение, которое можно, например, вернуть из подпрограммы, присвоить переменной или передать в качестве параметра. Примеры:

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-разрядная контрольная сумма. Контрольная сумма вычисляется путем суммирования числовых значений расширенных значений (для строковых полей берётся сумма символьных кодов; для битовых полей — сумма нулей и единиц).

Например, следующее вычисляет то же число, что и программа 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.

my @animals = ("cat");
unshift(@animals, "mouse"); # ("mouse", "cat")

my @colors = ("red");
unshift(@colors, ("blue", "green")); # ("blue", "green", "red")

Возвращает новое количество элементов в обновлённом массиве.

# Return value is the number of items in the updated array
my $color_count = unshift(@colors, ("yellow", "purple"));

say "There are $color_count colors in the updated array";

Обратите внимание, что LIST добавляется целиком, а не по одному элементу за раз, поэтому добавленные элементы сохраняют свой порядок. Используйте reverse для обратного порядка.

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

untie VARIABLE

Прерывает привязку между переменной и пакетом. (См. tie.) Не имеет эффекта, если переменная не привязана.

use Module VERSION LIST

use Module VERSION

use Module LIST

use Module

Импортирует семантику из указанного модуля в текущий пакет, обычно, путём алиасирования определенных подпрограмм или переменных в ваш пакет. Это точно эквивалентно

BEGIN { require Module; Module->import( LIST ); }

за исключением того, что Module обязательно должен быть идентификатором. Импорт может быть условным путём использования модуля if.

Ключевое слово 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;

См. perlmodlib для списка стандартных модулей и псевдо-модулей. См. perlrun для -M и -m командной строки Perl, предоставляющих функциональность use из командной строки.

use VERSION

Лексически включает все функции, доступные в запрошенной версии, как определено прагмой feature, отключая любые функции, отсутствующие в наборе функций запрошенной версии. См. feature.

VERSION может быть строкой, начинающейся с «v», такой как v5.24.1, которая будет сравниваться с $^V (также $PERL_VERSION), или числовым аргументом в формате 5.024001, который будет сравниваться с $]. Если VERSION больше версии текущего интерпретатора Perl, возникает исключение; Perl не будет пытаться обработать остальную часть файла. Сравните с require, который может выполнить аналогичную проверку во время выполнения.

Если указанная версия Perl 5.12 или выше, ограничения активируются лексически, как и с use strict. Аналогично, если указанная версия Perl 5.35.0 или выше, предупреждения включаются. Позже использование use VERSION переопределит всё поведение предыдущего use VERSION, возможно, удалив strict, warnings, и feature добавленные им. use VERSION не загружает файлы feature.pm, strict.pm или warnings.pm.

В текущей реализации любое явное использование use strict или no strict переопределяет use VERSION, даже если оно предшествует ему. Однако это может быть изменено в будущих релизах Perl, поэтому новый код не должен полагаться на этот факт. Рекомендуется, чтобы объявление use VERSION было первым значимым оператором в файле (возможно, после оператора package или любого количества пробелов или комментариев), чтобы его эффекты происходили первыми, а другие прагмы применялись после него.

Указание 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. (Мы стараемся не делать этого больше, чем необходимо.)

Симметрично, no VERSION позволяет указать, что вам нужна версия Perl, более старая, чем указанная. Исторически это было добавлено во время ранней разработки языка Raku (ранее "Perl 6"), чтобы программа Perl 5 могла начинать

no 6;

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

Следует быть осторожным при использовании формы no VERSION, поскольку она только предназначена для утверждения, что работающий Perl имеет более раннюю версию, чем его аргумент, и не для отмены эффектов включения функций с помощью use VERSION.

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 в контексте «ничего» сбрасывает итератор без дополнительной нагрузки.

Помимо сброса итератора, values @array в контексте списка эквивалентен простому @array. (Мы рекомендуем использовать контекст «ничего» 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 v5.12;	# 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 с форматами с big-endian 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, также можно манипулировать логическими операторами |, &, ^, и ~. Эти операторы будут предполагать желательность операции над битовой последовательностью, когда оба операнда — строки. См. "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"

Для преобразования битовой последовательности в строку или список нулей и единиц используйте эти:

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, используя формат, связанный с этим файлом. По умолчанию формат файла — имя файлового дескриптора, но формат текущего выходного канала (см. функцию select) может быть явно задан путём присваивания имени формата переменной $~.

Обработка верхней части формы обрабатывается автоматически: если на текущей странице недостаточно места для форматированной записи, страница переносится путём записи символа перевода страницы и используется специальный формат верхней части страницы для форматирования нового заголовка страницы перед записью записи. По умолчанию формат верхней части страницы — имя файлового дескриптора со строкой _TOP в конце или top в текущем пакете, если предыдущий не существует. Это было бы проблемой с автоматическими файловыми дескрипторами, но это можно динамически установить на формат по вашему выбору путём присваивания имени переменной $^ во время выбора этого файлового дескриптора. Число строк, оставшихся на текущей странице, находится в переменной $-, которая может быть установлена на 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

isa

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.

try

catch

finally

Эти ключевые слова управления потоком, связанные с экспериментальной try функцией, описаны в "Обработка исключений try-catch" в perlsyn.

defer

Это ключевое слово управления потоком, связанное с экспериментальной defer функцией, описано в "Блоки defer" в perlsyn.

ADJUST

Этот блок фазы, относящийся к классам, описан в perlclass.