perlsyn — онлайн в облаке

ПРОГРАММА:

ИМЯ

perlsyn - синтаксис Perl

ОПИСАНИЕ

Программа Perl состоит из последовательности объявлений и операторов, которые запускаются из
сверху вниз. Циклы, подпрограммы и другие управляющие структуры позволяют
внутри кода.

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

Многие из синтаксических элементов Perl необязательный. Вместо того, чтобы требовать от вас поставить
скобки вокруг каждого вызова функции и объявлять каждую переменную, вы часто можете оставить
отключите такие явные элементы, и Perl поймет, что вы имели в виду. Это известно как Do
Что I среднеесокращенно ДВИМ. Это позволяет программистам быть ленивый и кодировать в стиле
с которым им комфортно.

Perl заимствует синтаксис и концепции из многих языков: awk, sed, C, Bourne Shell,
Smalltalk, Lisp и даже английский. Другие языки позаимствовали синтаксис у Perl.
особенно его расширения регулярных выражений. Итак, если вы запрограммировали в другом
языке вы увидите знакомые куски в Perl. Они часто работают одинаково, но видят perltrap
для получения информации о том, чем они отличаются.

Объявления
Единственное, что вам нужно объявить в Perl, это форматы отчетов и подпрограммы (и
иногда даже не подпрограммы). Скалярная переменная содержит неопределенное значение ("undef").
пока ему не будет присвоено определенное значение, отличное от "undef". Когда
используется как число, "undef" рассматривается как 0; при использовании в виде строки он рассматривается как
пустой строки, ""; и при использовании в качестве ссылки, которой не назначается, она обрабатывается
как ошибка. Если вы включите предупреждения, вы будете уведомлены о неинициализированном значении
всякий раз, когда вы обрабатываете "undef" как строку или число. Ну, обычно. логические контексты,
, таких как:

если ($а) {}

освобождены от предупреждений (поскольку они заботятся об истине, а не о определенности).
Такие операторы, как "++", "--", "+=", "-=" и ".=", которые работают с неопределенными переменными.
, таких как:

неопределенный $а;
$ a ++;

также всегда освобождаются от таких предупреждений.

Объявление может быть помещено везде, где может быть оператор, но оно не влияет на выполнение
основная последовательность операторов: все объявления вступают в силу во время компиляции. Все
объявления обычно помещаются в начале или в конце скрипта. Однако, если
вы используете закрытые переменные с лексической областью видимости, созданные с помощью «my()», «state()» или
"наш()", вы должны убедиться, что ваш формат или определение подпрограммы находятся в одном и том же
block scope как my, если вы ожидаете получить доступ к этим закрытым переменным.

Объявление подпрограммы позволяет использовать имя подпрограммы, как если бы это был оператор списка.
с этого момента вперед в программе. Вы можете объявить подпрограмму, не определяя ее
произнося «дополнительное имя», таким образом:

под моим именем;
$me = мое имя $0 или умереть "не могу получить мое имя";

Подобное голое объявление объявляет функцию оператором списка, а не унарным.
оператора, поэтому вы должны быть осторожны, используя круглые скобки (или "или" вместо "||".)
"||" оператор связывает слишком сильно, чтобы использовать его после операторов списка; он становится частью последнего
элемент. Вы всегда можете использовать круглые скобки вокруг аргументов операторов списка, чтобы
list обратно во что-то, что больше похоже на вызов функции. Альтернативно,
вы можете использовать прототип "($)", чтобы превратить подпрограмму в унарный оператор:

под моим именем ($);
$me = мое имя $0 || умереть "не могу получить мое имя";

Теперь это анализируется так, как вы ожидаете, но вы все равно должны привыкнуть использовать
скобки в этой ситуации. Подробнее о прототипах см. perlsub.

Объявления подпрограмм также могут быть загружены с помощью оператора «require» или загружены одновременно.
и импортируется в ваше пространство имен с оператором «использовать». См. perlmod для получения подробной информации об этом.

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

Комментарии
Текст от символа "#" до конца строки является комментарием и игнорируется.
Исключения включают "#" внутри строки или регулярного выражения.

просто Отчеты
Единственный вид простого оператора — это выражение, оцениваемое по его побочным эффектам. Каждый
простой оператор должен заканчиваться точкой с запятой, если только он не является последним оператором в
блок, в этом случае точка с запятой необязательна. Но в любом случае поставьте точку с запятой, если
блок занимает более одной строки, потому что со временем вы можете добавить еще одну строку. Обратите внимание, что
есть такие операторы, как "eval {}", "sub {}" и "do {}", которые смотреть как соединение
операторы, но не являются - они просто ТЕРМИНЫ в выражении - и, следовательно, нуждаются в явном
завершение при использовании в качестве последнего элемента в выражении.

Truth и ложность
Число 0, строки '0' и "", пустой список "()" и "undef" ложны в
логический контекст. Все остальные значения верны. Отрицание истинного значения с помощью "!" или нет"
возвращает специальное ложное значение. При вычислении в виде строки она обрабатывается как "", но как
число, оно считается равным 0. Большинство операторов Perl, возвращающих true или false, ведут себя так.
пути.

заявление Модификаторы
Любое простое утверждение может при желании сопровождаться SINGLE модификатор, непосредственно перед
завершающая точка с запятой (или окончание блока). Возможные модификаторы:

если EXPR
если EXPR
в то время как EXPR
до EXPR
для СПИСКА
СПИСОК
когда EXPR

