perlfunc

СОДЕРЖАНИЕ

ИМЯ
ОПИСАНИЕ

ИМЯ

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

ОПИСАНИЕ

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Функции для реальных @ARRAY

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

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

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

Функции для реальных %HASH

delete, each, exists, keys, values

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

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

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

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

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

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

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

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

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

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

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

Ключевые слова, связанные с областью видимости

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

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

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

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

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

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

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

do, import, no, package, require, use

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

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

Функции низкоуровневых сокетов

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

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

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

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

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

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

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

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

gmtime, localtime, time, times

Ключевые слова (не функции)

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

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

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

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

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

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

-X FILEHANDLE

-X EXPR

-X DIRHANDLE

-X

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

use 5.010;  # so filetest ops can stack

abs VALUE

abs

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

accept NEWSOCKET,GENERICSOCKET

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

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

alarm SECONDS

alarm

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

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

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

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

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

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

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

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

atan2 Y,X

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

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

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

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

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

bind SOCKET,NAME

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

binmode FILEHANDLE, LAYER

binmode FILEHANDLE

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

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

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

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

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

:bytes, :crlf, :utf8, и любые другие директивы вида :..., называются I/O слоями. Предикат open может использоваться для установления I/O слоёв по умолчанию.

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

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

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

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

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

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

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

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

bless REF,CLASSNAME

bless REF

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

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

См. "Perl Modules" в perlmod.

break

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

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

caller EXPR

caller

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

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

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

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

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

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

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

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

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

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

chdir EXPR

chdir FILEHANDLE

chdir DIRHANDLE

chdir

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

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

chmod LIST

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

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

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

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

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

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

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

chomp VARIABLE

chomp( LIST )

chomp

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

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

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

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

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

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

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

chroot FILENAME

chroot

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

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

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

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

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

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

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

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

Когда нет блока, continue — это функция, которая проходит через текущий when или default блок вместо итерации динамически окружающего foreach блока или выхода из лексически окружающего given блока. В Perl 5.14 и ранее такая форма continue была доступна только при включенном "switch" feature. См. 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'd с тем же солью, что и сохранённый дайджест. Если два дайджеста совпадают, пароль правильный.

При проверке существующей строки дайджеста необходимо использовать дайджест в качестве соли (как 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). Чтобы предотвратить создание базы данных, если она не существует, вы можете задать MODE равным 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 для этого элемента больше не возвращает true. Установка элемента хэша в неопределённое значение не удаляет его ключ, но удаление его — делает; см. exists.

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

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

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

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

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

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

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

use Scalar::Util "blessed";

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

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

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

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

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

Вы можете организовать вызов обратного вызова непосредственно перед выполнением die, установив зацепку $SIG{__DIE__}. Соответствующий обработчик вызывается с исключением в качестве аргумента и может изменить исключение, если сочтёт нужным, вызвав die снова. См. "%SIG" в 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 содержал '.' (текущий каталог), делая эти два случая эквивалентными, это больше не обязательно так, так как '.' не включён в @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.

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

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

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

each HASH

each ARRAY

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

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

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

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

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

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

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

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

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

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

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

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

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

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

eof FILEHANDLE

eof ()

eof

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

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

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

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

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

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

eval EXPR

eval BLOCK

eval

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

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

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

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

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

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

В рамках "unicode_eval" функции

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

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

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

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

За пределами "unicode_eval" функции

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

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

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

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

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

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

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

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

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

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

Блочный eval

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

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

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

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

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

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

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

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

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

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

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

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

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

evalbytes EXPR

evalbytes

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

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

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

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

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

выводит

и $@ пуста.

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

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

exec LIST

exec PROGRAM LIST

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

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

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

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

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

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

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

или, более непосредственно,

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

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

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

my @args = ( "echo surprise" );

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

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

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

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

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

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

exists EXPR

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

exit EXPR

exit

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

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

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

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

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

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

exp EXPR

exp

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

fc EXPR

fc

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

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

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

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

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

fc($this) eq fc($that)

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

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

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

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

Хотя Стандарт Юникод определяет две дополнительные формы складки регистра, одну для тюркских языков и одну, которая никогда не преобразует один символ в несколько, в ядре 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. Эта строка равна true в контексте булевой переменной и 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__

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

fileno FILEHANDLE

fileno DIRHANDLE

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

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

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

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

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

flock FILEHANDLE,OPERATION

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

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

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

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

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

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

Если вы 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: Между версиями 5.8.1 и 5.16.0 Perl обходил не-POSIX семантику потоков в меньшинстве систем Linux (и системах Debian GNU/kFreeBSD), которые использовали LinuxThreads; эта эмуляция была удалена. Подробности см. в документации для $$.

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

getpriority WHICH,WHO

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

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

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

getpwnam NAME

getgrnam NAME

gethostbyname NAME

getnetbyname NAME

getprotobyname NAME

getpwuid UID

getgrgid GID

getservbyname NAME,PROTO

gethostbyaddr ADDR,ADDRTYPE

getnetbyaddr ADDR,ADDRTYPE

getprotobynumber NUMBER

getservbyport PORT,PROTO

getpwent

getgrent

gethostent

getnetent

getprotoent

getservent

setpwent

setgrent

sethostent STAYOPEN

setnetent STAYOPEN

setprotoent STAYOPEN

setservent STAYOPEN

endpwent

endgrent

endhostent

endnetent

endprotoent

endservent

Эти функции аналогичны своим коллегам в системной библиотеке 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).

Вот пример проверки включения алгоритма Найгла на сокете:

use Socket qw(:all);

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

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

glob EXPR

glob

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

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

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

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

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

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

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

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

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

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

gmtime EXPR

gmtime

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

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

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

goto LABEL

goto EXPR

goto &NAME

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

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

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

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

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

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

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

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

grep БЛОК СПИСОК

grep ВЫРАЖЕНИЕ,СПИСОК

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

Вычисляет БЛОК или ВЫРАЖЕНИЕ для каждого элемента СПИСКА (локально устанавливая $_ для каждого элемента) и возвращает список элементов, для которых выражение вычислилось в true. В скалярном контексте возвращает количество раз, когда выражение было истинным.

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

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

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

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

См. также map для списка, составленного из результатов БЛОКА или ВЫРАЖЕНИЯ.

hex ВЫРАЖЕНИЕ

hex

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

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 СПИСОК

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

index СТРОКА, ПОДСТРОКА, ПОЗИЦИЯ

index СТРОКА, ПОДСТРОКА

Функция index ищет одну строку в другой, но без поведения «подстановочных знаков» полного регулярного выражения. Она возвращает позицию первого вхождения ПОДСТРОКИ в СТРОКЕ на или после ПОЗИЦИИ. Если ПОЗИЦИЯ опущена, поиск начинается с начала строки. ПОЗИЦИЯ до начала строки или после её конца обрабатывается так, как если бы она была в начале или в конце соответственно. ПОЗИЦИЯ и возвращаемое значение основаны на нуле. Если подстрока не найдена, index возвращает -1.

int ВЫРАЖЕНИЕ

int

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

ioctl ДЕСКРИПТОР_ФАЙЛА,ФУНКЦИЯ,СКАЛЯР

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

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

чтобы получить правильные определения функций. Если sys/ioctl.ph не существует или не содержит правильных определений, придётся самостоятельно реализовать их на основе ваших заголовков C, таких как <sys/ioctl.h>. (В комплекте Perl есть скрипт h2ph, который может помочь в этом, но это нетривиальная задача.) СКАЛЯР будет считываться и/или записываться в зависимости от ФУНКЦИИ; указатель C на строковое значение СКАЛЯРА будет передан в качестве третьего аргумента фактического вызова ioctl. (Если у СКАЛЯРА нет строкового значения, но есть числовое, это значение будет передано вместо указателя на строковое значение. Чтобы гарантировать это, добавьте 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 ВЫРАЖЕНИЕ,СПИСОК

Объединяет отдельные строки списка в одну строку с разделителями, задаваемыми значением ВЫРАЖЕНИЯ, и возвращает эту новую строку. Пример:

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

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

keys ХЭШ

keys МАССИВ

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

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

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

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

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

или как насчёт сортировки по ключу:

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

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

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

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

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

keys %hash = 200;

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

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

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

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

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

kill SIGNAL, LIST

kill SIGNAL

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

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

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

Список имён сигналов, поддерживаемых текущей платформой, можно найти в $Config{sig_name}, который предоставляется модулем Config. Более подробную информацию см. в разделе «Конфигурация».

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

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

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

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

См. раздел «Сигналы» в perlipc для получения дополнительной информации.

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

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

Если нет списка LIST процессов, сигнал не отправляется, и возвращаемое значение равно 0. Эта форма иногда используется, поскольку она запускает проверки проверки загрязнения. Однако см. раздел «Отбеливание и выявление загрязнённых данных» в 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 в нижнем регистре. Это внутренняя функция, реализующая экранирование \L в строках с двойными кавычками.

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

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

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

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

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

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

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

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

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

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

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

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

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

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__

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

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"

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

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

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

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

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

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

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

lock THING

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

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

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

log EXPR

log

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

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

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

lstat FILEHANDLE

lstat EXPR

lstat DIRHANDLE

lstat

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

Если EXPR опущено, получает статистику $_.

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

m//

Оператор сопоставления. См. "Regexp Quote-Like Operators" в perlop.

map BLOCK LIST

map EXPR,LIST

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

mkdir FILENAME,MODE

mkdir FILENAME

mkdir

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

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

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

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

msgctl ID,CMD,ARG

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

use IPC::SysV;

чтобы получить правильные определения констант. Если CMD равен IPC_STAT, то ARG должен быть переменной, которая будет содержать возвращаемую msqid_ds структуру. Возвращает значения аналогично ioctl: неопределённое значение для ошибки, "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. Если перечислено более одной переменной, список должен быть помещён в скобки.

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

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

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

next LABEL

next EXPR

next

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

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

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

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

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

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

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

no MODULE VERSION LIST

no MODULE VERSION

no MODULE LIST

no MODULE

no VERSION

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

oct EXPR

oct

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

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

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

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

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

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

open FILEHANDLE,EXPR

open FILEHANDLE,MODE,EXPR

open FILEHANDLE,MODE,EXPR,LIST

open FILEHANDLE,MODE,REFERENCE

open FILEHANDLE

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

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

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

и для записи:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Старый стиль — использовать простое слово в качестве дескриптора файла, как

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вот скрипт, который сохраняет, перенаправляет и восстанавливает 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 по умолчанию (в большинстве случаев).

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

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

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

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

или

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

после которого

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

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

Следующие блоки более или менее эквивалентны:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

opendir DIRHANDLE,EXPR

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

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

ord EXPR

ord

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

Для обратного преобразования см. chr. См. perlunicode для получения дополнительной информации об 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 strict;

$Foo::foo = 23;

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

print $Foo::foo; # prints 23

print $foo; # ERROR: requires explicit package name

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

package Foo;
use strict;

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

print $Foo::foo; # prints 23

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

package Foo;
use strict;

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

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

our($bar, $baz);

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

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

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

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

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

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

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

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

Точные семантика и интерфейс TYPE и ATTRS все еще развиваются. TYPE в настоящее время связан с использованием псевдонима 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 _and_ if Perl has been compiled to
      support those.  Raises an exception otherwise.
      Note that there are different long double formats.)

p  A pointer to a null-terminated string.
P  A pointer to a structure (fixed-length string).

u  A uuencoded string.
U  A Unicode character number.  Encodes to a character in char-
   acter mode and UTF-8 (or UTF-EBCDIC in EBCDIC platforms) in
   byte mode.

w  A BER compressed integer (not an ASN.1 BER, see perlpacktut
   for details).  Its bytes represent an unsigned integer in
   base 128, most significant digit first, with as few digits
   as possible.  Bit eight (the high bit) is set on each byte
   except the last.

x  A null byte (a.k.a ASCII NUL, "\000", chr(0))
X  Back up a byte.
@  Null-fill or truncate to absolute position, counted from the
   start of the innermost ()-group.
.  Null-fill or truncate to absolute position specified by
   the value.
