perlmod - En ligne dans le Cloud

PROGRAMME:

Nom

perlmod - modules Perl (packages et tables de symboles)

DESCRIPTION

Is ceci. le document you ont été après?
Il existe d'autres documents qui peuvent contenir les informations que vous recherchez :

Ce document
Les packages Perl, les espaces de noms et quelques informations sur les classes.

perlnouveaumod
Tutoriel sur la création d'un nouveau module.

style perlmod
Meilleures pratiques pour créer un nouveau module.

Formules
Perl fournit un mécanisme pour les espaces de noms alternatifs pour protéger les paquets contre le piétinement
les variables les unes des autres. En fait, il n'y a vraiment pas de variable globale dans
Perl. L'instruction package déclare l'unité de compilation comme étant dans le donné
espace de noms. La portée de la déclaration de package va de la déclaration elle-même à
la fin du bloc englobant, "eval", ou du fichier, selon la première éventualité (la même portée que
le ma() et locale() les opérateurs). Les identifiants dynamiques non qualifiés seront dans ce
espace de noms, à l'exception de ces quelques identifiants qui, s'ils ne sont pas qualifiés, sont par défaut le principal
package au lieu de l'actuel comme décrit ci-dessous. Une instruction de package n'affecte que
variables dynamiques, y compris celles que vous avez utilisées locale() sur--mais pas variables lexicales
Créé avec ma(). Il s'agirait généralement de la première déclaration dans un fichier inclus par le
opérateurs "do", "require" ou "use". Vous pouvez passer à un forfait dans plusieurs
endroit; il influence simplement quelle table de symboles est utilisée par le compilateur pour le reste de
ce bloc. Vous pouvez faire référence aux variables et aux descripteurs de fichiers dans d'autres packages en préfixant le
identifiant avec le nom du package et un double deux-points : $Package::Variable. Si le paquet
name est null, le package "principal" est supposé. C'est-à-dire que $::sail équivaut à
$main::voile.

L'ancien délimiteur de package était un guillemet simple, mais le double deux-points est maintenant le préféré
délimiteur, en partie parce qu'il est plus lisible pour les humains, et en partie parce qu'il est plus
lisible à emacs macro. Cela donne également aux programmeurs C++ l'impression qu'ils savent ce qui se passe
on--par opposition à l'utilisation du guillemet simple comme séparateur, qui était là pour faire Ada
les programmeurs ont l'impression de savoir ce qui se passe. Parce que la syntaxe à l'ancienne est
toujours pris en charge pour la compatibilité descendante, si vous essayez d'utiliser une chaîne comme "Ceci est
$owner's house", vous accéderez à $owner ::s, c'est-à-dire à la variable $s dans package
"propriétaire", ce qui n'est probablement pas ce que vous vouliez dire. Utilisez des accolades pour lever l'ambiguïté, comme dans "Ceci est
la maison de ${owner}".

Les packages peuvent eux-mêmes contenir des séparateurs de packages, comme dans $OUTER::INNER::var. Cette
n'implique cependant rien sur l'ordre des recherches de nom. Il n'y a pas de packages relatifs :
tous les symboles sont soit locaux au package actuel, soit doivent être entièrement qualifiés à partir du
nom du package externe vers le bas. Par exemple, il n'y a nulle part dans le package "OUTER" qui
$INNER::var fait référence à $OUTER::INNER::var. « INTÉRIEUR » fait référence à un ensemble global totalement séparé
paquet.

Seuls les identifiants commençant par des lettres (ou souligné) sont stockés dans le symbole d'un package
table. Tous les autres symboles sont conservés dans le package "main", y compris toutes les variables de ponctuation,
comme $_. De plus, lorsqu'ils sont non qualifiés, les identifiants STDIN, STDOUT, STDERR, ARGV,
ARGVOUT, ENV, INC et SIG sont forcés d'être dans le package "main", même lorsqu'ils sont utilisés pour d'autres
fins que leurs fonctions intégrées. Si vous avez un package appelé "m", "s" ou "y", alors
vous ne pouvez pas utiliser la forme qualifiée d'un identifiant car il serait plutôt interprété
comme une correspondance de modèle, une substitution ou une translittération.

