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()) даже при использовании pragmy 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 $] lt '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 содержит поля каждой строки, прочитанной при включенном режиме autosplit. См. 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

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

Мнемоническое правило: значение параметра -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 для получения дополнительной информации об этом специальном случае.

Вот еще несколько примеров:

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

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

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

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

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

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

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

local $SIG{__WARN__} = sub {};

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

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

__DIE__/__WARN__ обработчики очень особенные в одном отношении: они могут быть вызваны для отчёта (вероятных) ошибок, обнаруженных анализатором. В таком случае анализатор может быть в несогласованном состоянии, поэтому любая попытка оценить код Perl из такого обработчика, вероятно, приведёт к ошибке segfault. Это означает, что предупреждения или ошибки, возникшие в результате анализа 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` или 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 она будет иметь значение undefined. До версии 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 для объекта версии.

${^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(). Дополнительные сведения см. в "Операторы ввода/вывода" в 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.

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

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

IO::Handle->output_record_separator( EXPR )

$OUTPUT_RECORD_SEPARATOR

$ORS

$\

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

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

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

HANDLE->autoflush( EXPR )

$OUTPUT_AUTOFLUSH

$|

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

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

${^LAST_FH}

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

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

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

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

$ACCUMULATOR

$^A

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

IO::Handle->format_formfeed(EXPR)

$FORMAT_FORMFEED

$^L

Формат вывода, как перевод страницы. Значение по умолчанию — \f.

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

HANDLE->format_page_number(EXPR)

$FORMAT_PAGE_NUMBER

$%

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

Мемоническое правило: % — это номер страницы в nroff.

HANDLE->format_lines_left(EXPR)

$FORMAT_LINES_LEFT

$-

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

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

IO::Handle->format_line_break_characters EXPR

$FORMAT_LINE_BREAK_CHARACTERS

$:

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

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

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

HANDLE->format_lines_per_page(EXPR)

$FORMAT_LINES_PER_PAGE

$=

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

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

HANDLE->format_top_name(EXPR)

$FORMAT_TOP_NAME

$^

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

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

HANDLE->format_name(EXPR)

$FORMAT_NAME

$~

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

Мемоническое правило: брат $^.

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

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

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

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

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

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

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

Наконец, $? может быть установлено в ненулевое значение, если внешняя программа /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; т.е. оно такое же, как $? когда действует pragma 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 с которой он был вызван. Форма 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, первая часть описывает входные слои, вторая — выходные.

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

Отражает определённые настройки 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, когда он находится в режиме корректировки UTF-8 в соответствии с локалью (например, при запуске с переключателем командной строки -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.