(  Start of a ()-group.

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

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

Если значение для упаковки слишком длинное, результат обрезается. Если оно слишком длинное и задано явное значение count, Z упаковывает только $count-1 байтов, после чего добавляет нулевой байт. Таким образом, Z всегда упаковывает завершающий нулевой байт, за исключением случая, когда count равно 0.
Аналогично, форматы b и B упаковывают строку, длина которой задана в битах. Каждый такой формат генерирует 1 бит результата. За ними обычно следует значение повторения, например, B8 или B64.

Каждый битовый результат основывается на младшем бите соответствующего входного символа, т.е. на ord($char)%2. В частности, символы "0" и "1" генерируют биты 0 и 1, как и символы "\000" и "\001".

Начиная с начала входной строки, каждая 8-ка символов преобразуется в 1 символ вывода. С форматом b, первый символ 8-ки определяет младший бит символа; с форматом B, он определяет старший бит символа.

Если длина входной строки не кратна 8, остаток упаковывается так, как будто входная строка дополнена нулевыми символами в конце. Аналогично, при распаковке «лишние» биты игнорируются.

Если входная строка длиннее, чем нужно, оставшиеся символы игнорируются.

* для значения повторения использует все символы входного поля. При распаковке биты преобразуются в строку из 0 и 1.
Форматы h и H упаковывают строку длиной в заданное количество нибблов (4-битовых групп, представимых шестнадцатеричными цифрами, "0".."9" "a".."f").

Для каждого такого формата, pack генерирует 4 бита результата. С символами, не являющимися буквами, результат основан на 4 младших битах входного символа, т.е. на ord($char)%16. В частности, символы "0" и "1" генерируют нибблы 0 и 1, как и байты "\000" и "\001". Для символов "a".."f" и "A".."F", результат совместим с обычными шестнадцатеричными цифрами, так что "a" и "A" оба генерируют ниббл 0xA==10. Используйте только эти специфические шестнадцатеричные символы с этим форматом.

Начиная с начала шаблона до pack, каждая пара символов преобразуется в 1 символ вывода. С форматом h, первый символ пары определяет младший ниббл символа вывода; с форматом H, он определяет старший ниббл.

Если длина входной строки нечётная, она ведет себя так, как будто дополнена нулевым символом в конце. Аналогично, «лишние» нибблы игнорируются при распаковке.

Если входная строка длиннее, чем нужно, лишние символы игнорируются.

* для значения повторения использует все символы входного поля. Для unpack, нибблы преобразуются в строку шестнадцатеричных цифр.
Формат p упаковывает указатель на нуль-терминированную строку. Вы несёте ответственность за обеспечение того, что строка не является временной переменной, так как она может быть освобождена до того, как вы успеете использовать упакованный результат. Формат P упаковывает указатель на структуру размера, указанного длиной. Нулевой указатель создаётся, если соответствующее значение для p или P равно undef; аналогично с unpack, где нулевой указатель распаковывается в undef.

Если на вашей системе размер указателя отличается от размера int или long, то может быть невозможно упаковать или распаковать указатели в порядке байтов big-endian или little-endian. Попытка сделать это вызовет исключение.
Символ шаблона / позволяет упаковывать и распаковывать последовательность элементов, где упакованная структура содержит упакованное количество элементов, за которым следуют сами упакованные элементы. Это полезно, когда структура, которую вы распаковываете, закодировала размеры или значения повторения некоторых своих полей внутри самой структуры как отдельные поля.

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

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

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

Если sequence-item относится к типу строки ("A", "a", или "Z"), то length-item — длина строки, а не число строк. При явном значении повторения для упаковки упакованная строка корректируется до этой длины. Например:
```
This code:                             gives this result:

unpack("W/a", "\004Gurusamy")          ("Guru")
unpack("a3/A A*", "007 Bond  J ")      (" Bond", "J")
unpack("a3 x2 /A A*", "007: Bond, J.") ("Bond, J", ".")

pack("n/a* w/a","hello,","world")     "\000\006hello,\005world"
pack("a/W2", ord("a") .. ord("z"))    "2ab"
```
length-item не возвращается явно из unpack.

Задавать значение count для формата length-item полезно только с A, a, или Z. Упаковка с length-item a или Z может ввести "\000" символы, которые Perl не считает допустимыми в числовых строках.
Целочисленные типы s, S, l, и L могут сопровождаться модификатором ! для указания родных коротких или длинных целых чисел. Как показано в примере выше, чистый l означает ровно 32 бита, хотя родной long, как видит локальный компилятор C, может быть больше. Это в основном проблема на 64-битных платформах. Вы можете проверить, влияет ли использование ! на результат следующим образом:
```
printf "format s is %d, s! is %d\n",
    length pack("s"), length pack("s!");

printf "format l is %d, l! is %d\n",
    length pack("l"), length pack("l!");
```
i! и I! также разрешены, но только для полноты: они идентичны i и I.

Фактические размеры (в байтах) родных коротких, целых, длинных и длинных длинных целых чисел на платформе, где был скомпилирован Perl, также доступны из командной строки:
```
$ perl -V:{short,int,long{,long}}size
shortsize='2';
intsize='4';
longsize='4';
longlongsize='8';
```
или программно через модуль Config:
```
use Config;
print $Config{shortsize},    "\n";
print $Config{intsize},      "\n";
print $Config{longsize},     "\n";
print $Config{longlongsize}, "\n";
```
$Config{longlongsize} не определено на системах без поддержки long long.

Форматы целых чисел s, S, i, I, l, L, j, и J изначально не переносимы между процессорами и операционными системами, потому что они следуют родной байтовой последовательности и типу представления. Например, 4-байтовое целое число 0x12345678 (305419896 в десятичной системе) будет упорядочено локально (расположено и обрабатывается регистрами процессора) в байтах как
```
0x12 0x34 0x56 0x78  # big-endian
0x78 0x56 0x34 0x12  # little-endian
```
В основном, процессоры Intel и VAX являются little-endian, в то время как все остальные, включая Motorola m68k/88k, PPC, Sparc, HP PA, Power и Cray, являются big-endian. Alpha и MIPS могут быть и тем, и другим: Digital/Compaq использовали (ну, использовали) их в little-endian режиме, но SGI/Cray используют их в big-endian режиме.

Названия big-endian и little-endian являются шутливыми ссылками на привычки поедания яиц у маленького лиллипутианца и большого блефускудьянца из классической сатиры Джонатана Свифта «Путешествия Гулливера». Это вошло в компьютерный жаргон через статью «О священных войнах и призыве к миру» Дэниела Коэна, USC/ISI IEN 137, 1 апреля 1980 года.

Некоторые системы могут иметь даже более странные порядки байтов, такие как
```
0x56 0x78 0x12 0x34
0x34 0x12 0x78 0x56
```
Эти порядки называются mid-endian, middle-endian, mixed-endian или просто странными.

Вы можете определить тип представления вашей системы с помощью этого заклинания:
```
printf("%#02x ", $_) for unpack("W*", pack L=>0x12345678);
```
Байтовая последовательность на платформе, на которой был создан Perl, также доступна через Config:
```
use Config;
print "$Config{byteorder}\n";
```
или из командной строки:
```
$ perl -V:byteorder
```
Байтовые последовательности "1234" и "12345678" являются little-endian; "4321" и "87654321" являются big-endian. Системы с многоархитектурными двоичными файлами будут иметь "ffff", что означает, что статическая информация не работает, необходимо использовать динамическое определение.

Для переносимых упакованных целых чисел используйте форматы n, N, v, и V, или используйте модификаторы > и <, описанные ниже. См. также perlport.
Также числа с плавающей точкой имеют тип представления. Обычно (но не всегда) он совпадает с типом представления целых чисел. Хотя большинство платформ в наши дни используют двоичный формат IEEE 754, есть различия, особенно если речь идёт о long double. Вы можете увидеть переменные Config doublekind и longdblkind (также doublesize, longdblsize) — значения «kind» являются перечислениями, в отличие от byteorder.

С точки зрения переносимости, вероятно, лучшим вариантом является использование 64-битных double IEEE 754 с согласованным типом представления. Другая возможность — формат "%a") printf.
Начиная с Perl 5.10.0, форматы целых и чисел с плавающей точкой, а также форматы p и P и группы () могут быть дополнены модификаторами типа представления > или < для соответственно принудительного использования big- или little-endian байтовой последовательности. Эти модификаторы особенно полезны, учитывая, что n, N, v, и V не охватывают знакомые целые числа, 64-битные целые числа или значения с плавающей точкой.

Вот несколько моментов, которые следует учитывать при использовании модификатора типа представления:
- Обмен знаковыми целыми числами между разными платформами работает только тогда, когда все платформы хранят их в одном формате. Большинство платформ хранят знакомые целые числа в обозначении дополнения до двух, поэтому обычно это не проблема.
- Модификаторы > или < могут быть использованы только с форматами чисел с плавающей точкой на машинах с big- или little-endian. В противном случае попытка их использования вызовет исключение.
- Принудительное использование big- или little-endian байтовой последовательности для значений с плавающей точкой при обмене данными может работать только в том случае, если все платформы используют одно и то же двоичное представление, такое как представление чисел с плавающей точкой IEEE. Даже если все платформы используют IEEE, могут быть небольшие различия. Возможность использования > или < для значений с плавающей точкой может быть полезной, но и опасной, если вы не знаете точно, что делаете. Это не является универсальным способом переносимого хранения значений с плавающей точкой.
- Использование > или < в группе () влияет на все типы внутри группы, которые принимают модификаторы байтовой последовательности, включая все подгруппы. Для всех других типов это игнорируется. Вы не можете переопределить байтовую последовательность внутри группы, которая уже имеет суффикс модификатора байтовой последовательности.
Вещественные числа (float и double) представлены в родном формате машины. Из-за множества форматов чисел с плавающей точкой и отсутствия стандартного «сетевого» представления для них не было реализовано никакой возможности обмена. Это означает, что упакованные данные с плавающей точкой, записанные на одном компьютере, могут быть нечитаемыми на другом, даже если оба используют арифметику с плавающей точкой IEEE (потому что тип представления в памяти не является частью спецификации IEEE). См. также perlport.

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

Поскольку Perl использует double (или long double, если настроено) для всех вычислений с числами, преобразование из double в float и обратно в double приводит к потере точности, поэтому unpack("f", pack("f", $foo)) обычно не будет равно $foo.
Функции pack и unpack могут работать в двух режимах: символьный режим (C0 режим), где упакованная строка обрабатывается посимвольно, и байтовый режим UTF-8 (U0 режим), где упакованная строка обрабатывается в ее кодированном в UTF-8 формате Unicode побайтно. Символьный режим является по умолчанию, если строка формата не начинается с U. Вы всегда можете переключиться между режимами в середине строки формата с помощью явного C0 или U0 в формате. Этот режим сохраняется до следующего изменения режима или до конца обрабатываемой им (непосредственно) группы ().

Использование C0 для получения символов Unicode при использовании U0 для получения не символов Unicode может быть неочевидным. Вероятно, только первое из этих вариантов вам и нужно:
```
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
  perl -CS -ne 'printf "%v04X\n", $_ for unpack("C0A*", $_)'
03B1.03C9
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
  perl -CS -ne 'printf "%v02X\n", $_ for unpack("U0A*", $_)'
CE.B1.CF.89
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
  perl -C0 -ne 'printf "%v02X\n", $_ for unpack("C0A*", $_)'
CE.B1.CF.89
$ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
  perl -C0 -ne 'printf "%v02X\n", $_ for unpack("U0A*", $_)'
C3.8E.C2.B1.C3.8F.C2.89
```
Эти примеры также показывают, что не стоит пытаться использовать pack/unpack в качестве замены модуля Encode.
Вы сами должны выполнять выравнивание или дополнение, вставляя, например, достаточно "x" при упаковке. Функции pack и unpack не знают, откуда и куда направляются символы, поэтому они обрабатывают свой ввод и вывод как плоские последовательности символов.
Группа () — это вложенная в скобки подшаблон. Группа может принимать повторяющееся количество как постфикс или, для unpack, также с помощью символа шаблона /. В каждой итерации группы позиционирование с @ начинается заново с 0. Поэтому результатом
```
pack("@1A((@2A)@3A)", qw[X Y Z])
```
является строка "\0X\0\0YZ".
x и X принимают модификатор ! для работы как команды выравнивания: они переходят к ближайшей позиции, выровненной по кратному значению count символов. Например, для pack или unpack структуры C, такой как
```
struct {
    char   c;    /* one signed, 8-bit character */
    double d;
    char   cc[2];
}
```
может потребоваться использовать шаблон c x![d] d c[2]. Это предполагает, что double должны быть выровнены по размеру double.

Для команд выравнивания count 0 эквивалентно count 1; оба являются операциями без действия.
n, N, v и V принимают модификатор ! для представления знакомых 16-/32-битных целых чисел в big-/little-endian порядке. Это переносимо только тогда, когда все платформы, обменивающиеся упакованными данными, используют одно и то же двоичное представление для знакомых целых чисел; например, когда все платформы используют представление дополнения до двух.
Комментарии могут быть встроены в шаблон с помощью # до конца строки. Между кодами 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

Объявляет блок или остальную часть блока компиляции как находящиеся в заданном пространстве имён. Область действия объявления пакета — это предоставленный код BLOCK или, в отсутствие BLOCK, от самого объявления до конца текущей области (вложенного блока, файла или eval). То есть, формы без BLOCK действуют до конца текущей области, как и операторы 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 должен быть номером версии в формате "strict", как определено модулем version: положительное десятичное число (целое или с дробной частью) без экспоненты или же строка v-десятичной точки с префиксом 'v' и по крайней мере тремя компонентами. Вы должны установить $VERSION только один раз в каждом пакете.

См. "Пакеты" в perlmod для получения дополнительной информации о пакетах, модулях и классах. См. perlsub для других вопросов области видимости.

__PACKAGE__

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

pipe READHANDLE,WRITEHANDLE

Открывает пару соединённых труб, как соответствующий системный вызов. Обратите внимание, что если вы создаёте цикл связанных труб, может произойти тупик, если вы не будете очень осторожны. Кроме того, обратите внимание, что трубы Perl используют буферизацию ввода-вывода, поэтому вам может потребоваться установить $| для сброса WRITEHANDLE после каждой команды, в зависимости от приложения.

Возвращает true при успехе.

См. IPC::Open2, IPC::Open3 и "Взаимодействие с другим процессом" в perlipc для примеров таких вещей.

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

pop ARRAY

pop

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

Возвращает неопределённое значение, если массив пуст, хотя это может произойти и в других случаях. Если ARRAY опущен, извлекает значение из массива @ARGV в основной программе, но из массива @_ в подпрограммах, как и shift.

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

pos SCALAR

pos

Возвращает смещение, с которого последняя m//g операция поиска остановилась для указанной переменной ($_ используется, когда переменная не указана). Это смещение в символах, за исключением случаев (не рекомендуемых) use bytes pragmas, в которых смещение измеряется в байтах. Обратите внимание, что 0 — это допустимое смещение совпадения. undef указывает, что позиция поиска сброшена (обычно из-за неудачи поиска, но также может произойти, если поиск ещё не выполнялся над скаляром).

pos напрямую обращается к месту, используемому движком регулярных выражений для хранения смещения, поэтому присвоение pos изменит это смещение и, следовательно, повлияет на \G утверждение нулевой длины в регулярных выражениях. Оба эти эффекта происходят для следующего поиска, поэтому вы не можете повлиять на позицию с помощью pos во время текущего поиска, например, в (?{pos() = 5}) или s//pos() = 5/e.

Установка pos также сбрасывает флаг совпадение нулевой длины, описанный в "Повторяющиеся шаблоны, совпадающие с подстрокой нулевой длины" в perlre.

