perlmod - Интернет в облаке

ПРОГРАММА:

ИМЯ

perlmod - модули Perl (пакеты и таблицы символов)

ОПИСАНИЕ

Is этой документ были после?
Существуют и другие документы, которые могут содержать искомую информацию:

Этот документ
Пакеты Perl, пространства имен и некоторая информация о классах.

Perlnewmod
Учебник по созданию нового модуля.

Perlmodstyle
Рекомендации по созданию нового модуля.

Packages
Perl предоставляет механизм для альтернативных пространств имен, чтобы защитить пакеты от вторжения.
переменные друг друга. Фактически, в действительности нет такой вещи, как глобальная переменная.
Perl. Оператор пакета объявляет, что единица компиляции находится в заданном
пространство имен. Объем объявления пакета - от самого объявления до
конец охватывающего блока, eval или файла, в зависимости от того, что наступит раньше (та же область, что и
мой() и местный() операторы). Неквалифицированные динамические идентификаторы будут в этом
пространство имен, за исключением тех немногих идентификаторов, которые, если они не определены, по умолчанию используются в основном
пакет вместо текущего, как описано ниже. Заявление о пакете влияет только на
динамические переменные - в том числе те, которые вы использовали местный() на - но лексические переменные
Создано с мой(). Обычно это первое объявление в файле, включенном
операторы do, require или use. Вы можете переключиться на пакет более чем в одном
место; он просто влияет на то, какая таблица символов используется компилятором для остальной части
этот блок. Вы можете ссылаться на переменные и дескрипторы файлов в других пакетах, добавив префикс
идентификатор с именем пакета и двойным двоеточием: $ Package :: Variable. Если пакет
name имеет значение null, предполагается "основной" пакет. То есть $ :: sail эквивалентно
$ main :: sail.

Старым разделителем пакетов была одинарная кавычка, но теперь предпочтительнее использовать двойное двоеточие.
разделитель, отчасти потому, что он более читабелен для людей, а отчасти потому, что он более
читаемый Emacs макросы. Это также заставляет программистов на C ++ чувствовать, что они знают, что происходит.
on - в отличие от использования одинарной кавычки в качестве разделителя, которая должна была сделать Ada
программисты чувствуют, что знают, что происходит. Поскольку старомодный синтаксис
по-прежнему поддерживается для обратной совместимости, если вы попытаетесь использовать строку типа «Это
$ owner's house ", вы получите доступ к $ owner :: s, то есть к переменной $ s в пакете
"владелец", что, вероятно, не то, что вы имели в виду. Используйте фигурные скобки для устранения неоднозначности, например, "Это
Дом $ {владельца} ".

Пакеты могут сами содержать разделители пакетов, как в $ OUTER :: INNER :: var. Этот
однако ничего не говорит о порядке поиска имени. Родственных пакетов нет:
все символы либо локальны для текущего пакета, либо должны быть полностью определены из
имя внешнего пакета вниз. Например, в пакете "OUTER" нет ничего, что
$ INNER :: var относится к $ OUTER :: INNER :: var. «ВНУТРЕННИЙ» относится к совершенно отдельному глобальному
пакет.

В символе пакета хранятся только идентификаторы, начинающиеся с букв (или подчеркивания).
стол. Все остальные символы хранятся в пакете main, включая все переменные пунктуации,
как $ _. Кроме того, если не указано иное, идентификаторы STDIN, STDOUT, STDERR, ARGV,
ARGVOUT, ENV, INC и SIG принудительно должны находиться в пакете main, даже когда они используются для других
целей, чем их встроенные. Если у вас есть пакет с именем «m», «s» или «y», тогда
вы не можете использовать квалифицированную форму идентификатора, потому что вместо этого он будет интерпретироваться
как сопоставление с шаблоном, подстановка или транслитерация.

Раньше переменные, начинающиеся с подчеркивания, принудительно помещались в основной пакет, но мы решили это
было более полезно для разработчиков пакетов использовать ведущее подчеркивание для обозначения
частные переменные и имена методов. Однако переменные и функции, названные одним
«_», такие как $ _ и «sub _», по-прежнему принудительно помещаются в пакет «main». См. Также «
Синтаксис имен переменных »в perlvar.

