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» или объектами version), и числовые сравнения иногда могут давать сбои; она подходит для проверки версий буквенных строк и не подходит для сравнения с переменной, которая не была проверена на корректность.

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

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

$SYSTEM_FD_MAX

$^F

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

@F

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

@INC

Массив @INC содержит список мест, где конструкции do EXPR, require, или use ищут файлы библиотек. Он первоначально состоит из аргументов любых флагов -I командной строки, за которым следует стандартная библиотека Perl, вероятно, /usr/local/lib/perl, за которым следует «.» для обозначения текущей директории. (Символ «.» не будет добавлен, если проверки taint включены, как и -T или -t, или если это не настроено в компиляторе -Ddefault_inc_excludes_dot.) Если вам нужно изменить это во время выполнения, вы должны использовать прагму 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()ing. Предположим, что ваш Perl был скомпилирован с -DPERL_EMERGENCY_SBRK и использовал malloc Perl. Тогда

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

выделит буфер размером 64 КБ для использования в экстренных случаях. Информация о том, как добавить пользовательские флаги компиляции C при компиляции perl, содержится в файле INSTALL в дистрибутиве 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 из такого обработчика, вероятно, приведёт к ошибке сегментации. Это означает, что предупреждения или ошибки, возникающие в результате анализа 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, так и для объектов версии:

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", "%{^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

$+

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

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

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

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

$LAST_SUBMATCH_RESULT

$^N

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

Это в первую очередь используется внутри (?{...}) блоков для проверки недавно сопоставленного текста. Например, чтобы эффективно сохранить текст в переменной (в дополнение к $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_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 должен быть лучше чем-то. :-)

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

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

$|

Если установлено ненулевое значение, вызывает сброс сразу и после каждой записи или print на текущем выбранном выходном канале. По умолчанию 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

$-

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

Мнемоника: lines_on_page - lines_printed.

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 может содержать более подробный индикатор ошибки, например, «Лоток CD-ROM не закрыт» в этом случае. Системы, не поддерживающие расширенные сообщения об ошибках, оставляют $^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, в противном случае ложно, но непосредственно изменяемо.

См. также warnings.

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

${^WARNING_BITS}

Текущий набор проверок предупреждений, включённых директивой use warnings. Она имеет тот же область действия, что и переменные $^H и %^H. Точные значения считаются внутренними для директивы warnings и могут меняться между версиями 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. См. документацию по переключателю -C в perlrun для получения дополнительной информации о возможных значениях.

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

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

${^UTF8CACHE}

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

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

${^UTF8LOCALE}

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

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

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

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

Присвоение ненулевого значения будет критическим в Perl v5.30.0.