perlfunc

СОДЕРЖАНИЕ

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

ИМЯ

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). За исключением теста -l, все они следуют по символическим ссылкам, потому что используют stat(), а не lstat() (поэтому висячие символические ссылки не могут быть проверены и, следовательно, сообщат об ошибке).

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

use 5.010;  # so filetest ops can stack

abs VALUE

abs

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

accept NEWSOCKET,GENERICSOCKET

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

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

alarm SECONDS

alarm

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

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

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

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

Если вы хотите использовать alarm для установки таймаута для системного вызова, вам нужно использовать пару eval/die. Вы не можете полагаться на то, что alarm заставит системный вызов завершиться неудачей со значением $!, установленным в EINTR, потому что Perl настраивает обработчики сигналов для перезапуска системных вызовов на некоторых системах. Использование eval/die всегда работает, за исключением оговорок, приведенных в "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). Возвращает истинно, если операция выполнена успешно, иначе — ложь. 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 и обсуждение переменной среды PERLIO в perlrun.

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

Параметр LAYER функции binmode описан как «DISCIPLINE» в «Программирование на Perl, 3-е издание». Однако, с момента публикации этой книги, известной многим как «Camel III», консенсус в наименовании этой функциональности перешёл от «дисциплина» к «слой». Поэтому вся документация этой версии Perl относится к «слоям», а не к «дисциплинам». Теперь вернёмся к обычной документации...

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

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

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

См. "Perl-Модули" в perlmod.

break

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

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

caller EXPR

caller

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

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

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

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

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

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

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

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

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

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

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

chdir EXPR

chdir FILEHANDLE

chdir DIRHANDLE

chdir

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

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

chmod LIST

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

, если у вас только строка.

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), передача дескрипторов файлов вызывает исключение. Дескрипторы файлов должны передаваться как значения globs или ссылки на globs для распознавания; слова без кавычек считаются именами файлов.

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

Вы также можете импортировать символические 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.

:

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

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

chomp VARIABLE

chomp( LIST )

chomp

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

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

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

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

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

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

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

chop VARIABLE

chop( LIST )

chop

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

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

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

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

См. также chomp.

chown LIST

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

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

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

Вот пример, который ищет нечисловые 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, этого не делает.

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

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

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

Пример:

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

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

closedir DIRHANDLE

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

connect SOCKET,NAME

Попытка подключения к удалённому сокету, как и connect(2). Возвращает true в случае успеха, false — в противном случае. NAME должен быть упакованным адресом соответствующего типа для сокета. См. примеры в "Sockets: Клиент/серверное взаимодействие" в 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 и "Операторы выбора" в perlsyn для получения дополнительной информации.

cos EXPR

cos

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

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

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

crypt PLAINTEXT,SALT

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

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

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

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

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

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

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

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

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

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

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

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

Если вы используете crypt с Unicode-строкой (которая потенциально содержит символы с кодовыми точками выше 255), Perl пытается осмыслить ситуацию, переведя (копию) строки обратно в восьмибитовую строку байтов перед вызовом 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. Для итерирования по большим файлам DBM предпочтительнее использовать функцию each. Пример:

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

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

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

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

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

defined EXPR

defined

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

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

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

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

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

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

Примеры:

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

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

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

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

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

delete EXPR

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

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

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

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

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

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

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

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

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

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

И так же эти:

delete @HASH{keys %HASH};

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

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

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

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

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

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

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

die LIST

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

Эквивалентные примеры:

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

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

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

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

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

что даёт, соответственно

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

Если LIST был пустым или был преобразован в пустую строку, и $@ уже содержит значение исключения (обычно от предыдущего 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.

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

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

die @_ if $^S;

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

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

do БЛОК

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

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

do ВЫРАЖЕНИЕ

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

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

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

do './stat.pl' в значительной степени подобно

eval `cat stat.pl`;

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

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

do 'foo/stat.pl';

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

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

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

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

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

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

dump Метка

dump ВЫРАЖЕНИЕ

dump

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

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

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

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

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

each HASH

each МАССИВ

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

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

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

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

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

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

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

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

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

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

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

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

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

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

выводит

256

и $@ пуста.

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

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

exec LIST

exec PROGRAM LIST

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

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

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

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

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

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

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

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

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

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

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

my @args = ( "echo surprise" );

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

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

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

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

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

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

exists EXPR

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

exists ⊂    # 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

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

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

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

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

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

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

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

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

fcntl FILEHANDLE,FUNCTION,SCALAR

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

use Fcntl;

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

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

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

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

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

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

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

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

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

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

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

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

формат

Объявление формата для использования функцией 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 как одну строку. Поэтому для реализации формата записи может потребоваться использовать несколько команд formlines, как и в компиляторе format.

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

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

getc FILEHANDLE

getc

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

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

my $key = getc(STDIN);

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

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

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

getlogin

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

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

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

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

getpeername SOCKET

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

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

getpgrp PID

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

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

getppid

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

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

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

getpriority WHICH,WHO

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

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

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

getpwnam NAME

getgrnam NAME

gethostbyname NAME

getnetbyname NAME

getprotobyname NAME

getpwuid UID

getgrgid GID

getservbyname NAME,PROTO

gethostbyaddr ADDR,ADDRTYPE

getnetbyaddr ADDR,ADDRTYPE

getprotobynumber NUMBER

getservbyport PORT,PROTO

getpwent

getgrent

gethostent

getnetent

getprotoent

getservent

setpwent

setgrent

sethostent STAYOPEN

setnetent STAYOPEN

setprotoent STAYOPEN

setservent STAYOPEN

endpwent

endgrent

endhostent

endnetent

endprotoent

endservent

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

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

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

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

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

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

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

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

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

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 вызывается в контексте SCALAR и что значение возврата проверяется на определённость.

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

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

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

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

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

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

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

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

getsockname SOCKET

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

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

getsockopt SOCKET,LEVEL,OPTNAME

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

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

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

use Socket qw(:all);

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

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

glob EXPR

glob

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

Обратите внимание, что glob разделяет свои аргументы по пробелам и рассматривает каждый сегмент как отдельный шаблон. Таким образом, glob("*.c *.h") соответствует всем файлам с расширением .c или .h. Выражение glob(".* *") соответствует всем файлам в текущей рабочей директории. Если вы хотите использовать glob для имён файлов, которые могут содержать пробелы, вам нужно поместить имя файла со пробелами в дополнительные кавычки, чтобы защитить его. Например, чтобы 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 BLOCK LIST

grep EXPR,LIST

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

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

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

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

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

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

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

hex EXPR

hex

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

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

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

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

import LIST

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

index STR,SUBSTR,POSITION

index STR,SUBSTR

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

int EXPR

int

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

ioctl FILEHANDLE,FUNCTION,SCALAR

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

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

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

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

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

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

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

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

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

join EXPR,LIST

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

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

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

keys HASH

keys ARRAY

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

Записи хэша возвращаются в, по-видимому, случайном порядке. Фактический случайный порядок специфичен для каждого хэша; идентичные последовательности операций над двумя хэшами могут привести к различным порядкам для каждого хэша. Любая вставка в хэш может изменить порядок, как и любое удаление, за исключением случая, когда последний ключ, возвращённый функцией each или keys, может быть удалён без изменения порядка. Пока хэш не модифицируется, вы можете полагаться на keys, values и each для последовательного возвращения одного и того же порядка. Подробную информацию о том, почему порядок хэша случайный, см. в разделе «Атаки на сложность алгоритма» в 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. Подробную информацию см. в Config.

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

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

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

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

Подробную информацию см. в разделе «Сигналы» в perlipc.

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

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

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

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

last LABEL

last EXPR

last

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

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

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

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

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

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

lc EXPR

lc

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

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

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

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

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

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

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

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

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

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

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

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

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

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

lcfirst EXPR

lcfirst

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

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

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

length EXPR

length

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

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

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

__LINE__

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

link OLDFILE,NEWFILE

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

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

listen SOCKET,QUEUESIZE

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

local EXPR

Вероятно, вы должны использовать my вместо local, так как 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 года. Чтобы получить 4-значный год, запишите:

$year += 1900;

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

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

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

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

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

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

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

Формат этого скалярного значения не зависит от локали, а встроен в Perl. Для получения GMT вместо местного времени используйте встроенную функцию gmtime. См. также модуль Time::Local (для преобразования секунд, минут, часов и т. д. обратно в целое число, возвращаемое time), и функции модуля 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

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

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

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

msgrcv ID,VAR,SIZE,TYPE,FLAGS

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

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

msgsnd ID,MSG,FLAGS

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

open FILEHANDLE,MODE,EXPR,LIST

open FILEHANDLE,MODE,REFERENCE

open FILEHANDLE,EXPR

open FILEHANDLE

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

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

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

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

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

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

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

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

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

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

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

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

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

О файлхендлах

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

О режимах

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Открытие файлхендла в внутримашинный скаляр

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

или

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

затем

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

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

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

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

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

Последние два примера в каждом блоке показывают канал в "форме списка", которая пока не поддерживается на всех платформах. (Если ваша платформа имеет настоящий fork, такой как Linux и macOS, вы можете использовать форму списка; она также работает в Windows с Perl 5.22 или новее.) Вы хотели бы использовать форму канала в виде списка, чтобы вы могли передавать буквальные аргументы команде без риска интерпретации shell-метасимволов в них. Однако это также не позволяет вам открывать каналы в команды, которые намеренно содержат shell-метасимволы, такие как:

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

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

Дублирование файлхендлов

Также, в соответствии с традициями 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-функции fdopen(3) для этого дескриптора файла (и не вызовет dup(2)); это более экономно расходует дескрипторы файлов. Например:

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

или

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

или

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

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

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

Использование устаревшего синтаксиса

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

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

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

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

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

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

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

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

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

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

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

Устаревший стиль заключается в использовании простого слова в качестве файлового дескриптора, как

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

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

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

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

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

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

Автоматическое сброс буфера трубы

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вызов C-стиля open

Если вам нужен «настоящий» 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

open FILEHANDLE, MODE, EXPR

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). Количество повторений потребляет столько значений из СПИСКА при использовании со всеми типами форматов, кроме a, A, Z, b, B, h, H, @, ., x, X, и P, где оно означает что-то другое, описанное ниже. Указание * для количества повторений вместо числа означает использование всех оставшихся элементов, за исключением:

  • @, x, и X, где оно эквивалентно 0.

  • <.>, где это означает относительно начала строки.

  • u, где оно эквивалентно 1 (или 45, что здесь эквивалентно).

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

  Например, шаблон x[L] пропускает столько байтов, сколько упакованных байтов содержит длинное целое число, а шаблон "$t X[$t] $t" распаковывает в два раза больше того, что $t (при переменном расширении) распаковывает. Если шаблон в скобках содержит команды выравнивания (например, x![d]), его упакованная длина вычисляется так, как если бы начало шаблона имело максимальное возможное выравнивание.

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

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

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

  • Если количество повторений 0, оно относительно текущей позиции.

  • Если количество повторений *, смещение относительно начала упакованной строки.

  • И если это целое число n, смещение относительно начала n-й самой внутренней ( ) группы или начала строки, если n больше уровня группы.

  Количество повторений для u интерпретируется как максимальное количество байтов для кодирования каждой строки вывода, при этом 0, 1 и 2 заменяются на 45. Количество повторений не должно превышать 65.

