Spec-Zone.ru › Perl 5.38

perlvar

СОДЕРЖАНИЕ

  • ИМЯ
  • ОПИСАНИЕ
    • Синтаксис имён переменных
  • СПЕЦИАЛЬНЫЕ ПЕРЕМЕННЫЕ
    • Общие переменные
    • Переменные, связанные с регулярными выражениями
      • Правила области действия переменных регулярных выражений
      • Проблемы производительности
    • Переменные, связанные с дескрипторами файлов
      • Переменные, связанные с форматами
    • Переменные ошибок
    • Переменные, связанные с состоянием интерпретатора
    • Устаревшие и удалённые переменные

ИМЯ

perlvar - Предопределённые переменные Perl

ОПИСАНИЕ

Синтаксис имён переменных

Имена переменных в Perl могут иметь несколько форматов. Обычно они должны начинаться с буквы или подчёркивания, после чего могут быть произвольно длинными (до внутреннего ограничения в 251 символ) и содержать буквы, цифры, подчёркивания или специальную последовательность :: или '. В этом случае часть перед последним :: или ' рассматривается как квалификатор пакета; см. perlmod. Буква Юникода, которая не является ASCII, не считается буквой, если "use utf8" не активна, и применяются несколько более сложные правила; см. "Разбор идентификаторов" в perldata для получения подробной информации.

Имена переменных Perl также могут быть последовательностью цифр, одиночным символом пунктуации или двухсимвольной последовательностью: ^ (крышка или знак CIRCUMFLEX ACCENT) за которым следует любой из символов [][A-Z^_?\]. Эти имена зарезервированы для специального использования в Perl; например, имена, состоящие только из цифр, используются для хранения данных, захваченных обратными ссылками после сопоставления с регулярным выражением.

Начиная с Perl v5.6.0, имена переменных Perl также могут быть алфавитно-цифровыми строками, предваряемыми крышкой. Все они должны быть записаны с использованием обозначенного формата переменной с использованием фигурных скобок, например ${^Foo}; фигурные скобки не являются необязательными. ${^Foo} обозначает скалярную переменную, имя которой считается контрольным F последовательностью из двух o (см. "Имена обозначенных переменных в фигурных скобках" в perldata для получения дополнительной информации о форматах написания имён переменных или указания доступа к элементу массива или хэша). Эти переменные зарезервированы для будущих специальных применений в Perl, за исключением тех, которые начинаются с ^_ (крышка-подчёркивание). Ни одно имя, начинающееся с ^_, не приобретёт особого значения в будущих версиях Perl; такие имена, следовательно, могут безопасно использоваться в программах. $^_ сам по себе, однако, зарезервирован.

Обратите внимание, что вы должны использовать обозначенный формат для доступа к индексам переменных этого типа при интерполяции, например, для доступа к первому элементу переменной @{^CAPTURE} внутри строки с двойными кавычками вы должны написать "${^CAPTURE[0]}", а НЕ "${^CAPTURE}[0]", что означало бы обращение к скалярной переменной с именем ${^CAPTURE} а не к индексу 0 магического массива @{^CAPTURE}, который заполняется движком регулярных выражений.

Идентификаторы Perl, начинающиеся с цифр или знаков препинания, освобождены от действия объявления package и всегда принудительно размещаются в пакете main; они также освобождены от ошибок strict 'vars'. Некоторые другие имена также освобождены от этих ограничений:

ENV      STDIN
INC      STDOUT
ARGV     STDERR
ARGVOUT
SIG

В частности, специальные ${^_XYZ} переменные всегда размещаются в пакете main, независимо от любых package объявлений, имеющихся в данный момент.

СПЕЦИАЛЬНЫЕ ПЕРЕМЕННЫЕ

Следующие имена имеют специальное значение для Perl. Большинство имён, состоящих из знаков препинания, имеют разумные мнемонические обозначения или аналоги в оболочках. Тем не менее, если вы хотите использовать длинные имена переменных, вам нужно только сказать:

use English;

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

Перед продолжением обратите внимание на порядок сортировки переменных. В общем случае, сначала мы перечисляем переменные в порядке, приближающемся к лексикографическому, не учитывая регистр (игнорируя слова { или ^, как в ${^UNICODE} или $^T), хотя $_ и @_ поднимаются на верхнюю позицию. В случае переменных с одинаковым идентификатором, мы перечисляем их в порядке скаляр, массив, хеш и неприводимое слово.

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

$ARG
$_

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

while (<>) {...}    # equivalent only in while!
while (defined($_ = <>)) {...}

/^Subject:/
$_ =~ /^Subject:/

tr/a-z/A-Z/
$_ =~ tr/a-z/A-Z/

chomp
chomp($_)

Вот места, где Perl будет предполагать $_, даже если вы его не используете:

  • Следующие функции используют $_ в качестве аргумента по умолчанию:

    abs, alarm, chomp, chop, chr, chroot, cos, defined, eval, evalbytes, exp, fc, glob, hex, int, lc, lcfirst, length, log, lstat, mkdir, oct, ord, pos, print, printf, quotemeta, readlink, readpipe, ref, require, reverse (только в скалярном контексте), rmdir, say, sin, split (для его второго аргумента), sqrt, stat, study, uc, ucfirst, unlink, unpack.

  • Все тесты файлов (-f, -d) за исключением -t, которое по умолчанию равно STDIN. См. "-X" в perlfunc

  • Операции сопоставления с образцом m//, s/// и tr/// (также известные как y///) при использовании без оператора =~.

  • Переменная-итератор по умолчанию в цикле foreach, если не указана другая переменная.

  • Неявная переменная-итератор в функциях grep() и map().

  • Неявная переменная given().

  • Место, куда помещается следующее значение или запись ввода, когда результат операции <FH>, readline, readdir или each проверяется сама по себе как единственное условие теста while. За пределами теста while это не произойдёт.

$_ — это глобальная переменная.

Однако между версиями Perl v5.10.0 и v5.24.0 она могла использоваться лексически, написав my $_. Тогда можно было сделать так, чтобы $_ ссылалась на глобальную $_ в том же блоке с помощью our $_. Эта экспериментальная функция была удалена и теперь является фатальной ошибкой, но вы можете встретить её в старом коде.

Мнемоника: подчеркивание понимается в определённых операциях.

@ARG
@_

Внутри подпрограммы массив @_ содержит параметры, переданные этому подпрограмме. Внутри подпрограммы @_ — это массив по умолчанию для операторов массива pop и shift.

См. perlsub.

$LIST_SEPARATOR
$"

Когда массив или срез массива интерполируется в строку с двойными кавычками или подобный контекст, например, /.../, его элементы разделяются этим значением. Значение по умолчанию — пробел. Например, это:

print "The array is: @array\n";

эквивалентно этому:

print "The array is: " . join($", @array) . "\n";

Мнемоника: работает в контексте двойных кавычек.

$PROCESS_ID
$PID
$$

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

Примечание для пользователей Linux и Debian GNU/kFreeBSD: До версии Perl v5.16.0 perl эмулировал семантику POSIX на системах Linux, используя LinuxThreads, частичную реализацию POSIX Threads, которая с тех пор была заменена на Native POSIX Thread Library (NPTL).

LinuxThreads теперь устарел на Linux, и кеширование getpid() таким образом делало встраивание perl излишне сложным (поскольку вам пришлось бы вручную обновлять значение $$), поэтому теперь $$ и getppid() всегда возвращают те же значения, что и базовая библиотека C.

Системы Debian GNU/kFreeBSD также использовали LinuxThreads до версии 6.0 включительно, но после этого перешли к семантике потоков FreeBSD, которая похожа на POSIX.

Чтобы узнать, влияет ли эта несогласованность на вашу систему, проверьте, возвращает ли getconf GNU_LIBPTHREAD_VERSION | grep -q NPTL ложное значение. Потоки NTPL сохраняют семантику POSIX.

Мнемоника: аналогично оболочкам.

$PROGRAM_NAME
$0

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

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

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

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

Примечание для пользователей BSD: установка $0 не полностью удаляет "perl" из вывода ps(1). Например, установка $0 в "foobar" может привести к "perl: foobar (perl)" (показ префикса "perl: " и суффикса "(perl)" зависит от вашей конкретной версии и разновидности BSD). Это функция операционной системы, Perl не может ей помочь.

В многопоточных скриптах Perl координирует потоки таким образом, что любой поток может изменить свою копию $0 и изменение станет видимым для ps(1) (если операционная система играет по правилам). Обратите внимание, что вид $0 у других потоков не изменится, поскольку у них есть свои копии.

Если программе был передан perl через переключатели -e или -E, $0 будет содержать строку "-e".

В Linux начиная с версии perl v5.14.0 имя процесса в старом формате будет устанавливаться с помощью prctl(2), кроме изменения имени POSIX с помощью argv[0], как это делается в perl с версии 4.000. Теперь системные утилиты, которые считывают имя процесса в старом формате, такие как ps, top и killall, будут распознавать имя, которое вы установили, присваивая значение $0. Строка, которую вы предоставляете, будет обрезана до 16 байтов, это ограничение, наложенное Linux.

Широкие символы недопустимы в значениях $0. Однако по историческим причинам Perl их принимает и кодирует в UTF-8. В этом случае генерируется предупреждение о широком символе.

Мнемоника: аналогично sh и ksh.

$REAL_GROUP_ID
$GID
$(

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

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

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

Мнемоника: круглые скобки используются для группирования вещей. Действительная группа — это группа, из которой вы вышли, если вы запускаете setgid.

$EFFECTIVE_GROUP_ID
$EGID
$)

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

Аналогично, значение, присвоенное $), также должно быть списком чисел, разделённых пробелами. Первое число устанавливает эффективную группу, а остальные (если есть) передаются в setgroups(). Чтобы получить эффект пустого списка для setgroups(), просто повторите новое значение эффективной группы; то есть, чтобы принудительно установить эффективную группу 5 и эффективно пустой список setgroups(), скажите $) = "5 5" .

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