Auparavant, les variables commençant par un trait de soulignement étaient forcées dans le package main, mais nous l'avons décidé
était plus utile pour les rédacteurs de packages de pouvoir utiliser un trait de soulignement de début pour indiquer
variables privées et noms de méthode. Cependant, les variables et les fonctions nommées avec un seul
"_", comme $_ et "sub _", sont toujours forcés dans le package "main". Voir aussi "Le
Syntaxe des noms de variables" dans perlvar.

Les chaînes "évaluées" sont compilées dans le package dans lequel le eval () a été compilé.
(Les affectations à $SIG{}, cependant, supposent que le gestionnaire de signal spécifié est dans le "main"
emballer. Qualifiez le nom du gestionnaire de signal si vous souhaitez avoir un gestionnaire de signal dans un
package.) Pour un exemple, examinez perldb.pl dans la bibliothèque Perl. Il commute d'abord
au package "DB" afin que le débogueur n'interfère pas avec les variables du programme
vous essayez de déboguer. À divers moments, cependant, il revient temporairement à la
package "main" pour évaluer diverses expressions dans le contexte du package "main" (ou
d'où que vous veniez). Voir perldebug.

Le symbole spécial "__PACKAGE__" contient le package actuel, mais ne peut pas (facilement) être utilisé
pour construire des noms de variables.

Voir perlsub pour d'autres problèmes de portée liés à ma() et locale(), et perlref concernant
fermetures.

Symbole Tables
La table des symboles d'un paquet se trouve être stockée dans le hachage de ce nom avec deux
deux-points ajoutés. Le nom de la table de symboles principale est donc %main ::, ou % :: en abrégé.
De même, la table des symboles pour le package imbriqué mentionné précédemment est nommée
%EXTÉRIEUR::INTÉRIEUR ::.

La valeur dans chaque entrée du hachage est ce à quoi vous faites référence lorsque vous utilisez le *nom
notation typeglob.

local *main::foo = *main::bar;

Vous pouvez l'utiliser pour imprimer toutes les variables d'un package, par exemple. Le standard
mais archaïque dumpvar.pl bibliothèque et le module CPAN Devel::Symdump en font usage.

Les résultats de la création directe de nouvelles entrées de table de symboles ou de la modification de toute entrée qui
ne sont pas déjà les typesglobs sont indéfinis et sujets à changement entre les versions de perl.

L'affectation à un typeglob effectue une opération d'alias, c'est-à-dire,

*bite = *richard;

provoque des variables, des sous-programmes, des formats et des descripteurs de fichiers et de répertoires accessibles via le
l'identifiant « richard » doit également être accessible via l'identifiant « dick ». Si tu veux
alias uniquement une variable ou un sous-programme particulier, attribuez une référence à la place :

*bite = \$richard;

Ce qui fait de $ richard et $dick la même variable, mais laisse @richard et @dick comme
tableaux séparés. Difficile, hein ?

Il y a une différence subtile entre les déclarations suivantes :

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

"*foo = *bar" rend les typeglobs eux-mêmes synonymes tandis que "*foo = \$bar" rend le
Les portions SCALAIRE de deux types distincts font référence à la même valeur scalaire. Cela signifie que
le code suivant :

$bar = 1 ;
*foo = \$bar; # Faire de $foo un alias pour $bar

{
$bar local = 2 ; # Restreindre les modifications au blocage
imprimer $foo ; # Affiche '1' !
}

Affiche '1', car $foo contient une référence au original $bar. Celui qui était
bourré par "local()" et qui sera restauré à la fin du bloc. Parce que
les variables sont accessibles via le typeglob, vous pouvez utiliser "*foo = *bar" pour créer un alias
qui peut être localisé. (Mais sachez que cela signifie que vous ne pouvez pas avoir un @foo séparé et
@bar, etc.)

Ce qui rend tout cela important, c'est que le module Exporter utilise l'alias global comme
mécanisme d'import/export. Si vous pouvez ou non localiser correctement une variable qui a été
exporté à partir d'un module dépend de la façon dont il a été exporté :

@EXPORT = qw($FOO); # Forme habituelle, ne peut pas être localisé
@EXPORT = qw(*FOO); # Peut être localisé

Vous pouvez contourner le premier cas en utilisant le nom complet ($Package::FOO) où
vous avez besoin d'une valeur locale, ou en la remplaçant en disant "*FOO = *Package::FOO" dans votre
scripts.

Le mécanisme "*x = \$y" peut être utilisé pour passer et retourner des références bon marché vers ou depuis
sous-routines si vous ne voulez pas tout copier. Cela ne fonctionne que lors de l'affectation à
variables dynamiques, pas lexicales.

%some_hash = (); # ne peut pas être mon()
*some_hash = fn( \%unautre_hash );
sous fn {
local *hashsym = décalage;
# utilisez maintenant %hashsym normalement, et vous
# affectera le %another_hash de l'appelant
mon %nhash = (); # Faites ce que vous voulez
renvoie \%nhash ;
}

Au retour, la référence écrasera l'emplacement de hachage dans la table des symboles spécifié par le
*some_hash typeglob. C'est un moyen un peu délicat de faire circuler des références à moindre coût
lorsque vous ne voulez pas avoir à vous souvenir de déréférencer explicitement les variables.

Une autre utilisation des tables de symboles est de créer des scalaires "constants".

*PI = \3.14159265358979 ;

Maintenant, vous ne pouvez pas modifier $PI, ce qui est probablement une bonne chose dans l'ensemble. Ce n'est pas pareil
en tant que sous-programme constant, qui est soumis à une optimisation au moment de la compilation. Une constante
Le sous-programme est un prototypé pour ne prendre aucun argument et pour renvoyer une expression constante.
Voir perlsub pour plus de détails à ce sujet. Le pragma « use constant » est un raccourci pratique pour
celles-ci.

Vous pouvez dire *foo{PACKAGE} et *foo{NAME} pour savoir quel nom et emballer le symbole *foo
l'entrée de la table vient. Cela peut être utile dans un sous-programme qui reçoit des typeglobs comme
arguments:

sous-identifiant_typeglob {
mon $glob = décalage;
print 'Tu m'as donné ', *{$glob}{PACKAGE},
' ::', *{$glob}{NAME}, "\n" ;
}
identifier_typeglob *foo;
identifier_typeglob *bar::baz;

Cette imprime

Tu m'as donné main::foo
Tu m'as donné bar ::baz

La notation *foo{THING} peut également être utilisée pour obtenir des références aux éléments individuels
de *toto. Voir perlref.

Les définitions de sous-programmes (et les déclarations, d'ailleurs) ne doivent pas nécessairement être
situés dans l'emballage dont ils occupent la table des symboles. Vous pouvez définir un sous-programme
en dehors de son package en qualifiant explicitement le nom du sous-programme :

paquet principal;
sub Some_package::foo { ... } # &foo défini dans Some_package

Ceci est juste un raccourci pour une affectation de typeglob au moment de la compilation :

COMMENCER { *Some_package::foo = sous { ... } }

Les modèles sont aussi pas la même chose que l'écriture :

{
paquet Un_paquet ;
sous foo { ... }
}

Dans les deux premières versions, le corps du sous-programme est lexicalement dans le package principal,
pas dans Some_package. Donc quelque chose comme ça :

paquet principal;

$Some_package::nom = "fred";
$main::name = "barney";

sous Some_package::foo {
print "in ", __PACKAGE__, " : \$nom est '$nom'\n" ;
}

Some_package::foo();

impressions:

dans main : $name est 'barney'

plutôt que:

dans Some_package : $name est 'fred'

Cela a également des implications pour l'utilisation du qualificatif SUPER :: (voir perlobj).

COMMENCER, CONTROLE DE L'UNITE, CHÈQUE, INIT et FIN
Cinq blocs de code spécialement nommés sont exécutés au début et à la fin d'une
programme Perl. Ce sont les blocs "BEGIN", "UNICHECK", "CHECK", "INIT" et "END".

Ces blocs de code peuvent être préfixés par "sub" pour donner l'apparence d'un sous-programme
(bien que ce ne soit pas considéré comme un bon style). Il faut noter que ces blocs de code
n'existent pas vraiment en tant que sous-programmes nommés (malgré leur apparence). La chose qui donne
c'est loin le fait que vous pouvez avoir plus que UN de ces blocs de code dans un programme,
et ils obtiendront tous exécuté au moment opportun. Vous ne pouvez donc exécuter aucun des
ces blocs de code par nom.

Un bloc de code "BEGIN" est exécuté dès que possible, c'est-à-dire au moment où il est complètement
défini, avant même que le reste du fichier (ou de la chaîne) contenant ne soit analysé. Vous pouvez avoir
plusieurs blocs "BEGIN" dans un fichier (ou une chaîne évaluée); ils exécuteront dans l'ordre de
définition. Parce qu'un bloc de code "BEGIN" s'exécute immédiatement, il peut extraire des définitions
de sous-routines et autres à partir d'autres fichiers à temps pour être visibles par le reste de la compilation
et le temps d'exécution. Une fois qu'un "BEGIN" s'est exécuté, il est immédiatement indéfini et tout code qu'il a utilisé est
retourné au pool de mémoire de Perl.

Un bloc de code "END" est exécuté le plus tard possible, c'est-à-dire après la fin de perl
exécuter le programme et juste avant la sortie de l'interpréteur, même s'il est en train de sortir
à la suite d'un mourir() fonction. (Mais pas s'il se transforme en un autre programme via
"exec", ou être soufflé hors de l'eau par un signal - vous devez le piéger vous-même (si
vous pouvez).) Vous pouvez avoir plusieurs blocs "END" dans un fichier - ils s'exécuteront à l'envers
ordre de définition; c'est-à-dire : dernier entré, premier sorti (LIFO). Les blocs "END" ne sont pas exécutés
lorsque vous exécutez perl avec le commutateur "-c", ou si la compilation échoue.

