Initial commit from the 2013 with minor fixes. From now and then,

[perlbook.git] / s02.tex

\section{Основы}
\subsection{Что и как?}
\begin{em}
PHP — это маленькое зло, созданное некомпетентными новичками, в то
время как Perl — это большое и коварное зло, созданное умелыми, но 
извращёнными профессионалами.
\begin{flushright}
Jon Ribbens
\end{flushright}
\end{em}

Сначала немножко теории. В вики написано:

\begin{em}
„Perl — высокоуровневый интерпретируемый динамический язык
программирования общего назначения, созданный Ларри Уоллом, лингвистом
по образованию.”
\end{em}

Ларри подошел к созданию языка программирования как лингвист,
поэтому в результате получился очень необычный язык.
В своей книге „Программирование на Perl” он постоянно приводит аналогии
между Perl’ом и естественным языком.
Возможно поэтому Perl так лихо обрабатывает любую текстовую информацию.
Что ещё мы узнали? Perl язык интерпретируемый, это означает, что текст
программы\footnote{Программы на Perl часто называют
сценариями или ещё чаще скриптами}
содержится в простом текстовом файле и переводиться на язык,
понятный комфьютеру специальной программой (интерпретатором).
Интерпретатор постепенно читает программу на Perl
(которую принято называть СКРИПТОМ) и заставляет твою компьютер
выполнять её. Теперь задумаемся над тем, что же такое программа?
Думаю можно сказать, что это алгоритм, записанный на каком-либо языке
программирования. А алгоритм это последовательность действий, приводящая
к определенному результату. Обобщим. Чтоб извлечь ништяки из
компьютера,нужно составить алгоритм. Человек должен четко представлять,
как достичь результата. Далее, алгоритм нужно перевести на один из
понятных для машины языков и чем богаче язык — тем легче нам будет это
сделать. Поэтому мы будем писать на Perl, очень богатом и гибком языке.

Хватит лирики, что нам нужно, чтобы приступить?
\begin{enumerate}
\item Интерпретатор Perl
\item Хороший текстовый редактор
\end{enumerate}

У пользователей Linux скорей всего есть и то и другое.

%\begin{minipage}[t][\height][t]{\textwidth}
\vbox{

\textbf{Windows:}
\begin{itemize}
\item Качаем интерпретатор здесь:

http://strawberryperl.com/
\item На роль текстового редактора вполне подойдет Notepad++:

http://notepad-plus-plus.org/download/
\end{itemize}
%\end{minipage}
}
Специально для пользователей windows есть один финт. Чтоб не скакать
по каталогам и сразу запустить командную строку там где нужно:
\begin{enumerate}
\item Создаем где-нибудь папку, в которой будут храниться все наши скрипты.
\item В этой папке создаём файл с расширением „bat”. В файл добавляем
единственную строку:

\texttt{cmd.exe}
\end{enumerate}
Теперь для запуска командной строки достаточно дважды кликнуть по батнику.

Но это не все подводные камни, подстерегающие пользователя windows
на пути к Perl. Дело в том, что в консоли Windows используется кодировка
\emph{cp866} , а блокнот, например сохраняет текст в \emph{cp1251}. Поэтому русский
текст, содержащийся в скрипте, который писался в блокноте, будет выведен
на экран в не читаемом виде. Но это легко исправить, собственно для того
мы и скачали Notepad++. Перед тем, как набирать/вставлять из буфера
листинг устанавливаем нужную кодировку:

\texttt{Кодировка>Кириллическая>ОЕМ 866}

Кстати, копировать листинги из книги — плохая идея. Настоятельно
рекомендую перебивать их вручную. Во-первых, так лучше запоминается.
Во-вторых, текст не всегда копируется правильно. На данный момент
известен как минимум один глюк, с которым я ничего не могу поделать. Он
описан в третьем пункте FAQ.

Мальчик мой, ты готов стать мужчиной!

\subsection{Первая программа}

Когда программист перестает быть мальчиком? Само собой, написав первую
программу! А вот и она:

\perl{l01.pl}