Строки "eval" компилируются в пакете, в котором eval () был составлен.
(Назначение $ SIG {}, однако, предполагает, что указанный обработчик сигнала находится в "главном"
упаковка. Укажите имя обработчика сигнала, если вы хотите иметь обработчик сигнала в
пакет.) Для примера рассмотрим perldb.pl в библиотеке Perl. Первоначально он переключает
в пакет "БД", чтобы отладчик не мешал переменным в программе
вы пытаетесь отлаживать. Однако в различные моменты он временно переключается обратно на
"основной" пакет для оценки различных выражений в контексте "основного" пакета (или
откуда бы вы ни приехали). Смотрите perldebug.

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

См. Perlsub, чтобы узнать о других проблемах, связанных с мой() и местный(), и perlref относительно
затворы.

Символ таблицы
Таблица символов для пакета хранится в хэше этого имени с двумя
добавлены двоеточия. Таким образом, имя основной таблицы символов -% main :: или% :: для краткости.
Точно так же таблица символов для вложенного пакета, упомянутого ранее, называется
% ВНЕШНИЙ :: ВНУТРЕННИЙ ::.

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

локальный * main :: foo = * main :: bar;

Вы можете использовать это, например, для распечатки всех переменных в пакете. Стандарт
но устаревший дампвар.pl библиотека и модуль CPAN Devel :: Symdump используют это.

Результаты прямого создания новых записей таблицы символов или изменения любых записей, которые
еще не являются typeglobs неопределенными и могут изменяться между выпусками perl.

Присваивание typeglob выполняет операцию псевдонима, т. Е.

* член = * Ричард;

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

* член = \ $ ричард;

Это делает $ richard и $ dick одной и той же переменной, но оставляет @richard и @dick как
отдельные массивы. Сложно, а?

Между следующими утверждениями есть одно тонкое различие:

* foo = * bar;
* foo = \ $ bar;

"* foo = * bar" делает сами typeglobs синонимами, а "* foo = \ $ bar" делает
СКАЛЯРНЫЕ части двух разных типов глобусов относятся к одному и тому же скалярному значению. Это означает, что
следующий код:

$ bar = 1;
* foo = \ $ bar; # Сделать $ foo псевдонимом для $ bar

{
локальный $ bar = 2; # Ограничить изменения до блокировки
print $ foo; # Печатает "1"!
}

Напечатал бы '1', потому что $ foo содержит ссылку на оригинал $ bar. Тот, что был
заполнены "local ()" и будут восстановлены, когда блок закончится. Потому что
доступ к переменным осуществляется через typeglob, вы можете использовать "* foo = * bar" для создания псевдонима
который можно локализовать. (Но имейте в виду, что это означает, что у вас не может быть отдельных @foo и
@bar и т. д.)

Что делает все это важным, так это то, что модуль Exporter использует глобальные псевдонимы в качестве
механизм импорта / экспорта. Сможете ли вы правильно локализовать переменную, которая была
экспортировано из модуля, зависит от того, как он был экспортирован:

@EXPORT = qw ($ FOO); # Обычная форма, локализовать нельзя
@EXPORT = qw (* FOO); # Может быть локализован

Первый случай можно обойти, используя полное имя ($ Package :: FOO), где
вам нужно локальное значение, или переопределив его, сказав "* FOO = * Package :: FOO" в вашем
скрипты.

Механизм «* x = \ $ y» может использоваться для передачи и возврата дешевых ссылок в или из
подпрограммы, если вы не хотите копировать все это целиком. Работает только при назначении
динамические переменные, а не лексические.

% some_hash = (); # не может быть моим ()
* some_hash = fn (\% another_hash);
суб фн {
локальный * hashsym = shift;
# теперь используйте% hashsym как обычно, а вы
# повлияет на% another_hash вызывающего
мой% nhash = (); # делай что хочешь
вернуть \% nhash;
}

По возвращении ссылка перезапишет хэш-слот в таблице символов, заданной параметром
* some_hash typeglob. Это довольно хитрый способ дешевой передачи ссылок.
когда вы не хотите помнить о явном разыменовании переменных.

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

* PI = \ 3.14159265358979;