Notez que les blocs de code "END" sont pas exécuté à la fin d'une chaîne "eval()": le cas échéant "END"
les blocs de code sont créés dans une chaîne "eval()", ils seront exécutés comme n'importe quel autre
Bloc de code "END" de ce package dans l'ordre LIFO juste avant que l'interpréteur soit en cours
sorti.

À l'intérieur d'un bloc de code "END", $? contient la valeur que le programme va passer à
"sortir()". Vous pouvez modifier $? pour changer la valeur de sortie du programme. Attention au changement
$? par accident (par exemple en exécutant quelque chose via "système").

A l'intérieur d'un bloc "END", la valeur de "${^GLOBAL_PHASE}" sera "END".

Les blocs de code "UNICHECK", "CHECK" et "INIT" sont utiles pour attraper la transition entre le
phase de compilation et la phase d'exécution du programme principal.

Les blocs "UNICHECK" sont exécutés juste après la compilation de l'unité qui les a définis. Les
le fichier programme principal et chaque module qu'il charge sont des unités de compilation, tout comme les chaînes "eval",
code d'exécution compilé à l'aide de la construction "(?{ })" dans une expression régulière, appels à "do FILE",
"require FILE", et le code après le commutateur "-e" sur la ligne de commande.

Les blocs " BEGIN " et " UNITCHECK " ne sont pas directement liés à la phase de l'interpréteur.
Ils peuvent être créés et exécutés au cours de n'importe quelle phase.

