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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

delete, each, exists, keys, values

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

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

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

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

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

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

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

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

break, caller, continue, die, do, dump, eval, evalbytes, exit, __FILE__, goto, last, __LINE__, 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, catch, CHECK, cmp, CORE, __DATA__, default, defer, DESTROY, else, elseif, elsif, END, __END__, eq, finally, for, foreach, ge, given, gt, if, INIT, isa, le, lt, ne, not, or, try, UNITCHECK, unless, until, when, while, x, xor

Портативность

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

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

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

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

-X FILEHANDLE

-X EXPR

-X DIRHANDLE

-X

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

use v5.10;  # so filetest ops can stack

abs VALUE

abs

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

accept NEWSOCKET,GENERICSOCKET

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

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

alarm SECONDS

alarm

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

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

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

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

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

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

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

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

atan2 Y,X

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

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

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

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

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

bind SOCKET,NAME

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

binmode FILEHANDLE, LAYER

binmode FILEHANDLE

Настраивает FILEHANDLE для чтения или записи в режиме «двоичный» или «текстовый» на системах, где runtime-библиотеки различают двоичные и текстовые файлы. Если 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», консенсус в названии этой функциональности сместился с «discipline» на «layer». Вся документация этой версии Perl поэтому ссылается на «слои», а не на «дисциплины». Вернемся к обычному графику документации...

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

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

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

Все варианты Unix, Mac OS (старые и новые), и файлы Stream_LF на VMS используют один символ для завершения каждой строки во внешнем представлении текста (даже если этот символ является символом CARRIAGE RETURN в старых, предшествующих Darwin, версиях Mac OS и символом LINE FEED в 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-пragm. Встроенные типы имеют имена с прописными буквами. Чтобы избежать путаницы, вам может потребоваться также избегать таких имён пакетов. Рекомендуется избегать имени класса 0, так как многие программы ошибочно используют результат ref в качестве логического значения.

См. "Perl Modules" в perlmod.

break

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

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

caller EXPR

caller

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

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

Как __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 истинно, если для кадра был настроен новый экземпляр @_. $hints и $bitmask содержат прагматические подсказки, с которыми была скомпилирована вызывающая сторона. $hints соответствует $^H, а $bitmask соответствует ${^WARNING_BITS}. Значения $hints и $bitmask могут меняться между версиями Perl и не предназначены для внешнего использования.

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

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

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

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

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

chdir EXPR

chdir FILEHANDLE

chdir DIRHANDLE

chdir

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

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

chmod LIST

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

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

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

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

Вот пример поиска nonnumeric uid в файле passwd:

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

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

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

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

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

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

chr NUMBER

chr

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

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

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

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

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

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

chroot FILENAME

chroot

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

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

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

close FILEHANDLE

close

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

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

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

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

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

Пример:

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

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

closedir DIRHANDLE

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

connect SOCKET,NAME

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

continue BLOCK

continue

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

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

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

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

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

cos EXPR

cos

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

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

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

crypt PLAINTEXT,SALT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

dbmclose HASH

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

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

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

dbmopen HASH,DBNAME,MASK

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

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

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

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

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

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

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

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

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

defined EXPR

defined

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

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

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

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

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

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

Примеры:

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

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

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

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

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

delete EXPR

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

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

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

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

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

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

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

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

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

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

И так же это:

delete @HASH{keys %HASH};

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

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

Примеры:

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

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

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

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

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

соответственно выведет

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

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

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

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

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

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

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

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

use Scalar::Util "blessed";

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

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

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

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

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

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

die @_ if $^S;

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

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

do BLOCK

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

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

do EXPR

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

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

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

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

eval `cat stat.pl`;

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

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

do 'foo/stat.pl';

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

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

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

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

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

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

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

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

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

use v5.12;  # so keys/values/each work on arrays
use v5.18;  # so each assigns to $_ in a lone while test

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

eof FILEHANDLE

eof ()

eof

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

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

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

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

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

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

eval EXPR

eval BLOCK

eval

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

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

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

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

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

Обратите внимание, что, поскольку eval перехватывает в противном случае фатальные ошибки, это полезно для определения того, реализована ли определённая функция (например, 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 или выше), Perl предполагает, что EXPR — это строка символов. Любые use utf8 или no utf8 объявления внутри строки не имеют никакого эффекта. Фильтры исходного кода также запрещены. (unicode_strings, однако, может появляться в строке.)

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

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

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

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

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

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

  • Если улучшен, $v будет "\xc4\x80" (т.е., use utf8 не оказывает никакого влияния.)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Блочный eval

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

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

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

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

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

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

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

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

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

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

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

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

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

evalbytes EXPR

evalbytes

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

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

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

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

exec LIST

exec PROGRAM LIST

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

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

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

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

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

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

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

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

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

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

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

my @args = ( "echo surprise" );

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

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

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

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

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

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

exists EXPR

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

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

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

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

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

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

Принимая выражение, указывающее имя подпрограммы, возвращает 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

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

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

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

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

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

fc($this) eq fc($that)

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

Perl реализует только полную форму преобразования к нижнему регистру, но вы можете получить доступ к простым преобразованиям с помощью "casefold()" в Unicode::UCD и "prop_invmap()" в Unicode::UCD. Для получения дополнительной информации о преобразовании к нижнему регистру, обратитесь к Стандарту Юникода, в частности к разделам 3.13 Default Case Operations, 4.2 Case-Normative, и 5.18 Case Mappings, доступным по адресу 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. Преобразование к нижнему регистру этого символа обычно будет "ss", но, как объясняется в разделе lc, изменения регистра, пересекающие границу 255/256, являются проблематичными в локалях и поэтому запрещены. Поэтому в локали эта функция возвращает вместо этого строку "\x{17F}\x{17F}", которая является LATIN SMALL LETTER LONG S. Поскольку сам этот символ преобразуется в "s", строка из двух таких символов должна быть эквивалентна одному U+1E9E при преобразовании к нижнему регистру.

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

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

fcntl FILEHANDLE,FUNCTION,SCALAR

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

use Fcntl;

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

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

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

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

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

use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);

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

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

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

__FILE__

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

fileno FILEHANDLE

fileno DIRHANDLE

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

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

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

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

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

flock FILEHANDLE,OPERATION

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

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

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

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

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

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

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

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

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

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

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

format

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

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

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

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

formline PICTURE,LIST

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

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

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

getc FILEHANDLE

getc

Возвращает следующий символ из входного файла, связанного с FILEHANDLE, или значение undef в конце файла или если произошла ошибка (в последнем случае $! устанавливается). Если 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 в Perl, используя модуль Config и значения d_pwquota, d_pwage, d_pwchange, d_pwcomment, и d_pwexpire. Файлы паролей Shadow поддерживаются только если ваш поставщик реализовал их интуитивно, так что вызов обычных процедур библиотеки C получает версии Shadow, если вы работаете с привилегиями или если существуют функции shadow(3) в System V (включая Solaris и Linux). Вряд ли будут поддерживаться системы, реализующие собственную собственную систему паролей Shadow.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

getsockname СОКЕТ

Возвращает упакованный адрес 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 СОКЕТ,УРОВЕНЬ,ИМЯ_ПАРАМЕТРА

Запрашивает параметр с именем ИМЯ_ПАРАМЕТРА, связанный с СОКЕТ на заданном УРОВНЕ. Параметры могут существовать на нескольких уровнях протоколов в зависимости от типа сокета, но по крайней мере самый верхний уровень сокета SOL_SOCKET (определённый в модуле Socket) будет существовать. Чтобы запросить параметры на другом уровне, следует указать номер протокола соответствующего протокола, контролирующего параметр. Например, чтобы указать, что параметр должен интерпретироваться протоколом TCP, УРОВЕНЬ должен быть установлен на номер протокола TCP, который можно получить с помощью getprotobyname.

Функция возвращает упакованную строку, представляющую запрашиваемый параметр сокета, или undef в случае ошибки, с причиной ошибки в $!. То, что содержится в упакованной строке, зависит от УРОВНЯ и ИМЯ_ПАРАМЕТРА; см. getsockopt(2) для получения подробной информации. Распространённым случаем является то, что параметр является целым числом, в этом случае результат — упакованное целое число, которое можно декодировать, используя unpack с форматом i (или I).

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

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 ВЫРАЖЕНИЕ

glob

В контексте списка возвращает (возможно, пустой) список расширений имён файлов для значения ВЫРАЖЕНИЕ, как это делал бы Unix-оболочка Bash. В скалярном контексте glob итерируется по таким расширениям имён файлов, возвращая undef при исчерпании списка. Если ВЫРАЖЕНИЕ опущено, используется $_.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Внутренние детали реализации:

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

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

gmtime ВЫРАЖЕНИЕ

gmtime

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

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

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

goto МЕТКА

goto ВЫРАЖЕНИЕ

goto &ИМЯ

Форма 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 (локально устанавливая $_ на каждый элемент) и возвращает список элементов, для которых выражение вычислилось в true. В скалярном контексте возвращает количество раз, когда выражение было true.

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

Используемый как 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 v5.12;  # so keys/values/each work on arrays

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

kill SIGNAL, LIST

kill SIGNAL

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

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

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

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

Отрицательное имя сигнала эквивалентно отрицательному номеру сигнала, убивая группы процессов вместо процессов. Например, 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. Однако эта форма иногда используется, поскольку она вызывает выполнение проверок на загрязнение, если ваш Perl поддерживает проверки на загрязнение. Но см. раздел «Отмывание и обнаружение заражённых данных» в perlsec.

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

last LABEL

last EXPR

last

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

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

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

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

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

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

lc EXPR

lc

Возвращает строку с EXPR в нижнем регистре. Если EXPR опущено, используется $_.

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

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

Если use bytes активна:

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

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

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

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

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

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

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

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

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

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

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

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

lcfirst EXPR

lcfirst

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

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

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

length EXPR

length

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

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

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

__LINE__

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

link OLDFILE,NEWFILE

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

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

listen SOCKET,QUEUESIZE

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

local EXPR

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

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

Конструкцию delete local EXPR также можно использовать для локализации удаления элементов массива/хэша в текущем блоке. См. "Localized deletion of elements of composite types" in perlsub.

localtime EXPR

localtime

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

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

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

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

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

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

$year += 1900;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вопросы совместимости: "localtime" in 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 (включая установку специального _ filehandle), но получает информацию о символической ссылке вместо файла, на который она указывает. Если символические ссылки не поддерживаются вашей системой, выполняется обычная функция stat. Для более подробной информации см. документацию по stat.

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

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

m//

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

map BLOCK LIST

map EXPR,LIST

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

mkdir FILENAME,MODE

mkdir FILENAME

mkdir

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

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

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

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

msgctl ID,CMD,ARG

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

use IPC::SysV;

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

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

msgget KEY,FLAGS

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

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

msgrcv ID,VAR,SIZE,TYPE,FLAGS

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

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