Поскольку неудачный m//gc поиск не сбрасывает смещение, возврат из pos также не изменится в этом случае. См. perlre и perlop.

print FILEHANDLE LIST

print FILEHANDLE

print LIST

print

Выводит строку или список строк. Возвращает true при успехе. FILEHANDLE может быть скалярной переменной, содержащей имя или ссылку на файловый дескриптор, что вводит один уровень косвенности. (ПРИМЕЧАНИЕ: если FILEHANDLE — это переменная, и следующий токен — это термин, он может быть неправильно интерпретирован как оператор, если вы не используете + или не поместите аргументы в скобки.) Если FILEHANDLE опущен, выводит в последний выбранный (см. select) файловый дескриптор вывода. Если LIST опущен, выводит $_ в текущий выбранный файловый дескриптор вывода. Чтобы использовать FILEHANDLE для вывода содержимого $_ в него, вам нужно использовать простой файловый дескриптор, такой как FH, а не косвенный, такой как $fh. Чтобы установить дескриптор вывода по умолчанию на значение, отличное от STDOUT, используйте операцию select.

Текущее значение $, (если есть) выводится между каждым элементом LIST. Текущее значение $\ (если есть) выводится после вывода всего LIST. Поскольку print принимает LIST, все элементы в LIST вычисляются в списке, включая любые подпрограммы, списки возвратов которых вы передаёте в print. Будьте внимательны, чтобы не ставить print за левой скобкой, если вы не хотите, чтобы соответствующая правая скобка завершала аргументы print; поместите все аргументы в скобки (или используйте +, но это не выглядит так хорошо).

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

print { $files[$i] } "stuff\n";
print { $OK ? *STDOUT : *STDERR } "stuff\n";

Выдача на закрытую трубу или сокет сгенерирует сигнал SIGPIPE. См. perlipc для получения более подробной информации об обработке сигналов.

printf FILEHANDLE FORMAT, LIST

printf FILEHANDLE

printf FORMAT, LIST

printf

Эквивалентно print FILEHANDLE sprintf(FORMAT, LIST), за исключением того, что $\ (разделитель записей вывода) не добавляется. FORMAT и LIST на самом деле анализируются как один список. Первый аргумент списка будет интерпретирован как формат printf. Это означает, что printf(@_) будет использовать $_[0] в качестве формата. См. sprintf для объяснения аргумента формата. Если use locale (включая use locale ':not_characters') включен и POSIX::setlocale был вызван, символ, используемый в качестве разделителя десятичных знаков в форматированных числах с плавающей точкой, зависит от настройки локали LC_NUMERIC. См. perllocale и POSIX.

По историческим причинам, если вы опускаете список, $_ используется в качестве формата; чтобы использовать FILEHANDLE без списка, вы должны использовать простой файловый дескриптор, такой как FH, а не косвенный, такой как $fh. Однако, это вряд ли даст желаемый результат; если $_ содержит форматирующие коды, они будут заменены пустой строкой, и будет выведено предупреждение, если warnings включены. Используйте print, если вы хотите вывести содержимое $_.

Не попадайтесь в ловушку использования printf, когда простая print подойдёт. print более эффективна и менее подвержена ошибкам.

prototype FUNCTION

prototype

Возвращает прототип функции в виде строки (или undef, если у функции нет прототипа). FUNCTION — ссылка на функцию или её имя, прототип которой нужно получить. Если FUNCTION опущено, используется $_.

Если FUNCTION — строка, начинающаяся с CORE::, остальная часть принимается как имя встроенной функции Perl. Если аргументы встроенной функции не могут быть адекватно выражены прототипом (например, system), prototype возвращает undef, так как встроенная функция не ведет себя как обычная Perl-функция. В противном случае возвращается строка, описывающая эквивалентный прототип.

push ARRAY,LIST

Обращается с ARRAY как со стеком, добавляя значения LIST в конец ARRAY. Длина ARRAY увеличивается на длину LIST. Эквивалентно