Les blocs de code "CHECK" sont exécutés juste après le initiale La phase de compilation Perl se termine et avant la
le temps d'exécution commence, dans l'ordre LIFO. Les blocs de code "CHECK" sont utilisés dans la suite du compilateur Perl
pour enregistrer l'état compilé du programme.

À l'intérieur d'un bloc "CHECK", la valeur de "${^GLOBAL_PHASE}" sera "CHECK".

Les blocs "INIT" sont exécutés juste avant le début de l'exécution de Perl, dans "premier entré, premier
out" (FIFO).

A l'intérieur d'un bloc "INIT", la valeur de "${^GLOBAL_PHASE}" sera "INIT".

Les blocs "CHECK" et "INIT" dans le code compilé par "require", chaîne "do", ou chaîne "eval"
ne seront pas exécutés s'ils surviennent après la fin de la phase de compilation principale ; qui peut
être un problème dans mod_perl et d'autres environnements persistants qui utilisent ces fonctions pour
charger le code à l'exécution.

Lorsque vous utilisez le -n et -p passe à Perl, "BEGIN" et "END" fonctionnent exactement comme dans
awk, comme un cas dégénéré. Les blocs "BEGIN" et "CHECK" sont exécutés lorsque vous utilisez le -c
basculez pour une vérification de syntaxe de compilation uniquement, bien que votre code principal ne le soit pas.