• Типы a, A, и Z потребляют только одно значение, но упаковывают его как строку длиной count, дополняя нулями или пробелами по мере необходимости. При распаковке A удаляет конечные пробелы и нули, Z удаляет всё после первого нуля, а a возвращает данные без удаления.

  Если значение для упаковки слишком длинное, результат усекается. Если оно слишком длинное, и указано явное количество, Z упаковывает только $count-1 байтов, после чего добавляет нулевой байт. Таким образом, Z всегда упаковывает конечный нуль, за исключением случая, когда количество равно 0.

• Аналогично, форматы b и B упаковывают строку, длина которой равна указанному количеству битов. Каждый такой формат генерирует 1 бит результата. После них обычно следует количество повторений, например, B8 или B64.

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

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

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

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

  * для количества повторений использует все символы входного поля. При распаковке биты преобразуются в строку из 0 и 1.

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

  Для каждого такого формата 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.

  Указание количества формату length-item полезно только с A, a, или Z. Упаковка с length-item a или Z может ввести символы "\000", которые Perl не считает допустимыми в числовых строках.

• Целочисленные типы s, S, l, и L могут быть последовы с модификатором ! для указания родных коротких или длинных целых чисел. Как показано в примере выше, простой l означает ровно 32 бита, хотя родной long, как видно из локального компилятора C, может быть больше. Это, главным образом, проблема на 64-битных платформах. Вы можете увидеть, повлияет ли использование ! на это таким способом:

  printf "format s is %d, s! is %d\n",
      length pack("s"), length pack("s!");
  
  printf "format l is %d, l! is %d\n",
      length pack("l"), length pack("l!");

  i! и I! также разрешены, но только для полноты: они идентичны i и I.

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

  $ perl -V:{short,int,long{,long}}size
  shortsize='2';
  intsize='4';
  longsize='4';
  longlongsize='8';

  или программно через модуль Config:

  use Config;
  print $Config{shortsize},    "\n";
  print $Config{intsize},      "\n";
  print $Config{longsize},     "\n";
  print $Config{longlongsize}, "\n";

  $Config{longlongsize} не определено на системах без поддержки очень длинных целых чисел.

• Целочисленные форматы s, S, i, I, l, L, j, и J по своей природе не переносимы между процессорами и операционными системами, так как они подчиняются порядку байтов и эндианности, свойственным конкретной платформе. Например, целое 4-байтовое число 0x12345678 (305419896 в десятичной системе) будет в соответствии с порядком байтов (определяющим расположение и обработку в регистрах процессора) представлено как

  0x12 0x34 0x56 0x78  # big-endian
  0x78 0x56 0x34 0x12  # little-endian

  В основном, процессоры Intel и VAX являются little-endian, тогда как все остальные, включая Motorola m68k/88k, PPC, Sparc, HP PA, Power и Cray, являются big-endian. Alpha и MIPS могут быть любыми: Digital/Compaq используют (ну, использовали) их в little-endian режиме, но SGI/Cray используют их в big-endian режиме.

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

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

  0x56 0x78 0x12 0x34
  0x34 0x12 0x78 0x56

  Они называются mid-endian, middle-endian, mixed-endian или просто странными.

  Вы можете определить эндианность вашей системы с помощью этой команды:

  printf("%#02x ", $_) for unpack("W*", pack L=>0x12345678);

  Порядок байтов на платформе, на которой был скомпилирован Perl, также доступен через Config:

  use Config;
  print "$Config{byteorder}\n";

  или из командной строки:

  $ perl -V:byteorder

  Порядок байтов "1234" и "12345678" — little-endian; "4321" и "87654321" — big-endian. Системы с многоархитектурными бинарными файлами будут иметь "ffff", что указывает на то, что статическая информация не работает; необходимо использовать динамическое определение.

  Для переносимого упаковки целых чисел используйте форматы n, N, v, и V или используйте модификаторы > и <, описанные ниже. См. также perlport.

• Также числа с плавающей точкой имеют эндианность. Обычно (но не всегда) она совпадает с эндианностью целых чисел. Несмотря на то, что большинство современных платформ используют двоичный формат IEEE 754, существуют различия, особенно если речь идёт о long doubles. Вы можете увидеть переменные Config doublekind и longdblkind (также doublesize, longdblsize) — значения «тип» являются перечислениями, в отличие от byteorder.

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

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

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

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

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

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

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

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

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

  Поскольку Perl использует числа двойной точности (или числа двойной точности extended, если настроено) во всех вычислениях с числами, преобразование из числа двойной точности в число одинарной точности и затем обратно в число двойной точности приводит к потере точности, поэтому 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]. Это предполагает, что числа двойной точности должны быть выровнены по размеру числа двойной точности.

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

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

• Комментарии могут быть встроены в шаблон с помощью # до конца строки. Пробелы могут разделят коды упаковки, но модификаторы и счётчики повторений должны следовать непосредственно за ними. Разбиение сложных шаблонов на отдельные компоненты по строкам с соответствующими аннотациями может в большей степени улучшить читаемость и поддерживаемость форматов 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.

пакет NAMESPACE

пакет NAMESPACE VERSION

пакет NAMESPACE BLOCK

пакет NAMESPACE VERSION BLOCK

Объявляет, что блок или остальная часть единицы компиляции находятся в заданном пространстве имен. Область действия объявления пакета — это предоставленный код БЛОК или, в отсутствие БЛОКа, от самого объявления до конца текущей области видимости (внешнего блока, файла или eval). То есть, формы без блока действуют до конца текущей области видимости, как и операторы my, state и our. Все неуточнённые динамические идентификаторы в этой области видимости будут находиться в заданном пространстве имен, за исключением случаев переопределения другим объявлением package или если они являются одним из специальных идентификаторов, которые квалифицируются в main::, например, STDOUT, ARGV, ENV, и переменных с пунктуацией.

