Tutorial su Perl
Luca Bennett
Cos'è Perl?
Perl è un linguaggio di programmazione dinamico, interpretato e di alto livello, di uso generale. Perl è un termine che sta per "Practical Extraction and Reporting Language" anche se non esiste un acronimo per Perl. È stato introdotto da Larry Wall nel 1987. Il linguaggio Perl è stato progettato appositamente per la modifica del testo. Ma ora è ampiamente utilizzato per una varietà di scopi, tra cui l'amministrazione del sistema Linux, la programmazione di rete, lo sviluppo web, ecc.
Mettiamolo in modo semplice. Sebbene i computer comprendano solo gli 0 e gli 1 (linguaggio binario/linguaggio macchina/[linguaggio di basso livello]), per noi umani è molto difficile programmare in un linguaggio binario. Perl è un linguaggio di programmazione che utilizza elementi del linguaggio naturale, parole utilizzate nella lingua inglese comune ed è quindi più facile da comprendere dagli esseri umani [linguaggio di alto livello]. Ora c'è un problema; i computer non possono comprendere i linguaggi di alto livello, che noi esseri umani possiamo comprendere facilmente. Per questo, abbiamo bisogno di qualcosa che possa tradurre il linguaggio di alto livello in un linguaggio di basso livello. Qui l'interprete viene in nostro aiuto. L'interprete è un software che converte il programma scritto in un linguaggio di alto livello in un linguaggio di basso livello affinché il computer possa comprendere ed eseguire le istruzioni scritte nel programma. Quindi, Perl è un linguaggio di programmazione interpretato.
Dove viene utilizzato Perl?
La potenza del linguaggio di scripting Perl può essere implementata in molti campi. L'uso più popolare di Perl è nello sviluppo Web. Perl è anche usato per automatizzare molte attività nei server Web e altri lavori di amministrazione, può generare automaticamente e-mail e ripulire i sistemi. Perl è ancora usato per il suo scopo originale, ovvero estrarre dati e generare report. Può produrre report sull'uso delle risorse e controllare i problemi di sicurezza in una rete. Per questo motivo, Perl è diventato un linguaggio popolare usato anche nello sviluppo Web, nel networking e nella bioinformatica. Oltre a tutto questo, Perl può anche essere usato per la programmazione CGI.
Perl può anche essere utilizzato per la creazione e la manipolazione di immagini. Oltre a ciò, la creazione di reti tramite telnet, FTP, ecc., la creazione di interfacce utente grafiche, l'elettronica VLSI e la creazione di filtri di posta per ridurre le pratiche di spamming sono alcuni casi di utilizzo di Perl.
Perl è anche noto per l'implementazione di pratiche OOP (programmazione orientata agli oggetti) e supporta tutte le forme di ereditarietà (semplice, multipla e a diamante), polimorfismo e incapsulamento. Perl è abbastanza flessibile da supportare contemporaneamente pratiche procedurali e OOP. Perl ha anche moduli extra che consentono di scrivere o utilizzare/riutilizzare codice scritto in Python, PHP, PDL, TCL, Ottava, Java, C, C++, Basic, Ruby e Lua nello script Perl. Ciò significa che puoi combinare Perl con questi extra linguaggi di programmazione piuttosto riscrivere il codice esistente.
Applicazioni del linguaggio di programmazione Perl
Perché usare Perl?
È vero che ci sono altri linguaggi di programmazione che possono essere usati per fare tutto ciò che è stato detto sopra, allora perché dovresti usare specificatamente Perl? Perl è molto facile da imparare, soprattutto se hai esperienza nella programmazione informatica. Perl è stato progettato per essere facile da scrivere e da comprendere per gli esseri umani piuttosto che per facilitarne l'elaborazione da parte dei computer. Utilizza espressioni regolari. Il suo stile naturale di linguaggio è diverso da altri linguaggi di programmazione che utilizzano grammatica e sintassi specifiche; quindi Perl è molto flessibile e non impone alcun modo particolare di pensare ad una soluzione o ad un problema. Perl è estremamente portatile. Può essere eseguito su qualsiasi sistema operativo che abbia installato l'interprete Perl, quindi è indipendente dalla piattaforma. Tutti i sistemi Linux OperaI sistemi di ting sono forniti con Perl installato, quindi puoi iniziare a programmare in Perl su Linux fin da subito. Questo è diverso dagli script Shell, in cui il codice cambia a seconda del tipo di distribuzione Linux utilizzata, rendendolo sempre meno portabile Piccoli compiti specifici in Perl diventano molto facili e veloci. In questo tutorial Perl per principianti imparerai come codificare programmi piccoli e veloci per attività specifiche. Prendiamo un semplice esempio del classico programma Hello World che serve per iniziare ad apprendere qualsiasi linguaggio di programmazione che abbia come radice UNIX:
Esempio: Perl ciao mondo
#!/usr/bin/perl print "Hello, world!";
Produzione:
Ciao mondo!
Le due righe di codice precedenti verranno stampate Hello, world! Ora, non era troppo semplice e veloce? Studenti con conoscenza di C, C++ saprà che sono necessarie molte più righe di codice per ottenere lo stesso risultato in quelle lingue.
Forse ti starai chiedendo perché Perl è così famoso sul Web. È semplice poiché la maggior parte delle cose che accadono sul web sono di TESTO e Perl è molto bravo nell'elaborazione del testo. Se confrontiamo Perl con uno qualsiasi dei linguaggi, allora Perl sarà il linguaggio migliore, utile nella gestione dei file, nell'elaborazione del testo e nel reporting dell'output
Uno dei migliori vantaggi di Perl è che lo è libero da usare
La comunità Perl crede fermamente che il software debba essere liberamente disponibile, liberamente modificabile e liberamente distribuibile. Diversi volontari della comunità Perl si sforzano di rendere il linguaggio di programmazione il migliore possibile.
Vantaggi e svantaggi di Perl
| PRO: | Contro: |
|---|---|
|
|
|
|
|
let's get started
Con una conoscenza sufficiente della storia di Perl e dei concetti di base della programmazione informatica necessari per scrivere codice in Perl, è giunto il momento di tuffarsi e iniziare con Perl. Il prossimo capitolo ti insegnerà come configurare Perl sul tuo sistema e prepararti per il viaggio di codifica in Perl. Questo tutorial sullo scripting Perl prenderà Linux come sistema operativo che gli studenti utilizzeranno per scrivere codice in Perl.
Scarica e installa Perl – Windows, Mac e Linux
Come ottenere Perl?
Buone notizie probabilmente ce l'hai!
Ma se non riesci a trovarlo già sul tuo sistema, puoi comunque ottenerlo gratuitamente.
Per scoprire se hai già installato Perl, vai alla riga di comando e digita: perl -v
Il comando visualizzerà la versione di Perl se è installata. In questo caso, la versione è v5.14.2. Ma in caso contrario... niente panico...
Unix
|
Già installato Viene preinstallato con Perl anche se potrebbe essere necessario aggiornare alla versione più recente. |
Mac OS 
|
Già installato OSX viene fornito con Perl preinstallato, anche se potrebbe essere necessario aggiornarlo all'ultima versione |
Windows
|
È necessario installare Sono disponibili due opzioni
|
Aggiornamento Perl su Linux:
Se hai bisogno di aggiornare la versione di Perl, inserisci semplicemente una singola riga di comando
sudo apt-get install perl
e rilassati. Al resto ci penseremo noi. Assicurati solo di avere una connessione Internet attiva.
Installa perl per Windows:
Per prima cosa scarica Active Perl da questo link. Segui questi passaggi per installare ActivePerl Windows sistema. Vedi gli screenshot qui sotto per lo stesso.
Passo 1: Una volta scaricato il programma di installazione e avviata l'installazione verrà visualizzata la finestra sottostante, fare clic su Avanti per procedere.
Passo 2: Accettare il contratto di licenza per procedere con l'installazione.
Passo 3: Di seguito sono riportati i diversi pacchetti che verranno installati. Per impostazione predefinita, saranno selezionati tutti. L'unica cosa diversa è PPM (Perl Package Manager). Questa è l'utilità fornita da Active Perl per installare moduli o librerie Perl esterni nel tuo sistema. Fare clic su Avanti per procedere.
Passo 4: Questi sono diversi tipi di estensioni Perl che possono essere utilizzate per Perl. Utilizzeremo principalmente .Pl, .Plx e .Pm per Perl. I moduli Perl utilizzano fondamentalmente .Pm come estensione di file per fare riferimento a un file di libreria. Seleziona tutte le opzioni e fai clic sul pulsante Avanti.
Passo 5: Fare clic sul pulsante Installa per procedere con l'installazione.
Passo 6: Una volta installato, esegui il comando 'Perl –v' per verificare se Perl è stato installato correttamente nel tuo sistema.
Ci sono molte cose che devono essere discusse per impostare l'ambiente Perl sia in Linux che in Linux Windows, poiché non saranno inclusi molti file di libreria in questa installazione. È necessario installarli manualmente. Puoi installarli manualmente utilizzando CPAN (Comprehensive Perl Archive Network) o PPM che funziona solo per le finestre perl. Ma questi file non sono obbligatori per iniziare a programmare in Perl.
Oltre a questa configurazione di Windows, potresti usare Windows Nuova funzionalità del sottosistema Linux su Windows e utilizzo per l'esecuzione del codice Perl
Primo programma Perl
Hello world!
Esempio Perl: Ciao mondo
#!/usr/bin/perl -w #this is just a comment… print "Hello World";
Non preoccuparti se non capisci questo testo. Presto tutto sarà chiaro. Vieni a dargli un'occhiata per riga:
#!/usr/bin/perl
Questo dice a Operating System per eseguire questo file con il programma situato in /usr/bin/perl Alcuni IDE non necessitano di questa riga. Se è essenziale, devi scrivere qui il percorso verso il tuo interprete. Ricordare! Questa riga speciale deve trovarsi all'inizio del programma e deve iniziare da #! utilizzare gli avvertimenti; Questo è un altro comando speciale che dice all'interprete di visualizzare eventuali avvisi, ad esempio -w che attiva gli avvisi a livello globale.
print "Hello World";
L'istruzione di stampa scrive il testo sullo schermo. Il punto e virgola alla fine della riga indica all'interprete perl che l'istruzione è terminata. Devi mettere un punto e virgola alla fine di ogni istruzione nel codice Perl. Notare le virgolette(“). È necessario per le istruzioni di stampa. Salva lo script sopra come firstprog.pl
On Windows
Se hai installato Strawberry, puoi semplicemente fare clic su Esegui. Puoi anche eseguire l'interfaccia della riga di comando e scrivere sulla console:
C:\> perl path\firstprog.pl
oppure, se perl.exe non è nel tuo percorso:
C:\> c:\perl\bin\perl.exe firstprog.pl
Su Linux/Unix
Non ti resta che aprire il Terminale e scrivere:
perl firstprog.pl
Se non puoi eseguire il programma, assicurati di avere l'idoneità per eseguirlo. Digitare nel Terminale:
chmod +x firstprog.pl
Il tuo programma è ora eseguibile e pronto per essere eseguito. Per eseguire, scrivere:
./firstprog
Installa i moduli cpan minus
I moduli sono insiemi di codici utilizzati per eseguire attività che eseguono operazioni comuni in diversi programmi. Se usi i moduli perl, non devi riscrivere i codici per eseguire la stessa operazione. Perl può fare uso di tali librerie di codici esterne. Una delle migliori librerie è la CPAN. Sta per Comprehensive Perl Archive Network e contiene una vasta quantità di moduli Perl che puoi utilizzare. È una comunità o una rete di un gran numero di sviluppatori che contribuiscono con tali moduli. Installando il supporto per i moduli CPAN nel tuo modulo perl, puoi utilizzare i moduli CPAN e semplificare il tuo lavoro. La maggior parte dei moduli Perl è scritta in Perl, alcuni usano XS (sono scritti in C) quindi richiedono un compilatore C (è facile ottenere questa configurazione, niente panico. I moduli possono avere dipendenze da altri moduli (quasi sempre su CPAN) e non possono essere installati senza di essi (o senza una versione specifica di essi). Vale la pena leggere attentamente la documentazione per le opzioni di seguito. Molti moduli su CPAN ora richiedono una versione recente di Perl (versione 5.8 o superiore). Installa cpanminus uno script per ottenere, decomprimere, compilare e installare moduli da CPAN per semplificare l'installazione di altri moduli (ci ringrazierai più tardi). Per installare App-cpanminus moduli perl, nella riga di comando digitare:
cpan App::cpanminus
cpan App::cpanminus Assicurati di avere una connessione internet mentre i moduli perl vengono scaricati e installati.
Ora installa qualsiasi modulo:
cpan –i <Module_Name>.
Vediamo un esempio di installazione di un modulo File::Data(È un'interfaccia per accedere ai dati dei file).
Variabile Perl
Ora parleremo di variabili. Puoi immaginare una variabile come una sorta di contenitore che contiene uno o più valori. Una volta definito, il nome della variabile rimane lo stesso, ma il valore o i valori cambiano continuamente.
Esistono 3 tipi di variabili:
Tipi di variabili in Perl
Quelli più semplici sono gli scalari, e questo è il nostro argomento di oggi
Variabile scalare
Questo tipo di variabile contiene un singolo valore.
Il suo nome inizia con il simbolo del dollaro e un identificatore Perl (è il nome della nostra variabile).
Variabile scalare in Perl
Convenzione sulla denominazione
Se hai familiarità con altri linguaggi di programmazione, allora saprai che esistono alcune regole sulla denominazione delle variabili. Allo stesso modo, Perl ha tre regole per nominare gli scalari.
- Tutti i nomi scalari inizieranno con $. È facile ricordarsi di anteporre a ogni nome $. Consideratelo come un $scalare.
- Come PHP. dopo il primo carattere $, che è speciale in Perl, sono consentiti caratteri alfanumerici, ad esempio dalla a alla z, dalla A alla Z e da 0 a 9. È consentito anche il carattere di sottolineatura. Utilizzare il carattere di sottolineatura per dividere i nomi delle variabili in due parole. 'Ma il Primo carattere non può essere un numero'
- Anche se i numeri possono far parte del nome, non possono venire subito dopo $. Ciò implica che il primo carattere dopo $ sarà un alfabeto o il trattino basso. Quelli provenienti da C/C++ lo sfondo dovrebbe essere immediatamente in grado di riconoscere la somiglianza. Esempi
Esempio Perl:
$var; $Var32; $vaRRR43; $name_underscore_23;
Questi, tuttavia, non sono nomi di variabili scalari legali.
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 regola generale dice che quando Perl ha solo uno di qualcosa, quello è uno scalare. Gli scalari possono essere letti dai dispositivi e possiamo usarli nei nostri programmi.
Due tipi di tipi di dati scalari
- Numbers
- String
Numbers:
In questo tipo di dati scalari potremmo specificare:
- numeri interi, sono semplicemente numeri interi, come 2, 0, 534
- numeri in virgola mobile, sono numeri reali, come 3.14, 6.74, 0.333
Nota: in generale, l'interprete Perl vede gli interi come numeri in virgola mobile. Ad esempio, se scrivi 2 nei tuoi programmi, Perl lo vedrà come 2.0000
Letterali interi:
È costituito da una o più cifre, facoltativamente precedute da un segno più o meno e contenenti trattini bassi.
Esempi Perl:
0; -2542; 4865415484645 #this also can be written with underscores (for clarity) : 4_865_415_484_645
Come puoi vedere, non è niente di speciale. Ma credimi, questo è il tipo più comune di scalari. Sono ovunque.
Letterali in virgola mobile:
È composto da cifre, facoltativamente meno, punto decimale ed esponente.
Esempi 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
Rappresentazione ottale, esadecimale e binaria:
E' alternativo al sistema decimale. Permettimi di mostrarti la rappresentazione ottale, esadecimale e binaria. Una breve tabella presenta tutte le informazioni importanti su questi strani stili:
| sul Mercato | Tavola XY | Proceduto da |
|---|---|---|
| Octal | 8 | 0 (zero) |
| Esadecimale | 16 | 0x |
| Binario | 2 | 0b |
Esempi Perl:
255; # 255 in decimal notation 0377; # 255 in octal notation 0xff; # 255 in hexadecimal notation 0b11111111; # 255 in binary notation
Tutti questi valori per Perl significano lo stesso. Perl non memorizza i valori nello stesso formato. Convertirà internamente questi valori esadecimali, binari, ottali in decimali.
L'assegnazione è l'operazione più comune su uno scalare ed è molto semplice. Perl usa per quel segno uguale. Prende un valore dell'espressione dal lato destro e inserisce questo valore nella nostra variabile.
Diamo un'occhiata agli esempi:
$size=15; # give $size value of 15 $y = -7.78; # give $y value of -7.78
Inoltre puoi inserire nella variabile non solo un numero, ma anche un'espressione.
$z = 6 + 12 # give $z value of 18
String
Stringhe: è anche un tipo scalare molto semplice.
La lunghezza massima di una stringa in Perl dipende dalla quantità di memoria di cui dispone il computer. Non esiste alcun limite alla dimensione della stringa, qualsiasi quantità di caratteri, simboli o parole può costituire le tue stringhe. La stringa più corta non ha caratteri. Il più lungo può riempire tutta la memoria del sistema. I programmi Perl possono essere scritti interamente in un set di caratteri ASCII a 7 bit. Perl ti consente anche di aggiungere qualsiasi set di caratteri a 8 o 16 bit, ovvero. caratteri non ASCII all'interno di stringhe letterali. Perl ha anche aggiunto il supporto per Unicode UTF-8.
Come i numeri, esistono due diversi tipi di stringhe:
- Stringhe letterali con virgolette singole
- Double virgolette stringhe letterali
Stringhe letterali con virgolette singole
Le virgolette singole vengono utilizzate per racchiudere i dati che si desidera prendere alla lettera. Un breve esempio e tutto dovrebbe essere chiaro:
Esempi Perl:
#!/usr/bin/perl $num = 7; $txt = 'it is $num'; print $txt;
Produzione:
è $num
Qui a causa delle virgolette singole, il valore di $num non è stato preso e i caratteri letterali '$','n', 'u' e 'm' vengono aggiunti al valore di $txt
Doublestringhe letterali tra virgolette
Double le virgolette vengono utilizzate per racchiudere i dati che devono essere interpolati prima dell'elaborazione. Ciò significa che i caratteri di escape e le variabili non vengono semplicemente inseriti letteralmente in operazioni successive, ma vengono valutati sul posto. I caratteri di escape possono essere utilizzati per inserire nuove righe, tabulazioni, ecc.
Esempi Perl:
$num = 7; $txt = "it is $num"; print $txt;
Produzione:
è 7
Qui, a causa delle virgolette doppie, il valore di $num viene aggiunto al valore di $txt
Double-virgolette interpolano variabili scalari e array, ma non hash. D'altro canto, puoi usare le virgolette doppie per interpolare slice di array e hash.
Misterioso\n
Considera il seguente programma
Esempi Perl:
print "hello \n";
Produzione:
Ciao
Perl non visualizza solo "ciao\n", ma solo "ciao". Perché? Perché '\n' è un segno speciale e significa che vuoi passare a una nuova riga mentre visualizzi il testo nel tuo programma. print “ciao\n nuova riga”; Prossima domanda: ci sono altri segni speciali? Sì! Ma non preoccuparti, solo alcuni. Controlla la tabella qui sotto
| Costruire | Descrizione |
|---|---|
| \n | nuova linea |
| \r | ritorno |
| \t | linguetta |
| \f | avanzamento modulo |
| \b | backspace |
| \a | campana |
| \e | fuga |
| \dieci | qualsiasi valore ASCII ottale (qui, 007 = campana) |
| \x7f | qualsiasi valore esadecimale (qui, 7f = cancella) |
| \\ | backslash |
| \ " | doppia virgoletta |
| \l | lettera successiva minuscola |
| \L | minuscole tutte le lettere seguenti fino a \E |
| \u | lettera successiva maiuscola |
| \U | maiuscole tutte le lettere seguenti fino a \E |
| \E | Terminare \L, \U |
Lo so, non ce ne sono 'solo pochi'… Ma credetemi, dovete saperlo proprio
Variabile di stringhe
È la stessa operazione che vediamo nell'assegnazione dei numeri. Perl ottiene la nostra stringa dal lato destro del segno uguale e inserisce questa stringa in una variabile.
Esempi 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;
Produzione:
procedura dettagliata315
Come puoi vedere, puoi inserire numeri e stringhe nelle stesse variabili. Non esiste una classe di variabili.
Concatenazione di stringhe (punto):
L’operatore di concatenazione “.” unisce due o più corde. Ricordare! Se la stringa contiene virgolette, ritorni a capo e barre rovesciate, tutti questi caratteri speciali devono essere preceduti da una barra rovesciata.
Variabile Perl ' ' Esempi:
#!/usr/bin/perl $a = "Tom is"; $b = "favorite cat"; $c = $a ." mother's ". $b; print $c;
Produzione:
Tom è il gatto preferito della mamma
Le corde
“$a”, “$b”, sono concatenati e memorizzati in “$c” utilizzando il simbolo “.” operatore.
Alla fine…
Conversione tra Numbers e stringhe:
Come sapete, Perl converte automaticamente i numeri in stringhe quando necessario. Come fa Perl a sapere di cosa abbiamo bisogno in questo momento? È semplice: tutto dipende dall'operatore (parleremo degli operatori più avanti, ora, accetta solo che ci sono molti operatori, diversi per numeri e stringhe). Se un operatore si aspetta un numero, Perl userà il valore come numero. Se un operatore si aspetta una stringa, Perl userà il valore come stringa. In altre parole, non devi preoccuparti di questo tipo di conversione. Un breve esempio e tutto dovrebbe essere chiaro:
Esempi Perl:
$string = "43"; $number = 28; $result = $string + $number; print $result;
Produzione:
71
il valore di $string viene convertito in un numero intero e aggiunto al valore di $number.
Il risultato dell'addizione, 71, viene assegnato a $risultato.
Ambito di una variabile – Modificatori di accesso
Possiamo dichiarare uno scalare ovunque nel programma. Ma devi specificare un modificatore di accesso
Esistono 3 tipi di modificatori
- my
- locale
- nostro
My: Usandolo puoi dichiarare qualsiasi variabile specifica all'interno del blocco. cioè all'interno delle parentesi graffe.
#!/usr/bin/perl
my $var=5;
if(1)
{
my $var_2 =$var;
}
print $var_2;
Nessuna uscita
L'output del programma non sarà nulla!
Nell'esempio sopra, vedrai che ci sono due variabili dichiarate, una è all'interno del blocco If ($var_2) e l'altra è all'esterno del blocco If ($var). La variabile dichiarata all'esterno del blocco sarà accessibile a if block ma la variabile dichiarata all'interno di if block non sarà accessibile al programma esterno.
Locale: Usandolo possiamo effettivamente mascherare gli stessi valori della variabile su valori diversi senza effettivamente modificare il valore originale della variabile, supponiamo di avere una variabile $a per la quale il valore è assegnato 5, puoi effettivamente modificare il valore di quella variabile da ri-dichiarare la stessa variabile utilizzando la parola chiave local senza alterare il valore originale della variabile che è 5. Vediamo come funziona con un esempio.
#!/usr/bin/perl
$var = 5;
{
local $var = 3;
print "local,\$var = $var \n";
}
print "global,\$var = $var \n";
L'output del programma sopra sarà in questo modo.
locale, $var = 3
globale, $var = 5
In questo modo possiamo modificare il valore della variabile senza alterare il valore originale.
Our: una volta dichiarata una variabile con il modificatore di accesso "our", può essere utilizzata nell'intero pacchetto. Supponiamo di avere un modulo Perl o un pacchetto test.pm che ha una variabile dichiarata con scope our. È possibile accedere a questa variabile in qualsiasi script che utilizzerà quel pacchetto.
Se siete seriamente intenzionati a programmare in Perl, dovreste iniziare il vostro programma con
#! / usr / local / bin / perl
usare rigorosamente;
Questo ti aiuterà a scrivere codice migliore e più pulito. 'use strict' attiva il pragma strict che ti farà dichiarare le tue variabili con la mia parola chiave.
Questa è una buona pratica di programmazione
#!/usr/local/bin/perl use strict; $var = 10; print "$var";
Risultato: errore
#!/usr/local/bin/perl use strict; my $var = 10; print "$var";
Produzione:
10
Array Perl
Cos'è l'array Perl?
Un Array è un tipo speciale di variabile che memorizza i dati sotto forma di elenco; è possibile accedere a ciascun elemento utilizzando il numero di indice che sarà univoco per ciascun elemento. Puoi memorizzare numeri, stringhe, valori mobili, ecc. nel tuo array. Sembra fantastico, quindi come creiamo un array in Perl? In Perl, puoi definire un array usando il carattere '@' seguito dal nome che vuoi dare. Consideriamo la definizione di un array in Perl.
il mio @array;
Questo è il modo in cui definiamo un array in Perl; potresti pensare a come dobbiamo archiviare i dati al suo interno. Esistono diversi modi per archiviare i dati in un array. Dipende da come lo utilizzerai.
my @array=(a,b,c,d); print @array;
Produzione:
abcd
Questo è un array con 4 elementi al suo interno.
L'indice dell'array inizia da 0 e termina con la dimensione massima dichiarata, in questo caso la dimensione massima dell'indice è 3.
Esempio di array Perl
Puoi anche dichiarare un array nel modo sopra; l'unica differenza è che memorizza i dati in un array considerando uno spazio bianco come delimitatore. Qui, qw() significa citazione. Il significato di questa funzione è generare un elenco di parole. Puoi utilizzare qw in diversi modi per dichiarare un array.
@array1=qw/a b c d/;
@array2= qw' p q r s';
@array3=qw { v x y z};
print @array1;
print @array2;
print @array3;
Produzione:
abcdpqrsvxyz
Supponiamo di voler assegnare un valore a 5th elemento di un array, come lo faremo.
$array[4] ='e';
Matrice sequenziale
Gli array sequenziali sono quelli in cui si memorizzano i dati in sequenza. Supponiamo di voler memorizzare da 1 a 10 numeri o alfabeti dalla az in un array. Invece di digitare tutte le lettere, puoi provare qualcosa come di seguito:
@numbers= (1..10); print @numbers; #Prints numbers from 1 to 10;
Produzione:
12345678910
Dimensioni dell'array Perl
Abbiamo un array che è già disponibile e non sai quale sia la dimensione di quell'array, quindi qual è il modo possibile per trovarlo.
@array= qw/a b c d e/; print $size=scalar (@array);
Possiamo ottenere la dimensione di un array senza utilizzare le funzioni? Sì possiamo.
@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
Produzione:
5
5
Matrice dinamica
Viene chiamato il metodo sopra descritto per dichiarare un array array statici, dove conosci la dimensione di un array.
Cos'è l'array dinamico?
Gli array dinamici sono quelli che dichiari senza specificare alcun valore su di essi. Quindi, quando memorizziamo esattamente i valori in quell'array? Semplice, li memorizziamo durante il runtime. Ecco un semplice programma per questo.
Utilizzeremo alcune funzioni Perl integrate per eseguire questa attività.
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.
}
Produzione:
Questo è anche
una specie di dinamica
mic
rr
y
La funzione split divide il contenuto della stringa in un array in base al delimitatore fornito. Questa funzione eliminerà anche il delimitatore dalla stringa, in questo caso è 'a';
Push, Pop, Shift, Unshift per gli array Perl:
Queste funzioni possono essere utilizzate in Perl per aggiungere/eliminare elementi di un array.
- Perl Push: aggiunge un elemento dell'array alla fine di un array esistente.
- Perl Pop: rimuove l'ultimo elemento da un array.
- Perl Shift: rimuove il primo elemento da un array.
- Perl Unshift: aggiunge un elemento all'inizio di un array.
Vediamo un esempio in cui possiamo utilizzare le funzioni seguenti.
@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";
Produzione:
1°: lun mar mer
2° quando si preme: lun mar mer gio
3° quando non turno: ven lun mar mer gio
4° quando pop: ven lun mar mer
5° quando turno: lun mar mer
Hash Perl
Perché abbiamo bisogno dell'hash?
Abbiamo già appreso degli scalari e degli array nelle sezioni precedenti.
Cosa fanno esattamente gli scalari? Memorizza solo numeri interi e stringhe.
Cosa fanno esattamente gli array? È una raccolta di scalari, in cui accedi a ciascun elemento di un array utilizzando gli indici. Ma è una buona idea utilizzare un array quando si hanno centinaia e migliaia di record? Dimenticheremo quale indice ha quale valore. Per superare questa situazione abbiamo qualcosa come Perl Hash.
Cosa sono gli hash?
Un hash può anche contenere tanti scalari quanti ne può contenere l'array. L'unica differenza è che non abbiamo alcun indice, piuttosto abbiamo chiavi e valori. È possibile dichiarare un hash iniziando con % seguito dal nome dell'hash. Vediamo un esempio di come possiamo definire un hash Perl e come possiamo differenziarlo dall'array
Considera un esempio di tre persone e le loro età sono rappresentate in una matrice.
@array=('Sainath',23,'Krishna',24,'Shruthi',25); #This is how an array looks.
print @array;
Produzione:
Sainath33Krishna24Shruthi25
In questo modo è difficile conoscere l'età individuale poiché dobbiamo ricordare sia la posizione dell'indice del nome che l'età di tutte le persone. Può essere semplice quando hai 3 nomi, ma quando ne hai 1000 o più? Tu sai la risposta.
Questo possiamo superarlo usando un hash.
Esempio di hash:
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.
Produzione:
Sainath33Krishna24Shruthi25Sainath33Krishna24Shruthi25
Ora abbiamo dichiarato un hash, fantastico!! Ma come possiamo accedervi o stamparlo? È necessario accedere a ciascun elemento nell'hash con la chiave associata alla quale verrà assegnato un valore. Quindi, esiste una mappatura uno tra ciascuna chiave e valore nell'hash.
Per stampare l'età di qualsiasi persona, devi solo ricordare il nome di quella persona.
print $hash{'Krishna'}; # This how we should access a hash. Key enclosed within {}.
Potresti esserti chiesto perché ho usato $hash{KeyName}, ricorda che un hash è ancora una volta una raccolta di scalari. Quindi, possiamo usare $ che rappresenta scalare per accedere a ciascun elemento hash.
Nota: ciascuna chiave nell'hash deve essere univoca, altrimenti sovrascriverà il valore assegnato in precedenza.
Come possiamo assegnare un hash a un altro hash? Semplice, come facciamo noi per
Possiamo anche stampare l'intero hash.
%hash=( 'Tom' => 23); %newHash=%hash; # Assigning hash to a new hashprint %newHash; print %newHash;
Produzione:
Tom23
Aggiungi hash Perl
Come puoi vedere, abbiamo già un hash %newHash e ora dobbiamo aggiungervi altre voci.
$newHash{'Jim'}=25;
$newHash{'John'}=26;
$newHash{'Harry'}=27;
print %newHash;
Produzione:
Jim25Giovanni26Harry27
Tasto Perl Elimina
Potresti voler eliminare una voce da un hash. Ecco come possiamo farlo.
delete $newHash{'Jim'};#This will delete an entry from the hash.
Elimina è una funzione incorporata di Perl. Qui vedremo un esempio di assegnazione di un hash a un array.
@array=%newHash; print "@array";
Nota: ogni volta che stampi un hash o quando memorizzi l'hash in un array. L'ordine può sempre differire. Non è sempre lo stesso.
Possiamo assegnare solo chiavi o valori di un hash a un array.
@arraykeys= keys(%newHash); @arrayvalues=values(%newHash); print "@arraykeys\n"; print "@arrayvalues\n"; # \n to print new line.
Per rimuovere tutte le voci nell'hash, possiamo assegnare direttamente l'hash a null.
%newHash=();# Questo ridefinirà l'hash senza voci.
Istruzioni condizionali Perl
Possiamo usare istruzioni condizionali in Perl. Allora, cosa sono le dichiarazioni condizionali? Le istruzioni condizionali sono quelle in cui controlli effettivamente che alcune circostanze siano soddisfatte nel tuo codice.
Pensa ad un esempio, stai comprando della frutta e non ti piace che il prezzo sia superiore a 100 dollari. Quindi la regola qui è 100 dollari.
Perl supporta due tipi di istruzioni condizionali; sono se e a meno che.
Perl Se
Se il blocco di codice verrà eseguito, quando la condizione è vera.
my $a=5;
if($a==5)
{
print "The value is $a";
}
Produzione:
5
Perl se altro
Sembra buono. Pensiamo a una situazione in cui $a non è 5.
my $a=10;
if($a==5)
{
print "The values is $a ---PASS";
}
else
{
print "The value is $a ---FAIL";
}
Produzione:
Il valore è 10 —FAIL
In questo modo possiamo controllare solo una condizione alla volta. È una limitazione? No, puoi anche controllare varie condizioni usando if... elsif... else.
Perl Altro Se
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";
}
Produzione:
Blocco elsif eseguito: il valore è 5
Nel caso precedente, il blocco elsif verrà eseguito poiché $a è uguale a 5.
Potrebbero verificarsi situazioni in cui sia i blocchi di codice if che quelli elif falliranno. In questo scenario verrà eseguito il blocco di codice else. Puoi effettivamente eliminare il controllo del codice else se non desideri includerlo.
Perl annidato se
In questo caso, è possibile utilizzare if code block in un altro if code block.
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";
}
Produzione:
All'interno del primo blocco else – Il valore è 1
Esegui lo stesso codice modificando il valore di $a; il resto puoi scoprirlo.
Perl a meno che
Hai già un'idea di cosa fa se (se la condizione è vera eseguirà il blocco di codice). A meno che sia opposto a se, a meno che il blocco di codice verrà eseguito se la condizione è falsa.
my $a=5;
unless($a==5)
{
print "Inside the unless block --- The value is $a";
}
else
{
print "Inside else block--- The value is $a";
}
Produzione:
All'interno del primo blocco else – Il valore è 1
Indovina quale sarà il risultato. Hai ragione!!!!!. L'output sarà l'istruzione print del blocco else. A causa della condizione in less code block è vera, ricorda a meno che il blocco verrà eseguito solo se la condizione è falsa. Cambia il valore di $ae esegui il codice vedrai la differenza.
Perl Utilizzando se
$a= " This is Perl";
if($a eq "SASSDSS"){
print "Inside If Block";
}
else
{
print "Inside else block"
}
Produzione:
All'interno del blocco altrimenti
Usando a meno che
$a= " This is Perl";
unless($a eq "SASSDSS"){
print "Inside unless Block";
}
else
{
print "Inside else block"
}
Produzione:
Dentro a meno che non sia bloccato
Perl Loops – Strutture di controllo
Perl supporta strutture di controllo simili ad altri linguaggi di programmazione. Perl supporta quattro tipi di strutture di controllo for, foreach, while e Until. Usiamo queste istruzioni per eseguire ripetutamente del codice.
Ciclo For Perl
Poiché il blocco di codice verrà eseguito finché la condizione non sarà soddisfatta. Prendiamo un esempio di come eseguire il looping di un array in Perl.
my @array=(1..10);
for(my $count=0;$count<10;$count++)
{
print "The array index $count value is $array[$count]";
print "\n";
}
Produzione:
Il valore dell'indice dell'array 0 è 1
Il valore dell'indice dell'array 1 è 2
Il valore dell'indice dell'array 2 è 3
Il valore dell'indice dell'array 3 è 4
Il valore dell'indice dell'array 4 è 5
Il valore dell'indice dell'array 5 è 6
Il valore dell'indice dell'array 6 è 7
Il valore dell'indice dell'array 7 è 8
Il valore dell'indice dell'array 8 è 9
Il valore dell'indice dell'array 9 è 10
Qui, nell'espressione for (), sono incluse molte istruzioni. C'è un significato per ognuno di essi.
for (inizializzazione; condizione; incremento)
Ecco un altro modo di utilizzare for.
for(1..10)
{
print "$_ n";
print "\n";
}
Produzione:
1n
2n
3n
4n
5n
6n
7n
8n
9n
10n
Perl Foreach
L'istruzione for each può essere utilizzata allo stesso modo di for; la differenza principale è che non abbiamo alcun controllo delle condizioni e alcun incremento in questo.
Prendiamo lo stesso esempio con foreach perl.
my @array=(1..10);
foreach my $value (@array)
{
print " The value is $value\n";
}
Produzione:
Il valore è 1
Il valore è 2
Il valore è 3
Il valore è 4
Il valore è 5
Il valore è 6
Il valore è 7
Il valore è 8
Il valore è 9
Il valore è 10
Foreach prende ogni elemento di un array e assegna quel valore a $var per ogni iterazione. Possiamo anche usare $_ per lo stesso.
my @array=(1..10);
foreach(@array)
{
print " The value is $_ \n"; # This is same as the above code.
}
Produzione:
Il valore è 1
Il valore è 2
Il valore è 3
Il valore è 4
Il valore è 5
Il valore è 6
Il valore è 7
Il valore è 8
Il valore è 9
Il valore è 10
Questo sembra buono per accedere agli array. Che ne dici di Hash, come possiamo ottenere chiavi e valori hash usando foreach?
Possiamo usare foreach per accedere alle chiavi e ai valori dell'hash eseguendo un loop.
my %hash=( 'Tom' => 23, 'Jerry' => 24, 'Mickey' => 25);
foreach my $key (keys %hash)
{
print "$key \n";
}
Produzione:
Mickey
Tom
Jerry
Forse ti starai chiedendo perché abbiamo usato le chiavi in foreach(). Keys è una funzione integrata di Perl con cui possiamo accedere rapidamente alle chiavi dell'hash. Che ne dici dei valori? Possiamo usare la funzione valori per accedere ai valori dell'hash.
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";
}
Produzione:
il valore è 24
il valore è 23
il valore è 25
Perl Mentre
Il ciclo While di Perl è una struttura di controllo, in cui il blocco di codice verrà eseguito finché la condizione non diventa vera.
Il blocco di codice uscirà solo se la condizione è falsa.
Prendiamo un esempio per il ciclo While di Perl.
Ecco un problema che richiederà l'input dell'utente e non verrà risolto fino al numero fornito come "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"
Produzione:
Indovina un numero compreso tra 1 e 10
9
Indovina un numero compreso tra 1 e 10
5
Indovina un numero compreso tra 1 e 10
7
Hai indovinato il numero fortunato 7
Nell'esempio precedente, la condizione while non sarà vera se inseriamo un input diverso da "7".
Se vedi come funziona while qui, il blocco di codice verrà eseguito solo se la condizione tra while è vera.
Perl fai-nel frattempo
Il ciclo while verrà eseguito almeno una volta anche se la condizione nella sezione while è falsa.
Prendiamo lo stesso esempio utilizzando do while.
$guru99 = 10;
do {
print "$guru99 \n";
$guru99--;
}
while ($guru99 >= 1);
print "Now value is less than 1";
Produzione:
10
9
8
7
6
5
4
3
2
1
Ora il valore è inferiore a 1
Perl fino a quando
Il blocco di codice Until è simile a less in un'istruzione condizionale. In questo caso, il blocco di codice verrà eseguito solo se la condizione nel blocco Until è falsa.
Prendiamo lo stesso esempio che abbiamo usato in caso di tempo.
Ecco un problema che richiederà l'input dell'utente e non verrà risolto finché non verrà fornito un nome diverso da "sai".
print "Enter any name \n";
my $name=<STDIN>;
chomp($name);
until($name ne 'sai')
{
print "Enter any name \n";
$name=<STDIN>;
chomp($name);
}
Produzione:
Inserisci un nome qualsiasi, sai
Perl do-fino a:
Do Until può essere utilizzato solo quando è necessario che una condizione sia falsa e dovrebbe essere eseguito almeno una volta.
print "Enter any name \n";
my $name=<STDIN>;
chomp($name);
do
{
print "Enter any name \n";
$name=<STDIN>;
chomp($name);
}until($name ne 'sai');
Produzione:
Inserisci un nome qualsiasi Howard
Inserisci un nome qualsiasi, Sheldon
Inserisci un nome qualsiasi, sai
Esegui while, do- while, Until e do-until codici di esempio per vedere la differenza.
Perl Operator
Cosa è Operatore?
OperaI motori nel linguaggio informatico indicano un'azione che può essere eseguita su un insieme di variabili o valori che il computer può comprendere. Perl ha incorporato la maggior parte dei Operaoperatori del linguaggio C. Perl ha molti operatori rispetto ad altri linguaggi di programmazione. OperaGli operatori sono classificati come aritmetici, logici, relazionali e di assegnazione.
Aritmetica Operatori:
Gli operatori aritmetici sono quelli che possono essere utilizzati per eseguire alcune operazioni matematiche di base. Questi operatori aritmetici sono operatori binari in cui sono necessari due argomenti per eseguire un'operazione di base. Possiamo anche utilizzare gli operatori unari per altre operazioni di base; puoi vedere la differenza negli esempi seguenti.
| Operator | Descrizione | Esempio |
|---|---|---|
|
+ |
Operazione di addizione utilizzata per aggiungere due valori o variabili detenere valori |
$x=5+6; # O $y=6; $z=$x+$y; |
|
- |
Operatore di sottrazione utilizzato per sottrarre due valori o variabili che contengono valori |
$x=6-5; # O $y=6; $z=$x-$y; |
|
* |
Operatore di moltiplicazione utilizzato per moltiplicare due valori o variabili che contengono valori |
$x=6*5; # O $y=6; $z=$x*$y; |
|
/ |
Operatore di divisione utilizzato per dividere due valori o variabili che contengono valori |
$x=36/6; # O $y=6; $z=$x/$y; |
|
** |
L'operatore esponenziale utilizzato per fornire l'esponente e ottenere il valore. Es: 22 = 43 = 27 |
$x=5**5; # O $x=4; $y=2; $z=$x**$y; |
|
% |
Operatore modulo utilizzato per ottenere il promemoria durante la divisione di due valori o variabili che contengono valori |
$x=5%2; # O $x=10; $y=2; $z=$x % $y; |
|
++ |
Operatore di addizione unario per incrementare il valore di una variabile di 1 |
$x=5; $x++; Or ++$x; |
|
- |
Operatore di sottrazione unaria per diminuire il valore di una variabile di 1 |
$x=5; $x–; # post decremento Or –$x;# pre-decremento |
Esempio per completare tutte le operazioni sopra indicate.
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");
Produzione:
La somma di 10 e 2 fa 12
Il sottotitolo di 10 e 2 fa 8
Mul di 10 e 2 fa 20
Div di 10 e 2 è 5
L'Exp di 10 e 2 è 100
Mod di 10 e 2 è 0
Assegnazione Operatori:
Gli operatori di assegnazione assegnano semplicemente valori alle variabili, ma c'è un'altra cosa che dobbiamo ricordare qui, gli operatori di assegnazione eseguiranno anche operazioni aritmetiche e assegneranno il nuovo valore alla stessa variabile su cui viene eseguita l'operazione.
| Operator | Descrizione | Esempio |
|---|---|---|
|
+= |
Operatore di addizione utilizzato per aggiungere e assegnare il valore alla stessa variabile |
$x=4; $x+=10; |
|
-= |
Operatore di sottrazione utilizzato per sottrarre e assegnare il valore alla stessa variabile |
$x=4; $x-=10; |
|
*= |
Operatore di moltiplicazione utilizzato per sommare e assegnare il valore alla stessa variabile |
$x=4; $x*=10; |
|
/= |
Operatore di divisione utilizzato per dividere e assegnare il valore alla stessa variabile |
$x=4; $x/=10; |
|
** = |
Operatore esponenziale utilizzato per ottenere l'esponente e assegnare il valore alla stessa variabile |
$x=4; $x**=10; |
|
%= |
Operatore modulo utilizzato per ottenere un promemoria durante la divisione e assegnare il valore alla stessa variabile |
$x=10; $x%=4; |
Esempio per completare tutte le operazioni sopra indicate.
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");
Produzione:
Aggiungi = 15
Sotto=10
Mul = 50
Div = 10
Logico e relazionale Operatori:
Perl utilizza operatori logici per confrontare numeri e stringhe. Nella maggior parte dei casi gli operatori logici vengono utilizzati nelle istruzioni condizionali.
Logico e relazionale Operatori in Perl
| Operator | Descrizione |
|---|---|
|
==o eq |
Operator utilizzato per verificare se entrambe le variabili sono uguali |
|
!=Oppure no |
Operator utilizzato per verificare se entrambe le variabili non sono uguali |
|
> o g |
Operator usato per verificare se A è maggiore di B |
|
<or lt |
Operator usato per verificare se A è minore di B |
|
>=o ge |
Operator usato per verificare se A è maggiore o uguale a B |
|
<=o le |
Operator usato per verificare se A è minore o uguale a B |
|
|| o o |
Operautilizzato per verificare che A o B mantengano valore |
|
&&o e |
Operator utilizzato per verificare che sia A che B mantengano valore |
Facciamo un esempio in cui possiamo spiegare tutti gli scenari.
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");
}
Produzione:
Vero: uguale 5 e 5
Vero, non uguale a 6 e 7
Vero: 7 maggiore di 6
Vero: 6 meno di 7
Vero: 6 meno di 7
Vero: 7 maggiore di 6
Esempi di operatori logici sono disponibili nelle sezioni successive.
Variabili speciali Perl
Cosa sono le variabili speciali di Perl?
Le variabili speciali in Perl sono quelle che hanno un significato predefinito. Queste variabili sono indicate con nomi reali o simboli di punteggiatura. Abbiamo una variabile speciale per tutte le variabili supportate da Perl come variabili speciali scalari, variabili speciali di array, variabili speciali hash. La maggior parte delle variabili speciali che usiamo sono scalari.
Quando vogliamo utilizzare la variabile speciale con il suo nome, dobbiamo caricare un modulo Perl 'use English', per dire esplicitamente all'interprete Perl che utilizzeremo variabili speciali utilizzando il suo nome.
Variabili speciali scalari
| Variabile | Descrizione |
|---|---|
|
$_$ARG |
Questa è la variabile predefinita che memorizza i valori correnti. |
|
$ 0 o $PROGRAM_NAME |
Memorizza il nome del file dello script Perl. |
|
$/ |
Il separatore del record di input ha il valore predefinito '\n' che è il carattere di nuova riga |
|
$. |
Contiene il numero di riga corrente del file che viene letto |
|
$, |
Separatore del campo di output, viene utilizzato principalmente dall'istruzione print(). Per impostazione predefinita, il valore è impostato su 0, possiamo modificare il valore di questa variabile. |
|
$\ |
Separatore del record di output, il valore di questa variabile sarà vuoto; possiamo assegnare qualsiasi valore a questo, che verrà utilizzato dall'istruzione print() durante la stampa dell'output. |
|
$# |
Questa variabile viene utilizzata per il formato di output durante la stampa dei numeri. |
|
$%$FORMAT_PAGE_NUMBER |
Manterrà il numero di pagina corrente del file letto. |
|
$=$FORMAT_LINES_PER_PAGE |
Manterrà la lunghezza della pagina corrente del file letto. |
|
$-$FORMAT_LINES_LEFT |
Contiene il valore del numero di righe rimaste da stampare dalla pagina. |
|
$~$FORMAT_NAME |
Nome formato: contiene il formato dell'output attualmente selezionato per impostazione predefinita, il nome dell'handle del file. |
|
$^$FORMAT_TOP_NAME |
Contiene il valore del formato dell'intestazione del gestore di file, per impostazione predefinita il valore sarà _TOP seguito dal nome del gestore di file. |
|
$|$OUTPUT_AUTOFLUSH |
Il valore predefinito è zero; questo valore viene utilizzato per svuotare il buffer di output dopo ogni write() o print(). |
|
$$ |
Manterrà il numero del processo in esecuzione dell'interprete Perl. |
|
$? |
Codice di stato: chiamata di tubo e di sistema. Lo stato di ritorno del comando eseguito. |
|
$&$PARTITA |
Utilizzato nelle espressioni regolari, conterrà una stringa dell'ultimo pattern match riuscito. |
|
$`$PREMATCH |
Utilizzato nelle espressioni regolari, manterrà la stringa preceduta dall'ultimo pattern match riuscito. |
|
$'$POST PARTITA |
Utilizzato nelle espressioni regolari, conterrà una stringa seguita dall'ultimo pattern match riuscito. |
|
$+$LAST_PAREN_MATCH |
Contiene la stringa dell'ultima parentesi che corrisponde all'ultimo modello di ricerca. |
|
$ |
$ 1, $ 2, $ 3…. Mantiene i valori del modello abbinati in ordine. |
|
$[ |
Primo indice: Array, una sottostringa. |
|
$] |
Una versione di Perl. |
|
$” |
Il separatore utilizzato per gli elementi dell'elenco, per impostazione predefinita, è uno spazio bianco. |
|
$; |
Separatore di pedice utilizzato negli array multidimensionali |
|
$! |
In contesto numerico, stampa il numero dell'errore. Nel contesto di una stringa, stampa l'errore. |
|
$@ |
Manterrà le informazioni sull'errore di sintassi, utilizzate quando viene utilizzato eval(). |
|
$< |
Contiene l'UID reale (ID utente) del processo che esegue lo script. |
|
$> |
Contiene l'UID effettivo del processo che esegue lo script. |
|
$( |
Contiene il GID reale (ID gruppo) del processo che esegue lo script. |
|
$) |
Contiene il GID effettivo del processo che esegue lo script. |
|
$^D$DEBUG |
Contiene il valore corrente dei flag di debug. |
|
$^C |
Mantiene il valore corrente del flag quando viene utilizzata l'opzione della riga di comando –c. |
|
$^F |
Il descrittore massimo di file di sistema, per valore predefinito, è impostato su 2 |
|
$^I$INPLACE_EDIT |
Contiene il valore dell'opzione della riga di comando –i. |
|
$^M |
È possibile utilizzare un pool di memoria speciale quando lo script Perl muore a causa di un errore di memoria esaurita. |
|
$^O$NOMEOS |
Operavengono memorizzate le informazioni di sistema. 'Linux' per i sistemi Linux, 'mswin32' per Windows sistemi. |
|
$^T$BASETIME |
Il tempo in cui gli script vengono eseguiti in secondi. |
|
$^W$ATTENZIONE |
Il valore corrente dell'opzione della riga di comando –w. Interruttore di avviso. |
|
$ARGV |
Nome del file corrente, quando viene utilizzato <>. |
Variabili speciali dell'array:
| Variabile | Descrizione |
|---|---|
|
@INC |
Contiene un elenco di percorsi in cui è possibile esaminare i moduli o gli script della libreria Perl durante l'esecuzione dello script corrente. Questo @INC viene utilizzato dalle istruzioni use e require per cercare in quei percorsi i moduli della libreria. |
|
@ARGV |
Memorizza gli argomenti della riga di comando passati. |
|
@_ |
Utilizzato nelle subroutine, durante il passaggio dei parametri alle subroutine. |
|
@F |
Questo è l'array in cui vengono memorizzate le righe di input quando viene utilizzata la suddivisione automatica –a (viene utilizzato lo switch della riga di comando). |
Variabili speciali hash:
| Variabile | Descrizione |
|---|---|
|
%INC |
Il nome del file sarà le chiavi; i valori saranno il percorso di quei file. Utilizzato da fare, utilizzare e richiedere. |
|
% ENV |
Variabili ambientali del sistema. |
|
%SIG |
Signals gestore. |
Espressione regolare Perl
Cos'è l'espressione regolare?
L'espressione regolare di Perl è sufficientemente forte da far corrispondere i modelli di stringa all'interno di un'istruzione o di un gruppo di istruzioni. Le espressioni regolari vengono utilizzate principalmente nell'analisi del testo, nella corrispondenza dei modelli e molto altro in base ai requisiti. Abbiamo alcuni operatori, che vengono utilizzati specialmente dal pattern binding delle espressioni regolari =~ e !~, Questi sono operatori di test e di assegnazione.
Regular Expression OperaTors
Regular Expression Operatori in Perl
- Perl Match — m//
- Sostituto Perl – s///
- Traslitterazione Perl – tr///
Prima di andare oltre, dobbiamo sapere alcune cose sulle espressioni regolari; ci sono alcune cose come i caratteri Meta, i caratteri jolly nella sintassi Perl Regex.
| carbonizzare | Significato |
|---|---|
|
\ |
Speciale o preventivo |
|
* |
Corrisponde a 0 o più caratteri |
|
+ |
Corrisponde a 1 o più caratteri |
|
? |
Corrisponde a 0 o 1 carattere |
|
| |
Può essere utilizzato per abbinare modelli alternativi |
|
() |
Utilizzato per memorizzare il modello abbinato |
|
[] |
È possibile passare un set di caratteri. Specificamente utilizzato per numeri e alfabeti. |
|
{} |
Utilizzato per fornire il numero di volte in cui è possibile eseguire la partita. |
|
^ |
Inizio della corda |
|
$ |
Fine della stringa |
|
\w |
Utilizzato per corrispondere a un singolo carattere o parola che può essere alfanumerico incluso "_" |
|
\W |
Corrisponde a qualsiasi cosa diversa da quella alfanumerica |
|
\s |
Utilizzato per abbinare gli spazi bianchi |
|
\S |
Corrisponde a qualsiasi cosa diversa dagli spazi bianchi |
|
\d |
Abbina i numeri. Non valori decimali e valori negativi |
|
\D |
Abbina qualsiasi cosa diversa dai numeri. |
|
\t |
Abbina lo spazio della scheda |
|
\n |
Corrisponde a nuova riga |
Quelli sopra riportati sono l'insieme di caratteri che possono essere utilizzati durante la corrispondenza dei modelli.
Vediamo alcuni esempi.
Considera una situazione in cui l'utente fornisce alcuni input durante l'esecuzione dello script e vogliamo verificare se l'utente ha inserito o meno un nome come input. Dobbiamo scrivere una sintassi di espressione regolare per estrarre il tuo nome e stampare lo stesso.
my $userinput="Guru99 Rocks";
if($userinput=~m/.*(Guru99).*/)
{
print "Found Pattern";
}
else
{
print "unable to find the pattern";
}
Produzione:
Modello trovato
Qui abbiamo scritto l'espressione regolare come /.*(Guru99).*/.* corrisponde a tutti i caratteri in una stringa. UN '.' in Perl la corrispondenza regex si riferisce a qualsiasi carattere compreso lo spazio.
Vediamo come possiamo costruire esattamente una Regex.
Considera un esempio di una stringa di più parole e cifre e simboli speciali come questo "Ciao a tutti, questo è il mio numero: +91-99298373639";
Regex : /^\w+\s\w+\s\w+\s\w+\s\w+\s\w+\:\+\d+\-\d+/i
Parola spazio parola spazio parola spazio parola spazio parola spazio parola spazio carattere speciale: spazio carattere speciale+cifre carattere speciale –cifre.
Perl Match OperaTors
Gli operatori di corrispondenza vengono utilizzati per abbinare una stringa all'interno di alcune istruzioni o in una variabile.
my $var="Hello this is perl";
if($var=~m/perl/)
{
print "true";
}
else
{
print "False";
}
Produzione:
vero
Questo piccolo codice verrà stampato come "vero", poiché il modello di corrispondenza Perl identifica la stringa in una variabile. Fondamentalmente, Perl cerca il testo fornito in // in tutta la stringa, anche se lo trova in un punto restituirà 'true'. Il modello può trovarsi ovunque nella variabile. Possiamo provare a sostituire =~ con !~ per vedere la differenza tra questi due operatori.
Sostituzione Perl Operator
Questo operatore può essere utilizzato per cercare e sostituire qualsiasi carattere con null o con un altro carattere.
my $a="Hello how are you"; $a=~s/hello/cello/gi; print $a;
Produzione:
violoncello, come stai?
Nota: possiamo effettivamente utilizzare qualsiasi stringa di corrispondenza del modello come abbiamo fatto in precedenza anche in questo operatore di sostituzione. Qui abbiamo usato 'gi', g-globally, i-ignore case.
Traduzione Perl Operator
È simile a Substitution, ma non utilizza alcuna espressione regolare Perl, piuttosto possiamo passare direttamente il valore o una parola che vogliamo sostituire.
my $a="Hello how are you"; $a=~tr/hello/cello/; print $a;
Produzione:
Ciao mucca, sei tu
I/O dei file Perl
Perl è stato progettato per manipolare file e operazioni di I/O in modo efficace. Il vantaggio principale di Perl è nell'analisi e nella gestione dei file. Ci sono molte funzioni e operatori integrati utilizzati durante la gestione dei file in Perl.
Fondamentalmente, le operazioni sui file eseguite con Perl vengono eseguite utilizzando FILEHANDLE. Dobbiamo definire questo FILEHANDLE durante l'apertura di un file sia in lettura che in scrittura.
In questo tutorial sugli script Perl imparerai:
Perl Apri il file
Possiamo aprire un file utilizzando la funzione open() disponibile in Perl.
open(FILEHANDLE, "filename or complete path of the file");
Ora abbiamo aperto un file, ora sorge una domanda. Serve per leggere o scrivere?
Perl Leggi file e Perl Scrivi file
Perl ha determinate modalità che devono essere utilizzate per leggere, scrivere o aggiungere un file.
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");
Alcuni esempi di lettura di un file:
Considera che abbiamo un file Perl con il nome file.txt e contiene poche righe di testo. Dobbiamo aprire questo file e stampare lo stesso.
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;
Questo stamperà il contenuto del file sulla schermata di output.
Ora scriveremo un programma per creare e scrivere dati in un file perl.
open(FH,">test.txt"); my $var=<>; print FH $var; close FH;
Questo scriverà l'input fornito durante il runtime e creerà un file test.txt che conterrà l'input.
Il metodo sopra descritto proverà sempre a creare un file denominato test.txt e scriverà l'input nel file; scriveremo lo stesso per aggiungere il file.
open(FH,">>test.txt"); my $var=<>; print FH $var; close FH;
| Modalità | Descrizione |
|---|---|
|
< |
Leggi |
|
+< |
Legge e scrive |
|
> |
Crea, scrive e tronca |
|
+> |
Leggere, scrivere, creare e troncare |
|
>> |
Scrive, aggiunge e crea |
|
+>> |
Leggere, scrivere, aggiungere e creare |
Ora dobbiamo vedere come leggere, scrivere e aggiungere file utilizzando esempi di base.
Vedremo alcuni altri esempi e altre funzioni che aiutano a comprendere meglio i file.
Perl Tell
Questo metodo restituirà la posizione corrente di FILEHANDLER in byte se specificato altrimenti considererà l'ultima riga come posizione.
open(FH, "test.pl");
while(<FH>)
{
$a=tell FH;
print "$a";
}
Ricerca Perl
La funzione di ricerca è simile alla chiamata di sistema fseek. Questo metodo viene utilizzato per posizionare il puntatore del file in una posizione specifica specificando i byte seguiti dall'inizio o dalla fine del puntatore del file.
seek FH, bytes, WHENCE;
DOVE è la posizione del puntatore del file da cui iniziare. Zero lo imposterà dall'inizio del file.
Esempio: lascia che input.txt contenga alcuni dati come "Ciao, questo è il mio mondo".
open FH, '+<','input.txt'; seek FH, 5, 0; # This will start reading data after 5 bytes. $/ = undef; $out = <FH>; print $out; close FH;
Produzione:
questo è il mio mondo
Perl Scollega
Lo scollegamento viene utilizzato per eliminare il file.
unlink("filename or complete file path");
Gestione delle directory:
Possiamo anche gestire directory attraverso le quali possiamo gestire più file.
vediamo come aprire una directory. Possiamo usare i metodi opendir e 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);
Questo stamperà tutti i file disponibili in quella directory.
Test dei file Perl e loro significato
|
-r |
Per verificare se il file/directory è leggibile dall'utente/gruppo corrente |
|
-w |
Per verificare se il file/directory è scrivibile dall'utente/gruppo corrente |
|
-x |
Per verificare se il file/directory è eseguibile dall'utente/gruppo corrente |
|
-o |
Per verificare se il file/directory è di proprietà dell'utente corrente |
|
-R |
Per verificare se il file/directory è leggibile da questo utente/gruppo reale |
|
-W |
Per verificare se il file/directory è scrivibile da questo utente/gruppo reale |
|
-X |
Per verificare se il file/directory è eseguibile da questo utente/gruppo reale |
|
-O |
Per verificare se il file/directory è di proprietà di questo utente reale |
|
-e |
Per verificare se il nome del file/directory esiste |
|
-z |
Per verificare se il file esiste e ha dimensione zero (sempre falso per le directory) |
|
-f |
Per verificare se Entry è un file semplice |
|
-d |
Per verificare se Entry è una directory |
|
-l |
Per verificare se Entry è un collegamento simbolico |
|
-S |
Per verificare se Entry è un socket |
|
-p |
Per verificare se Entry è una pipe denominata (una "FIFO") |
|
-b |
Per verificare se Entry è un file speciale a blocchi (come un disco montabile) |
|
-c |
Per verificare se Entry è un file di caratteri speciali (come un dispositivo I/O) |
|
-u |
Per verificare se il file o la directory è setuid |
|
-g |
Per verificare se il file o la directory sono setgid |
|
-k |
Per verificare se il file o la directory hanno lo sticky bit impostato |
|
-t |
Il filehandle fornito è un TTY (come per la funzione di sistema isatty(), i nomi dei file non possono essere testati da questo test) |
|
-T |
Per verificare se il file assomiglia a un file di "testo". |
|
-B |
Per verificare se File assomiglia a un file "binario". |
|
-M |
Per verificare l'età della modifica (misurata in giorni) del file |
|
-A |
Per verificare l'età di accesso (misurata in giorni) del file |
|
-C |
Per verificare l'età di modifica dell'inode (misurata in giorni) del file |
Subroutine Perl
Cos'è la subroutine?
subroutine sono simili alle funzioni di altri linguaggi di programmazione. Abbiamo già utilizzato alcune funzioni integrate come print, chomp, chomp, ecc. Possiamo scrivere le nostre subroutine in Perl. Queste subroutine possono essere scritte ovunque nel programma; è preferibile posizionare i sottoprogrammi all'inizio o alla fine del codice.
Esempio di subroutine
sub subroutine_name
{
Statements…; # this is how typical subroutines look like.
}
Ora che sappiamo come scrivere una subroutine, come possiamo accedervi?
Dobbiamo accedere o chiamare una subroutine utilizzando il nome della subroutine preceduto dal simbolo "&".
sub display
{
print "this is a subroutine";
}
display(); # This is how we call a subroutine
Passaggio di parametri Perl e argomenti Perl
Le subroutine o le funzioni Perl vengono scritte per inserire al loro interno il codice riutilizzabile. La maggior parte del codice riutilizzabile richiede che i parametri vengano passati alla subroutine. Qui impareremo come passare gli argomenti alla subroutine.
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.
Produzione:
3 è il valore passato
@_ è una variabile array speciale che memorizza gli argomenti passati alle subroutine.
Perl Shift
Possiamo anche usare la parola chiave 'shift' che sposta un parametro alla volta in una variabile o $_[0],$_[1]... che è un singolo elemento dell'array @_
sub display
{
my $var=shift;
print "$var is passed";
}
display("hello");
Produzione:
ciao è passato
Le subroutine vengono generalmente utilizzate nella programmazione orientata agli oggetti e anche in luoghi in cui è possibile inserire più codice riutilizzabile.
La funzionalità principale delle subroutine è eseguire alcune attività e restituire il risultato del codice riutilizzabile.
Possiamo restituire un valore dalla subroutine utilizzando la parola chiave return.
sub add
{
my $a=shift;
my $b=shift;
return($a+$b);
}
my $result=add(5,6);
print $result;
Produzione:
11
$result manterrà il valore di $a e $b aggiunti.
Possiamo anche passare hash e array direttamente alla subroutine.
sub hash
{
my %hash=@_;
print %hash;
}
%value= ( 1=>'a', 2=>'b');
&hash(%value);
Produzione:
1a2b
Possiamo anche restituire un hash o un array.
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;
Produzione:
All'interno della subroutine2b1aDopo la chiamata della subroutine2b1a
Formato Perl
Perl ha un meccanismo tramite il quale possiamo generare report. Utilizzando questa funzionalità, possiamo creare report esattamente come vogliamo, mentre li stampiamo sullo schermo Output o in un file. Un formato semplice può essere scritto utilizzando le funzioni printf o sprintf disponibili in Perl.
printf "%05d\n", 30;
Ciò includerà degli zeri iniziali davanti al numero 30, per un conteggio totale delle cifre pari a 5. Lo stesso può essere utilizzato per sprintf.
sprintf "%05d\n", 30; # This will print the same as printf.
Utilizzando printf e sprintf, possiamo ottenere la maggior parte dei formati Perl. Nel caso dei report, sarà difficile da implementare.
================================================== =========================
Nome Indirizzo Età Telefono
================================================== =========================
Krishna Chennai 24 929309242
Shruthi Chennai 24 929309232
Quanto sopra è un esempio che segnala che dobbiamo stampare nello stesso modo in Perl. Questo può essere ottenuto usando perl printf e perl sprintf. Può essere implementato efficacemente usando format.
Un formato può essere dichiarato nel modo seguente.
format FORMATNAME=FORMATLIST.
Qui utilizzeremo un particolare metodo di scrittura per stampare i dati sulla schermata di output o nel file.
| Simbolo | Descrizione |
|---|---|
|
@ |
Utilizzato per rappresentare l'inizio del titolare del campo |
|
> |
Giusto allineamento del testo |
|
< |
Allineamento del testo a sinistra |
|
| |
Allineamento centrale |
|
# |
Numerico se sono forniti più #. Assume come commento se viene fornito un singolo # |
|
. |
Punto decimale |
|
^ |
L'inizio del titolare del campo può essere utilizzato anche per multiriga e anche per il ritorno a capo automatico |
|
~ |
La riga dovrebbe essere vuota se la variabile è vuota |
|
@* |
Linee multiple. |
($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
.
Esegui il codice per vedere l'output.
Stiamo utilizzando il simbolo @ per specificare l'inizio del titolare del campo o della stringa, '<' ogni carattere.
Stiamo utilizzando STDOUT per stampare sull'output standard. Possiamo cambiarlo nel gestore di file che stiamo utilizzando per scrivere i dati nel file.
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
Possiamo sostituire '<' con '>' o '|' per modificare l'allineamento del testo.STDOUT_TOP viene utilizzato per progettare l'intestazione del formato. Possiamo anche utilizzare lo stesso con il gestore di file utilizzando FH_TOP (FH è il gestore di file). Ciò restituirà il formato al file su cui stiamo lavorando SU.
Standard di codifica Perl
Ogni programmatore avrà il proprio senso di scrivere il codice utilizzando determinati standard; questi standard dovrebbero essere sufficientemente familiari da consentire ad altri programmatori di comprendere e supportare correttamente il codice.
Standard di codifica in Perl
Scrivere codice è semplice e facile. Il problema sorge quando è necessario mantenerlo in fasi successive. Durante la scrittura del codice, è necessario seguire linee guida e standard di codifica appropriati. Perl definisce anche alcuni standard che saranno utili ai programmatori per scrivere codice. Si consiglia di caricare 'strict' e 'warnings module' durante la scrittura del codice. Ognuno di questi moduli ha la sua importanza. Strict ci farà dichiarare la variabile prima di utilizzarla e ci dirà anche se nel codice è presente una parola nuda. In alternativa, il modulo Warnings può essere utilizzato passando l'opzione '-w' all'interprete Perl in shebang. Gli Warnings verranno stampati sullo schermo di output.
#!/usr/bin/perl –w
Di seguito sono riportati alcuni elenchi di standard.
- Utilizza i moduli 'rigorosi' e 'avvisi'.
- Rimuovi la variabile che non è in uso.
- I nomi delle variabili dovrebbero essere comprensibili agli altri utenti. Esempio: $nome, @fileData ecc.
- La documentazione è richiesta durante la codifica di uno script.
- Non codificare alcun valore, piuttosto provare a recuperarli dinamicamente o chiedere all'utente di inserirli durante il runtime (percorso file, nomi file).
- Massimizza il riutilizzo del codice. Prova a inserire il codice riutilizzabile nelle subroutine.
- Il significato dei nomi completi dovrebbe essere dato alle subroutine.
- Le subroutine devono essere scritte con commenti e documentazione appropriati.
- Inizializza sempre le variabili.
- Controlla sempre i codici di ritorno per le chiamate di sistema. L'apertura di un file può avvenire o meno, avere un codice di ritorno qui visualizzerà lo stato di errore se il file non esiste.
Esempio: aperto(FH,
- La subroutine dovrebbe sempre restituire un valore.
- Apri i ricci sulla stessa linea.
- Il BLOCCO a linea singola può essere posizionato in una linea singola con riccio.
- Usa le etichette durante i LOOPS, sarà facile uscire dal loop ogni volta che sarà necessario.
- Utilizzare il carattere di sottolineatura mentre frasi lunghe di parole vengono scritte come nome di variabile o subroutine.
- Prova a utilizzare semplici espressioni regolari durante la codifica.
Esempio perfetto con standard di codifica:
#######################################################################
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
Gestione degli errori Perl
Che cos'è un'eccezione?
Un'eccezione è un evento che si verifica durante l'esecuzione del programma e che sospenderà o terminerà il programma.
Gestione degli errori
La gestione degli errori è quella di cui ogni programmatore deve occuparsi durante la programmazione. Perl fornisce anche tecniche di gestione degli errori con le quali possiamo intercettare l'errore e gestirlo di conseguenza.
Gestione degli errori in Perl
Esistono molti modi per verificare la presenza di errori nel programma. Dobbiamo esaminare i codici di ritorno del codice della funzione che stiamo utilizzando. Se siamo in grado di gestire correttamente questi codici di ritorno, è possibile ottenere la maggior parte della gestione degli errori.
Cosa restituirà in caso di chiamate di sistema?
Nel caso delle chiamate di sistema, lo stato restituito verrà memorizzato in due variabili speciali $? E $!
$! – Ciò rileverà il numero di errore o il numero di errore associato al messaggio di errore.
$? – Ciò manterrà la funzione return status system().
Utilizzando l'operatore Perl o Logico
Possiamo utilizzare l'operatore logico o per la gestione degli errori durante l'utilizzo delle chiamate di sistema.
Es:
open(FH,"<test.txt");
Questo aprirà il file in modalità lettura se il file esiste.
Cosa succede se manca il file?
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
Valutazione Perl
La funzione Eval può gestire errori fatali, errori in fase di compilazione, errori di runtime e quegli errori che terminano il codice in un determinato momento.
La funzione Perl Eval può avere un blocco di codice o un'espressione. Evals considera tutto ciò che vi viene inserito come una stringa.
Consideriamo la situazione in cui si chiama una subroutine che non è definita nello script. In questa situazione, lo script termina affermando "subroutine non definita &XYZ, questo errore può essere gestito nella funzione eval.
Esistono molti usi del blocco evals; uno di questi usi è quando vogliamo caricare il modulo specifico del sistema operativo durante il runtime.
Esempio: la divisione per zero provoca un errore fatale; per gestire questo possiamo inserire il codice nel blocco evals.
$a=5;
$b=0;
eval
{
'$result=$a/$b';
}
if($@)
{
print "$@"; # All the error codes returned by evals will get stored in $@.
}
Produzione:
errore di sintassi in C:\Users\XYZ\Text.pl riga 8, vicino a ")
{"
Esecuzione di C:\Users\XYZ\Text.pl interrotta a causa di errori di compilazione.
Esempio: eval utilizzando l'istruzione perl die.
sub test
{
die "Dieing in sub test \n";
}
eval
{
test();
};
print "Caught : $@\n";
Produzione:
Catturato: Morire nel sub-test
Utilizzo di Perl Prova
Perl non supporta i blocchi try, catch e final code come altri linguaggi di programmazione. Possiamo ancora usarli caricando un modulo Perl esterno.
usa Prova::Tiny;
Usando questo possiamo inserire il tuo codice nel blocco try e rilevare l'errore nel blocco warn.
Al posto di $@ usato in eval Try::Tiny usa $_.
# gestire gli errori con un gestore catch
try
{
die "Die now";
}
catch
{
warn "caught error: $_"; # not $@
};
Utilizzando finalmente.
my $y;
try
{
die 'foo'
}
finally
{
$y = 'bar'
};
try
{
die 'Die now'
}
catch
{
warn "Returned from die: $_"
}
finally
{
$y = 'gone'
};
Produzione:
foo in C:\Users\XYZ\Text.pl riga 4.
Possiamo usare try, catch e finalmente in questo modo.
prova { # istruzione }
prendi {# istruzione }
infine { # istruzione };
Or
try
{
# statement
}
finally
{
# statement
};
Produzione:
Or
try
{
# statement
}
finally
{
# statement
}
catch
{
# statement
};
Produzione:
Programmazione Perl Socket
Cos'è una presa?
Il socket è un mezzo attraverso il quale due computer possono interagire su una rete utilizzando l'indirizzo e le porte di rete.
Supponiamo che A (Server) e B (Client) siano due sistemi, che devono interagire tra loro utilizzando Socket per eseguire alcuni programmi.
Per implementare ciò dobbiamo creare socket sia in A (Server) che in B (Client), A sarà nello stato di ricezione e B sarà nello stato di invio.
A (Server):
Qui, il server desidera ricevere una connessione da B (Client) ed eseguire alcune attività e inviare il risultato a B (Client). Quando eseguiamo il codice, il sistema operativo in A tenta di creare un socket e associa una porta a quel socket. Quindi ascolterà dal mittente che è B.
B (Cliente).
Qui, il client desidera inviare un programma dal suo sistema ad A (Server) per alcune elaborazioni. Quando eseguiamo il codice, il sistema operativo in B tenta di creare un socket per comunicare con A (Server), B deve specificare l'indirizzo IP e il numero di porta di A a cui B desidera connettersi.
Se tutto va bene, entrambi i sistemi interagiranno per scambiare le informazioni attraverso una porta. Perl supporta anche la programmazione socket.
Perl ha un'API nativa attraverso la quale è possibile implementare i socket. Per semplificare, ci sono molti moduli CPAN con i quali scriviamo programmi socket.
Operazioni del server:
- Crea presa
- Associa il socket con l'indirizzo e la porta
- Ascolta il socket su quell'indirizzo di porta
- Accetta le connessioni client che tentano di connettersi utilizzando la porta e l'IP del server
- Eseguire le operazioni
. Operazioni:
- Crea presa
- Connettiti al server utilizzando l'indirizzo della sua porta
- Eseguire le operazioni
Presa.io
Questo è un modulo per la programmazione socket, che si basa sulla programmazione orientata agli oggetti. Questo modulo non supporta il tipo di rete INET utilizzato nelle reti.
IO::Presa::INET:
Questo modulo supporta il dominio INET ed è basato su IO::Sockets. Tutti i metodi disponibili in IO::Sockets sono ereditati nel modulo INET.
Client e server che utilizzano il protocollo TCP:
TCP è un protocollo orientato alla connessione; utilizzeremo questo protocollo per la programmazione del socket.
Prima di procedere oltre vediamo come possiamo creare un oggetto per il modulo IO::Socket::INET e creare 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";
Il nuovo metodo nel modulo IO::Socket::INET accetta un hash come parametro di input per la subroutine. Questo hash è predefinito e dobbiamo solo fornire i valori alle chiavi che vogliamo utilizzare. C'è un elenco di chiavi utilizzate da questo hash.
|
PeerAddr |
Indirizzo dell'host remoto |
|
PeerHost |
Sinonimo di PeerAddr |
|
PeerPort |
Porta o servizio remoto |
|
Indirizzo locale |
Indirizzo di collegamento dell'host locale |
|
Localhost |
Sinonimo di LocalAddr |
|
Porta locale |
Porta di collegamento dell'host locale |
|
Proto |
Nome del protocollo (o numero) |
|
Tipo |
Tipo di socket |
|
Ascoltare |
Dimensioni della coda per l'ascolto |
|
RiutilizzaInd |
Imposta SO_REUSEADDR prima dell'associazione |
|
Riutilizzo |
Imposta SO_REUSEADDR prima dell'associazione |
|
RiutilizzaPorta |
Imposta SO_REUSEPORT prima dell'associazione |
|
Broadcast |
Imposta SO_BROADCAST prima dell'associazione |
|
timeout |
Valore di timeout per varie operazioni |
|
MultiHomed |
Prova tutti gli indirizzi per host multihomed |
|
Prodotti di blocco |
Determina se la connessione sarà in modalità di blocco |
Server.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);
Cliente.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);
Nota:
Nella programmazione del socket, dovremo eseguire prima Server.pl e poi client.pl individualmente in diversi prompt dei comandi se stiamo eseguendo l'host locale.
Che cosa sono i moduli e i pacchetti Perl
Moduli e pacchetti sono strettamente correlati tra loro e sono indipendenti. Pacchetto: un pacchetto Perl è anche noto come spazio dei nomi e contiene tutte le variabili univoche utilizzate come hash, array, scalari e subroutine. Modulo: il modulo è una raccolta di codice riutilizzabile, in cui scriviamo subroutine. Questi moduli possono essere caricati nei programmi Perl per utilizzare le subroutine scritte in quei moduli.
Cosa sono i moduli Perl?
I moduli standard verranno installati durante l'installazione di Perl su qualsiasi sistema. CPAN: Perl completo Archive Network – Un repository globale di moduli Perl. I nostri moduli Perl personalizzati che possono essere scritti da noi. Fondamentalmente, un modulo quando caricato in qualsiasi script esporterà tutte le sue variabili globali e subroutine. Queste subroutine possono essere richiamate direttamente come se fossero dichiarate nello script stesso. I moduli Perl possono essere scritti con estensione .pm nel nome file Ex: Foo.pm. Un modulo può essere scritto utilizzando il "pacchetto Foo" all'inizio del programma.
Modulo Perl di 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;
Nessuna uscita
Per utilizzare questo modulo Perl, dobbiamo inserirlo nella directory attualmente funzionante.
Possiamo caricare un modulo Perl utilizzando require o utilizzare ovunque nel codice. La differenza principale tra require e use è che richiedono il modulo caricato durante il runtime e utilizzano i carichi durante la compilazione.
#!/usr/bin/perl require Arithmetic; print Arithmetic::add(5,6); print Arithmetic:: subtract (5,6);
Qui, nell'esempio precedente, stiamo accedendo alle subroutine utilizzando il nome del modulo completo.
Possiamo anche accedere al pacchetto usando 'use Arithmetic'.
Esportatore:
Questo modulo ha una funzionalità predefinita di metodi di importazione.
#!/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;
L'array @EXPORT può essere utilizzato per passare un elenco di variabili e subroutine che per impostazione predefinita verranno esportate al chiamante del modulo.
L'array @EXPORT_OK può essere utilizzato per passare un elenco di variabili e subroutine che verranno esportate su richiesta, dove l'utente deve specificare durante il caricamento del modulo.
#!/usr/bin/perl use Arithmetic qw(subtract); print add(5,6); print subtract (5,6);
Per impostazione predefinita, verrà esportata la subroutine aggiunta. Il metodo di sottrazione non verrà esportato se non viene specificato durante il caricamento del modulo.
Programmazione orientata agli oggetti in Perl
In questa sezione impareremo come creare moduli Perl orientati agli oggetti. Per prima cosa, vediamo qual è l'oggetto? Un oggetto è un'istanza tramite la quale possiamo accedere, modificare e localizzare alcuni dati in qualsiasi modulo Perl. Questo non è altro che far sì che il pacchetto Perl esistente, le variabili e le subroutine agiscano come classi, oggetti e metodi in riferimento ad altri linguaggi di programmazione.
Crea classe
Sappiamo già come creare moduli dall'argomento precedente. Lo scopo della classe è memorizzare metodi e variabili. Un modulo Perl avrà subroutine che sono metodi. Dobbiamo accedere a tali variabili e oggetti subroutine.
Costruttore Perl
Un costruttore in Perl è un metodo che verrà eseguito e ci restituirà un riferimento con il nome del modulo taggato al riferimento. Questa è chiamata benedizione della classe. Usiamo una variabile particolare per benedire una classe perl, che è 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;
Il nuovo metodo utilizzato come costruttore per una classe, questo costruttore creerà un oggetto per noi e tornerà allo script che sta chiamando questo costruttore.
#!/usr/bin/perl use Arithmetic; my $obj= Arithmetic->new(); my $result= $obj->add(5,6); print "$result"; $result = $obj->subtract(6,5); print "$result";
Qui dobbiamo capire come è stato creato l'oggetto. Ogni volta che proviamo a creare un oggetto per la classe, dobbiamo utilizzare il nome completo della classe. Supponiamo che la classe perl si trovi in qualche lib\Math\Arithmetic.pm. E, se vogliamo accedere a questa classe perl dalla directory lib, dobbiamo fornire l'intero percorso della classe mentre chiamiamo lo script.
utilizzare lib::Math::Arithmetic;
my $obj = lib::Math::Arithmetic->new();
Ecco come avviene la creazione dell'oggetto in Perl.
@INC:
Come fa lo script Perl a sapere dove esiste il modulo della libreria? Perl conosce solo la directory corrente dello script e il percorso della libreria incorporata di Perl. Ogni volta che utilizziamo un modulo Perl che non si trova nella directory corrente o nel percorso della libreria Perl, lo script fallirà sempre. Per quanto riguarda @INC, questo è un array che contiene tutti i percorsi di directory in cui deve cercare i moduli Perl. Prova a eseguire questo comando e guarda quale sarà l'output.
perl –e "print @INC"
Questo fornirà un output e questo è il percorso in cui saranno disponibili i moduli lib. Ogni volta che utilizziamo un nuovo modulo della libreria, dobbiamo dire a Perl, interprete, di esaminare quella particolare posizione in cui è disponibile il modulo Perl.
push(@INC, "PATH TO YOUR MODULE");
Impostalo come prima riga di codice. Questo dirà al tuo interprete di esaminare quel percorso. O uso
lib Arithmetic; # List here is your Perl Module location
Distruttore Perl
Per impostazione predefinita, il distruttore di un oggetto viene chiamato alla fine e prima della chiusura dello script. Questo viene utilizzato per distruggere i tuoi oggetti dalla memoria.
Script di shell PERL V/s
- La programmazione in Perl non causa problemi di portabilità, cosa comune quando si utilizzano shell diverse nello scripting di shell.
- La gestione degli errori è molto semplice in Perl
- Si possono scrivere programmi lunghi e complessi su Perl facilmente grazie alla sua vastità. Questo è in contrasto con Shell che non supporta namespace, moduli, oggetti, ereditarietà ecc.
- Shell ha meno librerie riutilizzabili disponibili. Niente in confronto al CPAN di Perl
- La Shell è meno sicura. Si chiama funzioni esterne (comandi come mv, cp ecc. dipendono dalla shell utilizzata). Al contrario Perl fa un lavoro utile durante l'utilizzo delle funzioni interne.
Come viene utilizzato PERL nei test di automazione
Perl è ampiamente utilizzato nell'automazione. Potrebbe non essere il miglior linguaggio di programmazione al mondo, ma è più adatto per determinati tipi di attività. Parliamo di dove e perché viene utilizzato Perl Test di automazione.
Test di archiviazione
Cos'è lo spazio di archiviazione? Dati archiviati in File.
Supponiamo di avere un file Storage correlato Test Case dove dobbiamo scrivere i dati su una partizione, leggerli e verificare che i dati siano scritti correttamente.
Questa operazione può essere eseguita manualmente, ma un tester manuale può eseguire le stesse operazioni 10000 volte? Sarà un incubo! Abbiamo bisogno di automazione
lo strumento migliore per automatizzare qualsiasi cosa relativa all'archiviazione è Perl per le sue tecniche di gestione dei file, REGEX e potente analisi dei file che consuma meno tempo di esecuzione rispetto ad altri linguaggi di programmazione.
Perché dobbiamo testare lo spazio di archiviazione? Pensate ai grandi Data Center in cui i dati fluiranno ininterrottamente da un sistema all'altro con migliaia di record archiviati al secondo. Testare la robustezza di tale meccanismo di archiviazione è essenziale.
Molte aziende come HP, Dell, IBM e molti produttori di server utilizzano Perl come interfaccia per testare la funzionalità nei domini di archiviazione e rete. NetApp è una di queste aziende che lavora completamente sullo storage e utilizza Perl come linguaggio di programmazione per automatizzare i casi di test.
Se sei interessato a Perl Automation, sarebbe consigliabile conoscere Storage e reti Concepts.
Test di server e rete:
Test di server e rete utilizzando Perl
PERL è ampiamente utilizzato nel tempo di attività del server e nel monitoraggio delle prestazioni.
Considera un data center con 100 host (server). È necessario connettersi a ciascun host ed eseguire alcuni comandi da remoto. Vuoi anche riavviare il sistema e controllare quando torna online.
Eseguire manualmente questa attività per tutti i 100 host sarà un incubo. Ma possiamo automatizzarlo facilmente usando PERL
Passaggi di progettazione per ottenere l'automazione di cui sopra utilizzando PERL
- Prendi input dal file sulle informazioni dell'host come (IP, nome utente e password).
- Utilizzare Net::SSH2 per connettersi a ciascun sistema e stabilire un canale per eseguire i comandi.
- Esegui la serie di comandi richiesti, ad esempio: ls, dir, ifconfig,ps ecc.
- Riavvia il sistema.
- Attendi 10 minuti affinché il sistema si avvii.
- Eseguire il ping del sistema utilizzando il modulo Net::Ping e stampare lo stato.
Codificheremo lo scenario sopra.
Prendiamo un file chiamato Input.txt che memorizzerà le informazioni complete su tutti gli host a cui dobbiamo connetterci ed eseguire il comando.
Ingresso.txt
192.168.1.2 password di root
192.168.1.3 password di root
192.168.1.4 radice radice123
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 non si limita solo ai test di archiviazione e rete. Possiamo anche eseguire test basati sul Web utilizzando PERL. WWW-Meccanizzare è un modulo utilizzato per test web. Fondamentalmente, non avvia alcun browser per testare la funzionalità delle applicazioni web, ma utilizza il codice sorgente delle pagine html.
Possiamo anche eseguire test basati su browser utilizzando Selenium IDE, RC, driver Web. Perl è supportato Selenium.
\N"; #questo manterrà la stringa rimanente una volta completata la corrispondenza dello schema.
stampa "