msgsnd ID,MSG,FLAGS

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

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

my VARLIST

my TYPE VARLIST

my VARLIST : ATTRS

my TYPE VARLIST : ATTRS

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

или

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

за которым следует

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Автоматическое опорожнение трубы

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

См. "open" в perlport.

opendir DIRHANDLE,EXPR

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

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

ord EXPR

ord

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

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

our VARLIST

our TYPE VARLIST

our VARLIST : ATTRS

our TYPE VARLIST : ATTRS

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

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

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

package Foo;
use v5.36;  # which implies "use strict;"

$Foo::foo = 23;

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

print $Foo::foo; # prints 23

print $foo; # ERROR: requires explicit package name

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

package Foo;
use v5.36;

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

print $Foo::foo; # prints 23

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

package Foo;
use v5.36;

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

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

our($bar, $baz);

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

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

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

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

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

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

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

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

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

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

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

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

pack TEMPLATE,LIST

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

u  A uuencoded string.
U  A Unicode character number.  Encodes to a character in char-
   acter mode and UTF-8 (or UTF-EBCDIC in EBCDIC platforms) in
   byte mode.  Also on EBCDIC platforms, the character number will
   be the native EBCDIC value for character numbers below 256.
   This allows most programs using this feature to not have to
   care which type of platform they are running on.

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

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

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

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

!   xX         Make x and X act as alignment commands.

!   nNvV       Treat integers as signed instead of unsigned.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  Для 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, существуют различия, особенно если речь идёт о длинных двойных значениях. Вы можете увидеть переменные Config doublekind и longdblkind (также doublesize, longdblsize) - значения "kind" являются перечислениями, в отличие от byteorder.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  является строка "\0X\0\0YZ".

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

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

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

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

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

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

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

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

Примеры:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package NAMESPACE

package NAMESPACE VERSION

package NAMESPACE BLOCK

package NAMESPACE VERSION BLOCK

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

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

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

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

__PACKAGE__

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

pipe READHANDLE,WRITEHANDLE

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

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

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

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

pop ARRAY

pop

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

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

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

pos SCALAR

pos

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

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

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

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

print FILEHANDLE LIST

print FILEHANDLE

print LIST

print

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

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

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

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

Вызов print закрытой трубы или сокета сгенерирует сигнал 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 принял стратегию экранирования, основанную на Юникоде; экранирование ASCII-символов не изменилось.

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

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

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

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

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

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

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

rand EXPR

rand

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

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

int(rand(10))

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

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

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

read FILEHANDLE,SCALAR,LENGTH,OFFSET

read FILEHANDLE,SCALAR,LENGTH

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

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

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

Обратите внимание на символы: в зависимости от состояния файлового дескриптора, читаются байты или символы. По умолчанию все файловые дескрипторы работают с байтами, но, например, если файловый дескриптор был открыт с помощью слоя ввода-вывода :utf8 (см. open и прагму open), ввод-вывод будет работать с закодированными в UTF8 символами Юникода, а не байтами. Аналогично для слоя :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, что установит $_ на каждой итерации. Если в качестве условия while/for используется выражение readdir или явное присваивание выражения readdir скаляру, то условие фактически проверяет определённость значения выражения, а не его обычную истинность.

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

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

use v5.12; # so readdir assigns to $_ in a lone while test

readline EXPR

readline

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

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

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

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

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

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

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

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

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

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

readlink EXPR

readlink

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

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

readpipe EXPR

readpipe

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

recv SOCKET,SCALAR,LENGTH,FLAGS

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

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

redo LABEL

redo EXPR

redo

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

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

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

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

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

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

ref EXPR

ref

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

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

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

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

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

Оператор подстановки. См. "Regexp Quote-Like Operators" в 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. После достижения EOF при чтении и последующего ожидания некоторое время, возможно, потребуется добавить фиктивный seek для сброса состояния. seek не изменяет позицию, но очищает состояние конца файла в файловом дескрипторе, так что последующий readline FILE заставляет Perl попытаться прочитать что-то снова. (Мы надеемся.)

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

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

seekdir DIRHANDLE,POS

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

select FILEHANDLE

select

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

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

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

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

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

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

STDERR->autoflush(1);

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

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

select RBITS,WBITS,EBITS,TIMEOUT

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

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

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

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

Обычный шаблон:

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

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

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

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

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

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

select(undef, undef, undef, 0.25);

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

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

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

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

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

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

semctl ID,SEMNUM,CMD,ARG

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

use IPC::SysV;

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

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

semget KEY,NSEMS,FLAGS

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

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

semop KEY,OPSTRING

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

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

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

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

send SOCKET,MSG,FLAGS,TO

send SOCKET,MSG,FLAGS

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

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

setpgrp PID,PGRP

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

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

setpriority WHICH,WHO,PRIORITY

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

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

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

setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL

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

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

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

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

shift ARRAY

shift

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

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

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

shmctl ID,CMD,ARG

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

use IPC::SysV;

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

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

shmget KEY,SIZE,FLAGS

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

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

shmread ID,VAR,POS,SIZE

shmwrite ID,STRING,POS,SIZE

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

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

shutdown SOCKET,HOW

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

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

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

Возвращает 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

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

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

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

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

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

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

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

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

Исторически Perl по-разному реализовывал сортировку по умолчанию. Если устойчивость важна, это можно явно контролировать, используя прагму sort.

Примеры:

# sort lexically
my @articles = sort @files;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

my @new = sort function_with_signature @old;

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

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

my @contact = sort { $a cmp $b } find_records @key;
my @contact = sort +find_records(@key);
my @contact = sort &find_records(@key);
my @contact = sort(find_records(@key));

Если вместо этого нужно отсортировать массив @key с функцией сравнения find_records(), можно использовать:

my @contact = sort { find_records() } @key;
my @contact = sort find_records(@key);
my @contact = sort(find_records @key);
my @contact = sort(find_records (@key));

$a и $b устанавливаются как глобальные переменные пакета, из которого вызывается sort(). Это означает $main::a и $main::b (или $::a и $::b) в пакете main, $FooPack::a и $FooPack::b в пакете FooPack и так далее. Если блок сортировки находится в области действия объявления my или state для $a и/или $b, вы обязательно должны указывать полные имена переменных в блоке сортировки:

package main;
my $a = "C"; # DANGER, Will Robinson, DANGER !!!

print sort { $a cmp $b }               qw(A C E G B D F H);
                                       # WRONG
sub badlexi { $a cmp $b }
print sort badlexi                     qw(A C E G B D F H);
                                       # WRONG
# the above prints BACFEDGH or some other incorrect ordering

print sort { $::a cmp $::b }           qw(A C E G B D F H);
                                       # OK
print sort { our $a cmp our $b }       qw(A C E G B D F H);
                                       # also OK
print sort { our ($a, $b); $a cmp $b } qw(A C E G B D F H);
                                       # also OK
sub lexi { our $a cmp our $b }
print sort lexi                        qw(A C E G B D F H);
                                       # also OK
# the above print ABCDEFGH

При надлежащей внимательности можно смешивать переменные пакета и мои (или state) $a и/или $b:

my $a = {
   tiny   => -2,
   small  => -1,
   normal => 0,
   big    => 1,
   huge   => 2
};

say sort { $a->{our $a} <=> $a->{our $b} }
    qw{ huge normal tiny small big};

# prints tinysmallnormalbighuge

$a и $b неявным образом локальны для выполнения sort() и восстанавливают свои первоначальные значения по завершении сортировки.

Подпрограммы сортировки, написанные с использованием $a и $b, привязаны к своему вызывающему пакету. Можно, но не имеет особого интереса определять их в другом пакете, поскольку подпрограмма все равно должна ссылаться на $a и $b вызывающего пакета:

package Foo;
sub lexi { $Bar::a cmp $Bar::b }
package Bar;
... sort Foo::lexi ...

Используйте прототипированные версии (см. выше) для более универсальной альтернативы.

Функция сравнения должна обеспечивать корректное поведение. Если она возвращает непоследовательные результаты (иногда говорит, что $x[1] меньше $x[2], а иногда наоборот, например), результаты не определены.

Поскольку <=> возвращает undef, когда один из операндов — NaN (не число), будьте внимательны при сортировке с помощью функции сравнения, как $a <=> $b, любых списков, которые могут содержать NaN. Следующий пример использует это, чтобы исключить любые NaN из входного списка.

my @result = sort { $a <=> $b } grep { $_ == $_ } @input;

В этой версии perl функция sort реализована с помощью алгоритма слияния.

splice ARRAY,OFFSET,LENGTH,LIST

splice ARRAY,OFFSET,LENGTH

splice ARRAY,OFFSET

splice ARRAY

Удаляет элементы, определяемые OFFSET и LENGTH из массива, и заменяет их элементами LIST, если таковые имеются. В контексте списка возвращает удалённые элементы из массива. В скалярном контексте возвращает последний удалённый элемент или undef, если элементы не были удалены. Массив увеличивается или уменьшается по мере необходимости. Если OFFSET отрицателен, он начинается на таком расстоянии от конца массива. Если LENGTH опущен, удаляются все элементы от OFFSET и далее. Если LENGTH отрицателен, удаляются элементы от OFFSET и далее, за исключением -LENGTH элементов в конце массива. Если и OFFSET, и LENGTH опущены, удаляются все элементы. Если OFFSET выходит за пределы массива и LENGTH был указан, Perl выводит предупреждение и выполняет срез в конце массива.

