Стандартные функции Perl

Устанавливает дескриптор FILEHANDLE для чтения или записи в "бинарный" или "текстовый" режимы в системах, библиотеки времени исполнения которых различают текстовые и двоичные данные. Если FILEHANDLE представляет собой выражение, то его значение принимается за имя дескриптора файла. Функция возвращает значение "истина" в случае успеха, в противном случае возвращает undef, а переменной $! присваивается сообщение об ошибке.

В некоторых системах (обычно это системы DOS и Windows) необходимо использовать binmode(), когда вы работаете не с текстовым файлом. В целях портативности будет хорошей практикой всегда использовать ее при необходимости, и никогда не использовать там, где она не подходит. Кроме того, люди могут устанавливать свои режимы ввода-вывода по умолчанию для UTF-8 закодированных данных, а не байтов.

Другими словами, независимо от платформы, используйте binmode() над бинарными данными, например такими, как изображения.

Если указан уровень LAYER, он является одной строкой, но может содержать несколько директив. Директивы изменяют поведение дескриптора. Когда LAYER указан, использование binmode над текстовым файлом имеет смысл.

Если LAYER опущен или указан как :raw,то дескриптор файла становится пригодным для передачи бинарных данных. Это включает в себя отключение возможных переводов CRLF и маркировки его как байт (в отличие от символов Юникода). Отметим, что несмотря на то, что может подразумеваться в "Программирование на Perl" (Камел, 3-е издание) или где-либо еще, :raw не просто обратна :crlf. Другие уровни, которые могут повлиять на бинарный характер потока также отключены. См. PerlIO, perlrun и обсуждение переменной среды PERLIO.

Директивы :bytes, :crlf, :utf8 и любые другие директивы в форме :... называются уровнями(layers) ввода-вывода. Для установки уровней ввода-вывода по умолчанию можно использовать прагму open. См. open.

Параметр LAYER функции binmode() описывается как "Дисциплина" в книге "Программирование на Perl, 3-го издания. Однако, с тех пор консенсус именования данной функциональности сместился с "дисциплина" на "уровень". По этой причине в документации текущей версии Perl мы используем понятие "уровни", а не "дисциплины".

Чтобы отметить FILEHANDLE как UTF-8, используйте :utf8 или :encoding(utf8). :utf8 только помечает данные как UTF-8 без дополнительной проверки, в то время как :encoding(utf8) проверяет данные на фактическую валидность UTF-8. Подробности можно найти в PerlIO::encoding.

В общем, binmode() должен вызываться после open(), но до операций ввода-вывода над дескриптором файла. Вызов binmode() обычно сбрасывает любые ожидающие буферизованные данные вывода (и, возможно, ожидающие данные ввода) дескриптора. Исключением является уровень :encoding, который изменяет для дескриптора кодировку по умолчанию, см "open". Уровень :encoding иногда необходимо вызывать в середине потока и это не сбрасывает поток. :encoding также неявно задействует уровень :utf8, поскольку внутренне Perl оперирует над utf-8 кодированными символами.

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

Mac OS, все вариации Unix и файлы Stream_LF в VMS используют один символ конца каждой строки во внешнем представлении текста (даже, если это один символ возврата каретки в Mac OS и перевода строки в Unix и в большинстве VMS файлов). В других системах, подобных OS/2, Dos и в различных разновидностях MS-Windows, ваша программа видит \n как один символ \cJ, но что хранится в текстовых файлах является двумя символами \cM\cJ. Это означает, что, если вы не используете binmode() в этих системах, последовательности \cM\cJ на диске будут преобразованы в \n на вводе и любые \n вашей программы будут преобразованы обратно в \cM\cJ на выводе. Это то что нужно для текстовых файлов, но это может быть катастрофическим для двоичных файлов.

Другим следствием использования binmode() (на некоторых системах) является то, что специальные маркеры конца файла будут рассматриваться как часть потока данных. Для систем из семейства Microsoft это означает, что, если бинарные данные содержат \cZ и вы не используете binmode(), то подсистема ввода-вывода эту последовательность принимает за конец файла.

binmode() имеет важное значение не только для операций readline() и print(), но так же при использовании read(), seak(), sysread(), syswrite() и tell() (см. perlport для более подробной информации). См. переменные $/ и $\ в perlvar о том, как вручную установить последовательности завершения строки для ввода и вывода.

