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

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

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

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

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

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

chdir EXPR

chdir FILEHANDLE

chdir DIRHANDLE

chdir

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

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

chmod LIST

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

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

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

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

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

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

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

chomp VARIABLE

chomp( LIST )

chomp

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

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

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

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

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

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

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

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

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

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

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

chroot FILENAME

chroot

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

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

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

close FILEHANDLE

close

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

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

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

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

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

Пример:

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

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

closedir DIRHANDLE

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

connect SOCKET,NAME

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

continue BLOCK

continue

Если за ним следует блок кода, 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 и "Switch Statements" в perlsyn для получения дополнительной информации.

cos EXPR

cos

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

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

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

crypt PLAINTEXT,SALT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

dbmclose HASH

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

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

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

dbmopen HASH,DBNAME,MASK

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

Эта функция связывает файл dbm(3), ndbm(3), sdbm(3), gdbm(3) или Berkeley DB с хэшем. HASH — имя хэша. (В отличие от обычной функции open, первый аргумент не является дескриптором файла, хотя и выглядит как таковой). DBNAME — имя базы данных (без расширений .dir или .pag, если они есть). Если база данных не существует, она создаётся с защитой, указанной в MASK (как изменено функцией umask). Чтобы предотвратить создание базы данных, если она не существует, можно указать 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 для этого элемента больше не возвращает true. Установка элемента хэша в значение undefined не удаляет его ключ, но удаление — делает это; см. exists.

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

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

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

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

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

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

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

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

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

То же самое делают и эти:

delete @HASH{keys %HASH};

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

Но оба варианта медленнее, чем присвоение пустого списка или undef для %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 завершается значением undefined. Если исключение находится вне всех окружающих evals, то неперехваченное исключение выводится в 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's errno, которое может быть установлено любым системным вызовом, это означает, что значение кода выхода, используемого die, может быть непредсказуемым, поэтому на него не следует полагаться, кроме как на то, что он не равен нулю.

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

die @_ if $^S;

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

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

do BLOCK

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

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

do EXPR

Использует значение EXPR в качестве имени файла и выполняет содержимое файла как скрипт Perl:

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

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

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

eval `cat stat.pl`;

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

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

do 'foo/stat.pl';

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

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

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

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

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

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

dump LABEL

dump EXPR

dump

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

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

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

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

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

each HASH

each ARRAY

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

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

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

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

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

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

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

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

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

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

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

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

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

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

eof FILEHANDLE

eof ()

eof

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

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

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

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

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

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

eval EXPR

eval BLOCK

eval

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

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

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

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

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

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

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

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

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

Строковый eval

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

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

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

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

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

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

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

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

• Он может потерять контроль над тем, должно ли что-то кодироваться как UTF-8 или нет.

• Активированные в eval фильтры исходного кода просачиваются в текущую область файла, который компилируется. Например, с модулем CPAN Semi::Semicolons:

  BEGIN { eval "use Semi::Semicolons; # not filtered" }
  # filtered here!

  evalbytes исправляет это, чтобы оно работало так, как ожидается:

  use feature "evalbytes";
  BEGIN { evalbytes "use Semi::Semicolons; # filtered" }
  # not filtered

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

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

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

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

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

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

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

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

Блочный eval

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

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

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

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

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

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

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

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

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

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

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

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

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

evalbytes EXPR

evalbytes

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

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

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

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

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

выводит

256

и $@ пуста.

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

evalbytes доступен начиная с Perl версии 5.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 — это процесс преобразования строк в форму, где разницы в регистре стёрты; сравнение двух строк в их casefolded форме фактически эквивалентно проверке их равенства, независимо от регистра.

Примерно, если вы когда-либо писали так

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 обратитесь к Стандарту Юникода, в частности к разделам 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. Casefolded форма этого символа обычно "ss", но, как объяснено в разделе lc, изменения регистра, пересекающие границу 255/256, вызывают проблемы в локали и поэтому запрещены. Поэтому эта функция в локали возвращает вместо этого строку "\x{17F}\x{17F}", которая является символом LATIN SMALL LETTER LONG S. Поскольку этот символ сам преобразуется в "s", строка из двух таких символов должна быть эквивалентна одному U+1E9E после применения casefolding.

Хотя Стандарт Юникода определяет две дополнительные формы 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 предупреждений Perl при неверных числовых преобразованиях.

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

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

use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);

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

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

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

__FILE__

Специальный идентификатор, возвращающий имя файла, в котором он находится. Он может быть изменён механизмом, описанным в "Простые комментарии (не!)" в perlsyn.

fileno FILEHANDLE

fileno DIRHANDLE

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

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

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

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

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

flock FILEHANDLE,OPERATION

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fork

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

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

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

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

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

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

format

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

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

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

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

formline PICTURE,LIST

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

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

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

getc FILEHANDLE

getc

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

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

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

getsockopt SOCKET,LEVEL,OPTNAME

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

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

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

use Socket qw(:all);

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

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

glob EXPR

glob

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

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

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

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

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

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

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

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

int EXPR

int

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

ioctl FILEHANDLE,FUNCTION,SCALAR

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

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

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

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

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

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

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

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

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

join EXPR,LIST

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

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

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

keys HASH

keys ARRAY

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

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

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

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

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

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

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

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

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

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

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

keys %hash = 200;

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

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

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

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

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

kill SIGNAL, LIST

kill SIGNAL

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

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

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

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

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

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

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

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

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

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

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

Если нет списка LIST процессов, сигнал не отправляется, а возвращаемое значение равно 0. Эта форма иногда используется, поскольку она запускает проверки таинства. Однако см. "Стирка и обнаружение заражённых данных" в perlsec.

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

last LABEL

last EXPR

last

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

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

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

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

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

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

lc EXPR

lc

Возвращает строку EXPR в нижнем регистре. Это внутренняя функция, реализующая 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, не определены однозначно. Например, строчная буква острого S (U+1E9E) в правилах Unicode — U+00DF (на платформах ASCII). Но в use locale (до версии 5.20 или не в UTF-8 локали) строчная буква U+1E9E — это сама она, потому что 0xDF может не быть строчной буквой острого 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"

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

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

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

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

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

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

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

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

lock THING

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

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

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

log EXPR

log

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

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

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

lstat FILEHANDLE

lstat EXPR

lstat DIRHANDLE

lstat

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

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

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

m//

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

map BLOCK LIST

map EXPR,LIST

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

mkdir FILENAME,MODE

mkdir FILENAME

mkdir

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

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

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

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

msgctl ID,CMD,ARG

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

use IPC::SysV;

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

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

msgget KEY,FLAGS

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

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

msgrcv ID,VAR,SIZE,TYPE,FLAGS

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

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

msgsnd ID,MSG,FLAGS

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

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

my VARLIST

my TYPE VARLIST

my VARLIST : ATTRS

my TYPE VARLIST : ATTRS

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

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

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

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

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

next LABEL

next EXPR

next

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

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

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

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

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

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

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

no MODULE VERSION LIST

no MODULE VERSION

no MODULE LIST

no MODULE

no VERSION

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

oct EXPR

oct

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

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

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

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

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

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

open FILEHANDLE,MODE,EXPR

open FILEHANDLE,MODE,EXPR,LIST

open FILEHANDLE,MODE,REFERENCE

open FILEHANDLE,EXPR

open FILEHANDLE

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

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

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

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

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

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

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

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