Давайте разбираться, что же мы написали и как это запустить? Здесь надо
подумать. Понимаю не хочется. Тем более что в первый раз это больно. Все
листинги\footnote{Листинг --- текст скрипта. Его исходный код}
будут оформляться похожим образом. Строки пронумерованы,
чтоб на них можно было легко ссылаться. Не нужно копировать номера!
Первая строка будет присутствовать во всех листингах, но пользователям
Windows она не нужна! В любом случае, первая строка удобный ориентир.
Не копируйте из книги ничего, что стоит левее „\emph{\#!}”. Ладно,
запускаем первый листинг.

\textbf{На Linux:}

Есть как минимум два пути:

\begin{enumerate}
\item Копируете 2ю строчку в файл foo\footnote{foo,
bar и baz --- имена метапеременных. Это слова-заменители, которые применяются
в технических текстах для обозначения чего-либо,
что может стоять на их месте}.pl.

Теперь достаточно набрать в
консоли:

\texttt{perl foo.pl}

Скрипт будет выполнен. Если foo.pl лежит вне текущего каталога,
необходимо указать полный путь к файлу:

\texttt{perl /home/YOBA/perl/foo.pl}

\item Другой способ состоит в том, чтоб сделать скрипт „\emph{исполняемым}”.
Для этого необходимо скопировать в файл foo.pl обе строчки. В первой
строке содержится специальная управляющая последовательность —
„\emph{\#!}”. Если строка начинается с неё, значит, далее в этой строке
прописан путь до интерпретатора Perl. Ключ „\emph{-w}” просит интерпретатор
выводить более подробные предупреждения и сообщения. Советую всегда
использовать его. Кстати, совершенно не обязательно, что в твоей
системе интерпретатор живет в папке /usr/bin. Чтобы точно узнать,
что же нужно писать в первой строке, достаточно ввести команду:

\texttt{which perl}

Также необходимо дать файлу со скриптом права на исполнение:

\texttt{chmod +x foo.pl}

Готово! Теперь скрипт можно запустить, просто набрав его имя в консоли:

\texttt{./foo.pl}

Если кто-то не знает, \emph{„./”} на Unix-подобных системах синоним для
текущего каталога. Также есть синоним для родительского каталога
„\emph{\symbol{126}/}” . Дело в том, что Linux и Unix пользователи хранят свои лич-
ные файлы (а скрипты дело очень личное) где-то в своих домашних
каталогах. Например „\emph{/home/Yoba/perlperl/}” , так вот, чтоб не писать
„\emph{/home/Yoba/}” , достаточно написать „\emph{\symbol{126}/}” .

Если foo.pl находится в каталоге отличном от текущего — необходимо
указать его полное имя . Полное имя включает в себя полный путь и % а как же относительный путь?
имя файла.

\item Можно обойтись вообще без файлов, используя знаменитые перловые
однострочники. Для этого вызываем интерпретатор с ключом \emph{„-e”} 
\footnote{Данный
ключ говорит интерпретатору, что далее пойдет не имя файла со скриптом,
а код на Perl который нужно выполнить.}
и пишем наш однострочник, заключив его в одинарные кавычки:

\texttt{perl -e \textquotesingle print "YOBA ETO TI?\textbackslash n";}\textquotesingle
\end{enumerate}

\textbf{На Windows:}
Здесь всё просто. Создаём файл с расширением \remph{pl} , в папке со скриптами.
Там же должен лежать созданный ранее батник, запускаем его. В открывшейся консоли набираем:

\texttt{perl foo.pl}

Однострочник под Windows будет выглядеть иначе. Дело в том, что под
Windows скрипт должен быть заключен в двойные кавычки, поэтому нужно
заменить кавычки в print на их синоним-- конструкцию \remph{qq()}.
Всё, что находится в скобках, будет вести себя так же, как если бы его
заключили в двойные кавычки. В остальном для однострочников справедливо
все, что сказано для однострочников под Linux. Итак:

\texttt{perl -e "print qq(YOBA ETO TI?\textbackslash n);"}

Готово! Я у мамы программист!

Теперь давай разбираться в нашем первом скрипте. Что мы видим?
Во-первых, оператор print. Оператор -- это кусочек кода, который
что-то делает. В данном случае он осуществляет вывод на экран.
Каждый оператор отделяется точкой с запятой. Забытая точка с запятой
приведет к синтаксической ошибке.

Далее идёт заключенный в кавычки текст. При этом кавычки могут быть
как двойные, так и одинарные. В чем разница? Важный момент! Существует
такое понятие, как \remph{интерполяция} , иначе подстановка. В одинарных
кавычках подстановка \textbf{не} осуществляется. Хотя есть два исключения, это 
\textbackslash\textquotesingle , для того, чтоб использовать одинарные кавычки в строке,
 ограниченной ими же, и
\textbackslash\textbackslash, чтоб можно было \remph{отключить} слэш в
конце строки (иначе он отключит одинарную кавычку). В двойных
осуществляется и ещё как! Что это значит? Некоторые вещи, заключенные в
двойные кавычки имеют сакральный смысл. Например есть ряд символов, 
начинающихся с бэкслэша:

\textbackslash t — табуляция

\textbackslash n — перевод строки

\textbackslash\textbackslash — бэкслэш

Тысячи их. В нашем примере мы используем перевод строки.
Советую запомнить этот спец. символ.

О комментариях. Всё что идёт после символа \emph{\#} считается комментарием.
Думаю, не нужно объяснять зачем комментировать скрипты? Остановимся на
менее очевидном применении комментариев. Можно целеком „закомментировать”
строчку, если не хочешь, чтоб она выполнялась по каким-либо причинам.

Ещё пара слов об однострочниках. Perl, как никакой другой язык
программирования, помогает людям в повседневной жизни, в том числе с
помощью однострочников. Однострочник -- это скрипт, записанный в одну
строку и переданный интерпретатору на исполнение непосредственно, без
создания файла не жестком диске. Ну действительно, зачем плодить лишние
сущности для скрипта-однодневки, вычисляющего значение конкретного
выражения? Кстати, именно благодаря однострочникам, Perl получил славу
непонятного и сложного языка. Скрипты, записанные одной строкой
действительно трудно читать. Понятность приносится в жертву удобству. Но %Не всегда трудно, можно запилить переводы строк.
однострочники обычно пишут раз и навсегда, не предполагая их изменения
в дальнейшем. Хотя конечно однострочник может содержать что угодно,
будь то фильтр текстовых строк, конвертер валют или интернет-магазин.
%\vskip

{\large{\textbf{Вопросы для самоконтроля:}}}

\begin{enumerate}
\item Что такое скрипт?
\item Для чего предназначен интерпретатор?
\item Чем программа отличается от алгоритма?
\item Из чего состоит полное имя файла?
\end{enumerate}

{\large{\textbf{Задания к разделу:}}}

\begin{enumerate}
\item Напишите однострочник, выводящий на экран следующий текст:
\begin{verbatim}
-$USERNAME, ДЕВУШКУ-ТО СЕБЕ НАШЕЛ?
-Нет.
-А ЧЕ ТАК? ТЫ ЧАСОМ НЕ ИЗ ЭТИХ?
\end{verbatim}
\item Что выведет на экран этот скрипт? Почему? Запустите его и проверьте
себя. Если ошиблись — 20 отжиманий.
\end{enumerate}

\perl{l02.pl}

\subsection{Типы данных}
\subsubsection{Скаляры}

Печатать фразы на экране быстро надоедает. Гораздо полезней было бы 
начать проводить какие-нибудь вычисления. Но вычисления проводятся над 
данными, а данные нужно где-то хранить. Для этого существуют переменные, а 
точнее \emph{скаляры} . В скаляре может храниться практически всё, что 
угодно, но только одно! Будь то числа, строки или, например, картинки. 
Универсальный контейнер на все случаи жизни. Неважно, какие данные вы 
хотите сохранить в скаляре, Perl всю рутину берёт на себя. В отличие, 
например, от Си, в котором целые и вещественные\footnote{Вещественные --- 
дробные числа} числа должны храниться в переменных разных типов.

Имя скаляра может содержать буквы латинского алфавита, цифры, символы 
подчёркивания. Причем идентификатор\footnote{Идентификатор --- имя скаляра, 
массива, хэша и т.п. Имя вашей переменной.} не должен начинаться с цифры. 
Вот примеры имён скаляров:

\begin{itemize}
\item \$counter
\item \$thread\_4574321
\item \$my\_var
\end{itemize}

Внимательный читатель должен был заметить знак доллара. Это 
\emph{разыменовывающий префикс} . Он говорит интерпретатору, что следующий 
за ним текст — имя скаляра. Для каждого типа данных свой разыменовывающий 
префикс. \$ — для скаляров. Легко запомнить, он похож на латинскую ’s’ в 
слове ’scalar’. @ — для массивов, тоже легко запомнить, как лат. ’a’ в слове 
’array’. Ну и \% — для хэшей. Но об этом позже.

Важный момент! Perl регистрозависим. Это означает, что \$YOBA и \$Yoba это два 
разных скаляра, не забывайте об этом! Тащемта скаляр --- это просто 
именованный кусочек памяти, в котором программа хранит свои данные.

Теперь мы знаем достаточно и можем использовать скаляры. Давайте 
сохраним в скаляр какое-нибудь значение:

\begin{verbatim}
$foo = 12345679;
\end{verbatim}

Что мы видим? Во-первых скаляр \$foo. Затем идёт оператор присваивания. Очень 
важно не путать оператор присваивания „=” с оператором равенства „==”. В 
данном случае, значок „=” говорит: „Скаляр \$foo устанавливается равным 
12345679”. 12345679 в данном примере является константой. Константа зашивается в 
программу, ей нельзя присваивать значение, её нельзя изменить. Но это, мне 
кажется, и так понятно. В конце идёт старый добрый символ точки с запятой, 
завершающий операцию присваивания.

Давайте поподробней остановимся на операциях. Операция есть какое-либо 
основное действие, предусмотренное самим языком. Операции бывают унарные 
(работают с одним значением), бинарные(два значения) и даже тернарные (три 
значения, разумеется, таких будет только одна). Операции отделяются друг 
от друга точкой с запятой. В нашем примере используется бинарная операция 
присваивания. В ней левому значению-операнду (наш скаляр \$foo) 
присваивается значение, находящееся справа (12345679). Также интересно знать, 
что Perl игнорирует пробельные символы (пробел, табуляция, перевод строки) 
везде, где только можно. Поэтому наше присваивание можно записать даже 
так:

\begin{verbatim}
        $foo
=
                12345679
;
\end{verbatim}

Давайте теперь запустим такой скрипт:

\perl{l03.pl}

В выводе мы использовали ранее оговоренное явление интерполяции. Как 
видно по четвёртой строке, вместо имени скаляра (\$foo) в print подставляется 
его значение. Но что, если нам нужно вывести идентификатор скаляра, а не 
его значение? Для этого мы \remph{экранируем} (отключаем) бэкслэшем 
разыменовывающий префикс \remph{\$} .

Как я уже говорил, в скаляре можно хранить не только числа. К примеру:

\begin{verbatim}
$bar= "SERBIA STRONG!\n";
\end{verbatim}

Несложно догадаться и о том, какие арифметические операции есть в нашем 
распоряжении:

\begin{verbatim}
$baz= 99/2*3+4-5;
++$foo; #аналогично $foo= $foo +1 или $foo+= 1;
\end{verbatim}

Пояснения требует разве что последняя строчка. В ней с помощью унарной 
операции значение скаляра \emph{инкрементируется} (увеличивается на 
единицу). Существует также краткая запись для операции \emph{декремента} 
(уменьшения на единицу), как ни странно, она выглядит так „\texttt{-\--}”.

Инкремент и декремент не так просты как кажутся. Их можно записать в 
префиксной (до операнда\footnote{Операнд --- аргумент операции. Данные, которые 
обрабатываются командой}) и постфиксной форме (после операнда). Выбор той 
или иной формы записи есть дело вкуса, но только в том случае, если 
инкрементирование/декрементирование не входит в состав других операций. 
В случае префиксной формы ин(де)кремент выполняется до выполнения 
операции, при постфиксной форме — после. Пример:

\perl{l04.pl}

Вики гласит: \remph{Скалярные переменные используются для хранения одиночных
значений. Они могут содержать числа, строки и ссылки на другие объекты.
Перед именем скалярной переменной необходимо ставить знак доллара ’\$’.
Тип скалярной переменной не фиксирован (в отличие от, например, языка 
Си) и определяется динамически в зависимости от контекста.}

Примеры:% рассказать о конкатенации строк, указателях и прочей хуите?

\perl{l05.pl}

{\large{\textbf{Вопросы для самоконтроля:}}}

\begin{enumerate}
\item Что такое операция, операнд и оператор?
\item Для чего предназначены скаляры?
\item Что такое разыменовывающий префикс и идентификатор скаляра?
\item Чем отличается префиксная и постфиксная форма записи в унарных
операциях?
\end{enumerate}

{\large{\textbf{Задания к разделу:}}}

\begin{enumerate}
\item Приведите пример унарных и бинарных операций.
\item Найдите в сети информацию о требованиях, предъявляемых к
идентификаторам. Какие стили именования переменных существуют? Что такое
\remph{верблюжья нотация} ?
\item Что будет напечатано на экране после выполнения скрипта? В чём
ошибка?

\perl{l06.pl}

Так уж и быть, дам развёрнутый ответ на первый вопрос. Тем более, что он не 
вполне очевиден. Как видно, скаляр начинает существовать с момента его 
первого упоминания, что очень плохо и в будущем мы научимся лечить этот 
недуг с помощью прагмы strict. Если такому скаляру не присвоить какое-либо 
значение, его содержимое будет не определено. Числовой эквивалент 
неопределенного значения равен нулю. Поэтому результатом выражения 
является ноль. Ответ на второй вопрос найти не трудно, но я подскажу. Perl 
регистрозависим!
\item Напишите 4 способа увеличить значение скаляра на 1 одной
операцией. Не выходит? Двадцать отжиманий.
\item Обладая знаниями об однострочниках, скалярах и операциях, уже
сейчас можно использовать Perl, как калькулятор. Напишите однострочник,
приводящий обыкновенную дробь $\frac{355}{113}$ за авторством китайского
астронома Цзу Чунчжи, в десятичный вид. Часть какого числа скрывается в
данной дроби?
\end{enumerate}

\subsubsection{Массивы}

Ранее мы говорили о скалярах, причем говорили уважительно. Каждый скаляр 
у нас был индивидуален, со своим уникальным идентификатором. Но такой 
подход не всегда оправдан. Представьте, что мы хотим обработать книгу и 
каждую её строчку хорошо бы поместить в отдельный скаляр. Сотни, тысячи 
скаляров! И каждому нужно придумать имя -- нет пути! Поэтому существуют 
массивы. Я уже говорил, что у массивов рызыменовывающим префиксом служит 
собака? Массив похож на тюрьму, где скаляры сидят в камерах под 
порядковыми номерами, а собака их охраняет :)

Ну что ж, давай попробуем наполнить нашу тюрьму арестантами и сделать 
что-нибудь с одним из них:

\perl{l07.pl}

В строках 3 и 4 мы задаём список начальных значений для массива. Иначе 
можно сказать, мы „инициализируем” массив. Строка не помещалась на 
странице и я разбил её на две, я уже говорил, что перлу плевать на подобные 
отступы. К имени каждого арестанта был добавлен символ перевода строки, 
иначе имена склеились бы во время вывода (строка 8). Попробуйте убрать 
переводы строк и посмотрите, что из этого получится. После присваивания 
массиву списка арестантов, мы можем обращаться к каждому из них по 
индексу. Нумерация начинается с нуля, очень важно не забывать об этом! Т.е. 
после присваивания в нулевой камере находится Юрий Есин, а индекс Ильхама 
равен трём. Но, по-видимому, 0 вызывает у Юрия неприятные ассоциации, 
поэтому администрация решила пойти на уступки, поменяв его местами с 
Ильхамом. Этот процесс простирается с 5й по 7ю строку. В пятой строке мы 
копируем Ильхама в скаляр с именем \$temp. В шестой строке Юрий Есин 
переезжает из нулевой камеры в третью, тем временем стирая с лица земли 
клон Ильхама, теперь у нас два Юрия! Но это ненадолго, в седьмой строке 
Ильхам занимает положенное место. Заметьте, что когда речь идёт о 
конкретном значении массива, рызыменовывающий префикс меняется на знак 
доллара. Так мы говорим Perl`у, что подразумеваем конкретный скаляр 
(конкретного зека), а не весь массив. Вот так например можно вывести имя 
элемента с индексом два:

\begin{verbatim}
print $jail[2];
\end{verbatim}

Также существуют отрицательные индексы. Индекс -1 позволяет получить 
доступ к последнему элементу, -2 к предпоследнему и так далее. Всегда можно 
узнать размер массива:

\begin{verbatim}
print $#jail +1 . "\n";
\end{verbatim}

Кстати, точка осуществляет конкатенацию (склеивание) строк. В переменной 
\$\#имя\_массива содержится индекс последнего элемента массива. Если 
прибавить к значению этой переменной единицу, мы получим количество 
элементов в массиве.

Для работы с массивами существует ряд подпрограмм (функций):

\begin{itemize}
\item push @array значение ; \#Добавить значение в конец массива.
\item pop @array; \#Удаляет последний элемент и возвращает его значение.
\item unshift @array; \#добавляет элемент в начало массива.
\item shift @array; \#удаляет первый элемент и возвращает его значение.
\end{itemize}

Что значит \remph{возвращает} ? Любой оператор, любая подпрограмма в
Perl что-то возвращает. Возвращаемое значение можно использовать или
игнорировать, но оно есть:

\perl{l08.pl}

В данном примере интерпретатор встречает имя подпрограммы \remph{pop}. Она 
удаляет последний элемент массива (Ильхам Зюлькорнеев) и возвращает его 
значение. Т.е. подставляет на место своего вызова. После того, как pop 
сделает своё дело, она как бы подставит в строку 5 вместо \remph{pop(@jail)} 
удалённый ранее элемент. Мы могли никак не отреагировать на возвращаемое 
значение, но в данном случае оно пригодилось. В строке 6 выводится 
значение последнего элемента, теперь можно видеть, что крайний у нас 
Владимир Дерюжкин.

Кстати! Если элемент не должен содержть пробелов, можно воспользоваться 
специальной конструкцией \remph{qw()} , которая аналогична двойным кавычкам, 
при этом, она сама расставляет запятые, что экономит время.

Пример:

\begin{verbatim}
@a= qw(Один Два Три 4 5 6 7);
\end{verbatim}

\subsubsection{Хэши}

Хэши --- тоже массивы, только ассоциативные. От обычных массивов они 
отличаются тем, что элементы в них не упорядочены; получать значение 
элемента нужно не по индексу, а по \emph{ключу}. На самом деле хэши --- вещь 
очень удобная, просто к ней нужно привыкнуть. Разыменовывающий префикс 
для хэшей таков \remph{\%} . Также справедливо правило, гласящее: когда мы 
обращаемся к конкретному элементу, необходимо менять разыменовывающий 
префикс на \remph{\$} . Пример:

\perl{l09.pl}

Во второй сроке мы говорим интерпретатору, что хотим использовать модуль 
„POSIX\footnote{POSIX читается, как позикс -- позитив. Переносимый интерфейс 
операционных систем Unix}”. В этом модуле определена нужная нам 
подпрограмма \remph{ceil} , которая округляет дробь до большего целого. В 
строках 4-6 парами \emph{ключ => значение}\footnote{Оператор \remph{=>}
ведёт себя, как обыкновенная запятая, но автоматически заключает в кавычки
значение, стоящее слева}
инициализируется хэш. Perl игнорирует пробельные 
символы\footnote{К пробельным символам относятся пробел, табуляция и перевод 
строки} , поэтому я разбиваю оператор на несколько строк для наглядности. 
В строке девять мы считываем в скаляр строку с клавиатуры. Строка 
считывается до тех пор, пока пользователь не нажмет ввод (\emph{Enter}, перевод 
строки). Но нажатый ввод тоже записывается в нашу строку в виде символа 
перевода строки, его нужно удалить. Это приходится делать так часто, что 
существует специальная функция из 10й строки. \remph{chomp} удаляет пробельный 
символ из конца переданной ему строки. В нашем случае, строка -- это 
содержимое скаляра \emph{\$country} . О вводе/выводе мы поговорим более подробно 
позднее. Особый интерес представляет 12я строка. В ней мы получаем элемент 
из хэша по ключу:

\begin{verbatim}
$pipirka{$country};
\end{verbatim}

Ключом у нас служит строка, записанная в скаляр \emph{\$country} . Элемент из хэша 
подставляется на место вызова и тут же попадает в крепкие объятья 
подпрограммы \emph{ceil} , которая округляет дробь до большего целого и 
возвращает результат. Возвращенное значение приклеивается к строке \remph{В 
этой стране } с помощью точки (оператора конкатенации). Затем к
получившейся строке дописывается ещё один кусочек \remph{см это
роскошь!\textbackslash n}.

\subsection {Управляющие конструкции}
\subsubsection{Ветвление}

\emph{Есть два стула...}

\emph{Истина} и \emph{Ложь} --- ключевые понятия в информатике. Ещё в 1666г. Готфрид 
Вильгельм Лейбниц пытался перевести логику (или, как называл ее Лейбниц, 
законы мышления) из словесного царства, полного неопределенностей, в 
царство математики, где отношения между объектами или высказываниями 
определяются совершенно точно. К сожалению, на тот момент применения этим 
трудам Лейбница не нашлось, но оно нашлось позже. Огромный вклад в 
становление \remph{Алгебры Логики} внёс Джордж Буль, поэтому часто сей 
предмет так и называют \remph{Булевой Алгеброй} . К счастью, для понимания 
многих вещей нам достаточно самых основ, освоить которые может любой 
школьник. Первое основное понятие --- это \remph{Логическое высказывание} .

\begin{itemize}
\item \emph{Логическое высказывание} — утверждение, о котором всегда можно 
однозначно сказать, истинно оно или ложно.
\end{itemize}

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

\begin{itemize}
\item Пять больше двух : ИСТИНА
\item Абу --- админ сайта со смешными картинками : ИСТИНА
\item В неделе три дня : ЛОЖЬ
\end{itemize}

Теперь нам нужно строгое определение Истины и Лжи. Не будем лезть в 
философию, достаточно чисто технической точки зрения. Приведу цитату от 
автора Perl’а:

\begin{em}
Что же такое "истина"и "ложь"? В Perl эти правила несколько странноваты, но, 
тем не менее, дают ожидаемые результаты. Управляющее выражение 
вычисляется как строковая величина в скалярном контексте (если это уже 
строка, ничего не изменяется, а если это число, то оно преобразуется в 
строку*). Если данная строка либо пуста (т.е. имеет нулевую длину), либо 
состоит из одного символа "0"(цифры нуль), то значение выражения — "ложь". 
Все остальное автоматически дает значение "истина". Почему же в Perl столь 
забавные правила? А потому, что это облегчает условный переход не только 
по нулю (в противоположность ненулевому числу), но и по пустой (в 
противоположность непустой) строке, причем без необходимости создания 
двух версий интерпретируемых значений "истина"и "ложь". Вот несколько 
примеров интерпретации этих значений.

\begin{itemize}
\item 0 \# преобразуется в "0 поэтому "ложь"
\item 1-1 \# дает в результате 0, затем преобразуется в "О поэтому "ложь"
\item 1 \# преобразуется в "1 поэтому "истина"
\item \# пустая строка, поэтому "ложь"
\item "1"\# не или "0 поэтому "истина"
\item "00" \# не или "0 поэтому "истина"(это странно, поэтому будьте настороже)
\item "0.000"\# "истина"— будьте внимательны, по той же причине
\item undef \# дает в результате , поэтому "ложь"
\end{itemize}
\end{em}

Если проще: „Истина --- это любое значение, не равное нулю”. Примеры 
истинных значений в Perl:

\begin{itemize}
\item "ALLO YOBA\textbackslash n"
\item -1
\item 2
\item 555
\item 0.1
\end{itemize}

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

\begin{verbatim}
$foo;
\end{verbatim}

В скаляре \remph{\$foo} будет содержаться ложное значение, ибо значение его не 
определено.

Как же заставить Perl принимать решения? Для этого существует специальная 
конструкция:

\perl{l10.pl}

После ключевого слова \remph{if} в скобках записывается выражение, истинность 
которого проверяется. Если выражение истинно, выполняется блок 
операторов в первых фигурных скобхах (с 2 по 4ю строки). Если же выражение 
ложно, вместо первого блока выполняется блок, идущий после ключевого 
слова \remph{else}. Второй блок необязателен и строки с 5-8 можно не писать. В 
этом случае оператор ветвления ничего не сделает, если выражение ложно.

Очень часто приходится проверять несколько условий, для этого есть 
специальная конструкция:

\begin{verbatim}
if (условие1)
  {
    #операторы, если условие1 истинно
  }
elsif (условие2)
  {
    # операторы, если истинно условие 2
  }
else
  {
    # Операторы на случай, если оба условия ложны
  }
\end{verbatim}

В богатом арсенале Perl есть ещё одно спецсредство, \remph{unless} :

\begin{verbatim}
unless(условие)
  {
    #операторы
  }
\end{verbatim}

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

\perl{l11.pl}

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

\begin{itemize}
\item НЕ — логическое отрицание
\item ИЛИ — логическое сложение
\item И — логическое умножение
\end{itemize}

В перле \remph{НЕ} выглядит так: \remph{not} . Инвертирует значение логического 
выражения. Истина становится ложью, а ложь истиной. \remph{ИЛИ} в перле 
представляется ключевым словом \remph{or} . Операция бинарная, сравнивает два 
логических значения, в итоге получается истина, если хотя бы одно из 
значений истинно. Примеры:

\begin{itemize}
\item 1 or 0 - ИСТИНА
\item 1 or 1 - ИСТИНА
\item 0 or 0 - ЛОЖЬ
\end{itemize}

\remph{И} - логическое умножение, в перле представлена ключевым словом \remph{and} 
. Ложно, если хотя бы одно из условий ложно:

\begin{itemize}
\item 1 and 0 - ЛОЖЬ
\item 0 and 1 - ЛОЖЬ
\item 1 and 1 - ИСТИНА
\end{itemize}

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

\begin{verbatim}
оператор ключевое_слово логическое_выражение;
\end{verbatim}

Пример:

\begin{verbatim}
print "ТОЛЬКО МОЛОДОСТЬ!\n" if $bus == 359;
\end{verbatim}

Кстати, символы сравнения:
\begin{itemize}
\item == равно
\item != не рано
\item > больше
\item < меньше
\item <= меньше или равно
\item >= больше или равно
\end{itemize}

Завершая теоретическую часть, расскажу о таком интересном приёме, как 
короткозамкнутость. В погоне за производительностью создатели 
интерпретаторов просекли, что, например, если левая часть выражения \remph{И} 
ложна, то нет смысла вычислять правую. В результате будет ложь. В случае с 
\remph{ИЛИ} нет смысла считать правую часть, если левая истинна. Чтоб стало 
понятней, улучшим описанный ранее листинг:

\perl{l12.pl}

Если в хэше нет страны, имя которой ввел пользователь, приложение 
завершается с выводом сообщения. \remph{die} занимается именно завершением 
скриптов на случай „нештатных” ситуаций, выводя сообщение, которое ей 
передают в качестве параметра.

В 12й строке представлена так называемая \remph{постфиксная} запись 
оператора ветвления. Условие записывается после оператора, но смысл от 
этого не меняется. Вначале проверится условие и, в зависимости от 
результата, оператор слева выполнится/не выполнится. Кстати, unless лучше 
использовать только в простой (постфиксной) форме, сложные условия в unless 
читать трудно, запомните это и постарайтесь избегать таких решений. 
Оператор \remph{exists} возвращает логическое значение, говорящее о 
существовании элемента с данным ключом в хэше. Этот оператор позволяет 
избежать проблем преобразования. Например, если стереть \remph{exists} и ввести 
„Амазония”, хэш вернёт значение ноль, которое будет преобразовано в 
ложь, и это несмотря на то, что значение с таким ключом существует!

Как видите, я не использую кавычки для ключей (Россия, Эстония и т.д.), так 
как оператор \remph{=>} автоматически заключает левый операнд в кавычки. 

\subsubsection{Циклы}

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

Итак, циклы --- это конструкция, которая выполняет некоторые действия
до тех пор, пока условие цикла выполняется. Делаем вывод:

\begin{enumerate}
\item У цикла есть условие
\item Также у него есть тело --- блок операторов, который будет выполняться, 
пока условие цикла истинно.
\item Цикл однажды должен завершиться. Тут два стула: либо условие станет 
ложным, либо мы повалим его насильственно.
\end{enumerate}

Сразу к делу. Первым циклом, который мы рассмотрим, будет \remph{while}. На 
русский это ключевое слово переводится, как „пока” или ,скорее, „до тех 
пор, пока”. Синтаксис:

\begin{verbatim}
while(условие)
  {
    #делаем что-то полезное, пока условие истинно
  }
\end{verbatim}

Пример:

\perl{l13.pl}

В листинге скаляр \emph{\$i} используется в качестве счетчика. В строке 6 мы 
проверяем условие "счетчик меньше или равен индексу последнего элемента 
массива?". Если да --- очередной элемент выводится на экран и значение 
счетчика увеличивается на единицу. Важный момент: если забыть увеличить 
счетчик --- скрипт \emph{зациклится}.

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

\begin{verbatim}
while($i= pop @porn_stars)
  {
    print "$i\n";
  }
\end{verbatim}

\emph{pop} будет удалять по одному элементу из массива, удалённые элементы 
присваиваются скаляру \emph{\$i} и затем выводятся на экран. Когда элементов в 
массиве не останется, \emph{pop} вернёт 0, а ноль суть ложь --- цикл прервется.

Очень хорошим примером будет вычисление числа $\pi$ по формуле Валлиса:% вообще тут должено быть \dotsm, но мне лень это подключать

$$\frac{2}{1}\cdot\frac{2}{3}\cdot\frac{4}{3}\cdot\frac{4}{5}\cdot\frac{6}{5}\cdot\frac{6}{7}
\cdot\frac{8}{7}\cdot\frac{8}{9}\dotsc = \frac{\pi}{2}$$

Формула не самая эффективная. $\pi$ уточняется достаточно долго. Пример:

\perl{l14.pl}

Скаляр \remph{\$e} указывает, до каких пор может увеличиваться числитель. 
Возможно, стоит уменьшить значение \remph{\$e} , иначе тело цикла совершит 250 
миллионов проходов\footnote{повторения цикла частенько называют итерациями. 
Запомните этот термин, он очень распространён.} , мой компьютер затратил 
на всё около 5 минут и вычислил число $\pi$ с точностью до восьмого 
десятичного знака. С 3 по 7 строку мы задаём начальные значения 
(инициализируем) скалярам, которые будут использоваться в цикле. Скаляр 
\remph{\$a} используется в качестве счетчика. В строке 9 мы проверяем, не 
превысил ли скаляр \remph{\$a} значение, хранящееся в \remph{\$e} , если так --- 
завершаем цикл. Очень важно, чтоб цикл когда-нибудь завершался, иначе 
скрипт \remph{зациклится} . Например, это может произойти , если программист 
забудет вставить в цикл код, увеличивающий счетчик. Обратите внимание на 
сокращённую запись, такая есть для многих операций. Советую запомнить эту 
фичу, экономит время.

Но \remph{while} в предыдущем примере --- не совсем подходящая кандидатура. Для 
реализации цикла с параметром в Perl есть гораздо более удобная 
конструкция:

\begin{verbatim}
for(начальное_значение_параметра; условие; приращение_параметра)
  {
    #делаем что-то полезное
  }
\end{verbatim}

А вот и пример:

\perl{l15.pl}% я бы приращение назвал изменением.

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

\begin{verbatim}
...
for(;;)
  {
    #делаем что-то полезно
  }
...
\end{verbatim}

Данная конструкция начинает „бесконечный цикл”. В кавычках, т.к. 
бесконечных циклов быть в принципе не должно. И в этом случае цикл тоже 
прервется, но насильно, из собственного тела. Для этих целей существует 
ключевое слово \remph{last} . Встретив его, интерпретатор выходит из текущего 
цикла. Примером у нас будет реализация алгоритма \remph{быстрого поиска} в 
массиве. Чем он отличается от простого перебора всех элементов? Обычный 
поиск \remph{в лоб} :

\perl{l16.pl}

Здесь нам приходится делать проверку дважды. Во-первых, мы проверяем 
счётчик на каждой итерации (строка 5), во-вторых, сравниваем каждый элемент 
с искомым значением (строка 7). Если искомый элемент найден, завершаем цикл 
с помощью \remph{last} в строке 7. Но мы могли бы обойтись одной проверкой в 
строке семь. Для этого нужно сделать так, чтоб скрипт в любом случае 
наткнулся на искомый элемент, для этого добавляем его в конец. 
Следовательно, если индекс найденного элемента окажется последним 
индексом массива, будем считать, что массив не содержит данного элемента:

\perl{l17.pl}

Выигрываем в скорости, но проигрываем в памяти. Ведь ещё один элемент 
нужно где-то хранить! Больше комментировать нечего. Пример достаточно 
очевиден.

Кроме \remph{last} существуют ещё два оператора для управления циклом:

\begin{itemize}
\item next — перейти к следующей итерации
\item redo — повторить текущую итерацию
\end{itemize}

Первую вещь я использую очень часто. Например, чтоб пропустить какую-то 
часть тела цикла на текущем ходу, второй пользовать не приходилось. Если 
узнаете простой и доступный пример — пишите! Добавлю в книгу!

Как я уже говорил, циклы и массивы так тесно связаны, что для обработки 
массивов существует специальная конструкция \remph{foreach} -- \remph{для каждого} . 
Синтаксис:

\begin{verbatim}
foreach текущий_элемент (массив)
  {
    #делаем что-то полезное
  }
\end{verbatim}

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

\perl{l18.pl}

Думаю, здесь всё очевидно. Цикл переберет все элементы массива и 
автоматически завершится.

Говоря о циклах, думаю стоит упомянуть о такой вещи, как \emph{map} . Этот 
оператор чем-то напоминает foreach. Он выполняет блок операторов для каждого 
элемента списка, который ему выдали\footnote{Вообще, map в других языках 
вызывает функцию поочерёдно на каждом элементе массива и возвращает 
результат. Более того, map может применять функцию, принимающую несколько 
аргументов на нескольких массивах -- массив первого, второго аргумента и 
так далее. Исправить map в Perl поможет функция zip на массивах аргументов.}, но 
в отличие от чистокровного цикла, map ещё и список возвращает. Этот список 
можно использовать в корыстных целях. Вот простой пример:

\perl{l19.pl}

Для каждого элемента массива „@a” выполняется блок операторов в 
фигурных скобках. Как видно, здесь действуют правила возврата значений из 
подпрограмм. Возвращается последнее вычисленное значение (которым 
является скаляр „\$scalar”). Текущий элемент находится в знакомом спец. 
скаляре „\$\_”. Если его изменить, измениться и соответствующий элемент в 
массиве „@a”. Но в нашем примере массив „@a” не меняется, зато создается 
новый массив, содержащий все элементы из „@a”, но в верхнем регистре.

\subsection{Генерал Фэйлор. Пара слов об ошибках.}%надо рассказать про REPL
%http://stackoverflow.com/questions/73667/how-can-i-start-an-interactive-console-for-perl

\begin{em}
Программирование сегодня — это гонка разработчиков программ, стремящихся
писать программы больше и с лучшей идиотоустойчивостью, и вселенной,
которая пытается создавать больших и лучших идиотов. Пока вселенная
побеждает.

\begin{flushright}
Rick Cook
\end{flushright}

\end{em}
%pageref на листинг 13. Можно попробовать автоматически создавать label`ы для листингов.

Вернёмся к первому примеру на странице~\pageref{lst:l13.pl} и сотрём оператор инкремента
\remph{\$i++} из цикла \remph{while} . Больше \$i не увеличивается, и
Perl обречён вечно выводить имя луноликой Саши. Это одна из самых страшных
ошибок, а ошибки бывают двух типов:

\begin{enumerate}
\item Синтаксические
\item Логические
\end{enumerate}

Синтаксическая ошибка --- это, например, пропущенная скобка или забытая 
точка с запятой. Наткнувшись на такую ошибку, интерпретатор обзовет 
погромиста дураком и откажется выполнять скрипт. И это очень хорошо! 
Такие ошибки самые безобидные и их видно сразу. Логические же ошибки 
намного коварней. Они не противоречат правилам языка, программа 
собирается без проблем, но ведёт себя не так, как хотелось бы. В нашем 
случае нетрудно понять, в чем же проблема, но в больших проектах это сущий 
Ад и Израиль. Недаром до 70\% времени, затраченного на создание программного 
обеспечения, занимает именно отладка.

Конечно можно отлаживать простым путём, всюду втыкая \remph{print} , но в нашем 
арсенале есть более простое и эффективное средство: \remph{perldebug}~! Давайте 
попробуем препарировать скрипт, считающий число $\pi$ , который находится 
на странице~\pageref{lst:l14.pl}. Чтобы начать, достаточно выполнить команду:

\begin{verbatim}
perl -d pi.pl
\end{verbatim}

Поздравляю, мы в отладчике! Что дальше? Давайте осмотримся. Вот так можно 
вывести строки с 5 по 10:

\begin{verbatim}
l 5-10
\end{verbatim}

На экран будет выведен фрагмент листинга, каждая строчка которого с 
любовью пронумерована по порядку. Нас интересуют только строчки, несущие 
смысловую нагрузку. Таковые после своего номера обозначены двоеточием. 
Теперь давайте укажем интерпретатору, что на шестой строке нужно будет 
сделать привал\footnote{Другими словами, при запуске программы, 
интерпретатор остановится на этой строке и будет ждать наших дальнейших 
указаний. Удобно в случае, если нам хочется не прослеживать ход работы 
программы с самого начала, а выяснить работу конкретного куска кода. 
Точка, где мы прикажем отладчику остановиться, называется \emph{точкой 
останова} (Breakpoint)}:

\begin{verbatim}
b 6
\end{verbatim}

Отлично. Начнём отладку командой \remph{r} . Скрипт начнёт выполняться и 
остановится на 6й строке. Теперь можно с помощью команды \remph{p} посмотреть 
значение какого-либо скаляра. Например:

\begin{verbatim}
p $e
\end{verbatim}

 Теперь можно, например, выполнять строку за строкой, нажимая \remph{s} или 
продолжить выполнение до следующей точки останова (если она есть) введя 
\remph{c} . Кстати, если нужно выполнить предыдущую команду, достаточно просто 
нажать enter. Для удаления точки останова, на которой сейчас находимся, 
необходимо нажать \remph{d} , для удаления вообще всех точек останова -- \remph{D}. 
Чтобы выйти из отладчика, необходимо ввести \remph{q} . На этом остановимся. 
Отладчик Perl -- вещь мощная, о нём есть даже целая книга. Поэтому google в 
помощь! 

\subsubsection{Константы}

\begin{em}
Я уехал, я уехал в Петербург,\\
А приехал в Ленинград.
\begin{flushright}
--- Борис Моисеев и Людмила Гурченко\\
„Петербург --- Ленинград”
\end{flushright}
\end{em}

Неожиданный финал, не правда ли? Чтобы подобные неприятности не 
случались, некоторые вещи должны оставаться неизменными. Любовь мамы и 
верность родине. Поэтому, сейчас мы будем говорить о константах. Тем 
более, что, судя по CPAN\footnote{Comprehensive Perl Archive Network, хранилище библиотек кода на 
Perl. Более подробно см. раздел ``Карп в пакете''}, программистам на Perl их явно 
недостаёт. Но я не буду рассказывать о сторонних модулях, гораздо 
полезней знать о том, что у нас всегда под рукой. Итак, несколько 
\textbf{ВАНИЛЬНЫХ}\footnote{Под „ванильными” я подразумеваю средства, входящие 
в стандартную поставку Perl} способов задания констант на Perl.

\perl{l20.pl}

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

Начиная с версии 5.8, можно сделать скаляр константным вот так:

\begin{verbatim}
Internals::SvREADONLY($RO_SCALAR => 1);
\end{verbatim}

Теперь при попытке изменить значение \$RO\_SCALAR интерпретатор прекратит 
выполнение скрипта с сообщением об ошибке. А с помощью команды:

\begin{verbatim}
Internals::SvREADONLY($RO_SCALAR => 0);
\end{verbatim}

Мы снова делаем скаляр доступным для записи. Преимущество данного метода 
в том, что работа с подобными „константами” ничем не отличается от 
работы со скаляром.

А вот ещё один способ. Старый, как сам перл:

\begin{verbatim}
*PI = \3.14159265358979323;
\end{verbatim}

Теперь можно писать:

\begin{verbatim}
print "$PI\n";
\end{verbatim}

В данном случае мы используем значения типа typeglob (запись таблицы 
символов). Это ещё один тип данных в Perl, о котором мы когда-нибудь 
поговорим более подробно. Я обещаю. А пока я позволю себе отмазаться 
словами Ларри: „То чего ты не знаешь, не может навредить. Во всяком случае, 
сильно.”

Зачем вообще нужны эти ваши константы?

\begin{enumerate}
\item Исчезает необходимость помнить конкретные числа — имена
запоминаются легче;
\item Ошибки в именах обычно выявляются компилятором автоматически;
\item Упростился процесс внесения изменений: значение константы задано
в программе всего в одном месте.
\end{enumerate}

Если коротко, константы гораздо информативней, чем
„магические числа”\footnote{Магическими числами называют плохую практику
программирования, когда в исходном тексте встречается числовое значение
и не очевидно, что оно означает.} , плюс они делают программу более
безопасной и переносимой.

\subsubsection{Нерушимые хэши}

Слава strict! Теперь мы не можем создать скаляр, просто опис\'{а}вшись,
но сохранить данные не по тому ключу хэша можем, ещё как. Недавно,
подобная ошибка стоила мне целого сундука нервов. Но даже если вас
съели, есть как минимум два выхода! Поэтому use Hash::Util, Luke.

В принципе, здесь: http://perldoc.perl.org/Hash/Util.html%\url{http://perldoc.perl.org/Hash/Util.html}
всё подробно описано. Но я опишу самые „вкусные” функции:

\begin{enumerate}
\item lock\_keys/unlock\_keys --- запрещает/разрешает добавлять новые
ключи в переданный хэш. Но ключи по-прежнему можно удалить.
\item lock\_value/unlock\_value --- запрещает/разрешает изменять
значение переданного ключа, но не запрещает его удаление.
\item lock\_hash/ulock\_hash --- Радикальные функции. Делают хэш
полностью константным. Ничего нельзя изменить или удалить.
\end{enumerate}

Нехитрые приёмы, описанные в данном разделе, способны сэкономить
кучу времени и нервов. Пользуйтесь на здоровье!