• alarm SECONDS
• alarm

  Подготавливает сигнал SIGALRM, который будет передан текущему процессу по истечении указанного количества секунд. Если SECONDS не указано, используется значение из $_. (на некоторых машинах, к сожалению, прошедшее время может быть меньше или больше указанного на одну секунду, в зависимости от того, как считаются секунды. Из-за этого планировщик процессов может отложить доставку сигнала на некоторое время).

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

  Чтобы задать время подачи сигналов с большей точностью, чем одна секунда, можно применить функцию ualarm(), которую предоставляет модуль Time::HiRes (можно найти на CPAN, начиная с Perl 5.8 является частью дистрибутива). Также можно использовать 4х-аргументную версию select(), оставляя первые три аргумента неопределенными. Еще один вариант задать миллисекунды предоставляет интерфейс syscall для обращения к setitimer(2), если система поддерживает его. См. perlfaq8 подробнее.

  Обычно смешивание вызовов alarm и sleep является ошибкой, потому что в вашей системе функция sleep может быть внутренне реализована с использованием механизма системного вызова alarm(2).

  Если вы планируете использовать alarm для формирования тайм-аута системного вызова, необходимо использовать пару eval/die. Не стоит полагаться на то, что, в случае, если системный вызов не отработает должным образом, переменная $! будет содержать значение EINTR, поскольку на некоторых операционных системах, Perl устанавливает обработчики сигналов таким образом, чтобы они перезапускали системные вызовы. А вот связка eval/die работает всегда, возможные сложности описаны в perlipc.

      eval {
          local $SIG{ALRM} = sub { die "alarm\n" }; # NB: \n обязателен
          alarm $timeout;
          $nread = sysread SOCKET, $buffer, $size;
          alarm 0;
      };
      
      # если вышли по тайм-ауту $timeout
      if ($@) {
          die unless $@ eq "alarm\n";   # обработка неожиданных ошибок
      }
      # все в порядке, сработали пределах установленного времени $timeout
      else {
              #...
      }
  

  За более подробной информацией обратитесь к perlipc.

---