Теперь вы не можете изменить $ PI, что, вероятно, в целом хорошо. Это не то же самое
как постоянная подпрограмма, которая подлежит оптимизации во время компиляции. Постоянная
подпрограмма - это прототип, который не принимает аргументов и возвращает постоянное выражение.
См. Подробности в perlsub. Прагма "использовать константу" - это удобное сокращение для
эти.

Вы можете сказать * foo {PACKAGE} и * foo {NAME}, чтобы узнать, какое имя и упаковать символ * foo.
запись в таблице происходит из. Это может быть полезно в подпрограмме, которая получает переданные typeglobs как
аргументы:

субident_typeglob {
мой $ glob = shift;
напечатайте 'Вы дали мне', * {$ glob} {PACKAGE},
'::', * {$ glob} {ИМЯ}, "\ n";
}
Identify_typeglob * foo;
identify_typeglob * bar :: baz;

Это печатает

Вы дали мне main :: foo
Ты дал мне бар :: baz

Обозначение * foo {THING} также может использоваться для получения ссылок на отдельные элементы.
из * foo. См. Perlref.

Определения подпрограмм (и объявления, если на то пошло) не обязательно должны быть
находятся в пакете, таблицу символов которого они занимают. Вы можете определить подпрограмму
вне своего пакета, явно указав имя подпрограммы:

основной пакет;
sub Some_package :: foo {...} # & foo определено в Some_package

Это просто сокращение для присвоения typeglob во время компиляции:

НАЧАТЬ {* Some_package :: foo = sub {...}}

и то же самое, что и писать:

{
пакет Some_package;
sub foo {...}
}

В первых двух версиях тело подпрограммы лексически находится в основном пакете,
в Some_package. Так что-то вроде этого:

основной пакет;

$ Some_package :: name = "Фред";
$ main :: name = "barney";

sub Some_package :: foo {
напечатайте "in", __PACKAGE__, ": \ $ name is '$ name' \ n";
}

Some_package :: foo ();

печатает:

в основном: $ name is 'barney'

скорее, чем:

в Some_package: $ name is 'fred'

Это также имеет значение для использования квалификатора SUPER :: (см. Perlobj).

НАЧИНАТЬ, УНИЧЕК, ПРОВЕРИТЬ, INIT и END
Пять специально названных блоков кода выполняются в начале и в конце рабочего цикла.
Программа на Perl. Это блоки «BEGIN», «UNITCHECK», «CHECK», «INIT» и «END».

Эти блоки кода могут иметь префикс "sub", чтобы создать вид подпрограммы.
(хотя это не считается хорошим стилем). Следует отметить, что эти блоки кода
на самом деле не существуют как именованные подпрограммы (несмотря на их внешний вид). То, что дает
это тот факт, что вы можете иметь больше чем one этих блоков кода в программе,
и они получат ВСЕ исполняется в подходящий момент. Таким образом, вы не можете выполнить ни одно из
эти блоки кода по имени.

Блок кода «НАЧАТЬ» выполняется как можно скорее, то есть в тот момент, когда он полностью
определяется даже до того, как будет проанализирована остальная часть содержащего файла (или строки). Ты можешь иметь
несколько блоков "BEGIN" в файле (или в строке с оценкой); они будут выполнять в порядке
определение. Поскольку блок кода "BEGIN" выполняется немедленно, он может извлекать определения
подпрограмм и тому подобного из других файлов, чтобы они были видны остальной части компиляции
и время выполнения. Как только "BEGIN" запущен, он сразу же становится неопределенным, и любой используемый им код становится
вернулся в пул памяти Perl.

Блок кода «КОНЕЦ» выполняется как можно позже, то есть после завершения работы perl.
запускает программу и непосредственно перед выходом из интерпретатора, даже если он выходит
В результате умереть () функция. (Но не в том случае, если он трансформируется в другую программу через
"exec", или быть выброшенным из воды сигналом - вы должны поймать это самостоятельно (если
вы можете).) У вас может быть несколько блоков "END" в файле - они будут выполняться в обратном порядке
порядок определения; то есть: последний пришел, первый ушел (LIFO). Блоки "КОНЕЦ" не выполняются
когда вы запускаете perl с ключом "-c" или если компиляция не удалась.

Обратите внимание, что блоки кода «КОНЕЦ» выполняется в конце строки «eval ()»: если есть «КОНЕЦ»
блоки кода создаются в строке "eval ()", они будут выполняться так же, как и любые другие
"КОНЕЦ" блока кода этого пакета в порядке LIFO непосредственно перед интерпретатором
вышел.

