В этой части речь пойдет об условных операторах и циклах.
Как всегда, начнем сразу с примеров.
$a
=
shift
;
if
($a
>
10
)
{
print
"a > 10\n
"
;
}
Программистам на C-подобных языках эта конструкция должна быть до боли знакома, так что комментировать тут особо нечего. Скажу лишь, что в отличие от Си, опустить фигурные скобки тут нельзя. Точнее говоря, способ есть, но о нем чуть ниже. Конструкции if-else и if-else-if-… на языке Perl выглядят следующим образом:
$a
=
shift
;
if
($a
>
10
)
{
print
"a > 10\n
"
;
}
else
{
print
"a <= 10\n
"
;
}
if
($a
>
0
)
{
# do something
}
elsif
($a
==
0
)
{
# do something
}
else
{
# do something else
}
В общем, все все как мы и ожидаем за одним исключением. Никакого «else if» в Perl нет — вместо этого следует использовать elsif и только его. Elsif может повторяться несколько раз, else использовать не обязательно, фигурные скобки опустить нельзя.
В отличие от других языков программирования, в Perl также предусмотрен оператор unless. Следующие два куска кода делают одно и то же:
unless
($a
==
0
)
{
# "... если только a не равно нулю"
...
}
if
($a
!=
0
)
{
# то же самое
# ...
}
Unless можно использовать в сочетании с elsif и else, однако никакого «elsunless» в Perl нет.
В Perl есть возможность уменьшить объем кода, если в случае выполнения условия должна быть выполнена только одна строка кода. Следующие примеры делают одно и то же:
if
($a
>
$b
)
{
exit
1
;
}
unless
($b
==
$c
)
{
exit
2
;
}
# если условие истинное - завершить скрипт с кодом 1
exit
1
if
($a
>
$b
)
;
# если b == c, продолжить выполнение скрипта
exit
2
unless
($b
==
$c
)
;
При этом скобки в последнем примере можно не использовать:
# если условие истинное - завершить скрипт с кодом 1
exit
1
if
$a
>
$b
;
Если вы пишите на Java/PHP или другом Си-подобном языке, такая конструкция скорее всего будет для вас непривычной, но на практике она действительно удобна. В русском языке мы ведь тоже обычно говорим «завершить программу, если …», а не «если …, то …».
Также, как в C/C++ и PHP, в Perl имеется тернарный оператор?: . Работает он аналогично конструкции if-else, только внутри выражений:
if
($a
>
$b
)
{
$a
=
$a
/
$b
;
}
else
{
$a
=
$b
/
$a
;
}
# аналогичный код, использующий оператор "знак вопроса"
# одна строчка кода вместо пяти
$a
=
$a
>
$b
?
$a
/ $b: $b /
$a
;
Также хотелось бы сказать пару слов об операторах сравнения. Операторы сравнения в языке Perl делятся на две группы — производящие сравнение чисел и сравнение строк.
Как вы помните, скаляры в Perl можно интерпретировать либо как строки, либо как числа. Например, число 123 больше числа 45, однако строка «123» меньше строки «45». Вот для чего потребовалось несколько групп операторов сравнения. Сравнение строк в Perl производится таким же образом, как и в других современных языках программирования, потому я надеюсь, что тут вопросов не возникает.
Цикл for прекрасно знаком всем программистам:
# вывести строку "0 1 2 3 4"
for
($i
=
0
;
$i
<
5
;
$i
++
)
{
print
"$i "
;
}
В круглых скобках через точку с запятой записывается:
Как и в случае с условными операторами, в циклах опускать фигурные скобки нельзя (для этого также есть специальная форма записи — см ниже).
Цикл foreach должен быть хорошо знаком программистам на PHP:
@arr
=
(0
,
1
,
2
,
3
,
4
)
;
# вывести строку "0 1 2 3 4"
foreach
$i
(@arr
)
{
print
"$i "
;
}
Тело цикла foreach выполняется для каждого элемента массива, указанного в скобках. Важная особенность foreach — в переменную $i не копируется элемент массива @arr, как думают многие . Переменная $i в теле цикла — это и есть сам элемент массива . Таким образом, следующий код увеличивает на единицу значение каждого элемента массива @arr:
$i
=
19880508
;
foreach
$i
(@arr
)
{
$i
++;
}
# $i по прежнему равен 19880508
Также foreach можно использовать для работы с хэшами:
%hash
=
(
aaa =>
1
,
bbb =>
2
,
)
;
# функция keys возвращает массив, содержащий все ключи хэша
foreach
$k
(keys
%hash
)
{
print
"$k => $hash{$k}\n
"
;
}
В Perl цикл foreach имеет короткую форму:
# если Вы забыли, что делает оператор qw,
# вернитесь к первой части "основ программирования на Perl"
for
$i
(qw/1 2 3/
)
{
print
"$i "
;
}
То есть фактически везде вместо foreach можно писать просто for. Perl не перепутает такую запись с настоящим циклом for, потому что в последнем нужно писать точки с запятой и так далее.
Циклы while, until и do работают точно так же, как и в C++ или Pascal/Delphi:
# выводим "1 2 3 4 5" четырьмя разными способами
$i
=
0
;
while
($i
<
5
)
{
# пока $i меньше пяти
print
++
$i
.
" "
;
}
print
"\n
"
;
# новая строка
$i
=
0
;
until
($i
==
5
)
{
# пока $i не станет равно пяти
print
++
$i
.
" "
;
}
print
"\n
"
;
$i
=
0
;
do
{
print
++
$i
.
" "
;
}
while
($i
<
5
)
;
# проверка в конце цикла
print
"\n
"
;
$i
=
0
;
do
{
print
++
$i
.
" "
;
}
until
($i
==
5
)
;
print
"\n
"
;
По аналогии с операторами if и unless, существует сокращенная форма записи циклов:
$i
=
0
;
print
++
$i
.
" "
while
($i
<
5
)
;
print
"\n
"
;
$i
=
0
;
print
++
$i
.
" "
until
($i
==
5
)
;
print
"\n
"
;
print
"$_ "
for
(qw/1 2 3 4 5/
)
;
# можно и foreach(qw/1 2 3 4 5/);
print
"\n
"
;
Обратите внимание на последний цикл foreach. Мы ведь помним, что это сокращенная запись foreach, а не цикл for, верно? Последний кстати не имеет короткой записи. Так вот, здесь не было указано имя переменной, с помощью которой мы будем обращаться к элементам массива. В сокращенной записи foreach ее нельзя использовать. В этом случае используется специальная переменная — $_. Следующий пример также вполне рабочий:
for
(qw/1 2 3 4/
)
{
print
"$_"
;
}
Его, кстати, можно переписать следующим образом.
Для сравнения скалярных данных или значений скалярных переменных язык Perl предлагает набор бинарных операций, вычисляющих отношения равенства, больше, больше или равно и т. п. между своими операндами, поэтому эту группу операций еще называют операциями отношения. Для сравнения числовых данных и строковых данных Perl использует разные операции. Все они представлены в табл. 4.1.
Таблица 4.1. Операции отношения
| Операция | Числовая | Строковая | Значение |
| Равенство | == | eq | Истина, если операнды равны, иначе ложь |
| Неравенство | != | ne | Истина, если операнды не равны, иначе ложь |
| Меньше | < | lt | Истина, если левый операнд меньше правого, иначе ложь |
| Больше | > | gt | Истина, если левый операнд больше правого, иначе ложь |
| Меньше или равно | <= | le | Истина, если левый операнд больше правого или равен ему, иначе ложь |
| Больше или равно | >= | ge | Истина, если правый операнд больше левого или равен ему, иначе ложь |
| Сравнение | <=> | cmt | 0, если операнды
равны 1, если левый операнд больше правого -1, если правый операнд больше левого |
Результатом операций отношения (кроме последней сравнения) является Истина, значение 1, или Ложь, пустая строка "".
Замечание
Значение истина в арифметических операциях интерпретируется
как число 1, а в строковых как строка "1". Значение
ложь в арифметических операциях интерпретируется как число
0, а в строковых как пустая строка " ".
Числовые операции отношения
Числовые операции отношения применяются к числовым данным, причем один или оба операнда могут задаваться строкой, содержащей правильное десятичное число. Если в числовых операциях отношения какой-либо из операндов задан строкой, содержимое которой не представляет правильное десятичное число, то его значение принимается равным о и отображается предупреждение о некорректном использовании операнда в числовой операции отношения (если включен режим отображения предупреждений интерпретатора Perl). Смысл операций отношения для числовых данных соответствует обычным математическим операциям сравнения чисел (пример 4.7).
123 > 89; # Результат: 1 (истина)
123 < 89; # Результат: "" (ложь)
123 <= 89; # Результат: "" (ложь)
89 <= 89; # Результат: 1 (истина)
23 >= 89; # Результат: "" (ложь)
23 <=> 89; # Результат: -1 (правый операнд больше левого)
89 <=> 23; # Результат: 1 (правый операнд больше левого)
Применение числовых операций сравнения не представляет сложности, однако при сравнении на равенство десятичных чисел с плавающей точкой могут проявиться эффекты округления, связанные с ограниченным количеством значащих цифр в мантиссе представления действительных чисел в компьютере и приводящие к "неправильной", с точки зрения пользователя работе операций сравнения. Пример 4.8 иллюстрирует подобную ситуацию.
#! peri -w
$z = 0.7;
$zz = 10+0.7-10; # Переменная $zz содержит число 0.7
# Печать строки "z равно zz", если равны значения переменных $z и $zz print "z равно zz\n" if ($z == $zz);
При попытке выполнить пример 4.8 мы с удивлением обнаружим, что наша программа ничего не напечатает. В чем же дело? Разгадка лежит в операторе вычисления значения переменной $zz. При выполнении арифметических операций в результате ошибок округления получается значение 0.699999999999999 (можете вставить оператор печати переменной $zz и убедиться в этом), хотя и близкое к 0.7, но не равное ему в точности. Следовательно, операция сравнения отработала верно!
Совет
Не используйте операцию сравнения на равенство вещественных
чисел, ее результат может не соответствовать ожидаемому с
точки зрения математики. Если необходимо проверить равенство
двух вещественных чисел, то лучше сравнивать абсолютное значение
их разности с некоторым очень маленьким числом (в зависимости
от требуемой точности):
abs($a-$b) <= 0.00000001; # Проверка равенства
Строковые операции отношения
Сравнение строковых данных базируется на их упорядочении в соответствии с таблицей кодов ASCII, т. е. символ с меньшим кодом ASCII предшествует символу с большим кодом. Сравнение строк осуществляется посимвольно слева направо. Это означает, что если равны первые символы строк, то сравниваются вторые и если они равны, то сравниваются третьи и т. д. Причем, если строки разной длины, то в конец строки меньшей длины добавляется недостающее для равенства количество символов с кодом о. Следует отметить, что в отличие от некоторых других языков программирования в Perl замыкающие строку пробельные символы являются значимыми при сравнении строк. В примере 4.9 показаны сравнения строк, иллюстрирующие изложенные правила.
| "A" It "a"; | # Результат: истина (код "А" - \101, код "а" - \141) |
| "a" It "aa"; | # с кодом \000, который меньше кода \141 # второго символа "а" строки правого операнда) |
| "a" It "a "; | # Результат:
истина (к строке "а" добавляется символ # с кодом \000, который меньше кода \040 # замыкающего пробела строки правого операнда) |
| "12" It "9"; | # Результат: истина (код "1" - \061, код "9" - \071) |
| "9" eq 09"; | # Результат: ложь (код " " - \040, код "О" - \060) |
Обратим внимание на две последние операции сравнения строковых литералов. Содержимое их операндов может быть преобразовано в правильные числа, и поэтому к ним применимы аналогичные числовые операции отношения. Однако их результат будет существенно отличаться от результата выполнения строковых операций отношения. При использовании операции < в предпоследнем выражении результат будет Ложь, а если в последнем выражении применить операцию ==, то результат будет Истина. Об этом всегда следует помнить, так как Perl автоматически преобразует символьные данные в числовые там, где это необходимо.
Есть несколько способов сравнения объектов в Perl. Можно проверить равенство значений используя инфиксный оператор === . Для неизменных (immutable ) объектов (значения которых нельзя изменить, литералов. Например литерал 7 всегда будет 7) это обычное сравнение значений. Например "hello"==="hello" всегда верно потому, что обе строки неизменны и имеют одинаковое значение.
Для изменяемых объектов === сравнивает их идентичность. === возвращает истину, если его аргументы являются псевдонимами одного и того же объекта. Или же двое объектов идентичны, если это один и тот же объект. Даже если оба массива @a и @b содержат одинаковые значения, если их контейнеры разные объекты, они будут иметь различные идентичности и не будут тождественны при сравнении === :
My @a = 1, 2, 3; my @b = 1, 2, 3; say @a === @a; # 1 say @a === @b; # 0 # здесь используется идентичность say 3 === 3; # 1 say "a" === "a"; # 1 my $a = "a"; say $a === "a"; # 1
Оператор eqv возвращает Истина если два объекта одного типа и одинаковой структуры. Так для @a и @b указанных в примере, @a eqv @b истинно потому, что @a и @b содержат одни и те же значения. С другой стороны "2" eqv 2 вернет False , так как аргумент слева строка, а справа - число, и таким образом они разных типов.
Так же как == преобразует свои аргументы в числа, инфиксный оператор eq сравнивает равенство строк, преобразуя аргументы в строки при необходимости.
If $greeting eq "hello" { say "welcome"; }
Другие операторы сравнивают строки лексикографически.
На самом деле более удобная форма для!== , который в свою очередб представляет собой объединеие метаоператора! и инфиксного оператора == . Такое же обяснение приминительно к ne и!eq .
Операторы three-way сравнения получают два операнда и возвращают Order::Increase , если операнд слева меньше, Order::Same - если равны, Order::Decrease - если операнд справа меньше (Order::Increase , Order::Same и Order::Decrease являются перечислениями (enums) ; см.). Для числовых сравнений используется оператор <=> , а для строковых это leg (от англ. l esser, e qual, g reater). Инфиксный оператор cmp также является оператором сравнения, возвращающий три результата сравнения. Его особенность в том, что он зависит от типа аргументов: числа сравнивает как <=> , строки как leg и (например) пары сначала сравнивая ключи, а затем значения (если ключи равны).
Say 10 <=> 5; # +1 say 10 leg 5; # because "1" lt "5" say "ab" leg "a"; # +1, lexicographic comparison
Типичным применением упомянутых three-way операторов сравнения является сортировка. Метод.sort в списках получает блок или функцию, которые сравнивают свои два аргумента и возвращают значения отрицательные если меньше, 0 - если аргументы равны и больше 0, если первый аргумент больше второго. Эти результаты затем используются при сортировке для формирования результата.
Say ~
По умолчанию используется сортировка чувствительная к регистру, т.е. символы в верхнем регистре "больше" символов в нижем. В примере используется сортировка без учета регистра.
Разные операторы сравнения приводит свои аргументы к определённым типам перед сравнением их. Это полезно, когда требуется конкретное сравнение, но типы параметров неизвестны. Perl 6 предоставляет особый оператор который позволяет производить сравнение "Делай Как Надо" (Do The Right Thing) с помощью ~~ - оператора "умного" сравнения.
If $pints-drunk ~~ 8 { say "Go home, you"ve had enough!"; } if $country ~~ "Sweden" { say "Meatballs with lingonberries and potato moose, please." } unless $group-size ~~ 2..4 { say "You must have between 2 and 4 people to book this tour."; }
Оператор "умного" сопоставления всегда решает какого рода сравнение производить в зависимости от типа значения в правой части. В предыдущих примерах эти сравнения были числовым, строковым и сравнением диапазонов соответственно. В данной главе была продемонстрирована работа операторов сравнения: чисел - == и строк eq .Однако нет оператора для сравнения диапазонов. Это является частью возможностей "умного" сопоставления: более сложные типы позволяют реализовывать необычные идеи сочетая сравнения их с другими.
"Умное" сопоставление работает, вызывая метод ACCEPTS у правого операнда и передавая ему операнд слева как аргумент. Выражение $answer ~~ 42 сводится к вызову 42.ACCEPTS($answer) . Данная информация пригодится, когда вы прочитаете последующие главы, посвященные классам и методам. Вы тоже напишите вещи, которые смогут производить "умное" сопоставление, реализовав метод ACCEPTS для того, чтобы "работало как надо".
Операторы в Perl-е имеют различный приоритет. Операторы, заимствованные из C , сохранили между собой ту же иерархию, что и в C . Термы имеют самый большой приоритет, они содержат переменные, кавычки, выражения в скобках, функции с их параметрами. Если за списковым оператором (например, print()) или унарным оператором (например, chdir()) следует список аргументов, заключенный в скобки, то эта последовательность имеет самый высокий приоритет, подобно функции с аргументами. Аналогично термам обрабатываются последовательности do{} и eval{} .
Также, как в С и С++ ``- > "" является инфиксным оператором ссылки. Если правая часть является [...] или {...} подпрограммой, тогда левая часть должна быть символьной ссылкой на массив или хэш. Если правая часть - это имя метода или скалярная переменная содержащая имя метода, то левая часть должна быть объектом или именем класса.
Эти операторы работают также как и в С. То есть, если они стоят перед
переменной, то они увеличивают или уменьшают переменную до возвращения значения.
Если они стоят после переменной, то увеличение или уменьшение переменной
происходит после возврата значения. Если переменная содержит в себе число или
употребляется в скалярном контексте, то использование ++ дает обычное
увеличение значения. Если же переменная употреблялась только в строковом
контексте, не является пустой строкой и содержит символы a-z,A-Z,0..9 , то
происходит строковое увеличение значения переменной:
print ++($foo = "99"); - напечатает 100
print ++($foo = "a0"); - напечатает a1
print ++($foo = "Az"); - напечатает Ba
print ++($foo = "zz"); - напечатает aaa
В Perl-е двойная звездочка ** является экспоненциальным оператором. Он требует к себе даже больше внимания, чем унарный минус: -2**4 это -(2**4) , но не (-2)**4 .
Унарный! означает логическое отрицание. Унарный минус, в случае числового
значения переменной, обозначает обычное арифметическое отрицание. Если операндом
является идентификатор, то возвращается строка, состоящая из знака минус и
идентификатора. Если строка начинается со знака + или - , то возвращается
строка, начинающаяся с противоположного знака.
Унарная тильда `` ~ "" обозначает побитовое отрицание.
Унарный плюс не имеет влияния даже на строки. Он используется для отделения
имя функции от выражения заключенного в скобки, которое иначе рассматривается
как список аргументов.
Rand (10) * 20; - (rand10) * 20; rand +(10) * 20; - rand(10 * 20); Унарный бэкслэш ``"" обозначает ссылку на то, что стоит за ним.
Знак равенства с тильдой ``= ~ ""связывает выражение слева с определенным шаблоном. Некоторые операторы обрабатывают и модифицируют переменную $_ . Эти же операции иногда желательно бывает выполнить над другой переменной. Правый аргумент это образец поиска, подстановки или трансляции, левый аргумент - это то, что должно быть подставлено вместо $_ . Возвращаемая величина показывает успех операции. Бинарное ``! ~ "" это тоже самое, что и ``= ~ "", только возвращаемая величина является отрицательной в логическом смысле.
Звездочка * - умножение двух чисел. Cлэш / - деление числа на число.
Процент % - вычисляет модуль двух чисел, x - оператор повторения. В
скалярном контексте возвращает строку, состоящую из многократно повторенного
левого операнда, причем повторяется он то количество раз, которое стоит справа.
В списковом контексте он многократно повторяет список.
print "a" x 80; напечатает букву a 80 раз.
@ones = (1) x 80; массив из восьмидесяти единиц.
@ones = (5) x @ones сделает все элементы равными пяти.
Бинарный плюс - операция сложения двух чисел.
Бинарный минус - операция вычитания двух чисел.
Бинарная точка - конкатенация строк.
Двоичный сдвиг осуществляется, как и во многих других языках программирования, с помощью операторов ``<<"" и ``>>"". При применении этих операторов значения левых аргументов сдвигаются в соответствующую сторону на количество разрядов, указанное в правых аргументах. Аргументы должны быть целочисленными.
``<"" - возвращает TRUE если левый аргумент численно меньше, чем правый.
``>"" - возвращает TRUE если правый аргумент численно меньше, чем левый.
``<="" - возвращает TRUE если правый аргумент численно меньше или равен левому.
``>="" - возвращает TRUE если левый аргумент численно меньше или равен правому.
``gt"" - возвращает TRUE если левый аргумент меньше (в строковом контексте), чем правый.
``lt"" - возвращает TRUE если правый аргумент меньше (в строковом контексте), чем левый.
На поведение операторов lt и gt влияют установки
системного языка, если операционная система способна работать с несколькими
языками. По этой причине операторы должны корректно работать со строками
на языках, отличных от US ASCII , что в системе UNIX задается указанием
свойств LC_COLLATE системного locale .
Возвращает TRUE , если левый аргумент численно эквивалентен правому.
!= возвращает TRUE , если левый аргумент численно неэквивалентен правому.
<=> возвращает -1, 0 или 1 в зависимости от того, численно меньше,
равен или больше левый аргумент правого.
eq возвращает TRUE , если левый аргумент эквивалентен правому (в строковом контексте).
ne возвращает TRUE , если левый аргумент неэквивалентен правому (в строковом контексте).
cmp возвращает -1, 0 или 1 в зависимости от того, меньше равен или
больше левый аргумент правого (в строковом контексте).
Бинарное & возвращает объединенные побитово операнды.
Бинарное | возвращает перемноженные побитово операнды.
Бинарное ^ возвращает исключенные побитово операнды.
Бинарное && - логическое И. Если левый аргумент FALSE , то правый не проверяется.
Бинарное || - логическое ИЛИ. Если левый аргумент TRUE , то правый
аргумент не проверяется.
||""и && отличаются от подобных операторов в \verb C| тем, что вместо 0 или
1 они возвращают последнюю обработанную величину.
Таким образом, наиболее удобным способом определить домашний каталог
пользователя из переменной окружения HOME будет (на практике такой способ
определения домашнего каталога пользователя не рекомендуется):
$home = $ENV{"HOME"} || $ENV{"LOGDIR"} || (getpwuid($<)) || die "You"re homeless!\n"; В качестве более удобной для чтения альтернативы Perl поддерживает операторы and и or , которые будут описаны далее. Их приоритет ниже, однако их можно с удобством использовать, не расставляя скобки, после операторов, аргументами которых являются списки: unlink "alpha", "beta", "gamma" or gripe(), next LINE; Если писать в стиле C , то это может быть записано так: unlink("alpha", "beta", "gamma") || (gripe(), next LINE);
Оператор диапазона. Реально это два разных оператора, в зависимости от контекста. В списковом контексте он работает как оператор диапазона от левого аргумента до правого.
For (1..10) { #code } В скалярном контексте он возвращает булевское значение. Если левый операнд TRUE , то.. принимает значение TRUE , если правый операнд тоже TRUE . if (101..200) { print "hi;)";} - напечатает вторую сотню строк
?: также как и в C является условным оператором. Он работает подобно if-then-else . Если аргумент перед? - TRUE , то возвращается аргумент перед: , в противоположном случае возвращается аргумент после: . Скалярный или списковый контекст второго и третьего аргументов передается по наследству.
($a_or_b ? $a: $b) = $c;
Обычный оператор присваивания. Вообще операторы присваивания работают также как и в C . $a += 2; - то же самое, что и $a = $a + 2; Можно использовать следующие сокращения:
**= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x= ($a += 2) *= 3; - то же самое, что и: $a = $a + 2; $a = $a * 3;Оператор запятая или comma-оператор. В скалярном контексте он обрабатывает левый аргумент и отбрасывает его значение, потом обрабатывает правый аргумент и возвращает его величину. В этом он подобен comma-оператору из C . В списковом контексте он играет роль разделителя аргументов и вставляет оба аргумента в список. => является синонимом comma-оператора.
Унарное NOT возвращает отрицание аргумента. Оно эквивалентно! , за исключением более низкого приоритета.
and возвращает конъюнкцию двух выражений. Он эквивалентен && , за исключением более низкого приоритета. or возвращает дизъюнкцию аргументов. Он эквивалентен ||, за исключением более низкого приоритета. xor (eXclusive OR) - исключающее ИЛИ, возвращает истину, если истинен ровно один из аргументов.
В Perl есть несколько операций ввода-вывода. Для вывода из файла используется команда <>.
Open(STDIN,"/etc/passwd");
while ($string =
Оператор s/PATTERN/REPLACEMENT/egimosx производит поиск строки, соответствующей шаблону PATTERN и если строка найдена, то подстановку на ее место текста REPLACEMENT . Возвращает количество произведенных подстановок. Если перед этим не использовался оператор =~ или!~ для определения переменной, которая будет обрабатываться, то будет модифицироваться переменная $_ . Этот оператор используется со следующими опциями: e интерпретирует правую часть как выражение. g производит подстановку на место каждой строки, соответствующей шаблону. i производит поиск различающий большие и маленькие буквы. m обрабатывает строку, как состоящую из нескольких строк. o происходит подстановка только на место первой встреченной строки. s обрабатывает строку, как состоящую только из одной строки. x использует расширенные регулярные выражения. Например:
$path =~ s|/usr/local/bin|/usr/bin|; ($foo = $bar) =~ s/this/that/o; $count = ($paragraf =~ s/Mister\b/Mr./gm);
tr/SEARCHLIST/REPLACEMENTLIST/cds y/SEARCHLIST/REPLACEMENTLIST/cds Заменяет все найденные символы из множества символов SEARCHLIST на соответствующие символы из множества символов REPLACEMENTLIST . Возвращает число символов, которые были заменены или удалены. Если посредством операторов =~, !~ не была указана никакая строка, то обрабатывается переменная $_ . y является синонимом tr . Если SEARCHLIST заключен в скобки, то REPLACEMENTLIST тоже заключается в скобки, которые могут отличаться от тех, в которые заключается шаблон, например:
Tr tr(+-*/)/ABCD/ Этот оператор употребляется со следующими опциями: c заменяет символы, которые не входят во множество SEARCHLIST на REPLACEMENTLIST , например: tr/a-zA-Z/ /cs; заменит неалфавитные символы. d Стирает символы, которые ни на что не заменяются. s Переводит последовательность символов, которые заменяются на один и тот же символ в один символ. Например: $a = "CCCCCCCCC"; $a =~ tr/C/D/s; теперь $a = "D"
