Perl est un langage de programmation stable et multiplateforme.
Bien que Perl ne soit pas officiellement un acronyme, peu de gens l'ont utilisé comme Practical Extraction and Report Language.
Il est utilisé pour des projets critiques dans les secteurs public et privé.
Perl est un logiciel Open Source , licencié sous sa licence artistique ou sous la licence publique générale GNU (GPL) .
Perl a été créé par Larry Wall.
Perl 1.0 a été publié sur alt.comp.sources d'usenet en 1987
Au moment de la rédaction de ce tutoriel, la dernière version de perl est la 5.16.2
Perl est répertorié dans l' Oxford English Dictionary .
Perl utilise les meilleures fonctionnalités d'autres langages, tels que C, awk, sed, sh et BASIC, entre autres.
Interface d'intégration de base de données Perls DBI prend en charge les bases de données tierces, notamment Oracle, Sybase, Postgres, MySQL et autres.
Perl fonctionne avec HTML, XML et d'autres langages de balisage.
Perl prend en charge Unicode.
Perl est conforme à l'an 2000.
Perl prend en charge la programmation procédurale et orientée objet.
Perl s'interface avec des bibliothèques C / C ++ externes via XS ou SWIG.
Perl est extensible. Il existe plus de 20 000 modules tiers disponibles sur le réseau complet d'archives Perl ( CPAN ).
L'interpréteur Perl peut être intégré dans d'autres systèmes.
Perl était le langage de programmation Web le plus populaire en raison de ses capacités de manipulation de texte et de son cycle de développement rapide.
Perl est largement connu comme " le ruban adhésif de l'Internet ".
Perl peut gérer les données Web cryptées, y compris les transactions de commerce électronique.
Perl peut être intégré aux serveurs Web pour accélérer le traitement jusqu'à 2000%.
Le mod_perl de Perl permet au serveur Web Apache d'intégrer un interpréteur Perl.
Le package DBI de Perl facilite l'intégration de la base de données Web.
Oui! Perl est un langage de programmation sensible à la casse.
Un identifiant Perl est un nom utilisé pour identifier une variable, une fonction, une classe, un module ou un autre objet. Un nom de variable Perl commence par $, @ ou% suivi de zéro ou plusieurs lettres, traits de soulignement et chiffres (0 à 9).
Perl a trois types de données de base: les scalaires, les tableaux de scalaires et les hachages de scalaires, également appelés tableaux associatifs.
Les scalaires sont des variables simples. Ils sont précédés d'un signe dollar ($). Un scalaire est un nombre, une chaîne ou une référence. Une référence est en fait l'adresse d'une variable, que nous verrons dans les prochains chapitres.
Les tableaux sont des listes ordonnées de scalaires auxquelles vous accédez avec un index numérique commençant par 0. Ils sont précédés d'un signe «at» (@).
Les hachages sont des ensembles non ordonnés de paires clé / valeur auxquels vous accédez en utilisant les clés comme indices. Ils sont précédés d'un signe de pourcentage (%).
Les variables Perl n'ont pas besoin d'être explicitement déclarées pour réserver de l'espace mémoire. La déclaration se produit automatiquement lorsque vous affectez une valeur à une variable. Le signe égal (=) est utilisé pour attribuer des valeurs aux variables.
Perl traite la même variable différemment en fonction du contexte, c'est-à-dire de la situation où une variable est utilisée.
L'affectation à une variable scalaire évalue le côté droit dans un contexte scalaire.
L'affectation à un tableau ou à un hachage évalue le côté droit dans un contexte de liste.
Le contexte booléen est simplement n'importe quel endroit où une expression est évaluée pour voir si elle est vraie ou fausse.
Ce contexte ne se soucie pas seulement de la valeur de retour, il ne veut même pas de valeur de retour.
Ce contexte ne se produit que dans des guillemets ou des choses qui fonctionnent comme des guillemets.
La chaîne entre guillemets simples imprime la variable Perl sous forme de chaîne tandis que la chaîne entre guillemets doubles évalue la variable et est utilisée pour obtenir la valeur de la variable.
#!/usr/bin/perl
$var = "This is string scalar!";
$quote = 'I m inside single quote - $var';
$double = "This is inside double quote - $var";
$escape = "This example of escape -\tHello, World!";
print "var = $var\n";
print "quote = $quote\n";
print "double = $double\n";
print "escape = $escape\n";Cela produira le résultat suivant -
var = This is string scalar!
quote = I m inside single quote - $var
double = This is inside double quote - This is string scalar!
escape = This example of escape - Hello, World!Un littéral de la forme v1.20.300.4000 est analysé comme une chaîne composée de caractères avec les ordinaux spécifiés. Cette forme est connue sous le nom de chaînes v.
Une chaîne V fournit une manière alternative et plus lisible de construire des chaînes, plutôt que d'utiliser la forme d'interpolation un peu moins lisible "\ x {1} \ x {14} \ x {12c} \ x {fa0}".
Il est utilisé pour obtenir le nom du fichier actuel.
Il est utilisé pour obtenir le numéro de ligne actuel.
Il est utilisé pour obtenir le nom du package actuel.
Pour faire référence à un seul élément d'un tableau, vous utiliserez le signe dollar ($) avec le nom de la variable suivi de l'index de l'élément entre crochets.
Voici un exemple simple d'utilisation des variables de tableau -
#!/usr/bin/perl
@ages = (25, 30, 40);
@names = ("John Paul", "Lisa", "Kumar");
print "\$ages[0] = $ages[0]\n";
print "\$ages[1] = $ages[1]\n";
print "\$ages[2] = $ages[2]\n";
print "\$names[0] = $names[0]\n";
print "\$names[1] = $names[1]\n";
print "\$names[2] = $names[2]\n";Une fois attendu, cela produira le résultat suivant -
$ages[0] = 25
$ages[1] = 30
$ages[2] = 40
$names[0] = John Paul
$names[1] = Lisa
$names[2] = KumarL'opérateur de plage (..) est utilisé pour créer des tableaux séquentiels.
#!/usr/bin/perl
@var_10 = (1..10);
@var_20 = (10..20);
@var_abc = (a..z);
print "@var_10\n"; # Prints number from 1 to 10
print "@var_20\n"; # Prints number from 10 to 20
print "@var_abc\n"; # Prints number from a to zIci, le double point (..) est appelé opérateur de plage. Cela produira le résultat suivant -
1 2 3 4 5 6 7 8 9 10
10 11 12 13 14 15 16 17 18 19 20
a b c d e f g h i j k l m n o p q r s t u v w x y zLa taille d'un tableau peut être déterminée en utilisant le contexte scalaire sur le tableau - la valeur retournée sera le nombre d'éléments dans le tableau -
@array = (1,2,3);
print "Size: ",scalar @array,"\n";La valeur renvoyée sera toujours la taille physique du tableau, et non le nombre d'éléments valides.
push @ARRAY, LIST - Pousse les valeurs de la liste à la fin du tableau.
#!/usr/bin/perl
# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins = @coins\n";
# add one element at the end of the array
push(@coins, "Penny");
print "2. \@coins = @coins\n";Cela produira le résultat suivant -
1. @coins = Quarter Dime Nickel
2. @coins = Quarter Dime Nickel Pennyunshift @ARRAY, LIST - Ajoute la liste au début du tableau et renvoie le nombre d'éléments dans le nouveau tableau.
#!/usr/bin/perl
# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins = @coins\n";
# add one element at the beginning of the array
unshift(@coins, "Dollar");
print "2. \@coins = @coins\n";Cela produira le résultat suivant -
1. @coins = Quarter Dime Nickel
2. @coins = Dollar Quarter Dime Nickelpop @ARRAY - S'éteint et renvoie la dernière valeur du tableau.
#!/usr/bin/perl
# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins = @coins\n";
# remove one element from the last of the array.
pop(@coins);
print "2. \@coins = @coins\n";Cela produira le résultat suivant -
1. @coins = Quarter Dime Nickel
2. @coins = Quarter Dimeshift @ARRAY - Décale la première valeur du tableau et la renvoie, raccourcissant le tableau de 1 et déplaçant tout vers le bas.
#!/usr/bin/perl
# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins = @coins\n";
# remove one element from the beginning of the array.
shift(@coins);
print "2. \@coins = @coins\n";Cela produira le résultat suivant -
1. @coins = Quarter Dime Nickel
2. @coins = Dime NickelVous pouvez également extraire une «tranche» d'un tableau - c'est-à-dire que vous pouvez sélectionner plusieurs éléments d'un tableau afin de produire un autre tableau.
#!/usr/bin/perl
@days = qw/Mon Tue Wed Thu Fri Sat Sun/;
@weekdays = @days[3,4,5];
print "@weekdays\n";Cela produira le résultat suivant -
Thu Fri SatLa fonction splice () supprimera les éléments de @ARRAY désignés par OFFSET et LENGTH, et les remplacera par LIST, si spécifié. Enfin, il renvoie les éléments supprimés du tableau.
splice @ARRAY, OFFSET [ , LENGTH [ , LIST ] ]Voici l'exemple -
#!/usr/bin/perl
@nums = (1..20);
print "Before - @nums\n";
splice(@nums, 5, 5, 21..25);
print "After - @nums\n";Cela produira le résultat suivant -
Before − 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
After − 1 2 3 4 5 21 22 23 24 25 11 12 13 14 15 16 17 18 19 20split () divise une chaîne en un tableau de chaînes et la renvoie. Si LIMIT est spécifié, se divise en au plus ce nombre de champs. Si PATTERN est omis, se divise sur des espaces.
split [ PATTERN [ , EXPR [ , LIMIT ] ] ]Voici l'exemple -
#!/usr/bin/perl
# define Strings
$var_string = "Rain-Drops-On-Roses-And-Whiskers-On-Kittens";
$var_names = "Larry,David,Roger,Ken,Michael,Tom";
# transform above strings into arrays.
@string = split('-', $var_string);
@names = split(',', $var_names);
print "$string[3]\n"; # This will print Roses
print "$names[4]\n"; # This will print MichaelCela produira le résultat suivant -
Roses
Michaeljoin () joint les chaînes séparées de LIST en une seule chaîne avec des champs séparés par la valeur de EXPR, et renvoie la chaîne.
join EXPR, LISTVoici l'exemple -
#!/usr/bin/perl
# define Strings
$var_string = "Rain-Drops-On-Roses-And-Whiskers-On-Kittens";
$var_names = "Larry,David,Roger,Ken,Michael,Tom";
# transform above strings into arrays.
@string = split('-', $var_string);
@names = split(',', $var_names);
$string1 = join( '-', @string );
$string2 = join( ',', @names );
print "$string1\n";
print "$string2\n";
print "$string[3]\n"; # This will print Roses
print "$names[4]\n"; # This will print MichaelCela produira le résultat suivant -
Rain-Drops-On-Roses-And-Whiskers-On-Kittens
Larry,David,Roger,Ken,Michael,TomLa fonction sort () trie chaque élément d'un tableau selon les normes numériques ASCII. Cette fonction a la syntaxe suivante -
sort [ SUBROUTINE ] LISTCette fonction trie la LISTE et renvoie la valeur du tableau trié. Si SUBROUTINE est spécifié, la logique spécifiée à l'intérieur de SUBTROUTINE est appliquée lors du tri des éléments.
#!/usr/bin/perl
# define an array
@foods = qw(pizza steak chicken burgers);
print "Before: @foods\n";
# sort this array
@foods = sort(@foods);
print "After: @foods\n";Cela produira le résultat suivant -
Before: pizza steak chicken burgers
After: burgers chicken pizza steakCette variable spéciale est un scalaire contenant le premier index de tous les tableaux. Comme les tableaux Perl ont une indexation basée sur zéro, $ [sera presque toujours égal à 0. Mais si vous définissez $ [sur 1, tous vos tableaux utiliseront l'indexation basée sur zéro. Il est recommandé de ne pas utiliser d'autre indexation que zéro. Cependant, prenons un exemple pour montrer l'utilisation de $ [variable -
#!/usr/bin/perl
# define an array
@foods = qw(pizza steak chicken burgers);
print "Foods: @foods\n";
# Let's reset first index of all the arrays.
$[ = 1;
print "Food at \@foods[1]: $foods[1]\n";
print "Food at \@foods[2]: $foods[2]\n";Cela produira le résultat suivant -
Foods: pizza steak chicken burgers
Food at @foods[1]: pizza
Food at @foods[2]: steakÉtant donné qu'un tableau n'est qu'une séquence de valeurs séparées par des virgules, vous pouvez les combiner comme indiqué ci-dessous.
#!/usr/bin/perl
@numbers = (1,3,(4,5,6));
print "numbers = @numbers\n";Cela produira le résultat suivant -
numbers = 1 3 4 5 6Les hachages sont créés de l'une des deux manières suivantes. Dans la première méthode, vous attribuez une valeur à une clé nommée sur une base un par un -
$data{'John Paul'} = 45;
$data{'Lisa'} = 30;
$data{'Kumar'} = 40;Dans le second cas, vous utilisez une liste, qui est convertie en prenant des paires individuelles de la liste: le premier élément de la paire est utilisé comme clé, et le second, comme valeur. Par exemple -
%data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);Lors de l'accès à des éléments individuels à partir d'un hachage, vous devez faire précéder la variable d'un signe dollar ($), puis ajouter la clé d'élément entre accolades après le nom de la variable. Par exemple -
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
print "$data{'John Paul'}\n";
print "$data{'Lisa'}\n";
print "$data{'Kumar'}\n";Cela produira le résultat suivant -
45
30
40Vous pouvez obtenir une liste de toutes les clés à partir d'un hachage en utilisant la fonction keys, qui a la syntaxe suivante -
keys %HASHCette fonction renvoie un tableau de toutes les clés du hachage nommé. Voici l'exemple -
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@names = keys %data;
print "$names[0]\n";
print "$names[1]\n";
print "$names[2]\n";Cela produira le résultat suivant -
Lisa
John Paul
KumarVous pouvez obtenir une liste de toutes les valeurs à partir d'un hachage en utilisant la fonction values, qui a la syntaxe suivante -
values %HASHCette fonction renvoie un tableau de toutes les valeurs du hachage nommé. Voici l'exemple -
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@ages = values %data;
print "$ages[0]\n";
print "$ages[1]\n";
print "$ages[2]\n";Cela produira le résultat suivant -
30
45
40En utilisant la fonction exist, qui renvoie true si la clé nommée existe, quelle que soit sa valeur -
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
if( exists($data{'Lisa'} ) ){
print "Lisa is $data{'Lisa'} years old\n";
}
else{
print "I don't know age of Lisa\n";
}Ici, nous avons introduit l'instruction IF ... ELSE, que nous étudierons dans un chapitre séparé. Pour l'instant, vous supposez simplement que si la partie (condition) ne sera exécutée que lorsque la condition donnée est vraie, sinon la partie sera exécutée. Ainsi, lorsque nous exécutons le programme ci-dessus, il produit le résultat suivant car ici la condition donnée existe ($ data {'Lisa'} renvoie true -
Lisa is 30 years oldVous pouvez obtenir la taille, c'est-à-dire le nombre d'éléments à partir d'un hachage en utilisant le contexte scalaire sur des clés ou des valeurs. En disant simplement que vous devez d'abord obtenir un tableau des clés ou des valeurs, vous pouvez ensuite obtenir la taille du tableau comme suit -
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@keys = keys %data;
$size = @keys;
print "1 - Hash size: is $size\n";
@values = values %data;
$size = @values;
print "2 - Hash size: is $size\n";Cela produira le résultat suivant -
1 - Hash size: is 3
2 - Hash size: is 3L'ajout d'une nouvelle paire clé / valeur peut être effectué avec une ligne de code à l'aide d'un opérateur d'affectation simple.
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@keys = keys %data;
$size = @keys;
print "1 - Hash size: is $size\n";
# adding an element to the hash;
$data{'Ali'} = 55;
@keys = keys %data;
$size = @keys;
print "2 - Hash size: is $size\n";Cela produira le résultat suivant -
1 - Hash size: is 3
2 - Hash size: is 4Pour supprimer un élément du hachage, vous devez utiliser la fonction de suppression comme indiqué ci-dessous dans l'exemple -
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@keys = keys %data;
$size = @keys;
print "1 - Hash size: is $size\n";
# delete the same element from the hash;
delete $data{'John Paul'};
@keys = keys %data;
$size = @keys;
print "2 - Hash size: is $size\n";Cela produira le résultat suivant -
1 - Hash size: is 3
2 - Hash size: is 2Il oblige la boucle à sauter le reste de son corps et à retester immédiatement son état avant de réitérer. Dernière déclaration.
Il met fin à l'instruction de boucle et transfère l'exécution à l'instruction immédiatement après la boucle. continue déclaration.
Un bloc continue, il est toujours exécuté juste avant que le conditionnel soit sur le point d'être évalué à nouveau.
La commande redo redémarre le bloc de boucle sans réévaluer le conditionnel. Le bloc Continuer, s'il y en a un, n'est pas exécuté.
Le formulaire goto LABEL passe à l'instruction étiquetée LABEL et reprend l'exécution à partir de là.
Le formulaire goto EXPR n'est qu'une généralisation de goto LABEL. Il s'attend à ce que l'expression renvoie un nom d'étiquette, puis saute à cette instruction étiquetée.
Il remplace un appel au sous-programme nommé pour le sous-programme en cours d'exécution.
Exposant - Effectue un calcul exponentiel (puissance) sur les opérateurs. Supposons que la variable $ a vaut 10 et la variable $ b vaut 20, alors $ a ** $ b donnera 10 à la puissance 20.
Il vérifie si la valeur de deux opérandes est égale ou non et renvoie -1, 0 ou 1 selon que l'argument de gauche est numériquement inférieur, égal ou supérieur à l'argument de droite. Supposons que la variable $ a soit 10 et la variable $ b 20 alors ($ a <=> $ b) renvoie -1.
Il renvoie true si l'argument de gauche est inférieur dans le sens de la chaîne à l'argument de droite. Supposons que la variable $ a contienne "abc" et que la variable $ b contienne "xyz" alors ($ a lt $ b) est vrai.
Il renvoie true si l'argument de gauche est supérieur dans le sens de la chaîne à l'argument de droite. Supposons que la variable $ a contienne "abc" et que la variable $ b contienne "xyz" alors ($ a gt $ b) est faux.
Il renvoie true si l'argument de gauche est inférieur ou égal à l'argument de droite dans le sens d'une chaîne. Supposons que la variable $ a contienne "abc" et que la variable $ b contienne "xyz" alors ($ a chier $ b) est vrai.
Il renvoie true si l'argument de gauche est supérieur ou égal à l'argument de droite dans le sens de la chaîne. Supposons que la variable $ a contienne "abc" et que la variable $ b contienne "xyz" alors ($ a ge $ b) est faux.
Il renvoie true si l'argument de gauche est égal au niveau de la chaîne à l'argument de droite. Supposons que la variable $ a contienne "abc" et que la variable $ b contienne "xyz" alors ($ a eq $ b) est faux.
Il renvoie true si l'argument de gauche n'est pas égal à l'argument de droite dans le sens d'une chaîne. Supposons que la variable $ a contienne "abc" et que la variable $ b contienne "xyz" alors ($ a ne $ b) est vrai.
Il renvoie -1, 0 ou 1 selon que l'argument de gauche est inférieur, égal ou supérieur à l'argument de droite dans le sens de la chaîne. Supposons que la variable $ a contienne "abc" et que la variable $ b contienne "xyz" alors ($ a cmp $ b) vaut -1.
Opérateur d'affectation exposant AND, effectue un calcul exponentiel (puissance) sur les opérateurs et attribue une valeur à l'opérande de gauche. $ c ** = $ a équivaut à $ c = $ c ** $ a
Il entoure une chaîne entre guillemets simples. q {abcd} donne 'abcd'
Il renferme une chaîne entre guillemets. qq {abcd} donne "abcd"
Il entoure une chaîne avec des guillemets inversés. qx {abcd} donne `abcd`
L'opérateur binaire dot (.) Concatène deux chaînes. Si $ a = "abc", $ b = "def" alors $ a. $ B donnera "abcdef"
L'opérateur de répétition x renvoie une chaîne constituée de l'opérande gauche répété le nombre de fois spécifié par l'opérande droit. ('-' x 3) donnera ---.
L'opérateur de plage .. renvoie une liste de valeurs comptées (par unités) de la valeur de gauche à la valeur de droite. (2..5) donnera (2, 3, 4, 5).
L'opérateur d'incrémentation automatique augmente la valeur entière de un. $ a ++ donnera 11.
L'opérateur de décrémentation automatique diminue la valeur entière de un. $ a−− donnera 9
L'opérateur de flèche est principalement utilisé pour déréférencer une méthode ou une variable d'un objet ou d'un nom de classe. $ obj -> $ a est un exemple pour accéder à la variable $ a depuis l'objet $ obj.
localtime (), qui renvoie les valeurs de la date et de l'heure actuelles si aucun argument n'est fourni.
#!/usr/local/bin/perl
@months = qw( Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec );
@days = qw(Sun Mon Tue Wed Thu Fri Sat Sun);
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime();
print "$mday $months[$mon] $days[$wday]\n";Lorsque le code ci-dessus est exécuté, il produit le résultat suivant -
16 Feb SatLa fonction gmtime () fonctionne comme la fonction localtime () mais les valeurs renvoyées sont localisées pour le fuseau horaire standard de Greenwich. Lorsqu'il est appelé dans un contexte de liste, $ isdst, la dernière valeur renvoyée par gmtime, est toujours 0. Il n'y a pas d'heure d'été en GMT.
localtime () renverra l'heure locale actuelle sur la machine qui exécute le script et gmtime () renverra l'heure universelle de Greenwich, ou GMT (ou UTC).
Vous pouvez utiliser la fonction time () pour obtenir l'heure de l'époque, c'est-à-dire le nombre de secondes qui se sont écoulées depuis une date donnée, sous Unix est le 1er janvier 1970.
Vous pouvez utiliser la fonction POSIX strftime () pour formater la date et l'heure.
La forme générale d'une définition de sous-programme dans le langage de programmation Perl est la suivante:
sub subroutine_name{
body of the subroutine
}La manière typique d'appeler ce sous-programme Perl est la suivante:
subroutine_name( list of arguments );ils peuvent être accédés à l'intérieur de la fonction en utilisant le tableau spécial @_. Ainsi, le premier argument de la fonction est dans $ _ [0], le second dans $ _ [1], et ainsi de suite.
en utilisant scalaire (@_), nous pouvons obtenir le nombre total d'arguments passés.
L'opérateur my limite une variable à une région de code particulière dans laquelle elle peut être utilisée et accessible. En dehors de cette région, cette variable ne peut pas être utilisée ou accessible.
Par défaut, toutes les variables en Perl sont des variables globales, ce qui signifie qu'elles sont accessibles de n'importe où dans le programme.
Les variables lexicales sont des variables privées créées à l'aide de mon opérateur.
Le local est utilisé lorsque la valeur actuelle d'une variable doit être visible pour les sous-programmes appelés.
Un local donne juste des valeurs temporaires aux variables globales (c'est-à-dire package). C'est ce qu'on appelle la portée dynamique.
Le cadrage lexical est fait avec mon opérateur. Une portée lexicale est généralement un bloc de code entouré d'un ensemble d'accolades, telles que celles définissant le corps du sous-programme ou celles marquant les blocs de code des instructions if, while, for, foreach et eval. L'opérateur my limite une variable à une région de code particulière dans laquelle elle peut être utilisée et accessible. En dehors de cette région, cette variable ne peut pas être utilisée ou accessible.
Il existe un autre type de variables lexicales, qui sont similaires aux variables privées mais qui conservent leur état et ne sont pas réinitialisées lors de plusieurs appels des sous-programmes. Ces variables sont définies à l'aide de l'opérateur d'état et disponibles à partir de Perl 5.9.4.
Le contexte d'un sous-programme ou d'une instruction est défini comme le type de valeur de retour attendu. Cela vous permet d'utiliser une seule fonction qui renvoie différentes valeurs en fonction de ce que l'utilisateur attend de recevoir. Par exemple, le localtime () suivant renvoie une chaîne lorsqu'il est appelé dans un contexte scalaire, mais il renvoie une liste lorsqu'il est appelé dans un contexte de liste.
my $datestring = localtime( time );Dans cet exemple, la valeur de $ timestr est désormais une chaîne composée de la date et de l'heure actuelles, par exemple, Thu Nov 30 15:21:33 2000. Inversement -
($sec,$min,$hour,$mday,$mon, $year,$wday,$yday,$isdst) = localtime(time);Désormais, les variables individuelles contiennent les valeurs correspondantes renvoyées par le sous-programme localtime ().
Une référence Perl est un type de données scalaire qui contient l'emplacement d'une autre valeur qui peut être scalaire, des tableaux ou des hachages. En raison de sa nature scalaire, une référence peut être utilisée n'importe où, un scalaire peut être utilisé.
Vous pouvez créer une référence pour n'importe quelle variable en la préfixant avec une barre oblique inverse comme suit -
$scalarref = \$foo;Vous pouvez créer une référence pour n'importe quel tableau en le préfixant avec une barre oblique inverse comme suit -
$arrayref = \@ARGV;Vous pouvez créer une référence pour n'importe quel hachage en le préfixant avec une barre oblique inverse comme suit -
$hashref = \%ENV;Vous pouvez créer une référence pour n'importe quel sous-routage en le préfixant avec une barre oblique inverse comme suit -
$cref = \&PrintHash;Le déréférencement renvoie la valeur d'un point de référence à l'emplacement.
Pour déréférencer une référence, utilisez simplement $, @ ou% comme préfixe de la variable de référence selon que la référence pointe vers un scalaire, un tableau ou un hachage.
Une référence circulaire se produit lorsque deux références contiennent une référence l'une à l'autre. Il faut être prudent lors de la création de références sinon une référence circulaire peut entraîner des fuites de mémoire. Voici un exemple -
#!/usr/bin/perl
my $foo = 100;
$foo = \$foo;
print "Value of foo is : ", $$foo, "\n";Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -
Value of foo is : REF(0x9aae38)Voici la syntaxe pour ouvrir file.txt en mode lecture seule. Ici, moins de <signe indique que le fichier doit être ouvert en mode lecture seule.
open(DATA, "<file.txt");Ici, DATA est le descripteur de fichier qui sera utilisé pour lire le fichier.
Voici la syntaxe pour ouvrir file.txt en mode écriture. Ici, le signe inférieur à> indique que le fichier doit être ouvert en mode d'écriture.
open(DATA, ">file.txt") or die "Couldn't open file file.txt, $!";Voici la syntaxe pour ouvrir file.txt en mode écriture sans le tronquer. Ici, moins de + <signe indique que le fichier doit être ouvert en mode écriture sans le tronquer.
open(DATA, "+<file.txt") or die "Couldn't open file file.txt, $!";Pour fermer un descripteur de fichier, et donc dissocier le descripteur de fichier du fichier correspondant, vous utilisez la fonction de fermeture. Cela vide les tampons du descripteur de fichier et ferme le descripteur de fichier du système.
La fonction getc renvoie un seul caractère du FILEHANDLE spécifié, ou STDIN si aucun n'est spécifié.
La fonction de lecture lit un bloc d'informations à partir du descripteur de fichier mis en mémoire tampon: Cette fonction est utilisée pour lire les données binaires du fichier.