«EXPR», следующее за модификатором, называется «условием». Это правда или
falsehood определяет поведение модификатора.

"if" выполняет оператор один раз if и только если условие истинно. "если" это
напротив, он выполняет оператор если не условие истинно (т. е. если
условие ложно).

выведите "У бассет-хаундов длинные уши", если длина $ear >= 10;
go_outside() и play(), если только $is_raining;

Модификатор for(each) — это итератор: он выполняет оператор один раз для каждого элемента в
СПИСОК (с псевдонимом $_ для каждого элемента по очереди).

напечатайте "Hello $_!\n" для qw(мировая медсестра Долли);

"пока" повторяет оператор в то время как условие истинно. "пока" не делает наоборот, это
повторяет заявление до условие истинно (или пока условие ложно):

# Оба они считаются от 0 до 10.
вывести $i++, пока $i <= 10;
печатать $j++ до тех пор, пока $j > 10;

Модификаторы «пока» и «пока» имеют обычную семантику цикла «пока» (условное
оценивается первой), кроме тех случаев, когда применяется к блоку "do"-BLOCK (или к блоку "do"-SUBROUTINE в Perl4).
оператор), и в этом случае блок выполняется один раз перед вычислением условного выражения.

Это так, что вы можете писать циклы, как:

делать {
$строка = ;
...
} до тех пор, пока не !defined($line) || $строка, эквивалентная ".\n"

См. «делать» в perlfunc. Заметьте также, что операторы управления циклом, описанные ниже, будут НЕ
работают в этой конструкции, потому что модификаторы не принимают метки цикла. Прости. Вы всегда можете
поместите другой блок внутри него (для «следующего») или вокруг него (для «последнего»), чтобы сделать что-то вроде
вещь. Для «далее» просто удвойте фигурные скобки:

делать {{
следующий, если $x == $y;
# сделай что-нибудь здесь
}} пока $x++ > $z;

Для «последнего» вы должны быть более сложными:

ПЕТЛЯ: {
делать {
последний, если $x = $y**2;
# сделай что-нибудь здесь
} пока $x++ <= $z;
}

ПРИМЕЧАНИЕ: Поведение «моего», «состояния» или «нашего», измененного с помощью модификатора оператора
условная конструкция или конструкция цикла (например, "my $x if...") не определено, Значение
переменная "my" может быть "undef", любым ранее присвоенным значением или, возможно, чем угодно
еще. Не полагайтесь на это. Будущие версии perl могут делать что-то отличное от
версии Perl, на которой вы попробуете это. Вот драконы.

Модификатор «когда» — экспериментальная функция, впервые появившаяся в Perl 5.14. Использовать
это, вы должны включить объявление «использовать v5.14». (Технически требуется только
функция «переключатель», но этот аспект был недоступен до версии 5.14.) Только в рабочем состоянии
из цикла foreach или заданного блока он выполняет оператор только в том случае, если
смартматч "$_ ~~ EXPR » правда. Если оператор выполняется, за ним следует «следующий».
изнутри "foreach" и "break" изнутри "данного".

В текущей реализации цикл foreach может находиться в любом месте внутри поля "когда".
динамическая область действия модификатора, но должна находиться в пределах лексической области действия «данного» блока. Этот
ограничения могут быть ослаблены в будущем выпуске. См. «Выражения Switch» ниже.

Соединение Отчеты
В Perl последовательность операторов, определяющая область действия, называется блоком. Иногда
блок ограничивается содержащим его файлом (в случае требуемого файла или
программы в целом), а иногда блок ограничивается длиной строки (в
случай оценки).

Но обычно блок ограничивается фигурными скобками, также известными как фигурные скобки. мы позвоним
эта синтаксическая конструкция БЛОК.

Следующие составные операторы могут использоваться для управления потоком:

если (EXPR) БЛОК
if (EXPR) БЛОК else БЛОК
if (EXPR) БЛОК elsif (EXPR) БЛОК ...
if (EXPR) БЛОКИРОВАТЬ elsif (EXPR) БЛОКИРОВАТЬ ... иначе БЛОКИРОВАТЬ

если (EXPR) БЛОК
если (EXPR) БЛОК else БЛОК
если (EXPR) БЛОК elsif (EXPR) БЛОК ...
если (EXPR) БЛОК elsif (EXPR) БЛОК ... иначе БЛОК

данный (EXPR) БЛОК

LABEL в то время как (EXPR) БЛОК
LABEL while (EXPR) БЛОК продолжить БЛОК

ЭТИКЕТКА до (EXPR) БЛОК
ЭТИКЕТКА до (EXPR) БЛОК продолжить БЛОК

ЭТИКЕТКА для (EXPR; EXPR; EXPR) БЛОК
ЭТИКЕТКА ДЛЯ БЛОКА VAR (СПИСОК)
ЭТИКЕТКА для VAR (СПИСОК) БЛОК продолжить БЛОК

МЕТКА foreach (EXPR; EXPR; EXPR) БЛОК
LABEL foreach VAR (СПИСОК) БЛОК
МЕТКА foreach VAR (СПИСОК) БЛОК продолжить БЛОК

БЛОК ЭТИКЕТКИ
ЭТИКЕТКА БЛОК продолжить БЛОК

ФАЗНЫЙ БЛОК

Экспериментальное «данное» утверждение автоматически включен; см. "Выражения Switch"
ниже, как это сделать, и сопутствующие предостережения.

