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'a. Эти переменные зарезервированы для будущего специального использования в Perl, за исключением тех, которые начинаются с ^_ (каретка-подчёркивание). Ни одно имя, начинающееся с ^_, не будет получать специального значения в будущих версиях Perl; такие имена могут безопасно использоваться в программах. $^_ сам по себе, однако, зарезервирован.

Идентификаторы 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.

Меморандум: то же, что у sh и ksh.

$REAL_GROUP_ID

$GID

$(

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

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

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

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

$EFFECTIVE_GROUP_ID

$EGID

$)

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

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

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

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

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

$REAL_USER_ID

$UID

$<

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

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

$EFFECTIVE_USER_ID

$EUID

$>

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

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

Вы можете изменить как эффективный uid, так и действительный 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 для предоставления более конкретной информации.

$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.

$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` из обработчика __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__} в текущей реализации приводит к тяжёлым и трудно отслеживаемым ошибкам. Избегайте этого и используйте вместо него переопределение `die` в END{} или CORE::GLOBAL::die.

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

$BASETIME

$^T

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

$PERL_VERSION

$^V

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

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

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

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

Хотя объекты версии перегружают строковое представление, для портативного преобразования $^V в его строковое представление используйте преобразование sprintf() в "%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 для объекта версии.

${^WIN32_SLOPPY_STAT}

Эта переменная больше не имеет никакого функционального назначения.

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

$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";
    }

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

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

my $outer = 'Wallace and Grommit';
my $inner = 'Mutt and Jeff';

my $pattern = qr/(\S+) and (\S+)/;

sub show_n { print "\$1 is $1; \$2 is $2\n" }

{
OUTER:
    show_n() if $outer =~ m/$pattern/;

    INNER: {
        show_n() if $inner =~ m/$pattern/;
        }

    show_n();
}

Вывод показывает, что внутри блока OUTER, значения $1 и $2 берутся из совпадения с $outer. Внутри блока INNER, значения $1 и $2 берутся из совпадения с $inner, но только до конца блока (т. е. динамический область видимости). После завершения блока INNER, значения $1 и $2 возвращаются к значениям совпадения с $outer, даже если мы не производили других совпадений:

$1 is Wallace; $2 is Grommit
$1 is Mutt; $2 is Jeff
$1 is Wallace; $2 is Grommit

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

Традиционно в 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}, которые позволили вам испытывать штрафы только для шаблонов, помеченных /p.

В 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, ...)

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

Обратите внимание на различие между буфером захвата, который соответствует пустой строке, и буфером захвата, который является необязательным. Например, (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}".

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

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

$MATCH

$&

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

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

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

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

${^MATCH}

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

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

В Perl версии 5.18 и ранее гарантируется возврат определенного значения только в том случае, когда шаблон был скомпилирован или выполнен с модификатором /p. В Perl версии 5.20 модификатор /p ничего не делает, поэтому ${^MATCH} делает то же, что и $MATCH.

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

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

$PREMATCH

$`

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

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

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

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

${^PREMATCH}

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

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

В Perl версии 5.18 и ранее гарантируется возврат определенного значения только в том случае, когда шаблон был скомпилирован или выполнен с модификатором /p. В Perl версии 5.20 модификатор /p ничего не делает, поэтому ${^PREMATCH} делает то же, что и $PREMATCH.

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

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

$POSTMATCH

$'

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

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

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

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

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

${^POSTMATCH}

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

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

В Perl версии 5.18 и ранее гарантируется возврат определенного значения только в том случае, когда шаблон был скомпилирован или выполнен с модификатором /p. В Perl версии 5.20 модификатор /p ничего не делает, поэтому ${^POSTMATCH} делает то же, что и $POSTMATCH.

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

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

$LAST_PAREN_MATCH

$+

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

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

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

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

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

$LAST_SUBMATCH_RESULT

$^N

Текст, сопоставленный с последней закрытой группой (т.е. группой с правой скобкой) последнего успешного шаблона поиска. Это немного отличается от $+. Например, в

"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

@+

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

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

%{^CAPTURE}

%LAST_PAREN_MATCH

%+

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

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

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

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

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

Основное поведение %+ обеспечивается модулем Tie::Hash::NamedCapture.

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

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

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

@LAST_MATCH_START

@-

$-[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}

%-

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

Вот пример:

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

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

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

$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.

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

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

$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 таким же, как $!.

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

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

${^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(), которая описывает последнюю ошибку внутри API Win32. Большинство кодов, специфичных для 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
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.

Эта переменная была добавлена в 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.

${^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.

${^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. В конце компиляции блока значение этой переменной восстанавливается до значения, при котором интерпретатор начал компилировать блок.

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

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

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

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, чтобы избежать конфликтов с другими пользователями хэша, существует соглашение о том, какие ключи использовать. Модуль должен использовать только ключи, начинающиеся с имени модуля (имени его основного пакета) и символа "/". Например, модуль 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 v5.8.0.

${^SAFE_LOCALES}

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

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

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

${^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.