• map BLOCK LIST
• map EXPR,LIST

  Вычисляет BLOCK или EXPR для каждого элемента списка LIST (локально устанавливая $_ равной каждому элементу) и возвращает список, объединяющий результаты всех таких вычислений. В скалярном контексте возвращает общее число сгенерированных элементов. Функция вычисляет BLOCK или EXPR в списковом контексте, поэтому каждый элемент списка LIST может производить ноль, один или более элементов в возвращаемом значении.

      @chars = map(chr, @nums);
  

  транслирует список чисел в список соответствующих символов. Другой пример:

      %hash = map { get_a_key_for($_) => $_ } @array;
  

  является лишь своеобразным вариантом следующей записи:

      %hash = ();
      foreach (@array) {
          $hash{get_a_key_for($_)} = $_;
      }
  

  Заметим, что переменная $_ представляет собой псевдоним значения списка, поэтому ее можно использовать для модификации элементов LIST. Хотя это удобно и поддерживается, но может привести к странным результатам если элементы LIST не являются переменными. Использование обычного цикла foreach для этой цели может быть понятнее в большинстве случаев. См. также функцию grep -- возвращает массив, состоящий из тех элементов первоначального списка, для которых BLOCK или EXPR принимает значение "истина".

  Если в области видимости, над которой оперирует map , переменная $_ является лексической (так как была объявлена ключевым словом my ), то, помимо того, что $_ представляет собой локальный псевдонимом списка элементов, она продолжает быть лексической внутри блока. Это значит, что переменная $_ не видна снаружи, предотвращая любые возможные побочные эффекты.

  Интерпретатор perl рассматривает фигурную скобку {, идущую после map , как начало ссылки на хэш или как блок, т.е map{ ... может быть началом либо map BLOCK LIST , либо map EXPR, LIST . Поскольку Perl не смотрит закрывающую скобку }, он должен предположить, с чем он имеет дело на основании того, что он находит после {. Обычно он делает это правильно, но если он ошибся, то он этого не поймет, пока не доберется до } и не встретить недостающую(или неожидаемую) запятую. В этом случае, синтаксическая ошибку будет указана ближе к }, чтобы помочь интерпретатору Perl разобраться с ситуацией, измените что-либо около {, например добавьте унарный + .

      %hash = map {  "\L$_" => 1  } @array; # perl предполагает EXPR. неправильно
      %hash = map { +"\L$_" => 1  } @array; # perl предполагает BLOCK. правильно
      %hash = map { ("\L$_" => 1) } @array; # это тоже работает
      %hash = map {  lc($_) => 1  } @array; # как и это.
      %hash = map +( lc($_) => 1 ), @array; # это EXPR и это работает!
       
      %hash = map  ( lc($_), 1 ),   @array; # определяется как (1, @array)
  

  или используйте +{, чтобы принудительно задать конструкцию анонимного хэша:

     @hashes = map +{ lc($_) => 1 }, @array # EXPR, поэтому требуется запятая в конце
  

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

Функция преобразует время, возвращаемое time в список из девяти элементов, представляющих время, приведенное к местному часовому поясу. Обычно используется так:

#  0    1    2     3     4    5     6     7     8
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
                                            localtime(time);

Все элементы представляют собой числа и поступают прямо из struct tm. $sec, $min, и $hour содержат соответственно секунды, минуты и часы в указанном времени.

my @abbr = qw( Январь Февраль Март Апрель Май Июнь Июль Август Сентябрь Октябрь Ноябрь Декабрь );
print "$abbr[$mon] $mday";
# при значениях $mon=9, $mday=18 на выводе "Октябрь 18"

$year - количество лет после 1900 года, а не просто последние две цифры года. Например, в 2023 году $year будет содержать значение 123 . Таким образом, получить 4-значный год можно следующим образом:

$year += 1900;

В противном случае, вы создаете Y2K-несовместимые программы, но вы не хотите делать этого, не так ли ?

Чтобы получить двухзначный год (например, '01' в 2001 году), используйте следующее:

$year = sprintf("%02d", $year % 100);

$wday - день недели, при этом воскресенье имеет номер 0, а среда - номер 3. $yday является днем в году, содержит значения в диапазоне 0..364 (или 0..365 в високосные годы.)

Если указанное время попадает в период летнего времени, $isdst содержит истинное значение, иначе - ложное.

Если EXPR опущено, localtime() использует текущее время (возвращаемое системной функцией time(3)).

$now_string = localtime;  # например, "Thu Oct 13 04:54:34 1994"

Это скалярное значение не зависимо от локали, формат встроен в Perl. Для GMT вместо локального времени используется встроенная функция gmtime. См. также модуль Time::Local (для преобразования секунд, минут, часов, ... обратно в целочисленное значение, возвращаемое ф-ей time()), и функции strftime(3) и mktime(3) модуля POSIX.

use POSIX qw(strftime);
$now_string = strftime "%a %b %e %H:%M:%S %Y", localtime;
# или в формате GMT в соответствии с вашей локалью:
$now_string = strftime "%a %b %e %H:%M:%S %Y", gmtime;

Отметим, что %a и %b, краткие формы дня недели и месяца в году, не обязательно должны быть длиной в три символа.

См. "localtime" in perlport в интересах портативности.

Модули Time::gmtime и Time::localtime обеспечивают удобный механизм доступа по имени к функциям gmtime() и localtime() соответственно.

Для решения всеобъемлющих задач представления даты и времени обратите внимание на модуль DateTime на CPAN.

Функция open открывает файл, имя которой задается в EXPR, и связывает его с внутренним указателем FILEHANDLE.

Простой пример открытия файла для чтения:

open(my $fh, '<', "input.txt") or die $!;

и для записи:

open(my $fh, '>', "output.txt") or die $!;

Если FILEHANDLE является неопределенной скалярной переменной (а также массивом или элементом хэша), переменной присваивается ссылка на новый анонимный указатель файла. Иначе, если FILEHANDLE является выражением, его значение используется в качестве имени существующего файлового дескриптора. (Так как возвращаемое значение интерпретируется как символическая ссылка, необходимо, чтобы это выражение было вне области действия use strict 'refs'.)

Если не указан параметр EXPR, то ведется поиск скалярной переменной с тем же именем, что и FILEHANDLE. Эта переменная должна содержать имя файла и необязательный режим. (Заметим, что лексические переменные, объявленные оператором my, не будут работать для этих целей; поэтому, если вы используете my, укажите EXPR в вашем вызове open.)

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

Можно поместить символ '+' перед любым из символов '>' или '<' чтобы открыть файл одновременно для чтения и записи. Так как режим '+>' затирает содержимое файла прежде чем можно будет что-нибудь из него прочесть, то режим '+<' почти всегда предпочтительнее для чтения/обновления по записи. Можно рассматривать файл, открытый в режиме обновления, как базу данных с произвольным доступом и перемещаться к байту с заданным номером при помощи seek, но переменная длина записей в обычных текстовых файлах делает непрактичным использование режима чтения-записи для обновления таких файлов. Лучший подход к обновлению говорится в описании параметра командной строки i в спецификации perlrun. Файл создается с режимом доступа 0666, данный режим зависит от текущей umask процесса.

Все эти префиксы соответствуют режимам 'r', 'r+', 'w', 'w+', 'a', и 'a+' в функции fopen(3).

Если open вызывается с одним или двумя аргументами, то режим и имя файла должны быть объединены(в таком порядке), возможно разделенные пробелом. Если режим не указан, тогда предполагается режим для чтения '<'.

  open(my $fh, "<:encoding(UTF-8)", "filename")
  || die "Ошибка при открытии файла в кодировке UTF-8: $!";

открывает UTF-8 закодированный файл, см. perluniintro. Отметим, что если дисциплины указаны в трех-аргументной форме open, то по умолчанию дисциплины, содержащиеся в ${^OPEN}, игнорируются. (см. perlvar, обычно устанавливается прагмой open или c помощью ключей командной строки -CioD)

Функция open() возвращает ненулевое значение в случае успеха и неопределенное значение в противном случае.

Если Perl исполняется на системе, которая различает текстовые и двоичные(бинарные) файлы, то при открытии двоичного файла следует указать двоичный режим с помощью функции binmode. Основное отличие систем, в которых требуется binmode - в формате текстовых файлов. Системам подобным Unix, Mac OS, и Plan 9, функция binmode не требуется, потому что в файлах данных систем каждая строка завершается одним символом, соответствующим тому, что на языке Си определяется как перевод строки - "\n".

Сегодня рассматриваются особые операторы в Perl - "Операторы проверки файлов". Особые тем, что действуют как обычные унарные операторы, но при этом внутренне взаимодействуют с операционной системой. Они принимают один аргумент, являющийся именем файла или его дескриптором, и проверяют, обладает ли этот файл некоторым свойством. Так как данный тип операторов тесно связан с системными вызовами stat и файлами, он рассматривается в разделе Функции: Указатели файлов, файлы или директории

• -X FILEHANDLE
• -X EXPR
• -X DIRHANDLE
• -X

  Проверка файла, где X - один из перечисленных далее символов. Унарный оператор принимает один аргумент, это может быть имя файла, файловый дескриптор, либо дескриптор каталога, и проверяет соответствующий файл на соответствие условию. Ели аргумент не указан, проверяет $_, кроме работы с ключом -t, который использует STDIN. Если не оговорено иное, возвращает 1 для успешной проверки и '' для не успешной, либо неопределенное значение если файл не существует. Несмотря на забавные имена, приоритет у файловых проверок такой же как и у прочих именованных унарных операторов. Оператор может быть один из:

  -w # Файл доступен для записи текущему пользователю или группе (effective uid/gid)
  -x # Файл доступен для выполнения текущему пользователю или группе (effective uid/gid)
  -o # Файл принадлежит текущему пользователю (effective uid)
  
  -R # Файл доступен для чтения реальному пользователю или группе (real uid/gid)
  -W # Файл доступен для записи реальному пользователю или группе (real uid/gid)
  -X # Файл доступен для выполнения реальному пользователю или группе (real uid/gid)
  -O # Файл принадлежит реальному пользователю (real uid)
  
  -e # Файл существует
  -z # Файл имеет нулевой длины (пуст)
  -s # Файл имеет ненулевую длину ( возвращает размер в байтах )
  
  -f # Обычный файл.
  -d # Файл является каталогом.
  -l # Файл является символической ссылкой.
  -p # Файл либо файловый дескриптор являются именованным каналом (FIFO).
  -S # Файл является сокетом.
  -b # Блочный файл.
  -c # Символьный файл.
  -t # Дескриптор файла открыт в текущем терминале (tty).
  
  -u # Для файла установлен бит setuid
  -g # Для файла установлен бит setgid
  -k # Для файла установлен "липкий бит" (sticky bit)
  
  -T # Файл является текстовым в формате ASCII (эвристическая догадка).
  -B # Файл является "Двоичным"(бинарным) (в противоположность -T).
  
  -M # Время, прошедшее от последней модификации файла до запуска сценария, в днях.
  -A # Время, прошедшее от последнего обращения к файлу до запуска сценария, в днях.
  -C # Время, прошедшее от последнего изменения индексного дескриптора (inode) до запуска сценария
  

  Например:

  while (<>) {
  	chomp;
  	next unless -f $_;	# пропустить "особые" файлы
  	#...
  }
  

  Интерпретация операторов прав доступа (-r, -R, -w, -W, -x и -X) основывается исключительно на свойствах файла и пользовательском и групповом идентификаторах пользователя (uids, gids). Могут быть другие причины, по которым не удается читать, записывать или выполнять файл, например, управление доступом сетевых файловых систем, ACL (списки управления доступом), файловые системы только для чтения, и нераспознанные форматы исполняемого файла. Заметим, что использование вышеупомянутых шести операторов для тестирования файла, может привести к ошибке в случае, если в это время над файлом производятся какие либо операциии, что может вызвать зависание, состояние гонки и прочие неприятности.

  Также отметим, что для суперпользователя на локальной файловой системе, проверки -r, -R, -w, -W всегда возвращают 1, а -x и -X возвращают 1, если установлен хоть один бит исполнения. Поэтому в сценариях, выполняемых суперпользователем, может потребоваться выполнение stat(), чтобы определить действительный режим файла, либо временно установить другой идентификатор пользователя(анг. effective uid).

  Если используется ACL, полезна прагма filetest, которая обеспечивает более точные результаты чем stat(). При вызове use filetest 'access' вышеупомянутые операторы работают с использованием access(2) или аналогичных системных вызовов. Отметим также, что под действием этой прагмы операторы -x и -X могут возвращать истинное значение, даже если биты прав на выполнение не установлены ( или не выставлены какие либо дополнительные права ACL). Эта странность происходит в основе реализации низкоуровневых системных вызовов. Отметим также, что в связи с реализацией use filetest 'access', там, где распространяется её действие, специальный файловый дескриптор _ не будет кэшировать результаты выполнения операторов проверки файлов. За более подробной информацией обратитесь к документации прагмы filetest.

  Обратите внимание, что -s/a/b/ не производит подстановки с отрицанием. Однако -exp($foo) работает, как должно: только одиночные буквы после минуса трактуются как проверка файла.

  Ключи -T и -B работают следующим образом. Участок файла примерно в объеме первого блока исследуется на наличие необычных символов, таких как коды управления или байты с установленным старшим битом (не похожие на UTF-8). Если необычных символов слишком много (больше 30%), то файл считается двоичным(<-B>), иначе это текстовый(-T) файл. Также, любой файл считается двоичным, если он содержит в первом блоке нулевой байт ( символ ASCII NUL(\0) ). Если -T или -B применяется к дескриптору файла, то исследуется не первый блок файла, а текущий буфер ввода ( стандартный I/O или "stdio"). Оба оператора -T и -B возвращают истину для пустого файла, или файла, указатель которого находится в EOF|wiki - конце файла, если проверяется дескриптор. Поскольку нужно прочесть файл, чтобы выполнить проверку -T, в большинстве случаев лучше сначала сделать проверку с ключом -f, например next unless -f $file && -T $file.

  Если какому-либо из проверок файлов (или операторам stat или lstat операторам) передается специальный дескриптор файла, состоящий из "_" - одного символа подчеркивания, то используется структура stat предыдущей проверки файла (или оператора stat), что позволяет избежать нового системного вызова. (Это не работает для оператора -t, и нужно помнить, что lstat и -l сохраняют значения в структуре stat, относящиеся к символической ссылке, а не к реальному файлу. ) (Аналогично, если stat буфер был заполнен вызовом lstat, -T и -B сбросят его с результатом stat _). Например:

  stat($filename);
  print "Доступен для чтения \n" if -r _;
  print "Доступен для записи \n" if -w _;
  print "Исполняемый \n" if -x _;
  print "Установлен бит setuid\n" if -u _;
  print "Установлен бит setgid\n" if -g _;
  print "Установлен 'липкий бит'\n" if -k _;
  print "Текстовый\n" if -T _;
  print "Бинарный\n" if -B _;
  

  Начиная с версии Perl 5.9.1, как форма синтаксического сахара может использоваться стек операторов тестирования файла. Таким образом, -f -w -x $file эквивалентно -x $file && -w _ && -f _. ( Но если использовать возвращаемое значение -f $file в качестве аргумента для другого оператора, никакой особой магии не произойдет.

При переводе данной документации использовались следующие источники:

Сегодня рассматриваются богатые возможности и нюансы в использовании perl функции split для расщепления строк.

• split /PATTERN/,EXPR,LIMIT
• split /PATTERN/,EXPR
• split /PATTERN/
• split

  Функция split расщепляет строку EXPR на список подстрок и возвращает полученный список. По умолчанию, ведущие пустые поля сохраняются, а замыкающие удаляются.

  В скалярном контексте, возвращается число найденных полей.

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

  Если число LIMIT задано и больше нуля, оно представляет собой максимальное число полей EXPR, на которые строка расщепляется, хотя фактическое число возвращаемых полей зависит от кол-ва найденных PATTERN в рамках EXPR. Если LIMIT не указан или равен нулю, замыкающие нулевые поля удаляются (о чем не мешало бы помнить тем, кто будет использовать функцию pop). Если LIMIT отрицательно, то считается, что была задана произвольно большая граница LIMIT.

  Шаблон, который может находить соответствие пустой строке (не путать с нулевым шаблоном //) или чему-то более длинному, чем нулевая строка, расщепляет значение EXPR на отдельные символы. Например:

      print join(':', split(/ */, 'hi there')), "\n";
  

  дает результат "h:i:t:h:e:r:e".

  Как особый случай для split, пустой шаблон // просто расщепляет строку на отдельные символы; не путать с обычным поиском по шаблону //, который повторяет поиск по последнему успешно найденному шаблону.

      print join(':', split(//, 'hi there')), "\n";
  

  выводит 'h:i: :t:h:e:r:e'.

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

     print join(':', split(/(?=\w)/, 'hi there!'));
  

  производит на выводе 'h:i :t:h:e:r:e!'. Пустые замыкающие поля с другой стороны, производятся при наличии соответствий в конце строки (и когда LIMIT указан и не равено нулю), независимо от длины сопоставления. Например.

     print join(':', split(//,   'hi there!', -1)), "\n";
     print join(':', split(/\W/, 'hi there!', -1)), "\n";
  

  производит на выходе 'h:i: :t:h:e:r:e:!:' и 'hi:there:', соответственно, оба с пустым замыкающим полем.

  Задание параметра LIMIT влечет расщепление только части строки.

      ($login, $passwd, $remainder) = split(/:/, $_, 3);
  

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

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

      split(/([,-])/, "1-10,20", 3);
  

  производит список значений

      (1, '-', 10, ',', 20)
  

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

      $header =~ s/\n(?=\s)//g;  # слить строки 
      %hdrs   =  (UNIX_FROM => split /^(\S*?):\s*/m, $header);
  

  Шаблон /PATTERN/ может быть замещен выражением, определяющим шаблон, который изменяется во время процесса расщепления строк. (Для разовой компиляции во время выполнения используется соответствующий модификатор, /$variable/o.)

  Особым случаем является задание в PATTERN одного пробела (' '), в этом случае расщепление производится по пробельным символам, как если бы split использовался без аргументов. Таким образом, с помощью split(' ') можно эмулировать режим работы awk по умолчанию, тогда как split(/ /) даст столько нулевых полей в начале (пустых строк), сколько имеется ведущих пробелов. split с выражением /\s+/ подобен split(' ') за исключением того, что ведущие пробелы производятся в нулевое первое поле. split без аргументов внутренне интерпретируется как split(' ', $_).

  PATTERN /^/ трактуется как /^/m, поскольку иначе выражение не имеет смысла.

  Пример использования функции split - обработка записей файла passwd(5) Unix.:

      open(PASSWD, '/etc/passwd');
      while (<PASSWD>) {
          chomp;
          ($login, $passwd, $uid, $gid,
           $gcos, $home, $shell) = split(/:/);
          #...
      }
  

  Как и в случае с регулярными выражениями, если даже каким-то парам скобок в PATTERN не найдено соответствия, возвращаются неопределенные значения undef.

      @fields = split /(A)|B/, "1A2B3";
      # @fields содержит (1, 'A', 2, undef, 3)