В отличие от C и Pascal, в Perl все они определяются в терминах БЛОКОВ, а не операторов.
Это означает, что фигурные скобки обязательный-- не допускаются висячие операторы. если ты
хотите написать условные операторы без фигурных скобок, есть несколько других способов сделать это.
Следующие действия делают одно и то же:

if (!open(FOO)) { die "Не могу открыть $FOO: $!" }
die "Не могу открыть $FOO: $!" если не открыто (FOO);
открыть(ФОО) || die "Не удается открыть $FOO: $!";
открыть (FOO) ? () : die "Не могу открыть $FOO: $!";
# немного экзотично, последнее

Оператор «если» прост. Поскольку БЛОКИ всегда ограничены фигурными
скобки, никогда не бывает двусмысленности в отношении того, с каким «если» следует «иначе». Если вы используете
«если» вместо «если» смысл теста меняется на противоположный. Как "если", "если" может быть
затем «другое». «если» может даже сопровождаться одним или несколькими операторами «elsif»,
хотя вы можете подумать дважды, прежде чем использовать эту конкретную языковую конструкцию, так как
всем, кто читает ваш код, придется подумать как минимум дважды, прежде чем он сможет понять
что происходит.

Оператор while выполняет блок до тех пор, пока выражение истинно. "до"
оператор выполняет блок до тех пор, пока выражение ложно. ЭТИКЕТКА необязательна,
и если присутствует, состоит из идентификатора, за которым следует двоеточие. ЭТИКЕТКА идентифицирует
цикл для операторов управления циклом «следующий», «последний» и «повторить». Если LABEL опущен,
оператор управления циклом относится к самому внутреннему охватывающему циклу. Это может включать
динамически просматривая ваш стек вызовов во время выполнения, чтобы найти LABEL. Такой отчаянный
поведение вызывает предупреждение, если вы используете прагму «использовать предупреждения» или -w флаг.

Если есть БЛОК «продолжить», он всегда выполняется непосредственно перед выполнением условия.
для повторной оценки. Таким образом, его можно использовать для увеличения переменной цикла, даже если
цикл был продолжен оператором «следующий».

Когда блоку предшествует ключевое слово фазы компиляции, такое как "BEGIN", "END", "INIT",
"CHECK" или "UNITCHECK", тогда блок будет выполняться только во время соответствующей фазы
исполнение. См. perlmod для более подробной информации.

Модули расширения также могут подключаться к синтаксическому анализатору Perl для определения новых типов соединений.
заявления. Они представлены ключевым словом, которое распознает расширение, и
синтаксис, следующий за ключевым словом, полностью определяется расширением. Если вы
разработчик, см. "PL_keyword_plugin" в perlapi, чтобы узнать о механизме. Если вы используете такие
модуль, см. документацию модуля для получения подробной информации о синтаксисе, который он определяет.

Петля Control
Команда «next» запускает следующую итерацию цикла:

СТРОКА: пока ( ) {
следующая СТРОКА, если /^#/; # удалить комментарии
...
}

«Последняя» команда немедленно выходит из рассматриваемого цикла. Блок «продолжить», если есть,
не выполняется:

СТРОКА: пока ( ) {
последняя СТРОКА if / ^ $ /; # выход по завершении с заголовком
...
}

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

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

в то время как (<>) {
чавкать;
если (с/\\$//) {
$_ .= <>;
повторить, если только eof();
}
# теперь обработаем $_
}

что является сокращением Perl для более явно написанной версии:

LINE: в то время как (определено ($ line = )) {
жевать ($ линия);
если ($line =~ s/\\$//) {
$ строка .= ;
повторить LINE, если только eof(); # не eof(ARGV)!
}
# теперь обрабатываем $line
}

Обратите внимание, что если бы в приведенном выше коде был блок «продолжить», он был бы выполнен только
в строках, отброшенных регулярным выражением (поскольку повтор пропускает блок продолжения). Блок продолжения
часто используется для сброса счетчиков строк или "m?pat?" одноразовые совпадения:

# вдохновлено :1,$g/fred/s//WILMA/
в то время как (<>) {
м? (фред)? && s//ВИЛМА $1 ВИЛМА/;
м? (барни)? && s//БЕТТИ $1 БЕТТИ/;
м? (Гомер)? && s//МАРДЖ $1 МАРДЖ/;
} Продолжить {
print "$ARGV $.: $_";
закрыть ARGV, если eof; # сбросить $.
сбросить, если eof; # сбросить ?pat?
}

Если слово «пока» заменить словом «до тех пор», смысл теста изменится на противоположный.
но условное выражение все еще проверяется перед первой итерацией.

Операторы управления циклом не работают в «если» или «если», поскольку они не являются циклами. Ты
Однако можно удвоить фигурные скобки, чтобы сделать их такими.

если (/шаблон/) {{
последний, если /fred/;
следующий, если /барни/; # тот же эффект, что и "последний",
# но не документирует
# сделай что-нибудь здесь
}}

Это вызвано тем, что блок сам по себе действует как цикл, который выполняется один раз, см.
«Основные БЛОКИ».

Форма «пока/если БЛОК БЛОК», доступная в Perl 4, больше не доступна. Заменять
любое появление «if BLOCK» на «if (do BLOCK)».

Что касается Петли
Цикл For в стиле C в Perl работает так же, как и соответствующий цикл while; это означает, что это:

for ($ i = 1; $ i <10; $ i ++) {
...
}

то же самое, что и это:

$ i = 1;
в то время как ($ я < 10) {
...
} Продолжить {
$ I ++;
}

Есть одно небольшое отличие: если переменные объявлены с "my" при инициализации
раздел «for», лексическая область действия этих переменных точно соответствует циклу «for» (т.
тело цикла и управляющие секции).

Как частный случай, если проверка в цикле for (или соответствующем цикле while)
пустой, он считается истинным. То есть оба

для (;;) {
...
}

и

в то время как () {
...
}

рассматриваются как бесконечные циклы.

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

$on_a_tty = -t STDIN && -t STDOUT;
подсказка { напечатать "да?", если $on_a_tty}
для (подсказка(); ; быстрый() ) {
# сделай что-нибудь
}

Используя "readline" (или операторную форму, " "), так как условие цикла "for"
сокращение для следующего. Это поведение аналогично условному циклу while.

для ( приглашение (); определено ( $ _ = ); быстрый() ) {
# сделай что-нибудь
}

Для каждого Петли
Цикл foreach перебирает обычное значение списка и устанавливает скалярную переменную VAR в значение
быть каждым элементом списка по очереди. Если переменной предшествует ключевое слово "my",
тогда он имеет лексическую область действия и, следовательно, виден только внутри цикла. В противном случае,
переменная неявно является локальной для цикла и восстанавливает свое прежнее значение при выходе из цикла.
петля. Если переменная была ранее объявлена ​​с «my», она использует эту переменную вместо
глобальный, но он все еще локализован в цикле. Эта неявная локализация происходит
Важно в цикле foreach.

Ключевое слово foreach на самом деле является синонимом ключевого слова for, поэтому вы можете использовать любое из них.
Если VAR опущен, $_ устанавливается для каждого значения.

Если какой-либо элемент LIST является lvalue, вы можете изменить его, изменив VAR внутри цикла.
И наоборот, если какой-либо элемент LIST НЕ является lvalue, любая попытка изменить этот элемент
не удастся. Другими словами, индексная переменная цикла foreach является неявным псевдонимом для
каждый элемент в списке, который вы зацикливаете.

Если какая-либо часть LIST является массивом, "foreach" сильно запутается, если вы добавите или удалите
элементы внутри тела цикла, например, с помощью «splice». Так что не делай этого.

foreach, вероятно, не будет делать то, что вы ожидаете, если VAR является связанной или другой специальной переменной.
Не делай и этого.

Начиная с Perl 5.22 существует экспериментальный вариант этого цикла, который принимает переменную
перед которым ставится обратная косая черта для VAR, и в этом случае элементы в СПИСОК должны быть ссылками.
Переменная с обратной косой чертой станет псевдонимом для каждого элемента, на который есть ссылка в СПИСОК, который
должен быть правильного типа. В этом случае переменная не обязательно должна быть скалярной, и
после обратной косой черты может следовать «мой». Чтобы использовать эту форму, вы должны включить "рефальсификацию"
функцию через «использовать функцию». (См. функцию. См. также «Назначение ссылок» в perlref.)

Примеры:

для (@ary) {s/foo/bar/}

для моего $elem (@elements) {
$ elem * = 2;
}

для $count (обратное (1..10), "БУМ") {
напечатать $count, "\n";
спать(1);
}

for (1..15) { print "Счастливого Рождества\n"; }

foreach $item (split(/:[\\\n:]*/, $ENV{TERMCAP})) {
print "Элемент: $item\n";
}

использовать функцию «рефалисинг»;
нет предупреждений "экспериментальный :: рефализинг";
foreach \мой %хэш (@array_of_hash_references) {
# сделать что-то, что каждый %hash
}

Вот как программист на C может написать конкретный алгоритм на Perl:

для (мой $i = 0; $i < @ary1; $i++) {
for (мой $j = 0; $j < @ary2; $j++) {
если ($ary1[$i] > $ary2[$j]) {
последний; # не могу перейти во внешний :-(
}
$ary1[$i] += $ary2[$j];
}
# вот куда меня занесло последнее
}

А вот как программист на Perl, более знакомый с идиомой, может это сделать:

ВНЕШНИЙ: для моего $wid (@ary1) {
ВНУТРЕННЯЯ: для моего $jet (@ary2) {
следующий ВНЕШНИЙ, если $wid > $jet;
$вид += $струя;
}
}

Видите, насколько это проще? Это чище, безопаснее и быстрее. Это чище, потому что это
менее шумный. Это безопаснее, потому что если код будет добавлен между внутренним и внешним циклами позже
включен, новый код не будет случайно выполнен. «Следующий» явно повторяет другой
цикл, а не просто завершающий внутренний. И это быстрее, потому что Perl выполняет
оператор foreach быстрее, чем эквивалентный цикл for.

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

Базовый БЛОКИРОВКИ
БЛОК сам по себе (помеченный или нет) семантически эквивалентен циклу, который выполняет
однажды. Таким образом, вы можете использовать любой из операторов управления циклом, чтобы выйти или перезапустить цикл.
блокировать. (Обратите внимание, что это НЕ верно в "eval{}", "sub{}" или вопреки распространенному мнению
блоки do{}, которые делают НЕ считаются циклами.) Блок «продолжить» является необязательным.

Конструкция BLOCK может использоваться для имитации структуры case.

ВЫКЛЮЧАТЕЛЬ: {
если (/^abc/) { $abc = 1; последний ПЕРЕКЛЮЧАТЕЛЬ; }
если (/^def/) { $def = 1; последний ПЕРЕКЛЮЧАТЕЛЬ; }
если (/^xyz/) { $xyz = 1; последний ПЕРЕКЛЮЧАТЕЛЬ; }
$ничего = 1;
}