$<, $>, $( и $) могут быть установлены только на машинах, которые поддерживают соответствующую процедуру set[re][ug]id(). $( и $) могут быть переключены только на машинах, поддерживающих setregid().

Мнемоника: круглые скобки используются для группирования вещей. Эффективная группа — это группа, которая подходит для вас, если вы используете setgid.

$REAL_USER_ID
$UID
$<

Действительный uid этого процесса. Вы можете изменить и действительный, и эффективный uid одновременно, используя POSIX::setuid(). Поскольку изменения в $< требуют системного вызова, проверьте $! после попытки изменения, чтобы обнаружить возможные ошибки.

Мнемоника: это uid, из которого вы пришли, если вы используете setuid.

$EFFECTIVE_USER_ID
$EUID
$>

Эффективный uid этого процесса. Например:

$< = $>;            # set real to effective uid
($<,$>) = ($>,$<);  # swap real and effective uids

Вы можете изменить и эффективный, и действительный uid одновременно, используя POSIX::setuid(). Изменения в $> требуют проверки $! для обнаружения возможных ошибок после попытки изменения.

$< и $> могут быть переключены только на машинах, поддерживающих setreuid().

Мнемоника: это uid, к которому вы перешли, если вы используете setuid.

$SUBSCRIPT_SEPARATOR
$SUBSEP
$;

Разделитель индексов для эмуляции многомерных массивов. Если вы ссылаетесь на элемент хэша как

$foo{$x,$y,$z}

он на самом деле означает

$foo{join($;, $x, $y, $z)}

Но не ставьте

@foo{$x,$y,$z}     # a slice--note the @

что означает

($foo{$x},$foo{$y},$foo{$z})

Значение по умолчанию — "\034", то же, что и SUBSEP в awk. Если ваши ключи содержат двоичные данные, может не быть безопасного значения для $;.

Рассмотрите возможность использования "настоящих" многомерных массивов, как описано в perllol.

Мнемоника: запятая (синтаксический разделитель индексов) — это полудвоеточие.

$a
$b

Специальные переменные пакета при использовании sort(), см. "sort" в perlfunc. Из-за этой специфики $a и $b не нужно объявлять (используя use vars, или our()) даже при использовании псевдонима strict 'vars'. Не нужно лексически их объявлять с my $a или my $b, если вы хотите использовать их в блоке сравнения sort() или функции.

%ENV

Хэш %ENV содержит вашу текущую среду. Установка значения в ENV изменяет среду для всех дочерних процессов, которые вы впоследствии fork().

Начиная с v5.18.0, как ключи, так и значения, хранящиеся в %ENV, строятся.

my $foo = 1;
$ENV{'bar'} = \$foo;
if( ref $ENV{'bar'} ) {
    say "Pre 5.18.0 Behaviour";
} else {
    say "Post 5.18.0 Behaviour";
}

Ранее только дочерние процессы получали строковые значения:

my $foo = 1;
$ENV{'bar'} = \$foo;

# Always printed 'non ref'
system($^X, '-e',
       q/print ( ref $ENV{'bar'}  ? 'ref' : 'non ref' ) /);

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

$OLD_PERL_VERSION
$]

Ревизия, версия и подверсия интерпретатора Perl, представленная как десятичная дробь в формате 5.XXXYYY, где XXX — версия / 1e3, а YYY — подверсия / 1e6. Например, Perl v5.10.1 будет "5.010001".

Эту переменную можно использовать для определения, находится ли интерпретатор Perl, выполняющий скрипт, в нужном диапазоне версий:

warn "No PerlIO!\n" if "$]" < 5.008;

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

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

См. "$^V" для представления версии Perl в виде объекта version, что позволяет проводить более гибкие строковые сравнения.

Основное преимущество $] перед $^V заключается в том, что она работает одинаково на любой версии Perl. Недостатки заключаются в том, что её нельзя легко сравнить с версиями в других форматах (например, буквальными строками v, "v1.2.3" или объектами версии), а числовые сравнения зависят от двоичной плавающей точки; она подходит для проверки числовых версий и не подходит для сравнения с переменной, которая не была проверена на корректность.

Формат $OLD_PERL_VERSION был добавлен в Perl v5.20.0 по историческим причинам, но его использование не рекомендуется. (Если ваша цель использования $] — запуск кода на старых версиях Perl, то ссылка на $OLD_PERL_VERSION будет самообманчивой.)

Мнемоника: Находится ли эта версия Perl в нужном диапазоне?

$SYSTEM_FD_MAX
$^F

Максимальный системный дескриптор файла, обычно 2. Системные дескрипторы файлов передаются в exec() процессы, в то время как дескрипторы файлов выше не передаются. Также, во время open(), системные дескрипторы файлов сохраняются, даже если open() завершается неудачно (обычные дескрипторы файлов закрываются перед попыткой open()). Статус закрытия дескриптора файла для выполнения будет определяться в соответствии со значением $^F во время открытия соответствующего файла, канала или сокета, а не во время exec().

@F

Массив @F содержит поля каждой строки, прочитанной при включении режима авторазбиения. См. perlrun для параметра -a. Этот массив специфичен для пакета и должен быть объявлен или иметь полное имя пакета, если он не находится в пакете main при выполнении под strict 'vars'.

@INC

Массив @INC содержит список мест, где do EXPR, require, или use конструкции ищут свои файлы библиотек. Изначально он состоит из аргументов любого флага -I командной строки, за которыми следует стандартная библиотека Perl, вероятно, /usr/local/lib/perl. До Perl 5.26, . (который представляет текущий каталог), был включен в @INC; он был удален. Это изменение поведения документировано в PERL_USE_UNSAFE_INC, и не рекомендуется добавлять . обратно в @INC. Если вам нужно изменить @INC во время выполнения, вы должны использовать псевдоним use lib для правильной загрузки машинозависимой библиотеки:

use lib '/mypath/libdir/';
use SomeMod;

Вы также можете вставить обработчики в систему включения файлов, поместив Perl-код непосредственно в @INC. Эти обработчики могут быть ссылками на подпрограммы, ссылками на массивы или освящёнными объектами. См. "require" в perlfunc для подробностей.

%INC

Хэш %INC содержит записи для каждого файла, включённого операторами do, require, или use. Ключом является имя файла, который вы указали (с именами модулей, преобразованными в имена путей), а значением — расположение найденного файла. Оператор require использует этот хэш для определения, был ли уже включён определённый файл.

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

$INC

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