Votre commencervérifier programme rend tout clair, finalement:

#!/usr/bin/perl

# commencer la vérification

print "10. Le code ordinaire s'exécute au moment de l'exécution.\n" ;

END { print "16. C'est donc la fin de l'histoire.\n" }
INIT { print " 7. Les blocs INIT exécutent FIFO juste avant l'exécution.\n" }
CONTRLE UNITÉ {
print " 4. Et donc avant tout bloc CHECK.\n"
}
CHECK { print " 6. Voici donc la sixième ligne.\n" }

print "11. Il s'exécute dans l'ordre, bien sûr.\n" ;

BEGIN { print " 1. Les blocs BEGIN exécutent FIFO pendant la compilation.\n" }
END { print "15. Lisez perlmod pour le reste de l'histoire.\n" }
CHECK { print " 5. Les blocs CHECK exécutent LIFO après toute compilation.\n" }
INIT { print " 8. Exécutez ceci à nouveau, en utilisant le commutateur -c de Perl.\n" }

print "12. Ceci est un code anti-obscurcissement.\n" ;

END { print "14. Les blocs END exécutent LIFO au moment de la fermeture.\n" }
BEGIN { print " 2. Donc cette ligne sort en deuxième.\n" }
CONTRLE UNITÉ {
print " 3. Les blocs UNITCHECK exécutent LIFO après la compilation de chaque fichier.\n"
}
INIT { print " 9. Vous verrez tout de suite la différence.\n" }

print "13. Il semble seulement que cela devrait prêter à confusion.\n" ;

__FINIR__

Perl Cours
Il n'y a pas de syntaxe de classe spéciale en Perl, mais un package peut agir comme une classe s'il fournit
sous-programmes pour agir comme des méthodes. Un tel package peut également dériver certaines de ses méthodes de
une autre classe (package) en répertoriant le(s) autre(s) nom(s) de package dans son tableau @ISA global
(qui doit être un package global, pas un lexical).

Pour en savoir plus à ce sujet, voir perlootut et perlobj.

Perl formation vidéo
Un module est juste un ensemble de fonctions liées dans un fichier bibliothèque, c'est-à-dire un package Perl avec
le même nom que le fichier. Il est spécifiquement conçu pour être réutilisable par d'autres modules ou
programmes. Il peut le faire en fournissant un mécanisme pour exporter certains de ses symboles dans
la table des symboles de tout package l'utilisant, ou il peut fonctionner comme une définition de classe et
rendre sa sémantique disponible implicitement via des appels de méthode sur la classe et ses objets,
sans rien exporter explicitement. Ou il peut faire un peu des deux.

Par exemple, pour démarrer un module traditionnel non OO appelé Some::Module, créez un fichier
appelé Certains/Module.pm et commencez avec ce modèle :

paquet Certains::Module; # suppose que Some/Module.pm

utiliser strict;
utiliser des avertissements ;

COMMENCER {
Exiger l'exportateur ;

# définir la version pour la vérification de version
notre $VERSION = 1.00 ;

# Hériter de l'exportateur pour exporter des fonctions et des variables
notre @ISA = qw(Exportateur);

# Fonctions et variables exportées par défaut
notre @EXPORT = qw(func1 func2) ;

# Fonctions et variables pouvant être éventuellement exportées
notre @EXPORT_OK = qw($Var1 %Hashit func3) ;
}