Вы также обнаружите, что цикл foreach используется для создания топикализатора и переключателя:

ПЕРЕКЛЮЧАТЕЛЬ:
для ($ вар) {
если (/^abc/) { $abc = 1; последний ПЕРЕКЛЮЧАТЕЛЬ; }
если (/^def/) { $def = 1; последний ПЕРЕКЛЮЧАТЕЛЬ; }
если (/^xyz/) { $xyz = 1; последний ПЕРЕКЛЮЧАТЕЛЬ; }
$ничего = 1;
}

Такие конструкции используются довольно часто, поскольку в старых версиях Perl их не было.
официальное заявление о «переключении», а также потому, что новая версия описана сразу ниже
остается экспериментальным и иногда может сбивать с толку.

Коммутатор Отчеты
Начиная с Perl 5.10.1 (ну, 5.10.0, но он не работал правильно), можно сказать

использовать функцию «переключатель»;

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

используйте v5.14;

Под функцией «переключатель» Perl получает экспериментальные ключевые слова «дано», «когда»,
«по умолчанию», «продолжить» и «перерыв». Начиная с Perl 5.16, перед переключателем можно поставить префикс
ключевые слова с «CORE::», чтобы получить доступ к функции без оператора «использовать функцию». То
ключевые слова «дано» и «когда» аналогичны «переключателю» и «регистру» в других языках, поэтому
код из предыдущего раздела можно было бы переписать как

используйте v5.10.1;
для ($ вар) {
когда (/^abc/) {$abc = 1}
когда (/^def/) {$def = 1}
когда (/^xyz/) {$xyz = 1}
по умолчанию { $ ничего = 1 }
}

«Foreach» — это не экспериментальный способ установки топикализатора. Если вы хотите использовать
очень экспериментальное «данное», которое можно было бы записать так:

используйте v5.10.1;
дано ($ вар) {
когда (/^abc/) {$abc = 1}
когда (/^def/) {$def = 1}
когда (/^xyz/) {$xyz = 1}
по умолчанию { $ ничего = 1 }
}

Начиная с версии 5.14 это также можно записать так:

используйте v5.14;
для ($ вар) {
$abc = 1, когда /^abc/;
$def = 1, когда /^def/;
$xyz = 1, когда /^xyz/;
по умолчанию { $ ничего = 1 }
}

Или, если вы не хотите перестраховаться, вот так:

используйте v5.14;
дано ($ вар) {
$abc = 1, когда /^abc/;
$def = 1, когда /^def/;
$xyz = 1, когда /^xyz/;
по умолчанию { $ ничего = 1 }
}

Аргументы «дано» и «когда» находятся в скалярном контексте, а «дано» присваивает $_
переменная значение темы.

Именно то, что EXPR аргумент «когда» трудно описать точно, но в
вообще, он пытается угадать, что вы хотите сделать. Иногда интерпретируется как "$_ ~~
EXPR », а иногда и нет. Он также ведет себя по-разному, когда лексически заключен в
"данный" блок, чем когда он динамически заключен в цикл "foreach". Правила
слишком сложно для понимания, чтобы описывать его здесь. См. "Экспериментальные детали данного
и когда" позже.

Из-за досадной ошибки в том, как "дано" было реализовано между Perl 5.10 и 5.16, под
в этих реализациях версия $_, управляемая "данным", является просто лексически ограниченной
копия оригинала, а не динамический псевдоним оригинала, как было бы, если бы он
были «foreach» или соответствовали как исходной, так и текущей спецификации языка Perl 6.
Эта ошибка была исправлена ​​в Perl 5.18. Если вам действительно нужен лексический $_, укажите, что
явно, но обратите внимание, что "my $_" теперь устарело и будет предупреждать, если предупреждения не были
был отключен:

данный (мой $_ = EXPR) { ... }

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

Идти к
Хотя Perl не для слабонервных, он поддерживает оператор goto. Есть
три формы: "goto"-LABEL, "goto"-EXPR и "goto"-&NAME. LABEL цикла на самом деле не
действительная цель для "goto"; это просто название петли.

Форма "goto"-LABEL находит оператор, помеченный LABEL, и возобновляет выполнение там.
Его нельзя использовать для входа в какую-либо конструкцию, требующую инициализации, такую ​​как
подпрограмма или цикл foreach. Его также нельзя использовать для входа в конструкцию, которая
оптимизированы. Его можно использовать для перехода практически в любое другое место в пределах динамической области видимости.
в том числе из подпрограмм, но обычно лучше использовать какую-то другую конструкцию, такую ​​как
«последним» или «умереть». Автор Perl никогда не чувствовал необходимости использовать эту форму «goto».
(в Perl это другое дело).

Форма "goto"-EXPR предполагает имя метки, область видимости которой будет определяться динамически. Этот
позволяет вычислять "goto" для FORTRAN, но не обязательно рекомендуется, если вы
оптимизация для ремонтопригодности:

goto(("FOO", "BAR", "GLARCH")[$i]);

Форма "goto"-&NAME весьма волшебна и заменяет вызов именованной подпрограммы.
для текущей подпрограммы. Это используется подпрограммами "AUTOLOAD()", которые хотят
загрузить другую подпрограмму, а затем сделать вид, что другая подпрограмма была вызвана в
первое место (за исключением того, что любые изменения @_ в текущей подпрограмме
распространяется на другую подпрограмму.) После "goto" даже "вызывающий()" не сможет
чтобы сказать, что эта подпрограмма была вызвана первой.