Обычно обход массива @INC осуществляется от начала к концу (0 .. $#INC), и если массив @INC изменяется обработчиком, итератор может остаться в состоянии, когда недавно добавленные элементы пропускаются. Изменение этого значения позволяет обработчику @INC переписать массив @INC и указать Perl, где продолжить позже. См. "require" в perlfunc для подробностей об обработчиках @INC.

$INPLACE_EDIT
$^I

Текущее значение расширения редактирования на месте. Используйте undef для отключения редактирования на месте.

Мнемоника: значение параметра -i.

@ISA

Каждый пакет содержит специальный массив, называемый @ISA, который содержит список родительских классов этого класса, если таковые имеются. Этот массив — просто список скаляров, каждый из которых — строка, соответствующая имени пакета. Массив проверяется, когда Perl выполняет разрешение методов, что описано в perlobj.

Для загрузки пакетов при добавлении их в @ISA, см. псевдоним parent. Не рекомендуемый псевдоним base делает то же самое, но его не следует использовать, кроме случаев, когда требуется совместимость с нерекомендуемым псевдонимом fields.

$^M

По умолчанию, недостаток памяти — это непреодолимая, фатальная ошибка. Однако, если Perl был должным образом скомпилирован, он может использовать содержимое $^M в качестве резервного пула памяти после die()рования. Предположим, что ваш Perl был скомпилирован с -DPERL_EMERGENCY_SBRK и использовал malloc Perl. Тогда

$^M = 'a' x (1 << 16);

выделит буфер размером 64 КБ для использования в чрезвычайных ситуациях. См. файл INSTALL в дистрибутиве Perl для получения информации о том, как добавить пользовательские флаги компиляции C при компиляции Perl. Чтобы не поощрять случайное использование этого расширенного функционала, нет длинного русского названия для этой переменной.

Эта переменная была добавлена в Perl 5.004.

${^MAX_NESTED_EVAL_BEGIN_BLOCKS}

Эта переменная определяет максимальное количество eval EXPR/BEGIN или require/BEGIN блоков вложенности, которые разрешены. Это означает, что она также контролирует максимальную вложенность операторов use.

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

Если значение установлено в 0, то блоки BEGIN внутри eval EXPR или require EXPR запрещены полностью и приведут к исключению, которое завершит компиляцию. В случае require, будет выброшено исключение, а в случае eval, ошибка вернётся в $@ как обычно.

Рассмотрим код

perl -le'sub f { eval "BEGIN { f() }"; } f()'

каждое обращение к f() будет потреблять значительную часть стека C, и эта переменная используется, чтобы привести такой код к завершению вместо исчерпания стека C и возникновения сегфолта. Излишне говорить, что код такого рода не характерен; маловероятно, что вам действительно потребуется увеличить значение. Однако может быть полезно установить его в 0 на ограниченное время, чтобы предотвратить выполнение блоков BEGIN{} во время eval EXPR.

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

BEGIN { $n += 1; BEGIN { $n += 2; BEGIN { $n += 4 } } }

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

BEGIN { $n+=4 }
BEGIN { $n+=2 }
BEGIN { $n+=1 }

что делает очевидным, почему значение ${^MAX_EVAL_BEGIN_DEPTH} равное 1 не заблокирует этот код.

Только BEGIN блоки, выполняемые внутри eval или require (возможно, через use), затрагиваются.

$OSNAME
$^O

Имя операционной системы, под которой была построена эта копия Perl, определённое во время процесса конфигурации. Примеры см. в "PLATFORMS" в perlport.

Значение идентично $Config{'osname'}. См. также Config и флаг командной строки -V, описанный в perlrun.

В платформах Windows $^O не очень полезен: так как он всегда MSWin32, он не различает 95/98/ME/NT/2000/XP/CE/.NET. Используйте Win32::GetOSName() или Win32::GetOSVersion() (см. Win32 и perlport) для различения вариантов.

Эта переменная была добавлена в Perl 5.003.

%SIG

Хэш %SIG содержит обработчики сигналов для сигналов. Например:

sub handler {   # 1st argument is signal name
    my($sig) = @_;
    print "Caught a SIG$sig--shutting down\n";
    close(LOG);
    exit(0);
}

$SIG{'INT'}  = \&handler;
$SIG{'QUIT'} = \&handler;
...
$SIG{'INT'}  = 'DEFAULT';   # restore default action
$SIG{'QUIT'} = 'IGNORE';    # ignore SIGQUIT

Использование значения 'IGNORE' обычно приводит к игнорированию сигнала, за исключением сигнала CHLD. См. perlipc для получения дополнительной информации об этом специальном случае. Использование пустой строки или undef в качестве значения имеет тот же эффект, что и 'DEFAULT'.

Вот некоторые другие примеры:

$SIG{"PIPE"} = "Plumber";   # assumes main::Plumber (not
                            # recommended)
$SIG{"PIPE"} = \&Plumber;   # just fine; assume current
                            # Plumber
$SIG{"PIPE"} = *Plumber;    # somewhat esoteric
$SIG{"PIPE"} = Plumber();   # oops, what did Plumber()
                            # return??

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

Использование строки, которая не соответствует никакой существующей функции, или шаблона, который не содержит слота кода, эквивалентно 'IGNORE', но при вызове обработчика выводится предупреждение (предупреждение не выводится для внутренних обработчиков, описанных ниже).

Если на вашей системе доступна функция sigaction(), то обработчики сигналов устанавливаются с её помощью. Это обеспечивает надёжную обработку сигналов.

Политика по умолчанию для доставки сигналов в Perl v5.8.0 изменилась с немедленной (также известной как «небезопасная») на отложенную, также известную как «безопасные сигналы». Подробнее см. perlipc.

Некоторые внутренние обработчики также могут быть установлены с помощью хэша %SIG. Процедура, указанная $SIG{__WARN__}, вызывается при появлении сообщения об ошибке. Сообщение об ошибке передается в качестве первого аргумента. Наличие обработчика __WARN__ подавляет обычный вывод предупреждений в STDERR. Это можно использовать для сохранения предупреждений в переменной или преобразования предупреждений в фатальные ошибки, как показано ниже:

local $SIG{__WARN__} = sub { die $_[0] };
eval $proggie;

Поскольку обработчик 'IGNORE' не поддерживается __WARN__, его эффект эквивалентен использованию 'DEFAULT'. Предупреждения можно отключить, используя пустую подпрограмму:

local $SIG{__WARN__} = sub {};

Процедура, указанная $SIG{__DIE__}, вызывается при появлении фатальной исключительной ситуации. Сообщение об ошибке передается в качестве первого аргумента. Когда обработчик __DIE__ возвращает управление, обработка исключений продолжается так же, как и без обработчика, если только сам обработчик не завершится с помощью goto &sub, выхода из цикла или die(). Обработчик __DIE__ явно отключен во время вызова, чтобы вы могли завершить работу из обработчика __DIE__. То же самое касается __WARN__.

Обработчик $SIG{__DIE__} вызывается даже внутри eval(). Этого не должно было происходить, но ошибка реализации позволила это. Раньше это было устаревшим, так как позволяло странные действия на расстоянии, такие как переписывание ожидаемого исключения в $@. Планы по исправлению были отменены, так как пользователи обнаружили, что переписывание ожидаемого исключения — это полезная функция, а не ошибка.

Обработчик $SIG{__DIE__} не поддерживает 'IGNORE'; его действие такое же, как у 'DEFAULT'.

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

require Carp if defined $^S;
Carp::confess("Something wrong") if defined &Carp::confess;
die "Something wrong, but could not load Carp to give "
  . "backtrace...\n\t"
  . "To see backtrace try starting Perl with -MCarp switch";

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

Необходимость думать о переменной $^S в обработчиках исключений — это ошибка. $SIG{__DIE__} в текущей реализации способствует возникновению серьёзных и трудно отслеживаемых ошибок. Избегайте этого и вместо этого используйте переопределение END{} или CORE::GLOBAL::die.

См. "die" в perlfunc, "warn" в perlfunc, "eval" в perlfunc и warnings для получения дополнительной информации.

%{^HOOK}

Этот хэш содержит ссылки на код, которые вызываются при вызове различных ключевых слов Perl, которые трудно или невозможно обернуть. Ключи этого хэша названы по имени ключевого слова, за которым следуют два подчёркивания и термин фазы; либо «before» (до), либо «after» (после).

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

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

require__before

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

Для облегчения выполнения действий с общим состоянием как до, так и после выполнения ключевого слова «require», обработчик require__before может возвращать ссылку на код «последействия», который в свою очередь будет выполнен при завершении require. Эта ссылка на код будет выполнена независимо от того, завершился ли require успешно или с ошибкой. Она будет вызвана с именем требуемого файла. Вы можете проверить %INC, чтобы определить, выполнилась ли загрузка успешно. Любой другой возврат из обработчика require__before будет проигнорирован.

Обработчики require__before вызываются в порядке очереди FIFO, а если обработчик возвращает ссылку на код, эти ссылки на код будут вызваны в порядке очереди FILO. Другими словами, если A требует B, а B требует C, то require__before будет вызван сначала для A, затем для B и затем для C, а ссылка на код «последействия» будет выполнена сначала для C, затем для B и затем для A.

Хорошо написанный код должен обеспечить, чтобы при настройке обработчика require__before любой ранее установленный обработчик был вызван, и что его возвращаемое значение, если это ссылка на код, также будет вызвано. См. "require" в perlfunc для примера реализации.

require__after

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

Обработчик require__after вызывается для каждого загруженного файла в обратном порядке (FILO). Другими словами, если A требует B, а B требует C, то require__after будет вызван сначала для C, затем для B и затем для A.

$BASETIME
$^T

Время начала выполнения программы в секундах с начала эпохи (начала 1970 года). Значения, возвращаемые файловыми тестами -M, -A и -C, основаны на этом значении.

$PERL_VERSION
$^V

Редакция, версия и подверсия интерпретатора Perl, представленные как объект version.

Эта переменная появилась в perl v5.6.0; в более ранних версиях Perl она будет иметь значение undef. Перед perl v5.10.0 $^V представлялось как v-строка, а не как объект version.

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

warn "Hashes not randomized!\n" if !$^V or $^V lt v5.8.1

Хотя объекты версии перегружают строковое представление, для портативного преобразования $^V в его строковое представление используйте преобразование sprintf()'s "%vd", которое работает как для v-строк, так и для объектов версии:

printf "version is v%vd\n", $^V;  # Perl's version

См. документацию use VERSION и require VERSION для удобного способа завершения работы, если интерпретатор Perl слишком старой версии.

См. также "$]" для десятичного представления версии Perl.

Основное преимущество $^V перед $] заключается в том, что для Perl v5.10.0 или более поздних версий она перегружает операторы, что позволяет легко сравнивать с другими представлениями версии (например, десятичным, буквальным v-строкой, «v1.2.3» или объектами). Недостатком является то, что до v5.10.0 она была только буквальной v-строкой, которую нельзя легко вывести или сравнить, в то время как поведение $] не изменяется во всех версиях Perl.

Мнемоника: используйте ^V для объекта версии.

$EXECUTABLE_NAME
$^X

Имя, используемое для запуска текущей копии Perl, из C's argv[0] или (где поддерживается) /proc/self/exe.

В зависимости от операционной системы хоста, значение $^X может быть относительным или абсолютным путем к файлу программы perl, или может быть строкой, используемой для вызова perl, но не путём к файлу программы perl. Кроме того, большинство операционных систем позволяют вызывать программы, которые не находятся в переменной среды PATH, поэтому нет гарантии, что значение $^X находится в PATH. Для VMS значение может или не может включать номер версии.

Обычно вы можете использовать значение $^X для повторного вызова независимой копии того же perl, который сейчас выполняется, например:

@first_run = `$^X -le "print int rand 100 for 1..100"`;

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

Небезопасно использовать значение $^X как имя файла, так как некоторые операционные системы, имеющие обязательный суффикс для исполняемых файлов, не требуют его использования при вызове команды. Для преобразования значения $^X в имя файла используйте следующие операторы:

# Build up a set of file names (not command names).
use Config;
my $this_perl = $^X;
if ($^O ne 'VMS') {
    $this_perl .= $Config{_exe}
    unless $this_perl =~ m/$Config{_exe}$/i;
}

Поскольку многие операционные системы позволяют любому с правами чтения на файл программы Perl скопировать его, изменить копию и запустить её, внимательный к безопасности программист Perl должен запускать установленную копию perl, а не копию, на которую ссылается $^X. Следующие операторы выполняют эту цель и создают имя пути, которое можно использовать как команду или ссылаться на него как на файл.

use Config;
my $secure_perl_path = $Config{perlpath};
if ($^O ne 'VMS') {
    $secure_perl_path .= $Config{_exe}
    unless $secure_perl_path =~ m/$Config{_exe}$/i;
}

Переменные, связанные с регулярными выражениями

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

if( /P(A)TT(ER)N/ ) {
    print "I found $1 and $2\n";
}

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

Правила области действия переменных регулярных выражений

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

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

Успешное совпадение включает любое успешное совпадение, выполненное оператором поиска и замены s///, а также оператором %%%CODE_BLOCK_343%%.

Рассмотрим следующий код:

my @state;
sub matchit {
    push @state, $1;            # pushes "baz"
    my $str = shift;
    $str =~ /(zat)/;            # matches "zat"
    push @state, $1;            # pushes "zat"
}

