perlvar

СОДЕРЖАНИЕ

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

ИМЯ

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

ОПИСАНИЕ

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

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

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

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

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

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

ENV      STDIN
INC      STDOUT
ARGV     STDERR
ARGVOUT
SIG

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

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

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

use English;

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

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

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

$ARG

$_

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

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

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

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

chomp
chomp($_)

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

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

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

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

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

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

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

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

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

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

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

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

@ARG

@_

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

См. perlsub.

$LIST_SEPARATOR

$"

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

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

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

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

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

$PROCESS_ID

$PID

$$

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

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

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

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

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

Мемоническое правило: так же, как в оболочках.

$PROGRAM_NAME

$0

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

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

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

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

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

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

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

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

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

Мемоническое правило: так же, как в sh и ksh.

$REAL_GROUP_ID

$GID

$(

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

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

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

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

$EFFECTIVE_GROUP_ID

$EGID

$)

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

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

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

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

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

$REAL_USER_ID

$UID

$<

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

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

$EFFECTIVE_USER_ID

$EUID

$>

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

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

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

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

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

$SUBSCRIPT_SEPARATOR

$SUBSEP

$;

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

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

это означает

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

Но не ставьте

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

что означает

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

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

Рассмотрите использование «реальных» многомерных массивов, как описано в perllol.

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

$a

$b

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

%ENV

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

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

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

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

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

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

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

$OLD_PERL_VERSION

$]

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

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

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

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

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

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

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

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

Мнемоника: находится ли эта версия perl в правильных скобках?

$SYSTEM_FD_MAX

$^F

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

@F

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

@INC

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

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

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

%INC

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

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

$INPLACE_EDIT

$^I

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

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

@ISA

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

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

$^M

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

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

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

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

$OSNAME

$^O

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

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

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

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

%SIG

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

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

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

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

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

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

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

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

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

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

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

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

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

local $SIG{__WARN__} = sub {};

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

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

Хук $SIG{__DIE__} не поддерживает 'IGNORE'; он имеет тот же эффект, что и 'DEFAULT'.

__DIE__/__WARN__ обработчики очень специфичны в одном отношении: они могут быть вызваны для сообщения (вероятных) ошибок, найденных парсером. В этом случае парсер может быть в несогласованном состоянии, поэтому любая попытка оценить Perl-код из такого обработчика, вероятно, приведёт к 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__} в текущей реализации вызывает трудно отслеживаемые ошибки. Избегайте её и используйте переопределение END{} или CORE::GLOBAL::die вместо неё.

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

$BASETIME

$^T

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

$PERL_VERSION

$^V

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

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

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

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

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

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

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

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

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

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

$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 по умолчанию была включена новая система copy-on-write, которая, наконец, решила все проблемы с производительностью этих трёх переменных и сделала их безопасными для использования в любом месте.

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

print "${^CAPTURE[0]}"

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

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

$MATCH

$&

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

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

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

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

${^MATCH}

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

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

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

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

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

$PREMATCH

$`

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

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

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

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

${^PREMATCH}

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

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

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

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

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

$POSTMATCH

$'

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

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

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

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

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

${^POSTMATCH}

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

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

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

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

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

$LAST_PAREN_MATCH

$+

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

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

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

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

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

$LAST_SUBMATCH_RESULT

$^N

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

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

у нас есть

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

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

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

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

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

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

@LAST_MATCH_END

@+

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

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

%{^CAPTURE}

%LAST_PAREN_MATCH

%+

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

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

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

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

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

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

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

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

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

@LAST_MATCH_START

@-

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

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

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

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

$` является тем же, что и substr($var, 0, $-[0])

$& является тем же, что и substr($var, $-[0], $+[0] - $-[0])

$' является тем же, что и substr($var, $+[0])

$1 является тем же, что и substr($var, $-[1], $+[1] - $-[1])

$2 является тем же, что и substr($var, $-[2], $+[2] - $-[2])

$3 является тем же, что и substr($var, $-[3], $+[3] - $-[3])

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

%{^CAPTURE_ALL}

%-

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

Вот пример:

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

что выведет:

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

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

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

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

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

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

$LAST_REGEXP_CODE_RESULT

$^R

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

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

${^RE_COMPILE_RECURSION_LIMIT}

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

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

${^RE_DEBUG_FLAGS}

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

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