Почти во всех случаях, подобных этому, гораздо лучше использовать структурированный
механизмы управления потоком «следующий», «последний» или «повторить» вместо того, чтобы прибегать к «переходу».
Для определенных приложений пара перехвата и выброса "eval{}" и умереть () за исключением
обработка также может быть разумным подходом.

Команда эллипсис заявление
Начиная с Perl 5.12, Perl принимает многоточие ""..." в качестве заполнителя для кода, который
вы еще не внедрили. Эта форма многоточия, нереализованный оператор, должна
не путать с оператором бинарного триггера "...". Один из них — заявление, а
другой оператор. (Perl обычно не путает их, потому что обычно Perl может сказать
требуется ли оператор или оператор, но см. ниже исключения.)

Когда Perl 5.12 или новее встречает оператор с многоточием, он анализирует его без ошибок,
но если и когда вы действительно попытаетесь выполнить его, Perl выдаст исключение с
текст "Не реализовано":

используйте v5.12;
суб нереализованный { ... }
eval {нереализованный()};
if ($@ =~ /^Не реализовано в /) {
сказать "Я нашел многоточие!";
}

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

используйте v5.12;
{...}
sub foo {...}
...;
eval {...};
суб-то {
мой $ self = shift;
...;
}
$х = сделать {
мой $ n;
...;
сказать «Ура!»;
$н;
};

Эллиптический оператор не может заменить выражение, являющееся частью более крупного
оператор, так как "..." также является трехточечной версией оператора триггера (см.
«Операторы диапазонов» в perlop).

Эти примеры попыток использования многоточия являются синтаксическими ошибками:

используйте v5.12;

Распечатать ...;
open(my $fh, ">", "/dev/passwd") или ...;
if ($condition && ...) { сказать "Привет" };

В некоторых случаях Perl не может сразу отличить
выражение и высказывание. Например, синтаксис для блока и анонимного хэша
ссылочный конструктор выглядит одинаково, если в фигурных скобках нет чего-то, что дает Perl
намекать. Многоточие является синтаксической ошибкой, если Perl не догадывается, что "{...}" является блоком.
В этом случае он не считает "..." многоточием, потому что ожидает
выражение вместо утверждения:

@transformed = map { ... } @input; # ошибка синтаксиса

Внутри вашего блока вы можете использовать «;» перед многоточием, чтобы обозначить, что "{...}" является
блок, а не конструктор ссылки на хэш. Теперь многоточие работает:

@преобразованный = карта {; ... } @Вход; # ';' устраняет неоднозначность

Примечание. Некоторые люди в просторечии называют этот пунктуационный знак «яда-яда» или «яда-яда».
"три точки", но его настоящее имя на самом деле многоточие.

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

=head1 Здесь будут стручки!

Затем этот текст и весь оставшийся текст, включая строку, начинающуюся с
"=cut" будет проигнорировано. Формат промежуточного текста описан в perlpod.

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

= украшение предмета ($)

Функция snazzle() будет вести себя наиболее эффектно.
форму, которую вы можете себе представить, даже не исключая
кибернетическая пиротехника.

= Вернитесь к компилятору, нахуй этот стручок!

суб ослепление ($) {
моя $штучка = сдвиг;
.........
}

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

$ a = 3;
= секретные вещи
warn "Ни POD, ни CODE!?"
= сократить
print "получил $a\n";

Вы, вероятно, не должны полагаться на то, что «предупреждение ()» будет удалено навсегда. Не все капсулы
трансляторы в этом отношении ведут себя хорошо, и, возможно, компилятор станет более разборчивым.

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

одноцветный Старый Комментарии (Нет!)
Perl может обрабатывать линейные директивы так же, как препроцессор C. Используя это, можно
управлять представлением Perl об именах файлов и номерах строк в сообщениях об ошибках или предупреждениях (особенно
для строк, которые обрабатываются с помощью "eval()"). Синтаксис этого механизма почти
то же, что и для большинства препроцессоров C: соответствует регулярному выражению

# пример: '# строка 42 "new_filename.plx"'
/^\# \с*
строка \s+ (\d+) \s*
(?:\s("?)([^"]+)\g2)? \с*
$/х

где $1 — номер строки для следующей строки, а $3 — необязательное имя файла.
(указывается с кавычками или без). Обратите внимание, что перед «#» не может стоять пробел, в отличие от
современные препроцессоры C.

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

Вот несколько примеров, которые вы должны уметь вводить в свою командную оболочку:

% перл
# строка 200 "бззз"
# '#' в предыдущей строке должен быть первым символом в строке
умереть «фу»;
__КОНЕЦ__
foo в строке bzzzt 201.