{
    $str = "foo bar baz blorp zat";
    $str =~ /(foo)/;            # matches "foo"
    push @state, $1;            # pushes "foo"
    {
        $str =~ /(pizza)/;      # does NOT match
        push @state, $1;        # pushes "foo"
        $str =~ /(bar)/;        # matches "bar"
        push @state, $1;        # pushes "bar"
        $str =~ /(baz)/;        # matches "baz"
        matchit($str);          # see above
        push @state, $1;        # pushes "baz"
    }
    $str =~ s/noodles/rice/;    # does NOT match
    push @state, $1;            # pushes "foo"
    $str =~ s/(blorp)/zwoop/;   # matches "blorp"
    push @state, $1;            # pushes "blorp"
}
# the following prints "foo, foo, bar, baz, zat, baz, foo, blorp"
print join ",", @state;

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

Известно, что goto LABEL может плохо взаимодействовать с динамически ограниченным контекстом совпадения. Это может быть не исправлено, и это считается одной из многих хороших причин избегать %%%CODE_BLOCK_347%%.

Проблемы производительности

Традиционно в Perl любое использование одной из трех переменных $`, $& или $' (или их use English эквивалентов) в любом месте кода приводило к тому, что все последующие успешные совпадения шаблонов делали копию сопоставленной строки, на случай, если код впоследствии обратится к одной из этих переменных. Это накладывало значительную нагрузку на производительность всей программы, поэтому использование этих переменных, как правило, не рекомендуется.

В Perl 5.6.0 были введены динамические массивы @- и @+, которые предоставляют индексы успешных совпадений. Таким образом, вы можете, например, сделать следующее:

$str =~ /pattern/;

print $`, $&, $'; # bad: performance hit

print             # good: no performance hit
substr($str, 0,     $-[0]),
substr($str, $-[0], $+[0]-$-[0]),
substr($str, $+[0]);

В Perl 5.10.0 были введены флаг оператора совпадения /p и переменные ${^PREMATCH}, ${^MATCH}, и ${^POSTMATCH}, которые позволяли вам испытывать штрафы только по шаблонам, помеченным как %%%CODE_BLOCK_360%%.

В Perl 5.18.0 и более поздних версиях perl начал отмечать наличие каждой из трех переменных отдельно и копировал только необходимую часть строки; таким образом, в

$`; $&; "abcdefgh" =~ /d/

perl скопировал бы только часть "abcd" строки. Это может значительно повлиять на что-то вроде

$str = 'x' x 1_000_000;
$&; # whoops
$str =~ /x/g # one char copied a million times, not a million chars

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

Модули Devel::NYTProf и Devel::FindAmpersand могут помочь вам найти использование этих проблемных переменных совпадения в вашем коде.

$<digits> ($1, $2, ...)

Содержит подстроку из соответствующей группы захвата из последнего успешного совпадения шаблона в текущей динамической области видимости. (См. "Правила области видимости переменных Regex".)

Обратите внимание на различие между буфером захвата, который соответствует пустой строке, и буфером захвата, который является необязательным. Например, (x?) и (x)? Последний может быть undef, первый — нет.

Эти переменные являются только для чтения.

Мемоника: как \digits.

@{^CAPTURE}

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

Обратите внимание, что индекс 0 массива @{^CAPTURE} эквивалентен $1, индекс 1 эквивалентен $2 и т. д.

if ("foal"=~/(.)(.)(.)(.)/) {
    print join "-", @{^CAPTURE};
}

должно вывести "f-o-a-l".

См. также "$<digits> ($1, $2, ...)", "%{^CAPTURE}" и "%{^CAPTURE_ALL}".

Обратите внимание, что, в отличие от большинства других магических переменных regex, нет эквивалента в виде одной буквы к @{^CAPTURE}. Также имейте в виду, что при интерполяции индексов этого массива обязательно используйте обозначенную форму переменной, например

print "${^CAPTURE[0]}"

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

Эта переменная была добавлена в версии 5.25.7

$MATCH
$&

Строка, соответствующая последнему успешному совпадению шаблона. (См. "Правила области видимости переменных Regex".)

См. "Проблемы производительности" выше для серьезных последствий для производительности использования этой переменной (даже один раз) в вашем коде.

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

Мемоника: как & в некоторых редакторах.

${^MATCH}

Гарантируется возвращение определенного значения только в том случае, если шаблон был скомпилирован или выполнен с модификатором /p.

Это аналогично $& ($MATCH) за исключением того, что для его использования необходимо использовать модификатор /p при выполнении шаблона, и это не влечет за собой штраф производительности, связанный с этой переменной.

См. "Проблемы производительности" выше.

Эта переменная была добавлена в Perl v5.10.0.

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

$PREMATCH
$`

Строка, предшествующая той, которая была сопоставлена последним успешным совпадением шаблона. (См. "Правила области видимости переменных Regex").

См. "Проблемы производительности" выше для серьезных последствий для производительности использования этой переменной (даже один раз) в вашем коде.

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

Мемоника: ` часто предшествует строке в кавычках.

${^PREMATCH}

Гарантируется возвращение определенного значения только в том случае, если шаблон был выполнен с модификатором /p.

Это аналогично $` ($PREMATCH), за исключением того, что для его использования необходимо использовать модификатор /p при выполнении шаблона, и это не влечет за собой штраф производительности, связанный с этой переменной.

См. "Проблемы производительности" выше.

Эта переменная была добавлена в Perl v5.10.0.

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

$POSTMATCH
$'

Строка, следующая за той, которая была сопоставлена последним успешным совпадением шаблона. (См. "Правила области видимости переменных Regex"). Пример:

local $_ = 'abcdefghi';
/def/;
print "$`:$&:$'\n";       # prints abc:def:ghi

См. "Проблемы производительности" выше для серьезных последствий для производительности использования этой переменной (даже один раз) в вашем коде.

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

Мемоника: ' часто следует за строкой в кавычках.

${^POSTMATCH}

Гарантируется возвращение определенного значения только в том случае, если шаблон был скомпилирован или выполнен с модификатором /p.

Это аналогично $' ($POSTMATCH) за исключением того, что для его использования необходимо использовать модификатор /p при выполнении шаблона, и это не влечет за собой штраф производительности, связанный с этой переменной.

См. "Проблемы производительности" выше.

Эта переменная была добавлена в Perl v5.10.0.

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

$LAST_PAREN_MATCH
$+

Текст, сопоставленный с группой захвата с наибольшим номером из последнего успешного поиска шаблона. (См. "Правила области видимости переменных Regex"). Он логически эквивалентен переменной захвата с наибольшим номером ($1, $2, ...), которая имеет определенное значение.

Это полезно, если вы не знаете, какой из набора альтернативных шаблонов сопоставился. Например:

/Version: (.*)|Revision: (.*)/ && ($rev = $+);

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

Мемоника: будьте позитивны и ориентированы на будущее.

$LAST_SUBMATCH_RESULT
$^N

Текст, сопоставленный с группой, которая была последней закрыта (т. е. группой с самой правой закрывающей скобкой) в последнем успешном совпадении. (См. "Правила области видимости переменных Regex").

Это немного отличается от $+. Например, в

"ab" =~ /^((.)(.))$/

у нас есть

$1,$^N   have the value "ab"
$2       has  the value "a"
$3,$+    have the value "b"

Это в основном используется внутри блоков (?{...}) для проверки недавно сопоставленного текста. Например, для эффективного захвата текста в переменную (в дополнение к $1, $2, и т. д.) замените (...) на

(?:(...)(?{ $var = $^N }))

Установка и последующее использование $var таким образом избавляет вас от необходимости беспокоиться о том, какая именно группа скобок была номерной.

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

Эта переменная была добавлена в Perl v5.8.0.

Мемоника: (возможно) вложенная скобка, которая была последней закрыта.

@LAST_MATCH_END
@+

Этот массив содержит смещения концов последнего успешного совпадения и любых сопоставленных буферов захвата, которые содержит шаблон. (См. "Правила области видимости переменных Regex")

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

$+[0] — это смещение в строке до конца всего совпадения. Это то же значение, что и возвращает функция pos при вызове на переменной, с которой сравнивался шаблон. n-й элемент этого массива содержит смещение n-го подсовпадения, поэтому $+[1] — это смещение после конца $1, $+[2] — смещение после конца $2 и т. д. Вы можете использовать $#+ для определения количества подгрупп в последнем успешном совпадении. См. примеры, приведенные для переменной @-.

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

Эта переменная была добавлена в Perl v5.6.0.

%{^CAPTURE}
%LAST_PAREN_MATCH
%+

Аналогично @+, хэш %+ позволяет получить доступ к именованным буферам захвата (если они существуют) в последнем успешном совпадении в текущей активной области видимости. (См. "Правила области видимости переменных Regex").

Например, $+{foo} эквивалентно $1 после следующего совпадения:

'foo' =~ /(?<foo>foo)/;

Ключи хэша %+ перечисляют только имена буферов, которые были захвачены (и, таким образом, имеют ассоциированные определенные значения).

Если несколько различных групп захвата имеют одно и то же имя, то $+{NAME} будет ссылаться на левую (самую первую) определенную группу в совпадении.

Поддерживающее поведение %+ обеспечивается модулем Tie::Hash::NamedCapture.

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

Эта переменная была добавлена в Perl v5.10.0. Псевдоним %{^CAPTURE} был добавлен в версии 5.25.7.

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

@LAST_MATCH_START
@-

Этот массив хранит смещения начала последнего успешного совпадения и любых буферов захвата, которые он содержит. (См. "Правила области действия переменных Regex").

Количество элементов будет на один больше, чем количество самых высоких буферов захвата (также называемых подгруппами), которые фактически совпали с чем-то. (В отличие от @+, которое может содержать меньше элементов.)

$-[0] — смещение начала последнего успешного совпадения. $-[n] — смещение начала подстроки, соответствующей n-й подмаске, или undef, если подмаска не совпала.