# Process every line in input.txt
while (my $line = <$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 возвращает ненулевое значение при успехе и неопределённое значение в противном случае. Если open представляло собой канал, возвращаемое значение будет идентификатором процесса дочернего процесса.

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

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

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

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

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

На некоторых системах (в основном, системах на основе DOS и Windows) binmode необходим, когда вы работаете не с текстовым файлом. Для обеспечения переносимости рекомендуется всегда использовать его, когда это необходимо, и никогда не использовать его, когда это не нужно. Кроме того, пользователи могут установить свой ввод-вывод по умолчанию в UTF8-кодированный 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; в противном случае нет.

Подробную информацию о PerlIO см. в perliol.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

или

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

или

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Проблемы переносимости

См. "open" в perlport.

opendir DIRHANDLE,EXPR

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

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

ord EXPR

ord

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

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

our VARLIST

our TYPE VARLIST

our VARLIST : ATTRS

our TYPE VARLIST : ATTRS

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

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

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

package Foo;
use 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. Подробности см. в "Private Variables via my()" in perlsub.

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

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

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

pack TEMPLATE,LIST

Принимает список значений и преобразует его в строку, используя правила, заданные TEMPLATE. Результирующая строка является конкатенацией преобразованных значений. Как правило, каждое преобразованное значение выглядит как его представление на уровне машины. Например, на 32-битных машинах целое число может быть представлено последовательностью из 4 байтов, которые в Perl будут представлены строкой длиной в 4 символа.

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

TEMPLATE — это последовательность символов, определяющих порядок и тип значений, как показано ниже:

a  A string with arbitrary binary data, will be null padded.
A  A text (ASCII) string, will be space padded.
Z  A null-terminated (ASCIZ) string, will be null padded.

b  A bit string (ascending bit order inside each byte,
   like vec()).
B  A bit string (descending bit order inside each byte).
h  A hex string (low nybble first).
H  A hex string (high nybble first).

c  A signed char (8-bit) value.
C  An unsigned char (octet) value.
W  An unsigned char value (can be greater than 255).

s  A signed short (16-bit) value.
S  An unsigned short value.

l  A signed long (32-bit) value.
L  An unsigned long value.

q  A signed quad (64-bit) value.
Q  An unsigned quad value.
     (Quads are available only if your system supports 64-bit
      integer values _and_ if Perl has been compiled to support
      those.  Raises an exception otherwise.)

i  A signed integer value.
I  An unsigned integer value.
     (This 'integer' is _at_least_ 32 bits wide.  Its exact
      size depends on what a local C compiler calls 'int'.)

n  An unsigned short (16-bit) in "network" (big-endian) order.
N  An unsigned long (32-bit) in "network" (big-endian) order.
v  An unsigned short (16-bit) in "VAX" (little-endian) order.
V  An unsigned long (32-bit) in "VAX" (little-endian) order.

j  A Perl internal signed integer value (IV).
J  A Perl internal unsigned integer value (UV).

f  A single-precision float in native format.
d  A double-precision float in native format.

F  A Perl internal floating-point value (NV) in native format
D  A float of long-double precision in native format.
     (Long doubles are available only if your system supports
      long double values. Raises an exception otherwise.
      Note that there are different long double formats.)

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

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

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

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

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

!   sSlLiI     Forces native (short, long, int) sizes instead
               of fixed (16-/32-bit) sizes.

!   xX         Make x and X act as alignment commands.

!   nNvV       Treat integers as signed instead of unsigned.

!   @.         Specify position as byte offset in the internal
               representation of the packed string.  Efficient
               but dangerous.

>   sSiIlLqQ   Force big-endian byte-order on the type.
    jJfFdDpP   (The "big end" touches the construct.)

<   sSiIlLqQ   Force little-endian byte-order on the type.
    jJfFdDpP   (The "little end" touches the construct.)

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

Применяются следующие правила:

• Каждый символ может быть необязательно последован числом, указывающим количество повторений. Числовое количество повторений может быть необязательно заключено в скобки, как в pack("C[80]", @arr). Количество повторений берет столько значений из СПИСКА, когда используется со всеми типами форматов, кроме a, A, Z, b, B, h, H, @, ., x, X, и P, где это имеет другое значение, описанное ниже. Предоставление * для количества повторений вместо числа означает использование оставшегося количества элементов, за исключением:

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

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

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

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

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

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

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

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

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

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

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

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

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

  Если значение для упаковки слишком длинное, результат усекается. Если оно слишком длинное, и предоставлено явное количество, Z упаковывает только $count-1 байт, после чего следует нулевой байт. Таким образом Z всегда упаковывает завершающий нуль, за исключением случая, когда количество равно 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} не определено на системах без поддержки long long.

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

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

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

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

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

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

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

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

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

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

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

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

  $ perl -V:byteorder

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  $ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
    perl -CS -ne 'printf "%v04X\n", $_ for unpack("C0A*", $_)'
  03B1.03C9
  $ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
    perl -CS -ne 'printf "%v02X\n", $_ for unpack("U0A*", $_)'
  CE.B1.CF.89
  $ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
    perl -C0 -ne 'printf "%v02X\n", $_ for unpack("C0A*", $_)'
  CE.B1.CF.89
  $ perl -CS -E 'say "\x{3B1}\x{3C9}"' |
    perl -C0 -ne 'printf "%v02X\n", $_ for unpack("U0A*", $_)'
  C3.8E.C2.B1.C3.8F.C2.89

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

• Вы сами должны выполнять выравнивание или заполнение, вставляя, например, достаточно "x" во время упаковки. Функции pack и unpack не знают, откуда или куда идут символы, поэтому они обрабатывают свой вывод и вход как плоские последовательности символов.

• Группа () — это вложенный шаблон, заключённый в скобки. Группа может принять количество повторений как постфикс, или для unpack, также через символ шаблона /. В каждом повторении группы позиционирование с @ начинается заново с 0. Таким образом, результат

  pack("@1A((@2A)@3A)", qw[X Y Z])

  — это строка "\0X\0\0YZ".

• x и X принимают модификатор ! для работы в качестве команд выравнивания: они перемещаются вперед или назад к ближайшей позиции, выровненной по кратному значению count символов. Например, для pack или unpack структуры C, такой как

  struct {
      char   c;    /* one signed, 8-bit character */
      double d;
      char   cc[2];
  }

  может потребоваться шаблон c x![d] d c[2]. Это предполагает, что числа двойной точности должны быть выровнены по размеру числа двойной точности.

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

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

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

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

• Попытка упаковать специальные значения чисел с плавающей точкой Inf и NaN (бесконечность, также в отрицательной форме, и не число) в упакованные целочисленные значения (например, "L") приводит к ошибке. Причина этого заключается в том, что просто нет разумного соответствия для этих специальных значений в целых числах.

Примеры:

$foo = pack("WWWW",65,66,67,68);
# foo eq "ABCD"
$foo = pack("W4",65,66,67,68);
# same thing
$foo = pack("W4",0x24b6,0x24b7,0x24b8,0x24b9);
# same thing with Unicode circled letters.
$foo = pack("U4",0x24b6,0x24b7,0x24b8,0x24b9);
# same thing with Unicode circled letters.  You don't get the
# UTF-8 bytes because the U at the start of the format caused
# a switch to U0-mode, so the UTF-8 bytes get joined into
# characters
$foo = pack("C0U4",0x24b6,0x24b7,0x24b8,0x24b9);
# foo eq "\xe2\x92\xb6\xe2\x92\xb7\xe2\x92\xb8\xe2\x92\xb9"
# This is the UTF-8 encoding of the string in the
# previous example

$foo = pack("ccxxcc",65,66,67,68);
# foo eq "AB\0\0CD"

# NOTE: The examples above featuring "W" and "c" are true
# only on ASCII and ASCII-derived systems such as ISO Latin 1
# and UTF-8.  On EBCDIC systems, the first example would be
#      $foo = pack("WWWW",193,194,195,196);

$foo = pack("s2",1,2);
# "\001\000\002\000" on little-endian
# "\000\001\000\002" on big-endian

$foo = pack("a4","abcd","x","y","z");
# "abcd"

$foo = pack("aaaa","abcd","x","y","z");
# "axyz"

$foo = pack("a14","abcdefg");
# "abcdefg\0\0\0\0\0\0\0"

$foo = pack("i9pl", gmtime);
# a real struct tm (on my system anyway)

$utmp_template = "Z8 Z8 Z16 L";
$utmp = pack($utmp_template, @utmp1);
# a struct utmp (BSDish)

@utmp2 = unpack($utmp_template, $utmp);
# "@utmp1" eq "@utmp2"

sub bintodec {
    unpack("N", pack("B32", substr("0" x 32 . shift, -32)));
}

$foo = pack('sx2l', 12, 34);
# short 12, two zero bytes padding, long 34
$bar = pack('s@4l', 12, 34);
# short 12, zero fill to position 4, long 34
# $foo eq $bar
$baz = pack('s.l', 12, 4, 34);
# short 12, zero fill to position 4, long 34

$foo = pack('nN', 42, 4711);
# pack big-endian 16- and 32-bit unsigned integers
$foo = pack('S>L>', 42, 4711);
# exactly the same
$foo = pack('s<l<', -42, 4711);
# pack little-endian 16- and 32-bit signed integers
$foo = pack('(sl)<', -42, 4711);
# exactly the same

Тот же шаблон, как правило, также может быть использован в unpack.

package NAMESPACE

package NAMESPACE VERSION

package NAMESPACE BLOCK

package NAMESPACE VERSION BLOCK

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

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

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

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

__PACKAGE__

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

pipe READHANDLE,WRITEHANDLE

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

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

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

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

pop ARRAY

pop

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

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

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

pos SCALAR

pos

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

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

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

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

print FILEHANDLE LIST

print FILEHANDLE

print LIST

print

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

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

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

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

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

printf FILEHANDLE FORMAT, LIST

printf FILEHANDLE

printf FORMAT, LIST

printf

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

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

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

prototype FUNCTION

prototype

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

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