# globals de package exportés ici
notre $Var1 = '';
notre %Hashit = ();

# globales de package non exportées vont ici
# (ils sont toujours accessibles en tant que $Some::Module::stuff)
notre @plus = ();
nos $trucs = '';

# les lexiques privés de fichiers vont ici, avant toutes les fonctions qui les utilisent
mon $priv_var = '';
mon %secret_hash = ();

# voici une fonction file-private en guise de fermeture,
# appelable en tant que $priv_func->();
mon $priv_func = sous {

};

# faire toutes vos fonctions, qu'elles soient exportées ou non ;
# n'oubliez pas de mettre quelque chose d'intéressant dans les stubs {}
sous-fonction1 { ... }
sous-fonction2 { ... }

# celui-ci n'est pas exporté, mais peut être appelé directement
# comme Some::Module::func3()
sous-fonction3 { ... }

END { ... } # code de nettoyage de module ici (destructeur global)

1; # n'oubliez pas de retourner une vraie valeur du fichier

Ensuite, déclarez et utilisez vos variables dans des fonctions sans aucune qualification. Voir
Exporter et perlmodlib pour plus de détails sur les problèmes de mécanique et de style dans la création de modules.

Les modules Perl sont inclus dans votre programme en disant

utiliser le module ;

or

utiliser le module LISTE ;

C'est exactement l'équivalent de

BEGIN { requiert 'Module.pm'; 'Module'->importer ; }

or

BEGIN { requiert 'Module.pm'; 'Module'->import( LIST ); }

Comme cas particulier

utiliser le module ();

est exactement équivalent à

BEGIN { requiert 'Module.pm'; }

Tous les fichiers du module Perl ont l'extension .pm. L'opérateur "use" suppose que vous
pas besoin d'épeler "Module.pm" entre guillemets. Cela permet aussi de différencier les nouveaux
modules de l'ancien .pl et .ph des dossiers. Les noms de module sont également en majuscule sauf s'ils sont
fonctionner comme des pragmas ; les pragmas sont en fait des directives du compilateur, et sont parfois
appelés « modules pragmatiques » (ou même « pragmata » si vous êtes un classique).

Les deux déclarations :

nécessite SomeModule ;
nécessite "UnModule.pm" ;

diffèrent les uns des autres de deux manières. Dans le premier cas, tout double deux-points dans le module
nom, tel que "Some::Module", sont traduits dans le séparateur de répertoire de votre système,
d'habitude "/". Le second cas ne l'est pas et devrait être spécifié littéralement. Les
l'autre différence est que voir les premiers indices "require" dans le compilateur qui utilise de
notation d'objet indirect impliquant "SomeModule", comme dans "$ob = purge SomeModule", sont
les appels de méthode, pas les appels de fonction. (Oui, cela peut vraiment faire une différence.)

Parce que l'instruction "use" implique un bloc "BEGIN", l'importation de la sémantique se produit comme
dès que l'instruction "use" est compilée, avant que le reste du fichier ne soit compilé. C'est
comment il est capable de fonctionner comme un mécanisme de pragma, et aussi comment les modules sont capables de déclarer
sous-routines qui sont alors visibles sous forme d'opérateurs de liste ou unaires pour le reste de la
déposer. Cela ne fonctionnera pas si vous utilisez "require" au lieu de "use". Avec "exiger", vous pouvez
entrer dans ce problème:

exiger Cwd ; # rendre Cwd :: accessible
$ici = Cwd::getcwd();

utiliser Cwd ; # importer des noms de Cwd : :
$ici = getcwd();

exiger Cwd ; # rendre Cwd :: accessible
$ici = getcwd(); # Oups! pas de main::getcwd()

En général, « use Module () » est recommandé plutôt que « require Module », car il détermine
disponibilité du module au moment de la compilation, pas au milieu de l'exécution de votre programme. Un
l'exception serait si deux modules essayaient chacun de « s'utiliser » l'un l'autre, et chacun appelait également un
fonction de cet autre module. Dans ce cas, il est facile d'utiliser "require" à la place.