${^RE_TRIE_MAXBUF}

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

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

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

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

use IO::Handle;

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

method HANDLE EXPR

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

HANDLE->method(EXPR)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

"1\f2\f3\f"

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

local $\ = "\f";

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

$ARGV

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

@ARGV

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

ARGV

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

ARGVOUT

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

IO::Handle->output_field_separator( EXPR )

$OUTPUT_FIELD_SEPARATOR

$OFS

$,

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

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

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

HANDLE->input_line_number( EXPR )

$INPUT_LINE_NUMBER

$NR

$.

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

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

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

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

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

Мнемоника: во многих программах "." обозначает текущий номер строки.

IO::Handle->input_record_separator( EXPR )

$INPUT_RECORD_SEPARATOR

$RS

$/

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

IO::Handle->output_record_separator( EXPR )

$OUTPUT_RECORD_SEPARATOR

$ORS

$\

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

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

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

HANDLE->autoflush( EXPR )

$OUTPUT_AUTOFLUSH

$|

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

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

${^LAST_FH}

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

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

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

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

$ACCUMULATOR

$^A

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

IO::Handle->format_formfeed(EXPR)

$FORMAT_FORMFEED

$^L

Формат, выводящий символ перевода страницы. По умолчанию \f.

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

HANDLE->format_page_number(EXPR)

$FORMAT_PAGE_NUMBER

$%

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

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

HANDLE->format_lines_left(EXPR)

$FORMAT_LINES_LEFT

$-

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

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

IO::Handle->format_line_break_characters EXPR

$FORMAT_LINE_BREAK_CHARACTERS

$:

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

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

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

HANDLE->format_lines_per_page(EXPR)

$FORMAT_LINES_PER_PAGE

$=

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

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

HANDLE->format_top_name(EXPR)

$FORMAT_TOP_NAME

$^

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

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

HANDLE->format_name(EXPR)

$FORMAT_NAME

$~

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

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

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

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

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

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

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

$@ устанавливается, если строка для eval-ирования не скомпилировалась (это может произойти, если open или close были импортированы с неправильными прототипами) или если во время вычисления была выполнена Perl-код die(). В этих случаях значение $@ - ошибка компиляции или аргумент 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, предоставляемых модулем POSIX.

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

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

$EXTENDED_OS_ERROR

$^E

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

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

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

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

Замечания, упомянутые в описании "$!", обычно относятся и к $^E.

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

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

$EXCEPTIONS_BEING_CAUGHT

$^S

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

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

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

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

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

$WARNING

$^W

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

См. также warnings.

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

${^WARNING_BITS}

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

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

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

$OS_ERROR

$ERRNO

$!

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

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

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

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

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

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

%OS_ERROR

%ERRNO

%!

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

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

$CHILD_ERROR

$?

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

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

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

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

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

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

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

$EVAL_ERROR

$@

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

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

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

Мнемоника: Где была ошибка "в"?

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

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

$COMPILING

$^C

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

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

$DEBUGGING

$^D

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

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

${^GLOBAL_PHASE}

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

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

CONSTRUCT

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

START

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

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

CHECK

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

INIT

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

RUN

Основная фаза выполнения, т.е. выполнение PL_main_root.

END

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

DESTRUCT

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

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

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

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

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

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

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

{
    package Print::Phase;

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

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

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

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

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

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

Это выведет

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

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

$^H

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

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

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

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

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

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

sub add_100 { $^H |= 0x100 }

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

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

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

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

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

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

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

%^H

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

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

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

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

${^OPEN}

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

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

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

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

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

$PERLDB

$^P

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

0x01

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

0x02

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

0x04

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

0x08

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

0x10

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

0x20

Запуск с включённой одношаговой отладки.

0x40

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

0x80

Отчёт об goto &subroutine также.

0x100

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

0x200

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

0x400

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

0x800

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

0x1000

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

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

${^TAINT}

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

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

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

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

${^SAFE_LOCALES}

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

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

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

${^UNICODE}

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

Эта переменная устанавливается во время запуска 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.

${^ENCODING}

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

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

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

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

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

local ${^ENCODING};

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

Эта переменная была добавлена в Perl 5.8.2 и удалена в 5.26.0. Присвоение ей любого значения, отличного от undef, привело к ошибке в Perl 5.28.0.

${^WIN32_SLOPPY_STAT}

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

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