страница №1

Владимир Маслов. Введение в Perl





© Copyright (C) Маслов Владимир Викторович
Все замечания и предложения направляйте по адресу:
emailmaslov@klgtts.kaluga.su

emailmaslov@news.kaluga.rosmail.com




Все примеры в книге проверены для Perl версии 5.003
операционной системы Unix FreeBSD 2.1.0.



Содержание





  • Аддитивные операторы.
  • Операторы сдвига.
  • Именованные унарные операторы.
  • Операторы отношений.
  • Операторы равенства.
  • Операторы работы с битами.
  • Логические операторы && (AND) и || (OR).
  • Оператор диаппазона '..'
  • Условный оператор '?:'
  • Операторы присваивания.
  • Оператор ',' (запятая)
  • Логические not, and, or, xor
  • Операторы ограничители строк.
  • Операторы ввода-вывода.
  • Слияние констант.
  • Целочисленная арифметика.

  • Встроенные функции
  • Подпрограммы

    1. Private переменные.
    2. Переменные типа local.
    3. Прототипы (prototypes).
    4. Ссылка как параметр.
    5. Переопределение встроенных функций.
    6. Автозагрузка.

  • Модули

    1. Таблицы имен.
    2. Конструкторы и деструкторы.
    3. Классы.
    4. Создание библиотеки.
    5. Pragma библиотеки.
    6. Стандартные библиотеки.
    7. CPAN

  • Форматы отчетов
  • Отладка
  • Список литературы.
  • Интернет - ссылки.

    Все замечания и предложения направляйте по адресу:


    maslov@klgtts.kaluga.su


    maslov@news.kaluga.rosmail.com


    -->

    Аннотация



    В книге приводятся начальные сведения по новому языку
    программирования Perl.
    Данный язык получил широкое распространение в связи с
    развитием компьютерной сети Интернет. Все примеры в книге
    проверены для Perl версии 5.003 операционной системы Unix
    FreeBSD 2.1.0.

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

    (C) Маслов Владимир Викторович.

    От простого к сложному



    Прежде чем приступить к последовательному ознакомлению с
    не знакомым для вас языком, должен оговориться и сказать, что
    все примеры да и сам язык описанию которого посвящена эта книга
    это Perl версии 5.003 для операционной системы FreeBSD версии
    2.01. Существуют реализации этого языка для операционных
    систем OS/2 , MS-DOS и Windows NT но они немного отстают по
    возможностям от оригинала, рожденного в недрах Юникса.

    Пример 1 Введите в файл test1.pl следующие строки:



    #!/usr/local/bin/perl
    # Содержимое файла test1.pl
    print "Наше Вам с кисточкой!\n";

    А теперь подробно разберем каждую строку.

    #!/usr/local/bin/perl
    Данная строка должна быть первой в любой Пел-программе.
    Она указыванет системному интерпретатору что данный файл - это Пел-программа.

    # Содержимое файла test1.pl
    Эта строка называется комментарием. Она всегда начинается
    символом '#' и заканчивается таким объяснением что как говорил
    великий Ходжа Насреддин "это тонкий филосовский
    вопрос", а говоря простым языком здесь можно писать все что угодно.
    Даже пожелание руководству. Уж здесь оно точно до него не
    дойдет.

    print "Наше Вам с кисточкой!\n";
    Самая последняя ну и конечно главная. Она просто выводит
    на экран надпись "Наше Вам с кисточкой!".

    Здесь слово print - это команда "вывести". Все что в кавычках - это символы,
    \n - перевод строки и ';' - признак конца команды. Он обязателен.
    В одной строке может быть несколько команд и все они должны завершаться
    символом ';'. После него может быть символ '#' - это значит остаток
    строки считается комментарием.

    Над этой строкой автору
    пришлось больше всего поломать голову так как в нее постоянно
    лезли какие то странные "hello", "hello all", "Построемся и спасемся",
    "Строй наше спасение" и т.д и т.п.

    Если вы никогда не работали с Пел, то бъюсь на спор в 10$, что данная
    программа сразу у вас не заработает!
    Не потому что она не верна, а потому что "Нельзя объять необъятное".
    Сразу, потом можно, да и то частями.
    Сначало сделайте ваш файл test1.pl исполняемым. Для этого введите
    команду:

    chmod +x test1.pl

    Затем проверьте где у вас Пел. Для этого введите:

    which perl

    Система вам выдаст что то вроде: /usr/bin/perl

    Если: perl: Command not found.

    То тогда закройте книжку и ложитесь спать. У вас просто нет Пел или
    он не установлен. А мне остается послать вас к системному администратору
    или к man (для переводчиков- man сокращение от manual а не то что вы подумали).

    Теперь проверьте что бы строка 01 содержала то что выдала команда which.
    Если совпало то введите:

    test1.pl

    и бъсь на 50$ что и теперь программа не заработает, так как правильней
    ввести:

    ./test1.pl

    Если я проиграл, то не радуйтесь. Да же если вам удалось запустить программу
    как test1.pl это значит, что у вас будут неприятности в будущем.

    Пример 2 Данная программа выводит на экран все ваши секреты. А именно файл /etc/passwd.



    #!/usr/local/bin/perl
    open(PASS, "</etc/passwd") || die "Файл не найден!";
    while(<PASS>)
    {
    print;
    }
    close(PASS);

    Пояснения:

    open(PASS, "</etc/passwd") || die "Файл не найден!";
    "Открыть" файл т.е. создать указатель файла PASS и
    в случае ошибки выдать "Файл не найден!" и закончить программу.

    while(<PASS>)
    Читать по одной строке файла в переменную по умолчанию $_.

    {
    Открыть блок операторов.

    print;
    Вывести на экран переменную по умолчанию $_

    }
    Конец блока.

    close(PASS);
    Закрыть файл. Этого можно и не делать так-как файл автоматически
    закроется после окончания программы.

    Результат работы этой программы тот же что и команды cat /etc/passwd.
    По экрану пробежали непонятные строки но зато теперь перед вами
    открыты горизонты Пел программирования!
    Все последующие примеры будут развитием этой программы и она
    превратится из гадкого утенка в прекрасного лебедя (не генерала).

    Пример 3 Разделенеие полей.



    #!/usr/local/bin/perl
    open(PASS, "</etc/passwd") || die "Файл не найден!";
    while(<PASS>)
    {
    ($login, $pass, $uid, $gid, $name, $home_dir, $shell) = split(':');
    print "$login \t $name\n";
    }
    close(PASS);

    Пояснение:

    ($login, $pass, $uid, $gid, $name, $home_dir, $shell) = split(':');
    Присвоить указанным переменным поля входной строки, считая разделителем символ ':'.

    print "$login \t $name\n";
    Вывести login - имя пользователя и его описание. Поля разделены символом '\t' - табуляции.


    Пример 4 Вывести имена пользователей отсортированных по группам.



    #!/usr/local/bin/perl
    open(PASS, "sort -n -t : +3 -4 +0 /etc/passwd|") || die "Файл не найден!";
    while(<PASS>)
    {
    ($login, $pass, $uid, $gid, $name, $home_dir, $shell) = split(':');
    print "$login \t $gid \t $name\n";
    }
    close(PASS);

    Поеснения:

    open(PASS, "sort -n -t : +3 -4 +0 /etc/passwd|") || die "Файл не найден!";
    В данной строке весь фокус! Входным файлом для нашей программы
    стал выход команды sort которая и отсортирует входные данные.


    Форматированный вывод.

    Ну а теперь напечатаем на экране все наши данные в удобной форме.


    #!/usr/local/bin/perl

    open(PASS, "sort -n -t : +3 -4 +0 /etc/passwd|") || die "Файл не найден!";
    while(<PASS>)
    {
    ($login, $pass, $uid, $gid, $name, $home_dir, $shell) = split(':');
    write(); # Форматированный ывод данных.
    }
    close(PASS);
    exit 0; # Завершение программы

    ############ Описание формы вывода ##################

    format STDOUT =

    Пользователь: ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    $name
    ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    $name
    ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    $name


    Login:@<<<<<<<< Uid:@<<< Gid:@<<< Home dir:@<<<<<<<<<<<<<<<<<<<<<
    $login, $uid, $gid, $home_dir



    . # Это последняя строка программы


    Фрагмент результата:

    Пользователь: Калужский ликеро-водочный завод. Лучшие водки и
    настойки. Звонить только перед праздником Кострикову
    Анатолию т. 2-23-06,,,


    Login:uucryst Uid:1055 Gid:66 Home dir:/var/spool/uucppublic/




    Пользователь: Торговый Дом Дилен,,,




    Login:uudilen Uid:1075 Gid:66 Home dir:/var/spool/uucppublic



    Если вам интересно узнать как работает эта программа, то переверните
    страницу и начините свое путешествие в мире Пел.
    Желаю удачи!

    Запуск интерпретатора Пел



    Синтаксис:



    perl [ключи] файл аргументы

    Перед стартом Пел ищет скрипт (программу) в следующем порядке:

    1. В командной строке если указан ключ '-e'

    2. Содержимое файла указанного в командной строке. В первой
    строке можно указывать #!/usr/bin/perl для "автоматического"
    запуска скрипта.

    3. Стандартный ввод/вывод если не указан файл или аргументы
    содержащие имя файла. Для передачи аргументов скрипту из
    стандартного потока имя файла в командной строке обозначается
    символом '-'.

    В методах 1 и 2 Пел сканирует строки начиная с первой если не
    указан ключ '-x', в противном случае началом программы считается
    строка с символами '#!' в начале и содержащая слово 'perl'.
    Концом программы считается строка '__END__'.
    В строке с '#!' можно указывать и ключи. Например '#!/bin/perl -d'
    для отладки программ.

    После "обнаружения" скрипта Пел компилирует его целиком во внутреннее
    представление. Если обнаруживаются ошибки то выполнение прекращается.
    Если ошибок нет он выполняется. Если скрипт заканчивается без
    команд exit() или die() то по умолчанию выполняется команда exit(0)
    обозначающая нормальное завершение программы.

    Ключи:



    -Oцифры


    Код символа-разделителя записей. По умолчанию \0.

    -a


    Включает режим автоматического разделения (split) переменной $_
    в массив $F. Применяется с ключами -n и -p.

    -c


    Выполняется синтаксическая проверка скрипта и выход без запуска.

    -d


    Запуск в режиме интерактивной отладки.

    -Dчисло или Dсписок


    Установить флаги отладки Пел. Например -d14 проследить
    как Пел исполняет вашу программу.

    1 p Синтаксический разбор
    2 s Состояние стека
    4 l Состояние стека имен
    8 t Трассировка исполнения
    16 o Создание оператора узла
    32 c Строковое/числовое преобразование
    64 p Вывод команды препроцессора для -P
    128 m Распределение памяти
    256 f Обработка формата
    512 r Синтаксический разбор регулярных выражений
    1024 x Дамп синтаксического дерева
    2048 u Проверка защиты
    4096 L "Утечка" памяти
    8192 H Дамп хеша
    16384 X Распределение scratchpad
    32768 D Очистка


    -e команда


    Выполнение скрипта из одной строки указанного в командной строке.

    -F шаблон


    Указывает шаблон разделения в режиме работы с ключом -a

    -iрасширение


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

    Пример:
    perl -p -i.old -e "s/рядовой/ефрейтор/" file

    - Поменять все слова "рядовой" на "ефрейтор" в файле file
    а оригинал записать в файле file.old

    -Iдиректория


    Директория includ- файлов для С препроцессора. Применяется с ключом -P
    по умолчанию это /usr/include и /usr/lib/perl.

    -lчисло


    Автоматическая обработка символа конца строки. Работает в двух случаях.
    1. Отбрасывает последний символ читаемых строк для режимов -n и -p
    2. Присваивает указанное значение переменной $\. Таким образом
    к концу каждой строки выводимой оператором print добавляется этот символ.

    -n


    Зацикливает скрипт и последовательно обрабатывает файлы указанные
    в командной строке. Позволяет создавать команды подобные sed или awk.
    Операторы BEGIN и END дают возможность делать начальные и конечные
    установки. Содержимое файлов не выводится.

    -p


    То же что и -n но печатает обрабатываемые строки файлов.

    -P


    Предварительная обработко препроцессором языка С. Будьте внимательны
    и не применяйте в комментариях слова 'if', 'else' или 'define'
    т.к. это команды С - препроцессора.

    -s


    Включение режима обработки ключей командной строки запуска скрипта.
    Все аргументы с символом '-' в начале, считаются ключом и переменным
    с таким же именем присваивается значение true.

    -S


    Использование системной переменной PATH для поиска скрипта.
    Данный ключ применяется в системах не воспринимающих последовательность
    "#!" в начале скрипта для указания интерпретатора.

    -T


    Режим проверки "дыр" в защите. Обычно это нужно для программ
    работающих в режиме повышенной привелегии (setuid, setguid).
    Желательно для CGI скриптов.

    -u


    Принудительный дамп памяти после компиляции скрипта. Этот дамп
    можно потом использовать для создания исполняемого файла с
    помощью программы undump.

    -U


    Разрешение выполнять опасные операции. Например стереть директорию
    или выполнять явно не закрытую программу.

    -v


    Вывод номера версии Пел.

    -w


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

    -x директория


    Режим запуска скрипта вставленного в файл содержащий
    обычный текст. Началом скрипта считаестся строка с символами '#!'
    в начале и содержащия слово perl. Концом - строка с '__END__'
    Указанная директория становится текущей в момент исполнения.
    Если необходимо читать последующие строки то это лучше делать
    через указатель файла DATA.


    Синтаксис



    Пел программа (скрипт) состоит из последовательности деклараций и предложений.
    Единственно что должно быть обязательно декларировано это форматы отчетов
    и подпрограммы (функции). Все не объявленные переменные, массивы, имеют
    значение 0 или null.

    Декларации (объявления).



    Пел имеет свободный формат. Комментарии начинаются с символа '#' и
    продолжаются до конца строки.
    Декларации могут использоваться в любом месте программы так же как и
    предложения (statements) но действуют они только в фазе компиляции
    программы. Обычно их помещают или в начале или в конце программы.
    Декларация подпрограмм позволяет использовать имя подпрограммы
    как списковый оператор начиная с момента декларирования.

    Пример:
    sub test; # Декларация подпрограммы test

    $var1 = test $0; # Использование как оператора списка.

    Декларации подпрограмм могут быть загружены из отдельного файла
    предложением require или загружено и импортировано в текущую
    область имен предложением use. Подробно см. главу Модули.


    Простое предложение.



    Простое предложение обязательно
    заканчивается символом ';' если только это не последнее предложение
    в блоке где ';' можно опустить. Заметьте что существуют операторы
    такие как eval{} и do{} которые выглядят как сложные предложения
    но на самом деле это термы и требуют обязательного указания конца
    предложения.

    Любое простое предложение может содержать single модификатор
    перед ';'. Существуют следующие single модификаторы:

    if EXPR
    unless EXPR
    while EXPR
    until EXPR

    где EXPR - выражение возвращающее логическое значение true или false.
    Модификаторы while и until вычисляются в начале предложения кроме блока do который выполняется первым.

    if EXPR - Модификатор "если". Предложение выполняется если EXPR возвращает true.

    Пример:
    $var = 1;
    $var2 = 3 if $var > 0; # Результат: $var2 = 3

    while EXPR - Модификатор "пока". Предложение выполняется столько раз пока EXPR = true

    Пример:
    $var = 1;
    print $var++ while $var < 5; # Печать $var с инкрементом

    Результат: 1234


    until EXPR - Модификатор "до ". Предложение выполняется до тех пор пока EXPR = false

    Пример:
    $var = 1;
    print $var++ until $var > 5; # Печать $var с инкрементом

    Результат: 12345

    unless EXPR - Модификатор "если не" . Обратный к if. Выражение выполняется есле EXPR = false.

    Пример:
    $var = 1;
    print $var++ unless $var > 5; # Печать $var с инкрементом

    Результат: 1


    Сложные предложения.



    Последовательность простых предложений ограниченная функциональными
    ограничителями называется блоком. В Пел это может быть
    целый файл, последовательность предложений в операторе eval{} или
    чаще всего это множество простых предложений ограниченных круглыми
    скобками '{}'.

    Сужествуют следующие виды сложных предложений:

    if (EXPR) BLOCK
    if (EXPR) BLOCK else BLOCK
    if (EXPR) BLOCK elsif (EXPR) BLOCK ... else BLOCK

    LABEL while (EXPR) BLOCK
    LABEL while (EXPR) BLOCK continue BLOCK
    LABEL for (EXPR; EXPR; EXPR) BLOCK
    LABEL foreach VAR (LIST) BLOCK
    LABEL BLOCK continue BLOCK

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

    if (EXPR) BLOCK - Вычисляется логическое выражение EXPR и если true блок выполняется.

    Пример:
    $var =1;
    if ($var == 1)
    { print $var,"\n";
    }
    Результат: 1


    if (EXPR) BLOCK else BLOCK2 - Если EXPR=true выполняется BLOCK иначе BLOCK2.

    Пример:
    $var =2;
    if ($var == 1)
    { print "\$var = 1\n";
    }
    else
    { print "\$var не равно 1\n";
    }

    Результат: $var не равно 1

    if (EXPR1) BLOCK1 elsif (EXPR2) BLOCK2 ... else BLOCK -
    Если EXPR1=true выполняется BLOCK1 иначе если EXPR2=true выполняется
    BLOCK2 иначе ... иначе BLOCK.

    Пример:
    $var = 1;
    if ($var == 0)
    { print "\$var = 0\n";
    }
    elsif ($var == 1)
    { print "\$var = 1\n";
    }
    else
    { print "Не известное \$var\n";
    }

    Результат: $var = 1

    Цикл while выполняет BLOCK до тех пор пока EXPR = true. Метка LABEL не
    обязательна и состоит из идентификатора завершающегося символом ':'.
    Метка необходима при использовании внутри блока цикла управляющих
    операторов next, last и redo. Если метка все же отсутсвует то
    эти операторы ссылаются к началу ближайшего цикла.
    Блок после continue выполняется всегда перед тем как вычисляется
    логическое выражение EXPR. Это подобно EXPR3 в предлжении for
    поэтому в этом блоке удобно изменять счетчики и флаги цикла даже
    если применяестя оператор next.

    Операторы управления циклом.



    next - подобен continue в С. Переходит к началу текущего цикла
    т.е. повторяет итерацию.

    Пример:
    M1:
    while ($i < 6)
    {
    ++$i; # Увеличиваем счетчик на 1
    next M1 if $i < 3; # Переходим в начало если $i < 3
    ++$i; # иначе увеличиваем счетчик еще раз на 1
    }
    continue
    {
    print "$i "; # Печатаем $i
    }

    Результат: 1 2 4 6

    last - подобен оператору break в языке С. Немедленно прерывает цикл.
    Блок continue пропускается.

    Пример:
    M1:
    while ($i < 6)
    {
    ++$i; # Увеличиваем счетчик на 1
    last M1 if $i > 3; # Выход из цикла если $i > 3
    ++$i; # иначе увеличиваем счетчик еще раз на 1
    }
    continue {
    print "$i "; # Печатаем $i
    }

    Результат: 2 4

    redo - начать новый цикл не вычисляя EXPR и не выполняя continue блок.

    Пример:
    M1:
    while ($i < 6)
    {
    ++$i; # Увеличиваем счетчик на 1
    redo M1 if $i == 3; # Далее пропустить для $i = 3
    ++$i; # иначе увеличиваем счетчик еще раз на 1
    }
    continue {
    print "$i "; # Печатаем $i
    }

    Результат: 2 5 7


    Цикл for.



    LABEL for (EXPR1; EXPR2; EXPR3) BLOCK
    Оператор for полностью аналогичен оператору for в С. В перед началом
    цикла выполняется EXPR1, если EXPR2 = true выполняется блок, затем
    выполняется EXPR3.

    Пример:
    for ($i = 2; $i < 5; ++$i)
    {
    print $i, " ";
    }
    print "\nПосле цикла i = $i\n";

    Результат:
    2 3 4
    После цикла i = 5

    Цикл foreach.



    LABEL foreach VAR (LIST) BLOCK

    Переменной VAR присваивается поочередно каждый элемент списка LIST
    и выполняется блок. Если VAR опущенно то элементы присваиваются
    встроеной переменной $_. Если в теле блока изменять значение VAR
    то это вызовет изменение и элементов списка т.к. VAR фактически
    указывает на текущий элемент списка.
    Вместо слова foreach можно писать просто for - это слова синонимы.

    Пример:
    @месяц = ("январь","февраль","март"); # Создали массив
    foreach $i (@месяц)
    {
    print $i," "; # Печать $i
    }

    Результат: январь февраль март

    Пример:
    @месяц = ("январь","февраль","март"); # Создали массив
    foreach $i (@месяц)
    {
    $i = uc($i); # Перевели в верхний регистр
    }
    print @месяц;

    Результат: ЯНВАРЬФЕВРАЛЬМАРТ

    Пример:

    for $i (3,5,7)
    {
    print "$i ";
    }
    Результат: 3 5 7


    Блоки и оператор switch.



    Блок не зависимо от того имеет он метку или нет семантически
    представляет собой цикл который выполняется один раз. Поэтому
    действие опраторов цикла next, last, redo - аналогично описанному
    выше. Блоки удобны для построения switch (переключатель) структур.
    В пел нет специального оператора switch подобного языку С поэтому
    вы сами можете создавать удобные для вас конструкции. Опыт автора
    показывает что для простоты написания лучше всего подходит
    конструкция вида if ... elsif ... else ... хотя можно сочинить
    и нечто подобное:

    SWITCH:
    {
    if ($i ==1 ) { .....; last SWITCH; }
    if ($i ==2 ) { .....; last SWITCH; }
    if ($i ==3 ) { .....; last SWITCH; }
    $default = 13;
    }

    Выбирайте сами по своему вкусу.


    Оператор goto.



    В Пел существует оператор goto хотя где , как и когда его применять
    как говорил Ходжа Насредин "Тонкий филосовский вопрос".
    Для начинающих программистов которым от так "нужен" я бы вообще
    посоветовал "забыть" о его существовании. Однако при создании
    больших производственных задач на последнем этапе особенно
    при отработке "отвальных" ошибочных ситуаций конечно goto нужен.

    В Пел реализовано три формы goto. goto - метка, goto - выражение
    и goto - подпрограмма.

    goto - метка выполняет непосредственный переход на указанную метку.

    goto - выражение - Вычисляет имя метки и делает соответсвующий переход.
    Например если мы хотим сделать переход на одну из трех меток
    "M1:", "M2:" или "M3:" в зависимости от значений переменной
    $i равной 0, 1 или 2 то это лучше сделать следующим образом:

    goto ("M1", "M2", "M3")[$i];

    здесь $i используется как индекс массива указанного непосредственно
    в выражении.

    goto подпрограмма - довольно редкий случай т.к. всегда проще и надежней
    вызвать подпрограмму "естественным" образом.

    POD операторы. Документирование программ.



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

    = head Набор стандартных процедур

    то пропускается все до слова '=cut'. Это удобно для включения
    длинных на несколько строк или страниц комментариев. Затем
    с помощью специальной программы pod можно отделить текст
    документации от текста программы.

    Переменные



    В Пел существует три типа структур данных: скаляры, массивы скаляров и
    хеши (hashes) - ассоциативные массивы скаляров. Обычно элементы массивов
    индексируются целыми числами, первый элемент - нулевой. Отрицательное
    значение индекса обозначает номер позиции элемента с конца. Хеши индексируются
    строками символов.

    Имена скалярных переменных всегда начинаются с символа '$' даже когда
    обозначают элемент массива.

    Пример:



    $var1 # Простой скаляр 'var1'

    @var1[0] # Первый элемент массива 'var1'

    $var1{'first'} # Элемент хэша с индексом 'first'


    В случае использования имени массива "целиком" или его "среза"
    перед именем массива ставится символ '@'.

    Пример:



    @var1 # Все элементы массива var1 ( $var1[0], $var1[1], ... $var1[n])

    @var1[1,3,10] # Элементы $var1[1], $var1[3], $var1[10]

    @var1{'first','last'} # то же что и ( $var1{'first'}, $var1{'last'} )

    Хеш "целиком" начинается с символа '%'.

    Пример:

    %var, %key, %years

    Имена подпрограмм начинаются символом '&' если из контекста не видно
    что это подпрограмма.

    Пример:

    &sub1, &test_prog, test(12)

    Имена таблиц символов всегда начинаются символом '*'.

    Каждый тип переменных имеет свою область памяти поэтому $var1 и $var1[0]
    совершенно разные переменные, хотя $var1[0] часть массива @var1. Так же\
    @var1 и %var1 - разные массивы переменных.

    Имена переменных могут содержать любые буквенно-цифровы символы за исключением
    пробела и табуляции. Эти смволы используются в качестве разделителей.
    Большие и малые буквы различаются поэтому $var1 и $Var1 - разные
    переменные. В Пел по умолчанию имена меток и указателей файлов пишут
    большими буквами.

    Контекст.



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

    Пример:

    $var1 = <>; # Прочитать одну строку файла

    @var1 = <>; # Прочитать все строки файла в массив @var1

    $var1 = (1,2,3); # $var = 3 - количество элементов

    @var1 = (1,2,3); # Создание массива @var1 с элементами 1,2,3

    Скалярные значения.



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

    В Пел не существует типов "строка" или "число" или "файл" или что то еще.
    Это контекстно зависимый полиморфный язык для работы с текстами.

    Скаляр имеет логическое значение "TRUE" (истина) если это не нулевая
    строка или число не равное 0.

    В Пел существует два типа нулевых (null) скаляров - определенные
    (defined) и не определенные (undefined). Не определенное значение
    возвращается когда что-то не существует. Например не известная
    переменная, конец файла или ошибка. С помощью функции defined()
    вы можете заранее обнаружить подобное состояние.

    Количество элементов массива так же является скаляром и начинается
    символами $# подобно интерпретатору csh. Фактически $#var1 - это
    индекс последнего элемента массива. Нужно помнить что первый
    элемент имеет индкес 0 поэтому количество элементов определяется
    как $#var1+1 . Присвоение значения $#var1 - изменит длину
    массива и разрушит "оставленные" значения.
    Присвоение значения элементу массива с индексом больше чем $#var1
    - увеличит размер массива, а присвоение ему нулевого списка -
    обнулит.

    В скалярном контексте имя массива возвращает его длину (для списка
    возвращается последний елемент).

    Пример:

    @var1 = (4, 3, 2, 1); # Присвоение значения элементам массива
    $i = @var1; # Использование скалярного контекста
    print $i; # Печать результата 4 - кол-во элементов
    print @var1; # Списковый контекст, печать всех элементов.

    Для принудительного получения скалярного значения удобно применять
    функцию scalar().

    Пример:

    print scalar(@var1); # Вывод длины массива а не его значений

    Хеш в скалярном контексте возвращает "true" если существует
    хотя бы одна пара "ключ-значение". Фактически возвращается строка
    типа 2/8 где 8 - количество выделенных "ячеек" памяти а
    2 - количество использованных.

    Конструкторы скаляров.

    Числа пишутся стандартно:

    123
    123.123
    0.12
    .12E-10
    0xABCD # Шестнадцетиричная запись
    0377 # Если 0 в начале - восьмеричная
    123_456_123 # Так тоже можно для удобства чтения.

    Строки ограничиваются одинарными (') или двойными (") кавычками:

    'Ровняйсь, смирно!'
    "Построемся и спасемся."

    Способов обозначения строк очень много. Плодробно смотрите описание
    оператора qq.
    В хеше можно опускать кавычки если индекс не содержит пробелов.

    Пример:

    $var1{first} то же что и $var1{'first'}

    Обратите внимание на то что перед первой одинарной кавычкой должен стоять
    пробел иначе строка воспримется как имя переменной так-как в именах
    разрешено использование одинарных кавычек.
    Запрещается в кавычках применять зарезервированные литералы __LINE__
    (номер текущей строки программы), __FILE__ (текущий файл).
    Для обозначения конца программы можно применять литерал __END__
    Весь последующий текст игнорируется, но его можно прочитать использую
    указатель файла DATA.

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

    В Пел есть возможность вставлять текст документа прямо в программу.
    Так называемый "here-doc" (здесь текст) метод. Обозначается символами
    << за которым идет слово-ограничитель.

    Пример:

    print <<EOF; # Все строки до EOF - текст для печати.

    Эй вы трое, идите двое сюда!

    Полковник Савонькин.
    EOF

    Конструкторы списков.



    Список - множество значений перечисленных через запятую и заключенных
    в круглые скобки. В списковом контексте список возвращает последний
    элемент списка.

    Пример:

    @var1 = (1, 2, 'привет', 1.2); # Присвоить значение элементам.

    где

    $var1[0] = 1,

    $var1[1] = 2,

    $var1[2] = 'привет'

    $var1[3] = 1.2


    $var1 = (1, 2, 'привет', 1.2);

    а здесь $var1 = 1.2 т.е. последнее значение списка.

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

    Пример:

    @s1 = (1, 2, 3); # Первый список

    @s2 = (6, 7, 8); # Второй

    @s = (0, @s1, 4, 5, @s2, 9, 10); # Включаем списки @s1 и @s2

    print @s; # Результат: 012345678910 - значения без пробелов.


    Список без элементов обозначаестя как () и называется нуль-списком.
    Списковое выражение можно употреблять как имя массива, но при этом
    его нужно брать в круглые скобки.

    Пример:

    print ('январь','февраль','март')[1];

    Результат: февраль

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

    Пример:

    ($a, $b, $c) = (1, 2, 3); # $a = 1, $b = 2, $c = 3

    Присваивание списков в скалярном контексте возвращает количество присвоенных
    элементов.

    Пример:

    $x = (($a, $b, $c) = (1,2)); # Результат $x=2

    В случае присваивания списка хешу список разсматривается как пары: ключ-значение.

    Пример:

    %дни_месяца = ('январь', 31, 'февраль', 30);

    Результат: $дни_месяца{январь} = 31, $дни_месяца{февраль} = 30

    Для удобства записи можно использовать выражение с => .

    Пример:

    %дни_месяца = (
    январь => 31,
    февраль => 30,
    );

    Тип typeglobs



    В Пел используется специальный внутренний тип typeglog для записи
    массива всех переменных. Такие массивы начинаются с символа '*'.
    Их удобно применять для передачи ссылок на массивы и хеши, но
    в данной версии Пел уже есть возможность применять
    ссылки поэтому это делается очень редко.
    Единственно где это необходимо так это для работы со
    ссылками на файлы. Например если вам нужно создать локальную
    ссылку на файл в процедуре то это лучше сделать так:

    sub new_sub
    { local *IN; # Ссылка на файл
    open (IN, "test") || return undef; # Открыть файл. Возврат при ошибке.
    .........
    return;
    }

    Более подробно это описано в главе Ссылки.

    Встроенные переменные Пел



    Описанные в данной главе переменныые имеют в Пел специальные значения.
    Они обозначаются несколько непривычно для "глаза" программистов
    т.к. состоят обычно только из дву символов причем первый это '$'
    символо с которого начинаются имена всех переменных и произвольный часто
    не буквенно-цифровой символ. Если вы хотите пользоваться их "нормальными"
    буквенными синонимами то вам нужно указать в начале программы:

    use English;

    Точно так же если вы захотите пользоваться переменными и методами
    текущего указателя файлов вы можете написать:

    use FileHandle;

    после этого можно можно просто писать:

    метод указатель выражение

    или

    указатель -> метод(выражение)


    Ниже приводятся имена как в короткой так и в длинной (словесной) форме.
    Некоторые из встроенных переменных имеют доступ тоько на чтение
    поэтому изменить их значение просто не возможно.

    $_



    $ARG


    Переменная - по умолчанию для операторов ввода и поиска.
    То есть если в качестве аргумента не указана никакая переменная то
    используется именно эта.

    $цифра


    Содержит найденные подстроку в последнем поиске когда
    шаблон содержит метасимволы в круглых скобках. Цифра в данном
    случае это номер скобок. Первая подстрока имеет номер 1.

    $&


    $MATCH
    Найденная подстрока в последнем поиске по шаблону.

    $`


    Подстрока предшевствующая найденной подстроке.

    $'


    $POSTMATCH
    Подстрока последующая за найденной подстрокой.

    $+


    $LAST_PAREN_MATCH
    Подстрока найденная в поиске с выбором по "или".

    $*


    $MULTILINE_MATCHING
    Если значение этой переменной установить равным 1 то
    переменная в которой осуществляется поиск будет считаться многосторочной
    т.е. содержащей символы '\n' - перевод строки. Если значеие равно 0
    то переменная считается однострочной. В Пел версии 5 и выше не рекомендуестя
    использовать эту переменную.

    $.


    $INPUT_LINE_NUMBER
    $NR
    Номер прочитанной строки последнего оператора ввода.
    Закрытие файла вызывает очистку значения этой переменной.

    $/


    $RS
    $INPUT_RECORD_SEPARATOR
    Символ - признак конца входной строки. По умолчанию это '\n'

    $|


    $OUTPUT_AUTOFLUSH
    Если присвоить этой переменной не нулевое значение то будет
    сброс буфера вывода после каждой операции вывода. Значение по умолчанию -0

    $,


    $OFS
    $OUTPUT_FIELD_SEPARATOR
    Символ добавляемый оператором print после каждого элемента
    из списка параметров.

    $\


    $ORS
    $OUTPUT_RECORD_SEPARATOR
    Символ добавляемый print после вывода всех параметров.

    $"


    $LIST_SEPARATOR
    Анологичен "$," но добавляется после каждого элемента массива
    указаноого в "....".

    $;


    $SUBSEP
    $SUBSCRIPT_SEPARATOR
    Символ - разделитель для эмуляции многомерных массивов в хеш
    массивах. По умолчанию '\034'.

    $#


    $OFMT
    Формат по умолчанию для вывода чисел.

    $%


    $FORMAT_PAGE_NUMBER
    Формат по умолчанию для вывода номеров страниц.

    $=


    $FORMAT_LINES_PER_PAGE
    Длина одной страницы. По умолчанию 60 строк.

    $-


    $FORMAT_LINES_LEFT
    Количество оставшихся строк на странице.

    $~


    $FORMAT_NAME
    Имя формата текущего вывода. По умолчанию имя указателя.

    $^


    $FORMAT_TOP_NAME
    Имя текущего формата для заголовка страницы.

    $:


    $FORMAT_LINE_BREAK_CHARACTERS
    Символы переноса строки для многострочных полей. В строке
    формата такие поля начинаются символом '^'. По умолчанию '\n-'.

    $^L


    $FORMAT_FORMFEED
    Символ перевода формата ( смены листа). По умолчанию '\f'.

    $^A


    $ACCUMULATOR
    Текущее значение аккумулятора функции write() для format().
    Значение этой переменной можно увидеть только при использовании
    функции formline() т.к. write() очищает ее после каждого вывода.

    $?


    $CHILD_ERROR
    Данная перменная содержит статус завершения таких процессов
    как: закрытие pipe, завершение функций system(), wait() и `...`.

    $!


    $ERRNO
    $OS_ERROR
    В числовом контексте возвращает код ошибки errno.
    В строковом - строку сообщения об ошибке. Можно принудительно
    присвоить этой перменной код ошибки что бы получить системное
    сообщение для данного кода или установить код завершения для
    функции die().

    $@


    $EVAL_ERROR
    Сообщение об ошибке последней команды eval().

    $$


    $PID
    $PROCESS_ID
    Номер текущего процесса.

    $<


    $UID
    $REAL_USER_ID
    Реальный UID текущего процесса.

    $>


    $EUID
    $EFFECTIVE_USER_ID
    Эффективный UID текущего процесса.

    $(


    $GID
    $REAL_GROUP_ID
    Реальный GID текущего процесса.

    $)


    $EGID
    $EFFECTIVE_GROUP_ID
    Эффективный GID текущего процесса.

    $O


    $PROGRAM_NAME
    Имя файла программы. Если этой переменной присвоить какое
    нибудь значение то его можно видеть в команде ps, что удобно для
    контроля за состоянием программы.

    $[


    Номер первого элемента массива или символа строки.
    Значение по умолчанию - 0.

    $]


    $PERL_VERSION
    Строка сообщение версии Пел. Печатается по команде perl -v
    Применяется в программе для определения рабочей версии Пел.
    В числовом контексте это номер версии плюс номер модификации / 1000.

    $^D


    $DEBUGGING
    Текущее значение ключа отладки '-D'.

    $^F


    $SYSTEM_FD_MAX
    Номер максимального системного описателя файлов (system file
    descriptor). Обычно это 2.

    $^I


    $INPLACE_EDIT
    Текущее значение inplace-edit возможности.
    Для отключения используйте undef.

    $^P


    $PERLDB
    Внутренний флаг отладки. Применяется для того что бы отладчик
    не отслеживал самого себя.

    $^T


    $BASETIME
    Время в секундах с начала 1970 года старта текущей программы.

    $^W


    $WARNING
    Значение флага '-w'. true -если включено и false - выключено.

    $^X


    $EXECUTABLE_NAME
    Команда запуска Пел. Аналогично argv[0] в С.

    $ARGV


    Имя текущего файла читаемого оператором '&lt;>'.

    @ARGV


    Массив параметров строки запуска программы.
    Внимание! @#ARGV - меньше количества параметров на 1 т.к.
    $ARGV[0] это первый параметр (не имя программы).

    @INC


    Список директорий диска которые просматривает Пел
    для выполнения команд do, require или use.

    %INC


    Этот хеш содержит имена директорий для имен использованных
    файлов командами do или require. Ключ - имя файла, а значение - директория.

    $ENV{выражение}


    Хеш %ENV содержит значения переменных окружения. Изменение
    этих значений вызывает изменение окружения для процессов потомков.

    $SIG{выражение}


    Хеш %SIG содержит имена подпрограмм для системных
    сигналов таких как INT, QUIT, PIPE, ...
    Значение 'DEFAULT' - для системной обработки.
    'IGNORE' - игнорировать данный сигнал.

    Регулярные выражения (шаблоны)



    В данной главе описывается синтаксис регулярных выражений. Чаще всего
    в Пел они используюстя в операторах поиска и замены таких как s//
    m/ операторах связки =~ или != и т.д.
    Как правило все эти операторы имеют схожие опции такие как:

    i - не различать строчные и заглавные буквы.
    m - считать строку многострочной.
    s - однострочная строка.
    x - расширенный синтаксис ( использование пробелов и комментариев)

    Обычно все эти опции обозначают как '/x'. Их можно использовать даже
    внутри шаблонов, используя новую конструкцию (?...)

    Регулярные выражения или шаблоны (pattern) то же самое что и regexp
    процедуры в Юниксе. Выражения и синтаксис заимствован из свободно
    распространяемых процедур V8 Генри Спенсера (Henry Spencer) там же
    они подробно и описаны.

    В шаблонах используются следующие метасимволы (символы обозначающие
    группы других символов) часто называемых egrep - стандартом:

    \ - считать следующий метасимвол как обычный символ.
    ^ - начало строки
    . - один произвольный символ. Кроме '\n' - конец строки.
    $ - конец строки
    | - альтернатива (или)
    () - группировка
    [] - класс символов

    Метасимволы имеют модификаторы (пишутся после метасимвола):

    * - повторяется 0 или большее число раз
    + - повторяется 1 или большее число раз
    ? - 1 или 0 раз
    {n} - точно n раз
    {n,} - по меньшей мере раз
    {n,m} - не менше n, но и не больше m

    Во все других случаях фигурные скобки считаются обычными (регулярными)
    символами. Таким образом '*' эквивалентна {0,} , '+' - {1,}
    и '?' - {0,1}. n и m не могут быть больше 65536.

    По умолчанию действие метасимволов "жадно" (greedy). Совпадение
    распространяется столько раз сколько возможно не учитывая результат
    действия следуюющих метасимволов. Если вы хотите "уменьшить их аппетит"
    то используйте символ '?'. Это не изменяет значение метасимволов
    просто уменьшает распространение. Таким образом:

    *? - станет 0 и более
    +? - 1 и более
    ?? - 0 или 1 раз
    {n}? - точно n раз
    {n,}? - не меньше n раз
    {n,m}? - больше или равно n и меньше m раз

    Шаблоны работают так же как и двойные кавычки поэтому в них можно
    использовать `\` - символы (бакслэш-символы):

    \t - символ табуляции
    \n - новая строка
    \r - перевод каретки
    \A - перевол формата
    \v - вертикальная табуляция
    \a - звонок
    \e - escape
    \033 - восьмеричная запись символа
    \x1A - шестнадцатеричная
    \c[ - control символ
    \l - нижний регистр следующего символа
    \u - верхний регистр -//-
    \L - все символы в нижнем регистре до \E
    \U - в верхнем -//-
    \E - ограничитель смены регистра
    \Q - отмена действия как метасимвола

    Дополнительно в Пел добавлены следующие метасимволы:

    \w - алфавитно-цифровой или '_' символ
    \W - не алфавитно-цифровой или '_' символ
    \s - один пробел
    \S - один не пробел
    \d - одна цифра
    \D - одна не цифра

    Обратите внимание что все это "один" символ. Для обозначения последовательности
    применяйте модификаторы. Так:

    \w+ - слово
    \d+ - целое число
    [+-]?\d+ - целое со знаком
    [+-]?\d+\.?\d* - число с точкой

    Кроме того существуют мнимые метасимволы. Обозначающие не существующие
    символы в месте смены значения. Такие как:

    \b - граница слова
    \B - не граница слова
    \A - начало строки
    \Z - конец строки
    \G - конец действия m//g

    Граница слова (\b) - это мнимая точка между символами \w и \W.
    Внутри класса символов '\b' обозначает символ backspace (стирания).
    Метасимволы \A и \Z - аналогичны '^' и '$' но если началостроки '^'
    и конец строки '$' действуют для каждой строки в многосторочной строке
    то \A и \Z обозначают начало и конец всей многосторчной строки.

    Если внутри шаблона применяется группировка (круглые скобки)
    то номер подстроки группы обозначается как '\цифра'.
    Заметьте что за шаблоном в пределах выражения или блока эти группы обозначаются
    как '$цифра'. Кроме этого существуют дополнительные переменные:

    $+ - обозначает последнее совпадение
    $& - все совпадение
    $` - все до совпадения
    $' - все после совпадения

    Пример:

    $s = "Один 1 два 2 и три 3";
    if ($s =~ /(\d+)\D+(\d+)/)
    {
    print "$1\n"; # Результат '1'
    print "$2\n"; # '2'
    print "$+\n"; # '2'
    print "$&\n"; # '1 два 2'
    print "$`\n"; # 'Один '
    print "$'\n"; # ' и три 3'
    }


    Пел версии 5 содержит дополнительные конструкции шаблонов:



    (?#комментарий) - комментарий в теле шаблона.

    (?:шаблон) - группировка как и '( )' но без обратной ссылки

    (?=шаблон) - "заглядывание" вперед. Например /\w+(?=\t)/
    соответствует слову за которым идет табуляция
    но символ '\t' не включается в результат.

    Пример:
    $s = "1+2-3*4";
    if ($s =~ /(\d)(?=-)/) # Наити цифру за которой стоит '-'
    {
    print "$1\n"; # Результат '2'
    }
    else { print "ошибка поиска\n";}


    (?!шаблон) - "заглядывание" вперед по отрицанию.

    Пример:
    $s = "1+2-3*4";
    if ($s =~ /(\d)(?!\+)/) # Наити цифру за которой не стоит '+'
    {
    print "$1\n"; # Результат '2'
    }
    else { print "ошибка поиска\n";}


    (?ismx) - "внутренние" модификаторы. Удобно применять в шаблонах
    где например нужно внутри шаблона указать модификатор.


    Правила регулярного выражения. (regex)



    1. Любой символ обозначает себя самого если это не метасимвол.
    Если вам нужно отменить действие метасимвола то поставьте
    перед ним '\'.
    2. Строка символов обозначает строку этих символов.

    3. Множество возможных символов (класс) заключается в квадратные
    скобки '[]' это значит что в данном месте может стоять один
    из указанных в скобках символ. Если первый символ в скобках
    это '^' - значит не один из указанных символов не может
    стоять в данном месте выражения. Внутри класса можно употреблять
    символ '-' обозначающий диаппазон символов. Например a-z
    один из малых букв латинского алфавита, 0-9 - цифра и т.д.

    4. Все символы, включая специальные можно обозначать с
    помощью '\' как в языке С.

    5. Альтернативные последовательности разделяются символом '|'
    Заметьте что внутри квадратных скобок это обычный символ.

    6. Внутри регулярного выражения можно указыват "подшаблоны"
    заключая их в круглые скобки и ссылаться на них как '\номер'
    Первая скобка обозначается как '\1'.

    Операторы и приоритеты



    В Пел ассоциативность и приоритетность операторов
    аналогична языку C. Ниже перечислены все операторы в порядке
    уменьшения приоритета, в начале строки указана ассоциативность.

    ассоц. операторы
    ----- ---------------------------
    левая термы и левосторонные списковые операторы
    левая ->
    - ++ --
    правая **
    правая ! ~ \ унарные + и -
    левая =~ !~
    левая * / % x
    левая + - .
    левая << >>
    - именованные унарные операторы
    - < > <= >= lt gt le ge
    - == != <=> eq ne cmp
    левая &
    левая | ^
    левая &&
    левая ||
    - ..
    правая ?:
    правая = += -= *= и т.д.
    левая , =>
    - правосторонние списковые операторы
    левая not
    левая and
    левая or xor


    Термы и левосторонние списковые операторы.



    Любой терм имеет самый высокий приоритет. К терму относятся
    переменные, кавычки и их операторы, арифметические и логические выражения
    в скобках, любые функции с параметрами в скобках. Фактически таких
    функций нет так как это просто унарные и списковые операторы просто
    они ведут себя подобно функциям с параметрами в скобках. Подробно смотри
    главу "Функции".
    Если после любого спикового оператора ( print(), и т.д.) или унарного
    оператора (chdir(), и т.д.) следует левая круглая скобка, то операторы
    внутри скобок имеют наивысший приоритет. Так же как и обычные функции.

    Если скобки отсутсвуют то приоритет списковых операторов или наивысший
    или наименьший в отношении операторов справа или слева от него.

    Например:

    @i = ('a ','b ', print 'c ', 'd ');
    print "\n",@i,"\n";

    Результат:
    c d
    a b 1

    Здесь мы имеем списковый оператор print. Для запятых слева от него он
    имеет наименьший приоритет, но повышает приоритет правой запятой.
    Поэтому правая запятая воспринимается как параметр для print и печатается
    'c d' а левая просто записывает код завершения операции в массив @i
    и последний print показывает это.

    Оператор '->'



    Так же как в С или С++ это инфиксный оператор переадрессации. Если
    справа от него стоит [...] или {...} выражение, то правая часть может
    быть непосредственной или символической ссылкой на массив или хеш.
    В противном случае правая сторона это метод или простой скаляр содержащий
    имя метода, а правая или объект или имя класса. Подробно смотри
    главу "Классы".

    Операторы ++ (инкремент) и — (декремент).



    Эти операторы работают так же как и в С. Если оператор стоит перед
    переменной то значение переменной изменяется на 1 и полученной значение
    используется. Если после переменной то ее величина изменяется после
    применения.

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

    Пример:
    print ++($i = "09"); # Результат "10"

    print ++($i = "a9"); # "b0"

    print ++($i = "az"); # "ba"

    print ++($i = "aZ"); # "bA"

    Оператор ** (возведение в степень)



    Пример:
    print 4**2 # Результат 16

    print -4**2 # Результат -16 т.е. -(4**2)

    Унарные операторы.



    '!' - логическое отрицание

    '-' - арифметический минус

    '~' - побитная инверсия (дополнение до 1)

    '+' - арифметический плюс

    '\' - получение ссылки на переменную (как & в С)

    Операторы "привязки" =~ и !~ .



    Эти "необычные

    Страницы

  • Подякувати Помилка?

    Дочати пiзнiше / подiлитися