push ARRAY,LIST

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

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

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

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

q/STRING/

qq/STRING/

qw/STRING/

qx/STRING/

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

qr/STRING/

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

quotemeta EXPR

quotemeta

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

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

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

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

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

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

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

Или:

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

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

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

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

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

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

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

В области действия use locale все символы Latin1, не являющиеся 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 обещает, что набор кодовых точек, обладающих этими двумя свойствами, никогда не изменится, поэтому то, что не экранируется в версии 5.16, никогда не потребует экранирования в будущих версиях Perl. (Не все кодовые точки, соответствующие Pattern_Syntax, на самом деле имеют назначенные символы; поэтому есть возможность роста, но они экранируются, независимо от назначения или отсутствия. Perl, конечно, никогда не будет использовать незанятую кодовую точку как фактический метасимвол.)

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

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

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

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

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

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

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

readline EXPR

readline

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

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

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

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

Если readline сталкивается с ошибкой операционной системы, $! будет установлено с соответствующим сообщением об ошибке. Это может быть полезно для проверки $!, когда вы читаете из файловых дескрипторов, которым не доверяете, таких как терминал или сокет. Следующий пример использует операторную форму 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: Message Passing" в 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 в English), либо числовым аргументом вида 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, это ведет себя как скалярное выражение с запятыми, вычисляя все, кроме последнего элемента, в пустом контексте и возвращая последний вычисленный элемент в скалярном контексте. Это редко то, что нужно.

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

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

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

seek($fh, 0, 1);

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

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

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

seekdir DIRHANDLE,POS

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

select FILEHANDLE

select

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

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

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

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

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

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

STDERR->autoflush(1);

(Перед версией Perl 5.14 необходимо use IO::Handle; явно это сделать.)

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

select RBITS,WBITS,EBITS,TIMEOUT

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

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

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

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

Обычный подход:

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

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

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

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

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

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

select(undef, undef, undef, 0.25);

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

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

На некоторых системах Unix, select(2) может сообщать о дескрипторе сокета как "готовом для чтения", даже если данные недоступны, и, следовательно, любой последующий read будет заблокирован. Этого можно избежать, если всегда использовать O_NONBLOCK для сокета. См. select(2) и fcntl(2) для получения дополнительной информации.

Стандартный модуль IO::Select предоставляет более удобный интерфейс к select, в основном потому, что он выполняет всю работу с битовыми масками за вас.

ПРЕДУПРЕЖДЕНИЕ: Не следует пытаться смешивать буферизированный ввод-вывод (например, read или readline) с select, за исключением случаев, разрешенных POSIX, и даже тогда только на системах POSIX. Вместо этого необходимо использовать sysread.

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

semctl ID,SEMNUM,CMD,ARG

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

use IPC::SysV;

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

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

semget KEY,NSEMS,FLAGS

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

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

semop KEY,OPSTRING

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

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

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

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

send SOCKET,MSG,FLAGS,TO

send SOCKET,MSG,FLAGS

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

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

setpgrp PID,PGRP

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

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

setpriority WHICH,WHO,PRIORITY

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

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

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

setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL

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

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

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

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

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

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

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

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

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

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

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

socket SOCKET,DOMAIN,TYPE,PROTOCOL

Открывает сокет указанного типа и прикрепляет его к файловому дескриптору SOCKET. DOMAIN, TYPE и PROTOCOL указаны так же, как и для одноимённого системного вызова. Вы должны use Socket сначала, чтобы получить надлежащие импортированные определения. См. примеры в "Sockets: 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

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

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

splice ARRAY,OFFSET,LENGTH,LIST

splice ARRAY,OFFSET,LENGTH

splice ARRAY,OFFSET

splice ARRAY

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

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

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

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

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

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

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

split /PATTERN/,EXPR,LIMIT

split /PATTERN/,EXPR

split /PATTERN/

split

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

sprintf FORMAT, LIST

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

Например:

# Format number with up to 8 leading zeroes
my $result = sprintf("%08d", $number);

# Round number to 3 digits after decimal point
my $rounded = sprintf("%.3f", $number);

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

В отличие от printf, sprintf не делает того, что вы, вероятно, имеете в виду, когда передаёте ему массив в качестве первого аргумента. Массив передаётся в скалярном контексте, и вместо использования 0-го элемента массива в качестве формата, Perl будет использовать количество элементов в массиве в качестве формата, что почти никогда не бывает полезно.

Perl's sprintf допускает следующие общеизвестные преобразования:

%%    a percent sign
%c    a character with the given number
%s    a string
%d    a signed integer, in decimal
%u    an unsigned integer, in decimal
%o    an unsigned integer, in octal
%x    an unsigned integer, in hexadecimal
%e    a floating-point number, in scientific notation
%f    a floating-point number, in fixed decimal notation
%g    a floating-point number, in %e or %f notation

Кроме того, Perl допускает следующие широко поддерживаемые преобразования:

%X    like %x, but using upper-case letters
%E    like %e, but using an upper-case "E"
%G    like %g, but with an upper-case "E" (if applicable)
%b    an unsigned integer, in binary
%B    like %b, but using an upper-case "B" with the # flag
%p    a pointer (outputs the Perl value's address in hexadecimal)
%n    special: *stores* the number of characters output so far
      into the next argument in the parameter list
%a    hexadecimal floating point
%A    like %a, but using upper-case letters

Наконец, для обратной совместимости (и мы действительно имеем в виду "обратную") Perl допускает эти ненужные, но широко поддерживаемые преобразования:

%i    a synonym for %d
%D    a synonym for %ld
%U    a synonym for %lu
%O    a synonym for %lo
%F    a synonym for %f

Обратите внимание, что количество цифр экспоненты в научной записи, производимой %e, %E, %g и %G для чисел с модулем экспоненты меньше 100, зависит от системы: это может быть три или меньше (с нулевым заполнением по мере необходимости). Другими словами, 1,23 умножить на десять в девяносто девятой степени может быть либо "1.23e99", либо "1.23e099". Точно так же для %a и %A: экспонента или шестнадцатеричные цифры могут перемещаться: особенно параметр конфигурации "long doubles" Perl может привести к неожиданным результатам.

Между % и буквой формата вы можете указать несколько дополнительных атрибутов, контролирующих интерпретацию формата. В порядке следования:

индекс параметра формата

Явный индекс параметра формата, например 2$. По умолчанию sprintf отформатирует следующий неиспользованный аргумент в списке, но это позволяет вам использовать аргументы в произвольном порядке:

printf '%2$d %1$d', 12, 34;      # prints "34 12"
printf '%3$d %d %1$d', 1, 2, 3;  # prints "3 1 1"

флаги

один или несколько из:

space   prefix non-negative number with a space
+       prefix non-negative number with a plus sign
-       left-justify within the field
0       use zeros, not spaces, to right-justify
#       ensure the leading "0" for any octal,
        prefix non-zero hexadecimal with "0x" or "0X",
        prefix non-zero binary with "0b" or "0B"

Например:

printf '<% d>',  12;   # prints "< 12>"
printf '<% d>',   0;   # prints "< 0>"
printf '<% d>', -12;   # prints "<-12>"
printf '<%+d>',  12;   # prints "<+12>"
printf '<%+d>',   0;   # prints "<+0>"
printf '<%+d>', -12;   # prints "<-12>"
printf '<%6s>',  12;   # prints "<    12>"
printf '<%-6s>', 12;   # prints "<12    >"
printf '<%06s>', 12;   # prints "<000012>"
printf '<%#o>',  12;   # prints "<014>"
printf '<%#x>',  12;   # prints "<0xc>"
printf '<%#X>',  12;   # prints "<0XC>"
printf '<%#b>',  12;   # prints "<0b1100>"
printf '<%#B>',  12;   # prints "<0B1100>"

Когда пробел и знак плюс даются одновременно в качестве флагов, пробел игнорируется.

printf '<%+ d>', 12;   # prints "<+12>"
printf '<% +d>', 12;   # prints "<+12>"

Когда флаг # и точность задаются в преобразовании %o, точность увеличивается, если это необходимо для ведущего "0".

printf '<%#.5o>', 012;      # prints "<00012>"
printf '<%#.5o>', 012345;   # prints "<012345>"
printf '<%#.0o>', 0;        # prints "<0>"

флаг вектора

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

printf "%vd", "AB\x{100}";           # prints "65.66.256"
printf "version is v%vd\n", $^V;     # Perl's version

Поставьте звездочку * перед v для переопределения строки, используемой для разделения чисел:

printf "address is %*vX\n", ":", $addr;   # IPv6 address
printf "bits are %0*v8b\n", " ", $bits;   # random bitstring

Вы также можете явно указать номер аргумента для использования в строке объединения, например *2$v; например:

printf '%*4$vX %*4$vX %*4$vX',       # 3 IPv6 addresses
        @addr[1..3], ":";

(минимальная) ширина

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

printf "<%s>", "a";       # prints "<a>"
printf "<%6s>", "a";      # prints "<     a>"
printf "<%*s>", 6, "a";   # prints "<     a>"
printf '<%*2$s>', "a", 6; # prints "<     a>"
printf "<%2s>", "long";   # prints "<long>" (does not truncate)

Если ширина поля, полученная с помощью *, отрицательная, она имеет тот же эффект, что и флаг -: выравнивание влево.

точность или максимальная ширина

Вы можете указать точность (для числовых преобразований) или максимальную ширину (для строковых преобразований), указав . и затем число. Для чисел с плавающей точкой, кроме g и G, это указывает, сколько знаков справа от десятичной точки отобразить (по умолчанию 6). Например:

# these examples are subject to system-specific variation
printf '<%f>', 1;    # prints "<1.000000>"
printf '<%.1f>', 1;  # prints "<1.0>"
printf '<%.0f>', 1;  # prints "<1>"
printf '<%e>', 10;   # prints "<1.000000e+01>"
printf '<%.1e>', 10; # prints "<1.0e+01>"

Для "g" и "G" это указывает максимальное количество значащих цифр для отображения; например:

# These examples are subject to system-specific variation.
printf '<%g>', 1;        # prints "<1>"
printf '<%.10g>', 1;     # prints "<1>"
printf '<%g>', 100;      # prints "<100>"
printf '<%.1g>', 100;    # prints "<1e+02>"
printf '<%.2g>', 100.01; # prints "<1e+02>"
printf '<%.5g>', 100.01; # prints "<100.01>"
printf '<%.4g>', 100.01; # prints "<100>"
printf '<%.1g>', 0.0111; # prints "<0.01>"
printf '<%.2g>', 0.0111; # prints "<0.011>"
printf '<%.3g>', 0.0111; # prints "<0.0111>"

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

printf '<%.6d>', 1;      # prints "<000001>"
printf '<%+.6d>', 1;     # prints "<+000001>"
printf '<%-10.6d>', 1;   # prints "<000001    >"
printf '<%10.6d>', 1;    # prints "<    000001>"
printf '<%010.6d>', 1;   # prints "<    000001>"
printf '<%+10.6d>', 1;   # prints "<   +000001>"

printf '<%.6x>', 1;      # prints "<000001>"
printf '<%#.6x>', 1;     # prints "<0x000001>"
printf '<%-10.6x>', 1;   # prints "<000001    >"
printf '<%10.6x>', 1;    # prints "<    000001>"
printf '<%010.6x>', 1;   # prints "<    000001>"
printf '<%#10.6x>', 1;   # prints "<  0x000001>"

Для строковых преобразований указание точности усекает строку, чтобы она соответствовала указанной ширине:

printf '<%.5s>', "truncated";   # prints "<trunc>"
printf '<%10.5s>', "truncated"; # prints "<     trunc>"

Вы также можете получить точность из следующего аргумента, используя .*, или из указанного аргумента (например, с помощью .*2$):

printf '<%.6x>', 1;       # prints "<000001>"
printf '<%.*x>', 6, 1;    # prints "<000001>"

printf '<%.*2$x>', 1, 6;  # prints "<000001>"

printf '<%6.*2$x>', 1, 4; # prints "<  0001>"

Если точность, полученная с помощью *, отрицательная, это считается отсутствием точности.

printf '<%.*s>',  7, "string";   # prints "<string>"
printf '<%.*s>',  3, "string";   # prints "<str>"
printf '<%.*s>',  0, "string";   # prints "<>"
printf '<%.*s>', -1, "string";   # prints "<string>"

printf '<%.*d>',  1, 0;   # prints "<0>"
printf '<%.*d>',  0, 0;   # prints "<>"
printf '<%.*d>', -1, 0;   # prints "<0>"

размер

Для числовых преобразований вы можете указать размер для интерпретации числа, используя l, h, V, q, L, или ll. Для целочисленных преобразований (d u o x X b i D U O) числа обычно предполагаются размером по умолчанию для целых чисел на вашей платформе (обычно 32 или 64 бита), но вы можете переопределить это, используя вместо этого один из стандартных типов C, поддерживаемых компилятором, используемым для сборки Perl:

hh          interpret integer as C type "char" or "unsigned
            char" on Perl 5.14 or later
h           interpret integer as C type "short" or
            "unsigned short"
j           interpret integer as C type "intmax_t" on Perl
            5.14 or later; and prior to Perl 5.30, only with
            a C99 compiler (unportable)
l           interpret integer as C type "long" or
            "unsigned long"
q, L, or ll interpret integer as C type "long long",
            "unsigned long long", or "quad" (typically
            64-bit integers)
t           interpret integer as C type "ptrdiff_t" on Perl
            5.14 or later
z           interpret integer as C types "size_t" or
            "ssize_t" on Perl 5.14 or later

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

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

use warnings FATAL => "printf";

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

use 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 double и double — одно и то же:

use Config;
($Config{doublesize} == $Config{longdblsize}) &&
        print "doubles are long doubles\n";

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

порядок аргументов

Обычно sprintf берет следующий неиспользованный аргумент в качестве значения для форматирования для каждого указания формата. Если указание формата использует * для требования дополнительных аргументов, они потребляются из списка аргументов в порядке их появления в указании формата *до* значения для форматирования. Где аргумент задаётся явным индексом, это не влияет на нормальный порядок аргументов, даже если явно указанный индекс был бы следующим аргументом.

Например:

printf "<%*.*s>", $a, $b, $c;

использует $a для ширины, $b для точности и $c как значение для форматирования; в то время как:

printf '<%*1$.*s>', $a, $b;

использовало бы $a для ширины и точности, и $b в качестве значения для форматирования.

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

printf "%2\$d %d\n",      12, 34;     # will print "34 12\n"
printf "%2\$d %d %d\n",   12, 34;     # will print "34 12 34\n"
printf "%3\$d %d %d\n",   12, 34, 56; # will print "56 12 34\n"
printf "%2\$*3\$d %d\n",  12, 34,  3; # will print " 34 12\n"
printf "%*1\$.*f\n",       4,  5, 10; # will print "5.0000\n"

Если use locale (включая use locale ':not_characters') активна и POSIX::setlocale была вызвана, символ, используемый для разделителя десятичных знаков в отформатированных числах с плавающей точкой, зависит от локали LC_NUMERIC. См. perllocale и POSIX.

sqrt EXPR

sqrt

Возвращает положительный квадратный корень из EXPR. Если EXPR опущено, используется $_. Работает только для неотрицательных операндов, если вы не загрузили модуль Math::Complex.

use Math::Complex;
print sqrt(-4);    # prints 2i

srand EXPR

srand

Устанавливает и возвращает начальное значение для генерации случайных чисел для оператора rand.

Функция предназначена для задания "семени" для функции rand, чтобы rand генерировал разные последовательности при каждом запуске программы. При вызове с параметром srand использует этот параметр в качестве семени; в противном случае (полу)случайно выбирает семя. В любом случае, начиная с Perl 5.14, она возвращает семя. Чтобы указать, что ваш код будет работать только с Perl недавних версий:

use 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 завершается неудачно. Обычно используется следующим образом:

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

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

my $mode = (stat($filename))[2];
printf "Permissions are %04o\n", $mode & 07777;

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

Модуль File::stat предоставляет удобный механизм доступа по имени:

use File::stat;
my $sb = stat($filename);
printf "File is %s, size is %s, perm %04o, mtime %s\n",
       $filename, $sb->size, $sb->mode & 07777,
       scalar localtime $sb->mtime;

Вы можете импортировать символические константы режима (S_IF*) и функции (S_IS*) из модуля Fcntl:

use Fcntl ':mode';

my $mode = (stat($filename))[2];

my $user_rwx      = ($mode & S_IRWXU) >> 6;
my $group_read    = ($mode & S_IRGRP) >> 3;
my $other_execute =  $mode & S_IXOTH;

printf "Permissions are %04o\n", S_IMODE($mode), "\n";

my $is_setuid     =  $mode & S_ISUID;
my $is_directory  =  S_ISDIR($mode);

Вы могли бы написать последние две, используя операторы -u и -d. Общие доступные константы S_IF*:

# Permissions: read, write, execute, for user, group, others.

S_IRWXU S_IRUSR S_IWUSR S_IXUSR
S_IRWXG S_IRGRP S_IWGRP S_IXGRP
S_IRWXO S_IROTH S_IWOTH S_IXOTH

# Setuid/Setgid/Stickiness/SaveText.
# Note that the exact meaning of these is system-dependent.

S_ISUID S_ISGID S_ISVTX S_ISTXT

# File types.  Not all are necessarily available on
# your system.

S_IFREG S_IFDIR S_IFLNK S_IFBLK S_IFCHR
S_IFIFO S_IFSOCK S_IFWHT S_ENFMT

# The following are compatibility aliases for S_IRUSR,
# S_IWUSR, and S_IXUSR.

S_IREAD S_IWRITE S_IEXEC

и функции S_IF*

S_IMODE($mode)    the part of $mode containing the permission
                  bits and the setuid/setgid/sticky bits

S_IFMT($mode)     the part of $mode containing the file type
                  which can be bit-anded with (for example)
                  S_IFREG or with the following functions

# The operators -f, -d, -l, -b, -c, -p, and -S.

S_ISREG($mode) S_ISDIR($mode) S_ISLNK($mode)
S_ISBLK($mode) S_ISCHR($mode) S_ISFIFO($mode) S_ISSOCK($mode)

# No direct -X operator counterpart, but for the first one
# the -g operator is often equivalent.  The ENFMT stands for
# record flocking enforcement, a platform-dependent feature.

S_ISENFMT($mode) S_ISWHT($mode)

См. документацию вашей системы chmod(2) и stat(2) для получения более подробной информации о константах S_*. Чтобы получить информацию о статусе символической ссылки, а не целевого файла за ссылкой, используйте функцию lstat.

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

state VARLIST

state TYPE VARLIST

state VARLIST : ATTRS

state TYPE VARLIST : ATTRS

state объявляет лексическую переменную, как и my. Однако эти переменные никогда не будут повторно инициализированы, в отличие от лексических переменных, которые повторно инициализируются каждый раз при входе в их содержащий блок. Подробности см. в разделе "Постоянные приватные переменные" в perlsub.

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

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

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

study SCALAR

study

На данный момент study ничего не делает. Это может измениться в будущем.

Перед Perl версии 5.16 она создавала инвертированный индекс всех символов, которые встречались в заданном SCALAR (или $_, если не указано). При сопоставлении шаблона наименее часто встречающийся символ из шаблона ищутся в этом индексе. Редкость основана на некоторых статических частотных таблицах, построенных из некоторых C-программ и английского текста.

sub NAME BLOCK

sub NAME (PROTO) BLOCK

sub NAME : ATTRS BLOCK

sub NAME (PROTO) : ATTRS BLOCK

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

См. perlsub и perlref для получения подробностей о подпрограммах и ссылках; см. attributes и Attribute::Handlers для получения дополнительной информации об атрибутах.

__SUB__

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

Поведение __SUB__ внутри блока кода регулярного выражения (например, /(?{...})/) может измениться.

Этот токен доступен только в use v5.16 или функции "current_sub". См. feature.

substr EXPR,OFFSET,LENGTH,REPLACEMENT

substr EXPR,OFFSET,LENGTH

substr EXPR,OFFSET

Извлекает подстроку из EXPR и возвращает её. Первый символ имеет смещение ноль. Если OFFSET отрицательный, начинает отсчёт за столько символов от конца строки. Если LENGTH опущен, возвращает всю строку до её конца. Если LENGTH отрицательный, оставляет столько символов от конца строки.

my $s = "The black cat climbed the green tree";
my $color  = substr $s, 4, 5;      # black
my $middle = substr $s, 4, -11;    # black cat climbed the
my $end    = substr $s, 14;        # climbed the green tree
my $tail   = substr $s, -4;        # tree
my $z      = substr $s, -4, 2;     # tr

Вы можете использовать функцию substr в качестве левостороннего операнда (lvalue), в этом случае EXPR также должен быть левосторонним операндом. Если вы присваиваете значение короче LENGTH, длина строки уменьшится, а если длиннее — увеличится, чтобы вместить его. Для сохранения длины строки, возможно, придётся дополнять или обрезать значение с помощью sprintf.

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

my $name = 'fred';
substr($name, 4) = 'dy';         # $name is now 'freddy'
my $null = substr $name, 6, 2;   # returns "" (no warning)
my $oops = substr $name, 7;      # returns undef, with warning
substr($name, 7) = 'gap';        # raises an exception

Альтернативой использованию substr в качестве левостороннего операнда (lvalue) является указание строки замены в качестве четвёртого аргумента. Это позволяет заменить части EXPR и вернуть то, что было раньше, за одну операцию, подобно тому, как это можно сделать с splice.

my $s = "The black cat climbed the green tree";
my $z = substr $s, 14, 7, "jumped from";    # climbed
# $s is now "The black cat jumped from the green tree"

Обратите внимание, что левосторонний операнд (lvalue), возвращаемый трёхаргументной версией substr, действует как «волшебная пуля»; каждый раз при присваивании он запоминает, какая часть исходной строки изменяется; например:

my $x = '1234';
for (substr($x,1,2)) {
    $_ = 'a';   print $x,"\n";    # prints 1a4
    $_ = 'xyz'; print $x,"\n";    # prints 1xyz4
    $x = '56789';
    $_ = 'pq';  print $x,"\n";    # prints 5pq9
}

При использовании отрицательных смещений он запоминает своё положение с конца строки при изменении целевой строки:

my $x = '1234';
for (substr($x, -3, 2)) {
    $_ = 'a';   print $x,"\n";    # prints 1a4, as above
    $x = 'abcdefg';
    print $_,"\n";                # prints f
}

До версии Perl 5.10 результат многократного использования левостороннего операнда (lvalue) был неопределённым. До версии 5.16 результат с отрицательными смещениями был неопределённым.

symlink OLDFILE,NEWFILE

Создаёт новое имя файла, символически связанное со старым именем файла. Возвращает 1 при успехе, 0 в противном случае. На системах, не поддерживающих символические ссылки, вызывает исключение. Для проверки этого используйте eval:

my $symlink_exists = eval { symlink("",""); 1 };

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

syscall NUMBER, LIST

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

См. perlopentut для более подробного объяснения открытия файлов.

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

sysread FILEHANDLE,SCALAR,LENGTH,OFFSET

sysread FILEHANDLE,SCALAR,LENGTH

Попытка прочитать LENGTH байт данных в переменную SCALAR из указанного FILEHANDLE, используя read(2). Она обходит все слои 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 возвращается в виде строки "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`" in 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`" in perlop и exec для получения подробностей.

Так как system выполняет fork и wait, она может повлиять на обработчик SIGCHLD. См. perlipc для получения подробностей.

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

syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET

syswrite FILEHANDLE,SCALAR,LENGTH

syswrite FILEHANDLE,SCALAR

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

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

time

Возвращает количество не високосных секунд с момента, который система считает эпохой, подходящее для передачи в gmtime и localtime. На большинстве систем эпоха — 00:00:00 по Гринвичу, 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 в строках с двойными кавычками. Она не пытается перевести начальные буквы в заглавные (titlecase). См. 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 или даже особенно антиобщественный mask 077. Программы редко, если вообще когда-либо, должны принимать решения о политике, которые лучше оставлять пользователям. Исключением являются файлы, которые должны оставаться частными: почтовые файлы, файлы cookie веб-браузера, файлы .rhosts и так далее.

Если umask(2) не реализован на вашей системе и вы пытаетесь ограничить доступ для себя (т. е., (EXPR & 0700) > 0), вызовет исключение. Если umask(2) не реализован и вы не пытаетесь ограничить доступ для себя, возвращает undef.

Помните, что umask — это число, обычно задаваемое в восьмеричной системе счисления; это не строка восьмеричных цифр. См. также oct, если у вас есть только строка.

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

undef EXPR

undef

Устанавливает значение EXPR в неопределённое, EXPR должен быть lvalue. Используется только со скалярными значениями, массивами (используя @), хэшами (используя %), подпрограммами (используя &) или typeglob (используя *). Оператор undef $hash{$key} вероятно не даст ожидаемого результата для большинства предопределённых переменных или значений списков DBM, поэтому не используйте его; см. delete. Всегда возвращает неопределённое значение. Вы можете опустить EXPR, в этом случае ничего не будет неопределённым, но вы всё равно получите неопределённое значение, которое можно, например, вернуть из подпрограммы, присвоить переменной или передать в качестве параметра. Примеры:

undef $foo;
undef $bar{'blurfl'};      # Compare to: delete $bar{'blurfl'};
undef @ary;
undef %hash;
undef &mysub;
undef *xyz;       # destroys $xyz, @xyz, %xyz, &xyz, etc.
return (wantarray ? (undef, $errmsg) : undef) if $they_blew_it;
select undef, undef, undef, 0.25;
my ($x, $y, undef, $z) = foo();    # Ignore third value returned

Обратите внимание, что это унарный оператор, а не оператор списка.

unlink LIST

unlink

Удаляет список файлов. При успехе возвращает количество успешно удалённых файлов. При ошибке возвращает ложь и устанавливает $! (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 опущен, unpacks строку $_. См. perlpacktut для введения в эту функцию.

Строка разбивается на части, описанные в TEMPLATE. Каждая часть преобразуется в отдельное значение. Как правило, либо строка является результатом pack, либо символы строки представляют собой структуру C.

TEMPLATE имеет тот же формат, что и в функции pack. Вот подпрограмма, которая выполняет подстрочную операцию:

sub substr {
    my ($what, $where, $howmuch) = @_;
    unpack("x$where a$howmuch", $what);
}

и затем есть

sub ordinal { unpack("W",$_[0]); } # same as ord()

В дополнение к полям, разрешённым в pack, вы можете добавить префикс <число> к полю, чтобы указать, что вы хотите вычислить контрольную сумму из <число> бит элементов вместо самих элементов. По умолчанию контрольная сумма 16-битовая. Контрольная сумма вычисляется путём суммирования числовых значений расширенных значений (для строковых полей берётся сумма символов; для битовых полей — сумма нулей и единиц).

Например, следующее вычисляет то же число, что и программа System V sum:

my $checksum = do {
    local $/;  # slurp!
    unpack("%32W*", readline) % 65535;
};

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

my $setbits = unpack("%32b*", $selectmask);

Форматы p и P следует использовать с осторожностью. Поскольку у Perl нет способа проверить, соответствует ли переданное значение unpack допустимому месту в памяти, передача значения указателя, не известного как допустимое, вероятно, приведёт к катастрофическим последствиям.

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

См. pack для получения дополнительных примеров и примечаний.

unshift ARRAY,LIST

Делает обратное shift. Или обратное push, в зависимости от того, как вы на это смотрите. Добавляет список в начало массива и возвращает новое количество элементов в массиве.

unshift(@ARGV, '-e') unless $ARGV[0] =~ /^-/;

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

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

untie VARIABLE

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

use Module VERSION LIST

use Module VERSION

use Module LIST

use Module

use VERSION

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

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

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

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

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

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

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

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

BEGIN принудительно выполняет require и import во время компиляции. require гарантирует, что модуль загружен в память, если он ещё не был загружен. import не является встроенной функцией; это просто обычный статический вызов метода в пакет Module для указания модулю импортировать список функций обратно в текущий пакет. Модуль может реализовывать свой метод import любым удобным способом, хотя большинство модулей выбирают способ получения метода import посредством наследования от класса Exporter, определённого в модуле Exporter. См. Exporter. Если метод import не найден, вызов пропускается, даже если существует метод AUTOLOAD.

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

use Module ();

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

BEGIN { require Module }

Если аргумент VERSION присутствует между Модулем и СПИСКОМ, то use вызовет метод VERSION в классе Модуль с заданной версией в качестве аргумента:

use Module 12.34;

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

BEGIN { require Module; Module->VERSION(12.34) }

Метод VERSION по умолчанию, унаследованный от класса UNIVERSAL, генерирует ошибку, если заданная версия больше значения переменной $Module::VERSION

Аргумент VERSION не может быть произвольным выражением. Он считается аргументом VERSION только в том случае, если это литерал номера версии, начинающийся либо с цифры, либо с v и цифры. Всё, что не похоже на литерал версии, будет интерпретировано как начало списка. Тем не менее, многие попытки использовать произвольное выражение в качестве аргумента VERSION, похоже, работают, потому что метод import Exporter'а обрабатывает числовые аргументы особым образом, выполняя проверки версий, а не рассматривая их как импортируемые объекты.

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

no integer;
no strict 'refs';
no warnings;

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

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

utime СПИСОК

Изменяет время доступа и изменения каждого файла в списке файлов. Первые два элемента списка должны быть числовыми значениями времени доступа и изменения соответственно. Возвращает количество файлов, успешно изменённых. Время изменения inode каждого файла устанавливается на текущее время. Например, этот код имеет тот же эффект, что и команда Unix touch(1), когда файлы уже существуют и принадлежат пользователю, выполняющему программу:

#!/usr/bin/perl
my $atime = my $mtime = time;
utime $atime, $mtime, @ARGV;

Начиная с Perl 5.8.0, если первые два элемента списка — undef, вызывается системный вызов utime(2) вашей библиотеки C с нулевым вторым аргументом. На большинстве систем это установит время доступа и изменения файла на текущее время (т.е., эквивалентно примеру выше) и будет работать даже с файлами, которые вам не принадлежат, при наличии прав на запись:

for my $file (@ARGV) {
    utime(undef, undef, $file)
        || warn "Couldn't touch $file: $!";
}

Под NFS это использует время сервера NFS, а не время локальной машины. Если есть проблема синхронизации времени, у сервера NFS и локальной машины будут разные времена. Команда Unix touch(1) фактически обычно использует этот формат вместо показанного в первом примере.

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

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

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

values HASH

values ARRAY

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

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

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

Помимо сброса итератора, values @array в контексте списка эквивалентно просто @array. (Мы рекомендуем использовать контекст пустоты keys @array для этого, но сочли, что удаление values @array потребует больше документации, чем его оставление.)

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

for (values %hash)      { s/foo/bar/g }  # modifies %hash values
for (@hash{keys %hash}) { s/foo/bar/g }  # same

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

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

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

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

vec EXPR,OFFSET,BITS

Обрабатывает строку в EXPR как битовую последовательность, состоящую из элементов шириной BITS, и возвращает значение элемента, заданного OFFSET, как целое без знака. Таким образом, BITS определяет количество битов, резервируемых для каждого элемента в битовой последовательности. Это должно быть степень двойки от 1 до 32 (или 64, если ваша платформа её поддерживает).

Если BITS равно 8, «элементы» совпадают с байтами входной строки.

Если BITS равно 16 или более, байты входной строки группируются в блоки размером BITS/8, и каждый блок преобразуется в число, как с pack/unpack с форматами с большим эндианностью n/N (и аналогично для BITS==64). Подробности см. в pack.

Если bits равно 4 или меньше, строка разбивается на байты, затем биты каждого байта разбиваются на группы 8/BITS. Биты байта нумеруются способом, похожим на little-endian, как в 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80. Например, разбивка одного входного байта chr(0x36) на две группы даёт список (0x6, 0x3); разбивка на 4 группы даёт (0x2, 0x1, 0x3, 0x0).

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

vec($image, $max_x * $x + $y, 8) = 3;

Если выбранный элемент находится за пределами строки, возвращается значение 0. Если элементу вне конца строки присваивается значение, Perl сначала расширит строку нужным количеством нулевых байтов. Ошибка возникает, если попытка присвоить значение элементу перед началом строки (то есть отрицательный OFFSET).

Если строка закодирована как UTF-8 внутри (и, следовательно, установлен флаг UTF8), vec пытается преобразовать её в внутреннее представление с одним байтом на символ. Однако, если строка содержит символы со значениями 256 или выше, произойдёт критическая ошибка.

Строки, созданные с помощью vec, также можно обрабатывать с помощью логических операторов |, &, ^, и ~. Эти операторы предположат, что требуется операция над битовой последовательностью, когда оба операнда — строки. Подробности см. в разделе «Bitwise String Operators» в perlop.

Следующий код создаст строку ASCII, говорящую 'PerlPerlPerl'. Комментарии показывают строку после каждого шага. Обратите внимание, что этот код работает одинаково на машинах с big-endian или little-endian архитектурой.

my $foo = '';
vec($foo,  0, 32) = 0x5065726C; # 'Perl'

# $foo eq "Perl" eq "\x50\x65\x72\x6C", 32 bits
print vec($foo, 0, 8);  # prints 80 == 0x50 == ord('P')

vec($foo,  2, 16) = 0x5065; # 'PerlPe'
vec($foo,  3, 16) = 0x726C; # 'PerlPerl'
vec($foo,  8,  8) = 0x50;   # 'PerlPerlP'
vec($foo,  9,  8) = 0x65;   # 'PerlPerlPe'
vec($foo, 20,  4) = 2;      # 'PerlPerlPe'   . "\x02"
vec($foo, 21,  4) = 7;      # 'PerlPerlPer'
                               # 'r' is "\x72"
vec($foo, 45,  2) = 3;      # 'PerlPerlPer'  . "\x0c"
vec($foo, 93,  1) = 1;      # 'PerlPerlPer'  . "\x2c"
vec($foo, 94,  1) = 1;      # 'PerlPerlPerl'
                               # 'l' is "\x6c"

Чтобы преобразовать битовую последовательность в строку или список нулей и единиц, используйте:

my $bits = unpack("b*", $vector);
my @bits = split(//, unpack("b*", $vector));

Если вам известна точная длина в битах, она может быть использована вместо *.

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

#!/usr/bin/perl -wl

print <<'EOT';
                                  0         1         2         3
                   unpack("V",$_) 01234567890123456789012345678901
------------------------------------------------------------------
EOT

for $w (0..3) {
    $width = 2**$w;
    for ($shift=0; $shift < $width; ++$shift) {
        for ($off=0; $off < 32/$width; ++$off) {
            $str = pack("B*", "0"x32);
            $bits = (1<<$shift);
            vec($str, $off, $width) = $bits;
            $res = unpack("b*",$str);
            $val = unpack("V", $str);
            write;
        }
    }
}

format STDOUT =
vec($_,@#,@#) = @<< == @######### @>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
$off, $width, $bits, $val, $res
.
__END__

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

                                  0         1         2         3
                   unpack("V",$_) 01234567890123456789012345678901
------------------------------------------------------------------
vec($_, 0, 1) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 1) = 1   ==          2 01000000000000000000000000000000
vec($_, 2, 1) = 1   ==          4 00100000000000000000000000000000
vec($_, 3, 1) = 1   ==          8 00010000000000000000000000000000
vec($_, 4, 1) = 1   ==         16 00001000000000000000000000000000
vec($_, 5, 1) = 1   ==         32 00000100000000000000000000000000
vec($_, 6, 1) = 1   ==         64 00000010000000000000000000000000
vec($_, 7, 1) = 1   ==        128 00000001000000000000000000000000
vec($_, 8, 1) = 1   ==        256 00000000100000000000000000000000
vec($_, 9, 1) = 1   ==        512 00000000010000000000000000000000
vec($_,10, 1) = 1   ==       1024 00000000001000000000000000000000
vec($_,11, 1) = 1   ==       2048 00000000000100000000000000000000
vec($_,12, 1) = 1   ==       4096 00000000000010000000000000000000
vec($_,13, 1) = 1   ==       8192 00000000000001000000000000000000
vec($_,14, 1) = 1   ==      16384 00000000000000100000000000000000
vec($_,15, 1) = 1   ==      32768 00000000000000010000000000000000
vec($_,16, 1) = 1   ==      65536 00000000000000001000000000000000
vec($_,17, 1) = 1   ==     131072 00000000000000000100000000000000
vec($_,18, 1) = 1   ==     262144 00000000000000000010000000000000
vec($_,19, 1) = 1   ==     524288 00000000000000000001000000000000
vec($_,20, 1) = 1   ==    1048576 00000000000000000000100000000000
vec($_,21, 1) = 1   ==    2097152 00000000000000000000010000000000
vec($_,22, 1) = 1   ==    4194304 00000000000000000000001000000000
vec($_,23, 1) = 1   ==    8388608 00000000000000000000000100000000
vec($_,24, 1) = 1   ==   16777216 00000000000000000000000010000000
vec($_,25, 1) = 1   ==   33554432 00000000000000000000000001000000
vec($_,26, 1) = 1   ==   67108864 00000000000000000000000000100000
vec($_,27, 1) = 1   ==  134217728 00000000000000000000000000010000
vec($_,28, 1) = 1   ==  268435456 00000000000000000000000000001000
vec($_,29, 1) = 1   ==  536870912 00000000000000000000000000000100
vec($_,30, 1) = 1   == 1073741824 00000000000000000000000000000010
vec($_,31, 1) = 1   == 2147483648 00000000000000000000000000000001
vec($_, 0, 2) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 2) = 1   ==          4 00100000000000000000000000000000
vec($_, 2, 2) = 1   ==         16 00001000000000000000000000000000
vec($_, 3, 2) = 1   ==         64 00000010000000000000000000000000
vec($_, 4, 2) = 1   ==        256 00000000100000000000000000000000
vec($_, 5, 2) = 1   ==       1024 00000000001000000000000000000000
vec($_, 6, 2) = 1   ==       4096 00000000000010000000000000000000
vec($_, 7, 2) = 1   ==      16384 00000000000000100000000000000000
vec($_, 8, 2) = 1   ==      65536 00000000000000001000000000000000
vec($_, 9, 2) = 1   ==     262144 00000000000000000010000000000000
vec($_,10, 2) = 1   ==    1048576 00000000000000000000100000000000
vec($_,11, 2) = 1   ==    4194304 00000000000000000000001000000000
vec($_,12, 2) = 1   ==   16777216 00000000000000000000000010000000
vec($_,13, 2) = 1   ==   67108864 00000000000000000000000000100000
vec($_,14, 2) = 1   ==  268435456 00000000000000000000000000001000
vec($_,15, 2) = 1   == 1073741824 00000000000000000000000000000010
vec($_, 0, 2) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 2) = 2   ==          8 00010000000000000000000000000000
vec($_, 2, 2) = 2   ==         32 00000100000000000000000000000000
vec($_, 3, 2) = 2   ==        128 00000001000000000000000000000000
vec($_, 4, 2) = 2   ==        512 00000000010000000000000000000000
vec($_, 5, 2) = 2   ==       2048 00000000000100000000000000000000
vec($_, 6, 2) = 2   ==       8192 00000000000001000000000000000000
vec($_, 7, 2) = 2   ==      32768 00000000000000010000000000000000
vec($_, 8, 2) = 2   ==     131072 00000000000000000100000000000000
vec($_, 9, 2) = 2   ==     524288 00000000000000000001000000000000
vec($_,10, 2) = 2   ==    2097152 00000000000000000000010000000000
vec($_,11, 2) = 2   ==    8388608 00000000000000000000000100000000
vec($_,12, 2) = 2   ==   33554432 00000000000000000000000001000000
vec($_,13, 2) = 2   ==  134217728 00000000000000000000000000010000
vec($_,14, 2) = 2   ==  536870912 00000000000000000000000000000100
vec($_,15, 2) = 2   == 2147483648 00000000000000000000000000000001
vec($_, 0, 4) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 4) = 1   ==         16 00001000000000000000000000000000
vec($_, 2, 4) = 1   ==        256 00000000100000000000000000000000
vec($_, 3, 4) = 1   ==       4096 00000000000010000000000000000000
vec($_, 4, 4) = 1   ==      65536 00000000000000001000000000000000
vec($_, 5, 4) = 1   ==    1048576 00000000000000000000100000000000
vec($_, 6, 4) = 1   ==   16777216 00000000000000000000000010000000
vec($_, 7, 4) = 1   ==  268435456 00000000000000000000000000001000
vec($_, 0, 4) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 4) = 2   ==         32 00000100000000000000000000000000
vec($_, 2, 4) = 2   ==        512 00000000010000000000000000000000
vec($_, 3, 4) = 2   ==       8192 00000000000001000000000000000000
vec($_, 4, 4) = 2   ==     131072 00000000000000000100000000000000
vec($_, 5, 4) = 2   ==    2097152 00000000000000000000010000000000
vec($_, 6, 4) = 2   ==   33554432 00000000000000000000000001000000
vec($_, 7, 4) = 2   ==  536870912 00000000000000000000000000000100
vec($_, 0, 4) = 4   ==          4 00100000000000000000000000000000
vec($_, 1, 4) = 4   ==         64 00000010000000000000000000000000
vec($_, 2, 4) = 4   ==       1024 00000000001000000000000000000000
vec($_, 3, 4) = 4   ==      16384 00000000000000100000000000000000
vec($_, 4, 4) = 4   ==     262144 00000000000000000010000000000000
vec($_, 5, 4) = 4   ==    4194304 00000000000000000000001000000000
vec($_, 6, 4) = 4   ==   67108864 00000000000000000000000000100000
vec($_, 7, 4) = 4   == 1073741824 00000000000000000000000000000010
vec($_, 0, 4) = 8   ==          8 00010000000000000000000000000000
vec($_, 1, 4) = 8   ==        128 00000001000000000000000000000000
vec($_, 2, 4) = 8   ==       2048 00000000000100000000000000000000
vec($_, 3, 4) = 8   ==      32768 00000000000000010000000000000000
vec($_, 4, 4) = 8   ==     524288 00000000000000000001000000000000
vec($_, 5, 4) = 8   ==    8388608 00000000000000000000000100000000
vec($_, 6, 4) = 8   ==  134217728 00000000000000000000000000010000
vec($_, 7, 4) = 8   == 2147483648 00000000000000000000000000000001
vec($_, 0, 8) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 8) = 1   ==        256 00000000100000000000000000000000
vec($_, 2, 8) = 1   ==      65536 00000000000000001000000000000000
vec($_, 3, 8) = 1   ==   16777216 00000000000000000000000010000000
vec($_, 0, 8) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 8) = 2   ==        512 00000000010000000000000000000000
vec($_, 2, 8) = 2   ==     131072 00000000000000000100000000000000
vec($_, 3, 8) = 2   ==   33554432 00000000000000000000000001000000
vec($_, 0, 8) = 4   ==          4 00100000000000000000000000000000
vec($_, 1, 8) = 4   ==       1024 00000000001000000000000000000000
vec($_, 2, 8) = 4   ==     262144 00000000000000000010000000000000
vec($_, 3, 8) = 4   ==   67108864 00000000000000000000000000100000
vec($_, 0, 8) = 8   ==          8 00010000000000000000000000000000
vec($_, 1, 8) = 8   ==       2048 00000000000100000000000000000000
vec($_, 2, 8) = 8   ==     524288 00000000000000000001000000000000
vec($_, 3, 8) = 8   ==  134217728 00000000000000000000000000010000
vec($_, 0, 8) = 16  ==         16 00001000000000000000000000000000
vec($_, 1, 8) = 16  ==       4096 00000000000010000000000000000000
vec($_, 2, 8) = 16  ==    1048576 00000000000000000000100000000000
vec($_, 3, 8) = 16  ==  268435456 00000000000000000000000000001000
vec($_, 0, 8) = 32  ==         32 00000100000000000000000000000000
vec($_, 1, 8) = 32  ==       8192 00000000000001000000000000000000
vec($_, 2, 8) = 32  ==    2097152 00000000000000000000010000000000
vec($_, 3, 8) = 32  ==  536870912 00000000000000000000000000000100
vec($_, 0, 8) = 64  ==         64 00000010000000000000000000000000
vec($_, 1, 8) = 64  ==      16384 00000000000000100000000000000000
vec($_, 2, 8) = 64  ==    4194304 00000000000000000000001000000000
vec($_, 3, 8) = 64  == 1073741824 00000000000000000000000000000010
vec($_, 0, 8) = 128 ==        128 00000001000000000000000000000000
vec($_, 1, 8) = 128 ==      32768 00000000000000010000000000000000
vec($_, 2, 8) = 128 ==    8388608 00000000000000000000000100000000
vec($_, 3, 8) = 128 == 2147483648 00000000000000000000000000000001

wait

Ведёт себя как wait(2) на вашей системе: ожидает завершения дочернего процесса и возвращает pid завершившегося процесса или -1 в случае отсутствия дочерних процессов. Статус возвращается в $? и ${^CHILD_ERROR_NATIVE}. Обратите внимание, что возвращаемое значение -1 может означать, что дочерние процессы собираются автоматически, как описано в perlipc.

Если вы используете wait в своём обработчике для $SIG{CHLD}, это может случайно привести к ожиданию дочернего процесса, созданного функцией qx или system. Подробности см. в perlipc.

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

waitpid PID,FLAGS

Ожидает завершения определённого дочернего процесса и возвращает pid завершившегося процесса, или -1 в случае отсутствия такого дочернего процесса. Неблокирующее ожидание (с WNOHANG в FLAGS) может вернуть 0, если существуют дочерние процессы, соответствующие PID, но ни один из них не завершился. Статус возвращается в $? и ${^CHILD_ERROR_NATIVE}.

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

Если вы используете

use POSIX ":sys_wait_h";

my $kid;
do {
    $kid = waitpid(-1, WNOHANG);
} while $kid > 0;

или

1 while waitpid(-1, WNOHANG) > 0;

то вы можете выполнить неблокирующее ожидание всех ожидающих процессов-сирот (см. "WAIT" в POSIX). Неблокирующее ожидание доступно на машинах, поддерживающих системные вызовы waitpid(2) или wait4(2). Однако ожидание конкретного PID с флагами 0 реализовано во всех системах. (Perl эмулирует системный вызов, запоминая статусы завершившихся процессов, которые ещё не обработаны скриптом Perl.)

Обратите внимание, что на некоторых системах возвращаемое значение -1 может означать автоматическое завершение дочерних процессов. Подробности, а также другие примеры см. в perlipc.

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

wantarray

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

return unless defined wantarray; # don't bother doing more
my @a = complex_calculation();
return wantarray ? @a : "@a";

wantarray не определён в главном уровне файла, в блоке BEGIN, UNITCHECK, CHECK, INIT или END, или в методе DESTROY.

Функция должна была называться wantlist().

warn LIST

Выводит предупреждение, обычно выведя его в STDERR. warn интерпретирует свой операнд LIST так же, как die, но немного отличается в том, что происходит по умолчанию, когда LIST пустой или создаёт пустую строку. Если он пустой и $@ уже содержит значение исключения, то это значение используется после добавления "\t...caught". Если он пустой и $@ также пустой, то используется строка "Warning: Something's wrong".

По умолчанию исключение, полученное из операнда LIST, преобразуется в строку и выводится в STDERR. Это поведение можно изменить, установив обработчик $SIG{__WARN__}. Если такой обработчик есть, сообщение автоматически не выводится; ответственность за обработку исключения лежит на обработчике (например, преобразование его в die). Поэтому большинство обработчиков должны организовать вывод предупреждений, с которыми они не готовы справиться, повторно вызывая warn в обработчике. Обратите внимание, что это достаточно безопасно и не приведёт к бесконечному циклу, поскольку обработчики __WARN__ не вызываются изнутри одного.

Вы увидите, что это поведение немного отличается от поведения обработчиков $SIG{__DIE__} (которые не подавляют текст ошибки, но вместо этого могут вызвать die снова, чтобы изменить его).

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

# wipe out *all* compile-time warnings
BEGIN { $SIG{'__WARN__'} = sub { warn $_[0] if $DOWARN } }
my $foo = 10;
my $foo = 20;          # no warning about duplicate my $foo,
                       # but hey, you asked for it!
# no compile-time or run-time warnings before here
$DOWARN = 1;

# run-time warnings enabled after here
warn "\$foo is alive and $foo!";     # does show up

Подробности о настройке записей %SIG и больше примеров см. в perlvar. Смотрите модуль Carp для других типов предупреждений, используя его функции carp и cluck.

write FILEHANDLE

write EXPR

write

Записывает отформатированную запись (возможно, многострочную) в указанный FILEHANDLE, используя формат, связанный с этим файлом. По умолчанию формат файла — это тот, который имеет то же имя, что и дескриптор файла, но формат текущего выходного канала (см. функцию select) можно явно задать, присвоив имя формата переменной $~.

Обработка верхнего блока формы выполняется автоматически: если на текущей странице недостаточно места для отформатированной записи, страница переходит к следующей, записав символ перевода страницы и специальный формат начала страницы для форматирования заголовка новой страницы перед записью записи. По умолчанию формат начала страницы — это имя дескриптора файла с добавленным _TOP, или top в текущем пакете, если первый не существует. Это было бы проблемой с автовивифицируемыми дескрипторами файлов, но его можно динамически установить на требуемый формат, присвоив имя переменной $^, пока этот дескриптор файла выбран. Количество строк, оставшихся на текущей странице, находится в переменной $-, которую можно установить в значение 0 для принудительного перехода к новой странице.

Если FILEHANDLE не указан, вывод направляется в текущий стандартный выходной канал, который изначально является STDOUT, но может быть изменён оператором select. Если FILEHANDLE — это EXPR, то выражение оценивается, а полученная строка используется для поиска имени FILEHANDLE во время выполнения. Дополнительную информацию о форматах см. в perlform.

Обратите внимание, что write — это не обратная функция к read. К сожалению.

y///

Оператор транслитерации. Такой же, как tr///. См. "Операторы типа кавычек" в perlop.

Нефункциональные ключевые слова по перекрестной ссылке

perldata

__DATA__

__END__

Эти ключевые слова описаны в "Специальные литералы" в perldata.

perlmod

BEGIN

CHECK

END

INIT

UNITCHECK

Эти ключевые слова фазы компиляции описаны в "BEGIN, UNITCHECK, CHECK, INIT и END" в perlmod.

perlobj

DESTROY

Это ключевое слово метода описано в "Деструкторы" в perlobj.

perlop

and

cmp

eq

ge

gt

le

lt

ne

not

or

x

xor

Эти операторы описаны в perlop.

perlsub

AUTOLOAD

Это ключевое слово описано в "Автозагрузка" в perlsub.

perlsyn

else

elsif

for

foreach

if

unless

until

while

Эти ключевые слова управления потоком описаны в "Составные операторы" в perlsyn.

elseif

Ключевое слово "else if" пишется как elsif в Perl. Также нет elif или else if. Он обрабатывает elseif, но только чтобы предупредить вас об этом.

См. документацию по ключевым словам управления потоком в "Составные операторы" в perlsyn.

default

given

when

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