Tutoriel Perl : Variable, tableau, hachages avec exemple de programmation
Lucas Bennett
Qu'est-ce que Perl ?
Perl est un langage de programmation dynamique de haut niveau, à usage général, interprété. Perl est un terme signifiant « Practical Extraction and Reporting Language » même s'il n'y a pas d'acronyme pour Perl. Il a été introduit par Larry Wall en 1987. Le langage Perl a été spécialement conçu pour l'édition de texte. Mais maintenant, il est largement utilisé à diverses fins, notamment l'administration système Linux, la programmation réseau, le développement Web, etc.
Disons-le de manière simple. Alors que les ordinateurs ne comprennent que les 0 et les 1 (langage binaire/langage machine/[langage de bas niveau]), il est très difficile de programmer dans un langage binaire pour nous, humains. Perl est un langage de programmation qui utilise des éléments du langage naturel, des mots utilisés dans la langue anglaise courante et qui est donc plus facile à comprendre par les humains.langage de haut niveau]. Maintenant, il y a un problème ; les ordinateurs ne peuvent pas comprendre les langages de haut niveau, que nous, les humains, pouvons facilement comprendre. Pour cela, nous avons besoin de quelque chose qui puisse traduire le langage de haut niveau en langage de bas niveau. Ici, l'interprète vient à notre aide. L'interprète est un logiciel qui convertit le programme écrit dans un langage de haut niveau en langage de bas niveau pour que l'ordinateur puisse comprendre et exécuter les instructions écrites dans le programme. Par conséquent, Perl est un langage de programmation interprété.
Où Perl est-il utilisé ?
La puissance du langage de script Perl peut être mise en œuvre dans de nombreux domaines. L'utilisation la plus populaire de Perl est le développement Web. Perl est également utilisé pour automatiser de nombreuses tâches sur les serveurs Web et d'autres tâches d'administration, il peut générer automatiquement des e-mails et nettoyer les systèmes. Perl est toujours utilisé pour son objectif initial, c'est-à-dire extraire des données et générer des rapports. Il peut produire des rapports sur l'utilisation des ressources et vérifier les problèmes de sécurité dans un réseau. Pour cette raison, Perl est également devenu un langage populaire utilisé dans le développement Web, les réseaux et la bioinformatique. En dehors de tout cela, Perl peut également être utilisé pour la programmation CGI.
Perl peut également être utilisé pour la création et la manipulation d'images. Outre cette mise en réseau via telnet, FTP, etc., la création d'interface utilisateur graphique, l'électronique VLSI et la création de filtres de messagerie pour réduire les pratiques de spam sont quelques cas d'utilisation de Perl.
Perl est également connu pour la mise en œuvre de pratiques OOP (programmation orientée objet) et prend en charge toutes les formes d'héritage (simple, multiple et diamant), le polymorphisme et l'encapsulation. Perl est suffisamment flexible pour prendre en charge simultanément les pratiques procédurales et OOP. Perl dispose également de modules supplémentaires qui vous permettent d'écrire ou d'utiliser/réutiliser du code écrit en Python, PHP, PDL, TCL, Octave, Java,C, C++, Basic, Ruby et Lua dans votre script Perl. Cela signifie que vous pouvez combiner Perl avec ces éléments supplémentaires langages de programmation plutôt réécrire le code existant.
Applications du langage de programmation Perl
Pourquoi utiliser Perl ?
Il est vrai qu'il existe d'autres langages de programmation qui peuvent être utilisés pour faire tout ce qui a été indiqué ci-dessus, alors pourquoi devriez-vous utiliser spécifiquement Perl ? Perl est très facile à apprendre, surtout si vous avez une formation en programmation informatique. Perl a été conçu pour être facile à écrire et à comprendre par les humains plutôt que de faciliter son traitement par les ordinateurs. Il utilise des expressions régulières. Son style naturel de langage est différent des autres langages de programmation qui utilisent une grammaire et des syntaxes spécifiques ; Par conséquent, Perl est très flexible et ne vous impose aucune manière particulière de réfléchir à une solution ou à un problème. Perl est extrêmement portable. Il peut fonctionner sur n'importe quel système d'exploitation doté d'un interpréteur Perl, il est donc indépendant de la plate-forme. Tout Linux OperaLes systèmes d'exploitation sont installés avec Perl, ce qui vous permet de commencer à coder en Perl sous Linux dès la sortie de la boîte. Cela ne ressemble pas aux scripts Shell, où le code change en fonction de la version de distribution Linux utilisée, ce qui le rend de moins en moins portable. Les petites tâches spécifiques en Perl deviennent très simples et rapides. Tout au long de ce didacticiel Perl pour débutants, vous apprendrez comment coder de petits programmes rapides pour des tâches spécifiques. Prenons un exemple simple du programme classique Hello World qui est utilisé pour commencer à apprendre n'importe quel langage de programmation dont les racines sont UNIX :
Exemple : Perl bonjour tout le monde
#!/usr/bin/perl print "Hello, world!";
Sortie :
Bonjour le monde!
Les deux lignes de code ci-dessus afficheront Hello, world ! N'était-ce pas trop simple et rapide ? Les étudiants ayant des connaissances en C, C++ saura qu'il faut beaucoup plus de lignes de code pour obtenir le même résultat dans ces langages.
Vous vous demandez peut-être pourquoi Perl est si célèbre sur le Web. C'est simple car la plupart des choses qui se passent sur le Web sont du TEXTE et Perl est très bon en traitement de texte. Si nous comparons Perl avec l'un des langages, alors Perl sera le meilleur langage qui soit performant en matière de gestion de fichiers, de traitement de texte et de reporting de sortie.
L'un des principaux avantages de Perl est qu'il gratuits
La communauté Perl croit fermement que les logiciels doivent être librement disponibles, librement modifiables et librement distribuables. Plusieurs bénévoles de la communauté Perl s'efforcent de rendre le langage de programmation aussi bon que possible.
Avantages et inconvénients de Perl
| Avantages: | Inconvénients: |
|---|---|
|
|
|
|
|
Commençons!
Avec suffisamment de connaissances sur l’histoire de Perl et les concepts de base de la programmation informatique requis pour le codage en Perl, il est temps de nous lancer et de commencer avec Perl. Le chapitre suivant vous apprendra comment configurer Perl sur votre système et vous préparer au voyage de codage en Perl. Ce didacticiel de script Perl prendra Linux comme système d'exploitation que les étudiants utiliseront pour coder en Perl.
Téléchargez et installez Perl – Windows, Mac et Linux
Comment obtenir Perl ?
Bonnes nouvelles vous l'avez probablement !
Mais si vous ne le trouvez pas déjà sur votre système, vous pouvez toujours l'obtenir gratuitement.
Pour savoir si Perl est déjà installé, accédez à la ligne de commande et tapez : perl -v
La commande affichera la version de Perl si elle est installée. Dans ce cas, la version est la v5.14.2. Mais sinon… pas de panique…
Unix
|
Déjà installé Livré préinstallé avec Perl, mais vous devrez peut-être mettre à jour vers la dernière version. |
Mac OS 
|
Déjà installé OSX est livré avec Perl préinstallé, bien que vous deviez peut-être le mettre à jour avec la dernière version |
Windows
|
Besoin d'installer Deux options sont disponibles
|
Mise à jour de Perl sous Linux :
Si vous devez mettre à jour la version Perl, entrez simplement une seule ligne de commande
sudo apt-get install perl
et détendre. Le reste sera pris en charge. Assurez-vous simplement d'avoir une connexion Internet active.
Installer Perl pour Windows:
Tout d'abord, téléchargez Active Perl à partir de ce lien. Suivez ces étapes pour installer ActivePerl sur Windows système. Voir les captures d'écran ci-dessous pour la même chose.
Étape 1: Une fois que vous avez téléchargé le programme d'installation et démarré l'installation, vous verrez la fenêtre ci-dessous, cliquez sur suivant pour continuer.
Étape 2: Acceptez le contrat de licence pour poursuivre l’installation.
Étape 3: Vous trouverez ci-dessous différents packages qui seront installés. Par défaut, tous seront sélectionnés. La seule chose différente est PPM (Perl Package Manager). Il s'agit de l'utilitaire fourni par Active Perl pour installer des modules ou bibliothèques Perl externes sur votre système. Cliquez sur Suivant pour continuer.
Étape 4: Ce sont différents types d'extensions Perl qui peuvent être utilisées pour Perl. Nous utiliserons principalement .Pl, .Plx et .Pm pour Perl. Les modules Perl utilisent essentiellement .Pm comme extension de fichier pour faire référence à un fichier de bibliothèque. Sélectionnez toutes les options et cliquez sur le bouton Suivant.
Étape 5: Cliquez sur le bouton Installer pour procéder à l'installation.
Étape 6: Une fois installé, exécutez la commande « Perl –v » pour vérifier si Perl est installé avec succès sur votre système.
Il y a beaucoup de choses qui doivent être discutées pour configurer l'environnement Perl sous Linux et Windows, car il n'y aura pas beaucoup de fichiers de bibliothèque inclus dans cette installation. Vous devez les installer manuellement. Vous pouvez les installer manuellement à l'aide de CPAN (Comprehensive Perl Archive Network) ou PPM qui ne fonctionne que pour les fenêtres Perl. Mais ces fichiers ne sont pas obligatoires pour commencer à coder en Perl.
En dehors de cette configuration de Windows, vous pouvez utiliser Windows 10 nouvelles fonctionnalités du sous-système Linux sur Windows et utilisez-le pour exécuter du code Perl
Premier programme Perl
Hello world!
Exemple Perl : Bonjour tout le monde
#!/usr/bin/perl -w #this is just a comment… print "Hello World";
Ne vous inquiétez pas si vous ne comprenez pas ce texte. Tout sera bientôt clair. Allez jeter un oeil par ligne :
#!/usr/bin/perl
Cela dit au Operating System pour exécuter ce fichier avec le programme situé dans /usr/bin/perl Certains IDE n'ont pas besoin de cette ligne. Si c'est indispensable, vous devez écrire ici un chemin vers votre interprète. Souviens-toi! Cette ligne spéciale doit être au début de votre programme et doit commencer par #! utiliser des avertissements ; Il s'agit d'une autre commande spéciale qui indique à l'interpréteur d'afficher tous les avertissements, c'est-à-dire -w qui active les avertissements globalement.
print "Hello World";
L'instruction d'impression écrit du texte à l'écran. Le point-virgule à la fin de la ligne indique à l'interpréteur Perl que l'instruction est terminée. Vous devez mettre un point-virgule à la fin de chaque instruction dans le code Perl. Notez le guillemet («). C'est nécessaire pour les instructions d'impression. Enregistrez le script ci-dessus sous firstprog.pl
On Windows
Si Strawberry est installé, vous pouvez simplement cliquer sur Exécuter. Vous pouvez également exécuter l'interface de ligne de commande et écrire sur la console :
C:\> perl path\firstprog.pl
ou, si perl.exe n'est pas sur votre chemin :
C:\> c:\perl\bin\perl.exe firstprog.pl
Sous Linux/Unix
Il vous suffit d'ouvrir le Terminal et d'écrire :
perl firstprog.pl
Si vous ne pouvez pas exécuter le programme, assurez-vous que vous êtes éligible pour l'exécuter. Tapez dans le terminal :
chmod +x firstprog.pl
Votre programme est maintenant exécutable et prêt à être exécuté. Pour exécuter, écrivez :
./firstprog
Installer les modules cpan moins
Les modules sont un ensemble de codes utilisés pour effectuer des tâches qui effectuent des opérations courantes dans plusieurs programmes. Si vous utilisez des modules Perl, vous n'avez pas besoin de réécrire les codes pour effectuer la même opération. Perl peut utiliser de telles bibliothèques externes de codes. L'une des meilleures bibliothèques est le CPAN. Cela signifie Comprehensive Perl Archive Network et contient une grande quantité de modules Perl que vous pouvez utiliser. C'est une communauté ou un réseau d'un grand nombre de développeurs qui contribuent à de tels modules. En installant le support des modules CPAN dans votre module perl, vous pouvez utiliser les modules CPAN et faciliter votre travail. La plupart des modules Perl sont écrits en Perl, certains utilisent XS (ils sont écrits en C) et nécessitent donc un compilateur C (il est facile d'obtenir cette configuration - ne paniquez pas. Les modules peuvent avoir des dépendances sur d'autres modules (presque toujours sur CPAN) et ne peuvent pas être installés sans eux (ou sans une version spécifique de ceux-ci). Il vaut la peine de lire attentivement la documentation des options ci-dessous. De nombreux modules sur CPAN nécessitent maintenant une version récente de Perl (version 5.8 ou supérieure). Installez cpanminus un script pour obtenir, décompresser, construire et installer des modules depuis CPAN pour faciliter l'installation d'autres modules (vous nous remercierez plus tard). Pour installer App-cpanminus modules perl, dans la ligne de commande tapez :
cpan App::cpanminus
cpan App :: cpanminus Assurez-vous d'avoir une connexion Internet pendant le téléchargement et l'installation des modules Perl.
Maintenant, installez n'importe quel module :
cpan –i <Module_Name>.
Voyons un exemple d'installation d'un module File::Data (C'est une interface pour accéder aux données de fichier).
Variable Perl
Maintenant, nous allons parler de variables. Vous pouvez imaginer une sorte de conteneur ressemblant à une variable qui contient une ou plusieurs valeurs. Une fois défini, le nom de la variable reste le même, mais la ou les valeurs changent encore et encore.
Il existe 3 types de variables :
Types de variables en Perl
Les plus simples sont les scalaires, et c'est notre sujet aujourd'hui
Variable scalaire
Ce type de variable contient une seule valeur.
Son nom commence par un signe dollar et un identifiant Perl (c'est le nom de notre variable).
Variable scalaire en Perl
Convention de nommage
Si vous êtes familier avec d’autres langages de programmation, vous savez qu’il existe certaines règles concernant la dénomination des variables. De même, Perl a trois règles pour nommer les scalaires.
- Tous les noms scalaires commenceront par un $. Il est facile de se rappeler de préfixer chaque nom avec $. Considérez-le comme un $scalaire.
- Comme PHP. après le premier caractère $, qui est spécial en Perl, les caractères alphanumériques, c'est-à-dire a à z, A à Z et 0 à 9, sont autorisés. Le caractère de soulignement est également autorisé. Utilisez le trait de soulignement pour diviser les noms de variables en deux mots. "Mais le premier caractère ne peut pas être un nombre"
- Même si les nombres peuvent faire partie du nom, ils ne peuvent pas apparaître immédiatement après $. Cela implique que le premier caractère après $ sera soit une lettre de l'alphabet, soit le trait de soulignement. Ceux qui viennent de C/C++ l’arrière-plan devrait être immédiatement capable de reconnaître la similitude. Exemples
Exemple Perl :
$var; $Var32; $vaRRR43; $name_underscore_23;
Cependant, ce ne sont pas des noms de variables scalaires légaux.
mohohoh # $ character is missing $ # must be at least one letter $47x # second character must be a letter $variable! # you can't have a ! in a variable name
La règle générale dit que lorsque Perl n'a qu'un seul élément de quelque chose, c'est un scalaire. Les scalaires peuvent être lus à partir d'appareils et nous pouvons les utiliser dans nos programmes.
Deux types de types de données scalaires
- Numbers
- String
Numbers:
Dans ce type de données scalaires on pourrait spécifier :
- des entiers, simplement des nombres entiers, comme 2, 0, 534
- nombres à virgule flottante, ce sont des nombres réels, comme 3.14, 6.74, 0.333
Remarque : En général, l'interpréteur Perl voit les entiers comme des nombres à virgule flottante. Par exemple, si vous écrivez 2 dans vos programmes, Perl le verra comme 2.0000
Littéraux entiers :
Il se compose d'un ou plusieurs chiffres, éventuellement précédés d'un plus ou d'un moins et contenant des traits de soulignement.
Exemples Perl :
0; -2542; 4865415484645 #this also can be written with underscores (for clarity) : 4_865_415_484_645
Comme vous pouvez le voir, ce n'est rien de spécial. Mais croyez-moi, c'est le type de scalaire le plus courant. Ils sont partout.
Littéraux à virgule flottante :
Il se compose de chiffres, éventuellement moins, d'un point décimal et d'un exposant.
Exemples Perl :
3.14; 255.000; 3.6e20; # it's 3.6 times 10 to the 20th -3.6e20; # same as above, but negative -3.6e-20; #it's negative 3.6 times 10 to the -20th -3.6E-20; #we also can use E – this means the same the lowercase version -3.6e-20
Représentation octale, hexadécimale et binaire :
C'est une alternative au système décimal. Permettez-moi de vous montrer la représentation octale, hexadécimale et binaire. Un petit tableau présente toutes les informations importantes sur ces styles étranges :
| Représentation | Base | Procédé par |
|---|---|---|
| Octal | 8 | 0 (zéro) |
| Hexadécimal | 16 | 0x |
| binaire | 2 | 0b |
Exemples Perl :
255; # 255 in decimal notation 0377; # 255 in octal notation 0xff; # 255 in hexadecimal notation 0b11111111; # 255 in binary notation
Toutes ces valeurs pour Perl signifient la même chose. Perl ne stocke pas les valeurs dans le même format. Il convertira en interne ces valeurs hexadécimales, binaires et octales en valeurs décimales.
L'affectation est l'opération la plus courante sur un scalaire, et elle est très simple. Perl utilise ce signe égal. Il prend une valeur de l'expression du côté droit et met cette valeur dans notre variable.
Jetons un coup d'œil à des exemples :
$size=15; # give $size value of 15 $y = -7.78; # give $y value of -7.78
De plus, vous pouvez mettre dans une variable non seulement un nombre, mais aussi une expression.
$z = 6 + 12 # give $z value of 18
String
Strings : C’est aussi un type de scalaire très simple.
La longueur maximale d'une chaîne en Perl dépend de la quantité de mémoire dont dispose l'ordinateur. Il n'y a pas de limite à la taille de la chaîne, n'importe quel nombre de caractères, symboles ou mots peut constituer vos chaînes. La chaîne la plus courte ne contient aucun caractère. Le plus long peut remplir toute la mémoire système. Les programmes Perl peuvent être entièrement écrits avec un jeu de caractères ASCII 7 bits. Perl vous permet également d'ajouter n'importe quel jeu de caractères 8 bits ou 16 bits. caractères non-ASCII dans les chaînes littérales. Perl a également ajouté la prise en charge d'Unicode UTF-8.
Comme les nombres, il existe deux types de chaînes différents :
- Littéraux de chaîne de guillemets simples
- Double guillemets des chaînes littérales
Littéraux de chaîne entre guillemets simples
Les guillemets simples sont utilisés pour encadrer les données que vous souhaitez prendre au pied de la lettre. Un petit exemple et tout devrait être clair :
Exemples Perl :
#!/usr/bin/perl $num = 7; $txt = 'it is $num'; print $txt;
Sortie :
c'est num $
Ici, en raison des guillemets simples, la valeur de $num n'est pas prise et les caractères littéraux '$','n', 'u' et 'm' sont ajoutés à la valeur de $txt.
Double-chaînes littérales entre guillemets
Double Les guillemets sont utilisés pour encadrer les données qui doivent être interpolées avant le traitement. Cela signifie que les caractères et les variables échappés ne sont pas simplement insérés littéralement dans les opérations ultérieures, mais sont évalués sur place. Les caractères d'échappement peuvent être utilisés pour insérer des sauts de ligne, des tabulations, etc.
Exemples Perl :
$num = 7; $txt = "it is $num"; print $txt;
Sortie :
c'est 7
Ici, en raison des guillemets doubles, la valeur de $num est ajoutée à la valeur de $txt
DoubleLes guillemets interpolent les variables scalaires et les variables de tableau, mais pas les hachages. D'un autre côté, vous pouvez utiliser des guillemets doubles pour interpoler des tranches de tableaux et de hachages.
Mystérieux \n
Considérez le programme suivant
Exemples Perl :
print "hello \n";
Sortie :
hello
Perl n'affiche pas seulement « bonjour\n », mais seulement « bonjour ». Pourquoi? Parce que '\n' est un signe spécial et signifie que vous souhaitez passer à une nouvelle ligne tout en affichant le texte dans votre programme. imprimer « bonjour\n nouvelle ligne » ; Question suivante : y a-t-il un autre signe spécial ? Oui, ils sont! Mais ne vous inquiétez pas, juste quelques-uns. Consultez le tableau ci-dessous
| Construire | Description |
|---|---|
| \n | nouvelle ligne |
| \r | retourner |
| \t | languette |
| \f | saut de page |
| \b | backspace |
| \a | cloche |
| \e | échapper |
| \ 007 | toute valeur octale ASCII (ici, 007 = cloche) |
| \x7f | n'importe quelle valeur hexadécimale (ici, 7f = supprimer) |
| \\ | barre oblique inverse |
| \ " | double citation |
| \l | lettre suivante en minuscule |
| \L | minuscules toutes les lettres suivantes jusqu'à \E |
| \u | lettre suivante en majuscule |
| \U | mettre en majuscule toutes les lettres suivantes jusqu'à \E |
| \E | Terminer \L, \U |
Je sais, il n'y en a pas « quelques-uns »… Mais croyez-moi, il faut savoir juste
Variable de chaînes
C'est la même opération que celle que l'on voit dans l'attribution des nombres. Perl récupère notre chaîne du côté droit du signe égal et place cette chaîne dans une variable.
Exemples Perl :
$string = 'tutorial'; # give $string the eight-character string 'tutorial' print $string; $string = $size + 3 ; # give $string the current value of $size plus 3 print $string; $string = $ string * 5; # multiplied $string by 5 print $string;
Sortie :
tutoriel315
Comme vous pouvez le voir, vous pouvez mettre des nombres et des chaînes dans les mêmes variables. Il n'y a pas de classe de variables.
Concaténation de chaînes (point) :
L'opérateur de concaténation "." unit deux ou plusieurs chaînes. Souviens-toi! Si la chaîne contient des guillemets, des retours chariot, des barres obliques inverses, tous ces caractères spéciaux doivent être échappés avec une barre oblique inverse.
Variable Perl ' ' Exemples :
#!/usr/bin/perl $a = "Tom is"; $b = "favorite cat"; $c = $a ." mother's ". $b; print $c;
Sortie :
Tom est le chat préféré de sa mère
Les cordes
"$a", "$b", est concaténé et stocké dans "$c" à l'aide du "." opérateur.
À la fin…
Conversion entre Numbers et chaînes :
Comme vous le savez, Perl convertit automatiquement les nombres en chaînes selon les besoins. Comment Perl sait-il ce dont nous avons besoin en ce moment ? C'est simple - tout dépend de l'opérateur (nous parlerons des opérateurs plus tard, maintenant, acceptez simplement qu'il y a beaucoup d'opérateurs, différents pour les nombres et les chaînes) Si un opérateur attend un nombre, Perl utilisera la valeur comme un nombre . Si un opérateur attend une chaîne, Perl utilisera la valeur comme chaîne. En d’autres termes, vous n’avez pas à vous soucier de ce type de conversion. Court exemple et tout devrait être clair :
Exemples Perl :
$string = "43"; $number = 28; $result = $string + $number; print $result;
Sortie :
71
la valeur de $string est convertie en entier et ajoutée à la valeur de $number.
Le résultat de l'addition, 71, est affecté à $result.
Portée d'une variable – Modificateurs d'accès
Nous pouvons déclarer un scalaire n’importe où dans le programme. Mais vous devez spécifier un modificateur d'accès
Il existe 3 types de modificateurs
- my
- locales
- nos
My : En utilisant ceci, vous pouvez déclarer n'importe quelle variable spécifique au sein du bloc. c'est-à-dire entre les accolades.
#!/usr/bin/perl
my $var=5;
if(1)
{
my $var_2 =$var;
}
print $var_2;
Aucune sortie
Le résultat du programme ne sera rien !
Dans l'exemple ci-dessus, vous verrez qu'il y a deux variables déclarées, l'une est à l'intérieur du bloc if ($var_2) et l'autre est à l'extérieur du bloc If ($var). La variable déclarée à l'extérieur du bloc sera accessible à if block mais la variable qui a été déclarée à l'intérieur de if block ne sera pas accessible au programme externe.
Local : en utilisant cela, nous pouvons en fait masquer les mêmes valeurs de variable en différentes valeurs sans réellement changer la valeur d'origine de la variable, supposons que nous ayons une variable $a pour laquelle la valeur est affectée à 5, vous pouvez réellement modifier la valeur de cette variable en re-déclarer la même variable en utilisant le mot-clé local sans modifier la valeur d'origine de la variable qui est 5. Voyons comment cela fonctionne avec un exemple.
#!/usr/bin/perl
$var = 5;
{
local $var = 3;
print "local,\$var = $var \n";
}
print "global,\$var = $var \n";
La sortie du programme ci-dessus sera de cette manière.
local, $var = 3
global, $var = 5
De cette façon, nous pouvons modifier la valeur de la variable sans affecter la valeur d'origine.
Notre : Une fois qu'une variable est déclarée avec le modificateur d'accès « notre », elle peut être utilisée dans l'ensemble du package. Supposons que vous ayez un module Perl ou un package test.pm qui a une variable déclarée avec la portée our. Cette variable est accessible dans tous les scripts qui utiliseront ce package.
Si vous êtes sérieux au sujet de la programmation en Perl, vous devriez commencer votre programme par
#! / usr / local / bin / perl
utiliser strict;
Cela vous aidera à écrire un code meilleur et plus propre. 'use strict' active le pragma strict qui vous fera déclarer vos variables avec mon mot-clé.
C'est une bonne pratique de programmation
#!/usr/local/bin/perl use strict; $var = 10; print "$var";
Résultat : erreur
#!/usr/local/bin/perl use strict; my $var = 10; print "$var";
Sortie :
10
Tableau Perl
Qu’est-ce que le tableau Perl ?
Un tableau est un type spécial de variable qui stocke les données sous forme de liste ; chaque élément est accessible à l'aide du numéro d'index qui sera unique pour chaque élément. Vous pouvez stocker des nombres, des chaînes, des valeurs flottantes, etc. dans votre tableau. Cela a l'air génial, alors comment créer un tableau en Perl ? En Perl, vous pouvez définir un tableau en utilisant le caractère '@' suivi du nom que vous souhaitez donner. Considérons la définition d'un tableau en Perl.
mon @array ;
C'est ainsi que nous définissons un tableau en Perl ; vous pensez peut-être à la manière dont nous devons y stocker des données. Il existe différentes manières de stocker des données dans un tableau. Cela dépend de la façon dont vous allez l'utiliser.
my @array=(a,b,c,d); print @array;
Sortie :
ABCD
Il s'agit d'un tableau contenant 4 éléments.
L'index du tableau commence à 0 et se termine à sa taille maximale déclarée, dans ce cas, la taille maximale de l'index est 3.
Exemple de tableau Perl
Vous pouvez également déclarer un tableau de la manière ci-dessus ; la seule différence est qu'il stocke les données dans un tableau en considérant un espace blanc comme délimiteur. Ici, qw() signifie mot de citation. L'importance de cette fonction est de générer une liste de mots. Vous pouvez utiliser qw de plusieurs manières pour déclarer un tableau.
@array1=qw/a b c d/;
@array2= qw' p q r s';
@array3=qw { v x y z};
print @array1;
print @array2;
print @array3;
Sortie :
abcdpqrsvxyz
Supposons que vous souhaitiez attribuer une valeur au 5th élément d’un tableau, comment allons-nous faire cela.
$tableau [4] = 'e';
Tableau séquentiel
Les tableaux séquentiels sont ceux dans lesquels vous stockez les données de manière séquentielle. Supposons que vous souhaitiez stocker 1 à 10 nombres ou alphabets az dans un tableau. Au lieu de taper toutes les lettres, vous pouvez essayer quelque chose comme ci-dessous :
@numbers= (1..10); print @numbers; #Prints numbers from 1 to 10;
Sortie :
12345678910
Taille du tableau Perl
Nous avons un tableau qui est déjà disponible, et vous ne savez pas quelle est la taille de ce tableau, alors quel est le moyen possible de le trouver.
@array= qw/a b c d e/; print $size=scalar (@array);
Pouvons-nous obtenir la taille d’un tableau sans utiliser de fonctions ? Oui nous pouvons.
@array= qw/a b c d e/; print $size=scalar (@array); print "\n"; print $size=$#array + 1; # $#array will print the Max Index of the array, which is 5 in this case
Sortie :
5
5
Tableau dynamique
La méthode ci-dessus pour déclarer un tableau est appelée tableaux statiques, où vous connaissez la taille d'un tableau.
Qu’est-ce que le tableau dynamique ?
Les tableaux dynamiques sont ceux que vous déclarez sans spécifier aucune valeur. Alors, quand exactement stockons-nous les valeurs dans ce tableau ? Simple, nous les stockons pendant l'exécution. Voici un programme simple pour cela.
Nous utiliserons certaines fonctions Perl intégrées pour effectuer cette tâche.
my $string="This is a kind of dynamic array";
my @array;
@array=split('a',$string);
foreach(@array)
{
print "$_ \n”;
# This is a special variable which stores the current value.
}
Sortie :
Ceci est
une sorte de dynamisme
micro
rr
y
La fonction split divise le contenu de la chaîne en un tableau en fonction du délimiteur qui lui est fourni. Cette fonction éliminera également le délimiteur de la chaîne, dans ce cas, il s'agit de « a » ;
Push, Pop, Shift, Unshift pour les tableaux Perl :
Ces fonctions peuvent être utilisées en Perl pour ajouter/supprimer des éléments d'un tableau.
- Perl Push : ajoute un élément de tableau à la fin d'un tableau existant.
- Perl Pop : supprime le dernier élément d'un tableau.
- Perl Shift: supprime le premier élément d'un tableau.
- Perl Unshift : ajoute un élément au début d'un tableau.
Voyons un exemple où nous pouvons utiliser les fonctions ci-dessous.
@days = ("Mon","Tue","Wed");
print "1st : @days\n";
push(@days, "Thu"); # adds one element at the end of an array
print "2nd when push : @days\n";
unshift(@days, "Fri"); # adds one element at the beginning of an array
print "3rd when unshift : @days\n";
pop(@days);
print "4th when pop : @days\n"; # remove one element from the last of an array.
shift(@days); # remove one element from the beginning of an array.
print "5th when shift : @days\n";
Sortie :
1er : Lun Mar Mer
2ème lors de la poussée : Lun Mar Mer Jeu
3ème lors du décalage : ven lun mar mer jeu
4ème quand pop : Ven Lun Mar Mer
5ème quand quart de travail : Lun Mar Mer
Hachages Perl
Pourquoi avons-nous besoin de Hash ?
Nous avons déjà découvert les scalaires et les tableaux dans les sections précédentes.
Que font exactement les scalaires ? Il ne stocke que des entiers et des chaînes.
À quoi servent exactement les tableaux ? Il s'agit d'une collection de scalaires, où vous accédez à chaque élément d'un tableau à l'aide d'indices. Mais est-ce une bonne idée d’utiliser un tableau lorsque vous avez des centaines et des milliers d’enregistrements ? Nous oublierons quel indice a quelle valeur. Pour surmonter cette situation, nous avons quelque chose comme le hachage Perl.
Que sont les hachages ?
Un hachage peut également contenir autant de scalaires que le tableau peut en contenir. La seule différence est que nous n’avons pas d’index mais plutôt des clés et des valeurs. Un hachage peut être déclaré en commençant par % suivi du nom du hachage. Voyons un exemple comment nous pouvons définir un hachage Perl et comment nous pouvons le différencier d'un tableau.
Prenons l'exemple de trois personnes et leurs âges sont représentés dans un tableau.
@array=('Sainath',23,'Krishna',24,'Shruthi',25); #This is how an array looks.
print @array;
Sortie :
Sainath33Krishna24Shruthi25
De cette façon, il est difficile de connaître l’âge individuel car nous devons nous souvenir à la fois des emplacements d’index du nom et de l’âge de toutes les personnes. C’est peut-être simple quand on a 3 noms, mais quand on en a 1000 ou plus ? Vous connaissez la réponse.
Nous pouvons surmonter ce problème en utilisant un hachage.
Exemple de hachage :
print %hash=( 'Sainath' => 23, 'Krishna' => 24, 'Shruthi' => 25); # This is how we create a hash.
print %hash=('Sainath',23,'Krishna',24,'Shruthi',25);# This way of assigning is called list.
Sortie :
Sainath33Krishna24Shruthi25Sainath33Krishna24Shruthi25
Nous avons maintenant déclaré un hachage, super !! Mais comment y accéder ou l’imprimer ? Chaque élément du hachage doit être accessible avec sa clé associée pour laquelle une valeur sera attribuée. Il existe donc un mappage un-un entre chacune des clés et des valeurs dans le hachage.
Pour imprimer l’âge d’une personne, il vous suffit de vous souvenir de son nom.
print $hash{'Krishna'}; # This how we should access a hash. Key enclosed within {}.
Vous vous êtes peut-être demandé pourquoi j'avais utilisé $hash{KeyName}, rappelez-vous qu'un hachage est encore une fois une collection de scalaires. Ainsi, nous pouvons utiliser $ qui représente un scalaire pour accéder à chaque élément de hachage.
Remarque : Chaque clé de hachage doit être unique, sinon elle remplacera votre valeur, qui a été attribuée précédemment.
Comment pouvons-nous attribuer un hachage à un autre hachage ? Simple, de la même manière que nous le faisons pour
Nous pouvons également imprimer le hash entier.
%hash=( 'Tom' => 23); %newHash=%hash; # Assigning hash to a new hashprint %newHash; print %newHash;
Sortie :
Tom23
Ajouter des hachages Perl
Comme vous pouvez le voir, nous avons déjà un hachage %newHash, et nous devons maintenant y ajouter plus d'entrées.
$newHash{'Jim'}=25;
$newHash{'John'}=26;
$newHash{'Harry'}=27;
print %newHash;
Sortie :
Jim25John26Harry27
Clé de suppression Perl
Vous souhaiterez peut-être supprimer une entrée d'un hachage. C'est ainsi que nous pouvons procéder.
delete $newHash{'Jim'};#This will delete an entry from the hash.
Supprimer est une fonction intégrée de Perl. Ici, nous verrons un exemple d'attribution d'un hachage à un tableau.
@array=%newHash; print "@array";
Remarque : chaque fois que vous imprimez un hachage ou lorsque vous stockez le hachage dans un tableau. L'ordre peut toujours différer. Ce n'est pas toujours pareil.
Nous pouvons attribuer uniquement les clés ou les valeurs d'un hachage à un tableau.
@arraykeys= keys(%newHash); @arrayvalues=values(%newHash); print "@arraykeys\n"; print "@arrayvalues\n"; # \n to print new line.
Pour supprimer toutes les entrées du hachage, nous pouvons directement attribuer le hachage à null.
%newHash=();# Cela redéfinira le hachage sans entrées.
Déclarations conditionnelles Perl
Nous pouvons utiliser des instructions conditionnelles en Perl. Alors, que sont les instructions conditionnelles ? Les instructions conditionnelles sont celles dans lesquelles vous vérifiez réellement que certaines circonstances sont satisfaites dans votre code.
Pensez à un exemple : vous achetez des fruits et vous n'aimez pas que le prix dépasse 100 dollars. La règle ici est donc de 100 dollars.
Perl prend en charge deux types d'instructions conditionnelles ; ils le sont si et moins.
Perl Si
Si le bloc de code sera exécuté, lorsque la condition est vraie.
my $a=5;
if($a==5)
{
print "The value is $a";
}
Sortie :
5
Perl si sinon
Cela semble bon. Pensons à une situation où $a n'est pas 5.
my $a=10;
if($a==5)
{
print "The values is $a ---PASS";
}
else
{
print "The value is $a ---FAIL";
}
Sortie :
La valeur est 10 —FAIL
De cette façon, nous ne pouvons contrôler qu’une seule condition à la fois. Est-ce une limitation ? Non, vous pouvez également contrôler diverses conditions en utilisant if… elsif… else.
Perl Sinon si
my $a=5;
if($a==6)
{
print "Executed If block -- The value is $a";
}
elsif($a==5)
{
print "Executed elsif block --The value is $a";
}
else
{
print "Executed else block – The value is $a";
}
Sortie :
Bloc elsif exécuté – La valeur est 5
Dans le cas ci-dessus, le bloc elsif sera exécuté car $a est égal à 5.
Il peut y avoir des situations dans lesquelles les blocs de code if et elsif échoueront. Dans ce scénario, le bloc de code else sera exécuté. Vous pouvez en fait éliminer la vérification du code else si vous n'aimez pas l'inclure.
Perl imbriqué si
Dans ce cas, vous pouvez utiliser le bloc de code if dans un autre bloc de code if.
my $a=11; #Change values to 11,2,5 and observe output
if($a<10){
print "Inside 1st if block";
if($a<5){
print "Inside 2nd if block --- The value is $a";
}
else{
print " Inside 2nd else block --- The value is $a";
}
}
else{
print "Inside 1st else block – The value is $a";
}
Sortie :
À l’intérieur du 1er bloc else – La valeur est 11
Exécutez le même code en modifiant la valeur de $a ; vous pouvez découvrir le reste.
Perl Sauf si
Vous avez déjà une idée de ce qui se passe (si la condition est vraie, le bloc de code sera exécuté). Sauf si est opposé à si, sauf si le bloc de code sera exécuté si la condition est fausse.
my $a=5;
unless($a==5)
{
print "Inside the unless block --- The value is $a";
}
else
{
print "Inside else block--- The value is $a";
}
Sortie :
À l’intérieur du 1er bloc else – La valeur est 5
Devinez quel sera le résultat. Tu as raison!!!!!. La sortie sera l’instruction print du bloc else. En raison de la condition sauf si le bloc de code est vrai, rappelez-vous que le bloc sauf si le bloc sera exécuté uniquement si la condition est fausse. Changez la valeur de $a et exécutez le code, vous verrez la différence.
Perl Utilisation de if
$a= " This is Perl";
if($a eq "SASSDSS"){
print "Inside If Block";
}
else
{
print "Inside else block"
}
Sortie :
À l'intérieur du bloc else
Utiliser à moins que
$a= " This is Perl";
unless($a eq "SASSDSS"){
print "Inside unless Block";
}
else
{
print "Inside else block"
}
Sortie :
À l'intérieur sauf si bloquer
Boucles Perl – Structures de contrôle
Perl prend en charge des structures de contrôle similaires à d'autres langages de programmation. Perl prend en charge quatre types de structures de contrôle pour, foreach, while et jusqu'à. Nous utilisons ces instructions pour exécuter du code à plusieurs reprises.
Pour la boucle Perl
Car le bloc de code s’exécutera jusqu’à ce que la condition soit satisfaite. Prenons un exemple de la façon dont Perl boucle un tableau.
my @array=(1..10);
for(my $count=0;$count<10;$count++)
{
print "The array index $count value is $array[$count]";
print "\n";
}
Sortie :
La valeur de l'indice 0 du tableau est 1
La valeur de l'indice 1 du tableau est 2
La valeur de l'indice 2 du tableau est 3
La valeur de l'indice 3 du tableau est 4
La valeur de l'indice 4 du tableau est 5
La valeur de l'indice 5 du tableau est 6
La valeur de l'indice 6 du tableau est 7
La valeur de l'indice 7 du tableau est 8
La valeur de l'indice 8 du tableau est 9
La valeur de l'indice 9 du tableau est 10
Ici, dans l'expression for (), de nombreuses instructions sont incluses. Il y a une signification pour chacun d'eux.
pour (initialisation ; condition ; incrémentation)
Voici une autre façon d'utiliser for.
for(1..10)
{
print "$_ n";
print "\n";
}
Sortie :
1n
2n
3n
4n
5n
6n
7n
8n
9n
10n
Perl pour chaque
L'instruction for each peut être utilisée de la même manière que for ; la principale différence est que nous n'avons aucune vérification de condition ni incrémentation.
Prenons le même exemple avec foreach perl.
my @array=(1..10);
foreach my $value (@array)
{
print " The value is $value\n";
}
Sortie :
La valeur est 1
La valeur est 2
La valeur est 3
La valeur est 4
La valeur est 5
La valeur est 6
La valeur est 7
La valeur est 8
La valeur est 9
La valeur est 10
Foreach prend chaque élément d'un tableau et attribue cette valeur à $var pour chaque itération. Nous pouvons également utiliser $_ pour la même chose.
my @array=(1..10);
foreach(@array)
{
print " The value is $_ \n"; # This is same as the above code.
}
Sortie :
La valeur est 1
La valeur est 2
La valeur est 3
La valeur est 4
La valeur est 5
La valeur est 6
La valeur est 7
La valeur est 8
La valeur est 9
La valeur est 10
Cela semble bon pour accéder aux tableaux. Qu'en est-il des hachages, comment pouvons-nous obtenir des clés de hachage et des valeurs en utilisant foreach ?
Nous pouvons utiliser foreach pour accéder aux clés et aux valeurs du hachage en le bouclant.
my %hash=( 'Tom' => 23, 'Jerry' => 24, 'Mickey' => 25);
foreach my $key (keys %hash)
{
print "$key \n";
}
Sortie :
Mickey
Tom
Jerry
Vous vous demandez peut-être pourquoi nous avons utilisé des clés dans foreach(). Keys est une fonction intégrée de Perl où nous pouvons accéder rapidement aux clés du hachage. Et les valeurs ? Nous pouvons utiliser la fonction de valeurs pour accéder aux valeurs du hachage.
my %hash=( 'Tom' => 23, 'Jerry' => 24, 'Mickey' => 25);
foreach my $value(values %hash) # This will push each value of the key to $value
{
print " the value is $value \n";
}
Sortie :
la valeur est 24
la valeur est 23
la valeur est 25
Perl tandis que
La boucle Perl While est une structure de contrôle, dans laquelle le bloc de code sera exécuté jusqu'à ce que la condition soit vraie.
Le bloc de code ne se terminera que si la condition est fausse.
Prenons un exemple pour la boucle Perl While.
Voici un problème qui nécessitera une saisie de la part de l'utilisateur et ne se terminera pas avant le numéro fourni comme « 7 ».
#!/usr/bin/perl
$guru99 = 0;
$luckynum = 7;
print "Guess a Number Between 1 and 10\n";
$guru99 = <STDIN>;
while ($guru99 != $luckynum)
{
print "Guess a Number Between 1 and 10 \n ";
$guru99 = <STDIN>;
}
print "You guessed the lucky number 7"
Sortie :
Devinez un nombre entre 1 et 10
9
Devinez un nombre entre 1 et 10
5
Devinez un nombre entre 1 et 10
7
Vous avez deviné le chiffre porte-bonheur 7
Dans l'exemple ci-dessus, la condition while ne sera pas vraie si nous saisissons une entrée autre que « 7 ».
Si vous voyez comment while fonctionne ici, le bloc de code ne s'exécutera que si la condition dans while est vraie.
Perl faire pendant ce temps
La boucle Do while s'exécutera au moins une fois même si la condition dans la section while est fausse.
Prenons le même exemple en utilisant do while.
$guru99 = 10;
do {
print "$guru99 \n";
$guru99--;
}
while ($guru99 >= 1);
print "Now value is less than 1";
Sortie :
10
9
8
7
6
5
4
3
2
1
Maintenant, la valeur est inférieure à 1
Perl jusqu'à
Le bloc de code Jusqu'à ce que soit similaire à sauf dans une instruction conditionnelle. Ici, le bloc de code ne s'exécutera que si la condition du bloc jusqu'à ce qu'elle soit fausse.
Prenons le même exemple que nous avons utilisé dans le cas d'un certain temps.
Voici un problème qui nécessitera une saisie de la part de l'utilisateur et ne se terminera que lorsque le nom sera fourni autre que « sai ».
print "Enter any name \n";
my $name=<STDIN>;
chomp($name);
until($name ne 'sai')
{
print "Enter any name \n";
$name=<STDIN>;
chomp($name);
}
Sortie :
Entrez n'importe quel nom sai
Perl faire jusqu'à ce que :
Do Until ne peut être utilisé que lorsque nous avons besoin qu'une condition soit fausse, et elle doit être exécutée au moins une fois.
print "Enter any name \n";
my $name=<STDIN>;
chomp($name);
do
{
print "Enter any name \n";
$name=<STDIN>;
chomp($name);
}until($name ne 'sai');
Sortie :
Entrez n’importe quel nom Howard
Entrez n’importe quel nom Sheldon
Entrez n'importe quel nom sai
Exécutez des exemples de codes while, do-while, Until et do-until pour voir la différence.
Perl Operator
Qu’est ce qu' Operator?
OperaLes indicateurs en langage informatique indiquent une action qui peut être effectuée sur un ensemble de variables ou de valeurs que l'ordinateur peut comprendre. Perl a incorporé la plupart des Operaopérateurs du langage C. Perl possède de nombreux opérateurs par rapport aux autres langages de programmation. OperaLes opérateurs sont classés en opérateurs arithmétiques, logiques, relationnels et d'affectation.
Arithmétique Operateurs :
Les opérateurs arithmétiques sont ceux qui peuvent être utilisés pour effectuer certaines opérations mathématiques de base. Ces opérateurs arithmétiques sont des opérateurs binaires où nous avons besoin de deux arguments pour effectuer une opération de base. Nous pouvons également utiliser des opérateurs unaires pour d'autres opérations de base ; vous pouvez voir la différence dans les exemples ci-dessous.
| Operator | Description | Exemple |
|---|---|---|
|
+ |
Opération d'addition utilisée pour ajouter deux valeurs ou variables détenir des valeurs |
$x=5+6 ; # ou $y=6 ; $z=$x+$y; |
|
- |
Opérateur de soustraction utilisé pour soustraire deux valeurs ou variables contenant des valeurs |
$x=6-5 ; # ou $y=6 ; $z=$x-$y ; |
|
* |
Opérateur de multiplication utilisé pour multiplier deux valeurs ou variables contenant des valeurs |
$x=6*5 ; # ou $y=6 ; $z=$x*$y; |
|
/ |
Opérateur de division utilisé pour diviser deux valeurs ou variables contenant des valeurs |
$x=36/6 ; # ou $y=6 ; $z=$x/$y; |
|
** |
L'opérateur exponentiel utilisé pour fournir l'exposant et obtenir la valeur. Ex : 22 = 43 = 27 |
$x=5**5 ; # ou $x=4 ; $y=2 ; $z=$x**$y; |
|
% |
Opérateur de module utilisé pour obtenir le rappel lors de la division de deux valeurs ou variables contenant des valeurs |
$x=5%2 ; # ou $x=10 ; $y=2 ; $z=$x % $y; |
|
++ |
Opérateur d'addition unaire pour incrémenter la valeur d'une variable de 1 |
$x=5 ; $x++ ; Or ++$x; |
|
- |
Opérateur de soustraction unaire pour décrémenter la valeur d'une variable de 1 |
$x=5 ; $x- ; # post décrémentation Or –$x;# pré-décrémentation |
Exemple pour effectuer toutes les opérations ci-dessus.
my $x=10;
my $y=2;
my $z;
$z=$x+$y;
print ("Add of $x and $y is $z \n");
$z=$x-$y;
print ("Sub of $x and $y is $z \n");
$z=$x*$y;
print ("Mul of $x and $y is $z \n");
$z=$x/$y;
print ("Div of $x and $y is $z \n");
$z=$x**$y;
print ("Exp of $x and $y is $z \n");
$z=$x%$y;
print ("Mod of $x and $y is $z \n");
Sortie :
La somme de 10 et 2 fait 12
Le sous de 10 et 2 est 8
Mul de 10 et 2 est 20
Div de 10 et 2 est 5
L'exp de 10 et 2 est de 100
Le mod de 10 et 2 est 0
Affectation Operateurs :
Les opérateurs d'affectation attribuent simplement des valeurs aux variables, mais il y a encore une chose dont nous devons nous rappeler ici : les opérateurs d'affectation effectueront également des opérations arithmétiques et attribueront la nouvelle valeur à la même variable sur laquelle l'opération est effectuée.
| Operator | Description | Exemple |
|---|---|---|
|
+= |
Opérateur d'addition utilisé pour ajouter et attribuer la valeur à la même variable |
$x=4 ; $x+=10 ; |
|
-= |
Opérateur de soustraction utilisé pour soustraire et attribuer la valeur à la même variable |
$x=4 ; $x-=10 ; |
|
*= |
Opérateur de multiplication utilisé pour ajouter et attribuer la valeur à la même variable |
$x=4 ; $x*=10 ; |
|
/= |
Opérateur de division utilisé pour diviser et attribuer la valeur à la même variable |
$x=4 ; $x/=10 ; |
|
** = |
Opérateur exponentiel utilisé pour obtenir l'exposant et attribuer la valeur à la même variable |
$x=4 ; $x**=10 ; |
|
%= |
Opérateur de module utilisé pour obtenir un rappel lors de la division et attribuer la valeur à la même variable |
$x=10 ; $x%=4 ; |
Exemple pour effectuer toutes les opérations ci-dessus.
my $x=10;
$x+=5;
print("Add = $x\n");
$x-=5;
print("Sub= $x\n");
$x*=5;
print("Mul = $x\n");
$x/=5;
print("Div = $x\n");
Sortie :
Ajouter = 15
Sous = 10
Mul = 50
Div = 10
Logique et Relationnel Operateurs :
Perl utilise des opérateurs logiques pour comparer des nombres et des chaînes. La plupart du temps, les opérateurs logiques sont utilisés dans les instructions conditionnelles.
Logique et Relationnel Operators en Perl
| Operator | Description |
|---|---|
|
==ou équation |
OperaTor utilisé pour vérifier si les deux variables sont égales |
|
!=Ou ne |
OperaTor utilisé pour vérifier si les deux variables ne sont pas égales |
|
> ou GT |
OperaTor utilisé pour vérifier si A est supérieur à B |
|
<ou lt |
OperaTor utilisé pour vérifier si A est inférieur à B |
|
>=ou ge |
OperaTor utilisé pour vérifier si A est supérieur ou égal à B |
|
<=ou le |
OperaTor utilisé pour vérifier si A est inférieur ou égal à B |
|
|| ou ou |
OperaTor utilisé pour vérifier que A ou B détient la valeur |
|
&&ou et |
OperaTor utilisé pour vérifier que A et B détiennent la valeur |
Prenons un exemple où nous pouvons expliquer tous les scénarios.
my $x=5;
my $y=5;
if($x == $y){
print ("True -- equal $x and $y \n");
}
else{
print ("False -- not equal $x and $y\n");
}
$x=6;
$y=7;
if($x != $y){
print ("True -- not equal $x and $y\n");
}
else{
print ("False -- equal $x and $y\n");
}
if($y > $x){
print ("True -- $y greater than $x\n");
}
else{
print ("False -- $y greater than $x\n");
}
if($x < $y){
print ("True -- $x less than $y\n");
}
else{
print ("False -- $x less than $y\n");
}
if($x <= $y){
print ("True -- $x less than $y\n");
}
else{
print ("False -- $x less than $y\n");
}
if($y >= $x){
print ("True -- $y greater than $x\n");
}
else{
print ("False -- $y greater than $x\n");
}
Sortie :
Vrai — égal à 5 et 5
Vrai — différent de 6 et 7
Vrai - 7 supérieur à 6
Vrai - 6 de moins que 7
Vrai - 6 de moins que 7
Vrai - 7 supérieur à 6
Vous pouvez voir des exemples d’opérateurs logiques dans les sections suivantes.
Variables spéciales Perl
Que sont les variables spéciales Perl ?
Les variables spéciales en Perl sont celles qui ont une signification prédéfinie. Ces variables sont indiquées par des symboles de nom réel ou de ponctuation. Nous avons une variable spéciale pour toutes les variables prises en charge par Perl, telles que les variables spéciales scalaires, les variables spéciales de tableau, les variables spéciales de hachage. La plupart des variables spéciales que nous utilisons sont des scalaires.
Lorsque nous voulons utiliser la variable spéciale avec son nom, nous devons alors charger un module Perl « utiliser l'anglais » pour dire explicitement à l'interpréteur Perl que nous allons utiliser des variables spéciales en utilisant son nom.
Variables spéciales scalaires
| Variable | Description |
|---|---|
|
$_$ARG |
Il s'agit de la variable par défaut qui stocke les valeurs actuelles. |
|
0 $ ou $PROGRAM_NAME |
Stocke le nom de fichier du script Perl. |
|
$/ |
Le séparateur d'enregistrement d'entrée, il a une valeur par défaut de '\n' qui est un caractère de nouvelle ligne |
|
$. |
Contient le numéro de ligne actuel du fichier en cours de lecture |
|
$, |
Séparateur de champ de sortie, il est principalement utilisé par l'instruction print(). Par défaut, la valeur de ceci est définie sur 0, nous pouvons modifier la valeur de cette variable. |
|
$\ |
Séparateur d'enregistrement en sortie, la valeur de cette variable sera vide ; nous pouvons lui attribuer n'importe quelle valeur, qui sera utilisée par l'instruction print() lors de l'impression de la sortie. |
|
$# |
Cette variable est utilisée pour le format de sortie lors de l'impression des nombres. |
|
$%$FORMAT_PAGE_NUMBER |
Contiendra le numéro de page actuel du fichier lu. |
|
$=$FORMAT_LINES_PER_PAGE |
Contiendra la longueur actuelle de la page du fichier lu. |
|
$-$FORMAT_LINES_LEFT |
Contient la valeur du nombre de lignes restant à imprimer à partir de la page. |
|
$~$FORMAT_NAME |
Nom du format : contient le format de la sortie actuellement sélectionnée, par défaut le nom du descripteur de fichier. |
|
$^$FORMAT_TOP_NAME |
Contient la valeur du format d'en-tête du gestionnaire de fichiers, par défaut la valeur sera _TOP suivi du nom du descripteur de fichier. |
|
$|$OUTPUT_AUTOFLUSH |
La valeur par défaut est zéro ; ceci est utilisé pour vider le tampon de sortie après chaque write() ou print(). |
|
$$ |
Contiendra le numéro du processus en cours d’exécution de l’interpréteur Perl. |
|
$? |
Code d'état : Pipe et appel système. L'état de retour de la commande exécutée. |
|
MATCH $&$ |
Utilisé dans les expressions régulières, cela contiendra une chaîne de la dernière correspondance de modèle réussie. |
|
$`$PREMATCH |
Utilisé dans les expressions régulières, cela contiendra la chaîne précédée de la dernière correspondance de modèle réussie. |
|
$'$APRÈS LE MATCH |
Utilisé dans les expressions régulières, cela contiendra une chaîne suivie de la dernière correspondance de modèle réussie. |
|
$+$LAST_PAREN_MATCH |
Contient la chaîne du dernier crochet correspondant à la dernière recherche de modèle. |
|
$ |
1$, 2$, 3$…. Contient les valeurs du modèle correspondant dans l’ordre. |
|
$[ |
Premier index : Array, une sous-chaîne. |
|
$] |
Une version de Perl. |
|
$ » |
Le séparateur utilisé pour les éléments de la liste, par défaut, est un espace. |
|
$; |
Séparateur d'indice utilisé dans les tableaux multidimensionnels |
|
$! |
Dans un contexte numérique, imprime le numéro d'erreur. Dans un contexte de chaîne, imprimez l'erreur. |
|
$@ |
Contiendra les informations d'erreur de syntaxe, utilisées lorsque eval() est utilisé. |
|
$< |
Contient le véritable UID (identifiant utilisateur) du processus exécutant le script. |
|
$> |
Contient l’UID effectif du processus exécutant le script. |
|
$( |
Contient le véritable GID (identifiant de groupe) du processus exécutant le script. |
|
$) |
Contient le GID effectif du processus exécutant le script. |
|
$^D$DÉBOGAGE |
Contient la valeur actuelle des indicateurs de débogage. |
|
$^C |
Contient la valeur actuelle de l'indicateur lorsque le commutateur de ligne de commande –c est utilisé. |
|
$^F |
Le descripteur de fichier système maximum, par défaut, est défini sur 2 |
|
$^I$INPLACE_EDIT |
Contient la valeur du commutateur de ligne de commande –i. |
|
$^M |
Un pool de mémoire spécial peut être utilisé lorsque le script Perl s'arrête avec une erreur de mémoire insuffisante. |
|
$^O$NOMOSI |
OperaLes informations système sont stockées. « Linux » pour les systèmes Linux, « mswin32 » pour Windows systèmes. |
|
$^T$TEMPS DE BASE |
L'heure à laquelle les scripts s'exécutent en secondes. |
|
$^W$AVERTISSEMENT |
La valeur actuelle du commutateur de ligne de commande –w. Interrupteur d'avertissement. |
|
$ARGV |
Nom du fichier actuel, lorsque <> est utilisé. |
Variables spéciales du tableau :
| Variable | Description |
|---|---|
|
@INC |
Contient une liste de chemins où les modules ou scripts de la bibliothèque Perl peuvent être consultés lors de l'exécution du script actuel. Ce @INC est utilisé par les instructions use et require pour examiner ces chemins pour les modules de bibliothèque. |
|
@ARGV |
Stocke les arguments de ligne de commande transmis. |
|
@_ |
Utilisé dans les sous-programmes, lors de la transmission des paramètres aux sous-programmes. |
|
@F |
Il s'agit du tableau dans lequel les lignes d'entrée sont stockées lors de la division automatique –a (le commutateur de ligne de commande est utilisé). |
Variables spéciales de hachage :
| Variable | Description |
|---|---|
|
%INC. |
Le nom du fichier sera les clés ; les valeurs seront le chemin d’accès à ces fichiers. Utilisé par do, use et require. |
|
%ENV |
Variables environnementales du système. |
|
%SIG |
Signals gestionnaire. |
Expression régulière Perl
Qu’est-ce que l’expression régulière ?
L'expression régulière Perl est suffisamment puissante pour faire correspondre les modèles de chaînes au sein d'une instruction ou d'un groupe d'instructions. Les expressions régulières sont principalement utilisées dans l'analyse de texte, la correspondance de modèles et bien plus encore en fonction des besoins. Nous avons certains opérateurs, qui sont spécialement utilisés par la liaison de modèles d'expressions régulières =~ et !~, ce sont des opérateurs de test et d'affectation.
Expression régulière Operajeudi
Expression régulière Operators en Perl
- Correspondance Perl — m//
- Substitut Perl – s///
- Translittération Perl – tr///
Avant d'aller plus loin, nous devons connaître quelques choses sur les expressions régulières ; il y a certaines choses comme les méta-caractères, les caractères génériques dans la syntaxe Perl Regex.
| Carboniser | Sens |
|---|---|
|
\ |
Spécial ou devis |
|
* |
Faites correspondre 0 caractère ou plus |
|
+ |
Faites correspondre 1 caractère ou plus |
|
? |
Faire correspondre 0 ou 1 caractère |
|
| |
Peut être utilisé pour correspondre à des modèles alternatifs |
|
() |
Utilisé pour stocker le motif correspondant |
|
[] |
Un ensemble de caractères peut être transmis. Spécifiquement utilisé pour les chiffres et les alphabets. |
|
{} |
Utilisé pour fournir le nombre de fois où le match peut être effectué. |
|
^ |
Début de chaîne |
|
$ |
Fin de chaîne |
|
\w |
Utilisé pour correspondre à un seul caractère ou mot pouvant être alphanumérique, y compris « _ » |
|
\W |
Correspond à tout ce qui n'est pas alphanumérique |
|
\s |
Utilisé pour faire correspondre les espaces |
|
\S |
Faire correspondre n'importe quoi d'autre que des espaces |
|
\d |
Faites correspondre les numéros. Pas de valeurs décimales ni de valeurs négatives |
|
\D |
Faites correspondre autre chose que des chiffres. |
|
\t |
Espace de tabulation de correspondance |
|
\n |
Faire correspondre la nouvelle ligne |
Les éléments ci-dessus représentent l'ensemble de caractères qui peuvent être utilisés lors de la correspondance de modèles.
Voyons quelques exemples.
Considérons une situation dans laquelle l'utilisateur fournit une entrée lors de l'exécution du script et nous souhaitons vérifier si l'utilisateur a entré un nom en entrée ou non. Nous devons écrire une syntaxe d'expression régulière pour extraire votre nom et l'imprimer.
my $userinput="Guru99 Rocks";
if($userinput=~m/.*(Guru99).*/)
{
print "Found Pattern";
}
else
{
print "unable to find the pattern";
}
Sortie :
Modèle trouvé
Ici, nous avons écrit l'expression régulière sous la forme /.*(Guru99).*/.* qui correspond à tous les caractères d'une chaîne. UN '.' en Perl, la correspondance regex fait référence à n'importe quel caractère, y compris l'espace.
Voyons comment exactement nous pouvons construire une Regex.
Prenons un exemple d'une chaîne de plusieurs mots et chiffres et de symboles spéciaux comme celui-ci « Bonjour à tous, voici mon numéro : +91-99298373639 » ;
Regex : /^\w+\s\w+\s\w+\s\w+\s\w+\s\w+\:\+\d+\-\d+/i
Espace mot espace mot espace mot espace mot espace mot espace mot caractère spécial : espace caractère spécial+chiffres caractère spécial –chiffres.
Correspondance Perl Operajeudi
Les opérateurs de correspondance sont utilisés pour faire correspondre une chaîne dans une instruction ou dans une variable.
my $var="Hello this is perl";
if($var=~m/perl/)
{
print "true";
}
else
{
print "False";
}
Sortie :
oui
Ce petit code affichera « vrai », car la correspondance de modèle Perl identifie la chaîne dans une variable. Fondamentalement, Perl recherche le texte fourni dans // tout au long de la chaîne, même s'il le trouve à un seul endroit, il renverra « vrai ». Le modèle peut être n'importe où dans la variable. Nous pouvons essayer de remplacer =~ par !~ pour voir la différence entre ces deux opérateurs.
Substitution Perl Operator
Cet opérateur peut être utilisé pour rechercher et remplacer n'importe quel caractère par null ou un autre caractère.
my $a="Hello how are you"; $a=~s/hello/cello/gi; print $a;
Sortie :
violoncelle, comment vas-tu
Remarque : Nous pouvons également utiliser n'importe quelle chaîne de correspondance de modèle comme nous l'avons fait précédemment dans cet opérateur de substitution. Ici, nous avons utilisé 'gi', g-globalement, i-ignorer la casse.
Traduction Perl Operator
Ceci est similaire à Substitution, mais il n'utilise aucune expression régulière Perl, nous pouvons plutôt transmettre directement la valeur ou un mot que nous voulons remplacer.
my $a="Hello how are you"; $a=~tr/hello/cello/; print $a;
Sortie :
Bonjour vache, es-tu
E/S de fichier Perl
Perl a été conçu pour manipuler efficacement les fichiers et les opérations d'E/S. Le principal avantage de Perl réside dans l'analyse et la gestion des fichiers. Il existe de nombreuses fonctions et opérateurs intégrés utilisés lors de la gestion des fichiers en Perl.
Fondamentalement, les opérations sur les fichiers effectuées avec Perl sont effectuées à l'aide de FILEHANDLE. Nous devons définir ce FILEHANDLE lors de l'ouverture d'un fichier en lecture ou en écriture.
Dans ce didacticiel de script Perl, vous apprendrez-
Perl Ouvrir un fichier
Nous pouvons ouvrir un fichier en utilisant la fonction open() disponible en Perl.
open(FILEHANDLE, "filename or complete path of the file");
Maintenant qu’on a ouvert un dossier, maintenant une question se pose. Est-ce pour lire ou écrire ?
Fichier de lecture Perl et fichier d'écriture Perl
Perl possède certains modes qui doivent être utilisés pour lire, écrire ou ajouter un fichier.
Read – open(my $fh,"<filename or complete path of the file"); Write – open(my $fh,">filename or complete path of the file"); Append – open(my $fh,">>filename or complete path of the file");
Quelques exemples de lecture d'un fichier :
Considérons que nous avons un fichier Perl portant le nom file.txt et contenant quelques lignes de texte. Nous devons ouvrir ce fichier et l'imprimer.
open(FH,"<file.txt");
while(<FH>) # Looping the file contents using the FH as a filehandle.
{
print "$_";
}
close FH;
or
open(FH,"<file.txt");
my @content=<FH>; # specifying the input of the array is FH.
foreach(@content)
{
print "$_";
}
close FH;
Cela imprimera le contenu du fichier sur l’écran de sortie.
Maintenant, nous allons écrire un programme pour créer et écrire des données dans un fichier Perl.
open(FH,">test.txt"); my $var=<>; print FH $var; close FH;
Cela écrira l'entrée fournie pendant l'exécution et créera un fichier test.txt qui contiendra l'entrée.
La méthode ci-dessus essaiera toujours de créer un fichier nommé test.txt et écrit l'entrée dans le fichier ; nous écrirons la même chose pour ajouter le fichier.
open(FH,">>test.txt"); my $var=<>; print FH $var; close FH;
| Modes | Description |
|---|---|
|
< |
Lire |
|
+< |
Lit et écrit |
|
> |
Crée, écrit et tronque |
|
+> |
Lire, écrire, créer et tronquer |
|
>> |
Écrit, ajoute et crée |
|
+>> |
Lire, écrire, ajouter et créer |
Maintenant, nous devons voir comment lire, écrire et ajouter des fichiers à l'aide d'exemples de base.
Nous verrons quelques exemples supplémentaires et d'autres fonctions qui aident à mieux comprendre les fichiers.
Perl Tell
Cette méthode renverra la position actuelle de FILEHANDLER en octets si elle est spécifiée, sinon elle considérera la dernière ligne comme position.
open(FH, "test.pl");
while(<FH>)
{
$a=tell FH;
print "$a";
}
Recherche Perl
La fonction Seek est similaire à l’appel système fseek. Cette méthode est utilisée pour positionner le pointeur de fichier vers un emplacement spécifique en spécifiant les octets suivis soit du début du pointeur de fichier, soit de la fin du pointeur de fichier.
seek FH, bytes, WHENCE;
WHENCE est la position du pointeur de fichier pour démarrer. Zero le définira depuis le début du fichier.
Exemple : laissez input.txt contenir des données telles que "Bonjour, c'est mon monde".
open FH, '+<','input.txt'; seek FH, 5, 0; # This will start reading data after 5 bytes. $/ = undef; $out = <FH>; print $out; close FH;
Sortie :
Ceci est mon univers
Perl Dissocier
Dissocier est utilisé pour supprimer le fichier.
unlink("filename or complete file path");
Gestion des répertoires :
Nous pouvons également gérer des répertoires à travers lesquels nous pouvons gérer plusieurs fichiers.
voyons comment ouvrir un répertoire. Nous pouvons utiliser les méthodes opendir et readdir.
opendir(DIR,"C:\\Program Files\\"); #DIR is the directory handler.
while(readdir(DIR)) # loop through the output of readdir to print the directory contents.
{
print "$_\n";
}
closedir(DIR); #used to close the directory handler.
or
opendir(DIR,"C:\\Program Files\\");
@content=readdir(DIR);
foreach(@content)
{
print "$_\n";
}
closedir(DIR);
Cela imprimera tous les fichiers disponibles dans ce répertoire.
Tests de fichiers Perl et leur signification
|
-r |
Pour vérifier si le fichier/répertoire est lisible par l'utilisateur/groupe actuel |
|
-w |
Pour vérifier si le fichier/répertoire est accessible en écriture par l'utilisateur/groupe actuel |
|
-x |
Pour vérifier si le fichier/répertoire est exécutable par l'utilisateur/groupe actuel |
|
-o |
Pour vérifier si le fichier/répertoire appartient à l'utilisateur actuel |
|
-R |
Pour vérifier si le fichier/répertoire est lisible par cet utilisateur/groupe réel |
|
-W |
Pour vérifier si le fichier/répertoire est accessible en écriture par cet utilisateur/groupe réel |
|
-X |
Pour vérifier si le fichier/répertoire est exécutable par ce véritable utilisateur/groupe |
|
-O |
Pour vérifier si le fichier/répertoire appartient à cet utilisateur réel |
|
-e |
Pour vérifier si le nom du fichier/répertoire existe |
|
-z |
Pour vérifier si le fichier existe et a une taille nulle (toujours faux pour les répertoires) |
|
-f |
Pour vérifier si l'entrée est un fichier brut |
|
-d |
Pour vérifier si Entry est un répertoire |
|
-l |
Pour vérifier si Entry est un lien symbolique |
|
-S |
Pour vérifier si Entry est un socket |
|
-p |
Pour vérifier si Entry est un tube nommé (un « FIFO ») |
|
-b |
Pour vérifier si Entry est un fichier spécial bloc (comme un disque montable) |
|
-c |
Pour vérifier si Entry est un fichier spécial de caractère (comme un périphérique d'E/S) |
|
-u |
Pour vérifier si le fichier ou le répertoire est setuid |
|
-g |
Pour vérifier si le fichier ou le répertoire est setgid |
|
-k |
Pour vérifier si le fichier ou le répertoire a le bit collant défini |
|
-t |
Le descripteur de fichier donné est un TTY (comme pour la fonction système isatty(), les noms de fichiers ne peuvent pas être testés par ce test) |
|
-T |
Pour vérifier si le fichier ressemble à un fichier « texte » |
|
-B |
Pour vérifier si le fichier ressemble à un fichier « binaire » |
|
-M |
Pour vérifier l'âge de modification (mesuré en jours) du fichier |
|
-A |
Pour vérifier l'âge d'accès (mesuré en jours) du fichier |
|
-C |
Pour vérifier l'âge de modification de l'inode (mesuré en jours) du fichier |
Sous-programme Perl
Qu'est-ce que le sous-programme?
Sous-programmes sont similaires aux fonctions d’autres langages de programmation. Nous avons déjà utilisé certaines fonctions intégrées comme print, chomp, chop, etc. Nous pouvons écrire nos propres sous-programmes en Perl. Ces sous-programmes peuvent être écrits n'importe où dans le programme ; il est préférable de placer les sous-programmes soit au début, soit à la fin du code.
Exemple de sous-programmes
sub subroutine_name
{
Statements…; # this is how typical subroutines look like.
}
Maintenant que nous savons comment écrire un sous-programme, comment y accéder ?
Nous devons accéder ou appeler un sous-programme en utilisant le nom du sous-programme préfixé par le symbole « & ».
sub display
{
print "this is a subroutine";
}
display(); # This is how we call a subroutine
Passer les paramètres Perl et les arguments Perl
Des sous-programmes ou des fonctions Perl sont écrits pour y placer le code réutilisable. La plupart du code réutilisable nécessite que des paramètres soient transmis au sous-programme. Ici, nous allons apprendre comment transmettre des arguments au sous-programme.
sub display
{
my $var=@_; # @_ is a special variable which stores the list of arguments passed.
print "$var is the value passed";
}
display(2,3,4); #this is how we need to pass the arguments.
Sortie :
3 est la valeur transmise
@_ est une variable tableau spéciale qui stocke les arguments passés aux sous-programmes.
Perl Shift
Nous pouvons également utiliser le mot-clé 'shift' qui déplace un paramètre à la fois vers une variable ou $_[0],$_[1]… qui est un élément individuel du tableau @_
sub display
{
my $var=shift;
print "$var is passed";
}
display("hello");
Sortie :
bonjour c'est passé
Les sous-programmes sont généralement utilisés dans la programmation orientée objet et également dans les endroits où vous pouvez placer davantage de code réutilisable.
La fonctionnalité principale des sous-programmes est d'effectuer certaines tâches et de renvoyer le résultat du code réutilisable.
Nous pouvons renvoyer une valeur du sous-programme en utilisant le mot-clé return.
sub add
{
my $a=shift;
my $b=shift;
return($a+$b);
}
my $result=add(5,6);
print $result;
Sortie :
11
$result contiendra la valeur des $a et $b ajoutés.
Nous pouvons également transmettre des hachages et des tableaux directement au sous-programme.
sub hash
{
my %hash=@_;
print %hash;
}
%value= ( 1=>'a', 2=>'b');
&hash(%value);
Sortie :
1a2b
Nous pouvons également renvoyer un hachage ou un tableau.
sub hashArray
{
my %hash=@_;
print "Inside Sub-routine";
print %hash;
return(%hash);
}
%hash=(1=>'a', 2=>'b');
my(@ret)=hashArray(%hash);
print "After Sub-routine call";
print @ret;
Sortie :
À l'intérieur du sous-programme 2b1aAprès l'appel du sous-programme 2b1a
Format Perl
Perl dispose d'un mécanisme grâce auquel nous pouvons générer des rapports. Grâce à cette fonctionnalité, nous pouvons créer des rapports exactement comme nous le souhaitons tout en les imprimant sur l'écran de sortie ou dans un fichier. Un format simple peut être écrit à l'aide des fonctions printf ou sprintf disponibles en Perl.
printf "%05d\n", 30;
Cela inclura des zéros non significatifs devant le numéro 30, ce qui fera un nombre total de chiffres jusqu'à 5. La même chose peut être utilisée pour sprintf.
sprintf "%05d\n", 30; # This will print the same as printf.
En utilisant printf et sprintf, nous pouvons obtenir la plupart des formats Perl. Dans le cas des rapports, cela sera difficile à mettre en œuvre.
================================================== =========================
Nom Adresse Âge Téléphone
================================================== =========================
Krishna Chennai 24 929309242
Shruthi Chennai 24 929309232
Ce qui précède est un exemple de rapport que nous devons imprimer de la même manière en Perl. Ceci peut être réalisé en utilisant Perl printf et Perl sprintf. Il peut être efficacement implémenté en utilisant le format.
Un format peut être déclaré de la manière ci-dessous.
format FORMATNAME=FORMATLIST.
Ici, nous utiliserons une méthode d'écriture particulière pour imprimer les données sur l'écran de sortie ou dans le fichier.
| Symbole | Description |
|---|---|
|
@ |
Utilisé pour représenter le début du titulaire du champ |
|
> |
Alignement correct du texte |
|
< |
Alignement du texte à gauche |
|
| |
Alignement central |
|
# |
Numérique si plusieurs # sont fournis. Suppose comme un commentaire si un seul # est fourni |
|
. |
Virgule |
|
^ |
Le support de début de champ peut également être utilisé pour le multiligne et également pour le retour à la ligne. |
|
~ |
La ligne doit être vide si la variable est vide |
|
@* |
Plusieurs lignes. |
($name,$addr,$age,$phone)=("krishna","chennai","24","929309242");
write;
($name,$addr,$age,$phone)=("shruthi","chennai","24","929309232");
write;
format STDOUT_TOP=
===============================================================
NAME ADDRESS AGE PHONE
===============================================================
.
format STDOUT=
@<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<<<<<< @<<< @<<<<<<<<<<
$name, $addr, $age, $phone
.
Exécutez le code pour voir le résultat.
Nous utilisons le symbole @ pour spécifier le début du titulaire du champ ou de la chaîne, '<' pour chaque caractère.
Nous utilisons STDOUT pour imprimer sur la sortie standard. Nous pouvons changer cela en gestionnaire de fichiers que nous utilisons pour écrire des données dans le fichier.
open(REPORT,">test.txt");
($name,$addr,$age,$phone)=("krishna","chennai","24","929309232");
write REPORT;
($name,$addr,$age,$phone)=("shruthi","chennai","24","929309232");
write REPORT;
format REPORT_TOP=
===============================================================
NAME ADDRESS AGE PHONE
===============================================================
.
format REPORT=
@<<<<<<<<<<<<< @<<<<<<<<<<<<<<<<<<<<< @<<< @<<<<<<<<<<
$name, $addr, $age, $phone
Nous pouvons remplacer '<' par '>' ou '|' pour modifier l'alignement du texte.STDOUT_TOP est utilisé pour concevoir l'en-tête du format.Nous pouvons également utiliser la même chose avec le gestionnaire de fichiers en utilisant FH_TOP (FH est le gestionnaire de fichiers).Cela affichera le format dans le fichier sur lequel nous travaillons sur.
Normes de codage Perl
Chaque programmeur aura sa propre façon d'écrire le code en utilisant certaines normes ; ces normes doivent être suffisamment familières pour que d'autres programmeurs puissent comprendre et prendre en charge correctement le code.
Normes de codage en Perl
L’écriture de code est simple et facile. Le problème se pose lorsqu’il faut le maintenir à des stades ultérieurs. Des directives et des normes de codage appropriées doivent être suivies lors de l'écriture du code. Perl définit également certaines normes qui seront utiles aux programmeurs pour écrire du code. Il est conseillé de charger 'strict' et 'warnings module' lors de l'écriture du code. Chacun de ces modules a sa propre importance. Strict nous fera déclarer la variable avant de l'utiliser et nous dira également si un mot nu est présent dans votre code. Le module d'avertissements peut également être utilisé en passant l'option '-w' à l'interpréteur Perl dans shebang. Les avertissements s'imprimeront sur l'écran de sortie.
#!/usr/bin/perl –w
Vous trouverez ci-dessous quelques listes de normes.
- Utilisez les modules « strict » et « avertissements ».
- Supprimez la variable qui n’est pas utilisée.
- Les noms de variables doivent être compréhensibles pour les autres utilisateurs. Ex : $name, @fileData etc.
- La documentation est requise lors du codage d'un script.
- Ne codez en dur aucune valeur, essayez plutôt de les récupérer dynamiquement ou demandez à l'utilisateur de les saisir pendant l'exécution. (Chemin du fichier, noms de fichiers).
- Maximisez la réutilisation du code. Essayez de mettre le code réutilisable dans des sous-programmes.
- Cela signifie que les noms complets doivent être donnés pour les sous-programmes.
- Les sous-programmes doivent être écrits avec les commentaires et la documentation appropriés.
- Initialisez toujours les variables.
- Vérifiez toujours les codes de retour pour les appels système. L'ouverture d'un fichier peut se produire ou non, avoir un code retour ici affichera l'état d'erreur si le fichier n'existe pas.
Ex : ouvert(FH,
- Le sous-programme doit toujours renvoyer une valeur.
- Ouvrez bouclés dans la même ligne.
- BLOC à ligne unique peut être placé sur une seule ligne avec bouclé.
- Utilisez des étiquettes pendant les BOUCLES, il serait facile de sortir de la boucle chaque fois que cela est nécessaire.
- Utilisez le trait de soulignement lorsque de longues phrases de mots sont écrites sous forme de nom de variable ou de sous-programme.
- Essayez d'utiliser une expression régulière simple lors du codage.
Exemple parfait avec les normes de codage :
#######################################################################
Program to read the file content
# Date: 22-2-2013
# Author : Guru99
########################################################################
#!/usr/bin/perl
use strict;
use warnings;
my $line;
open FR, "file.txt" || die("Cannot open the file $!");
while ($line=<FR>)
{
print $line;
} # Looping file handler to print data
Gestion des erreurs Perl
Qu'est-ce qu'une exception ?
Une exception est un événement qui se produit pendant l'exécution du programme et qui suspendra ou terminera votre programme.
La gestion des erreurs
La gestion des erreurs est une gestion à laquelle chaque programmeur doit faire attention pendant la programmation. Perl fournit également des techniques de gestion des erreurs avec lesquelles nous pouvons intercepter l'erreur et les gérer en conséquence.
Gestion des erreurs en Perl
Il existe de nombreuses façons de vérifier les erreurs dans le programme. Nous devons examiner les codes de retour de la fonction que nous utilisons. Si nous sommes capables de gérer correctement ces codes de retour, la plupart des erreurs peuvent être traitées.
Qu'est-ce qui reviendra en cas d'appels système ?
Dans le cas d'appels système, l'état de retour sera stocké dans deux variables spéciales $ ? Et $ !
$! – Cela détectera le numéro d’erreur ou le numéro d’erreur associé au message d’erreur.
$? – Cela contiendra la fonction return status system().
Utilisation de l'opérateur Perl ou logique
Nous pouvons utiliser un opérateur logique ou pour la gestion des erreurs lors de l'utilisation des appels système.
Ex:
open(FH,"<test.txt");
Cela ouvrira le fichier en mode lecture si le fichier existe.
Que faire si le fichier est manquant ?
open(FH,"<test.txt") or die("File not exists $!"); # This will perl exit the program if the file not exists.
open(FH,"<test.txt") or warn ("File not exists $!"); # This will print a warning message on STDERR
Évaluation Perl
La fonction Eval peut gérer les erreurs fatales, les erreurs de compilation, les erreurs d'exécution et les erreurs qui mettent fin à votre code à un moment donné.
La fonction Perl Eval peut avoir un bloc de code ou une expression. Evals considère tout ce qui y est placé comme une chaîne.
Considérons une situation d'appel d'un sous-programme qui n'est pas défini dans le script. Dans cette situation, le script se termine en indiquant « sous-programme non défini &XYZ, cette erreur peut être gérée dans la fonction eval.
Il existe de nombreuses utilisations du bloc evals ; une de ces utilisations est lorsque nous voulons charger le module spécifique au système d'exploitation pendant l'exécution.
Ex : La division par zéro provoque une erreur fatale ; pour gérer cela, nous pouvons placer le code dans le bloc evals.
$a=5;
$b=0;
eval
{
'$result=$a/$b';
}
if($@)
{
print "$@"; # All the error codes returned by evals will get stored in $@.
}
Sortie :
erreur de syntaxe à la ligne 8 de C:\Users\XYZ\Text.pl, près de ")
{"
L'exécution de C:\Users\XYZ\Text.pl a été interrompue en raison d'erreurs de compilation.
Exemple : évaluer à l'aide de l'instruction perl die.
sub test
{
die "Dieing in sub test \n";
}
eval
{
test();
};
print "Caught : $@\n";
Sortie :
Pris : Mourir en sous-test
Utiliser Perl Essayer
Perl ne prend pas en charge les blocs de code try, catch et enfin comme les autres langages de programmation. Nous pouvons toujours les utiliser en chargeant un module Perl externe.
utilisez Try :: Tiny ;
En utilisant cela, nous pouvons placer votre code dans le bloc try et détecter l'erreur dans le bloc warn.
À la place de $@ utilisé dans eval, Try::Tiny utilise $_.
# gérer les erreurs avec un gestionnaire catch
try
{
die "Die now";
}
catch
{
warn "caught error: $_"; # not $@
};
Utilisation enfin.
my $y;
try
{
die 'foo'
}
finally
{
$y = 'bar'
};
try
{
die 'Die now'
}
catch
{
warn "Returned from die: $_"
}
finally
{
$y = 'gone'
};
Sortie :
foo à C:\Users\XYZ\Text.pl ligne 4.
Nous pouvons utiliser try, catch et enfin de cette manière.
essayez { # instruction }
attraper {# instruction }
enfin { # instruction } ;
Or
try
{
# statement
}
finally
{
# statement
};
Sortie :
Or
try
{
# statement
}
finally
{
# statement
}
catch
{
# statement
};
Sortie :
Programmation de sockets Perl
Qu'est-ce qu'une prise ?
Le socket est un support par lequel deux ordinateurs peuvent interagir sur un réseau en utilisant l'adresse et les ports réseau.
Supposons que A (serveur) et B (client) soient deux systèmes qui doivent interagir l'un avec l'autre à l'aide de Sockets pour exécuter certains programmes.
Pour implémenter cela, nous devons créer des sockets à la fois dans A (serveur) et B (client), A sera dans l'état de réception et B sera dans l'état d'envoi.
Un serveur):
Ici, le serveur souhaite recevoir une connexion de B (Client), exécuter certaines tâches et renvoyer le résultat à B (Client). Lorsque nous exécutons le code, le système d'exploitation en A essaie de créer un socket et lie un port à ce socket. Ensuite, il écoutera l'expéditeur qui est B.
B (Client).
Ici, le client souhaite envoyer un programme de son système à A (serveur) pour un traitement. Lorsque nous exécutons le code, le système d'exploitation en B essaie de créer un socket pour communiquer avec A (serveur), B doit spécifier l'adresse IP et le numéro de port de A auquel B souhaite se connecter.
Si cela se passe bien, les deux systèmes interagiront pour échanger des informations via un seul port. Perl prend également en charge la programmation de sockets.
Perl dispose d'une API native grâce à laquelle les sockets peuvent être implémentées. Pour faciliter les choses, il existe de nombreux modules CPAN à l'aide desquels nous écrivons des programmes socket.
Opérations du serveur :
- Créer une prise
- Lier le socket avec l'adresse et le port
- Écoutez le socket sur cette adresse de port
- Acceptez les connexions client qui tentent de se connecter en utilisant le port et l'IP du serveur
- Effectuer des opérations
Témoignage Operation :
- Créer une prise
- Connectez-vous au serveur en utilisant son adresse de port
- Effectuer des opérations
socket.io
Il s'agit d'un module de programmation socket, basé sur la programmation orientée objet. Ce module ne prend pas en charge le type de réseau INET utilisé dans les réseaux.
IO::Socket::INET :
Ce module prend en charge le domaine INET et est construit sur IO::Sockets. Toutes les méthodes disponibles dans IO::Sockets sont héritées du module INET.
Client et Serveur utilisant le protocole TCP :
TCP est un protocole orienté connexion ; nous utiliserons ce protocole pour la programmation des sockets.
Avant d'aller plus loin, voyons comment créer un objet pour le module IO::Socket::INET et créer un socket.
$socket = IO::Socket::INET->new(PeerPort => 45787, PeerAddr => inet_ntoa(INADDR_BROADCAST), Proto => udp,LocalAddr => 'localhost',Broadcast => 1 ) or die "Can't create socket and bind it : $@n";
La nouvelle méthode du module IO::Socket::INET accepte un hachage comme paramètre d'entrée du sous-programme. Ce hachage est prédéfini, et il suffit de fournir les valeurs des clés que l'on souhaite utiliser. Il existe une liste de clés utilisées par ce hachage.
|
Adresse homologue |
Adresse de l'hôte distant |
|
Hôte homologue |
Synonyme pour PeerAddr |
|
Port homologue |
Port ou service distant |
|
Adresse Locale |
Adresse de liaison de l'hôte local |
|
localhost |
Synonyme pour LocalAddr |
|
PortLocal |
Port de liaison de l'hôte local |
|
Proto |
Nom (ou numéro) du protocole |
|
Type |
Type de Socket |
|
Écoutez |
Taille de la file d'attente pour l'écoute |
|
RéutiliserAdr |
Définir SO_REUSEADDR avant la liaison |
|
Réutilisation |
Définir SO_REUSEADDR avant la liaison |
|
RéutiliserPort |
Définir SO_REUSEPORT avant la liaison |
|
Diffusez |
Définir SO_BROADCAST avant la liaison |
|
Temps mort |
Valeur du délai d'attente pour diverses opérations |
|
MultiHébergement |
Essayez toutes les adresses pour les hôtes multirésidents |
|
Blocage |
Déterminer si la connexion sera en mode blocage |
Serveur.pl
use IO::Socket;
use strict;
use warnings;
my $socket = new IO::Socket::INET (
LocalHost => 'localhost',
LocalPort => '45655',
Proto => 'tcp',
Listen => 1,
Reuse => 1,
);
die "Could not create socket: $!n" unless $socket;
print "Waiting for the client to send datan";
my $new_socket = $socket->accept();
while(<$new_socket>) {
print $_;
}
close($socket);
Client.pl
use strict; use warnings; use IO::Socket; my $socket = new IO::Socket::INET ( PeerAddr => 'localhost', PeerPort => '45655', Proto => 'tcp', ); die "Could not create socket: $!n" unless $socket; print $socket "Hello this is socket connection!n"; close($socket);
Remarque:
Dans la programmation socket, nous devrons d'abord exécuter Server.pl, puis client.pl individuellement dans différentes invites de commande si nous exécutons sur un hôte local.
Qu'est-ce que les modules et packages Perl
Les modules et les packages sont étroitement liés les uns aux autres et sont indépendants. Package : un package Perl est également connu sous le nom d'espace de noms et contient toutes les variables uniques utilisées telles que des hachages, des tableaux, des scalaires et des sous-programmes. Module : Le module est une collection de code réutilisable, dans lequel nous y écrivons des sous-programmes. Ces modules peuvent être chargés dans des programmes Perl pour utiliser les sous-programmes écrits dans ces modules.
Que sont les modules Perl ?
Les modules standard seront installés lors de l'installation de Perl sur n'importe quel système. CPAN : Perl complet Archive Network – Un référentiel mondial de modules Perl. Nos propres modules Perl personnalisés qui peuvent être écrits par nos soins. Fondamentalement, un module chargé dans n'importe quel script exportera toutes ses variables globales et sous-programmes. Ces sous-programmes peuvent appeler directement comme s'ils étaient déclarés dans le script lui-même. Les modules Perl peuvent être écrits avec l'extension .pm au nom de fichier Ex : Foo.pm. Un module peut être écrit en utilisant le « package Foo » au début du programme.
Module Perl de base :
#!/usr/bin/perl
package Arithmetic;
sub add
{
my $a=$_[0];
my $b=$_[1];
return ($a+$b);
}
sub subtract
{
my $a=$_[0];
my $b=$_[1];
return ($a-$b);
}
1;
Aucune sortie
Pour utiliser ce module Perl, nous devons le placer dans le répertoire actuellement en cours de travail.
Nous pouvons charger un module Perl en utilisant require ou use n'importe où dans le code. La principale différence entre require et use est qu'il faut exiger un module chargé pendant l'exécution et utiliser des charges pendant la compilation.
#!/usr/bin/perl require Arithmetic; print Arithmetic::add(5,6); print Arithmetic:: subtract (5,6);
Ici, dans l'exemple ci-dessus, nous accédons aux sous-programmes en utilisant le nom de module complet.
Nous pouvons également accéder au package en utilisant « utiliser l'arithmétique ».
Exportateur:
Ce module a une fonctionnalité par défaut d'importation de méthodes.
#!/usr/bin/perl
package Arithmetic;
require Exporter;
@ISA= qw(Exporter); # This is basically for implementing inheritance.
@EXPORT = qw(add);
@EXPORT_OK = qw(subtract);
sub add
{
my $a=$_[0];
my $b=$_[1];
return ($a+$b);
}
sub subtract
{
my $a=$_[0];
my $b=$_[1];
return ($a-$b);
}
1;
Le tableau @EXPORT peut être utilisé pour transmettre une liste de variables et de sous-programmes qui par défaut seront exportés vers l'appelant du module.
Le tableau @EXPORT_OK peut être utilisé pour transmettre une liste de variables et de sous-programmes qui seront exportés à la demande, où l'utilisateur doit spécifier lors du chargement du module.
#!/usr/bin/perl use Arithmetic qw(subtract); print add(5,6); print subtract (5,6);
Par défaut, l'ajout de sous-programme sera exporté. La méthode de soustraction ne sera pas exportée si elle n'est pas spécifiée lors du chargement du module.
Programmation orientée objet en Perl
Dans cette section, nous apprendrons comment créer des modules orientés objet Perl. Voyons d’abord quel est l’objet ? Un objet est une instance à l'aide de laquelle nous pouvons accéder, modifier et localiser certaines données dans n'importe quel module Perl. Il ne s'agit que de faire en sorte que votre package Perl, vos variables et vos sous-programmes existants agissent comme une classe, des objets et des méthodes en référence à d'autres langages de programmation.
Créer une classe
Nous savons déjà comment créer des modules à partir du sujet précédent. Le but de la classe est de stocker des méthodes et des variables. Un module Perl aura des sous-programmes qui sont des méthodes. Nous devons accéder à ces variables et objets de sous-programmes.
Constructeur Perl
Un constructeur en Perl est une méthode qui s'exécutera et nous renverra une référence avec le nom du module balisé avec la référence. C’est ce qu’on appelle une bénédiction pour la classe. Nous utilisons une variable particulière pour bénir une classe Perl, qui est bless.
#!/usr/bin/perl
package Arithmetic;
sub new
{
my $class=shift;
my $self={};
bless $self, $class;
return $self;
}
sub add
{
my $self= shift;
my $a=$_[0];
my $b=$_[1];
return ($a+$b);
}
sub subtract
{
my $self= shift;
my $a=$_[0];
my $b=$_[1];
return ($a-$b);
}
1;
La nouvelle méthode utilisée comme constructeur pour une classe, Ce constructeur va créer un objet pour nous et reviendra au script qui appelle ce constructeur.
#!/usr/bin/perl use Arithmetic; my $obj= Arithmetic->new(); my $result= $obj->add(5,6); print "$result"; $result = $obj->subtract(6,5); print "$result";
Ici, nous devons comprendre comment l'objet a été créé. Chaque fois que nous essayons de créer un objet pour la classe, nous devons utiliser le nom complet de la classe. Supposons que la classe Perl se trouve dans un fichier lib\Math\Arithmetic.pm. Et, si nous voulons accéder à cette classe Perl à partir du répertoire lib, nous devons fournir le chemin complet de la classe lors de l'appel du script.
utilisez lib::Math::Arithmétique ;
my $obj = lib::Math::Arithmetic->new();
C'est ainsi que se produit la création d'objets en Perl.
@INC :
Comment le script Perl sait-il où se trouve le module de bibliothèque ? Perl ne connaît que le répertoire actuel du script et le chemin de la bibliothèque intégrée à Perl. Chaque fois que nous utilisons un module Perl qui ne se trouve pas dans le répertoire actuel ou dans le chemin de la bibliothèque Perl, le script échouera toujours. À propos de @INC, il s'agit d'un tableau contenant tous les chemins de répertoire dans lesquels il doit rechercher les modules Perl. Essayez d'exécuter cette commande et voyez quel sera le résultat.
perl –e "print @INC"
Cela donnera une sortie, et c'est le chemin où les modules lib seront disponibles. Chaque fois que nous utilisons un nouveau module de bibliothèque, nous devons dire à Perl, l'interprète, de rechercher cet emplacement particulier où le module Perl est disponible.
push(@INC, "PATH TO YOUR MODULE");
Faites-en votre première ligne de code. Cela indiquera à votre interprète d’examiner ce chemin. ou utilisé
lib Arithmetic; # List here is your Perl Module location
Destructeur Perl
Le destructeur d'un objet est appelé par défaut à la fin et avant la fin de votre script. Ceci est utilisé pour détruire vos objets de la mémoire.
Scripts Shell PERL V/s
- La programmation en Perl ne provoque pas de problèmes de portabilité, ce qui est courant lors de l'utilisation de différents shells dans les scripts shell.
- La gestion des erreurs est très simple en Perl
- Vous pouvez facilement écrire des programmes longs et complexes sur Perl en raison de son immensité. Cela contraste avec Shell qui ne prend pas en charge les espaces de noms, les modules, les objets, l'héritage, etc.
- Shell dispose de moins de bibliothèques réutilisables disponibles. Rien comparé au CPAN de Perl
- Shell est moins sécurisé. Il appelle des fonctions externes (les commandes comme mv, cp etc dépendent du shell utilisé). Au contraire, Perl fait un travail utile en utilisant des fonctions internes.
Comment PERL est utilisé dans les tests d'automatisation
Perl est largement utilisé en automatisation. Ce n’est peut-être pas le meilleur langage de programmation au monde, mais il est le mieux adapté à certains types de tâches. Discutons de où et pourquoi Perl est utilisé Tests d'automatisation.
Tests de stockage
Qu’est-ce que le stockage ? Données stockées dans des fichiers.
Supposons que nous ayons un problème lié au stockage Cas de test où nous devons écrire des données sur une partition, les lire et vérifier que les données sont écrites correctement.
Cela peut être fait manuellement, mais un testeur manuel peut-il effectuer la même chose 10000 fois ? Ce sera un cauchemar ! Nous avons besoin d'automatisation
Le meilleur outil pour automatiser tout ce qui concerne le stockage est Perl en raison de ses techniques de gestion de fichiers, REGEX et une analyse de fichiers puissante qui consomme le moins de temps d'exécution par rapport aux autres langages de programmation.
Pourquoi devons-nous tester le stockage ? Pensez aux grands centres de données où les données circuleront en continu d'un système à un autre, avec des milliers d'enregistrements stockés par seconde. Il est essentiel de tester la robustesse d’un tel mécanisme de stockage.
De nombreuses entreprises comme HP, Dell, IBM et de nombreux fabricants de serveurs utilisent Perl comme interface pour tester les fonctionnalités dans les domaines du stockage et de la mise en réseau. NetApp est l'une de ces sociétés qui travaille entièrement sur le stockage et utilise Perl comme langage de programmation pour automatiser les cas de test.
Si vous êtes intéressé par l'automatisation Perl, il serait conseillé de vous renseigner sur le stockage et la mise en réseau. Concepts.
Tests de serveur et de réseau :
Tests de serveurs et de réseaux avec Perl
PERL est largement utilisé pour la surveillance de la disponibilité et des performances des serveurs.
Prenons un centre de données doté de 100 hôtes (serveurs). Vous devez vous connecter à chaque hôte, exécuter certaines commandes à distance. Vous souhaitez également redémarrer le système et vérifier quand il revient en ligne.
Effectuer manuellement cette tâche pour les 100 hôtes sera un cauchemar. Mais nous pouvons facilement automatiser cela en utilisant PERL
Étapes de conception pour réaliser cette automatisation ci-dessus à l'aide de PERL
- Prenez les données du fichier sur les informations de l'hôte telles que (IP, nom d'utilisateur et mot de passe).
- Utilisez Net::SSH2 pour vous connecter à chaque système et établir un canal pour exécuter les commandes.
- Exécutez l'ensemble des commandes requises, ex : ls, dir, ifconfig,ps etc.
- Redémarrez le système.
- Attendez 10 minutes pour que le système démarre.
- Pingez le système à l’aide du module Net::Ping et imprimez l’état.
Nous coderons le scénario ci-dessus.
Prenons un fichier appelé Input.txt qui stockera les informations complètes sur tous les hôtes sur lesquels nous devons nous connecter et exécuter la commande.
Entrée.txt
Mot de passe root 192.168.1.2
Mot de passe root 192.168.1.3
192.168.1.4 racine racine123
HostCheck.pl
use Net::SSH2;
use Net::Ping;
use strict;
use warnings;
my $ping = Net::Ping->new(); # Creating object for Net::Ping
my $SSHObj = Net::SSH2->new(); #Creating object for Net::SSH2
open( FH, "Input.txt" ); # Opening file and placing content to FH
my @hosts = <FH>;
my $ip;
my @ips;
foreach (@hosts)
{
if ( $_ =~ /(.*)\s+(\w+)\s+(.*)/ ) #Regex to get each info from file
{
$ip = $1;
my $user = $2;
my $password = $3;
$SSHObj->connect($ip);
print "Connecting to host -- $ip --Uname:$user --Password:$password\n";
my $status = $SSHObj->auth_password( $user, $password );
print "$status\n";
die("unable to establish connection to -- $ip") unless ($status);
my $shell = $SSHObj->channel();
print "$_\n" while <$shell>;
$shell->blocking(1);
$shell->pty('tty');
$shell->shell();
sleep(5);
#Executing the list of command on particular host. Can be any command
print $shell "ls \n";
print "$_\n" while <$shell>;
print $shell "ps \n";
print "$_\n" while <$shell>;
print $shell "dir \n";
print "$_\n" while <$shell>;
print $shell "init 6\n"; #rebooting the system
push( @ips, $ip );
}
}
sleep 600;
foreach (@ips)
{
if ( $ping->ping($_) )
{
print "$_ is alive.\n" if $ping->ping($_);
}
else
{
print "$_ is not still up --waiting for it to come up\n";
}
}
Test Web
Perl ne se limite pas aux tests de stockage et de réseau. Nous pouvons également effectuer des tests Web en utilisant PERL. WWW-Mécaniser est un module utilisé pour test Web. Fondamentalement, il ne lancera aucun navigateur pour tester les fonctionnalités des applications Web, mais utilisera plutôt le code source des pages HTML.
Nous pouvons également effectuer des tests basés sur un navigateur en utilisant Selenium IDE, RC, pilote Web. Perl est pris en charge pour Selenium.
\n”; #this conservera la chaîne restante une fois la correspondance de motif terminée.
imprimer "