% перл
# строка 200 "бззз"
eval qq[\n#line 2001 ""\ndie 'foo']; напечатать $@;
__КОНЕЦ__
foo at - строка 2001.

% перл
eval qq[\n#line 200 "foo bar"\ndie 'foo']; напечатать $@;
__КОНЕЦ__
foo в баре foo, строка 200.

% перл
# строка 345 "гуп"
eval "\n#строка " . __ЛИНИЯ__ . ' "' .__FILE__ ."\"\ndie 'foo'";
напечатать $@;
__КОНЕЦ__
foo в строке goop 345.

Экспериментальный Подробнее on данный и когда
Как упоминалось ранее, функция «переключатель» считается экспериментальной; это
могут быть изменены с небольшим уведомлением. В частности, «когда» имеет хитрое поведение, которое
Ожидается, что в будущем они изменятся, чтобы стать менее сложными. Не полагайтесь на его текущий
(неправильная) реализация. До Perl 5.18 «дано» также имело хитрое поведение, которое вы должны
по-прежнему остерегайтесь, если ваш код должен работать на более старых версиях Perl.

Вот более длинный пример «дано»:

использовать функцию ":5.10";
given ($ foo) {
когда (неопредел.) {
say '$foo не определено';
}
когда ("фу") {
say '$foo - это строка "foo"';
}
когда ([1,3,5,7,9]) {
say '$foo - нечетная цифра';
Продолжать; # Провалиться
}
когда ($_ < 100) {
say '$foo численно меньше 100';
}
когда (\&complicated_check) {
say 'сложная проверка $foo верна';
}
дефолт {
die q(я не знаю, что делать с $foo);
}
}

До Perl 5.18 "данные(EXPR)" присваивали значение EXPR просто лексически
копия (!) из $_, а не псевдоним с динамической областью действия, как это делает foreach. Это сделало это
похож на

сделать {мой $_ = EXPR; ... }

за исключением того, что блок был автоматически разорван успешным "когда" или
явный "разрыв". Поскольку это была всего лишь копия, и поскольку она была ограничена только лексически,
не динамический, вы не могли бы делать с ним то, к чему вы привыкли в
цикл "для каждого". В частности, это не работало для произвольных вызовов функций, если те
функции могут попытаться получить доступ к $_. Для этого лучше всего придерживаться «foreach».

Большая часть мощности исходит от неявного интеллектуального сопоставления, которое иногда может применяться. Большинство
время «когда (EXPR)» рассматривается как неявное интеллектуальное совпадение $_, то есть «$_ ~~ EXPR».
(См. «Оператор Smartmatch» в perlop для получения дополнительной информации о smartmatching.) Но когда
EXPR является одним из 10 исключительных случаев (или им подобных), перечисленных ниже, он используется
непосредственно как логическое значение.

1. Пользовательский вызов подпрограммы или вызов метода.

2. Соответствие регулярному выражению в виде "/REGEX/", "$foo =~ /REGEX/" или "$foo =~"
EXPR". Кроме того, инвертированное регулярное выражение соответствует форме "!/REGEX/", "$foo !~
/REGEX/", или "$foo !~ EXPR".

3. Интеллектуальное сопоставление, в котором используется явный оператор «~~», например «EXPR ~~ EXPR».

ПРИМЕЧАНИЕ: Вам часто придется использовать "$c ~~ $_", потому что по умолчанию используется "$_ ~~ $c",
что часто противоположно тому, что вы хотите.

4. Логический оператор сравнения, такой как "$_ < 10" или "$x eq "abc"". Относительный
операторы, к которым это относится, — это шесть числовых сравнений ("<", ">", "<=", ">=",
"==" и "!="), а также шесть сравнений строк ("lt", "gt", "le", "ge", "eq" и
«нэ»).

5. Не менее трех встроенных функций "defined(...)", "exists(...)" и "eof(...)".
Мы могли бы когда-нибудь добавить больше из них позже, если мы будем думать о них.

6. Отрицательное выражение, будь то "!(EXPR)" или "not(EXPR)", или логическое исключающее ИЛИ,
"(EXPR1) xor (EXPR2)". Побитовые версии ("~" и "^") не включены.

7. Оператор проверки файлов, ровно с 4 исключениями: "-s", "-M", "-A" и "-C", как эти
возвращать числовые значения, а не логические. Оператор проверки файлов "-z" не включен.
в списке исключений.

8. Триггерные операторы ".." и "...". Обратите внимание, что оператор триггера "..."
полностью отличается от только что описанного эллиптического утверждения "...".

В этих 8 случаях выше значение EXPR используется непосредственно как логическое значение, поэтому
смартматчинг выполнен. Вы можете думать о «когда» как об умном умном матче.

Кроме того, Perl проверяет операнды логических операторов, чтобы решить, использовать ли их.
smartmatching для каждого из них, применяя вышеуказанный тест к операндам:

9. Если EXPR равен «EXPR1 && EXPR2» или «EXPR1 и EXPR2», тест применяется. рекурсивно в
как EXPR1, так и EXPR2. Только если изоферменты печени операнды также проходят проверку, рекурсивно, будет ли
выражение следует рассматривать как логическое. В противном случае используется смарт-матчинг.

10. Если EXPR равен «EXPR1 || EXPR2», «EXPR1 // EXPR2» или «EXPR1 или EXPR2», тест
прикладной рекурсивно только к EXPR1 (что само по себе может быть И с более высоким приоритетом
оператор, например, и, таким образом, подчиняется предыдущему правилу), а не EXPR2. Если EXPR1
заключается в использовании интеллектуального сопоставления, то EXPR2 также делает то же самое, независимо от того, что содержит EXPR2. Но
если EXPR2 не сможет использовать smartmatching, то второй аргумент не будет
либо. Это сильно отличается от только что описанного случая "&&", так что будьте осторожны.

Эти правила сложны, но цель состоит в том, чтобы они делали то, что вы хотите (даже если вы
не совсем понимаю, зачем они это делают). Например:

когда (/^\d+$/ && $_ < 75) { ... }

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

А также:

когда ([qw(foo bar)] && /baz/) { ... }

будет использовать Smartmatching, потому что только one операндов является логическим: другие используют
smartmatching, и это побеждает.

Далее:

когда ([qw(foo bar)] || /^baz/) { ... }

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

когда (/^баз/ || [qw(foo bar)]) { ... }

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

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

когда ("foo" или "bar") { ... }

Это оптимизируется до «foo», поэтому «bar» никогда не будет учитываться (хотя правила
скажем, использовать smartmatch для «foo»). Для такого чередования будет работать ссылка на массив,
потому что это спровоцирует умное сопоставление:

когда ([qw(foo bar)] { ... }

Это в некоторой степени эквивалентно отказоустойчивой функциональности оператора switch в стиле C.
(не путать с в Perl отказоустойчивая функциональность — см. ниже), при этом тот же
блок используется для нескольких операторов case.

Другой полезный ярлык заключается в том, что если вы используете литеральный массив или хэш в качестве аргумента для
«дано», оно превращается в ссылку. Таким образом, "данный(@foo)" - это то же самое, что и "данный(\@foo)",
например.

«По умолчанию» ведет себя точно так же, как «когда (1 == 1)», то есть всегда совпадает.

Разрыв внешний

Вы можете использовать ключевое слово «break», чтобы выйти из окружающего «данного» блока. Каждое "когда"
блок неявно заканчивается «разрывом».

Провалиться

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

данный ($ foo) {
когда (/x/) { say '$foo содержит x'; Продолжать }
когда (/у/) { говорят '$foo содержит ау' }
default { сказать '$foo не содержит ау' }
}

ВОЗВРАТ ценностное

Когда «данное» утверждение также является допустимым выражением (например, когда оно является последним
оператор блока), он оценивается как:

· Пустой список, как только встречается явный "разрыв".

· Значение последнего оцененного выражения успешного предложения «когда»/«по умолчанию»,
если таковой окажется.

· Значение последнего оцененного выражения «данного» блока, если нет условия.
правда.

В обоих последних случаях последнее выражение оценивается в контексте, который был применен к
«данный» блок.

Обратите внимание, что, в отличие от «если» и «если», ошибочные операторы «когда» всегда дают пустое значение.
.

моя $ цена = сделать {
данный ($ элемент) {
когда (["груша", "яблоко"]) { 1 }
перерыв при "голосовании"; # Мой голос нельзя купить
1e10, когда /Мона Лиза/;
"неизвестный";
}
};

В настоящее время «данные» блоки не всегда могут использоваться как правильные выражения. Это может быть
рассматривается в будущей версии Perl.

Переключение in a поиска

Вместо использования "given()" вы можете использовать цикл "foreach()". Например, вот один из способов
чтобы подсчитать, сколько раз конкретная строка встречается в массиве:

используйте v5.10.1;
мой счетчик $ = 0;
для (@массива) {
когда ("foo") {++$count}
}
print "\@array содержит $count копий 'foo'\n";

Или в более поздней версии:

используйте v5.14;
мой счетчик $ = 0;
для (@массива) {
++$счет когда "foo";
}
print "\@array содержит $count копий 'foo'\n";

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

Это не работает, если вы явно указываете переменную цикла, например, «для $item (@array)».
Вы должны использовать переменную по умолчанию $_.

Различия от Perl 6

Smartmatch Perl 5 и конструкции "данные"/"когда" несовместимы с их Perl 6.
аналоги. Наиболее заметное и наименее важное различие состоит в том, что в Perl 5
Круглые скобки необходимы вокруг аргумента для «данного()» и «когда()» (кроме случаев, когда это
последний используется как модификатор оператора). Скобки в Perl 6 всегда необязательны.
управляющая конструкция, такая как "if()", "while()" или "when()"; их нельзя сделать необязательными в
Perl 5 без большой потенциальной путаницы, потому что Perl 5 будет анализировать
выражение

учитывая $foo {
...
}

как если бы аргумент «дано» был элементом хеша %foo, интерпретируя
фигурные скобки как синтаксис хеш-элемента.

Тем не менее, их много, много других различий. Например, это работает в Perl 5:

используйте v5.12;
мой @primary = ("красный", "синий", "зеленый");

если (@основной ~~ "красный") {
сказать «основной смарт-матч красный»;
}

если ("красный" ~~ @primary) {
сказать «красные смарт-матчи первичны»;
}

сказать «все, ребята!»;

Но это вообще не работает в Perl 6. Вместо этого вы должны использовать (распараллеливаемый) «любой»
оператор:

если есть(@primary) eq "красный" {
сказать «основной смарт-матч красный»;
}

если "красный" eq any(@primary) {
сказать «красные смарт-матчи первичны»;
}

Таблица смарт-матчей в «Операторе смарт-матчей» в perlop не идентична той
предложенный спецификацией Perl 6, в основном из-за различий между Perl 6 и Perl
5, но также и потому, что спецификация Perl 6 изменилась с момента появления Perl 5.
раннее принятие.

В Perl 6 функция when() всегда выполняет неявное интеллектуальное сопоставление со своим аргументом, в то время как в Perl
5 удобно (хотя и потенциально запутанно) подавить это неявное умное совпадение в
различные довольно расплывчатые ситуации, как в общих чертах описано выше. (Разница
во многом потому, что Perl 5 не имеет логического типа даже внутри.)

Используйте perlsyn онлайн с помощью сервисов onworks.net