Таким образом, после совпадения с $_, $& совпадает с substr $_, $-[0], $+[0] - $-[0]. Аналогично, $n совпадает с substr $_, $-[n], $+[n] - $-[n], если $-[n] определено, и $+ совпадает с substr $_, $-[$#-], $+[$#-] - $-[$#-]. Можно использовать $#-, чтобы найти последнюю совпавшую подгруппу в последнем успешном совпадении. Противопоставьте это $#+, числу подгрупп в регулярном выражении.

$-[0] — смещение в строке начала всего совпадения. n-й элемент этого массива хранит смещение n-го подсовпадения, так что $-[1] — смещение, где начинается $1, $-[2] — смещение, где начинается $2, и так далее.

После совпадения с какой-то переменной $var:

$` — это то же, что и substr($var, 0, $-[0])
$& — это то же, что и substr($var, $-[0], $+[0] - $-[0])
$' — это то же, что и substr($var, $+[0])
$1 — это то же, что и substr($var, $-[1], $+[1] - $-[1])
$2 — это то же, что и substr($var, $-[2], $+[2] - $-[2])
$3 — это то же, что и substr($var, $-[3], $+[3] - $-[3])

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

Эта переменная была добавлена в Perl v5.6.0.

%{^CAPTURE_ALL}
%-

Аналогично %+, эта переменная позволяет получить доступ к именованным группам захвата в последнем успешном совпадении в текущей активной динамической области видимости. (См. "Правила области видимости переменных Regex"). Она связывает каждое имя группы захвата, найденное в регулярном выражении, со ссылкой на массив, содержащий список значений, захваченных всеми буферами с этим именем (если их несколько), в порядке их появления.

Вот пример:

if ('1234' =~ /(?<A>1)(?<B>2)(?<A>3)(?<B>4)/) {
    foreach my $bufname (sort keys %-) {
        my $ary = $-{$bufname};
        foreach my $idx (0..$#$ary) {
            print "\$-{$bufname}[$idx] : ",
                  (defined($ary->[$idx])
                      ? "'$ary->[$idx]'"
                      : "undef"),
                  "\n";
        }
    }
}

выведет:

$-{A}[0] : '1'
$-{A}[1] : '3'
$-{B}[0] : '2'
$-{B}[1] : '4'

Ключи хэша %- соответствуют всем именам буферов, найденным в регулярном выражении.

Поведение %- реализовано с помощью модуля Tie::Hash::NamedCapture.

Примечание: %- и %+ являются привязанными представлениями к общему внутреннему хэшу, связанному с последним успешным регулярным выражением. Поэтому смешивание итерационного доступа к ним с помощью each может привести к непредсказуемым результатам. Точно так же, если последнее успешное совпадение изменяется, результаты могут быть неожиданными. См. "Правила области видимости переменных Regex".

Эта переменная была добавлена в Perl v5.10.0. Псевдоним %{^CAPTURE_ALL} был добавлен в 5.25.7.

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

${^LAST_SUCCESSFUL_PATTERN}

Последний успешно совпавший шаблон в текущей области видимости. Пустой шаблон по умолчанию совпадает с этим. Например:

if (m/foo/ || m/bar/) {
    s//BLAH/;
}

и

if (m/foo/ || m/bar/) {
    s/${^LAST_SUCCESSFUL_PATTERN}/BLAH/;
}

эквивалентны.

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

Добавлена в Perl 5.37.10.

$LAST_REGEXP_CODE_RESULT
$^R

Результат оценки последнего успешного (?{ code }) утверждения регулярного выражения (см. perlre).

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

Эта переменная была добавлена в Perl 5.005.

${^RE_COMPILE_RECURSION_LIMIT}

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

Эта переменная была добавлена в Perl v5.30.0.

${^RE_DEBUG_FLAGS}

Текущее значение флагов отладки регулярных выражений. Устанавливается в 0 для вывода отладки даже при загрузке модуля re 'debug'. См. re для получения подробной информации.

Эта переменная была добавлена в Perl v5.10.0.

${^RE_TRIE_MAXBUF}

Управляет применением определённых оптимизаций регулярных выражений и использованием памяти. Это значение по умолчанию равно 65536, что соответствует временной кэшу размером 512 КБ. Установите это значение в большее значение для обмена памятью на скорость при совпадении с большими альтернативами. Установите его в меньшее значение, если вы хотите, чтобы оптимизации были максимально консервативны относительно памяти, но всё ещё происходили, и установите его в отрицательное значение, чтобы предотвратить оптимизацию и сохранить как можно больше памяти. В нормальных ситуациях эта переменная для вас не должна представлять интереса.

Эта переменная была добавлена в Perl v5.10.0.

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

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

use IO::Handle;

после чего вы можете использовать либо

method HANDLE EXPR

или более безопасно,

HANDLE->method(EXPR)

Каждый метод возвращает старое значение атрибута IO::Handle. Методы принимают необязательный EXPR, который, если предоставлен, указывает новое значение атрибута IO::Handle в вопросе. Если не предоставлен, большинство методов ничего не делают с текущим значением – за исключением autoflush(), которая примет для вас значение 1, чтобы отличаться.

Поскольку загрузка класса IO::Handle — дорогостоящая операция, вы должны научиться использовать стандартные встроенные переменные.

Некоторые из этих переменных считаются «только для чтения». Это означает, что если вы попытаетесь присвоить значение этой переменной, напрямую или косвенно через ссылку, вы вызовете исключение во время выполнения.

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

open my $fh, "<", "foo" or die $!;
local $/; # enable localized slurp mode
my $content = <$fh>;
close $fh;

Но следующий код довольно плох:

open my $fh, "<", "foo" or die $!;
undef $/; # enable slurp mode
my $content = <$fh>;
close $fh;

поскольку какой-то другой модуль может захотеть прочитать данные из какого-то файла в режиме «строка по строке» по умолчанию, поэтому если код, который мы только что представили, был выполнен, глобальное значение $/ теперь изменено для любого другого кода, работающего внутри того же интерпретатора Perl.

Обычно, когда переменная локализована, вы хотите убедиться, что это изменение затрагивает наименьшую область видимости. Итак, если вы не находитесь уже внутри какого-то короткого {} блока, вы должны создать его самостоятельно. Например:

my $content = '';
open my $fh, "<", "foo" or die $!;
{
    local $/;
    $content = <$fh>;
}
close $fh;

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

for ( 1..3 ){
    $\ = "\r\n";
    nasty_break();
    print "$_";
}

sub nasty_break {
    $\ = "\f";
    # do something with $_
}

Вы, вероятно, ожидаете, что этот код выведет эквивалент

"1\r\n2\r\n3\r\n"

но вместо этого вы получите:

"1\f2\f3\f"

Почему? Потому что nasty_break() изменяет $\ без предварительной локализации. Значение, которое вы установили в nasty_break(), всё ещё существует, когда вы возвращаетесь. Исправление — добавить local(), чтобы значение не утекло из nasty_break(): 

local $\ = "\f";

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

$ARGV

Содержит имя текущего файла при чтении из <>.

@ARGV

Массив @ARGV содержит аргументы командной строки, предназначенные для скрипта. $#ARGV обычно равно числу аргументов минус один, потому что $ARGV[0] — это первый аргумент, а не имя команды программы. См. "$0" для имени команды.

ARGV

Специальный дескриптор файла, который итерирует файлы командной строки в @ARGV. Обычно записывается как нулевой дескриптор файла в угловой оператор <>. Обратите внимание, что в настоящее время ARGV оказывает свое магическое действие только внутри оператора <>; в других местах это просто обычный дескриптор файла, соответствующий последнему открытому файлу <>. В частности, передача \*ARGV в качестве параметра функции, ожидающей дескриптор файла, может не заставить вашу функцию автоматически считывать содержимое всех файлов в @ARGV.

ARGVOUT

Специальный дескриптор файла, который указывает на текущий открытый выходной файл при обработке редактирования на месте с помощью -i. Полезно, когда вам нужно выполнить много вставок и не хотите продолжать изменять $_. См. perlrun для переключателя -i.

IO::Handle->output_field_separator( EXPR )
$OUTPUT_FIELD_SEPARATOR
$OFS
$,

Разделитель полей вывода для оператора print. Если определён, это значение печатается между каждым из аргументов print. Значение по умолчанию undef.

Вы не можете вызвать output_field_separator() для дескриптора, только как статический метод. См. IO::Handle.

Мнемоника: то, что печатается, когда в вашем операторе print есть «,».

HANDLE->input_line_number( EXPR )
$INPUT_LINE_NUMBER
$NR
$.

Текущий номер строки для последнего дескриптора файла, к которому был произведён доступ.

Каждый дескриптор файла в Perl подсчитывает количество строк, которые были из него прочитаны. (В зависимости от значения $/, представление Perl о том, что представляет собой строка, может не совпадать с вашим.) Когда строка читается из дескриптора файла (через readline() или <>), или когда tell() или seek() вызываются для него, $. становится псевдонимом счётчика строк для этого дескриптора файла.

Вы можете настроить счётчик, присвоив значение $., но это не фактически сдвинет указатель поиска. Локализация $. не локализует счётчик строк дескриптора файла. Вместо этого она локализует представление Perl о том, к какому дескриптору файла $. в настоящее время относится.

$. сбрасывается при закрытии дескриптора файла, но не при повторном открытии открытого дескриптора файла без промежуточного close(). Для более подробной информации см. "Операторы Ввода/Вывода" в perlop. Поскольку <> никогда не выполняет явное закрытие, номера строк увеличиваются через ARGV файлы (но см. примеры в "eof" в perlfunc).

Вы также можете использовать HANDLE->input_line_number(EXPR) для доступа к счётчику строк для заданного дескриптора файла, не беспокоясь о том, к какому дескриптору вы последний раз обращались.

Мнемоника: многие программы используют «.» для обозначения текущего номера строки.

IO::Handle->input_record_separator( EXPR )
$INPUT_RECORD_SEPARATOR
$RS
$/

Разделитель записей ввода, по умолчанию — новая строка. Это влияет на представление Perl о том, что такое «строка». Работает как переменная RS в awk, включая обработку пустых строк как терминатора, если она установлена в пустую строку (пустая строка не может содержать пробелы или табуляции). Вы можете установить её в строку из нескольких символов, чтобы сопоставить многосимвольный терминатор, или в undef для чтения до конца файла. Установка её в "\n\n" означает немного другое, чем установка в "", если файл содержит последовательные пустые строки. Установка её в "" будет рассматривать две или более последовательных пустых строк как одну пустую строку. Установка её в "\n\n" будет слепо предполагать, что следующий входной символ принадлежит следующему абзацу, даже если это новая строка.

local $/;           # enable "slurp" mode
local $_ = <FH>;    # whole file now here
s/\n[ \t]+/ /g;

Помните: значение $/ — это строка, а не регулярное выражение. awk должен быть лучше для чего-то.

Установка $/ в пустую строку — так называемый режим абзаца — заслуживает особого внимания. Когда $/ установлена в "" и весь файл читается с этим параметром, любая последовательность одной или более последовательных новых строк в начале файла отбрасывается. За исключением последней записи в файле, каждая последовательность символов, заканчивающаяся двумя или более новыми строками, обрабатывается как одна запись и читается, чтобы закончиться ровно двумя новыми строками. Если последняя запись в файле заканчивается нулевой или одной последовательной новой строкой, эта запись читается с этим количеством новых строк. Если последняя запись заканчивается двумя или более последовательными новыми строками, она читается с двумя новыми строками, как все предыдущие записи.

Предположим, мы записали следующую строку в файл:

my $string = "\n\n\n";
$string .= "alpha beta\ngamma delta\n\n\n";
$string .= "epsilon zeta eta\n\n";
$string .= "theta\n";

my $file = 'simple_file.txt';
open my $OUT, '>', $file or die;
print $OUT $string;
close $OUT or die;

Теперь мы читаем этот файл в режиме абзаца:

local $/ = ""; # paragraph mode
open my $IN, '<', $file or die;
my @records = <$IN>;
close $IN or die;

@records будет состоять из этих 3 строк:

(
  "alpha beta\ngamma delta\n\n",
  "epsilon zeta eta\n\n",
  "theta\n",
)

Установка $/ в ссылку на целое число, скаляр, содержащий целое число, или скаляр, который можно преобразовать в целое число, попытается прочитать записи вместо строк, при этом максимальный размер записи будет равен числу символов, на которое ссылается целое число. Так что это:

local $/ = \32768; # or \"32768", or \$var_containing_32768
open my $fh, "<", $myfile or die $!;
local $_ = <$fh>;

будет читать запись не более чем из 32768 символов из $fh. Если вы не читаете из файла, ориентированного на записи (или ваша операционная система не имеет файлов, ориентированных на записи), то, скорее всего, вы получите весь фрагмент данных с каждым чтением. Если запись больше, чем размер записи, который вы установили, вы получите запись частями. Попытка установить размер записи на ноль или меньше устарела и приведет к тому, что $/ будет иметь значение «undef», что приведет к чтению всего (остального) файла.

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

Только на VMS, чтение записей обходит слои PerlIO и любую связанную буферизацию, поэтому вы не должны смешивать чтение записей и чтение без записей для одного и того же дескриптора файла. Режим записей смешивается с режимом строк только тогда, когда для обоих режимов используется один и тот же слой буферизации.

Вы не можете вызвать input_record_separator() для дескриптора, только как статический метод. См. IO::Handle.

См. также "Новые строки" в perlport. Также см. "$.".

Мнемоника: / разграничивает границы строк при цитировании стихов.

IO::Handle->output_record_separator( EXPR )
$OUTPUT_RECORD_SEPARATOR
$ORS
$\

Разделитель записей вывода для оператора print. Если определён, это значение печатается после последнего из аргументов print. Значение по умолчанию undef.

Вы не можете вызвать output_record_separator() для дескриптора, только как статический метод. См. IO::Handle.

Мнемоника: вы устанавливаете $\ вместо добавления «\n» в конце print. Также, это как $/, но это то, что вы получаете «назад» от Perl.

HANDLE->autoflush( EXPR )
$OUTPUT_AUTOFLUSH
$|

Если установлено в ненулевое значение, заставляет немедленно выполнить сброс и после каждого написания или печати в текущем выбранном выходном канале. Значение по умолчанию 0 (независимо от того, действительно ли канал буферизуется системой или нет; $| сообщает только о том, попросили ли вы Perl выполнить сброс после каждой записи). STDOUT обычно будет буферизован по строкам, если вывод идёт в терминал, и в блочный буфер в противном случае. Установка этой переменной полезна в основном при выводе в канал или сокет, например, когда вы запускаете программу Perl с помощью rsh и хотите видеть вывод по мере его появления. Это не влияет на буферизацию ввода. См. "getc" в perlfunc для этого. См. "select" в perlfunc о том, как выбрать выходной канал. См. также IO::Handle.

Мнемоника: когда вы хотите, чтобы ваши каналы были горячими.

${^LAST_FH}

Эта переменная только для чтения содержит ссылку на дескриптор файла, последний прочитанный. Это устанавливается <HANDLE>, readline, tell, eof и seek. Это тот же дескриптор, который $. и tell и eof используют без аргументов. Это также дескриптор, используемый, когда Perl добавляет ", <STDIN> строка 1" к сообщению об ошибке или предупреждении.

Эта переменная была добавлена в Perl v5.18.0.

Переменные, связанные с форматами

Специальные переменные для форматов являются подмножеством переменных для дескрипторов файлов. См. perlform для получения дополнительной информации о форматах Perl.

$ACCUMULATOR
$^A

Текущее значение аккумулятора write() для format() строк. Формат содержит formline() вызовы, которые помещают свой результат в $^A. После вызова его формата, write() выводит содержимое $^A и очищает его. Поэтому вы никогда не увидите содержимое $^A, если сами не вызовете formline() и не посмотрите. См. perlform и "formline PICTURE,LIST" в perlfunc.

IO::Handle->format_formfeed(EXPR)
$FORMAT_FORMFEED
$^L

Формат вывода, как подача формы. По умолчанию \f.

Вы не можете вызвать format_formfeed() для обработчика, только как статический метод. См. IO::Handle.

HANDLE->format_page_number(EXPR)
$FORMAT_PAGE_NUMBER
$%

Текущий номер страницы текущего выбранного выходного канала.

Мнемоника: % - номер страницы в nroff.

HANDLE->format_lines_left(EXPR)
$FORMAT_LINES_LEFT
$-

Количество оставшихся строк на странице текущего выбранного выходного канала.

Мнемоника: количество_строк_на_странице - количество_напечатанных_строк.

IO::Handle->format_line_break_characters EXPR
$FORMAT_LINE_BREAK_CHARACTERS
$:

Текущий набор символов, после которых строка может быть разбита для заполнения полей продолжения (начиная с ^) в формате. По умолчанию " \n-", разбить по пробелу, новой строке или дефису.

Вы не можете вызвать format_line_break_characters() для обработчика, только как статический метод. См. IO::Handle.

Мнемоника: «двоеточие» в поэзии — часть строки.

HANDLE->format_lines_per_page(EXPR)
$FORMAT_LINES_PER_PAGE
$=

Текущая длина страницы (печатаемых строк) текущего выбранного выходного канала. По умолчанию 60.

Мнемоника: = имеет горизонтальные линии.

HANDLE->format_top_name(EXPR)
$FORMAT_TOP_NAME
$^

Имя текущего формата начала страницы для текущего выбранного выходного канала. По умолчанию имя файла-обработчика со строкой _TOP в конце. Например, имя формата начала страницы для файла-обработчика STDOUT - STDOUT_TOP.

Мнемоника: указывает на начало страницы.

HANDLE->format_name(EXPR)
$FORMAT_NAME
$~

Имя текущего формата отчета для текущего выбранного выходного канала. По умолчанию имя формата совпадает с именем файла-обработчика. Например, имя формата по умолчанию для файла-обработчика STDOUT - просто STDOUT.

Мнемоника: брат $^.

Переменные ошибок

Переменные $@, $!, $^E, и $? содержат информацию о различных типах условий ошибок, которые могут возникнуть во время выполнения программы Perl. Переменные показаны в порядке «удаленности» подсистемы, сообщившей об ошибке, от процесса Perl. Они соответствуют ошибкам, обнаруженным интерпретатором Perl, библиотекой C, операционной системой или внешней программой, соответственно.

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

eval q{
    open my $pipe, "/cdrom/install |" or die $!;
    my @res = <$pipe>;
    close $pipe or die "bad pipe: $?, $!";
};

Когда perl выполняет выражение eval(), оно транслирует вызовы open(), <PIPE>, и close в библиотеке выполнения C, а затем в ядро операционной системы. perl устанавливает $! в значение errno библиотеки C, если один из этих вызовов завершится ошибкой.

$@ устанавливается, если строка для eval-ния не скомпилировалась (это может произойти, если open или close были импортированы с плохими прототипами) или если выполняется код Perl во время оценки die()d. В этих случаях значение $@ — ошибка компиляции или аргумент для die (который интерполирует $! и $?). (См. также Fatal.)

В некоторых операционных системах $^E может содержать более подробный индикатор ошибки, например, «Лоток CD-ROM не закрыт». Системы, не поддерживающие расширенные сообщения об ошибках, оставляют $^E таким же, как $!.

Наконец, $? может быть установлено в значение отличное от 0, если внешняя программа /cdrom/install завершается ошибкой. Старшие восемь бит отражают конкретные условия ошибок, с которыми столкнулась программа (значение exit() программы). Младшие восемь бит отражают способ отказа, например, сигнал завершения и информацию о дампе ядра. См. wait(2) для получения подробностей. В отличие от $! и $^E, которые устанавливаются только при обнаружении условия ошибки, переменная $? устанавливается при каждом wait или канале close, перезаписывая старое значение. Это больше похоже на $@, которое при каждом eval() всегда устанавливается при ошибке и очищается при успехе.

Для получения дополнительной информации см. индивидуальные описания в $@, $!, $^E, и $?.

END_OF_DOCUMENT_MARKER
${^CHILD_ERROR_NATIVE}

Состояние, возвращённое последним закрытием канала, командой обратной кавычки (``), успешным вызовом wait() или waitpid(), или оператором system(). В системах, подобных POSIX, это значение можно декодировать с помощью функций WIFEXITED, WEXITSTATUS, WIFSIGNALED, WTERMSIG, WIFSTOPPED и WSTOPSIG, предоставленных модулем POSIX.

В VMS это отражает фактическое состояние выхода VMS; то есть это то же самое, что и $?, когда применяется предикативное use vmsish 'status'.

Эта переменная была добавлена в Perl v5.10.0.

$EXTENDED_OS_ERROR
$^E

Информация об ошибке, специфичная для текущей операционной системы. В настоящее время она отличается от "$!" только в VMS, OS/2 и Win32 (и для MacPerl). Во всех остальных платформах $^E всегда такое же, как $!.

В VMS, $^E предоставляет значение статуса VMS от последней системной ошибки. Это более подробная информация о последней системной ошибке, чем та, которая предоставляется $!. Это особенно важно, когда $! установлено в EVMSERR.

В OS/2, $^E устанавливается в код ошибки последнего вызова API OS/2, либо через CRT, либо напрямую из perl.

В Win32, $^E всегда возвращает последнюю информацию об ошибке, сообщённую вызовом Win32 GetLastError(), который описывает последнюю ошибку из Win32 API. Большая часть кода, специфичного для Win32, будет сообщать об ошибках через $^E. ANSI C и вызовы типа Unix устанавливают errno, поэтому большая часть переносимого Perl-кода будет сообщать об ошибках через $!.

Ограничения, упомянутые в описании "$!", в целом применимы и к $^E.

Эта переменная была добавлена в Perl 5.003.

Мемоническое обозначение: Дополнительное объяснение ошибки.

$EXCEPTIONS_BEING_CAUGHT
$^S

Текущее состояние интерпретатора.

$^S         State
---------   -------------------------------------
undef       Parsing module, eval, or main program
true (1)    Executing an eval or try block
false (0)   Otherwise

Первое состояние может произойти в обработчиках $SIG{__DIE__} и $SIG{__WARN__}.

Название $EXCEPTIONS_BEING_CAUGHT на английском языке немного вводит в заблуждение, потому что значение undef не указывает, обрабатываются ли исключения, так как компиляция основной программы не обрабатывает исключения.

Эта переменная была добавлена в Perl 5.004.

$WARNING
$^W

Текущее значение переключателя предупреждений, по умолчанию истинно, если использовался -w, ложно в противном случае, но может изменяться напрямую.

См. также warnings.

Мемоническое обозначение: связано со переключателем -w.

${^WARNING_BITS}

Текущий набор проверок предупреждений, включённых прагмой use warnings. Она имеет тот же охват, что и переменные $^H и %^H. Точные значения считаются внутренними для прагмы warnings и могут изменяться между версиями Perl.

Каждый раз, когда оператор заканчивает компиляцию, текущее значение ${^WARNING_BITS} хранится с этим оператором и может быть позже получено через (caller($level))[9].

Эта переменная была добавлена в Perl v5.6.0.

$OS_ERROR
$ERRNO
$!

При обращении $! получает текущее значение целочисленной переменной C errno. Если $! присваивается числовое значение, то это значение сохраняется в errno. При обращении как строки $! выдает строку системной ошибки, соответствующую errno.

Многие системные или библиотечные вызовы устанавливают errno при ошибке, чтобы указать причину сбоя. Обычно они не устанавливают errno в ноль при успехе и могут установить errno в ненулевое значение при успехе. Это означает, что errno, и, следовательно, $!, имеет смысл только непосредственно после ошибки:

if (open my $fh, "<", $filename) {
    # Here $! is meaningless.
    ...
}
else {
    # ONLY here is $! meaningful.
    ...
    # Already here $! might be meaningless.
}
# Since here we might have either success or failure,
# $! is meaningless.

Здесь бессмысленно означает, что $! может не иметь отношения к результату оператора open(). Присвоение значения $! аналогичным образом кратковременно. Его можно использовать непосредственно перед вызовом оператора die(), чтобы установить значение выхода, или чтобы просмотреть строку системной ошибки, соответствующую ошибке n, или восстановить $! в осмысленное состояние.

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

Мемоническое обозначение: Что только что взорвалось?

%OS_ERROR
%ERRNO
%!

Каждый элемент %! имеет истинное значение только если $! установлено в это значение. Например, $!{ENOENT} истинно только если текущее значение $! равно ENOENT; то есть, если последняя ошибка была "Файл или директория не найдены" (или его аналог: не все операционные системы возвращают эту точную ошибку, и определённо не все языки). Конкретное истинное значение не гарантируется, но в прошлом оно обычно было численным значением $!. Чтобы проверить, имеет ли конкретный ключ смысл в вашей системе, используйте exists $!{the_key}; для списка допустимых ключей используйте keys %!. См. Errno для получения дополнительной информации, и также см. "$!".

Эта переменная была добавлена в Perl 5.005.

$CHILD_ERROR
$?

Состояние, возвращённое последним закрытием канала, командой обратной кавычки (``), успешным вызовом wait() или waitpid(), или оператором system(). Это просто 16-битовое слово состояния, возвращаемое традиционным системным вызовом Unix wait() (или же оно создаётся так, чтобы выглядеть как таковое). Таким образом, значение выхода подпроцесса — это на самом деле ($? >> 8), $? & 127 указывает, от какого сигнала, если таковой имеется, процесс завершился, и $? & 128 сообщает, был ли сгенерирован дамп ядра.

Кроме того, если переменная h_errno поддерживается в C, её значение возвращается через $? в случае неудачи любой функции gethost*().

Если у вас установлен обработчик сигнала для SIGCHLD, значение $? обычно будет неправильным вне этого обработчика.

Внутри подпрограммы END $? содержит значение, которое будет передано exit(). Вы можете изменить $? в подпрограмме END для изменения значения завершения вашей программы. Например:

END {
    $? = 1 if $? == 255;  # die would make it 255
}

В VMS, прагма use vmsish 'status' заставляет $? отражать фактическое состояние выхода VMS вместо эмуляции состояния POSIX; см. "$?" в perlvms для получения подробностей.

Мемоническое обозначение: аналогично sh и ksh.

$EVAL_ERROR
$@

Perl-ошибка от последнего оператора eval, т.е. последнее перехваченное исключение. Для eval BLOCK, это либо сообщение об ошибке во время выполнения, либо строка или ссылка die, с которой был вызван. Форма eval STRING также перехватывает синтаксические ошибки и другие исключения во время компиляции.

Если ошибки не происходит, eval устанавливает $@ в пустую строку.

Сообщения об ошибках не собираются в этой переменной. Однако вы можете настроить процедуру обработки предупреждений, установив $SIG{__WARN__}, как описано в "%SIG".

Мемоническое обозначение: Где была ошибка?

Переменные, связанные с состоянием интерпретатора

Эти переменные предоставляют информацию о текущем состоянии интерпретатора.

$COMPILING
$^C

Текущее значение флага, связанного со переключателем -c. В основном используется с -MO=... для возможности коду изменять своё поведение при компиляции, например, для AUTOLOAD во время компиляции вместо обычной отложенной загрузки. Установка $^C = 1 аналогична вызову B::minus_c.

Эта переменная была добавлена в Perl v5.6.0.

$DEBUGGING
$^D

Текущее значение флагов отладки. Может быть прочитано или установлено. Как и его эквивалент в командной строке, вы можете использовать числовые или символические значения, например, $^D = 10 или $^D = "st". См. "-Dчисло" в perlrun. Содержимое этой переменной также влияет на работу отладчика. См. "Внутренности отладчика" в perldebguts.

Мнемоническое обозначение: значение переключателя -D.

${^GLOBAL_PHASE}

Текущая фаза интерпретатора Perl.

Возможные значения:

CONSTRUCT

PerlInterpreter* строятся с помощью perl_construct. Это значение в основном присутствует для полноты и использования через базовую переменную C PL_phase. Perl-код фактически не может выполняться, пока не завершено построение интерпретатора.

START

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

Эта фаза не называется «BEGIN», чтобы избежать путаницы с BEGIN-блоками, поскольку они выполняются во время компиляции любого блока, а не только основной программы. Новая, локальная фаза компиляции, входящая во время выполнения, например, такими конструкциями, как eval "use SomeModule", не являются глобальными фазами интерпретатора и, следовательно, не отражаются ${^GLOBAL_PHASE}.

CHECK

Выполнение любого CHECK блока.

INIT

Аналогично «CHECK», но для INIT-блоков, а не CHECK-блоков.

RUN

Основное время выполнения, т.е. выполнение PL_main_root.

END

Выполнение любых END блоков.

DESTRUCT

Глобальное уничтожение.

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

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

Пример всех фаз, которые может увидеть Perl-код:

BEGIN { print "compile-time: ${^GLOBAL_PHASE}\n" }

INIT  { print "init-time: ${^GLOBAL_PHASE}\n" }

CHECK { print "check-time: ${^GLOBAL_PHASE}\n" }

{
    package Print::Phase;

    sub new {
        my ($class, $time) = @_;
        return bless \$time, $class;
    }

    sub DESTROY {
        my $self = shift;
        print "$$self: ${^GLOBAL_PHASE}\n";
    }
}

print "run-time: ${^GLOBAL_PHASE}\n";

my $runtime = Print::Phase->new(
    "lexical variables are garbage collected before END"
);

END   { print "end-time: ${^GLOBAL_PHASE}\n" }

our $destruct = Print::Phase->new(
    "package variables are garbage collected after END"
);

Это выведет

compile-time: START
check-time: CHECK
init-time: INIT
run-time: RUN
lexical variables are garbage collected before END: RUN
end-time: END
package variables are garbage collected after END: DESTRUCT

Эта переменная была добавлена в Perl 5.14.0.

$^H

ПРЕДУПРЕЖДЕНИЕ: Эта переменная предназначена только для внутреннего использования. Её доступность, поведение и содержимое могут быть изменены без предварительного уведомления.

Эта переменная содержит подсказки времени компиляции для интерпретатора Perl. В конце компиляции блока значение этой переменной восстанавливается до значения, когда интерпретатор начал компиляцию блока.

Каждый раз, когда оператор завершает компиляцию, текущее значение $^H сохраняется вместе с этим оператором и может быть позже получено с помощью (caller($level))[8]. См. "caller EXPR" в perlfunc.

Когда perl начинает анализировать любой блок конструкции, который предоставляет лексический контекст (например, тело eval, требуемый файл, тело подпрограммы, тело цикла или условный блок), существующее значение $^H сохраняется, но его значение не изменяется. Когда компиляция блока завершается, он восстанавливает сохранённое значение. Между точками, где его значение сохраняется и восстанавливается, код, выполняющийся внутри BEGIN блоков, свободен менять значение $^H.

Это поведение обеспечивает семантику лексического охвата и используется, например, в use strict pragме.

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

sub add_100 { $^H |= 0x100 }

sub foo {
    BEGIN { add_100() }
    bar->baz($boon);
}

Представьте, что происходит во время выполнения BEGIN блока. На этом этапе BEGIN блок уже был скомпилирован, но тело foo() всё ещё компилируется. Поэтому новое значение $^H будет видно только во время компиляции тела foo().

Замена BEGIN { add_100() } блока на:

BEGIN { require strict; strict->import('vars') }

демонстрирует, как реализован use strict 'vars'. Вот условная версия того же лексического прагмы:

BEGIN {
    require strict; strict->import('vars') if $condition
}

Эта переменная была добавлена в Perl 5.003.

%^H

Хэш %^H обеспечивает те же семантики охвата, что и $^H. Это делает его полезным для реализации прагм с лексическим охватом. См. perlpragma. Все записи строятся при обращении во время выполнения, поэтому могут быть приняты только простые значения. Это означает отсутствие ссылок на объекты, например.

Каждый раз, когда оператор завершает компиляцию, текущее значение %^H сохраняется вместе с этим оператором и может быть позже получено с помощью (caller($level))[10]. См. "caller EXPR" в perlfunc.

При размещении элементов в %^H, чтобы избежать конфликтов с другими пользователями хэша, существует соглашение относительно использования ключей. Модуль должен использовать только ключи, начинающиеся с имени модуля (имя его основного пакета) и символа "/". Например, модуль Foo::Bar должен использовать ключи, такие как Foo::Bar/baz.

Эта переменная была добавлена в Perl v5.6.0.

${^OPEN}

Внутренняя переменная, используемая в PerlIO. Строка из двух частей, разделённых \0 байтом; первая часть описывает входные слои, а вторая - выходные слои.

Это механизм, который применяет лексическое влияние прагмы open и влияние глобальной области программы опций io или D для -C параметра командной строки и переменной окружения PERL_UNICODE.

Функции accept(), open(), pipe(), readpipe() (а также связанные qx и `STRING` операторы), socket(), socketpair(), и sysopen() влияют на лексическое значение этой переменной. Неявная ручка "ARGV", открытая readline() (или связанные <> и <<>> операторы) для переданных имён файлов, также затронута (но не если она открывает STDIN). Если эта переменная не задана, эти функции установят стандартные слои, как описано в "Стандартные значения и как их переопределить" в PerlIO.

open() игнорирует эту переменную (и стандартные слои), когда вызывается с 3 аргументами и явными слоями.

Косвенные вызовы этих функций через модули, такие как IO::Handle, не затронуты, поскольку они происходят в другом лексическом контексте. Дескрипторы каталогов, такие как открытые opendir(), в настоящее время не затронуты.

Эта переменная была добавлена в Perl v5.8.0.

$PERLDB
$^P

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

0x01

Ввод/вывод подпрограммы отладки.

0x02

Отладка по строкам. Приводит к вызову подпрограммы DB::DB() для каждого выполненного оператора. Также приводит к сохранению строк исходного кода (как 0x400).

0x04

Отключение оптимизаций.

0x08

Сохранение большего объёма данных для будущих инспекций в интерактивном режиме.

0x10

Сохранение информации о строках исходного кода, в которых определена подпрограмма.

0x20

Начать с включённого пошагового режима.

0x40

Использовать адрес подпрограммы вместо имени при отчёте.

0x80

Отчитывать goto &subroutine также.

0x100

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

0x200

Предоставлять информативные имена анонимным подпрограммам, основанные на месте их компиляции.

0x400

Сохранение строк исходного кода в @{"_<$filename"}.

0x800

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

0x1000

При сохранении исходного кода включать исходный код, который не был скомпилирован.

Некоторые биты могут быть актуальны только во время компиляции, некоторые только во время выполнения. Это новый механизм, и детали могут меняться. См. также perldebguts.

${^TAINT}

Показывает, включён ли режим taint или выключен. 1 для включения (программа была запущена с -T), 0 для выключения, -1, когда разрешены только предупреждения taint (т.е. с -t или -TU).

Примечание: если ваш perl был скомпилирован без поддержки taint (см. perlsec), то ${^TAINT} всегда будет 0, даже если программа была запущена с -T).

Эта переменная только для чтения.

Эта переменная была добавлена в Perl v5.8.0.

${^SAFE_LOCALES}

Показывает, доступны ли безопасные операции локализации для этого perl (если значение равно 1) или нет (если значение равно 0). Эта переменная всегда равна 1, если perl был скомпилирован без поддержки потоков. Она также равна 1, если этот perl использует безопасные для потоков операции локализации. Обратите внимание, что отдельный поток может выбрать использование глобальной локали (обычно небезопасной) путём вызова "switch_to_global_locale" в perlapi. В настоящее время эта переменная в таких потоках всё ещё установлена в 1.

Эта переменная только для чтения.

Эта переменная была добавлена в Perl v5.28.0.

${^UNICODE}

Отражает определённые параметры Unicode Perl. См. документацию perlrun#-C-[число/список] переключателя для получения дополнительной информации о возможных значениях.

Эта переменная устанавливается во время запуска Perl и после этого является только для чтения.

Эта переменная была добавлена в Perl v5.8.2.

${^UTF8CACHE}

Эта переменная управляет состоянием кэширования смещений в кодировке UTF-8. 1 — включено (по умолчанию), 0 — выключено, -1 — отладка кода кэширования путём проверки всех его результатов по линейным сканированиям и паникой при любых расхождениях.

Эта переменная была добавлена в Perl v5.8.9. Она может быть изменена или удалена без предварительного уведомления, но в настоящее время используется для избежания перерасчёта границ многобайтовых символов, закодированных в UTF-8.

${^UTF8LOCALE}

Эта переменная указывает, был ли обнаружен локаль UTF-8 Perl при запуске. Эта информация используется Perl, когда он находится в режиме корректировки utf8-соответствия локале (например, при запуске со флагом командной строки -CL); см. perlrun для получения дополнительной информации по этому поводу.

Эта переменная была добавлена в Perl v5.8.8.

Устаревшие и удалённые переменные

Устаревание переменной объявляет намерение разработчиков Perl в конечном счёте удалить переменную из языка. Она может всё ещё быть доступна, несмотря на свой статус. Использование устаревшей переменной вызывает предупреждение.

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

См. perldiag для получения подробной информации об сообщениях об ошибках.

$#

$# была переменной, которую можно было использовать для форматирования выводимых чисел. После цикла устаревания её магия была удалена в Perl v5.10.0, и её использование теперь вызывает предупреждение: $# is no longer supported.

Это не тот символ, который вы используете перед именем массива для получения последнего индекса, например, $#array. Таким образом вы по-прежнему получаете последний индекс массива в Perl. Эти два понятия не связаны.

Устарела в Perl 5.

Удалена в Perl v5.10.0.

$*

$* была переменной, которую можно было использовать для включения многострочного сопоставления. После цикла устаревания её магия была удалена в Perl v5.10.0. Использование её сейчас вызывает предупреждение: $* is no longer supported. Вместо этого следует использовать модификаторы регулярных выражений /s и /m.

Устарела в Perl 5.

Удалена в Perl v5.10.0.

$[

Эта переменная хранит индекс первого элемента в массиве и первой буквы в подстроке. Значение по умолчанию — 0, но теоретически вы можете установить его в 1, чтобы Perl вел себя как awk (или Fortran) при индексировании и вычислении функций index() и substr().

Начиная с версии 5 Perl, присваивание $[ обрабатывается как директива компилятора и не может влиять на поведение других файлов. (Поэтому вы можете присваивать только константы времени компиляции.) Её использование крайне нежелательно.

До Perl v5.10.0 присваивание $[ было видно из внешних лексических областей в одном файле, в отличие от других директив времени компиляции (например, strict). Использование local() для неё привязывало бы её значение строго к лексическому блоку. Теперь она всегда лексически ограничена.

Начиная с Perl v5.16.0, она реализуется модулем arybase.

Начиная с Perl v5.30.0, или под use v5.16, или no feature "array_base", $[ больше не имеет никакого эффекта и всегда содержит 0. Разрешено присваивать 0, но любое другое значение вызовет ошибку.

Мнемоника: [ обозначает начало индексов.

Устарела в Perl v5.12.0.

${^ENCODING}

Эта переменная больше не поддерживается.

Раньше она хранила ссылку на объект на объект Encode, который использовался для преобразования исходного кода в Unicode.

Её целью было позволить вашим скриптам Perl, не использующим ASCII, не быть написанными в UTF-8; это было полезно до появления редакторов, работающих с текстом в UTF-8, но это было давно. Она вызывала проблемы, такие как влияние на работу других модулей, которые не ожидали её, вызывая общую сумятицу.

Если вам нужна функциональность подобного рода, рекомендуется использовать простой фильтр исходного кода, такой как Filter::Encoding.

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

local ${^ENCODING};

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

Эта переменная была добавлена в Perl 5.8.2 и удалена в 5.26.0. Установка её на значение, отличное от undef, сделана фатальной в Perl 5.28.0.

${^WIN32_SLOPPY_STAT}

Эта переменная больше не выполняет никаких функций.

Эта переменная была добавлена в Perl v5.10.0 и удалена в Perl v5.34.0.

© 1993–2023 Larry Wall and others
Licensed under the GNU General Public License version 1 or later, or the Artistic License.
The Perl logo is a trademark of the Perl Foundation.
https://perldoc.perl.org/5.38.0/perlvar

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API