Следующие эквивалентности выполняются (предполагая $#a >= $i )

push(@a,$x,$y)      splice(@a,@a,0,$x,$y)
pop(@a)             splice(@a,-1)
shift(@a)           splice(@a,0,1)
unshift(@a,$x,$y)   splice(@a,0,0,$x,$y)
$a[$i] = $y         splice(@a,$i,1,$y)

splice может быть использована, например, для реализации n-арной обработки очереди:

sub nary_print {
  my $n = shift;
  while (my @next_n = splice @_, 0, $n) {
    say join q{ -- }, @next_n;
  }
}

nary_print(3, qw(a b c d e f g h));
# prints:
#   a -- b -- c
#   d -- e -- f
#   g -- h

Начиная с Perl 5.14, экспериментальная функция разрешала splice принимать скалярное выражение. Этот эксперимент был признан неудачным и был удалён начиная с Perl 5.24.

split /PATTERN/,EXPR,LIMIT

split /PATTERN/,EXPR

split /PATTERN/

split

Разделяет строку EXPR на список строк и возвращает список в контексте списка или размер списка в скалярном контексте. (До Perl 5.11, он также перезаписывал @_ списком в пустом и скалярном контекстах. Будьте осторожны, если вы работаете со старыми версиями Perl.)

Если указан только PATTERN, EXPR по умолчанию принимает значение $_.

Любое в EXPR, что соответствует PATTERN, рассматривается как разделитель, который разделяет EXPR на подстроки (называемые «полями»), которые не включают разделитель. Обратите внимание, что разделитель может быть длиннее одного символа или даже не содержать символов вообще (пустая строка, которая является соответствием нулевой ширины).

PATTERN не обязательно должен быть константой; можно использовать выражение для указания шаблона, который меняется во время выполнения.

Если PATTERN соответствует пустой строке, EXPR разделяется в позиции совпадения (между символами). Например:

my @x = split(/b/, "abc"); # ("a", "c")

использует b в 'abc' как разделитель для получения списка («a», «c»). Однако это:

my @x = split(//, "abc"); # ("a", "b", "c")

использует совпадения пустой строки как разделители; таким образом, пустая строка может использоваться для разделения EXPR на список его составляющих символов.

В качестве специального случая для split, пустой шаблон, заданный в синтаксисе оператора соответствия (//), специально соответствует пустой строке, что противоречит его обычному толкованию как последнего успешного соответствия.

Если PATTERN равно /^/, то он обрабатывается так, как будто он использовал модификатор многострочный (/^/m), поскольку в противном случае он не очень полезен.

/m и любые другие модификаторы шаблонов, допустимые для qr (подробно описанные в "qr/STRING/msixpodualn" в perlop) могут быть указаны явно.

В качестве еще одного специального случая, split эмулирует поведение утилиты командной строки awk, когда PATTERN опущено или представляет собой строку, состоящую из одного пробела (например, ' ' или "\x20", но не, например, / /). В этом случае любые ведущие пробелы в EXPR удаляются перед разделением, а PATTERN вместо этого обрабатывается так, как если бы это было /\s+/; в частности, это означает, что любые смежные пробелы (а не только один символ пробела) используются как разделитель.

my @x = split(" ", "  Quick brown fox\n");
# ("Quick", "brown", "fox")

my @x = split(" ", "RED\tGREEN\tBLUE");
# ("RED", "GREEN", "BLUE")

Использование split таким образом очень похоже на работу qw//.

Однако, этот специальный режим обработки можно избежать, указав шаблон / / вместо строки " ", тем самым, разрешив только один пробел как разделитель. В более ранних версиях Perl этот специальный случай был ограничен использованием простого " " в качестве аргумента шаблона для split; в Perl 5.18.0 и более поздних версиях этот специальный случай запускается любым выражением, которое оценивается как простая строка " ".

Начиная с Perl 5.28, этот специальный режим разделения пробелами работает как ожидается в контексте "use feature 'unicode_strings'". В предыдущих версиях и вне этого контекста он демонстрирует "Проблему Юникода" в perlunicode: символы, которые являются пробелами в соответствии с правилами Юникода, но не в соответствии с правилами 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 умножить на десять в степени 99 может быть либо "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 v5.14;  # 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 v5.14;  # so srand returns the seed

Если srand не вызывается явно, он вызывается неявно без параметра при первом использовании оператора rand.

Однако есть несколько ситуаций, когда программы, вероятно, захотят вызвать srand. Одна из них — для получения предсказуемых результатов, обычно для тестирования или отладки. В этом случае вы используете srand($seed), с тем же $seed каждый раз. Другой случай — вы можете вызвать srand после fork, чтобы избежать совместного использования начального значения дочерними процессами с родительским процессом (и, следовательно, друг с другом).

Не вызывайте srand() (то есть без аргумента) более одного раза в одном процессе. Внутреннее состояние генератора случайных чисел должно содержать больше энтропии, чем может предоставить любое начальное значение, поэтому повторный вызов srand фактически уменьшает случайность.

Большинство реализаций srand принимают целое число и молча отбрасывают дробную часть. Это означает, что srand(42) обычно даёт те же результаты, что и srand(42.1). Для безопасности всегда передавайте srand целое число.

Типичное использование возвращаемого начального значения — для тестовой программы, у которой слишком много комбинаций, чтобы её можно было полностью протестировать за доступное время каждого запуска. Она может тестировать случайную подмножество каждый раз и, в случае ошибки, записывать начальное значение, используемое для этого запуска, чтобы позже можно было воспроизвести те же результаты.

rand не является криптографически безопасным. Вы не должны полагаться на него в ситуациях, требующих безопасности. На момент написания этого документа ряд сторонних модулей CPAN предлагают генераторы случайных чисел, предназначенные их авторами для криптографической безопасности, в том числе: Data::Entropy, Crypt::Random, Math::Random::Secure и Math::TrulyRandom.

stat FILEHANDLE

stat EXPR

stat DIRHANDLE

stat

Возвращает список из 13 элементов, содержащих информацию о статусе файла, либо файла, открытого через FILEHANDLE или DIRHANDLE, либо указанного именем EXPR. Если EXPR опущен, он выполняет stat для $_ (а не _!). Возвращает пустой список, если stat завершился неудачно. Обычно используется следующим образом:

my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
    $atime,$mtime,$ctime,$blksize,$blocks)
       = stat($filename);

Не все поля поддерживаются на всех типах файловых систем. Вот значения полей:

 0 dev      device number of filesystem
 1 ino      inode number
 2 mode     file mode  (type and permissions)
 3 nlink    number of (hard) links to the file
 4 uid      numeric user ID of file's owner
 5 gid      numeric group ID of file's owner
 6 rdev     the device identifier (special files only)
 7 size     total size of file, in bytes
 8 atime    last access time in seconds since the epoch
 9 mtime    last modify time in seconds since the epoch
10 ctime    inode change time in seconds since the epoch (*)
11 blksize  preferred I/O size in bytes for interacting with the
            file (may vary from file to file)
12 blocks   actual number of system-specific blocks allocated
            on disk (often, but not always, 512 bytes each)

(Эпоха была в 00:00 1 января 1970 года по Гринвичу.)

(*) Не все поля поддерживаются на всех типах файловых систем. Обратите внимание, что поле ctime не является переносимым. В частности, вы не можете ожидать, что это будет «время создания»; см. "Файлы и файловые системы" в perlport для подробностей.

Если stat передаётся специальный файловый дескриптор, состоящий из подчёркивания, то stat не выполняется, но возвращается текущее содержимое структуры stat из последнего вызова stat, lstat или filetest.

if (-x $file && (($d) = stat(_)) && $d < 0) {
    print "$file is executable NFS file\n";
}

(Это работает только на платформах, на которых номер устройства отрицателен в NFS.)

На некоторых платформах номера inode имеют тип, больший, чем Perl может обрабатывать как целочисленные значения. Если необходимо, номер inode будет возвращён в виде десятичной строки, чтобы сохранить всё значение. Если он используется в числовом контексте, он будет преобразован в число с плавающей точкой с округлением, чему лучше избегать. Поэтому вы должны предпочесть сравнение номеров inode с помощью eq вместо ==. eq прекрасно работает с номерами inode, которые представлены числовыми значениями, а также в виде строк.

Так как разрешения содержат как тип файла, так и его разрешения, вы должны замаскировать часть типа файла и использовать "%o", если хотите увидеть реальные разрешения.

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

Это определение подпрограммы, а не настоящей функции per se. Без BLOCK это просто объявление вперёд. Без NAME — это объявление анонимной функции, поэтому она возвращает значение: CODE-ссылку только что созданного замыкания.

См. perlsub и perlref для получения подробностей о подпрограммах и ссылках; см. attributes и Attribute::Handlers для получения дополнительной информации об атрибутах.

__SUB__

Специальный токен, возвращающий ссылку на текущую подпрограмму или undef вне подпрограммы.

Поведение __SUB__ внутри блока кода регулярного выражения (такого как /(?{...})/) может быть изменено.

Этот токен доступен только в use v5.16 или в "current_sub".

substr EXPR,OFFSET,LENGTH,REPLACEMENT

substr EXPR,OFFSET,LENGTH

substr EXPR,OFFSET

Извлекает подстроку из EXPR и возвращает её. Первый символ находится по смещению ноль. Если OFFSET отрицательный, начинается за этим количеством символов от конца строки. Если LENGTH опущен, возвращает всё до конца строки. Если LENGTH отрицательный, оставляет столько символов с конца строки.

my $s = "The black cat climbed the green tree";
my $color  = substr $s, 4, 5;      # black
my $middle = substr $s, 4, -11;    # black cat climbed the
my $end    = substr $s, 14;        # climbed the green tree
my $tail   = substr $s, -4;        # tree
my $z      = substr $s, -4, 2;     # tr

Вы можете использовать функцию substr в качестве lvalue, в этом случае EXPR также должно быть lvalue. Если вы присваиваете значение короче LENGTH, строка уменьшится, а если длиннее — строка увеличится, чтобы вместить его. Чтобы сохранить длину строки, вам может потребоваться дополнить или обрезать ваше значение с помощью sprintf.

Если OFFSET и LENGTH определяют подстроку, частично выходящую за пределы строки, возвращается только часть внутри строки. Если подстрока выходит за пределы обоих концов строки, substr возвращает неопределённое значение и выводит предупреждение. При использовании в качестве lvalue указание подстроки, полностью выходящей за пределы строки, вызывает исключение. Вот пример, демонстрирующий поведение в граничных случаях:

my $name = 'fred';
substr($name, 4) = 'dy';         # $name is now 'freddy'
my $null = substr $name, 6, 2;   # returns "" (no warning)
my $oops = substr $name, 7;      # returns undef, with warning
substr($name, 7) = 'gap';        # raises an exception

Альтернатива использованию substr в качестве lvalue — указать строку замены как четвёртый аргумент. Это позволяет вам заменить части EXPR и вернуть то, что было ранее, за одну операцию, как и в splice.

my $s = "The black cat climbed the green tree";
my $z = substr $s, 14, 7, "jumped from";    # climbed
# $s is now "The black cat jumped from the green tree"

Обратите внимание, что lvalue, возвращаемое трёхаргументной версией substr, действует как «волшебная пуля»; каждый раз при присваивании она запоминает, какая часть исходной строки изменяется; например:

my $x = '1234';
for (substr($x,1,2)) {
    $_ = 'a';   print $x,"\n";    # prints 1a4
    $_ = 'xyz'; print $x,"\n";    # prints 1xyz4
    $x = '56789';
    $_ = 'pq';  print $x,"\n";    # prints 5pq9
}

С отрицательными смещениями она запоминает своё положение с конца строки при изменении целевой строки:

my $x = '1234';
for (substr($x, -3, 2)) {
    $_ = 'a';   print $x,"\n";    # prints 1a4, as above
    $x = 'abcdefg';
    print $_,"\n";                # prints f
}

До версии Perl 5.10 результат многократного использования lvalue был неопределённым. До 5.16 результат с отрицательными смещениями был неопределённым.

symlink OLDFILE,NEWFILE

Создаёт новое имя файла, символически связанное со старым именем файла. Возвращает 1 при успехе, 0 в противном случае. На системах, не поддерживающих символические ссылки, генерирует исключение. Для проверки этого используйте eval:

my $symlink_exists = eval { symlink("",""); 1 };

Проблемы переносимости: "symlink" в perlport.

syscall NUMBER, LIST

Вызывает системный вызов, указанный как первый элемент списка, передавая оставшиеся элементы в качестве аргументов системному вызову. Если не реализован, генерирует исключение. Аргументы интерпретируются следующим образом: если данный аргумент числовой, аргумент передаётся как int. Если нет, передаётся указатель на строковое значение. Вы несёте ответственность за обеспечение того, чтобы строка была предварительно расширена достаточно для получения любого результата, который может быть записан в строку. Вы не можете использовать строковую литерал (или другую неизменяемую строку) в качестве аргумента для syscall, потому что Perl должен предположить, что любой указатель на строку может быть записан. Если ваши целочисленные аргументы не являются литералами и никогда не интерпретировались в числовом контексте, вам может потребоваться добавить 0 к ним, чтобы заставить их выглядеть как числа. Это эмулирует функцию syswrite (или наоборот):

require 'syscall.ph';        # may need to run h2ph
my $s = "hi there\n";
syscall(SYS_write(), fileno(STDOUT), $s, length $s);

Обратите внимание, что Perl поддерживает передачу не более 14 аргументов в ваш syscall, чего, как правило, должно быть достаточно.

Syscall возвращает то же значение, что и системный вызов. Если системный вызов завершается ошибкой, syscall возвращает -1 и устанавливает $! (errno). Обратите внимание, что некоторые системные вызовы могут легитимно вернуть -1. Правильный способ обработки таких вызовов — присвоить $! = 0 перед вызовом, затем проверить значение $!, если syscall возвращает -1.

Есть проблема с syscall(SYS_pipe()): она возвращает номер файла чтения созданной им трубы, но нет способа получить номер файла другого конца. Вы можете избежать этой проблемы, используя pipe вместо этого.

Проблемы переносимости: "syscall" в perlport.

sysopen FILEHANDLE,FILENAME,MODE

sysopen FILEHANDLE,FILENAME,MODE,PERMS

Открывает файл с именем FILENAME и связывает его с FILEHANDLE. Если FILEHANDLE является выражением, его значение используется в качестве реального дескриптора файла; неопределённый скаляр будет уместно автоматизирован. Эта функция вызывает функцию open(2) ОС с параметрами FILENAME, MODE и PERMS.

Возвращает true при успехе и undef в противном случае.

Слой PerlIO будет применяться к дескриптору файла так же, как и в вызове open, который не указывает слои. То есть, текущее значение ${^OPEN}, установленное предикатом open в лексическом области, или параметр -C командной строки или переменная среды PERL_UNICODE, в области основной программы, с падением к системным значениям по умолчанию, как описано в "Значения по умолчанию и как их переопределить" в PerlIO. Если вы хотите удалить любые слои, которые могут преобразовывать байтовую последовательность, используйте binmode после открытия.

Возможные значения и флаги параметра MODE зависят от системы; они доступны через стандартный модуль Fcntl. Обратитесь к документации системного вызова open(2) вашей операционной системы, чтобы узнать, какие значения и флаги доступны. Вы можете объединить несколько флагов с помощью оператора |.

Некоторые из наиболее распространённых значений — O_RDONLY для открытия файла в режиме только для чтения, O_WRONLY для открытия файла в режиме только для записи и O_RDWR для открытия файла в режиме чтения и записи.

По историческим причинам некоторые значения работают почти на всех системах, поддерживаемых Perl: 0 означает только чтение, 1 означает только запись, а 2 — чтение/запись. Нам известно, что эти значения не работают в OS/390; вы, вероятно, не хотите использовать их в новом коде.

Если файл с именем FILENAME не существует и вызов open создаёт его (как правило, потому что MODE включает флаг O_CREAT), то значение PERMS определяет права вновь созданного файла. Если вы опускаете аргумент PERMS в sysopen, Perl использует восьмеричное значение 0666. Эти значения прав должны быть восьмеричными и модифицируются текущим umask процесса.

На многих системах доступен флаг O_EXCL для открытия файлов в режиме исключения. Это не блокировка: исключительность здесь означает, что если файл уже существует, sysopen завершается ошибкой. O_EXCL может не работать с сетевыми файловыми системами и не имеет эффекта, если не установлен флаг O_CREAT. Установка O_CREAT|O_EXCL предотвращает открытие файла, если это символическая ссылка. Это не защищает от символических ссылок в пути к файлу.

Иногда вам может потребоваться обрезать уже существующий файл. Это можно сделать с помощью флага O_TRUNC. Поведение O_TRUNC с O_RDONLY не определено.

Вы редко, если вообще, должны использовать 0644 в качестве аргумента sysopen, потому что это лишает пользователя возможности иметь более разрешительную маску. Лучше опустить её. Смотрите umask для получения более подробной информации об этом.

Эта функция не имеет прямой связи с использованием sysread, syswrite или sysseek. Дескриптор файла, открытый с помощью этой функции, может использоваться с буферизованным вводом/выводом так же, как и тот, что открыт с помощью open, может использоваться с небуферизованным вводом/выводом.

Обратите внимание, что в Perl-версиях старше 5.8.0, sysopen зависит от функции fdopen(3) C-библиотеки. На многих Unix-системах fdopen(3) может завершиться неудачно при превышении определённого значения дескрипторов файлов, обычно 255. Если вам нужны дескрипторы файлов больше, чем это, рассмотрите использование функции POSIX::open. Для Perl 5.8.0 и более поздних версий PerlIO — (в большинстве случаев) используется по умолчанию.

См. perlopentut для более простого объяснения открытия файлов.

Проблемы переносимости: "sysopen" в perlport.

sysread FILEHANDLE,SCALAR,LENGTH,OFFSET

sysread FILEHANDLE,SCALAR,LENGTH

Попытка прочитать LENGTH байтов данных в переменную SCALAR из указанного FILEHANDLE, используя read(2). Она опускает любые слои PerlIO, включая буферизованный ввод-вывод (но зависит от наличия слоя :utf8, как описано позже), поэтому смешивание этого с другими видами чтений, print, write, seek, tell или eof может вызвать путаницу, потому что слои :perlio или :crlf обычно буферизуют данные. Возвращает количество фактически прочитанных байтов, 0 в конце файла, или undef, если произошла ошибка (в последнем случае $! также установлено). SCALAR будет увеличена или уменьшена так, чтобы последний фактически прочитанный байт был последним байтом скаляра после чтения.

Можно указать смещение OFFSET, чтобы поместить прочитанные данные в определённом месте строки, отличном от начала. Отрицательное OFFSET указывает на размещение на указанном количестве символов, отсчитывая назад от конца строки. Положительное OFFSET, большее длины SCALAR, приводит к тому, что строка заполняется требуемого размера с "\0" байтами перед добавлением результата чтения.

Функции syseof() не существует, что нормально, так как eof в любом случае не работает хорошо с файловыми устройствами (например, ttys). Используйте sysread и проверьте возвращаемое значение на 0, чтобы определить, закончено ли чтение.

Обратите внимание, что если дескриптор файла помечен как :utf8, то sysread вызовет исключение. Слой :encoding(...) неявно вводит слой :utf8. См. binmode, open и прагму open.

sysseek FILEHANDLE,POSITION,WHENCE

Устанавливает системную позицию FILEHANDLE в байтах, используя lseek(2). FILEHANDLE может быть выражением, значение которого даёт имя дескриптора файла. Значения для WHENCE: 0 для установки новой позиции на POSITION; 1 для установки на текущую позицию плюс POSITION; и 2 для установки на конец файла плюс POSITION, обычно отрицательное значение.

Обратите внимание на акцент на байтах: даже если дескриптор файла настроен на работу с символами (например, используя слой ввода-вывода :encoding(UTF-8)), функции seek, tell и sysseek используют байтовые смещения, а не смещения символов, поскольку поиск по смещению символов в файле UTF-8 будет очень медленным.

sysseek опускает стандартный буферизованный ввод-вывод, поэтому смешивание его с операциями чтения, кроме sysread (например, readline или read), print, write, seek, tell или eof может вызвать путаницу.

В качестве WHENCE можно использовать константы SEEK_SET, SEEK_CUR, и SEEK_END (начало файла, текущая позиция, конец файла) из модуля Fcntl. Использование констант также более переносимо, чем полагаться на 0, 1 и 2. Например, для определения функции "systell":

use Fcntl 'SEEK_CUR';
sub systell { sysseek($_[0], 0, SEEK_CUR) }

Возвращает новую позицию или значение 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`" в perlop. Значение -1 указывает на неудачу запуска программы или ошибку системного вызова wait(2) (проверьте $! для причины).

Если вы хотите, чтобы system (и многие другие части Perl) вызывали исключение при ошибке, посмотрите прагму autodie.

Как и exec, system позволяет обманывать программу относительно её имени, если используется синтаксис system PROGRAM LIST. Опять же, см. exec.

Поскольку SIGINT и SIGQUIT игнорируются во время выполнения system, если вы ожидаете, что ваша программа завершится при получении этих сигналов, вам нужно будет организовать это самостоятельно, исходя из возвращаемого значения.

my @args = ("command", "arg1", "arg2");
system(@args) == 0
    or die "system @args failed: $?";

Если вы хотите вручную проверить неудачу system, вы можете проверить все возможные режимы ошибок, посмотрев $? так:

if ($? == -1) {
    print "failed to execute: $!\n";
}
elsif ($? & 127) {
    printf "child died with signal %d, %s coredump\n",
        ($? & 127),  ($? & 128) ? 'with' : 'without';
}
else {
    printf "child exited with value %d\n", $? >> 8;
}

В качестве альтернативы, вы можете проверить значение ${^CHILD_ERROR_NATIVE} с помощью вызовов W*() из модуля POSIX.

Когда аргументы system выполняются косвенно через оболочку, результаты и коды возврата зависят от её особенностей. См. "`STRING`" в perlop и exec для деталей.

Так как system выполняет fork и wait, это может повлиять на обработчик SIGCHLD. См. perlipc для получения подробной информации.

Проблемы с переносимостью: "system" в perlport.

syswrite FILEHANDLE,SCALAR,LENGTH,OFFSET

syswrite FILEHANDLE,SCALAR,LENGTH

syswrite FILEHANDLE,SCALAR

Попытка записи LENGTH байтов данных из переменной SCALAR в указанный FILEHANDLE, используя write(2). Если LENGTH не указан, записывается весь SCALAR. Она опускает любые слои PerlIO, включая буферизованный ввод-вывод (но зависит от наличия слоя :utf8, как описано позже), поэтому смешивание этого с операциями чтения (кроме sysread)), print, write, seek, tell или eof может вызвать путаницу, потому что слои :perlio и :crlf обычно буферизуют данные. Возвращает количество фактически записанных байтов или undef в случае ошибки (в этом случае переменная errno $! также установлена). Если LENGTH больше доступных данных в SCALAR после OFFSET, запишется только доступный объём данных.

Можно указать смещение OFFSET, чтобы записать данные из определённой части строки, отличной от начала. Отрицательное OFFSET указывает на запись на указанном количестве символов, отсчитывая назад от конца строки. Если длина SCALAR равна нулю, вы можете использовать только OFFSET 0.

ПРЕДУПРЕЖДЕНИЕ: Если дескриптор файла помечен как :utf8, то syswrite вызовет исключение. Слой :encoding(...) неявно вводит слой :utf8. В качестве альтернативы, если дескриптор не помечен кодировкой, но вы пытаетесь записать символы с кодовыми точками более 255, будет выброшено исключение. См. binmode, open и прагму open.

tell FILEHANDLE

tell

Возвращает текущую позицию в байтах для FILEHANDLE или -1 при ошибке. FILEHANDLE может быть выражением, значение которого даёт имя фактического файлового дескриптора. Если FILEHANDLE опущен, предполагается, что это последний прочитанный файл.

Обратите внимание на акцент на байтах: даже если файловый дескриптор настроен на работу с символами (например, с помощью :encoding(UTF-8)) слоя ввода-вывода, функции seek, tell и sysseek используют байтовые смещения, а не смещения символов, так как поиск по смещению символов в файле UTF-8 будет очень медленным.

Значение возвращаемое функцией tell для стандартных потоков, таких как STDIN, зависит от операционной системы: она может вернуть -1 или другое значение. tell для труб, FIFO и сокетов обычно возвращает -1.

Функции systell нет. Используйте sysseek($fh, 0, 1).

Не используйте tell (или другие операции буферизованного ввода-вывода) с файловым дескриптором, который был изменён функциями sysread, syswrite или sysseek. Эти функции игнорируют буферизацию, а tell — нет.

telldir DIRHANDLE

Возвращает текущую позицию функций readdir в DIRHANDLE. Значение можно передать в seekdir для доступа к определённому месту в каталоге. telldir имеет те же оговорки о возможной уплотнении каталога, что и соответствующая системная библиотечная функция.

tie VARIABLE,CLASSNAME,LIST

Эта функция связывает переменную с классом пакета, который обеспечит реализацию для переменной. VARIABLE — имя переменной, которую нужно изменить. CLASSNAME — имя класса, реализующего объекты правильного типа. Любые дополнительные аргументы передаются соответствующему конструктору метода класса (что означает TIESCALAR, TIEHANDLE, TIEARRAY, или TIEHASH). Как правило, это такие аргументы, как те, которые могут быть переданы в функцию dbm_open(3) языка C. Объект, возвращаемый конструктором, также возвращается функцией tie, что может быть полезно, если вам нужно получить доступ к другим методам в CLASSNAME.

Обратите внимание, что такие функции, как keys и values, могут возвращать огромные списки при использовании с большими объектами, такими как файлы DBM. Вы можете использовать функцию each для итерации по таким объектам. Пример:

# print out history file offsets
use NDBM_File;
tie(my %HIST, 'NDBM_File', '/usr/lib/news/history', 1, 0);
while (my ($key,$val) = each %HIST) {
    print $key, ' = ', unpack('L', $val), "\n";
}

Класс, реализующий хэш-таблицу, должен иметь следующие методы:

TIEHASH classname, LIST
FETCH this, key
STORE this, key, value
DELETE this, key
CLEAR this
EXISTS this, key
FIRSTKEY this
NEXTKEY this, lastkey
SCALAR this
DESTROY this
UNTIE this

Класс, реализующий обычный массив, должен иметь следующие методы:

TIEARRAY classname, LIST
FETCH this, key
STORE this, key, value
FETCHSIZE this
STORESIZE this, count
CLEAR this
PUSH this, LIST
POP this
SHIFT this
UNSHIFT this, LIST
SPLICE this, offset, length, LIST
EXTEND this, count
DELETE this, key
EXISTS this, key
DESTROY this
UNTIE this

Класс, реализующий файловый дескриптор, должен иметь следующие методы:

TIEHANDLE classname, LIST
READ this, scalar, length, offset
READLINE this
GETC this
WRITE this, scalar, length, offset
PRINT this, LIST
PRINTF this, format, LIST
BINMODE this
EOF this
FILENO this
SEEK this, position, whence
TELL this
OPEN this, mode, LIST
CLOSE this
DESTROY this
UNTIE this

Не все перечисленные выше методы должны быть реализованы. См. perltie, Tie::Hash, Tie::Array, Tie::Scalar и Tie::Handle.

В отличие от dbmopen, функция tie не будет use или require модуля за вас; вы должны сделать это явно сами. См. DB_File или модуль Config для интересных реализаций tie.

Для получения более подробной информации см. perltie, tied.

tied VARIABLE

Возвращает ссылку на объект, лежащий в основе VARIABLE (то же самое значение, что и изначально возвращалось вызовом tie, который связал переменную с пакетом). Возвращает undef, если VARIABLE не связана с пакетом.

time

Возвращает количество невисокосных секунд с момента, который система считает началом отсчёта, подходящее для передачи в gmtime и localtime. На большинстве систем началом отсчёта является 00:00:00 UTC, 1 января 1970 года; заметным исключением является Mac OS Classic, которая использует 00:00:00, 1 января 1904 года в текущей часовой зоне для своего начального момента.

Для измерения времени с большей точностью, чем одна секунда, используйте модуль Time::HiRes из Perl 5.8 и далее (или из CPAN до этого), или, если у вас есть gettimeofday(2), вы можете использовать интерфейс syscall Perl. Подробности см. в perlfaq8.

Для обработки дат и времени посмотрите на многие связанные модули в CPAN. Для комплексного представления даты и времени посмотрите на модуль DateTime.

times

Возвращает список из четырёх элементов, содержащий время пользователя и системы в секундах для данного процесса и всех завершившихся дочерних процессов.

my ($user,$system,$cuser,$csystem) = times;

В скалярном контексте times возвращает $user

Время дочерних процессов включается только для завершённых дочерних процессов.

Проблемы с переносимостью: "times" in perlport.

tr///

Оператор транслитерации. То же, что и y///. См. "Quote-Like Operators" in perlop.

truncate FILEHANDLE,LENGTH

truncate EXPR,LENGTH

Усекает файл, открытый в FILEHANDLE или указанный EXPR, до указанной длины. Вызывает исключение, если truncate не реализовано на вашей системе. Возвращает true при успехе, undef при ошибке.

Поведение не определено, если LENGTH больше, чем длина файла.

Позиция в файле FILEHANDLE не изменяется. Перед записью в файл может потребоваться вызов seek.

Проблемы с переносимостью: "truncate" in perlport.

uc EXPR

uc

Возвращает EXPR в верхнем регистре. Если EXPR опущен, используется $_.

my $str = uc("Perl is GREAT"); # "PERL IS GREAT"

Эта функция ведёт себя одинаково под различными пragma, такими как в локали, как и lc.

Если вам нужна регистрация заглавных букв начальных букв, используйте ucfirst.

Примечание: Это внутренняя функция, реализующая escape-последовательность \U в строках с двойными кавычками.

my $str = "Perl is \Ugreat\E"; # "Perl is GREAT"

ucfirst EXPR

ucfirst

Возвращает значение EXPR с первой буквой в верхнем регистре (заглавными буквами в Юникоде). Это внутренняя функция, реализующая escape-последовательность \u в строках с двойными кавычками.

Если EXPR опущен, используется $_.

Эта функция ведёт себя одинаково под различными пragma, такими как в локали, как и lc.

umask EXPR

umask

Устанавливает маску umask для процесса в EXPR и возвращает предыдущее значение. Если EXPR опущен, просто возвращает текущую маску umask.

Разрешения Unix rwxr-x--- представлены в виде трёх наборов из трёх битов или трёх восьмеричных цифр: 0750 (ведущая 0 указывает на восьмеричный формат и не является одной из цифр). Значение umask представляет собой такое число, которое отражает отключенные биты разрешений. Значения разрешений (или "режимов"), которые вы передаёте в mkdir или sysopen, модифицируются вашей маской umask, поэтому даже если вы укажете sysopen создать файл с разрешениями 0777, если ваша маска umask равна 0022, то файл будет фактически создан с разрешениями 0755. Если ваша маска umask была 0027 (группа не может писать; другие не могут читать, писать или выполнять), то передача sysopen 0666 создаст файл с режимом 0640 (потому что 0666 &~ 027 равно 0640).

Вот совет: используйте режим создания 0666 для обычных файлов (в sysopen) и 0777 для каталогов (в mkdir) и исполняемых файлов. Это даёт пользователям свободу выбора: если они хотят защищённые файлы, они могут выбрать маски umask процесса 022, 027 или даже особенно недружелюбную маску 077. Программы редко, если вообще, должны принимать решения по политике, которые лучше оставлять пользователю. Исключением являются файлы, которые должны храниться конфиденциально: файлы почты, файлы cookie веб-браузера, файлы .rhosts и так далее.

Если umask(2) не реализована на вашей системе и вы пытаетесь ограничить доступ для себя (т.е. (EXPR & 0700) > 0), возникает исключение. Если umask(2) не реализована и вы не пытаетесь ограничить доступ для себя, возвращается undef.

Помните, что umask — это число, обычно в восьмеричном формате; это не строка восьмеричных цифр. См. также oct, если у вас есть только строка.

Проблемы с переносимостью: "umask" in perlport.

undef EXPR

undef

Сбрасывает значение EXPR, которое должно быть lvalue. Используйте только со скалярным значением, массивом (используя @), хэш-таблицей (используя %), подпрограммой (используя &) или typeglob (используя *). Выражение undef $hash{$key} вряд ли сделает то, что вы ожидаете, для большинства предопределённых переменных или значений списков DBM, поэтому не используйте его; см. delete. Всегда возвращает неопределённое значение. Вы можете опустить EXPR, в этом случае ничего не будет определено, но вы всё равно получите неопределённое значение, которое, например, можно вернуть из подпрограммы, присвоить переменной или передать в качестве параметра. Примеры:

undef $foo;
undef $bar{'blurfl'};      # Compare to: delete $bar{'blurfl'};
undef @ary;
undef %hash;
undef &mysub;
undef *xyz;       # destroys $xyz, @xyz, %xyz, &xyz, etc.
return (wantarray ? (undef, $errmsg) : undef) if $they_blew_it;
select undef, undef, undef, 0.25;
my ($x, $y, undef, $z) = foo();    # Ignore third value returned

Обратите внимание, что это унарный оператор, а не оператор списка.

unlink LIST

unlink

Удаляет список файлов. При успехе возвращает количество успешно удалённых файлов. При ошибке возвращает false и устанавливает $! (errno):

my $unlinked = unlink 'a', 'b', 'c';
unlink @goners;
unlink glob "*.bak";

В случае ошибки unlink не сообщит вам, какие файлы не удалось удалить. Если вы хотите узнать, какие файлы не удались, попробуйте удалить их по одному:

foreach my $file ( @goners ) {
    unlink $file or warn "Could not unlink $file: $!";
}

Примечание: unlink не попытается удалить каталоги, если вы не являетесь суперпользователем и не указан флаг -U для Perl. Даже если эти условия выполнены, будьте осторожны, что удаление каталога может повредить вашу файловую систему. Наконец, использование unlink для каталогов не поддерживается во многих операционных системах. Используйте rmdir вместо этого.

Если LIST опущен, unlink использует $_.

unpack TEMPLATE,EXPR

unpack TEMPLATE

unpack выполняет обратное действие pack: он принимает строку и разворачивает её в список значений. (В скалярном контексте он возвращает только первое созданное значение.)

Если EXPR опущен, функция 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 бит. Контрольная сумма вычисляется путём суммирования числовых значений расширенных значений (для строковых полей берется сумма ord($char); для полей бит берется сумма нулей и единиц).

Например, следующее вычисляет то же число, что и программа System V sum:

my $checksum = do {
    local $/;  # slurp!
    unpack("%32W*", readline) % 65535;
};

Следующее эффективно подсчитывает количество установленных битов в битовой строке:

my $setbits = unpack("%32b*", $selectmask);

Форматы p и P следует использовать с осторожностью. Поскольку Perl не может проверить, соответствует ли значение, переданное unpack, допустимому месту в памяти, передача значения указателя, которое неизвестно, является допустимым, вероятно, приведёт к катастрофическим последствиям.

Если есть больше кодов упаковки или если число повторений поля или группы больше, чем позволяет оставшаяся часть входной строки, результат не определён: число повторений может быть уменьшено, или unpack может создать пустые строки или нули, или может вызвать исключение. Если входная строка длиннее, чем описано в TEMPLATE, остаток входной строки игнорируется.

См. pack для получения дополнительных примеров и замечаний.

unshift ARRAY,LIST

Делает обратное действие shift. Или обратное действие push, в зависимости от того, как на это посмотреть. Добавляет список в начало массива и возвращает новое количество элементов в массиве.

unshift(@ARGV, '-e') unless $ARGV[0] =~ /^-/;

Обратите внимание, что список добавляется целиком, а не по одному элементу за раз, поэтому добавленные элементы сохраняют свой порядок. Используйте reverse для обратного порядка.

Начиная с Perl 5.14, была экспериментальная возможность, которая позволяла unshift принимать скалярное выражение. Этот эксперимент был признан неудачным и был удален в Perl 5.24.

untie VARIABLE

Разрывает связь между переменной и пакетом. (См. tie.) Не имеет эффекта, если переменная не связана.

use Module VERSION LIST

use Module VERSION

use Module LIST

use Module

Импортирует некоторые семантики в текущий пакет из указанного модуля, обычно путём алиасирования определённых имен подпрограмм или переменных в ваш пакет. Это точно эквивалентно

BEGIN { require Module; Module->import( LIST ); }

за исключением того, что Module обязательно должно быть именем без пробелов. Импорт может быть условным, используя модуль if.

BEGIN заставляет require и import происходить во время компиляции. require гарантирует, что модуль загружен в память, если он ещё не загружен. import не является встроенной функцией; это просто обычный статический вызов метода в пакет Module, чтобы сообщить модулю импортировать список функций обратно в текущий пакет. Модуль может реализовать свой метод import любым способом, хотя большинство модулей просто выбирают выводить свой метод import через наследование от класса Exporter, который определён в модуле Exporter. См. Exporter. Если метод import не найден, вызов пропускается, даже если есть метод AUTOLOAD.

Если вы не хотите вызывать метод пакета import (например, чтобы не изменять ваш пространство имён), явно укажите пустой список:

use Module ();

Это точно эквивалентно

BEGIN { require Module }

Если аргумент VERSION присутствует между Module и LIST, то use вызовет метод VERSION в классе Module с заданной версией в качестве аргумента:

use Module 12.34;

эквивалентно:

BEGIN { require Module; Module->VERSION(12.34) }

метод по умолчанию VERSION, унаследованный от класса UNIVERSAL, выдаёт ошибку, если заданная версия больше, чем значение переменной $Module::VERSION.

Аргумент VERSION не может быть произвольным выражением. Он считается аргументом VERSION только если он представляет собой литерал версии, начинающийся либо с цифры, либо с v и за ней следует цифра. Всё, что не выглядит как литерал версии, будет интерпретировано как начало LIST. Тем не менее, многие попытки использовать произвольное выражение в качестве аргумента VERSION, по-видимому, работают, потому что метод import из Exporter обрабатывает числовые аргументы особым образом, выполняя проверки версий, а не обрабатывая их как то, что нужно экспортировать.

Опять же, существует разница между опущением LIST (import вызывается без аргументов) и явным пустым списком () (import не вызывается). Обратите внимание, что после VERSION нет запятой!

Так как это открытый интерфейс, прагмы (директивы компилятора) также реализуются таким образом. Некоторые из реализованных в настоящее время прагм:

use constant;
use diagnostics;
use integer;
use sigtrap  qw(SEGV BUS);
use strict   qw(subs vars refs);
use subs     qw(afunc blurfl);
use warnings qw(all);
use sort     qw(stable);

Некоторые из этих псевдомодулей импортируют семантику в текущее пространство имён (как strict или integer, в отличие от обычных модулей, которые импортируют символы в текущий пакет (которые эффективны до конца файла).

Поскольку use действует во время компиляции, он не учитывает обычный порядок выполнения компилируемого кода. В частности, размещение use внутри ложного ветвления условного оператора не предотвращает его обработку. Если модуль или прагма должны загружаться только условно, это можно сделать с помощью прагмы if:

use if $] < 5.008, "utf8";
use if WANT_WARNINGS, warnings => qw(all);

Существует соответствующее объявление no, которое отменяет значения, импортированные use, т.е. вызывается Module->unimport(LIST) вместо import. Оно ведёт себя так же, как import с VERSION, опущенным или пустым LIST или если метод unimport не найден.

no integer;
no strict 'refs';
no warnings;

См. perlmodlib для списка стандартных модулей и прагм. См. perlrun для командной строки -M и -m для Perl, которые обеспечивают функциональность use с командной строки.

use VERSION

Лексически включает все доступные в запрошенной версии функции, определенные прагмой feature, и отключает все функции, отсутствующие в наборе функций запрошенной версии. См. feature.

VERSION может быть строкой типа v5.24.1, которая будет сравниваться с $^V (также известна как $PERL_VERSION), или числовым аргументом в формате 5.024001, который будет сравниваться с $]. Если VERSION больше, чем версия текущего интерпретатора Perl, будет поднято исключение; Perl не будет пытаться обработать остальную часть файла. Сравните с require, который может выполнять аналогичную проверку во время выполнения.

Если указанная версия Perl 5.12 или выше, ограничения включаются лексически, как и с use strict. Аналогично, если указанная версия Perl 5.35.0 или выше, включены предупреждения warnings. Позже использование use VERSION переопределит все поведение предыдущей use VERSION, возможно удалив strict, warnings, и feature добавленные ею. use VERSION не загружает файлы feature.pm, strict.pm или warnings.pm.

В текущей реализации любое явное использование use strict или no strict переопределяет use VERSION, даже если оно предшествует ему. Однако это может измениться в будущей версии Perl, поэтому новый код не должен полагаться на этот факт. Рекомендуется, чтобы объявление use VERSION было первым значимым оператором в файле (возможно, после оператора package или любого количества пробелов или комментариев), чтобы его эффекты произошли первыми, а затем применялись другие прагмы.

Указание VERSION как числового аргумента в формате 5.024001 следует в целом избегать, поскольку это более устаревшая и менее читаемая синтаксическая конструкция по сравнению с v5.24.1. До выпуска perl 5.8.0 в 2002 году более громоздкий числовой формат был единственным поддерживаемым синтаксисом, поэтому вы можете увидеть его в более старом коде.

use v5.24.1;    # compile time version check
use 5.24.1;     # ditto
use 5.024_001;  # ditto; older syntax compatible with perl 5.6

Это часто полезно, если вам нужно проверить текущую версию Perl перед use библиотечных модулей, которые не будут работать со старыми версиями Perl. (Мы стараемся не делать этого больше, чем необходимо.)

Симметрично, no VERSION позволяет указать, что вы хотите версию Perl, более старую, чем указанная. Исторически это было добавлено во время ранних проектов языка Raku (ранее "Perl 6"), чтобы программа Perl 5 могла начать

no 6;

заявлять, что она не является программой Perl 6. Поскольку два языка имеют разные реализации, соглашения об именовании файлов и другую инфраструктуру, эта функция сейчас мало используется на практике и следует избегать в новом коде.

Следует проявлять осторожность при использовании формы no VERSION, поскольку она только предназначена для утверждения, что выполняемый Perl имеет более раннюю версию, чем его аргумент, и не для отмены эффектов включения функций в use VERSION.

utime LIST

Изменяет время доступа и изменения для каждого файла в списке файлов. Первые два элемента списка должны быть числовыми временем доступа и изменения, в таком порядке. Возвращает количество успешно изменённых файлов. Время изменения индекса каждого файла устанавливается на текущее время. Например, этот код имеет тот же эффект, что и команда Unix touch(1), когда файлы уже существуют и принадлежат пользователю, выполняющему программу:

#!/usr/bin/perl
my $atime = my $mtime = time;
utime $atime, $mtime, @ARGV;

С Perl 5.8.0, если первые два элемента списка — undef, вызов utime(2) из вашей библиотеки C вызывается с нулевым вторым аргументом. На большинстве систем это установит время доступа и изменения файла на текущее время (т.е., эквивалентно приведенному выше примеру) и будет работать даже на файлах, которые вам не принадлежат, при условии, что у вас есть разрешение на запись:

for my $file (@ARGV) {
    utime(undef, undef, $file)
        || warn "Couldn't touch $file: $!";
}

В NFS это будет время сервера NFS, а не время локальной машины. Если есть проблема со синхронизацией времени, сервер NFS и локальная машина будут иметь разное время. Команда Unix touch(1) фактически обычно использует этот формат вместо показанного в первом примере.

Передача только одного из первых двух элементов как undef эквивалентна передаче 0 и не будет иметь эффекта, описанного при передаче обоих как undef. Это также вызывает предупреждение о неопределённой переменной.

На системах, поддерживающих futimes(2), вы можете передавать дескрипторы файлов среди файлов. На системах, которые не поддерживают futimes(2), передача дескрипторов файлов вызывает исключение. Дескрипторы файлов должны передаваться как шаблоны или ссылки на шаблоны, чтобы быть распознанными; отдельные слова рассматриваются как имена файлов.

Проблемы с переносимостью: "utime" в perlport.

values HASH

values ARRAY

В контексте списка возвращает список, содержащий все значения именованного хэша. В Perl 5.12 или более поздних версиях также вернёт список значений массива; до выпуска этой версии попытка использовать массив в качестве аргумента приведёт к синтаксической ошибке. В скалярном контексте возвращает количество значений.

Элементы хэша возвращаются в, казалось бы, случайном порядке. Фактический случайный порядок специфичен для данного хэша; абсолютно одинаковые последовательности операций над двумя хэшами могут привести к разному порядку для каждого хэша. Любое добавление в хэш может изменить порядок, как и любое удаление, за исключением того, что последний ключ, возвращённый функцией each или keys, может быть удалён без изменения порядка. Пока хэш не изменяется, вы можете полагаться на keys, values и each для повторного возвращения того же порядка друг за другом. См. "Algorithmic Complexity Attacks" в perlsec для получения подробностей о том, почему порядок хэша случайный. Помимо гарантий, предоставленных здесь, точные детали алгоритма хэширования Perl и порядок обхода хэша могут быть изменены в любой версии Perl. Связанные хэши могут вести себя по-другому по сравнению с хэшами Perl в отношении изменений порядка при добавлении и удалении элементов.

В качестве побочного эффекта, вызов values сбрасывает внутренний итератор хэша или массива (см. each) перед возвращением значений. В частности, вызов values в контексте пустоты сбрасывает итератор без дополнительной нагрузки.

За исключением сброса итератора, values @array в контексте списка такое же, как обычное @array. (Мы рекомендуем использовать контекст пустоты keys @array, но посчитали, что исключение values @array потребовало бы больше документации, чем его оставление.)

Обратите внимание, что значения не копируются, что означает, что их изменение повлияет на содержимое хэша:

for (values %hash)      { s/foo/bar/g }  # modifies %hash values
for (@hash{keys %hash}) { s/foo/bar/g }  # same

Начиная с Perl 5.14, экспериментальная функция позволяла values принимать скалярное выражение. Этот эксперимент считается неудачным и был удалён начиная с Perl 5.24.

Чтобы избежать путаницы у потенциальных пользователей вашего кода, использующих более ранние версии Perl, со странными синтаксическими ошибками, поместите эту конструкцию в начало вашего файла, чтобы указать, что ваш код будет работать только в последних версиях Perl:

use v5.12;  # so keys/values/each work on arrays

См. также keys, each и sort.

vec EXPR,OFFSET,BITS

Обрабатывает строку в EXPR как вектор бит, состоящий из элементов шириной BITS, и возвращает значение элемента, заданного OFFSET, как целое без знака. BITS, следовательно, определяет количество бит, зарезервированных для каждого элемента в векторе бит. Это должно быть степенью двойки от 1 до 32 (или 64, если ваша платформа это поддерживает).

Если BITS равен 8, "элементы" совпадают с байтами входной строки.

Если BITS равен 16 или более, байты входной строки группируются в блоки размером BITS/8, и каждый блок преобразуется в число, как в pack/unpack с форматами с большим порядком байтов n/N (и аналогично для BITS==64). См. pack для получения подробностей.

Если bits равно 4 или меньше, строка разбивается на байты, а затем биты каждого байта разбиваются на группы 8/BITS. Бит байта нумеруются в стиле little-endian, как в 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80. Например, разбиение одного входного байта chr(0x36) на две группы даёт список (0x6, 0x3); разбиение на 4 группы даёт (0x2, 0x1, 0x3, 0x0).

vec также может быть присвоено, в этом случае круглые скобки необходимы, чтобы дать выражению правильный приоритет, как в

vec($image, $max_x * $x + $y, 8) = 3;

Если выбранный элемент находится вне строки, возвращается значение 0. Если элементу вне конца строки присваивается значение, Perl сначала расширит строку, добавив достаточное количество нулевых байтов. Ошибка возникает при попытке записи вне начала строки (т.е. отрицательное OFFSET).

Если строка закодирована как UTF-8 внутри (и, следовательно, установлен флаг UTF8), vec пытается преобразовать её в внутреннее представление с одним байтом на символ. Однако если строка содержит символы со значениями 256 или выше, произойдёт фатальная ошибка.

Строки, созданные с помощью vec, также могут быть обработаны логическими операторами |, &, ^, и ~. Эти операторы будут предполагать, что нужно выполнить операцию над вектором бит, когда оба операнда являются строками. См. "Bitwise String Operators" в perlop.

Следующий код создаст строку ASCII, говорящую 'PerlPerlPerl'. Комментарии показывают строку после каждой стадии. Обратите внимание, что этот код работает одинаково на машинах с big-endian или little-endian архитектурой.

my $foo = '';
vec($foo,  0, 32) = 0x5065726C; # 'Perl'

# $foo eq "Perl" eq "\x50\x65\x72\x6C", 32 bits
print vec($foo, 0, 8);  # prints 80 == 0x50 == ord('P')

vec($foo,  2, 16) = 0x5065; # 'PerlPe'
vec($foo,  3, 16) = 0x726C; # 'PerlPerl'
vec($foo,  8,  8) = 0x50;   # 'PerlPerlP'
vec($foo,  9,  8) = 0x65;   # 'PerlPerlPe'
vec($foo, 20,  4) = 2;      # 'PerlPerlPe'   . "\x02"
vec($foo, 21,  4) = 7;      # 'PerlPerlPer'
                               # 'r' is "\x72"
vec($foo, 45,  2) = 3;      # 'PerlPerlPer'  . "\x0c"
vec($foo, 93,  1) = 1;      # 'PerlPerlPer'  . "\x2c"
vec($foo, 94,  1) = 1;      # 'PerlPerlPerl'
                               # 'l' is "\x6c"

Для преобразования вектора бит в строку или список 0 и 1 используйте:

my $bits = unpack("b*", $vector);
my @bits = split(//, unpack("b*", $vector));

Если вы знаете точную длину в битах, она может быть использована вместо *.

Вот пример, иллюстрирующий, как биты на самом деле выстраиваются:

#!/usr/bin/perl -wl

print <<'EOT';
                                  0         1         2         3
                   unpack("V",$_) 01234567890123456789012345678901
------------------------------------------------------------------
EOT

for $w (0..3) {
    $width = 2**$w;
    for ($shift=0; $shift < $width; ++$shift) {
        for ($off=0; $off < 32/$width; ++$off) {
            $str = pack("B*", "0"x32);
            $bits = (1<<$shift);
            vec($str, $off, $width) = $bits;
            $res = unpack("b*",$str);
            $val = unpack("V", $str);
            write;
        }
    }
}

format STDOUT =
vec($_,@#,@#) = @<< == @######### @>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
$off, $width, $bits, $val, $res
.
__END__

Независимо от архитектуры машины, на которой она выполняется, пример выше должен вывести следующую таблицу:

                                  0         1         2         3
                   unpack("V",$_) 01234567890123456789012345678901
------------------------------------------------------------------
vec($_, 0, 1) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 1) = 1   ==          2 01000000000000000000000000000000
vec($_, 2, 1) = 1   ==          4 00100000000000000000000000000000
vec($_, 3, 1) = 1   ==          8 00010000000000000000000000000000
vec($_, 4, 1) = 1   ==         16 00001000000000000000000000000000
vec($_, 5, 1) = 1   ==         32 00000100000000000000000000000000
vec($_, 6, 1) = 1   ==         64 00000010000000000000000000000000
vec($_, 7, 1) = 1   ==        128 00000001000000000000000000000000
vec($_, 8, 1) = 1   ==        256 00000000100000000000000000000000
vec($_, 9, 1) = 1   ==        512 00000000010000000000000000000000
vec($_,10, 1) = 1   ==       1024 00000000001000000000000000000000
vec($_,11, 1) = 1   ==       2048 00000000000100000000000000000000
vec($_,12, 1) = 1   ==       4096 00000000000010000000000000000000
vec($_,13, 1) = 1   ==       8192 00000000000001000000000000000000
vec($_,14, 1) = 1   ==      16384 00000000000000100000000000000000
vec($_,15, 1) = 1   ==      32768 00000000000000010000000000000000
vec($_,16, 1) = 1   ==      65536 00000000000000001000000000000000
vec($_,17, 1) = 1   ==     131072 00000000000000000100000000000000
vec($_,18, 1) = 1   ==     262144 00000000000000000010000000000000
vec($_,19, 1) = 1   ==     524288 00000000000000000001000000000000
vec($_,20, 1) = 1   ==    1048576 00000000000000000000100000000000
vec($_,21, 1) = 1   ==    2097152 00000000000000000000010000000000
vec($_,22, 1) = 1   ==    4194304 00000000000000000000001000000000
vec($_,23, 1) = 1   ==    8388608 00000000000000000000000100000000
vec($_,24, 1) = 1   ==   16777216 00000000000000000000000010000000
vec($_,25, 1) = 1   ==   33554432 00000000000000000000000001000000
vec($_,26, 1) = 1   ==   67108864 00000000000000000000000000100000
vec($_,27, 1) = 1   ==  134217728 00000000000000000000000000010000
vec($_,28, 1) = 1   ==  268435456 00000000000000000000000000001000
vec($_,29, 1) = 1   ==  536870912 00000000000000000000000000000100
vec($_,30, 1) = 1   == 1073741824 00000000000000000000000000000010
vec($_,31, 1) = 1   == 2147483648 00000000000000000000000000000001
vec($_, 0, 2) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 2) = 1   ==          4 00100000000000000000000000000000
vec($_, 2, 2) = 1   ==         16 00001000000000000000000000000000
vec($_, 3, 2) = 1   ==         64 00000010000000000000000000000000
vec($_, 4, 2) = 1   ==        256 00000000100000000000000000000000
vec($_, 5, 2) = 1   ==       1024 00000000001000000000000000000000
vec($_, 6, 2) = 1   ==       4096 00000000000010000000000000000000
vec($_, 7, 2) = 1   ==      16384 00000000000000100000000000000000
vec($_, 8, 2) = 1   ==      65536 00000000000000001000000000000000
vec($_, 9, 2) = 1   ==     262144 00000000000000000010000000000000
vec($_,10, 2) = 1   ==    1048576 00000000000000000000100000000000
vec($_,11, 2) = 1   ==    4194304 00000000000000000000001000000000
vec($_,12, 2) = 1   ==   16777216 00000000000000000000000010000000
vec($_,13, 2) = 1   ==   67108864 00000000000000000000000000100000
vec($_,14, 2) = 1   ==  268435456 00000000000000000000000000001000
vec($_,15, 2) = 1   == 1073741824 00000000000000000000000000000010
vec($_, 0, 2) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 2) = 2   ==          8 00010000000000000000000000000000
vec($_, 2, 2) = 2   ==         32 00000100000000000000000000000000
vec($_, 3, 2) = 2   ==        128 00000001000000000000000000000000
vec($_, 4, 2) = 2   ==        512 00000000010000000000000000000000
vec($_, 5, 2) = 2   ==       2048 00000000000100000000000000000000
vec($_, 6, 2) = 2   ==       8192 00000000000001000000000000000000
vec($_, 7, 2) = 2   ==      32768 00000000000000010000000000000000
vec($_, 8, 2) = 2   ==     131072 00000000000000000100000000000000
vec($_, 9, 2) = 2   ==     524288 00000000000000000001000000000000
vec($_,10, 2) = 2   ==    2097152 00000000000000000000010000000000
vec($_,11, 2) = 2   ==    8388608 00000000000000000000000100000000
vec($_,12, 2) = 2   ==   33554432 00000000000000000000000001000000
vec($_,13, 2) = 2   ==  134217728 00000000000000000000000000010000
vec($_,14, 2) = 2   ==  536870912 00000000000000000000000000000100
vec($_,15, 2) = 2   == 2147483648 00000000000000000000000000000001
vec($_, 0, 4) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 4) = 1   ==         16 00001000000000000000000000000000
vec($_, 2, 4) = 1   ==        256 00000000100000000000000000000000
vec($_, 3, 4) = 1   ==       4096 00000000000010000000000000000000
vec($_, 4, 4) = 1   ==      65536 00000000000000001000000000000000
vec($_, 5, 4) = 1   ==    1048576 00000000000000000000100000000000
vec($_, 6, 4) = 1   ==   16777216 00000000000000000000000010000000
vec($_, 7, 4) = 1   ==  268435456 00000000000000000000000000001000
vec($_, 0, 4) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 4) = 2   ==         32 00000100000000000000000000000000
vec($_, 2, 4) = 2   ==        512 00000000010000000000000000000000
vec($_, 3, 4) = 2   ==       8192 00000000000001000000000000000000
vec($_, 4, 4) = 2   ==     131072 00000000000000000100000000000000
vec($_, 5, 4) = 2   ==    2097152 00000000000000000000010000000000
vec($_, 6, 4) = 2   ==   33554432 00000000000000000000000001000000
vec($_, 7, 4) = 2   ==  536870912 00000000000000000000000000000100
vec($_, 0, 4) = 4   ==          4 00100000000000000000000000000000
vec($_, 1, 4) = 4   ==         64 00000010000000000000000000000000
vec($_, 2, 4) = 4   ==       1024 00000000001000000000000000000000
vec($_, 3, 4) = 4   ==      16384 00000000000000100000000000000000
vec($_, 4, 4) = 4   ==     262144 00000000000000000010000000000000
vec($_, 5, 4) = 4   ==    4194304 00000000000000000000001000000000
vec($_, 6, 4) = 4   ==   67108864 00000000000000000000000000100000
vec($_, 7, 4) = 4   == 1073741824 00000000000000000000000000000010
vec($_, 0, 4) = 8   ==          8 00010000000000000000000000000000
vec($_, 1, 4) = 8   ==        128 00000001000000000000000000000000
vec($_, 2, 4) = 8   ==       2048 00000000000100000000000000000000
vec($_, 3, 4) = 8   ==      32768 00000000000000010000000000000000
vec($_, 4, 4) = 8   ==     524288 00000000000000000001000000000000
vec($_, 5, 4) = 8   ==    8388608 00000000000000000000000100000000
vec($_, 6, 4) = 8   ==  134217728 00000000000000000000000000010000
vec($_, 7, 4) = 8   == 2147483648 00000000000000000000000000000001
vec($_, 0, 8) = 1   ==          1 10000000000000000000000000000000
vec($_, 1, 8) = 1   ==        256 00000000100000000000000000000000
vec($_, 2, 8) = 1   ==      65536 00000000000000001000000000000000
vec($_, 3, 8) = 1   ==   16777216 00000000000000000000000010000000
vec($_, 0, 8) = 2   ==          2 01000000000000000000000000000000
vec($_, 1, 8) = 2   ==        512 00000000010000000000000000000000
vec($_, 2, 8) = 2   ==     131072 00000000000000000100000000000000
vec($_, 3, 8) = 2   ==   33554432 00000000000000000000000001000000
vec($_, 0, 8) = 4   ==          4 00100000000000000000000000000000
vec($_, 1, 8) = 4   ==       1024 00000000001000000000000000000000
vec($_, 2, 8) = 4   ==     262144 00000000000000000010000000000000
vec($_, 3, 8) = 4   ==   67108864 00000000000000000000000000100000
vec($_, 0, 8) = 8   ==          8 00010000000000000000000000000000
vec($_, 1, 8) = 8   ==       2048 00000000000100000000000000000000
vec($_, 2, 8) = 8   ==     524288 00000000000000000001000000000000
vec($_, 3, 8) = 8   ==  134217728 00000000000000000000000000010000
vec($_, 0, 8) = 16  ==         16 00001000000000000000000000000000
vec($_, 1, 8) = 16  ==       4096 00000000000010000000000000000000
vec($_, 2, 8) = 16  ==    1048576 00000000000000000000100000000000
vec($_, 3, 8) = 16  ==  268435456 00000000000000000000000000001000
vec($_, 0, 8) = 32  ==         32 00000100000000000000000000000000
vec($_, 1, 8) = 32  ==       8192 00000000000001000000000000000000
vec($_, 2, 8) = 32  ==    2097152 00000000000000000000010000000000
vec($_, 3, 8) = 32  ==  536870912 00000000000000000000000000000100
vec($_, 0, 8) = 64  ==         64 00000010000000000000000000000000
vec($_, 1, 8) = 64  ==      16384 00000000000000100000000000000000
vec($_, 2, 8) = 64  ==    4194304 00000000000000000000001000000000
vec($_, 3, 8) = 64  == 1073741824 00000000000000000000000000000010
vec($_, 0, 8) = 128 ==        128 00000001000000000000000000000000
vec($_, 1, 8) = 128 ==      32768 00000000000000010000000000000000
vec($_, 2, 8) = 128 ==    8388608 00000000000000000000000100000000
vec($_, 3, 8) = 128 == 2147483648 00000000000000000000000000000001

wait

Ведёт себя как wait(2) на вашей системе: ожидает завершения дочернего процесса и возвращает pid умершего процесса, или -1 , если нет дочерних процессов. Статус возвращается в $? и ${^CHILD_ERROR_NATIVE}. Обратите внимание, что возвращаемое значение -1 может означать, что дочерние процессы автоматически собираются, как описано в perlipc.

Если вы используете wait в своём обработчике для $SIG{CHLD}, это может случайно подождать дочерний процесс, созданный qx или system. Подробности см. в perlipc.

Проблемы переносимости: "wait" в perlport.

waitpid PID,FLAGS

Ожидает завершения конкретного дочернего процесса и возвращает pid умершего процесса, или -1 , если такого дочернего процесса нет. Неблокирующее ожидание (с WNOHANG в FLAGS) может вернуть 0, если есть дочерние процессы, соответствующие PID, но ни один из них ещё не завершился. Статус возвращается в $? и ${^CHILD_ERROR_NATIVE}.

PID со значением 0 указывает на ожидание любого дочернего процесса, у которого идентификатор группы процессов равен идентификатору группы процессов текущего процесса. PID со значением меньше -1 указывает на ожидание любого дочернего процесса, у которого идентификатор группы процессов равен -PID. PID со значением -1 указывает на ожидание любого дочернего процесса.

Если вы пишете

use POSIX ":sys_wait_h";

my $kid;
do {
    $kid = waitpid(-1, WNOHANG);
} while $kid > 0;

или

1 while waitpid(-1, WNOHANG) > 0;

тогда вы можете выполнить неблокирующее ожидание всех ожидающих процессов-зомби (см. "WAIT" в POSIX). Неблокирующее ожидание доступно на машинах, поддерживающих системные вызовы waitpid(2) или wait4(2). Однако ожидание конкретного pid со значением FLAGS 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, используя формат, связанный с этим файлом. По умолчанию формат для файла - тот, который имеет то же имя, что и filehandle, но формат для текущего выходного канала (см. функцию select) можно явно задать, присвоив имя формата переменной $~.

Обработка верхней части формы выполняется автоматически: если для отформатированного записываемого блока недостаточно места на текущей странице, страница продвигается, записывая символ подачи формы и используется специальный формат верхней части страницы для форматирования нового заголовка страницы перед записью блока. По умолчанию, формат верхней части страницы - имя filehandle с добавленным _TOP, или top в текущем пакете, если первого не существует. Это может быть проблемой с автовивифицированными filehandle, но его можно динамически установить на нужный вам формат, присвоив имя переменной $^, в то время как этот filehandle выбран. Количество строк, оставшихся на текущей странице, находится в переменной $-, которую можно установить на 0 для принудительного создания новой страницы.

Если FILEHANDLE не указан, вывод идёт в текущий выходной канал по умолчанию, который по умолчанию STDOUT, но может быть изменён оператором select. Если FILEHANDLE является EXPR, то выражение вычисляется, а полученная строка используется для поиска имени FILEHANDLE во время выполнения. Дополнительную информацию о форматах см. в perlform.

Обратите внимание, что write не является противоположностью read. К сожалению.

y///

Оператор транслитерации. То же, что и tr///. См. "Операторы, похожие на кавычки" в perlop.

Нефункциональные ключевые слова по перекрестной ссылке

perldata

__DATA__

__END__

Эти ключевые слова описаны в "Специальные литералы" в perldata.

perlmod

BEGIN

CHECK

END

INIT

UNITCHECK

Эти ключевые слова фазы компиляции описаны в "BEGIN, UNITCHECK, CHECK, INIT и END" в perlmod.

perlobj

DESTROY

Это ключевое слово метода описано в "Деструкторы" в perlobj.

perlop

and

cmp

eq

ge

gt

isa

le

lt

ne

not

or

x

xor

Эти операторы описаны в perlop.

perlsub

AUTOLOAD

Это ключевое слово описано в "Автозагрузка" в perlsub.

perlsyn

else

elsif

for

foreach

if

unless

until

while

Эти ключевые слова управления потоком описаны в "Составные операторы" в perlsyn.

elseif

Ключевое слово "else if" пишется как elsif в Perl. Нет elif или else if. Оно анализируется elseif, но только чтобы предупредить вас о его неправильном использовании.

См. документацию по ключевым словам управления потоком в "Составные операторы" в perlsyn.

default

given

when

Эти ключевые слова управления потоком, связанные с экспериментальной функцией переключения, описаны в "Операторы переключения" в perlsyn.

try

catch

finally

Эти ключевые слова управления потоком, связанные с экспериментальной функцией try, описаны в "Обработка исключений try-catch" в perlsyn.

defer

Это ключевое слово управления потоком, связанное с экспериментальной функцией defer, описано в "блоки defer" в perlsyn.