Внутри блока кода «КОНЕЦ» $? содержит значение, которое программа собирается передать
"выход()". Вы можете изменить $? для изменения значения выхода из программы. Остерегайтесь изменений
$? случайно (например, запустив что-то через "систему").

Внутри блока «END» значение «$ {^ GLOBAL_PHASE}» будет «END».

Блоки кода «UNITCHECK», «CHECK» и «INIT» полезны для обнаружения перехода между
фаза компиляции и фаза выполнения основной программы.

Блоки «UNITCHECK» запускаются сразу после того, как модуль, который их определил, был скомпилирован. В
основной файл программы и каждый загружаемый модуль являются единицами компиляции, как и строка eval,
код времени выполнения, скомпилированный с использованием конструкции "(? ​​{})" в регулярном выражении, вызывает "do FILE",
"требуется ФАЙЛ" и код после переключателя "-e" в командной строке.

Блоки «BEGIN» и «UNITCHECK» не имеют прямого отношения к фазе интерпретатора.
Их можно создавать и выполнять на любом этапе.

Блоки кода "CHECK" запускаются сразу после начальный Фаза компиляции Perl заканчивается и до
время выполнения начинается в порядке LIFO. Блоки кода "CHECK" используются в наборе компиляторов Perl.
для сохранения скомпилированного состояния программы.

Внутри блока «CHECK» значение «$ {^ GLOBAL_PHASE}» будет «CHECK».

Блоки «INIT» запускаются непосредственно перед началом выполнения среды выполнения Perl, в режиме «первым пришел, первым»
out »(FIFO) заказ.

Внутри блока «INIT» значение «$ {^ GLOBAL_PHASE}» будет «INIT».

Блоки «CHECK» и «INIT» в коде, скомпилированном с помощью «require», string «do» или строки «eval»
не будут выполняться, если они возникнут после окончания основной фазы компиляции; это может
быть проблемой в mod_perl и других постоянных средах, которые используют эти функции для
загрузить код во время выполнения.

Когда вы используете -n и -p переключается на Perl, "BEGIN" и "END" работают так же, как и в
AWK, как вырожденный случай. Оба блока "BEGIN" и "CHECK" запускаются, когда вы используете -c
переключатель для проверки синтаксиса только для компиляции, хотя ваш основной код - нет.

The начать проверку программа все проясняет, в конце концов:

#!/ usr / bin / perl

# начать проверку

print "10. Обычный код выполняется во время выполнения. \ n";

END {print "16. Итак, это конец сказки. \ N"}
INIT {print "7. Блоки INIT запускают FIFO непосредственно перед выполнением. \ N"}
БЕЗ ПРОВЕРКИ {
print "4. И, следовательно, перед любыми блоками CHECK. \ n"
}
ПРОВЕРЬТЕ {print "6. Итак, это шестая строка. \ N"}

print "11. Конечно, все работает по порядку. \ n";

BEGIN {print "1. Блоки BEGIN запускают FIFO во время компиляции. \ N"}
END {print "15. Прочтите perlmod до конца истории. \ N"}
CHECK {print "5. Блоки CHECK запускают LIFO после всей компиляции. \ N"}
INIT {print "8. Запустите это снова, используя переключатель Perl -c. \ N"}

print "12. Это антиобфусцированный код. \ n";

END {print "14. Блоки END запускают LIFO во время выхода. \ N"}
BEGIN {print "2. Итак, эта строка выходит второй. \ N"}
БЕЗ ПРОВЕРКИ {
print "3. Блоки UNITCHECK запускают LIFO после компиляции каждого файла. \ n"
}
INIT {print "9. Вы сразу заметите разницу. \ N"}

print "13. Это только _выглядывает_, как будто это должно сбивать с толку. \ n";

__КОНЕЦ__

Perl Классы
В Perl нет специального синтаксиса классов, но пакет может действовать как класс, если он предоставляет
подпрограммы, которые действуют как методы. Такой пакет может также унаследовать некоторые из своих методов от
другой класс (пакет), указав другие имена пакетов в глобальном массиве @ISA
(который должен быть глобальным пакетом, а не лексическим).

Подробнее об этом см. Perlootut и perlobj.