for my $value (LIST) {
    $ARRAY[++$#ARRAY] = $value;
}

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

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

q/STRING/

qq/STRING/

qw/STRING/

qx/STRING/

Обобщённые кавычки. Смотрите "Quote-Like Operators" в perlop.

qr/STRING/

Оператор кавычек для регулярных выражений. Смотрите "Regexp Quote-Like Operators" в perlop.

quotemeta EXPR

quotemeta

Возвращает значение EXPR с экранированными всеми ASCII-символами, не являющимися "словесными" (т.е. все ASCII-символы, не соответствующие /[A-Za-z_0-9]/ , будут предваряться обратной косой чертой в возвращаемой строке, независимо от настроек локали). Это внутренняя функция, реализующая экранирование \Q в строках с двойными кавычками. (См. поведение с не-ASCII кодовыми точками ниже.)

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

quotemeta (и \Q ... \E) полезны при интерполяции строк в регулярные выражения, потому что по умолчанию интерполированная переменная рассматривается как мини-регулярное выражение. Например:

my $sentence = 'The quick brown fox jumped over the lazy dog';
my $substring = 'quick.*?fox';
$sentence =~ s{$substring}{big bad wolf};

приведёт к тому, что $sentence станет 'The big bad wolf jumped over...'.

С другой стороны:

my $sentence = 'The quick brown fox jumped over the lazy dog';
my $substring = 'quick.*?fox';
$sentence =~ s{\Q$substring\E}{big bad wolf};

Или:

my $sentence = 'The quick brown fox jumped over the lazy dog';
my $substring = 'quick.*?fox';
my $quoted_substring = quotemeta($substring);
$sentence =~ s{$quoted_substring}{big bad wolf};

оба оставят предложение без изменений. Обычно, при приёме литеральных строковых данных от пользователя, необходимо использовать quotemeta или \Q.

В Perl v5.14 все не-ASCII символы экранируются в не-UTF-8 кодированных строках, но не экранируются в UTF-8 строках.

Начиная с Perl v5.16, Perl использует стратегию кодирования не-ASCII символов, основанную на Unicode; экранирование ASCII символов не меняется.

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

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

В противном случае Perl экранирует не-ASCII символы, используя адаптацию из Unicode (см. http://www.unicode.org/reports/tr31/). Единственные кодовые точки, которые экранируются, — это те, которые имеют одно из свойств Unicode: Pattern_Syntax, Pattern_White_Space, White_Space, Default_Ignorable_Code_Point или General_Category=Control.

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

Perl обещает, что если мы когда-либо добавим метасимволы регулярных выражений к уже определённому десятку (\ | ( ) [ { ^ $ * + ? .), то будем использовать только те, которые имеют свойство Pattern_Syntax. Perl также обещает, что если мы когда-либо добавим символы, считающиеся пробелами в регулярных выражениях (в настоящее время в основном затронутые /x), то все они будут иметь свойство Pattern_White_Space.

Unicode гарантирует, что набор кодовых точек, обладающих этими двумя свойствами, никогда не изменится, поэтому то, что не экранировалось в v5.16, никогда не будет нуждаться в экранировании в будущих версиях Perl. (Не все кодовые точки, соответствующие Pattern_Syntax, на самом деле получили символы; поэтому есть место для роста, но они экранируются независимо от того, назначены им символы или нет. Perl, разумеется, никогда не будет использовать незанятую кодовую точку в качестве фактического метасимвола.)

Экранирование символов, имеющих другие 3 свойства, выполняется для повышения удобочитаемости регулярного выражения, а не потому, что они фактически нуждаются в экранировании для целей регулярных выражений (символы со свойством White_Space, скорее всего, неразличимы на странице или экране от символов со свойством Pattern_White_Space; а другие две категории содержат непечатаемые символы).

rand EXPR

rand

Возвращает случайное дробное число, большее или равное 0 и меньшее значения EXPR. (EXPR должно быть положительным.) Если EXPR опущено, используется значение 1. В настоящее время EXPR со значением 0 также обрабатывается как специальный случай, как 1 (это не документировалось до Perl 5.8.0 и может измениться в будущих версиях Perl). Автоматически вызывает srand, если srand ещё не вызывался. См. также srand.

Применяйте int к возвращаемому значением rand, если вам нужны случайные целые числа, а не случайные дробные числа. Например,

int(rand(10))

возвращает случайное целое число между 0 и 9, включительно.

(Примечание: Если функция rand постоянно возвращает числа, которые слишком велики или слишком малы, то ваша версия Perl, вероятно, была скомпилирована с неправильным количеством RANDBITS.)

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

read FILEHANDLE,SCALAR,LENGTH,OFFSET

read FILEHANDLE,SCALAR,LENGTH

Попытка прочитать LENGTH символов данных в переменную SCALAR из указанного FILEHANDLE. Возвращает количество фактически прочитанных символов, 0 в конце файла или undef в случае ошибки (в последнем случае $! также установлено). SCALAR будет увеличена или уменьшена так, чтобы последний фактически прочитанный символ был последним символом скаляра после чтения.

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

Вызов реализован на основе либо функции Perl, либо системной функции fread(3). Для получения вызова системной функции read(2) см. sysread.

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

readdir DIRHANDLE

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

Если вы планируете использовать filetest на возвращаемых значениях из readdir, лучше всего префиксровать каталог, о котором идёт речь. В противном случае, так как мы не chdir туда, это будет проверка неправильного файла.

opendir(my $dh, $some_dir) || die "Can't opendir $some_dir: $!";
my @dots = grep { /^\./ && -f "$some_dir/$_" } readdir($dh);
closedir $dh;

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

opendir(my $dh, $some_dir) || die "Can't open $some_dir: $!";
while (readdir $dh) {
    print "$some_dir/$_\n";
}
closedir $dh;

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

use 5.012; # so readdir assigns to $_ in a lone while test

readline EXPR

readline

Читает из файлового дескриптора, типглоб которого содержится в EXPR (или из *ARGV если EXPR не указан). В скалярном контексте каждый вызов читает и возвращает следующую строку до достижения конца файла, после чего последующий вызов возвращает undef. В списочном контексте считывает до конца файла и возвращает список строк. Обратите внимание, что понятие "строка" здесь определяется тем, что вы определили с помощью $/ (или $INPUT_RECORD_SEPARATOR в английском языке). См. "$/" в perlvar.

Когда $/ установлено в undef, когда readline находится в скалярном контексте (т.е., режим считывания всего файла), и когда считывается пустой файл, он возвращает '' в первый раз, а затем undef в последующие разы.

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

my $line = <STDIN>;
my $line = readline(STDIN);    # same thing

Если readline сталкивается с системной ошибкой, $! будет установлено с соответствующим сообщением об ошибке. Это может быть полезно при чтении из файловых дескрипторов, которым вы не доверяете, таких как tty или сокет. Следующий пример использует операторную форму readline и завершается ошибкой, если результат не определён.

while ( ! eof($fh) ) {
    defined( $_ = readline $fh ) or die "readline failed: $!";
    ...
}

Обратите внимание, что вы не можете обработать ошибки readline таким способом с файловым дескриптором ARGV. В этом случае вам нужно самостоятельно открыть каждый элемент @ARGV, поскольку eof обрабатывает ARGV по-другому.

foreach my $arg (@ARGV) {
    open(my $fh, $arg) or warn "Can't open $arg: $!";

    while ( ! eof($fh) ) {
        defined( $_ = readline $fh )
            or die "readline failed for $arg: $!";
        ...
    }
}

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

readlink EXPR

readlink

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

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

readpipe EXPR

readpipe

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

recv SOCKET,SCALAR,LENGTH,FLAGS

Принимает сообщение по сокету. Пытается принять LENGTH символов данных в переменную SCALAR из указанного файлового дескриптора SOCKET. SCALAR будет увеличен или уменьшен до длины, фактически прочитанной. Принимает те же флаги, что и системный вызов с тем же именем. Возвращает адрес отправителя, если протокол SOCKET это поддерживает; в противном случае возвращает пустую строку. В случае ошибки возвращает неопределённое значение. Этот вызов фактически реализован с использованием системного вызова recvfrom(2). См. "UDP: Message Passing" в perlipc для примеров.

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

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

Неоднозначность между именами встроенных типов и именами классов существенно ограничивает полезность ref. Для получения однозначной информации используйте Scalar::Util::blessed() для получения информации об освящении и Scalar::Util::reftype() для получения информации о физических типах. Используйте метод isa для проверки принадлежности к классу, хотя необходимо убедиться в освящённости объекта перед попыткой вызова метода.

См. также perlref и perlobj.

rename OLDNAME,NEWNAME

Изменяет имя файла; существующий файл NEWNAME будет перезаписан. Возвращает true при успехе, false в противном случае.

Поведение этой функции сильно варьируется в зависимости от реализации вашей системы. Например, она обычно не будет работать через границы файловых систем, даже если команда системы mv иногда компенсирует это. Другие ограничения включают то, работает ли она с каталогами, открытыми файлами или существующими файлами. Обратитесь к perlport и либо к странице справки rename(2), либо к соответствующей системной документации для получения подробностей.

Для платформенно-независимой функции move обратитесь к модулю File::Copy.

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

require VERSION

require EXPR

require

Требует версию Perl, указанную в VERSION, или требует определённой семантики, указанной в EXPR, или $_, если EXPR не предоставлен.

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

Использование VERSION в качестве числового аргумента в форме 5.024001 следует избегать, так как это устаревший и менее удобочитаемый синтаксис по сравнению с v5.24.1. До perl 5.8.0 (выпущенного в 2002 году), более громоздкая числовая форма была единственным поддерживаемым синтаксисом, поэтому вы можете встретить её в старом коде.

require v5.24.1;    # run time version check
require 5.24.1;     # ditto
require 5.024_001;  # ditto; older syntax compatible
                      with perl 5.6

В противном случае, require требует включения файла библиотеки, если он ещё не был включён. Файл включается с помощью механизма do-FILE, который по сути является разновидностью eval с оговоркой, что лексические переменные в вызывающем скрипте будут невидимы для включённого кода. Если бы это было реализовано на чистом Perl, оно имело бы семантику, аналогичную следующей:

use Carp 'croak';
use version;

sub require {
    my ($filename) = @_;
    if ( my $version = eval { version->parse($filename) } ) {
        if ( $version > $^V ) {
           my $vn = $version->normal;
           croak "Perl $vn required--this is only $^V, stopped";
        }
        return 1;
    }

    if (exists $INC{$filename}) {
        return 1 if $INC{$filename};
        croak "Compilation failed in require";
    }

    foreach $prefix (@INC) {
        if (ref($prefix)) {
            #... do other stuff - see text below ....
        }
        # (see text below about possible appending of .pmc
        # suffix to $filename)
        my $realfilename = "$prefix/$filename";
        next if ! -e $realfilename || -d _ || -b _;
        $INC{$filename} = $realfilename;
        my $result = do($realfilename);
                     # but run in caller's namespace

        if (!defined $result) {
            $INC{$filename} = undef;
            croak $@ ? "$@Compilation failed in require"
                     : "Can't locate $filename: $!\n";
        }
        if (!$result) {
            delete $INC{$filename};
            croak "$filename did not return true value";
        }
        $! = 0;
        return $result;
    }
    croak "Can't locate $filename in \@INC ...";
}

Обратите внимание, что файл не будет включён дважды под тем же именем.

Файл должен вернуть true в качестве последнего оператора для указания успешного выполнения любого кода инициализации, поэтому принято завершать такой файл 1; , если вы не уверены, что он вернёт true иначе. Но лучше просто поместить 1;, на случай, если вы добавите больше операторов.

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

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

require Foo::Bar;     # a splendid bareword

Функция require фактически будет искать файл Foo/Bar.pm в каталогах, указанных в массиве @INC, и автоматически создаст стек Foo::Bar:: в момент компиляции.

Но если вы попробуете это:

    my $class = 'Foo::Bar';
    require $class;       # $class is not a bareword
#or
    require "Foo::Bar";   # not a bareword because of the ""

Функция require будет искать файл Foo::Bar в массиве @INC и сообщит об отсутствии файла Foo::Bar. В этом случае можно сделать:

eval "require $class";

или можно сделать

require "Foo/Bar.pm";

Ни одна из этих форм не будет автоматически создавать стеки в момент компиляции и будет иметь лишь последствия во время выполнения.

Теперь, когда вы понимаете, как require ищет файлы с аргументом без префиксов, есть небольшая дополнительная функциональность, которая происходит за кулисами. Перед тем, как require будет искать расширение .pm, он сначала будет искать аналогичное имя файла с расширением .pmc. Если этот файл будет найден, он будет загружен вместо любого файла с расширением .pm. Это относится как к явной require "Foo/Bar.pm"; форме, так и к require Foo::Bar; форме.

Вы также можете вставить обработчики в механизм импорта, поместив Perl-код непосредственно в массив @INC. Существует три вида обработчиков: ссылки на подпрограммы, ссылки на массивы и освящённые объекты.

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

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

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

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

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

push @INC, \&my_sub;
sub my_sub {
    my ($coderef, $filename) = @_;  # $coderef is \&my_sub
    ...
}

или:

push @INC, [ \&my_sub, $x, $y, ... ];
sub my_sub {
    my ($arrayref, $filename) = @_;
    # Retrieve $x, $y, ...
    my (undef, @parameters) = @$arrayref;
    ...
}

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

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

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

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

Для ещё более мощного механизма импорта см. use и perlmod.

reset EXPR

reset

Обычно используется в блоке continue в конце цикла для очистки переменных и сброса m?pattern? поисков, чтобы они работали снова. Выражение интерпретируется как список отдельных символов (разрешены тире для диапазонов). Все переменные и массивы, начинающиеся с одной из этих букв, сбрасываются до первоначального состояния. Если выражение опущено, поиски по одному совпадению (m?pattern?) сбрасываются для повторного совпадения. Сбрасываются только переменные или поиски в текущем пакете. Всегда возвращает 1. Примеры:

reset 'X';      # reset all X variables
reset 'a-z';    # reset lower case variables
reset;          # just reset m?one-time? searches

Сброс "A-Z" не рекомендуется, потому что вы стёрте массивы @ARGV и @INC и хеш %ENV. Сбрасываются только переменные пакета; лексические переменные не затрагиваются, но они очищаются при выходе из области видимости, поэтому, вероятно, их следует использовать вместо этого. См. my.

return EXPR

return

Возвращает значение из подпрограммы, eval, do FILE, блока sort или блока вычисления регулярных выражений (но не блока grep или map) со значением, заданным в EXPR. Вычисление EXPR может выполняться в списковом, скалярном или пустом контексте в зависимости от того, как будет использоваться возвращаемое значение, и контекст может изменяться от одного выполнения к другому (см. wantarray). Если EXPR не указан, возвращается пустой список в списковом контексте, неопределённое значение в скалярном контексте и (конечно) ничего вообще в пустом контексте.

(В отсутствие явного return подпрограмма, eval или do FILE автоматически возвращает значение последнего вычисленного выражения.)

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

reverse LIST

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

print join(", ", reverse "world", "Hello"); # Hello, world

print scalar reverse "dlrow ,", "olleH";    # Hello, world

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

$_ = "dlrow ,olleH";
print reverse;                         # No output, list context
print scalar reverse;                  # Hello, world

Обратите внимание, что обращение массива к самому себе (как в @a = reverse @a) сохранит несуществующие элементы, где это возможно; то есть, для не магических массивов или для связанных массивов с методами EXISTS и DELETE.

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

my %by_name = reverse %by_address;  # Invert the hash

rewinddir DIRHANDLE

Устанавливает текущую позицию в начало каталога для процедуры readdir в DIRHANDLE.

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

rindex STR,SUBSTR,POSITION

rindex STR,SUBSTR

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

rmdir FILENAME

rmdir

Удаляет каталог, указанный FILENAME, если этот каталог пуст. В случае успеха возвращает true; в противном случае возвращает false и устанавливает $! (errno). Если FILENAME опущено, используется $_.

Для рекурсивного удаления дерева каталогов (rm -rf в Unix) обратитесь к функции rmtree модуля File::Path.

s///

Оператор подстановки. См. "Операторы Regexp Quote-Like" в perlop.

say FILEHANDLE LIST

say FILEHANDLE

say LIST

say

Подобно print, но неявно добавляет перевод строки. say LIST — просто сокращение для { local $\ = "\n"; 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, это будет работать как скалярное выражение с запятыми, оценивая все элементы, кроме последнего, в контексте void и возвращая последний оцененный элемент в скалярном контексте. В редких случаях это то, что нужно.

Следующее единственное утверждение:

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 на некоторых системах нужно выполнить поиск при переключении между чтением и записью. Среди прочего, это может привести к вызову stdio's clearerr(3).

WHENCE, равное 1 (SEEK_CUR) полезно, чтобы не перемещать позицию файла:

seek($fh, 0, 1);

Это также полезно для приложений, эмулирующих tail -f. После достижения EOF при чтении и последующего ожидания некоторое время (вероятно), необходимо поместить фиктивный seek для сброса состояния. seek не меняет позицию, но очищает состояние конца файла в обработчике, чтобы следующий readline FILE заставил Perl попытаться прочитать что-то заново. (Мы надеемся.)

Если это не работает (некоторые реализации ввода-вывода особенно капризны), вам может потребоваться что-то вроде этого:

for (;;) {
    for ($curpos = tell($fh); $_ = readline($fh);
         $curpos = tell($fh)) {
        # search for some stuff and put it into files
    }
    sleep($for_a_while);
    seek($fh, $curpos, 0);
}

seekdir DIRHANDLE,POS

Устанавливает текущую позицию для процедуры readdir в DIRHANDLE. POS должно быть значением, возвращённым telldir. seekdir также имеет те же оговорки относительно возможной уплотнения каталога, что и соответствующая системная библиотечная функция.

select FILEHANDLE

select

Возвращает текущий выбранный файловый дескриптор. Если FILEHANDLE указан, устанавливает новый текущий стандартный файловый дескриптор для вывода. Это имеет два эффекта: во-первых, write или print без файлового дескриптора по умолчанию будут направлены в этот FILEHANDLE. Во-вторых, ссылки на переменные, связанные с выводом, будут ссылаться на этот выходной канал.

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

select(REPORT1);
$^ = 'report1_top';
select(REPORT2);
$^ = 'report2_top';

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

my $oldfh = select(STDERR); $| = 1; select($oldfh);

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

STDERR->autoflush(1);

(До версии Perl 5.14 нужно use IO::Handle; явно сначала.)

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

select RBITS,WBITS,EBITS,TIMEOUT

Этот вызов системы select(2) с указанными битовыми масками, которые можно создать с помощью fileno и vec, примерно так:

my $rin = my $win = my $ein = '';
vec($rin, fileno(STDIN),  1) = 1;
vec($win, fileno(STDOUT), 1) = 1;
$ein = $rin | $win;

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

sub fhbits {
    my @fhlist = @_;
    my $bits = "";
    for my $fh (@fhlist) {
        vec($bits, fileno($fh), 1) = 1;
    }
    return $bits;
}
my $rin = fhbits(\*STDIN, $tty, $mysock);

Обычный приём:

my ($nfound, $timeleft) =
  select(my $rout = $rin, my $wout = $win, my $eout = $ein,
                                                         $timeout);

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

my $nfound =
  select(my $rout = $rin, my $wout = $win, my $eout = $ein, undef);

Большинство систем не беспокоятся о возвращении чего-то полезного в $timeleft, поэтому вызов select в скалярном контексте просто возвращает $nfound.

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

Вы можете вызвать задержку на 250 миллисекунд так:

select(undef, undef, undef, 0.25);

Обратите внимание, что независимо от того, перезапускается ли select после сигналов (например, SIGALRM), зависит от реализации. См. также perlport для замечаний о портативности select.

При ошибке select ведёт себя так же, как select(2): возвращает -1 и устанавливает $!.

На некоторых 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

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

use IPC::SysV;

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

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

semget KEY,NSEMS,FLAGS

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

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

semop KEY,OPSTRING

Вызывает системную функцию System V IPC semop(2) для операций с семафорами, таких как сигнализация и ожидание. OPSTRING должен быть упакованным массивом структур semop. Каждая структура semop может быть сгенерирована с помощью pack("s!3", $semnum, $semop, $semflag). Длина OPSTRING указывает количество операций с семафором. Возвращает true при успехе, false при ошибке. Например, следующий код ожидает на семафоре $semnum с идентификатором семафора $semid:

my $semop = pack("s!3", $semnum, -1, 0);
die "Semaphore trouble: $!\n" unless semop($semid, $semop);

Для сигнализации семафору замените -1 на 1. См. также "SysV IPC" в perlipc и документацию по IPC::SysV и IPC::Semaphore.

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

send SOCKET,MSG,FLAGS,TO

send SOCKET,MSG,FLAGS

Отправляет сообщение по сокету. Попытка отправить скаляр MSG в файл-дескриптор SOCKET. Принимает те же флаги, что и системный вызов с таким же именем. Для неподключенных сокетов необходимо указать пункт назначения, в этом случае используется вызов sendto(2). Возвращает количество отправленных символов или неопределенное значение при ошибке. Системный вызов sendmsg(2) в настоящее время не реализован. См. "UDP: Передача сообщений" в perlipc для примеров.

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

setpgrp PID,PGRP

Устанавливает текущую группу процессов для указанного PID, 0 для текущего процесса. Вызывает исключение, когда используется на машине, которая не реализует POSIX setpgid(2) или BSD setpgrp(2). Если аргументы опущены, по умолчанию используется 0,0. Обратите внимание, что версия BSD 4.2 setpgrp не принимает аргументы, поэтому только setpgrp(0,0) является портативной. См. также POSIX::setsid().

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

setpriority WHICH,WHO,PRIORITY

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

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

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

setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL

Устанавливает запрашиваемый параметр сокета. Возвращает undef при ошибке. Используйте целочисленные константы, предоставленные модулем Socket, для LEVEL и OPNAME. Значения для LEVEL также можно получить из getprotobyname. OPTVAL может быть либо упакованной строкой, либо целым числом. Целое число OPTVAL — это сокращение для pack("i", OPTVAL).

Пример отключения алгоритма Nagle для сокета:

use Socket qw(IPPROTO_TCP TCP_NODELAY);
setsockopt($socket, IPPROTO_TCP, TCP_NODELAY, 1);

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

shift ARRAY

shift

Сдвигает первое значение массива и возвращает его, укорачивая массив на 1 и перемещая всё ниже. Если в массиве нет элементов, возвращает неопределённое значение. Если ARRAY опущен, сдвигает массив @_ внутри лексического пространства подпрограмм и форматов, и массив @ARGV вне подпрограммы, а также внутри лексических пространств, созданных конструкциями eval STRING, BEGIN {}, INIT {}, CHECK {}, UNITCHECK {}, и END {}.

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

См. также unshift, push и pop. shift и unshift делают то же самое с левым концом массива, что pop и push делают с правым концом.

shmctl ID,CMD,ARG

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

use IPC::SysV;

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

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

shmget KEY,SIZE,FLAGS

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

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

shmread ID,VAR,POS,SIZE

shmwrite ID,STRING,POS,SIZE

Читает или записывает сегмент разделяемой памяти System V с идентификатором ID, начиная с позиции POS размером SIZE, прикрепляясь к нему, копируя в/из него и открепляясь от него. При чтении VAR должна быть переменной, которая будет хранить считанные данные. При записи, если STRING слишком длинный, используются только SIZE байт; если STRING слишком короткий, нули записываются, чтобы заполнить SIZE байт. Возвращает true при успехе, false при ошибке. shmread загрязняет переменную. См. также "SysV IPC" в perlipc и документацию по IPC::SysV и модулю IPC::Shareable из CPAN.

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

shutdown SOCKET,HOW

Закрывает соединение по сокету указанным способом HOW, который имеет такое же толкование, как и в системном вызове с таким же именем.

shutdown($socket, 0);    # I/we have stopped reading data
shutdown($socket, 1);    # I/we have stopped writing data
shutdown($socket, 2);    # I/we have stopped using this socket

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

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

sin EXPR

sin

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

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

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

sleep EXPR

sleep

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

Может быть прервано, если процесс получает сигнал, такой как SIGALRM.

eval {
    local $SIG{ALRM} = sub { die "Alarm!\n" };
    sleep;
};
die $@ unless $@ eq "Alarm!\n";

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

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

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

См. также функцию POSIX модуля pause.

socket SOCKET,DOMAIN,TYPE,PROTOCOL

Открывает сокет указанного типа и привязывает его к файловому дескриптору SOCKET. DOMAIN, TYPE и PROTOCOL задаются так же, как и для системного вызова с тем же именем. Сначала необходимо use Socket, чтобы получить правильные определения. См. примеры в "Sockets: Client/Server Communication" в perlipc.

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

socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL

Создаёт неопределённую пару сокетов в указанном домене, заданного типа. DOMAIN, TYPE и PROTOCOL задаются так же, как и для системного вызова с тем же именем. Если не реализовано, вызывает исключение. Возвращает true в случае успеха.

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

В некоторых системах pipe определяется через socketpair, в котором вызов pipe($rdr, $wtr) эквивалентен:

use Socket;
socketpair(my $rdr, my $wtr, AF_UNIX, SOCK_STREAM, PF_UNSPEC);
shutdown($rdr, 1);        # no more writing for reader
shutdown($wtr, 0);        # no more reading for writer

См. perlipc для примера использования socketpair. Perl 5.8 и более поздние версии будут эмулировать socketpair с использованием IP-сокетов к localhost, если ваша система реализует сокеты, но не socketpair.

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

sort SUBNAME LIST

sort BLOCK LIST

sort LIST

В контексте списка эта функция сортирует LIST и возвращает отсортированный список. В скалярном контексте поведение sort не определено.

Если SUBNAME или BLOCK пропущены, sort выполняется в стандартном порядке сравнения строк. Если SUBNAME указан, он задаёт имя подпрограммы, которая возвращает целое число меньше, равно или больше 0, в зависимости от порядка элементов списка. (Операторы <=> и cmp чрезвычайно полезны в таких процедурах.) SUBNAME может быть именем скалярной переменной (без индексации), в этом случае значение предоставляет имя (или ссылку на) фактическую подпрограмму для использования. Вместо SUBNAME можно указать блок как анонимную, встроенную подпрограмму сортировки.

Если прототип подпрограммы ($$), элементы для сравнения передаются по ссылке в @_, как и в обычной подпрограмме. Это медленнее, чем нетипизированные подпрограммы, где элементы для сравнения передаются в подпрограмму как глобальные переменные пакета $a и $b (см. пример ниже).

Если подпрограмма является XSUB, элементы для сравнения помещаются в стек, так же, как обычно передаются аргументы в XSUB. $a и $b не устанавливаются.

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

Также нельзя завершать выполнение блока сортировки или подпрограммы с помощью операторов управления циклом, описанных в perlsyn, или с помощью goto.

Когда use locale (но не use locale ':not_characters') активна, sort LIST сортирует LIST в соответствии с текущим регионом сортировки. См. perllocale.

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

Исторически Perl по-разному обрабатывал стабильность сортировки по умолчанию. Если стабильность важна, она может быть явно контролируется с помощью прагмы sort.

Примеры:

# sort lexically
my @articles = sort @files;

# same thing, but with explicit sort routine
my @articles = sort {$a cmp $b} @files;

# now case-insensitively
my @articles = sort {fc($a) cmp fc($b)} @files;

# same thing in reversed order
my @articles = sort {$b cmp $a} @files;

# sort numerically ascending
my @articles = sort {$a <=> $b} @files;

# sort numerically descending
my @articles = sort {$b <=> $a} @files;

# this sorts the %age hash by value instead of key
# using an in-line function
my @eldest = sort { $age{$b} <=> $age{$a} } keys %age;

# sort using explicit subroutine name
sub byage {
    $age{$a} <=> $age{$b};  # presuming numeric
}
my @sortedclass = sort byage @class;

sub backwards { $b cmp $a }
my @harry  = qw(dog cat x Cain Abel);
my @george = qw(gone chased yz Punished Axed);
print sort @harry;
    # prints AbelCaincatdogx
print sort backwards @harry;
    # prints xdogcatCainAbel
print sort @george, 'to', @harry;
    # prints AbelAxedCainPunishedcatchaseddoggonetoxyz

# inefficiently sort by descending numeric compare using
# the first integer after the first = sign, or the
# whole record case-insensitively otherwise

my @new = sort {
    ($b =~ /=(\d+)/)[0] <=> ($a =~ /=(\d+)/)[0]
                        ||
                fc($a)  cmp  fc($b)
} @old;

# same thing, but much more efficiently;
# we'll build auxiliary indices instead
# for speed
my (@nums, @caps);
for (@old) {
    push @nums, ( /=(\d+)/ ? $1 : undef );
    push @caps, fc($_);
}

my @new = @old[ sort {
                       $nums[$b] <=> $nums[$a]
                                ||
                       $caps[$a] cmp $caps[$b]
                     } 0..$#old
              ];

# same thing, but without any temps
my @new = map { $_->[0] }
       sort { $b->[1] <=> $a->[1]
                       ||
              $a->[2] cmp $b->[2]
       } map { [$_, /=(\d+)/, fc($_)] } @old;

# using a prototype allows you to use any comparison subroutine
# as a sort subroutine (including other package's subroutines)
package Other;
sub backwards ($$) { $_[1] cmp $_[0]; }  # $a and $b are
                                         # not set here
package main;
my @new = sort Other::backwards @old;

# guarantee stability
use sort 'stable';
my @new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;

Предупреждение: при сортировке списка, возвращаемого функцией, требуется внимательность. Если вы хотите отсортировать список, возвращаемый вызовом функции find_records(@key), вы можете использовать:

my @contact = sort { $a cmp $b } find_records @key;
my @contact = sort +find_records(@key);
my @contact = sort &find_records(@key);
my @contact = sort(find_records(@key));

Если вместо этого вы хотите отсортировать массив @key с помощью функции сравнения find_records(), вы можете использовать:

my @contact = sort { find_records() } @key;
my @contact = sort find_records(@key);
my @contact = sort(find_records @key);
my @contact = sort(find_records (@key));

$a и $b устанавливаются как глобальные переменные пакета, в котором вызывается sort(). Это означает $main::a и $main::b (или $::a и $::b) в пакете main, $FooPack::a и $FooPack::b в пакете FooPack и т.д. Если блок сортировки находится в области действия объявления my или state переменных $a и/или $b, вы обязательно должны указывать полное имя переменных в блоке сортировки:

package main;
my $a = "C"; # DANGER, Will Robinson, DANGER !!!

print sort { $a cmp $b }               qw(A C E G B D F H);
                                       # WRONG
sub badlexi { $a cmp $b }
print sort badlexi                     qw(A C E G B D F H);
                                       # WRONG
# the above prints BACFEDGH or some other incorrect ordering

print sort { $::a cmp $::b }           qw(A C E G B D F H);
                                       # OK
print sort { our $a cmp our $b }       qw(A C E G B D F H);
                                       # also OK
print sort { our ($a, $b); $a cmp $b } qw(A C E G B D F H);
                                       # also OK
sub lexi { our $a cmp our $b }
print sort lexi                        qw(A C E G B D F H);
                                       # also OK
# the above print ABCDEFGH

При надлежащем уходе вы можете смешивать переменные пакета и my (или state) $a и/или $b.

my $a = {
   tiny   => -2,
   small  => -1,
   normal => 0,
   big    => 1,
   huge   => 2
};

say sort { $a->{our $a} <=> $a->{our $b} }
    qw{ huge normal tiny small big};

# prints tinysmallnormalbighuge

$a и $b неявным образом локальны для выполнения sort() и восстанавливают свои предыдущие значения по завершении сортировки.

Подпрограммы сортировки, написанные с использованием $a и $b, привязаны к вызывающему их пакету. Возможно, но малоинтересно, определить их в другом пакете, поскольку подпрограмма всё равно должна ссылаться на $a и $b вызывающего пакета:

package Foo;
sub lexi { $Bar::a cmp $Bar::b }
package Bar;
... sort Foo::lexi ...

Используйте типизированные версии (см. выше) для более универсальной альтернативы.

Функция сравнения должна правильно работать. Если она возвращает несогласованные результаты (иногда утверждая, что $x[1] меньше $x[2], а иногда наоборот, например), результаты не определены.

Поскольку <=> возвращает undef, когда один из операндов является NaN (не числом), будьте осторожны при сортировке с помощью функции сравнения, подобной $a <=> $b, любых списков, которые могут содержать NaN. Следующий пример использует NaN != NaN для исключения любых NaN из входного списка.

my @result = sort { $a <=> $b } grep { $_ == $_ } @input;

splice ARRAY,OFFSET,LENGTH,LIST

splice ARRAY,OFFSET,LENGTH

splice ARRAY,OFFSET

splice ARRAY

Удаляет элементы, указанные OFFSET и LENGTH, из массива, и заменяет их элементами LIST, если таковые имеются. В контексте списка возвращает элементы, удаленные из массива. В скалярном контексте возвращает последний удалённый элемент или undef, если элементы не были удалены. Массив увеличивается или уменьшается по мере необходимости. Если OFFSET отрицательный, он начинается на этом расстоянии от конца массива. Если LENGTH пропущен, удаляются все элементы с OFFSET и далее. Если LENGTH отрицательный, удаляются элементы с OFFSET и далее, за исключением -LENGTH элементов в конце массива. Если оба OFFSET и LENGTH пропущены, удаляются все элементы. Если OFFSET находится за пределами массива, и был предоставлен LENGTH, Perl выдает предупреждение и вставляет элементы в конец массива.

Следующие эквивалентности выполняются (предполагая $#a >= $i )

push(@a,$x,$y)      splice(@a,@a,0,$x,$y)
pop(@a)             splice(@a,-1)
shift(@a)           splice(@a,0,1)
unshift(@a,$x,$y)   splice(@a,0,0,$x,$y)
$a[$i] = $y         splice(@a,$i,1,$y)

splice может использоваться, например, для реализации обработки очереди n-арных элементов:

sub nary_print {
  my $n = shift;
  while (my @next_n = splice @_, 0, $n) {
    say join q{ -- }, @next_n;
  }
}

nary_print(3, qw(a b c d e f g h));
# prints:
#   a -- b -- c
#   d -- e -- f
#   g -- h

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

split /PATTERN/,EXPR,LIMIT

split /PATTERN/,EXPR

split /PATTERN/

split

Разделяет строку EXPR на список строк и возвращает этот список в контексте списка, или размер списка в скалярном контексте. (До Perl 5.11 также перезаписывал @_ списком в пустом и скалярном контексте. Будьте осторожны, если вы нацеливаетесь на старые версии Perl.)

Если указан только PATTERN, EXPR по умолчанию равен $_.

Любое вхождение в EXPR, которое соответствует PATTERN, рассматривается как разделитель, разделяющий EXPR на подстроки (называемые «полями»), которые не включают разделитель. Обратите внимание, что разделитель может быть длиннее одного символа или даже не содержать символов вообще (пустая строка, которая соответствует нулевой длине).

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

Если PATTERN соответствует пустой строке, EXPR разделяется в позиции совпадения (между символами). Например:

print join(':', split(/b/, 'abc')), "\n";

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

print join(':', split(//, 'abc')), "\n";

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

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

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

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

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

Начиная с Perl 5.28, это специальное разбиение по пробелам работает как ожидается в рамках "use feature 'unicode_strings". В предыдущих версиях и вне области действия этой функции наблюдается "Ошибка Unicode" в perlunicode: символы, являющиеся пробелами согласно правилам Unicode, но не согласно правилам ASCII, могут обрабатываться как часть полей, а не как разделители полей, в зависимости от кодировки строки.

Если опущен, PATTERN по умолчанию равен одному пробелу, " ", что вызывает описанную выше эмуляцию awk.

Если LIMIT задан и положителен, он представляет собой максимальное количество полей, на которые может быть разделен EXPR; другими словами, LIMIT на единицу больше максимального числа разбиений EXPR. Таким образом, значение LIMIT 1 означает, что EXPR может быть разделен не более чем нуль раз, что даёт максимум одно поле (а именно, всё значение EXPR). Например:

print join(':', split(//, 'abc', 1)), "\n";

выдает результат abc, а это:

print join(':', split(//, 'abc', 2)), "\n";

выдает результат a:bc, и каждое из этих:

print join(':', split(//, 'abc', 3)), "\n";
print join(':', split(//, 'abc', 4)), "\n";

выдает результат a:b:c.

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

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

print join(':', split(/,/, 'a,b,c,,,')), "\n";

выдает результат a:b:c, но следующее:

print join(':', split(/,/, 'a,b,c,,,', -1)), "\n";

выдает результат a:b:c:::.

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

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

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

Пустое ведущее поле создаётся, когда совпадение ненулевой длины находится в начале EXPR. Например:

print join(':', split(/ /, ' abc')), "\n";

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

print join(':', split(//, ' abc'));

выдает результат :a:b:c (а не : :a:b:c).

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

print join(':', split(//, ' abc', -1)), "\n";

выдает результат :a:b:c:.

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

split(/-|,/, "1-10,20", 3)
# ('1', '10', '20')

split(/(-|,)/, "1-10,20", 3)
# ('1', '-', '10', ',', '20')

split(/-|(,)/, "1-10,20", 3)
# ('1', undef, '10', ',', '20')

split(/(-)|,/, "1-10,20", 3)
# ('1', '-', '10', undef, '20')

split(/(-)|(,)/, "1-10,20", 3)
# ('1', '-', undef, '10', undef, ',', '20')

sprintf FORMAT, LIST

Возвращает строку, отформатированную по обычным printf соглашениям функции C-библиотеки sprintf. Более подробная информация приведена ниже, а также см. sprintf(3) или printf(3) на вашей системе для объяснения общих принципов.

Например:

# Format number with up to 8 leading zeroes
my $result = sprintf("%08d", $number);

# Round number to 3 digits after decimal point
my $rounded = sprintf("%.3f", $number);

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

В отличие от printf, sprintf не делает того, что вы, вероятно, имеете в виду, когда передаёте массив в качестве первого аргумента. Массив передаётся в скалярный контекст, и вместо использования 0-го элемента массива в качестве формата, 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 only with a C99 compiler
            prior to Perl 5.30 (unportable)
l           interpret integer as C type "long" or
            "unsigned long"
q, L, or ll interpret integer as C type "long long",
            "unsigned long long", or "quad" (typically
            64-bit integers)
t           interpret integer as C type "ptrdiff_t" on Perl
            5.14 or later
z           interpret integer as C type "size_t" on Perl 5.14
            or later

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

use warnings FATAL => "printf";

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

use 5.014;  # for hh/j/t/z/ printf modifiers

Вы можете узнать, поддерживает ли ваш Perl квадры, используя Config:

use Config;
if ($Config{use64bitint} eq "define"
    || $Config{longsize} >= 8) {
    print "Nice quads!\n";
}

Для преобразований с плавающей точкой (e f g E F G), числа обычно предполагаются с размером плавающей точкой по умолчанию на вашей платформе (double или long double), но вы можете принудительно использовать "long double" с q, L, или ll если ваша платформа их поддерживает. Вы можете узнать, поддерживает ли ваш Perl long doubles, используя Config:

use Config;
print "long doubles\n" if $Config{d_longdbl} eq "define";

Вы можете узнать, считает ли Perl "long double" значением по умолчанию для плавающей точки на вашей платформе, используя Config:

use Config;
if ($Config{uselongdouble} eq "define") {
    print "long doubles by default\n";
}

Также может быть, что long doubles и doubles - это одно и то же:

use Config;
($Config{doublesize} == $Config{longdblsize}) &&
        print "doubles are long doubles\n";

Спецификатор размера V не имеет эффекта для кода Perl, но поддерживается для совместимости с XS-кодом. Это означает "использовать стандартный размер для целого числа или числа с плавающей точкой Perl", что является значением по умолчанию.

порядок аргументов

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

Например:

printf "<%*.*s>", $a, $b, $c;

использует $a для ширины, $b для точности и $c в качестве значения для форматирования; в то время как:

printf '<%*1$.*s>', $a, $b;

использовало бы $a для ширины и точности, и $b как значение для форматирования.

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

printf "%2\$d %d\n",      12, 34;     # will print "34 12\n"
printf "%2\$d %d %d\n",   12, 34;     # will print "34 12 34\n"
printf "%3\$d %d %d\n",   12, 34, 56; # will print "56 12 34\n"
printf "%2\$*3\$d %d\n",  12, 34,  3; # will print " 34 12\n"
printf "%*1\$.*f\n",       4,  5, 10; # will print "5.0000\n"

Если use locale (включая use locale ':not_characters') активно и POSIX::setlocale был вызван, символ, используемый для десятичного разделителя в отформатированных числах с плавающей точкой, зависит от LC_NUMERIC локали. См. perllocale и POSIX.

sqrt EXPR

sqrt

Возвращает положительный квадратный корень из EXPR. Если EXPR опущено, используется $_. Работает только для неотрицательных операндов, если вы не загрузили модуль Math::Complex.

use Math::Complex;
print sqrt(-4);    # prints 2i

srand EXPR

srand

Устанавливает и возвращает начальное значение для генерации случайных чисел для оператора rand.

Цель функции — задать «семя» для функции rand, чтобы rand генерировала различную последовательность каждый раз при запуске программы. При вызове с параметром srand использует этот параметр в качестве семени; в противном случае выбирает (полу-)случайное семя. В любом случае, начиная с Perl 5.14, она возвращает семя. Чтобы указать, что ваш код будет работать только с Perl недавних версий:

use 5.014;  # so srand returns the seed

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

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

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

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

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

stat FILEHANDLE

stat EXPR

stat DIRHANDLE

stat

Возвращает список из 13 элементов, содержащий информацию о состоянии файла, либо файла, открытого через FILEHANDLE или DIRHANDLE, либо указанного именем EXPR. Если EXPR опущен, она выполняет stat для $_ (а не _!). Возвращает пустой список, если stat завершается неудачно. Обычно используется следующим образом:

my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
    $atime,$mtime,$ctime,$blksize,$blocks)
       = stat($filename);

Не все поля поддерживаются на всех типах файловых систем. Вот значения полей:

 0 dev      device number of filesystem
 1 ino      inode number
 2 mode     file mode  (type and permissions)
 3 nlink    number of (hard) links to the file
 4 uid      numeric user ID of file's owner
 5 gid      numeric group ID of file's owner
 6 rdev     the device identifier (special files only)
 7 size     total size of file, in bytes
 8 atime    last access time in seconds since the epoch
 9 mtime    last modify time in seconds since the epoch
10 ctime    inode change time in seconds since the epoch (*)
11 blksize  preferred I/O size in bytes for interacting with the
            file (may vary from file to file)
12 blocks   actual number of system-specific blocks allocated
            on disk (often, but not always, 512 bytes each)

(Эпоха была в 00:00 1 января 1970 года по Гринвичу.)

(*) Не все поля поддерживаются на всех типах файловых систем. В частности, поле ctime не является переносимым. В частности, вы не можете ожидать, что это будет «время создания»; см. "Файлы и файловые системы" в perlport для получения подробностей.

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

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

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

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

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

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

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

См. perlsub и perlref для получения подробностей о подпрограммах и ссылках; см. attributes и Attribute::Handlers для получения дополнительной информации об атрибутах.

__SUB__

Специальный токен, возвращающий ссылку на текущую подпрограмму или undef вне подпрограммы.

Поведение __SUB__ внутри блока кода регулярного выражения (например, /(?{...})/) может измениться.

Этот токен доступен только при use v5.16 или функции "current_sub". См. feature.

substr EXPR,OFFSET,LENGTH,REPLACEMENT

substr EXPR,OFFSET,LENGTH

substr EXPR,OFFSET

Извлекает подстроку из EXPR и возвращает её. Первый символ имеет смещение ноль. Если OFFSET отрицателен, он отсчитывается от конца строки. Если LENGTH опущен, возвращается всё до конца строки. Если LENGTH отрицателен, отбрасывается указанное количество символов с конца строки.

my $s = "The black cat climbed the green tree";
my $color  = substr $s, 4, 5;      # black
my $middle = substr $s, 4, -11;    # black cat climbed the
my $end    = substr $s, 14;        # climbed the green tree
my $tail   = substr $s, -4;        # tree
my $z      = substr $s, -4, 2;     # tr

Вы можете использовать функцию substr как lvalue, в этом случае EXPR также должно быть lvalue. Если вы присваиваете значение короче, чем LENGTH, строка уменьшится, а если длиннее, строка увеличится, чтобы вместить его. Для сохранения длины строки может потребоваться дополнение или обрезка значения с помощью sprintf.

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

my $name = 'fred';
substr($name, 4) = 'dy';         # $name is now 'freddy'
my $null = substr $name, 6, 2;   # returns "" (no warning)
my $oops = substr $name, 7;      # returns undef, with warning
substr($name, 7) = 'gap';        # raises an exception

Альтернатива использованию substr как lvalue — это задание строки замены в качестве четвёртого аргумента. Это позволяет заменить части EXPR и вернуть то, что было до этого, за одну операцию, точно так же, как вы можете сделать с помощью splice.

my $s = "The black cat climbed the green tree";
my $z = substr $s, 14, 7, "jumped from";    # climbed
# $s is now "The black cat jumped from the green tree"

Обратите внимание, что lvalue, возвращаемое трёхаргументной версией substr, действует как «волшебная пуля»; каждый раз при присваивании она запоминает, какая часть исходной строки изменяется; например:

my $x = '1234';
for (substr($x,1,2)) {
    $_ = 'a';   print $x,"\n";    # prints 1a4
    $_ = 'xyz'; print $x,"\n";    # prints 1xyz4
    $x = '56789';
    $_ = 'pq';  print $x,"\n";    # prints 5pq9
}

С отрицательными смещениями она запоминает своё положение от конца строки, когда целевая строка изменяется:

my $x = '1234';
for (substr($x, -3, 2)) {
    $_ = 'a';   print $x,"\n";    # prints 1a4, as above
    $x = 'abcdefg';
    print $_,"\n";                # prints f
}

До версии Perl 5.10 результат использования lvalue несколько раз был неопределённым. До версии 5.16 результат с отрицательными смещениями был неопределённым.

symlink OLDFILE,NEWFILE

Создаёт новое имя файла, символически связанное со старым именем файла. Возвращает 1 при успехе, 0 в противном случае. На системах, не поддерживающих символические ссылки, генерирует исключение. Для проверки этого используйте eval:

my $symlink_exists = eval { symlink("",""); 1 };

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

syscall NUMBER, LIST

Вызывает системный вызов, указанный как первый элемент списка, передавая оставшиеся элементы в качестве аргументов системному вызову. Если не реализовано, вызывает исключение. Аргументы интерпретируются следующим образом: если данный аргумент числовой, аргумент передаётся как int. Если нет, передаётся указатель на строковое значение. Вы несёте ответственность за обеспечение того, чтобы строка была достаточно расширена, чтобы принять любой результат, который может быть записан в строку. Вы не можете использовать строковую литерал (или другую неизменяемую строку) в качестве аргумента для syscall, потому что Perl должен предполагать, что любой указатель на строку может быть записан. Если ваши целочисленные аргументы не являются литералами и никогда не интерпретировались в числовом контексте, вам может потребоваться добавить 0, чтобы они выглядели как числа. Это эмулирует функцию syswrite (или наоборот):

require 'syscall.ph';        # may need to run h2ph
my $s = "hi there\n";
syscall(SYS_write(), fileno(STDOUT), $s, length $s);

Обратите внимание, что Perl поддерживает передачу не более 14 аргументов вашему системному вызову, чего, как правило, достаточно.

Syscall возвращает то значение, которое возвращает системный вызов. Если системный вызов завершается ошибкой, syscall возвращает -1 и устанавливает $! (errno). Обратите внимание, что некоторые системные вызовы могут законно вернуть -1. Правильный способ обработки таких вызовов — присвоить $! = 0 перед вызовом, затем проверить значение $!, если syscall возвращает -1.

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

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

sysopen FILEHANDLE,FILENAME,MODE

sysopen FILEHANDLE,FILENAME,MODE,PERMS

Открывает файл с заданным именем FILENAME и связывает его с FILEHANDLE. Если FILEHANDLE является выражением, его значение используется в качестве фактического имени файла; неопределённый скаляр будет надлежащим образом автоматизирован. Эта функция вызывает функцию системного открывания open(2) с параметрами FILENAME, MODE и PERMS.

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

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

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

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

Если файл с именем FILENAME не существует, и вызов open создаёт его (обычно, потому что MODE включает флаг O_CREAT), то значение PERMS задаёт разрешения вновь созданного файла. Если вы опустите аргумент PERMS в sysopen, Perl использует восьмеричное значение 0666. Эти значения разрешений должны быть восьмеричными и модифицируются текущим значением маски umask вашего процесса.

Во многих системах доступен флаг O_EXCL для открытия файлов в эксклюзивном режиме. Это не блокировка: эксклюзивность означает здесь, что если файл уже существует, sysopen завершается ошибкой. O_EXCL может не работать с сетевыми файловыми системами и не имеет эффекта, если не установлен флаг O_CREAT. Установка O_CREAT|O_EXCL предотвращает открытие файла, если это символическая ссылка. Она не защищает от символических ссылок в пути к файлу.

Иногда вам может потребоваться обнулить уже существующий файл. Это можно сделать с помощью флага O_TRUNC. Поведение O_TRUNC с флагом O_RDONLY неопределённо.

Вы редко, если вообще когда-либо, должны использовать 0644 как аргумент для sysopen, так как это лишает пользователя возможности использования более разрешительной маски. Лучше её опустить. См. umask для получения дополнительной информации об этом.

Обратите внимание, что в Perl, более старых, чем 5.8.0, sysopen зависит от функции C-библиотеки fdopen(3). На многих Unix-системах fdopen(3) известна тем, что завершается ошибкой, когда дескрипторы файлов превышают определённое значение, как правило, 255. Если вам нужны дескрипторы файлов больше, чем это, рассмотрите использование функции POSIX::open. Для Perl 5.8.0 и более поздних версий PerlIO является (чаще всего) значением по умолчанию.

См. perlopentut для более подробного объяснения открытия файлов.

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

sysread FILEHANDLE,SCALAR,LENGTH,OFFSET

sysread FILEHANDLE,SCALAR,LENGTH

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

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

Нет функции syseof(), что нормально, так как eof не работает хорошо с файлами устройств (например, терминалами). Используйте sysread и проверяйте возвращаемое значение на 0, чтобы определить, закончили ли вы.

Обратите внимание, что если для дескриптора файла установлено значение :utf8, вместо байтов считываются символы Юникода (LENGTH, OFFSET и возвращаемое значение sysread задаются в символах Юникода). Слой :encoding(...) неявно вводит слой :utf8. См. binmode, open и прагму open.

sysseek FILEHANDLE,POSITION,WHENCE

Устанавливает системную позицию FILEHANDLE в байтах с помощью lseek(2). FILEHANDLE может быть выражением, значение которого даёт имя файлового дескриптора. Значения для WHENCE — 0 для установки новой позиции в POSITION; 1 для установки её в текущую позицию плюс POSITION; и 2 для установки её в EOF плюс POSITION, обычно отрицательное значение.

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

sysseek опускает обычный буферизованный ввод-вывод, поэтому смешивание его с чтением, отличным от sysread (например, readline или read), print, write, seek, tell или eof, может вызвать путаницу.

Для WHENCE вы также можете использовать константы SEEK_SET, SEEK_CUR, и SEEK_END (начало файла, текущая позиция, конец файла) из модуля Fcntl. Использование констант также более переносимо, чем использование 0, 1 и 2. Например, для определения функции «systell»:

use Fcntl 'SEEK_CUR';
sub systell { sysseek($_[0], 0, SEEK_CUR) }

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

system СПИСОК

system ПРОГРАММА СПИСОК

Делает ровно то же самое, что и exec, за исключением того, что сначала выполняется fork, и родительский процесс ожидает завершения дочернего процесса. Обратите внимание, что обработка аргументов зависит от количества аргументов. Если в СПИСКЕ более одного аргумента, или если СПИСОК — массив с более чем одним значением, запускает программу, заданную первым элементом списка, с аргументами, заданными остальными элементами списка. Если существует только один скалярный аргумент, аргумент проверяется на наличие символов метаязыка оболочки, и если таковые есть, весь аргумент передаётся оболочке системы команд для анализа (это /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" в perlport.

syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET

syswrite FILEHANDLE,SCALAR,LENGTH

syswrite FILEHANDLE,SCALAR

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

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

ВНИМАНИЕ: Если файловый дескриптор помечен :utf8, символы Unicode, закодированные в UTF-8, записываются вместо байтов, и LENGTH, OFFSET и возвращаемое значение syswrite находятся в (закодированных в UTF8 символах Unicode). Слой :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 имеет те же оговорки о возможной уплотнении каталога, что и соответствующая системная библиотечная функция.

привязать 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, до указанной длины. Вызывает исключение, если усечение не реализовано на вашей системе. Возвращает true, если успешно, undef при ошибке.

Поведение неопределено, если LENGTH больше длины файла.

Позиция в файле FILEHANDLE остается неизменной. Возможно, вам нужно вызвать seek перед записью в файл.

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

uc EXPR

uc

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

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

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

ucfirst EXPR

ucfirst

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

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

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

umask EXPR

umask

Устанавливает umask для процесса на EXPR и возвращает предыдущее значение. Если EXPR опущен, просто возвращает текущий umask.

Права доступа Unix rwxr-x--- представлены тремя наборами по три бита или тремя восьмеричными цифрами: 0750 (ведущий 0 указывает на восьмеричную систему и не является одной из цифр). Значение umask — это число, представляющее отключенные биты прав. Значения прав (или «режима»), которые вы передаёте mkdir или sysopen, изменяются вашим umask, поэтому даже если вы сообщите sysopen о создании файла с правами 0777, если ваш umask равен 0022, то файл фактически будет создан с правами 0755. Если ваш umask был 0027 (группа не может писать; другие не могут читать, писать или исполнять), то передача sysopen 0666 создаст файл с режимом 0640 (потому что 0666 &~ 027 есть 0640).

Вот совет: используйте режим создания 0666 для обычных файлов (sysopen) и 0777 для каталогов (mkdir) и исполняемых файлов. Это даёт пользователям свободу выбора: если они хотят защищённые файлы, они могут выбрать маски umask процесса 022, 027, или даже особенно антисоциальную маску 077. Программы редко, если вообще, должны принимать политические решения, которые лучше оставлять пользователю. Исключением являются случаи записи файлов, которые должны быть конфиденциальными: файлы почты, куки браузера, файлы .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 бит. Контрольная сумма вычисляется путём суммирования числовых значений расширенных значений (для строковых полей берётся сумма ord($char); для полей бит — сумма нулей и единиц).

Например, следующее вычисляет то же число, что и программа System V sum:

my $checksum = do {
    local $/;  # slurp!
    unpack("%32W*", readline) % 65535;
};

Следующее эффективно подсчитывает количество установленных битов в битовом векторе:

my $setbits = unpack("%32b*", $selectmask);

Форматы p и P следует использовать с осторожностью. Поскольку Perl не может проверить, соответствует ли значение, переданное unpack, валидному месту в памяти, передача значения указателя, которое не известно как валидное, вероятно, приведёт к катастрофическим последствиям.

Если есть дополнительные коды pack, или если количество повторений поля или группы больше, чем позволяет оставшаяся часть входной строки, результат не определён: количество повторений может быть уменьшено, или unpack может произвести пустые строки или нули, или может быть вызвано исключение. Если входная строка длиннее, чем указано в TEMPLATE, оставшаяся часть этой входной строки игнорируется.

См. pack для получения дополнительных примеров и замечаний.

unshift ARRAY,LIST

Выполняет операцию, обратную shift. Или обратную push, в зависимости от того, как вы на это смотрите. Добавляет список в начало массива и возвращает новое количество элементов в массиве.

unshift(@ARGV, '-e') unless $ARGV[0] =~ /^-/;

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

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

untie VARIABLE

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

use Module VERSION LIST

use Module VERSION

use Module LIST

use Module

use VERSION

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

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

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

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

Указание VERSION числовым аргументом в формате 5.024001 следует в целом избегать, как более сложный и трудночитаемый синтаксис по сравнению с v5.24.1. До версии perl 5.8.0, выпущенной в 2002 году, более подробный числовой формат был единственным поддерживаемым синтаксисом, поэтому вы можете увидеть его в

use v5.24.1;    # compile time version check
use 5.24.1;     # ditto
use 5.024_001;  # ditto; older syntax compatible with perl 5.6

Это часто полезно, если вам нужно проверить текущую версию Perl, прежде чем use библиотечные модули, которые не будут работать с более старыми версиями Perl. (Мы стараемся избегать этого, насколько это возможно.)

use VERSION также лексически включает все функции, доступные в запрошенной версии, как определено в прагме feature, и отключает любые функции, отсутствующие в наборе функций запрошенной версии. См. feature. Аналогично, если указанная версия Perl больше или равна 5.12.0, включаются ограничения лексически, как с use strict. Любое явное использование use strict или no strict переопределяет use VERSION, даже если оно стоит перед ним. Более позднее использование use VERSION переопределит всё поведение предыдущего use VERSION, возможно, удалив strict и feature добавленные use VERSION. use VERSION не загружает файлы feature.pm или strict.pm.

BEGIN принуждает require и import произойти на этапе компиляции. require обеспечивает загрузку модуля в память, если он ещё не загружен. import — это не встроенная функция; это просто обычный статический вызов метода в пакет Module для указания модулю импортировать список функций обратно в текущий пакет. Модуль может реализовать свой метод import любым способом, хотя большинство модулей выбирают получение своего метода import через наследование от класса Exporter, определённого в модуле Exporter. См. Exporter. Если метод import не найден, вызов пропускается, даже если есть метод AUTOLOAD.

Если вы не хотите вызывать метод пакета import (например, для предотвращения изменения вашего пространства имён), явно укажите пустой список:

use Module ();

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

BEGIN { require Module }

Если аргумент VERSION присутствует между Module и LIST, то use вызовет метод VERSION в классе Module с заданной версией в качестве аргумента:

use Module 12.34;

эквивалентно:

BEGIN { require Module; Module->VERSION(12.34) }

Метод по умолчанию VERSION, унаследованный от класса UNIVERSAL, выдаёт ошибку, если заданная версия больше значения переменной $Module::VERSION.

Аргумент VERSION не может быть произвольным выражением. Он считается аргументом VERSION только если это литерал версии, начинающийся с цифры или v и последующей цифры. Всё, что не выглядит как литерал версии, будет распознано как начало LIST. Тем не менее, многие попытки использовать произвольное выражение в качестве аргумента VERSION, похоже, работают, потому что метод import в Exporter обрабатывает числовые аргументы специально, выполняя проверки версии, а не обрабатывая их как элементы для экспорта.

Ещё раз, существует разница между пропуском LIST (import вызывается без аргументов) и явным пустым LIST () (import не вызывается). Обратите внимание, что после VERSION нет запятой!

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

use constant;
use diagnostics;
use integer;
use sigtrap  qw(SEGV BUS);
use strict   qw(subs vars refs);
use subs     qw(afunc blurfl);
use warnings qw(all);
use sort     qw(stable);

Некоторые из этих псевдомодулей импортируют семантику в текущую область видимости (например, strict или integer), в отличие от обычных модулей, которые импортируют символы в текущий пакет (которые действуют до конца файла).

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

use if $] < 5.008, "utf8";
use if WANT_WARNINGS, warnings => qw(all);

Есть соответствующее объявление no, которое отменяет значения, импортированные с помощью use, т.е. оно вызывает Module->unimport(LIST) вместо import. Она ведет себя так же, как import с VERSION, пропущенным или пустым LIST, или если метод unimport не найден.

no integer;
no strict 'refs';
no warnings;

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

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

utime LIST

Изменяет время доступа и изменения для каждого файла в списке файлов. Первые два элемента списка должны быть числовыми значениями времени доступа и изменения соответственно. Возвращает количество успешно изменённых файлов. Время изменения индекса inode каждого файла устанавливается на текущее время. Например, этот код имеет тот же эффект, что и команда Unix touch(1), когда файлы уже существуют и принадлежат пользователю, запускающему программу:

#!/usr/bin/perl
my $atime = my $mtime = time;
utime $atime, $mtime, @ARGV;

Начиная с Perl 5.8.0, если первые два элемента списка являются undef, системный вызов utime(2) из вашей библиотеки C вызывается со значением null для второго аргумента. На большинстве систем это установит время доступа и изменения файла на текущее время (то есть эквивалентно примеру выше) и будет работать даже для файлов, которыми вы не владеете, при условии, что у вас есть права на запись:

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 5.012;  # so keys/values/each work on arrays

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

vec EXPR,OFFSET,BITS

Обращается к строке в EXPR как к битовому вектору, состоящему из элементов шириной BITS, и возвращает значение элемента, указанного OFFSET, как целое без знака. Таким образом, BITS задаёт количество битов, резервируемых для каждого элемента в битовом векторе. Это должно быть степень двойки от 1 до 32 (или 64, если ваша платформа поддерживает это).

Если BITS равно 8, «элементы» совпадают с байтами входной строки.

Если BITS равно 16 или больше, байты входной строки группируются в блоки размером BITS/8, и каждый блок преобразуется в число, как с pack/unpack с форматами с порядком байтов big-endian n/N (и аналогично для BITS=64). Смотрите pack для подробностей.

Если биты равны 4 или меньше, строка разбивается на байты, а затем биты каждого байта разбиваются на группы 8/BITS. Биты байта нумеруются по принципу little-endian, как в 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80. Например, разбиение одного входного байта chr(0x36) на две группы даёт список (0x6, 0x3); разбиение на 4 группы даёт (0x2, 0x1, 0x3, 0x0).

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

vec($image, $max_x * $x + $y, 8) = 3;

Если выбранный элемент выходит за пределы строки, возвращается значение 0. Если элементу за пределами строки присваивается значение, Perl сначала дополнит строку достаточным количеством нулевых байтов. Попытка записи вне начала строки (т.е. отрицательного OFFSET) является ошибкой.

Если строка закодирована как UTF-8 внутри (и, следовательно, имеет флаг UTF8), vec пытается преобразовать её для использования однобайтовой кодировки на символ. Однако, если строка содержит символы со значениями 256 или выше, это преобразование завершится неудачей, и будет выведено сообщение об устаревании. В этом случае vec будет работать с базовым буфером независимо, в его внутреннем представлении UTF-8. В Perl 5.32 это будет фатальная ошибка.

Строки, созданные с помощью vec, также можно обрабатывать логическими операторами |, &, ^, и ~. Эти операторы будут предполагать, что требуется операция с битовым вектором, когда оба операнда являются строками. Смотрите "Bitwise String Operators" в perlop.

Следующий код создаст строку ASCII, обозначающую 'PerlPerlPerl'. Комментарии показывают строку после каждого шага. Обратите внимание, что этот код работает одинаково на машинах с big-endian и little-endian архитектурами.

my $foo = '';
vec($foo,  0, 32) = 0x5065726C; # 'Perl'

# $foo eq "Perl" eq "\x50\x65\x72\x6C", 32 bits
print vec($foo, 0, 8);  # prints 80 == 0x50 == ord('P')

vec($foo,  2, 16) = 0x5065; # 'PerlPe'
vec($foo,  3, 16) = 0x726C; # 'PerlPerl'
vec($foo,  8,  8) = 0x50;   # 'PerlPerlP'
vec($foo,  9,  8) = 0x65;   # 'PerlPerlPe'
vec($foo, 20,  4) = 2;      # 'PerlPerlPe'   . "\x02"
vec($foo, 21,  4) = 7;      # 'PerlPerlPer'
                               # 'r' is "\x72"
vec($foo, 45,  2) = 3;      # 'PerlPerlPer'  . "\x0c"
vec($foo, 93,  1) = 1;      # 'PerlPerlPer'  . "\x2c"
vec($foo, 94,  1) = 1;      # 'PerlPerlPerl'
                               # 'l' is "\x6c"

Для преобразования битового вектора в строку или список 0 и 1 используйте:

my $bits = unpack("b*", $vector);
my @bits = split(//, unpack("b*", $vector));

Если вы знаете точную длину в битах, она может быть использована вместо *.

Вот пример, чтобы проиллюстрировать, как биты фактически размещаются:

#!/usr/bin/perl -wl

print <<'EOT';
                                  0         1         2         3
                   unpack("V",$_) 01234567890123456789012345678901
------------------------------------------------------------------
EOT

for $w (0..3) {
    $width = 2**$w;
    for ($shift=0; $shift < $width; ++$shift) {
        for ($off=0; $off < 32/$width; ++$off) {
            $str = pack("B*", "0"x32);
            $bits = (1<<$shift);
            vec($str, $off, $width) = $bits;
            $res = unpack("b*",$str);
            $val = unpack("V", $str);
            write;
        }
    }
}

format STDOUT =
vec($_,@#,@#) = @<< == @######### @>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
$off, $width, $bits, $val, $res
.
__END__

Независимо от архитектуры машины, на которой он работает, пример выше должен вывести следующую таблицу:

                                  0         1         2         3
                   unpack("V",$_) 01234567890123456789012345678901
------------------------------------------------------------------
vec($_, 0, 1) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 1) = 1   ==          2 01000000000000000000000000000000
vec($_, 2, 1) = 1   ==          4 00100000000000000000000000000000
vec($_, 3, 1) = 1   ==          8 00010000000000000000000000000000
vec($_, 4, 1) = 1   ==         16 00001000000000000000000000000000
vec($_, 5, 1) = 1   ==         32 00000100000000000000000000000000
vec($_, 6, 1) = 1   ==         64 00000010000000000000000000000000
vec($_, 7, 1) = 1   ==        128 00000001000000000000000000000000
vec($_, 8, 1) = 1   ==        256 00000000100000000000000000000000
vec($_, 9, 1) = 1   ==        512 00000000010000000000000000000000
vec($_,10, 1) = 1   ==       1024 00000000001000000000000000000000
vec($_,11, 1) = 1   ==       2048 00000000000100000000000000000000
vec($_,12, 1) = 1   ==       4096 00000000000010000000000000000000
vec($_,13, 1) = 1   ==       8192 00000000000001000000000000000000
vec($_,14, 1) = 1   ==      16384 00000000000000100000000000000000
vec($_,15, 1) = 1   ==      32768 00000000000000010000000000000000
vec($_,16, 1) = 1   ==      65536 00000000000000001000000000000000
vec($_,17, 1) = 1   ==     131072 00000000000000000100000000000000
vec($_,18, 1) = 1   ==     262144 00000000000000000010000000000000
vec($_,19, 1) = 1   ==     524288 00000000000000000001000000000000
vec($_,20, 1) = 1   ==    1048576 00000000000000000000100000000000
vec($_,21, 1) = 1   ==    2097152 00000000000000000000010000000000
vec($_,22, 1) = 1   ==    4194304 00000000000000000000001000000000
vec($_,23, 1) = 1   ==    8388608 00000000000000000000000100000000
vec($_,24, 1) = 1   ==   16777216 00000000000000000000000010000000
vec($_,25, 1) = 1   ==   33554432 00000000000000000000000001000000
vec($_,26, 1) = 1   ==   67108864 00000000000000000000000000100000
vec($_,27, 1) = 1   ==  134217728 00000000000000000000000000010000
vec($_,28, 1) = 1   ==  268435456 00000000000000000000000000001000
vec($_,29, 1) = 1   ==  536870912 00000000000000000000000000000100
vec($_,30, 1) = 1   == 1073741824 00000000000000000000000000000010
vec($_,31, 1) = 1   == 2147483648 00000000000000000000000000000001
vec($_, 0, 2) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 2) = 1   ==          4 00100000000000000000000000000000
vec($_, 2, 2) = 1   ==         16 00001000000000000000000000000000
vec($_, 3, 2) = 1   ==         64 00000010000000000000000000000000
vec($_, 4, 2) = 1   ==        256 00000000100000000000000000000000
vec($_, 5, 2) = 1   ==       1024 00000000001000000000000000000000
vec($_, 6, 2) = 1   ==       4096 00000000000010000000000000000000
vec($_, 7, 2) = 1   ==      16384 00000000000000100000000000000000
vec($_, 8, 2) = 1   ==      65536 00000000000000001000000000000000
vec($_, 9, 2) = 1   ==     262144 00000000000000000010000000000000
vec($_,10, 2) = 1   ==    1048576 00000000000000000000100000000000
vec($_,11, 2) = 1   ==    4194304 00000000000000000000001000000000
vec($_,12, 2) = 1   ==   16777216 00000000000000000000000010000000
vec($_,13, 2) = 1   ==   67108864 00000000000000000000000000100000
vec($_,14, 2) = 1   ==  268435456 00000000000000000000000000001000
vec($_,15, 2) = 1   == 1073741824 00000000000000000000000000000010
vec($_, 0, 2) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 2) = 2   ==          8 00010000000000000000000000000000
vec($_, 2, 2) = 2   ==         32 00000100000000000000000000000000
vec($_, 3, 2) = 2   ==        128 00000001000000000000000000000000
vec($_, 4, 2) = 2   ==        512 00000000010000000000000000000000
vec($_, 5, 2) = 2   ==       2048 00000000000100000000000000000000
vec($_, 6, 2) = 2   ==       8192 00000000000001000000000000000000
vec($_, 7, 2) = 2   ==      32768 00000000000000010000000000000000
vec($_, 8, 2) = 2   ==     131072 00000000000000000100000000000000
vec($_, 9, 2) = 2   ==     524288 00000000000000000001000000000000
vec($_,10, 2) = 2   ==    2097152 00000000000000000000010000000000
vec($_,11, 2) = 2   ==    8388608 00000000000000000000000100000000
vec($_,12, 2) = 2   ==   33554432 00000000000000000000000001000000
vec($_,13, 2) = 2   ==  134217728 00000000000000000000000000010000
vec($_,14, 2) = 2   ==  536870912 00000000000000000000000000000100
vec($_,15, 2) = 2   == 2147483648 00000000000000000000000000000001
vec($_, 0, 4) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 4) = 1   ==         16 00001000000000000000000000000000
vec($_, 2, 4) = 1   ==        256 00000000100000000000000000000000
vec($_, 3, 4) = 1   ==       4096 00000000000010000000000000000000
vec($_, 4, 4) = 1   ==      65536 00000000000000001000000000000000
vec($_, 5, 4) = 1   ==    1048576 00000000000000000000100000000000
vec($_, 6, 4) = 1   ==   16777216 00000000000000000000000010000000
vec($_, 7, 4) = 1   ==  268435456 00000000000000000000000000001000
vec($_, 0, 4) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 4) = 2   ==         32 00000100000000000000000000000000
vec($_, 2, 4) = 2   ==        512 00000000010000000000000000000000
vec($_, 3, 4) = 2   ==       8192 00000000000001000000000000000000
vec($_, 4, 4) = 2   ==     131072 00000000000000000100000000000000
vec($_, 5, 4) = 2   ==    2097152 00000000000000000000010000000000
vec($_, 6, 4) = 2   ==   33554432 00000000000000000000000001000000
vec($_, 7, 4) = 2   ==  536870912 00000000000000000000000000000100
vec($_, 0, 4) = 4   ==          4 00100000000000000000000000000000
vec($_, 1, 4) = 4   ==         64 00000010000000000000000000000000
vec($_, 2, 4) = 4   ==       1024 00000000001000000000000000000000
vec($_, 3, 4) = 4   ==      16384 00000000000000100000000000000000
vec($_, 4, 4) = 4   ==     262144 00000000000000000010000000000000
vec($_, 5, 4) = 4   ==    4194304 00000000000000000000001000000000
vec($_, 6, 4) = 4   ==   67108864 00000000000000000000000000100000
vec($_, 7, 4) = 4   == 1073741824 00000000000000000000000000000010
vec($_, 0, 4) = 8   ==          8 00010000000000000000000000000000
vec($_, 1, 4) = 8   ==        128 00000001000000000000000000000000
vec($_, 2, 4) = 8   ==       2048 00000000000100000000000000000000
vec($_, 3, 4) = 8   ==      32768 00000000000000010000000000000000
vec($_, 4, 4) = 8   ==     524288 00000000000000000001000000000000
vec($_, 5, 4) = 8   ==    8388608 00000000000000000000000100000000
vec($_, 6, 4) = 8   ==  134217728 00000000000000000000000000010000
vec($_, 7, 4) = 8   == 2147483648 00000000000000000000000000000001
vec($_, 0, 8) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 8) = 1   ==        256 00000000100000000000000000000000
vec($_, 2, 8) = 1   ==      65536 00000000000000001000000000000000
vec($_, 3, 8) = 1   ==   16777216 00000000000000000000000010000000
vec($_, 0, 8) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 8) = 2   ==        512 00000000010000000000000000000000
vec($_, 2, 8) = 2   ==     131072 00000000000000000100000000000000
vec($_, 3, 8) = 2   ==   33554432 00000000000000000000000001000000
vec($_, 0, 8) = 4   ==          4 00100000000000000000000000000000
vec($_, 1, 8) = 4   ==       1024 00000000001000000000000000000000
vec($_, 2, 8) = 4   ==     262144 00000000000000000010000000000000
vec($_, 3, 8) = 4   ==   67108864 00000000000000000000000000100000
vec($_, 0, 8) = 8   ==          8 00010000000000000000000000000000
vec($_, 1, 8) = 8   ==       2048 00000000000100000000000000000000
vec($_, 2, 8) = 8   ==     524288 00000000000000000001000000000000
vec($_, 3, 8) = 8   ==  134217728 00000000000000000000000000010000
vec($_, 0, 8) = 16  ==         16 00001000000000000000000000000000
vec($_, 1, 8) = 16  ==       4096 00000000000010000000000000000000
vec($_, 2, 8) = 16  ==    1048576 00000000000000000000100000000000
vec($_, 3, 8) = 16  ==  268435456 00000000000000000000000000001000
vec($_, 0, 8) = 32  ==         32 00000100000000000000000000000000
vec($_, 1, 8) = 32  ==       8192 00000000000001000000000000000000
vec($_, 2, 8) = 32  ==    2097152 00000000000000000000010000000000
vec($_, 3, 8) = 32  ==  536870912 00000000000000000000000000000100
vec($_, 0, 8) = 64  ==         64 00000010000000000000000000000000
vec($_, 1, 8) = 64  ==      16384 00000000000000100000000000000000
vec($_, 2, 8) = 64  ==    4194304 00000000000000000000001000000000
vec($_, 3, 8) = 64  == 1073741824 00000000000000000000000000000010
vec($_, 0, 8) = 128 ==        128 00000001000000000000000000000000
vec($_, 1, 8) = 128 ==      32768 00000000000000010000000000000000
vec($_, 2, 8) = 128 ==    8388608 00000000000000000000000100000000
vec($_, 3, 8) = 128 == 2147483648 00000000000000000000000000000001

wait

Ведёт себя как wait(2) на вашей системе: ожидает завершения дочернего процесса и возвращает pid умершего процесса, или -1 если нет дочерних процессов. Статус возвращается в $? и ${^CHILD_ERROR_NATIVE}. Обратите внимание, что значение возврата -1 может означать, что дочерние процессы собираются автоматически, как описано в perlipc.

Если вы используете wait в своём обработчике для $SIG{CHLD}, вы можете случайно подождать дочерний процесс, созданный qx или system. Смотрите perlipc для получения подробностей.

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

waitpid PID,FLAGS

Ожидает завершения конкретного дочернего процесса и возвращает pid умершего процесса, или -1 если такого дочернего процесса нет. Неблокирующее ожидание (с WNOHANG в FLAGS) может вернуть 0, если есть дочерние процессы, соответствующие PID, но ни один из них ещё не завершился. Статус возвращается в $? и ${^CHILD_ERROR_NATIVE}.

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

Если вы говорите

use POSIX ":sys_wait_h";

my $kid;
do {
    $kid = waitpid(-1, WNOHANG);
} while $kid > 0;

или

1 while waitpid(-1, WNOHANG) > 0;

тогда вы можете выполнить неблокирующее ожидание всех ожидающих процессов-зомби (см. "WAIT" в POSIX). Неблокирующее ожидание доступно на машинах, поддерживающих системные вызовы waitpid(2) или wait4(2). Однако ожидание конкретного pid со значением FLAGS 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

См. perlvar для получения подробной информации об установке записей %SIG и для получения дополнительных примеров. См. модуль Carp для получения других видов предупреждений, используя его функции carp и cluck.

write FILEHANDLE

write EXPR

write

Записывает отформатированный блок записей (возможно, многострочный) в указанный FILEHANDLE, используя формат, связанный с этим файлом. По умолчанию формат файла — это тот, который имеет то же имя, что и дескриптор файла, но формат текущего выходного канала (см. функцию select) можно явно установить, присвоив имя формата переменной $~.

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

Если FILEHANDLE не указан, вывод направляется на текущий канал вывода по умолчанию, который изначально равен STDOUT, но может быть изменён оператором select. Если FILEHANDLE — это EXPR, то выражение оценивается, а полученная строка используется для поиска имени FILEHANDLE во время выполнения. Для получения дополнительной информации о форматах см. perlform.

Обратите внимание, что write не является противоположностью read. К сожалению.

y///

Оператор транслитерации. Такой же, как tr///. См. "Quote-Like Operators" в perlop.

Нефункциональные ключевые слова по перекрёстной ссылке

perldata

__DATA__
__END__: Эти ключевые слова описаны в "Special Literals" в perldata.

perlmod

BEGIN
CHECK
END
INIT
UNITCHECK: Эти ключевые слова фазы компиляции описаны в "BEGIN, UNITCHECK, CHECK, INIT и END" в perlmod.

perlobj

DESTROY: Это ключевое слово метода описано в "Destructors" в perlobj.

perlop

and
cmp
eq
ge
gt
le
lt
ne
not
or
x
xor: Эти операторы описаны в perlop.

perlsub

AUTOLOAD: Это ключевое слово описано в "Autoloading" в perlsub.

perlsyn

else

elsif

for

foreach

if

unless

until

while

Эти ключевые слова управления потоком описаны в "Compound Statements" в perlsyn.

elseif

Ключевое слово «else if» пишется как elsif в Perl. Также нет elif или else if. Оно разбирается elseif, но только для вывода предупреждения о неиспользовании.

См. описание ключевых слов управления потоком в "Compound Statements" в perlsyn.

default
given
when: Эти ключевые слова управления потоком, связанные с экспериментальной функцией переключения, описаны в "Switch Statements" в perlsyn.

© 1993–2020 Larry Wall and others
Licensed under the GNU General Public License version 1 or later, or the Artistic License.
The Perl logo is a trademark of the Perl Foundation.
https://perldoc.perl.org/5.28.3/perlfunc