Les packages Perl peuvent être imbriqués dans d'autres noms de packages, nous pouvons donc avoir des noms de packages
contenant " ::". Mais si nous utilisions ce nom de package directement comme nom de fichier, cela ferait
pour les noms de fichiers lourds ou impossibles sur certains systèmes. Par conséquent, si le nom d'un module est,
disons, "Text::Soundex", alors sa définition se trouve en fait dans le fichier de bibliothèque
Texte/Soundex.pm.

Les modules Perl ont toujours un .pm fichier, mais il peut aussi y avoir des exécutables liés dynamiquement
(se terminant souvent par .so) ou des définitions de sous-programmes chargées automatiquement (se terminant souvent par .Al)
associé au module. Si tel est le cas, celles-ci seront entièrement transparentes pour l'utilisateur du
module. Il est de la responsabilité du .pm fichier pour charger (ou organiser pour charger automatiquement) n'importe quel
fonctionnalité supplémentaire. Par exemple, bien que le module POSIX fasse les deux
chargement dynamique et chargement automatique, l'utilisateur peut simplement dire "utiliser POSIX" pour tout obtenir.

Fabrication votre module thread-safe
Perl prend en charge un type de threads appelés threads interpréteurs (threads). Ces fils peuvent
être utilisé explicitement et implicitement.

Les Ithreads fonctionnent en clonant l'arbre de données afin qu'aucune donnée ne soit partagée entre les différents
fils. Ces threads peuvent être utilisés en utilisant le module "threads" ou en faisant fourchette() on
win32 (faux fourchette() Support). Lorsqu'un thread est cloné, toutes les données Perl sont clonées, mais non
Les données Perl ne peuvent pas être clonées automatiquement. Perl après 5.8.0 prend en charge le "CLONE"
sous-programme spécial. Dans "CLONE", vous pouvez faire tout ce que vous devez faire, comme par exemple
gérer le clonage des données non Perl, si nécessaire. "CLONE" sera appelé une fois en tant que classe
méthode pour chaque package qui l'a défini (ou en hérite). Il sera appelé dans le
contexte du nouveau fil, donc toutes les modifications sont apportées dans la nouvelle zone. Actuellement CLONE
est appelé sans autre paramètre que le nom du package de l'invocateur, mais le code ne doit pas
supposer que cela restera inchangé, car il est probable qu'à l'avenir des paramètres supplémentaires
sera transmis pour donner plus d'informations sur l'état du clonage.

Si vous souhaitez CLONER tous les objets, vous devrez les suivre par paquet. C'est
simplement fait en utilisant un hachage et Scalaire::Util::weaken().

Perl après 5.8.7 prend en charge la sous-routine spéciale "CLONE_SKIP". Comme "CLONE",
"CLONE_SKIP" est appelé une fois par package ; cependant, il est appelé juste avant le début du clonage,
et dans le contexte du thread parent. S'il renvoie une valeur vraie, alors aucun objet de
cette classe sera clonée ; ou plutôt, ils seront copiés en tant que valeurs non bénies, undef. Pour
exemple : si dans le parent il y a deux références à un seul hachage béni, alors dans le
enfant, il y aura à la place deux références à une seule valeur scalaire non définie. Cette
fournit un mécanisme simple pour rendre un module threadsafe ; ajoutez simplement "sous CLONE_SKIP { 1
}" en haut de la classe, et "DÉTRUIRE()" ne sera désormais appelé qu'une seule fois par objet.
bien sûr, si le thread enfant a besoin d'utiliser les objets, alors un thread plus sophistiqué
approche est nécessaire.

Comme "CLONE", "CLONE_SKIP" est actuellement appelé sans autre paramètre que l'invocateur
nom du package, bien que cela puisse changer. De même, pour permettre une expansion future, le
la valeur de retour doit être une seule valeur 0 ou 1.

Utilisez perlmod en ligne en utilisant les services onworks.net