Perl Модули
Модуль - это просто набор связанных функций в файле библиотеки, т. Е. Пакет Perl с
то же имя, что и у файла. Он специально разработан для повторного использования другими модулями или
программы. Он может сделать это, предоставив механизм для экспорта некоторых своих символов в
таблица символов любого пакета, использующего ее, или она может функционировать как определение класса и
сделать свою семантику доступной неявно через вызовы методов класса и его объектов,
без явного экспорта чего-либо. Или это может сделать и то, и другое.

Например, чтобы запустить традиционный, не объектно-ориентированный модуль Some :: Module, создайте файл
которые называются Некоторые / Module.pm и начнем с этого шаблона:

пакет Some :: Module; # предполагает Some / Module.pm

использовать строго;
использовать предупреждения;

НАЧАТЬ {
требуется экспортер;

# установить версию для проверки версии
наша ВЕРСИЯ $ = 1.00;

# Наследовать от Exporter для экспорта функций и переменных
наш @ISA = qw (Экспортер);

# Функции и переменные, которые экспортируются по умолчанию
наш @EXPORT = qw (func1 func2);

# Функции и переменные, которые можно дополнительно экспортировать
наш @EXPORT_OK = qw ($ Var1% Hashit func3);
}

# глобальные экспортируемые пакеты перейдите сюда
наш $ Var1 = '';
наш% Hashit = ();

# глобальные неэкспортированные пакеты перейдите сюда
# (они все еще доступны как $ Some :: Module :: stuff)
наш @more = ();
наш $ stuff = '';

# файловые частные лексики идут сюда перед любыми функциями, которые их используют
мой $ priv_var = '';
мой% secret_hash = ();

# вот закрывающая функция file-private,
# вызывается как $ priv_func -> ();
my $ priv_func = sub {
...
};

# сделать все ваши функции, независимо от того, экспортированы они или нет;
# не забудьте добавить что-нибудь интересное в {} заглушки
sub func1 {...}
sub func2 {...}

# этот не экспортируется, но может вызываться напрямую
# как Some :: Module :: func3 ()
sub func3 {...}

END {...} # здесь код очистки модуля (глобальный деструктор)

1; # не забудьте вернуть истинное значение из файла

Затем переходите к объявлению и использованию ваших переменных в функциях без каких-либо оговорок. Видеть
Экспортер и perlmodlib для получения подробной информации о механике и стилях при создании модуля.

Модули Perl включаются в вашу программу, говоря

использовать модуль;

or

использовать список модулей;

Это в точности эквивалентно

BEGIN {требуется 'Module.pm'; 'Модуль' -> импорт; }

or

BEGIN {требуется 'Module.pm'; 'Модуль' -> импорт (СПИСОК); }

Как частный случай

используйте Module ();

в точности эквивалентен

BEGIN {требуется 'Module.pm'; }

Все файлы модулей Perl имеют расширение .вечера. Оператор use предполагает это, поэтому вы
не нужно объяснять "Модуль.pm"в кавычках. Это также помогает различать новые
модули из старых .pl и .ph файлы. Имена модулей также пишутся с заглавной буквы, если они не
функционирование как прагмы; прагмы в действительности являются директивами компилятора, а иногда
так называемые «прагматические модули» (или даже «прагматы», если вы классицист).

Два заявления:

требуется SomeModule;
требуется "SomeModule.pm";

отличаются друг от друга двумя способами. В первом случае любые двойные двоеточия в модуле
имя, такое как "Some :: Module", переводится в разделитель каталогов вашей системы,
как правило "/". Во втором случае нет, и его следует указывать буквально. В
Другое отличие состоит в том, что первые подсказки "require" в компиляторе, использующем
нотация косвенных объектов, включающая "SomeModule", например "$ ob = purge SomeModule", является
вызовы методов, а не вызовы функций. (Да, это действительно может иметь значение.)

Поскольку оператор "use" подразумевает блок "BEGIN", импорт семантики происходит как
как только будет скомпилирован оператор "use", до того, как будет скомпилирована остальная часть файла. Это
как он может функционировать как механизм прагмы, а также как модули могут объявлять
подпрограммы, которые затем отображаются в виде списка или унарных операторов для остальной части текущего
файл. Это не сработает, если вы используете "require" вместо "use". С помощью "require" вы можете
попасть в эту проблему:

требуется Cwd; # сделать Cwd :: доступным
$ здесь = Cwd :: getcwd ();

используйте Cwd; # импортировать имена из Cwd ::
$ здесь = getcwd ();

требуется Cwd; # сделать Cwd :: доступным
$ здесь = getcwd (); # ой! нет main :: getcwd ()

В общем, использование "использовать Module ()" рекомендуется вместо "require Module", поскольку оно определяет
доступность модуля во время компиляции, а не в середине выполнения вашей программы. An
исключение было бы, если бы два модуля каждый пытались "использовать" друг друга, и каждый также вызвал бы
функция из этого другого модуля. В этом случае вместо этого легко использовать "require".

Пакеты Perl могут быть вложены в другие имена пакетов, поэтому мы можем иметь имена пакетов
содержащий "::". Но если бы мы использовали это имя пакета непосредственно как имя файла, это сделало бы
для громоздких или невозможных имен файлов в некоторых системах. Следовательно, если имя модуля,
скажем "Text :: Soundex", тогда его определение действительно находится в файле библиотеки.
Текст / Soundex.pm.

В модулях Perl всегда есть .вечера файл, но также могут быть динамически связанные исполняемые файлы
(часто оканчивается на .так) или автоматически загружаемых определений подпрограмм (часто заканчивающихся на .al)
связанный с модулем. Если это так, они будут полностью прозрачны для пользователя
модуль. Это ответственность .вечера файл, чтобы загрузить (или настроить автозагрузку) любой
дополнительный функционал. Например, хотя модуль POSIX выполняет оба
динамическая загрузка и автозагрузка, пользователь может просто сказать «используйте POSIX», чтобы получить все это.

Создание модуль потокобезопасный
Perl поддерживает тип потоков, называемых потоками интерпретатора (ithreads). Эти темы могут
использоваться явно и неявно.

Ithreads работают путем клонирования дерева данных, так что никакие данные не распределяются между разными
потоки. Эти потоки можно использовать с помощью модуля «потоки» или путем выполнения вилка () on
win32 (подделка вилка () служба поддержки). Когда поток клонируется, клонируются все данные Perl, но не
Данные Perl нельзя клонировать автоматически. Perl после 5.8.0 поддерживает "КЛОНА"
специальная подпрограмма. В «КЛОНЕ» вы можете делать все, что вам нужно, например,
при необходимости обработайте клонирование данных, отличных от Perl. "CLONE" будет называться один раз как класс
для каждого пакета, в котором он определен (или наследует его). Он будет называться в
контекст нового потока, поэтому все изменения вносятся в новую область. В настоящее время CLONE
вызывается без параметров, кроме имени вызывающего пакета, но код не должен
предполагаем, что это останется неизменным, так как вполне вероятно, что в будущем дополнительные параметры
будут переданы, чтобы предоставить дополнительную информацию о состоянии клонирования.

Если вы хотите КЛОНИРОВАТЬ все объекты, вам нужно будет отслеживать их для каждого пакета. Это
просто делается с помощью хеша и Scalar :: Util :: weaken ().

Perl после версии 5.8.7 поддерживает специальную подпрограмму "CLONE_SKIP". Как "КЛОН",
CLONE_SKIP вызывается один раз для каждого пакета; однако он вызывается непосредственно перед началом клонирования,
и в контексте родительского потока. Если он возвращает истинное значение, то никакие объекты
этот класс будет клонирован; или, скорее, они будут скопированы как unblessed, undef значения. Для
пример: если в родительском есть две ссылки на один благословенный хеш, то в
child вместо этого будут две ссылки на одно неопределенное скалярное значение. Этот
предоставляет простой механизм для создания потокобезопасного модуля; просто добавьте "sub CLONE_SKIP {1
} "в верхней части класса, а" DESTROY () "теперь будет вызываться только один раз для каждого объекта.
конечно, если дочерний поток должен использовать объекты, то более сложный
подход нужен.

Как и «CLONE», «CLONE_SKIP» в настоящее время вызывается без параметров, кроме вызывающего.
имя пакета, хотя оно может измениться. Точно так же, чтобы учесть будущее расширение,
возвращаемое значение должно быть единственным значением 0 или 1.

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