Заявление о пакете влияет только на динамические переменные, включая те, на которые вы использовали local, но не на переменные с лексической областью видимости, которые создаются с помощью my, state или our. Обычно это будет первое объявление в файле, включённом с помощью require или use. Вы можете переключаться в пакет в нескольких местах, так как это определяет только ту таблицу символов по умолчанию, которую компилятор использует для остальной части этого блока. Вы можете ссылаться на идентификаторы в других пакетах, отличных от текущего, добавив префикс к идентификатору имени пакета и двойного двоеточия, как в $SomePack::var или ThatPack::INPUT_HANDLE. Если имя пакета опущено, предполагается пакет main. То есть, $::sail эквивалентно $main::sail (а также $main'sail, которое всё ещё встречается в старом коде, в основном из Perl 4).

Если указана VERSION, package задаёт переменную $VERSION в заданном пространстве имен в виде объекта версии с предоставленной VERSION. VERSION должна быть номером версии в "строгом" формате, как определено модулем version: положительное десятичное число (целое или с дробной частью) без экспоненты или строка v-десятичных чисел с префиксом 'v' и по крайней мере тремя компонентами. Вы должны установить $VERSION только один раз на пакет.

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

__PACKAGE__

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

pipe READHANDLE,WRITEHANDLE

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

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

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

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

pop ARRAY

pop

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

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

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

pos SCALAR

pos

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

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

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

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

print FILEHANDLE LIST

print FILEHANDLE

print LIST

print

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

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

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

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

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

printf FILEHANDLE FORMAT, LIST

printf FILEHANDLE

printf FORMAT, LIST

printf

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

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

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

prototype FUNCTION

prototype

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

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

push ARRAY,LIST

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

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

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

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

q/STRING/

qq/STRING/

qw/STRING/

qx/STRING/

Обобщённые кавычки. См. "Операторы-аналоги кавычек" в perlop.

qr/STRING/

Оператор-аналог регулярного выражения. См. "Операторы-аналоги регулярных выражений" в perlop.

quotemeta EXPR

quotemeta

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

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

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

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

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

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

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

Или:

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

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

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

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

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

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

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

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

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

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

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

rand EXPR

rand

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

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

int(rand(10))

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

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

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

read FILEHANDLE,SCALAR,LENGTH,OFFSET

read FILEHANDLE,SCALAR,LENGTH

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

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

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

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

readdir DIRHANDLE

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

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

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

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

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

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

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

readline EXPR

readline

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

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

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

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

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

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

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

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

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

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

readlink EXPR

readlink

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

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

readpipe EXPR

readpipe

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

recv SOCKET,SCALAR,LENGTH,FLAGS

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

Обратите внимание, что если сокет помечен как :utf8, recv выбросит исключение. Уровень :encoding(...) неявно вводит уровень :utf8. См. binmode.

redo LABEL

redo EXPR

redo

Команда redo перезапускает блок цикла, не вычисляя условное выражение заново. Блок continue, если таковой имеется, не выполняется. Если LABEL опущен, команда относится к самому внутреннему циклу. Форма redo EXPR, доступная начиная с Perl 5.18.0, позволяет вычислять имя метки во время выполнения, и в остальном она идентична redo LABEL. Программы, которые хотят солгать самим себе о том, что только что было введено, обычно используют эту команду:

# a simpleminded Pascal comment stripper
# (warning: assumes no { or } in strings)
LINE: while (<STDIN>) {
    while (s|({.*}.*){.*}|$1 |) {}
    s|{.*}| |;
    if (s|{.*| |) {
        my $front = $_;
        while (<STDIN>) {
            if (/}/) {  # end of comment?
                s|^|$front\{|;
                redo LINE;
            }
        }
    }
    print;
}

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

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

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

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

ref EXPR

ref

Изучает значение EXPR, ожидая, что это ссылка, и возвращает строку, дающую информацию о ссылке и типе объекта, на который она ссылается. Если EXPR не указан, используется $_.

Если операнд не ссылка, возвращается пустая строка. Пустая строка будет возвращена только в этом случае. ref часто бывает полезно, чтобы просто проверить, является ли значение ссылкой, что можно сделать, сравнив результат с пустой строкой. Это распространённая ошибка - использовать результат ref напрямую как истинностное значение: это неправильно, потому что 0 (ложь) может быть возвращено для ссылки.

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

Если операнд - ссылка на необлагословлённый объект, то возвращаемое значение указывает тип объекта. Если необлагословлённый объект не скаляр, то возвращаемое значение будет одной из строк ARRAY, HASH, CODE, FORMAT, или IO, указывающей только на вид объекта. Если необлагословлённый объект является скаляром, то возвращаемое значение будет одной из строк SCALAR, VSTRING, REF, GLOB, LVALUE, или REGEXP, в зависимости от типа значения, которым сейчас обладает скаляр. Но обратите внимание, что qr// скаляры создаются уже благословлёнными, поэтому ref qr/.../, скорее всего, вернёт Regexp. Будьте осторожны, эти встроенные имена типов также могут использоваться как имена классов, поэтому ref возвращает одно из этих имён, это не однозначно указывает на то, что объект принадлежит к типу, соответствующему имени.

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

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

rename OLDNAME,NEWNAME

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

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

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

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

require VERSION

require EXPR

require

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

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

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

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

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

use Carp 'croak';
use version;

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

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

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

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

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

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

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

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

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. Ссылка на скаляр, содержащий любой исходный код для добавления в начало файла или генерации.

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

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

4. Дополнительное состояние для подпрограммы. Состояние передаётся как $_[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 или do BLOCK), с указанным значением в EXPR. Вычисление EXPR может происходить в списке, скаляре или пустом контексте, в зависимости от того, как будет использоваться возвращаемое значение, и контекст может меняться от одного выполнения к другому (см. wantarray). Если EXPR не указан, возвращает пустой список в контексте списка, неопределённое значение в скалярном контексте и (разумеется) ничего в контексте пустоты.

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

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

reverse LIST

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

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

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

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

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

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

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

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

rewinddir DIRHANDLE

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

Проблемы с переносимостью: "rewinddir" в 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///

Оператор подстановки. Смотрите "Операторы регуляных выражений, похожих на операторы экранирования" в perlop.

say FILEHANDLE LIST

say FILEHANDLE

say LIST

say

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

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

scalar EXPR

Принуждает EXPR к интерпретации в скалярном контексте и возвращает значение EXPR.

my @counts = ( scalar @a, scalar @b, scalar @c );

Нет эквивалентного оператора для принуждения выражения к интерпретации в списочном контексте, потому что на практике это никогда не требуется. Однако, если вы действительно хотите это сделать, вы можете использовать конструкцию @{[ (some expression) ]}, но обычно достаточно простого (some expression).

Поскольку scalar является унарным оператором, если вы случайно используете заключённый в скобки список для EXPR, это работает как скалярное выражение с запятой, вычисляя все элементы, кроме последнего, в контексте 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 для установки её на конец файла плюс 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 на некоторых системах вам нужно делать seek при каждом переключении между чтением и записью. Среди прочего, это может привести к вызову clearerr(3) в stdio. WHENCE значение 1 (SEEK_CUR) полезно для того, чтобы не перемещать позицию файла:

seek($fh, 0, 1);

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

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

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

seekdir DIRHANDLE,POS

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

select FILEHANDLE

select

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

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

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

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

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

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

STDERR->autoflush(1);

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

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

select RBITS,WBITS,EBITS,TIMEOUT

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

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

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

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: неопределенное значение для ошибки, "0 but true" для нуля или фактическое возвращаемое значение в противном случае. ARG должен состоять из вектора целых чисел типа short, которые можно создать с помощью pack("s!",(0)x$nsem). См. также "SysV IPC" в perlipc и документацию для IPC::SysV и IPC::Semaphore.

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

semget KEY,NSEMS,FLAGS

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

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

semop KEY,OPSTRING

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

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

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

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

send SOCKET,MSG,FLAGS,TO

send SOCKET,MSG,FLAGS

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

Обратите внимание, что если сокет помечен как :utf8, send будет выбрасывать исключение. Слой :encoding(...) неявно вводит слой :utf8. См. binmode.

setpgrp PID,PGRP

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

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

setpriority WHICH,WHO,PRIORITY

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

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

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

setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL

Устанавливает параметр сокета. Возвращает undef при ошибке. Используйте целочисленные константы, предоставляемые модулем Socket, для LEVEL и OPTNAME. Значения для 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 но истина" для нуля; и фактическое возвращаемое значение в противном случае. См. также "SysV IPC" в perlipc и документацию для IPC::SysV.

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

shmget KEY,SIZE,FLAGS

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

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

shmread ID,VAR,POS,SIZE

shmwrite ID,STRING,POS,SIZE

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

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

shutdown SOCKET,HOW

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

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

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

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

sin EXPR

sin

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

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

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

sleep EXPR

sleep

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

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

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

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

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

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

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

socket SOCKET,DOMAIN,TYPE,PROTOCOL

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

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

socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL

Создаёт безымянную пару сокетов в указанном домене, определённого типа. DOMAIN, TYPE и PROTOCOL задаются так же, как и для системного вызова с тем же именем. Если не реализовано, поднимает исключение. Возвращает true, если успешно.

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

Некоторые системы определяют pipe в терминах socketpair, в котором вызов pipe($rdr, $wtr) по существу:

use Socket;
socketpair(my $rdr, my $wtr, AF_UNIX, SOCK_STREAM, PF_UNSPEC);
shutdown($rdr, 1);        # no more writing for reader
shutdown($wtr, 0);        # no more reading for writer

См. perlipc для примера использования socketpair. Perl 5.8 и более поздние версии будут эмулировать socketpair с использованием IP-сокетов для localhost, если ваша система реализует сокеты, но не socketpair.

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

sort SUBNAME LIST

sort BLOCK LIST

sort LIST

В контексте списка сортирует LIST и возвращает отсортированный список. В скалярном контексте поведение sort не определено.

Если SUBNAME или BLOCK опущены, sort сортирует по стандартному порядку сравнения строк. Если SUBNAME указан, он задаёт имя подпрограммы, которая возвращает целое число меньше, равно или больше, чем 0, в зависимости от того, как элементы списка должны быть упорядочены. (Операторы <=> и cmp очень полезны в таких подпрограммах.) SUBNAME может быть именем скалярной переменной (без индексов), в этом случае значение предоставляет имя (или ссылку на) фактическую подпрограмму для использования. Вместо SUBNAME вы можете предоставить BLOCK как анонимную, встроенную подпрограмму сортировки.

Если прототип подпрограммы ($$), элементы для сравнения передаются по ссылке в @_, как и для обычной подпрограммы. Это медленнее, чем нетипизированные подпрограммы, где элементы для сравнения передаются в подпрограмму как глобальные переменные пакета $a и $b (см. пример ниже).

Если подпрограмма является XSUB, элементы для сравнения помещаются в стек, как обычно передаются аргументы XSUB. $a и $b не задаются.

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

Вы также не можете выйти из блока сортировки или подпрограммы, используя какие-либо операторы управления циклом, описанные в perlsyn, или с помощью goto.

Когда use locale (но не use locale ':not_characters') активна, sort LIST сортирует LIST в соответствии с текущим языковым стандартом сортировки. См. perllocale.

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

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

Примеры:

# sort lexically
my @articles = sort @files;

# same thing, but with explicit sort routine
my @articles = sort {$a cmp $b} @files;

# now case-insensitively
my @articles = sort {fc($a) cmp fc($b)} @files;

# same thing in reversed order
my @articles = sort {$b cmp $a} @files;

# sort numerically ascending
my @articles = sort {$a <=> $b} @files;

# sort numerically descending
my @articles = sort {$b <=> $a} @files;

# this sorts the %age hash by value instead of key
# using an in-line function
my @eldest = sort { $age{$b} <=> $age{$a} } keys %age;

# sort using explicit subroutine name
sub byage {
    $age{$a} <=> $age{$b};  # presuming numeric
}
my @sortedclass = sort byage @class;

sub backwards { $b cmp $a }
my @harry  = qw(dog cat x Cain Abel);
my @george = qw(gone chased yz Punished Axed);
print sort @harry;
    # prints AbelCaincatdogx
print sort backwards @harry;
    # prints xdogcatCainAbel
print sort @george, 'to', @harry;
    # prints AbelAxedCainPunishedcatchaseddoggonetoxyz

# inefficiently sort by descending numeric compare using
# the first integer after the first = sign, or the
# whole record case-insensitively otherwise

my @new = sort {
    ($b =~ /=(\d+)/)[0] <=> ($a =~ /=(\d+)/)[0]
                        ||
                fc($a)  cmp  fc($b)
} @old;

# same thing, but much more efficiently;
# we'll build auxiliary indices instead
# for speed
my (@nums, @caps);
for (@old) {
    push @nums, ( /=(\d+)/ ? $1 : undef );
    push @caps, fc($_);
}

my @new = @old[ sort {
                       $nums[$b] <=> $nums[$a]
                                ||
                       $caps[$a] cmp $caps[$b]
                     } 0..$#old
              ];

# same thing, but without any temps
my @new = map { $_->[0] }
       sort { $b->[1] <=> $a->[1]
                       ||
              $a->[2] cmp $b->[2]
       } map { [$_, /=(\d+)/, fc($_)] } @old;

# using a prototype allows you to use any comparison subroutine
# as a sort subroutine (including other package's subroutines)
package Other;
sub backwards ($$) { $_[1] cmp $_[0]; }  # $a and $b are
                                         # not set here
package main;
my @new = sort Other::backwards @old;

# guarantee stability
use sort 'stable';
my @new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;

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

my @contact = sort { $a cmp $b } find_records @key;
my @contact = sort +find_records(@key);
my @contact = sort &find_records(@key);
my @contact = sort(find_records(@key));

Если вместо этого вы хотите отсортировать массив @key с помощью функции сравнения find_records(), вы можете использовать:

my @contact = sort { find_records() } @key;
my @contact = sort find_records(@key);
my @contact = sort(find_records @key);
my @contact = sort(find_records (@key));

$a и $b устанавливаются как глобальные переменные пакета, в котором вызван sort(). Это означает $main::a и $main::b (или $::a и $::b) в пакете main, $FooPack::a и $FooPack::b в пакете FooPack и т. д. Если блок сортировки находится в области действия объявления my или state для $a и/или $b, вы обязательно должны указать полное имя переменных в блоке сортировки:

package main;
my $a = "C"; # DANGER, Will Robinson, DANGER !!!

print sort { $a cmp $b }               qw(A C E G B D F H);
                                       # WRONG
sub badlexi { $a cmp $b }
print sort badlexi                     qw(A C E G B D F H);
                                       # WRONG
# the above prints BACFEDGH or some other incorrect ordering

print sort { $::a cmp $::b }           qw(A C E G B D F H);
                                       # OK
print sort { our $a cmp our $b }       qw(A C E G B D F H);
                                       # also OK
print sort { our ($a, $b); $a cmp $b } qw(A C E G B D F H);
                                       # also OK
sub lexi { our $a cmp our $b }
print sort lexi                        qw(A C E G B D F H);
                                       # also OK
# the above print ABCDEFGH

С надлежащим вниманием вы можете смешивать пакетные и мои (или state) $a и/или $b:

my $a = {
   tiny   => -2,
   small  => -1,
   normal => 0,
   big    => 1,
   huge   => 2
};

say sort { $a->{our $a} <=> $a->{our $b} }
    qw{ huge normal tiny small big};

# prints tinysmallnormalbighuge

$a и $b неявным образом локализованы для выполнения sort() и восстанавливают свои прежние значения после завершения сортировки.

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

package Foo;
sub lexi { $Bar::a cmp $Bar::b }
package Bar;
... sort Foo::lexi ...

Используйте прототипированные версии (см. выше) для более универсальной альтернативы.

Функция сравнения должна работать корректно. Если она возвращает несогласованные результаты (иногда указывая, что $x[1] меньше, чем $x[2], а иногда наоборот, например), результаты не определены.

Так как <=> возвращает undef, когда любой операнд NaN (не число), будьте внимательны при сортировке со функцией сравнения, такой как $a <=> $b, любых списков, которые могут содержать NaN. Следующий пример использует это, чтобы устранить любые NaN из входного списка.

my @result = sort { $a <=> $b } grep { $_ == $_ } @input;

splice ARRAY,OFFSET,LENGTH,LIST

splice ARRAY,OFFSET,LENGTH

splice ARRAY,OFFSET

splice ARRAY

Удаляет элементы, обозначенные OFFSET и LENGTH из массива, и заменяет их элементами LIST, если таковые имеются. В контексте списка возвращает удалённые элементы из массива. В скалярном контексте возвращает последний удалённый элемент или undef, если элементы не удалены. Массив увеличивается или уменьшается по мере необходимости. Если OFFSET отрицательный, он начинается на расстоянии OFFSET от конца массива. Если LENGTH опущен, удаляются все элементы с OFFSET и далее. Если LENGTH отрицательный, удаляются элементы с OFFSET и далее, кроме -LENGTH элементов в конце массива. Если и OFFSET, и LENGTH опущены, удаляются все элементы. Если OFFSET находится за пределами массива, и был указан LENGTH, Perl выводит предупреждение и выполняет splice в конце массива.

Следующие эквивалентности выполняются (при условии $#a >= $i )

push(@a,$x,$y)      splice(@a,@a,0,$x,$y)
pop(@a)             splice(@a,-1)
shift(@a)           splice(@a,0,1)
unshift(@a,$x,$y)   splice(@a,0,0,$x,$y)
$a[$i] = $y         splice(@a,$i,1,$y)

splice можно использовать, например, для реализации обработки очереди n-арности:

sub nary_print {
  my $n = shift;
  while (my @next_n = splice @_, 0, $n) {
    say join q{ -- }, @next_n;
  }
}

nary_print(3, qw(a b c d e f g h));
# prints:
#   a -- b -- c
#   d -- e -- f
#   g -- h

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

split /PATTERN/,EXPR,LIMIT

split /PATTERN/,EXPR

split /PATTERN/

split

Разбивает строку EXPR на список строк и возвращает список в контексте списка или размер списка в скалярном контексте. (До Perl 5.11 он также перезаписывал @_ списком в пустом и скалярном контекстах. Если вы работаете со старыми версиями Perl, будьте осторожны.)

Если задан только PATTERN, EXPR по умолчанию равен $_.

Любое в EXPR, что соответствует PATTERN, рассматривается как разделитель, который разделяет EXPR на подстроки (называемые «полями»), которые не включают разделитель. Обратите внимание, что разделитель может быть длиннее одного символа или даже не содержать символов (пустая строка, которая является соответствием нулевой ширины).

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

Если PATTERN соответствует пустой строке, EXPR разбивается в позиции соответствия (между символами). Например:

print join(':', split(/b/, 'abc')), "\n";

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

print join(':', split(//, 'abc')), "\n";

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

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

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

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

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

Начиная с Perl 5.28, это специальное разделение по пробелам работает как ожидалось в контексте "use feature 'unicode_strings". В предыдущих версиях и вне контекста этой функции она демонстрирует "Ошибка Unicode" в perlunicode: символы, которые являются пробелами в соответствии с правилами Unicode, но не в соответствии с правилами ASCII, могут рассматриваться как часть полей, а не как разделители полей, в зависимости от внутреннего кодирования строки.

Если PATTERN опущен, он по умолчанию равен одному пробелу, " ", что запускает ранее описанную эмуляцию awk.

Если LIMIT указан и является положительным числом, он представляет собой максимальное количество полей, на которые может быть разделен EXPR; другими словами, LIMIT на единицу больше максимального количества раз, когда EXPR может быть разделен. Таким образом, значение LIMIT 1 означает, что EXPR может быть разделен максимум ноль раз, что даст максимум одно поле (а именно, все значение EXPR). Например:

print join(':', split(//, 'abc', 1)), "\n";

дает вывод abc, а это:

print join(':', split(//, 'abc', 2)), "\n";

дает вывод a:bc, и каждое из этих:

print join(':', split(//, 'abc', 3)), "\n";
print join(':', split(//, 'abc', 4)), "\n";

дает вывод a:b:c.

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

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

print join(':', split(/,/, 'a,b,c,,,')), "\n";

дает вывод a:b:c, но следующее:

print join(':', split(/,/, 'a,b,c,,,', -1)), "\n";

дает вывод a:b:c:::.

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

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

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

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

print join(':', split(/ /, ' abc')), "\n";

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

print join(':', split(//, ' abc'));

дает вывод :a:b:c (а не : :a:b:c).

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

print join(':', split(//, ' abc', -1)), "\n";

дает вывод :a:b:c:.

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

split(/-|,/, "1-10,20", 3)
# ('1', '10', '20')

split(/(-|,)/, "1-10,20", 3)
# ('1', '-', '10', ',', '20')

split(/-|(,)/, "1-10,20", 3)
# ('1', undef, '10', ',', '20')

split(/(-)|,/, "1-10,20", 3)
# ('1', '-', '10', undef, '20')

split(/(-)|(,)/, "1-10,20", 3)
# ('1', '-', undef, '10', undef, ',', '20')

sprintf FORMAT, LIST

Возвращает строку, отформатированную по обычным printf соглашениям функции C-библиотеки sprintf. Более подробные сведения см. ниже, а также в sprintf(3) или printf(3) на вашей системе для объяснения общих принципов.

Например:

# Format number with up to 8 leading zeroes
my $result = sprintf("%08d", $number);

# Round number to 3 digits after decimal point
my $rounded = sprintf("%.3f", $number);

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

В отличие от printf, sprintf не делает того, что вы, вероятно, имеете в виду, когда передаёте массив в качестве первого аргумента. Массив передаётся в скалярный контекст, и вместо использования нулевого элемента массива в качестве формата, Perl использует количество элементов в массиве как формат, что почти никогда не бывает полезным.

Perl's sprintf допускает следующие общеизвестные преобразования:

%%    a percent sign
%c    a character with the given number
%s    a string
%d    a signed integer, in decimal
%u    an unsigned integer, in decimal
%o    an unsigned integer, in octal
%x    an unsigned integer, in hexadecimal
%e    a floating-point number, in scientific notation
%f    a floating-point number, in fixed decimal notation
%g    a floating-point number, in %e or %f notation

Кроме того, Perl допускает следующие широко поддерживаемые преобразования:

%X    like %x, but using upper-case letters
%E    like %e, but using an upper-case "E"
%G    like %g, but with an upper-case "E" (if applicable)
%b    an unsigned integer, in binary
%B    like %b, but using an upper-case "B" with the # flag
%p    a pointer (outputs the Perl value's address in hexadecimal)
%n    special: *stores* the number of characters output so far
      into the next argument in the parameter list
%a    hexadecimal floating point
%A    like %a, but using upper-case letters

Наконец, для обратной (и мы имеем в виду «обратной») совместимости Perl допускает эти ненужные, но широко поддерживаемые преобразования:

%i    a synonym for %d
%D    a synonym for %ld
%U    a synonym for %lu
%O    a synonym for %lo
%F    a synonym for %f

Обратите внимание, что количество цифр экспоненты в научной записи, генерируемой %e, %E, %g и %G для чисел с модулем экспоненты меньше 100, зависит от системы: это может быть три или меньше (с нулевым дополнением, если необходимо). Другими словами, 1,23 умножить на десять в 99-й степени может быть либо "1.23e99", либо "1.23e099". Аналогично для %a и %A: экспонента или шестнадцатеричные цифры могут перемещаться: в частности, опция конфигурации Perl «long doubles» может привести к неожиданным результатам.

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

индекс параметра формата

Явный индекс параметра формата, например, 2$. По умолчанию sprintf отформатирует следующий неиспользуемый аргумент в списке, но это позволяет вам изменять порядок аргументов:

printf '%2$d %1$d', 12, 34;      # prints "34 12"
printf '%3$d %d %1$d', 1, 2, 3;  # prints "3 1 1"

флаги

один или несколько из:

space   prefix non-negative number with a space
+       prefix non-negative number with a plus sign
-       left-justify within the field
0       use zeros, not spaces, to right-justify
#       ensure the leading "0" for any octal,
        prefix non-zero hexadecimal with "0x" or "0X",
        prefix non-zero binary with "0b" or "0B"

Например:

printf '<% d>',  12;   # prints "< 12>"
printf '<% d>',   0;   # prints "< 0>"
printf '<% d>', -12;   # prints "<-12>"
printf '<%+d>',  12;   # prints "<+12>"
printf '<%+d>',   0;   # prints "<+0>"
printf '<%+d>', -12;   # prints "<-12>"
printf '<%6s>',  12;   # prints "<    12>"
printf '<%-6s>', 12;   # prints "<12    >"
printf '<%06s>', 12;   # prints "<000012>"
printf '<%#o>',  12;   # prints "<014>"
printf '<%#x>',  12;   # prints "<0xc>"
printf '<%#X>',  12;   # prints "<0XC>"
printf '<%#b>',  12;   # prints "<0b1100>"
printf '<%#B>',  12;   # prints "<0B1100>"

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

printf '<%+ d>', 12;   # prints "<+12>"
printf '<% +d>', 12;   # prints "<+12>"

Когда флаг # и точность указаны в преобразовании %o, точность увеличивается, если это необходимо для ведущей «0».

printf '<%#.5o>', 012;      # prints "<00012>"
printf '<%#.5o>', 012345;   # prints "<012345>"
printf '<%#.0o>', 0;        # prints "<0>"

флаг вектора

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

printf "%vd", "AB\x{100}";           # prints "65.66.256"
printf "version is v%vd\n", $^V;     # Perl's version

Поместите звездочку * перед v для переопределения строки, используемой для разделения чисел:

printf "address is %*vX\n", ":", $addr;   # IPv6 address
printf "bits are %0*v8b\n", " ", $bits;   # random bitstring

Вы также можете явно указать номер аргумента, используемого для строки соединения, используя что-то вроде *2$v; например:

printf '%*4$vX %*4$vX %*4$vX',       # 3 IPv6 addresses
        @addr[1..3], ":";

(минимальная) ширина

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

printf "<%s>", "a";       # prints "<a>"
printf "<%6s>", "a";      # prints "<     a>"
printf "<%*s>", 6, "a";   # prints "<     a>"
printf '<%*2$s>', "a", 6; # prints "<     a>"
printf "<%2s>", "long";   # prints "<long>" (does not truncate)

Если ширина поля, полученная с помощью *, отрицательна, она имеет тот же эффект, что и флаг -: выравнивание влево.

точность или максимальная ширина

Вы можете указать точность (для числовых преобразований) или максимальную ширину (для строковых преобразований), указав ., за которым следует число. Для чисел с плавающей точкой, за исключением g и G, это указывает, сколько десятичных знаков справа от десятичной точки следует показать (по умолчанию 6). Например:

# these examples are subject to system-specific variation
printf '<%f>', 1;    # prints "<1.000000>"
printf '<%.1f>', 1;  # prints "<1.0>"
printf '<%.0f>', 1;  # prints "<1>"
printf '<%e>', 10;   # prints "<1.000000e+01>"
printf '<%.1e>', 10; # prints "<1.0e+01>"

Для «g» и «G» это указывает максимальное количество значащих цифр для отображения; например:

# These examples are subject to system-specific variation.
printf '<%g>', 1;        # prints "<1>"
printf '<%.10g>', 1;     # prints "<1>"
printf '<%g>', 100;      # prints "<100>"
printf '<%.1g>', 100;    # prints "<1e+02>"
printf '<%.2g>', 100.01; # prints "<1e+02>"
printf '<%.5g>', 100.01; # prints "<100.01>"
printf '<%.4g>', 100.01; # prints "<100>"
printf '<%.1g>', 0.0111; # prints "<0.01>"
printf '<%.2g>', 0.0111; # prints "<0.011>"
printf '<%.3g>', 0.0111; # prints "<0.0111>"

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

printf '<%.6d>', 1;      # prints "<000001>"
printf '<%+.6d>', 1;     # prints "<+000001>"
printf '<%-10.6d>', 1;   # prints "<000001    >"
printf '<%10.6d>', 1;    # prints "<    000001>"
printf '<%010.6d>', 1;   # prints "<    000001>"
printf '<%+10.6d>', 1;   # prints "<   +000001>"

printf '<%.6x>', 1;      # prints "<000001>"
printf '<%#.6x>', 1;     # prints "<0x000001>"
printf '<%-10.6x>', 1;   # prints "<000001    >"
printf '<%10.6x>', 1;    # prints "<    000001>"
printf '<%010.6x>', 1;   # prints "<    000001>"
printf '<%#10.6x>', 1;   # prints "<  0x000001>"

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

printf '<%.5s>', "truncated";   # prints "<trunc>"
printf '<%10.5s>', "truncated"; # prints "<     trunc>"

Вы также можете получить точность из следующего аргумента, используя .*, или из указанного аргумента (например, с помощью .*2$):

printf '<%.6x>', 1;       # prints "<000001>"
printf '<%.*x>', 6, 1;    # prints "<000001>"

printf '<%.*2$x>', 1, 6;  # prints "<000001>"

printf '<%6.*2$x>', 1, 4; # prints "<  0001>"

Если точность, полученная через *, отрицательна, она считается отсутствием точности.

printf '<%.*s>',  7, "string";   # prints "<string>"
printf '<%.*s>',  3, "string";   # prints "<str>"
printf '<%.*s>',  0, "string";   # prints "<>"
printf '<%.*s>', -1, "string";   # prints "<string>"

printf '<%.*d>',  1, 0;   # prints "<0>"
printf '<%.*d>',  0, 0;   # prints "<>"
printf '<%.*d>', -1, 0;   # prints "<0>"

размер

Для числовых преобразований вы можете указать размер для интерпретации числа, используя l, h, V, q, L, или ll. Для целочисленных преобразований (d u o x X b i D U O), числа обычно предполагаются размера, соответствующего стандартному целочисленному размеру в вашей платформе (обычно 32 или 64 бита), но вы можете переопределить это, используя один из стандартных типов C, поддерживаемых компилятором, используемым для сборки Perl:

hh          interpret integer as C type "char" or "unsigned
            char" on Perl 5.14 or later
h           interpret integer as C type "short" or
            "unsigned short"
j           interpret integer as C type "intmax_t" on Perl
            5.14 or later; and prior to Perl 5.30, only with
            a C99 compiler (unportable)
l           interpret integer as C type "long" or
            "unsigned long"
q, L, or ll interpret integer as C type "long long",
            "unsigned long long", or "quad" (typically
            64-bit integers)
t           interpret integer as C type "ptrdiff_t" on Perl
            5.14 or later
z           interpret integer as C types "size_t" or
            "ssize_t" on Perl 5.14 or later

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

корень квадратный EXPR

sqrt

Возвращает положительный квадратный корень из EXPR. Если EXPR опущен, используется $_. Работает только для неотрицательных операндов, если вы не загрузили модуль Math::Complex.

use Math::Complex;
print sqrt(-4);    # prints 2i

srand EXPR

srand

Устанавливает и возвращает начальное значение генератора случайных чисел для оператора rand.

Цель функции — «засеять» функцию rand, чтобы rand каждый раз при запуске программы генерировал различную последовательность. При вызове с параметром srand использует его в качестве начального значения; в противном случае выбирает (полу-)случайное начальное значение. В любом случае, начиная с Perl 5.14, он возвращает начальное значение. Чтобы указать, что ваш код будет работать только с Perl последних версий:

use 5.014;  # so srand returns the seed

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

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

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

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

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

stat FILEHANDLE

stat EXPR

stat DIRHANDLE

stat

Возвращает список из 13 элементов, содержащий информацию о состоянии файла, либо файла, открытого через FILEHANDLE или DIRHANDLE, либо файла, имя которого указано в EXPR. Если EXPR опущен, он выполняет stat для $_ (а не _!). Возвращает пустой список, если stat завершается неудачно. Типичное использование:

my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
    $atime,$mtime,$ctime,$blksize,$blocks)
       = stat($filename);

Не все поля поддерживаются на всех типах файловых систем. Вот значения полей:

 0 dev      device number of filesystem
 1 ino      inode number
 2 mode     file mode  (type and permissions)
 3 nlink    number of (hard) links to the file
 4 uid      numeric user ID of file's owner
 5 gid      numeric group ID of file's owner
 6 rdev     the device identifier (special files only)
 7 size     total size of file, in bytes
 8 atime    last access time in seconds since the epoch
 9 mtime    last modify time in seconds since the epoch
10 ctime    inode change time in seconds since the epoch (*)
11 blksize  preferred I/O size in bytes for interacting with the
            file (may vary from file to file)
12 blocks   actual number of system-specific blocks allocated
            on disk (often, but not always, 512 bytes each)

(Эпоха была 00:00 1 января 1970 года по Гринвичу.)

(*) Не все поля поддерживаются на всех типах файловых систем. В частности, поле ctime не является переносимым. В частности, вы не можете ожидать, что это будет «время создания»; см. "Файлы и файловые системы" в perlport для получения подробной информации.

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

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

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

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

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

my $mode = (stat($filename))[2];
printf "Permissions are %04o\n", $mode & 07777;

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

Модуль File::stat предоставляет удобный механизм доступа по имени:

use File::stat;
my $sb = stat($filename);
printf "File is %s, size is %s, perm %04o, mtime %s\n",
       $filename, $sb->size, $sb->mode & 07777,
       scalar localtime $sb->mtime;

Вы можете импортировать символические константы режима (S_IF*) и функции (S_IS*) из модуля Fcntl:

use Fcntl ':mode';

my $mode = (stat($filename))[2];

my $user_rwx      = ($mode & S_IRWXU) >> 6;
my $group_read    = ($mode & S_IRGRP) >> 3;
my $other_execute =  $mode & S_IXOTH;

printf "Permissions are %04o\n", S_IMODE($mode), "\n";

my $is_setuid     =  $mode & S_ISUID;
my $is_directory  =  S_ISDIR($mode);

Вы могли бы записать две последние с использованием операторов -u и -d. Общие доступные константы S_IF*:

# Permissions: read, write, execute, for user, group, others.

S_IRWXU S_IRUSR S_IWUSR S_IXUSR
S_IRWXG S_IRGRP S_IWGRP S_IXGRP
S_IRWXO S_IROTH S_IWOTH S_IXOTH

# Setuid/Setgid/Stickiness/SaveText.
# Note that the exact meaning of these is system-dependent.

S_ISUID S_ISGID S_ISVTX S_ISTXT

# File types.  Not all are necessarily available on
# your system.

S_IFREG S_IFDIR S_IFLNK S_IFBLK S_IFCHR
S_IFIFO S_IFSOCK S_IFWHT S_ENFMT

# The following are compatibility aliases for S_IRUSR,
# S_IWUSR, and S_IXUSR.

S_IREAD S_IWRITE S_IEXEC

и функции S_IF*

S_IMODE($mode)    the part of $mode containing the permission
                  bits and the setuid/setgid/sticky bits

S_IFMT($mode)     the part of $mode containing the file type
                  which can be bit-anded with (for example)
                  S_IFREG or with the following functions

# The operators -f, -d, -l, -b, -c, -p, and -S.

S_ISREG($mode) S_ISDIR($mode) S_ISLNK($mode)
S_ISBLK($mode) S_ISCHR($mode) S_ISFIFO($mode) S_ISSOCK($mode)

# No direct -X operator counterpart, but for the first one
# the -g operator is often equivalent.  The ENFMT stands for
# record flocking enforcement, a platform-dependent feature.

S_ISENFMT($mode) S_ISWHT($mode)

См. вашу документацию chmod(2) и stat(2) для получения более подробной информации о константах S_*. Для получения информации о состоянии символической ссылки вместо целевого файла за ссылкой используйте функцию lstat.

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

state VARLIST

state TYPE VARLIST

state VARLIST : ATTRS

state TYPE VARLIST : ATTRS

state объявляет лексически ограниченную переменную, как и my. Однако эти переменные никогда не будут повторно инициализированы, в отличие от лексических переменных, которые повторно инициализируются каждый раз при входе в их окружающий блок. См. "Постоянные частные переменные" в perlsub для получения подробной информации.

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

state доступна только если включена функция "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 ref только что созданного замыкания.

См. perlsub и perlref для получения подробностей о подпрограммах и ссылках; см. attributes и Attribute::Handlers для получения дополнительной информации об атрибутах.

__SUB__

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

Поведение __SUB__ внутри блока кода регулярного выражения (например, /(?{...})/) может быть изменено.

Этот токен доступен только под use v5.16 или функцией "current_sub". См. feature.

substr EXPR,OFFSET,LENGTH,REPLACEMENT

substr EXPR,OFFSET,LENGTH

substr EXPR,OFFSET

Извлекает подстроку из EXPR и возвращает её. Первый символ имеет смещение ноль. Если OFFSET отрицательное, оно отсчитывается от конца строки. Если LENGTH опущено, возвращается всё до конца строки. Если LENGTH отрицательное, столько символов опускается с конца строки.

my $s = "The black cat climbed the green tree";
my $color  = substr $s, 4, 5;      # black
my $middle = substr $s, 4, -11;    # black cat climbed the
my $end    = substr $s, 14;        # climbed the green tree
my $tail   = substr $s, -4;        # tree
my $z      = substr $s, -4, 2;     # tr

Вы можете использовать функцию substr в качестве левостороннего значения, в этом случае EXPR также должно быть левосторонним значением. Если вы присваиваете значение короче LENGTH, строка уменьшится, а если длиннее, строка увеличится, чтобы вместить его. Для сохранения длины строки может потребоваться заполнение или обрезка значения с помощью sprintf.

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

my $name = 'fred';
substr($name, 4) = 'dy';         # $name is now 'freddy'
my $null = substr $name, 6, 2;   # returns "" (no warning)
my $oops = substr $name, 7;      # returns undef, with warning
substr($name, 7) = 'gap';        # raises an exception

Альтернативой использованию substr в качестве левостороннего значения является указание строки замены в качестве четвёртого аргумента. Это позволяет заменить части EXPR и вернуть то, что было до этого, в одной операции, точно так же, как вы можете с splice.

my $s = "The black cat climbed the green tree";
my $z = substr $s, 14, 7, "jumped from";    # climbed
# $s is now "The black cat jumped from the green tree"

Обратите внимание, что левостороннее значение, возвращаемое трёхаргументной версией substr, действует как «волшебная пуля»; каждый раз, когда оно присваивается, запоминает, какая часть исходной строки модифицируется; например:

my $x = '1234';
for (substr($x,1,2)) {
    $_ = 'a';   print $x,"\n";    # prints 1a4
    $_ = 'xyz'; print $x,"\n";    # prints 1xyz4
    $x = '56789';
    $_ = 'pq';  print $x,"\n";    # prints 5pq9
}

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

my $x = '1234';
for (substr($x, -3, 2)) {
    $_ = 'a';   print $x,"\n";    # prints 1a4, as above
    $x = 'abcdefg';
    print $_,"\n";                # prints f
}

До версии Perl 5.10 результат многократного использования левостороннего значения был неопределённым. До версии 5.16 результат с отрицательными смещениями был неопределённым.

symlink OLDFILE,NEWFILE

Создаёт новое имя файла, символически связанное со старым именем файла. Возвращает 1 при успехе, 0 в противном случае. На системах, не поддерживающих символические ссылки, вызывает исключение. Для проверки этого используйте eval:

my $symlink_exists = eval { symlink("",""); 1 };

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

syscall NUMBER, LIST

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

require 'syscall.ph';        # may need to run h2ph
my $s = "hi there\n";
syscall(SYS_write(), fileno(STDOUT), $s, length $s);

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

Функция syscall возвращает то же значение, что и системный вызов. Если системный вызов завершается неудачно, syscall возвращает -1 и устанавливает $! (errno). Обратите внимание, что некоторые системные вызовы могут законно возвращать -1. Правильный способ обработки таких вызовов — присвоить $! = 0 перед вызовом, а затем проверить значение $!, если syscall возвращает -1.

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

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

sysopen FILEHANDLE,FILENAME,MODE

sysopen FILEHANDLE,FILENAME,MODE,PERMS

Открывает файл с заданным именем FILENAME и ассоциирует его с FILEHANDLE. Если FILEHANDLE — это выражение, его значение используется в качестве нужного реального дескриптора файла; неопределённый скаляр будет надлежащим образом автоматизирован. Эта функция вызывает системную функцию open(2) ОС с параметрами FILENAME, MODE и PERMS.

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

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

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

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

По историческим причинам некоторые значения работают практически на всех системах, поддерживаемых Perl: 0 означает только чтение, 1 означает только запись, а 2 означает чтение/запись. Мы знаем, что эти значения не работают под OS/390 и на 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 для получения дополнительной информации об этом.

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

Обратите внимание, что в Perl-версиях старше 5.8.0, sysopen зависит от функции fdopen(3) C-библиотеки. На многих Unix-системах fdopen(3) может завершиться неудачей, если дескрипторы файлов превышают определённое значение, обычно 255. Если вам нужны дескрипторы файлов больше, чем это, рассмотрите использование функции POSIX::open. Для Perl 5.8.0 и новее PerlIO (чаще всего) является значением по умолчанию.

См. perlopentut для более подробного объяснения открытия файлов.

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

sysread FILEHANDLE,SCALAR,LENGTH,OFFSET

sysread FILEHANDLE,SCALAR,LENGTH

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

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

Функции syseof() не существует, что нормально, так как eof в любом случае плохо работает с файлами устройств (например, ttys). Используйте sysread и проверьте значение возврата на 0, чтобы определить, закончено ли чтение.

Обратите внимание, что если для файлового дескриптора установлено значение :utf8, то sysread вызовет исключение. Слой :encoding(...) неявно вводит слой :utf8. См. binmode, open и прагму open.

sysseek FILEHANDLE,POSITION,WHENCE

Устанавливает системную позицию FILEHANDLE в байтах с помощью lseek(2). FILEHANDLE может быть выражением, значение которого дает имя файлового дескриптора. Значения для WHENCE: 0 для установки новой позиции в POSITION; 1 для установки позиции на текущую позицию плюс POSITION; и 2 для установки позиции в конец файла плюс POSITION (обычно отрицательное значение).

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

sysseek опускает обычный буферизованный ввод-вывод, поэтому смешивание его с другими операциями чтения, кроме sysread (например, readline или read), print, write, seek, tell или eof может вызвать путаницу.

Для WHENCE также можно использовать константы SEEK_SET, SEEK_CUR, и SEEK_END (начало файла, текущая позиция, конец файла) из модуля Fcntl. Использование констант также более переносимо, чем использование 0, 1 и 2. Например, для определения функции «systell»:

use Fcntl 'SEEK_CUR';
sub systell { sysseek($_[0], 0, SEEK_CUR) }

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

system LIST

system PROGRAM LIST

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

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

Значение возврата — код завершения программы, возвращаемый вызовом wait. Чтобы получить фактическое значение выхода, сдвиньте его вправо на восемь бит (см. ниже). См. также exec. Это не то, что нужно использовать для захвата вывода команды; для этого следует использовать обратные кавычки или qx//, как описано в "`STRING`" в perlop. Значение возврата -1 указывает на неудачу запуска программы или ошибку вызова системы wait(2) (посмотрите $! для причины).

Если вы хотите, чтобы system (и многие другие части Perl) выдавали ошибку при возникновении ошибки, посмотрите прагму autodie.

Как и exec, system позволяет вам солгать программе о её имени, если вы используете синтаксис system PROGRAM LIST. Опять же, см. exec.

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

my @args = ("command", "arg1", "arg2");
system(@args) == 0
    or die "system @args failed: $?";

Если вы хотите вручную проверить неудачу system, вы можете проверить все возможные способы неудачи, посмотрев $? так:

if ($? == -1) {
    print "failed to execute: $!\n";
}
elsif ($? & 127) {
    printf "child died with signal %d, %s coredump\n",
        ($? & 127),  ($? & 128) ? 'with' : 'without';
}
else {
    printf "child exited with value %d\n", $? >> 8;
}

В качестве альтернативы, вы можете посмотреть значение ${^CHILD_ERROR_NATIVE} с помощью вызовов W*() из модуля POSIX.

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

Так как system выполняет fork и wait, это может повлиять на обработчик SIGCHLD. Подробности см. в perlipc.

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

syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET

syswrite FILEHANDLE,SCALAR,LENGTH

syswrite FILEHANDLE,SCALAR

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

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

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

tell FILEHANDLE

tell

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

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

Значение возвращаемое функцией tell для стандартных потоков, таких как STDIN, зависит от операционной системы: может вернуть -1 или другое значение. tell для труб, FIFO и сокетов обычно возвращает -1.

Функции systell нет. Используйте sysseek($fh, 0, 1) для этого.

Не используйте tell (или другие операции буферизованного ввода-вывода) с файловым дескриптором, который был изменён с помощью sysread, syswrite или sysseek. Эти функции игнорируют буферизацию, в то время как tell - нет.

telldir DIRHANDLE

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

tie VARIABLE,CLASSNAME,LIST

Эта функция связывает переменную с классом пакета, который предоставит реализацию для переменной. VARIABLE - имя переменной, которая должна быть «очарована». CLASSNAME - имя класса, реализующего объекты правильного типа. Любые дополнительные аргументы передаются соответствующему методу конструктора класса (что означает TIESCALAR, TIEHANDLE, TIEARRAY, или TIEHASH). Обычно это такие аргументы, которые могут быть переданы функции dbm_open(3) языка C. Объект, возвращённый конструктором, также возвращается функцией tie, что будет полезно, если вы хотите получить доступ к другим методам в CLASSNAME.

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

# print out history file offsets
use NDBM_File;
tie(my %HIST, 'NDBM_File', '/usr/lib/news/history', 1, 0);
while (my ($key,$val) = each %HIST) {
    print $key, ' = ', unpack('L', $val), "\n";
}

Класс, реализующий хеш, должен иметь следующие методы:

TIEHASH classname, LIST
FETCH this, key
STORE this, key, value
DELETE this, key
CLEAR this
EXISTS this, key
FIRSTKEY this
NEXTKEY this, lastkey
SCALAR this
DESTROY this
UNTIE this

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

TIEARRAY classname, LIST
FETCH this, key
STORE this, key, value
FETCHSIZE this
STORESIZE this, count
CLEAR this
PUSH this, LIST
POP this
SHIFT this
UNSHIFT this, LIST
SPLICE this, offset, length, LIST
EXTEND this, count
DELETE this, key
EXISTS this, key
DESTROY this
UNTIE this

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

TIEHANDLE classname, LIST
READ this, scalar, length, offset
READLINE this
GETC this
WRITE this, scalar, length, offset
PRINT this, LIST
PRINTF this, format, LIST
BINMODE this
EOF this
FILENO this
SEEK this, position, whence
TELL this
OPEN this, mode, LIST
CLOSE this
DESTROY this
UNTIE this

Не все указанные выше методы необходимо реализовывать. См. perltie, Tie::Hash, Tie::Array, Tie::Scalar и Tie::Handle.

В отличие от dbmopen, функция tie не будет use или require модуля за вас; вы должны сделать это явно. Обратитесь к модулю DB_File или Config для интересных реализаций tie.

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

tied VARIABLE

Возвращает ссылку на объект, лежащий в основе VARIABLE (то же значение, которое изначально возвращалось вызовом tie, который связывал переменную с пакетом). Возвращает неопределённое значение, если VARIABLE не привязана к пакету.

time

Возвращает количество не високосных секунд с момента, когда система считает эпоху, подходящее для передачи в gmtime и localtime. На большинстве систем эпоха - 00:00:00 UTC, 1 января 1970; заметным исключением является Mac OS Classic, которая использует 00:00:00, 1 января 1904 в текущем часовом поясе для своей эпохи.

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

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

times

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

my ($user,$system,$cuser,$csystem) = times;

В скалярном контексте, times возвращает $user.

Временные данные дочерних процессов учитываются только для завершённых дочерних процессов.

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

tr///

Оператор транслитерации. То же, что и y///. См. "Quote-Like Operators" в perlop.

truncate FILEHANDLE,LENGTH

truncate EXPR,LENGTH

Усекает файл, открытый в FILEHANDLE или именованный EXPR, до указанной длины. Выбрасывает исключение, если усечение не реализовано на вашей системе. Возвращает true при успехе, undef при ошибке.

Поведение неопределённо, если LENGTH больше длины файла.

Позиция в файле FILEHANDLE не изменяется. Возможно, вы захотите вызвать seek перед записью в файл.

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

uc EXPR

uc

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

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

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

ucfirst EXPR

ucfirst

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

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

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

umask EXPR

umask

Устанавливает маску umask для процесса на EXPR и возвращает предыдущее значение. Если EXPR опущено, просто возвращает текущую маску umask.

Unix разрешения rwxr-x--- представлены тремя наборами из трёх битов или тремя восьмеричными цифрами: 0750 (ведущая 0 указывает на восьмеричное представление и не является одной из цифр). Значение umask - это такое число, представляющее отключённые биты разрешений. Значения разрешений (или «режима»), которые вы передаёте в mkdir или sysopen, модифицируются вашей маской umask, поэтому даже если вы скажете sysopen создать файл с разрешениями 0777, если ваша маска umask 0022, то файл фактически будет создан с разрешениями 0755. Если ваша umask была 0027 (группа не может писать; другие не могут читать, писать или исполнять), то передача sysopen 0666 создаст файл с режимом 0640 (потому что 0666 &~ 027 это 0640).

Вот совет: используйте режим создания 0666 для обычных файлов (в sysopen) и один из 0777 для каталогов (в mkdir) и исполняемых файлов. Это даёт пользователям свободу выбора: если они хотят защищённые файлы, они могут выбрать маски umask процесса 022, 027 или даже особенно антиобщественную маску 077. Программы редко, если вообще, должны принимать решения по политике, которые лучше оставлять пользователям. Исключение составляют файлы, которые должны быть конфиденциальными: почтовые файлы, файлы cookie веб-браузера, файлы .rhosts и так далее.

Если umask(2) не реализовано на вашей системе и вы пытаетесь ограничить доступ для себя (т.е., (EXPR & 0700) > 0), возникает исключение. Если umask(2) не реализовано и вы не пытаетесь ограничить доступ для себя, возвращает undef.

Помните, что umask - это число, обычно в восьмеричной системе счисления; это не строка восьмеричных цифр. См. также oct, если у вас только строка.

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

undef EXPR

undef

Устанавливает значение EXPR в неопределенное, EXPR должен быть lvalue. Используйте только для скалярных значений, массивов (используя @), хэшей (используя %), подпрограмм (используя &) или typeglob (используя *). Оператор undef на большинстве предопределённых переменных или значениях списков 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 опущен, unpack-рует строку $_. См. 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] =~ /^-/;

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

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

В форме use VERSION VERSION может быть либо v-строкой, такой как 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 присутствует между Модулем и LIST, то use вызовет метод VERSION в классе Модуль с заданной версией в качестве аргумента:

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

Изменяет время доступа и изменения каждого файла в списке файлов. Первые два элемента списка должны быть ЧИСЛОВЫМИ временем доступа и изменения, в указанном порядке. Возвращает количество успешно изменённых файлов. Время изменения индексного узла каждого файла устанавливается на текущее время. Например, этот код имеет тот же эффект, что и команда Unix touch(1), когда файлы уже существуют и принадлежат пользователю, выполняющему программу:

#!/usr/bin/perl
my $atime = my $mtime = time;
utime $atime, $mtime, @ARGV;

Начиная с Perl 5.8.0, если первые два элемента списка — undef, вызывается системный вызов utime(2) из вашей библиотеки C с нулевым вторым аргументом. На большинстве систем это установит время доступа и изменения файла на текущее время (т.е., эквивалентно приведенному выше примеру) и будет работать даже с файлами, которые вам не принадлежат, при условии, что у вас есть разрешение на запись:

for my $file (@ARGV) {
    utime(undef, undef, $file)
        || warn "Couldn't touch $file: $!";
}

В NFS это будет использовать время сервера NFS, а не время локальной машины. При проблемах с синхронизацией времени сервер NFS и локальная машина будут иметь разные значения времени. Команда Unix touch(1) на самом деле обычно использует эту форму вместо той, которая показана в первом примере.

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

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

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

values HASH

values ARRAY

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

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

В качестве побочного эффекта, вызов values сбрасывает внутренний итератор HASH или ARRAY (см. 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 с форматами с большим порядком байтов n/N (и аналогично для BITS==64). Подробности см. в pack.

Если bits равно 4 или меньше, строка разбивается на байты, затем биты каждого байта разбиваются на группы 8/BITS. Биты байта нумеруются в стиле little-endian, как в 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80. Например, разбитие одного входного байта chr(0x36) на две группы даёт список (0x6, 0x3); разбитие на 4 группы даёт (0x2, 0x1, 0x3, 0x0).

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

vec($image, $max_x * $x + $y, 8) = 3;

Если выбранный элемент находится за пределами строки, возвращается значение 0. Если элементу вне строки присваивается значение, Perl сначала расширит строку на необходимое количество нулевых байтов. Попытка записи вне начала строки (т.е. отрицательное OFFSET) является ошибкой.

Если строка закодирована как UTF-8 (и, следовательно, установлен флаг UTF8), vec пытается преобразовать её в внутреннее представление с одним байтом на символ. Однако, если строка содержит символы со значениями 256 или выше, произойдёт фатальная ошибка.

Строки, созданные с помощью vec, также могут быть обработаны с помощью логических операторов |, &, ^, и ~. Эти операторы предполагают битовую операцию над векторами, когда оба операнда являются строками. См. "Bitwise String Operators" в perlop.

Следующий код создаёт ASCII-строку, которая гласит 'PerlPerlPerl'. Комментарии показывают строку после каждого шага. Обратите внимание, что этот код работает одинаково на машинах с big-endian или little-endian архитектурой.

my $foo = '';
vec($foo,  0, 32) = 0x5065726C; # 'Perl'

# $foo eq "Perl" eq "\x50\x65\x72\x6C", 32 bits
print vec($foo, 0, 8);  # prints 80 == 0x50 == ord('P')

vec($foo,  2, 16) = 0x5065; # 'PerlPe'
vec($foo,  3, 16) = 0x726C; # 'PerlPerl'
vec($foo,  8,  8) = 0x50;   # 'PerlPerlP'
vec($foo,  9,  8) = 0x65;   # 'PerlPerlPe'
vec($foo, 20,  4) = 2;      # 'PerlPerlPe'   . "\x02"
vec($foo, 21,  4) = 7;      # 'PerlPerlPer'
                               # 'r' is "\x72"
vec($foo, 45,  2) = 3;      # 'PerlPerlPer'  . "\x0c"
vec($foo, 93,  1) = 1;      # 'PerlPerlPer'  . "\x2c"
vec($foo, 94,  1) = 1;      # 'PerlPerlPerl'
                               # 'l' is "\x6c"

Для преобразования битового вектора в строку или список из 0 и 1 используйте эти методы:

my $bits = unpack("b*", $vector);
my @bits = split(//, unpack("b*", $vector));

Если известна точная длина в битах, она может быть использована вместо *.

Вот пример, иллюстрирующий, как биты фактически выстраиваются:

#!/usr/bin/perl -wl

print <<'EOT';
                                  0         1         2         3
                   unpack("V",$_) 01234567890123456789012345678901
------------------------------------------------------------------
EOT

for $w (0..3) {
    $width = 2**$w;
    for ($shift=0; $shift < $width; ++$shift) {
        for ($off=0; $off < 32/$width; ++$off) {
            $str = pack("B*", "0"x32);
            $bits = (1<<$shift);
            vec($str, $off, $width) = $bits;
            $res = unpack("b*",$str);
            $val = unpack("V", $str);
            write;
        }
    }
}

format STDOUT =
vec($_,@#,@#) = @<< == @######### @>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
$off, $width, $bits, $val, $res
.
__END__

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

                                  0         1         2         3
                   unpack("V",$_) 01234567890123456789012345678901
------------------------------------------------------------------
vec($_, 0, 1) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 1) = 1   ==          2 01000000000000000000000000000000
vec($_, 2, 1) = 1   ==          4 00100000000000000000000000000000
vec($_, 3, 1) = 1   ==          8 00010000000000000000000000000000
vec($_, 4, 1) = 1   ==         16 00001000000000000000000000000000
vec($_, 5, 1) = 1   ==         32 00000100000000000000000000000000
vec($_, 6, 1) = 1   ==         64 00000010000000000000000000000000
vec($_, 7, 1) = 1   ==        128 00000001000000000000000000000000
vec($_, 8, 1) = 1   ==        256 00000000100000000000000000000000
vec($_, 9, 1) = 1   ==        512 00000000010000000000000000000000
vec($_,10, 1) = 1   ==       1024 00000000001000000000000000000000
vec($_,11, 1) = 1   ==       2048 00000000000100000000000000000000
vec($_,12, 1) = 1   ==       4096 00000000000010000000000000000000
vec($_,13, 1) = 1   ==       8192 00000000000001000000000000000000
vec($_,14, 1) = 1   ==      16384 00000000000000100000000000000000
vec($_,15, 1) = 1   ==      32768 00000000000000010000000000000000
vec($_,16, 1) = 1   ==      65536 00000000000000001000000000000000
vec($_,17, 1) = 1   ==     131072 00000000000000000100000000000000
vec($_,18, 1) = 1   ==     262144 00000000000000000010000000000000
vec($_,19, 1) = 1   ==     524288 00000000000000000001000000000000
vec($_,20, 1) = 1   ==    1048576 00000000000000000000100000000000
vec($_,21, 1) = 1   ==    2097152 00000000000000000000010000000000
vec($_,22, 1) = 1   ==    4194304 00000000000000000000001000000000
vec($_,23, 1) = 1   ==    8388608 00000000000000000000000100000000
vec($_,24, 1) = 1   ==   16777216 00000000000000000000000010000000
vec($_,25, 1) = 1   ==   33554432 00000000000000000000000001000000
vec($_,26, 1) = 1   ==   67108864 00000000000000000000000000100000
vec($_,27, 1) = 1   ==  134217728 00000000000000000000000000010000
vec($_,28, 1) = 1   ==  268435456 00000000000000000000000000001000
vec($_,29, 1) = 1   ==  536870912 00000000000000000000000000000100
vec($_,30, 1) = 1   == 1073741824 00000000000000000000000000000010
vec($_,31, 1) = 1   == 2147483648 00000000000000000000000000000001
vec($_, 0, 2) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 2) = 1   ==          4 00100000000000000000000000000000
vec($_, 2, 2) = 1   ==         16 00001000000000000000000000000000
vec($_, 3, 2) = 1   ==         64 00000010000000000000000000000000
vec($_, 4, 2) = 1   ==        256 00000000100000000000000000000000
vec($_, 5, 2) = 1   ==       1024 00000000001000000000000000000000
vec($_, 6, 2) = 1   ==       4096 00000000000010000000000000000000
vec($_, 7, 2) = 1   ==      16384 00000000000000100000000000000000
vec($_, 8, 2) = 1   ==      65536 00000000000000001000000000000000
vec($_, 9, 2) = 1   ==     262144 00000000000000000010000000000000
vec($_,10, 2) = 1   ==    1048576 00000000000000000000100000000000
vec($_,11, 2) = 1   ==    4194304 00000000000000000000001000000000
vec($_,12, 2) = 1   ==   16777216 00000000000000000000000010000000
vec($_,13, 2) = 1   ==   67108864 00000000000000000000000000100000
vec($_,14, 2) = 1   ==  268435456 00000000000000000000000000001000
vec($_,15, 2) = 1   == 1073741824 00000000000000000000000000000010
vec($_, 0, 2) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 2) = 2   ==          8 00010000000000000000000000000000
vec($_, 2, 2) = 2   ==         32 00000100000000000000000000000000
vec($_, 3, 2) = 2   ==        128 00000001000000000000000000000000
vec($_, 4, 2) = 2   ==        512 00000000010000000000000000000000
vec($_, 5, 2) = 2   ==       2048 00000000000100000000000000000000
vec($_, 6, 2) = 2   ==       8192 00000000000001000000000000000000
vec($_, 7, 2) = 2   ==      32768 00000000000000010000000000000000
vec($_, 8, 2) = 2   ==     131072 00000000000000000100000000000000
vec($_, 9, 2) = 2   ==     524288 00000000000000000001000000000000
vec($_,10, 2) = 2   ==    2097152 00000000000000000000010000000000
vec($_,11, 2) = 2   ==    8388608 00000000000000000000000100000000
vec($_,12, 2) = 2   ==   33554432 00000000000000000000000001000000
vec($_,13, 2) = 2   ==  134217728 00000000000000000000000000010000
vec($_,14, 2) = 2   ==  536870912 00000000000000000000000000000100
vec($_,15, 2) = 2   == 2147483648 00000000000000000000000000000001
vec($_, 0, 4) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 4) = 1   ==         16 00001000000000000000000000000000
vec($_, 2, 4) = 1   ==        256 00000000100000000000000000000000
vec($_, 3, 4) = 1   ==       4096 00000000000010000000000000000000
vec($_, 4, 4) = 1   ==      65536 00000000000000001000000000000000
vec($_, 5, 4) = 1   ==    1048576 00000000000000000000100000000000
vec($_, 6, 4) = 1   ==   16777216 00000000000000000000000010000000
vec($_, 7, 4) = 1   ==  268435456 00000000000000000000000000001000
vec($_, 0, 4) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 4) = 2   ==         32 00000100000000000000000000000000
vec($_, 2, 4) = 2   ==        512 00000000010000000000000000000000
vec($_, 3, 4) = 2   ==       8192 00000000000001000000000000000000
vec($_, 4, 4) = 2   ==     131072 00000000000000000100000000000000
vec($_, 5, 4) = 2   ==    2097152 00000000000000000000010000000000
vec($_, 6, 4) = 2   ==   33554432 00000000000000000000000001000000
vec($_, 7, 4) = 2   ==  536870912 00000000000000000000000000000100
vec($_, 0, 4) = 4   ==          4 00100000000000000000000000000000
vec($_, 1, 4) = 4   ==         64 00000010000000000000000000000000
vec($_, 2, 4) = 4   ==       1024 00000000001000000000000000000000
vec($_, 3, 4) = 4   ==      16384 00000000000000100000000000000000
vec($_, 4, 4) = 4   ==     262144 00000000000000000010000000000000
vec($_, 5, 4) = 4   ==    4194304 00000000000000000000001000000000
vec($_, 6, 4) = 4   ==   67108864 00000000000000000000000000100000
vec($_, 7, 4) = 4   == 1073741824 00000000000000000000000000000010
vec($_, 0, 4) = 8   ==          8 00010000000000000000000000000000
vec($_, 1, 4) = 8   ==        128 00000001000000000000000000000000
vec($_, 2, 4) = 8   ==       2048 00000000000100000000000000000000
vec($_, 3, 4) = 8   ==      32768 00000000000000010000000000000000
vec($_, 4, 4) = 8   ==     524288 00000000000000000001000000000000
vec($_, 5, 4) = 8   ==    8388608 00000000000000000000000100000000
vec($_, 6, 4) = 8   ==  134217728 00000000000000000000000000010000
vec($_, 7, 4) = 8   == 2147483648 00000000000000000000000000000001
vec($_, 0, 8) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 8) = 1   ==        256 00000000100000000000000000000000
vec($_, 2, 8) = 1   ==      65536 00000000000000001000000000000000
vec($_, 3, 8) = 1   ==   16777216 00000000000000000000000010000000
vec($_, 0, 8) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 8) = 2   ==        512 00000000010000000000000000000000
vec($_, 2, 8) = 2   ==     131072 00000000000000000100000000000000
vec($_, 3, 8) = 2   ==   33554432 00000000000000000000000001000000
vec($_, 0, 8) = 4   ==          4 00100000000000000000000000000000
vec($_, 1, 8) = 4   ==       1024 00000000001000000000000000000000
vec($_, 2, 8) = 4   ==     262144 00000000000000000010000000000000
vec($_, 3, 8) = 4   ==   67108864 00000000000000000000000000100000
vec($_, 0, 8) = 8   ==          8 00010000000000000000000000000000
vec($_, 1, 8) = 8   ==       2048 00000000000100000000000000000000
vec($_, 2, 8) = 8   ==     524288 00000000000000000001000000000000
vec($_, 3, 8) = 8   ==  134217728 00000000000000000000000000010000
vec($_, 0, 8) = 16  ==         16 00001000000000000000000000000000
vec($_, 1, 8) = 16  ==       4096 00000000000010000000000000000000
vec($_, 2, 8) = 16  ==    1048576 00000000000000000000100000000000
vec($_, 3, 8) = 16  ==  268435456 00000000000000000000000000001000
vec($_, 0, 8) = 32  ==         32 00000100000000000000000000000000
vec($_, 1, 8) = 32  ==       8192 00000000000001000000000000000000
vec($_, 2, 8) = 32  ==    2097152 00000000000000000000010000000000
vec($_, 3, 8) = 32  ==  536870912 00000000000000000000000000000100
vec($_, 0, 8) = 64  ==         64 00000010000000000000000000000000
vec($_, 1, 8) = 64  ==      16384 00000000000000100000000000000000
vec($_, 2, 8) = 64  ==    4194304 00000000000000000000001000000000
vec($_, 3, 8) = 64  == 1073741824 00000000000000000000000000000010
vec($_, 0, 8) = 128 ==        128 00000001000000000000000000000000
vec($_, 1, 8) = 128 ==      32768 00000000000000010000000000000000
vec($_, 2, 8) = 128 ==    8388608 00000000000000000000000100000000
vec($_, 3, 8) = 128 == 2147483648 00000000000000000000000000000001

wait

Ведёт себя как wait(2) на вашей системе: ждёт завершения дочернего процесса и возвращает pid завершённого процесса, или -1 если нет дочерних процессов. Статус возвращается в $? и ${^CHILD_ERROR_NATIVE}. Обратите внимание, что возвращаемое значение -1 может означать, что дочерние процессы собираются автоматически, как описано в perlipc.

Если вы используете wait в своём обработчике для $SIG{CHLD}, это может случайно подождать дочерний процесс, созданный с помощью qx или system. Подробности см. в perlipc.

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

waitpid PID,FLAGS

Ждёт завершения определённого дочернего процесса и возвращает pid завершённого процесса, или -1 если такого дочернего процесса нет. Неблокирующее ожидание (с WNOHANG в FLAGS) может вернуть 0, если существуют дочерние процессы, соответствующие PID, но ни один из них ещё не завершился. Статус возвращается в $? и ${^CHILD_ERROR_NATIVE}.

PID со значением 0 указывает на ожидание любого дочернего процесса, группа процессов которого совпадает с группой текущего процесса. PID меньше -1 указывает на ожидание любого дочернего процесса, группа процессов которого равна -PID. PID со значением -1 указывает на ожидание любого дочернего процесса.

Если вы используете

use POSIX ":sys_wait_h";

my $kid;
do {
    $kid = waitpid(-1, WNOHANG);
} while $kid > 0;

или

1 while waitpid(-1, WNOHANG) > 0;

то вы можете выполнить неблокирующее ожидание всех ожидающих процессов-зомби (см. "WAIT" в POSIX). Неблокирующее ожидание доступно на машинах, поддерживающих системные вызовы waitpid(2) или wait4(2). Однако ожидание конкретного pid с флагами 0 реализовано везде. (Perl эмулирует системный вызов, запоминая статусы процессов, которые завершились, но ещё не обработаны скриптом Perl.)

Обратите внимание, что на некоторых системах возвращаемое значение -1 может означать, что дочерние процессы собираются автоматически. Подробности см. в perlipc, а также другие примеры.

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

wantarray

Возвращает true, если контекст текущей подпрограммы или eval ожидает список значений. Возвращает false, если контекст ожидает скаляр. Возвращает undef, если контекст ожидает отсутствие значения (контекст беззначения).

return unless defined wantarray; # don't bother doing more
my @a = complex_calculation();
return wantarray ? @a : "@a";

wantarray результат не определён в главном уровне файла, в BEGIN, UNITCHECK, CHECK, INIT или END блоках, или в DESTROY методе.

Эта функция должна была называться wantlist().

warn LIST

Выводит предупреждение, обычно выведя его в STDERR. warn интерпретирует свой операнд LIST так же, как и die, но немного отличается в том, что он по умолчанию делает, когда LIST пустой или создаёт пустую строку. Если он пустой и $@ уже содержит значение исключения, то это значение используется после добавления "\t...caught". Если он пустой и $@ тоже пустой, то используется строка "Warning: Something's wrong".

По умолчанию, исключение, полученное из операнда LIST, строкуется и выводится в STDERR. Это поведение может быть изменено путём установки обработчика $SIG{__WARN__}. Если такой обработчик есть, то сообщение автоматически не выводится; обязанность обработчика — обработать исключение по своему усмотрению (например, преобразовать его в die). Поэтому большинство обработчиков должны организовать вывод предупреждений, с которыми они не готовы справиться, вызвав warn снова в обработчике. Обратите внимание, что это достаточно безопасно и не приведёт к бесконечной петле, так как __WARN__-хуки не вызываются изнутри одного.

Вы заметите, что это поведение немного отличается от поведения обработчиков $SIG{__DIE__} (которые не подавляют текст ошибки, но вместо этого могут вызвать die снова, чтобы его изменить).

Использование обработчика __WARN__ предоставляет мощный способ подавления всех предупреждений (даже так называемых обязательных). Пример:

# wipe out *all* compile-time warnings
BEGIN { $SIG{'__WARN__'} = sub { warn $_[0] if $DOWARN } }
my $foo = 10;
my $foo = 20;          # no warning about duplicate my $foo,
                       # but hey, you asked for it!
# no compile-time or run-time warnings before here
$DOWARN = 1;

# run-time warnings enabled after here
warn "\$foo is alive and $foo!";     # does show up

См. perlvar для получения подробностей о настройке %SIG записей и для получения дополнительных примеров. Обратитесь к модулю Carp для получения других видов предупреждений, используя его carp и cluck функции.

write FILEHANDLE

write EXPR

write

Записывает отформатированный блок записей (возможно, многострочный) в указанный FILEHANDLE, используя формат, связанный с этим файлом. По умолчанию формат файла — тот, у которого такое же имя, как у filehandle, но формат текущего выходного канала (см. функцию select) может быть установлен явно, присвоив имя формата переменной $~.

Обработка начала формы выполняется автоматически: если на текущей странице недостаточно места для отформатированной записи, страница переносится на следующую, записывая символ перехода страницы и специальный формат начала страницы используется для форматирования заголовка новой страницы перед записью записи. По умолчанию, формат начала страницы — имя filehandle с добавленным _TOP, или top в текущем пакете, если первый не существует. Это было бы проблемой с автовивифицированными filehandle, но это может быть динамически установлено на формат вашего выбора, присвоив имя переменной $^ при выборе этого filehandle. Количество строк, оставшихся на текущей странице, хранится в переменной $-, которая может быть установлена в 0 для принудительного перехода на новую страницу.

Если FILEHANDLE не указан, вывод направляется в текущий стандартный выходной канал, который по умолчанию равен STDOUT, но может быть изменён оператором select. Если FILEHANDLE является EXPR, то выражение вычисляется, а полученная строка используется для поиска имени FILEHANDLE во время выполнения. Дополнительную информацию о форматах см. в perlform.

Обратите внимание, что write не является противоположностью read. К сожалению.

y///

Оператор транслитерации. То же самое, что tr///. См. "Операторы, похожие на кавычки" в perlop.

Ключевые слова без функций по перекрестной ссылке

perldata

__DATA__

__END__

Эти ключевые слова описаны в "Специальные литералы" в perldata.

perlmod

BEGIN

CHECK

END

INIT

UNITCHECK

Эти ключевые слова фазы компиляции описаны в "BEGIN, UNITCHECK, CHECK, INIT и END" в perlmod.

perlobj

DESTROY

Это ключевое слово метода описано в "Деструкторы" в perlobj.

perlop

and

cmp

eq

ge

gt

le

lt

ne

not

or

x

xor

Эти операторы описаны в perlop.

perlsub

AUTOLOAD

Это ключевое слово описано в "Автозагрузка" в perlsub.

perlsyn

else

elsif

for

foreach

if

unless

until

while

Эти ключевые слова управления потоком описаны в "Составные операторы" в perlsyn.

elseif

Ключевое слово «else if» в Perl пишется как elsif. Также нет elif или else if. Он действительно анализирует elseif, но только чтобы предупредить вас о его неиспользовании.

См. документацию по ключевым словам управления потоком в "Составные операторы" в perlsyn.

default

given

when

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