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__. Аналогично для __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 для получения дополнительной информации.

$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()'s "%vd", которое работает как со строками v, так и с объектами version:

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 для объекта version.

${^WIN32_SLOPPY_STAT}

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

Эту переменную можно установить в файле sitecustomize.pl для настройки локальной установки Perl для использования "небрежного" stat() по умолчанию. См. документацию к -f в perlrun для получения дополнительной информации о настройке сайта.

Эта переменная была добавлена в Perl v5.10.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 v5.18 и более ранних версиях гарантируется возвращение определенного значения только тогда, когда шаблон был скомпилирован или выполнен с модификатором /p. В Perl v5.20 модификатор /p ничего не делает, поэтому ${^MATCH} делает то же самое, что и $MATCH.

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

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

$PREMATCH

$`

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

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

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

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

${^PREMATCH}

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

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

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

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

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

$POSTMATCH

$'

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

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

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

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

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

${^POSTMATCH}

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

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

В Perl v5.18 и более ранних версиях гарантируется возвращение определенного значения только тогда, когда шаблон был скомпилирован или выполнен с модификатором /p. В Perl v5.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(). Подробнее см. "I/O Operators" в 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 должен быть лучше чем-то. :-)

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

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

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.

См. также "Newlines" в 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 обычно имеет буферизацию строк, если вывод направлен на терминал, и блочную буферизацию в противном случае. Установка этой переменной полезна в основном при выводе в pipe или сокет, например, когда вы запускаете программу Perl под rsh и хотите видеть вывод по мере его появления. Это не влияет на буферизацию ввода. См. "getc" в perlfunc для этого. См. "select" в perlfunc о том, как выбрать выходной канал. См. также IO::Handle.

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

${^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()л. В этих случаях значение $@ — это ошибка компиляции или аргумент для die (который интерполирует $! и $?). (См. также Fatal.)

В некоторых операционных системах $^E может содержать более подробный указатель ошибки, например, в данном случае "CDROM tray not closed." Системы, которые не поддерживают расширенные сообщения об ошибках, оставляют $^E таким же, как $!.

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

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

${^CHILD_ERROR_NATIVE}

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

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

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

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

$WARNING

$^W

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

См. также предупреждения.

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

${^WARNING_BITS}

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

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

$OS_ERROR

$ERRNO

$!

При обращении к $!, извлекается текущее значение целочисленной переменной C 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, или чтобы восстановить $! в осмысленное состояние.

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

%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, с которой был вызван 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, не написанным в UTF-8, не нуждаться в 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 pragma.

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

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' реализован. Вот условная версия того же лексического pragmy:

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

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

%^H

Хеш-таблица %^H обеспечивает ту же семантику лексического объявления, что и $^H. Это делает её полезной для реализации лексически объявленных pragm. См. 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

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

0x200

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

0x400

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

0x800

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

0x1000

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

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

${^TAINT}

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

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

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

${^SAFE_LOCALES}

Отражает, доступны ли безопасные операции с локалью для данного perl (значение 1) или нет (значение 0). Эта переменная всегда равна 1, если perl был скомпилирован без поддержки потоков. Также она равна 1, если данный perl использует безопасные операции с локалью для потоков. Обратите внимание, что отдельный поток может выбрать использование глобальной локали (обычно небезопасной), вызвав "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.