Perl - Guida rapida

Perl è un linguaggio di programmazione generico sviluppato originariamente per la manipolazione del testo e ora utilizzato per un'ampia gamma di attività, tra cui amministrazione del sistema, sviluppo web, programmazione di rete, sviluppo di GUI e altro.

Cos'è Perl?

Perl è un linguaggio di programmazione stabile e multipiattaforma.
Sebbene Perl non sia ufficialmente un acronimo, ma poche persone lo hanno usato come Practical Extraction and Report Language.
Viene utilizzato per progetti mission-critical nel settore pubblico e privato.
Perl è un software Open Source , concesso in licenza con la sua Artistic License , o GNU General Public License (GPL) .
Perl è stato creato da Larry Wall.
Perl 1.0 è stato rilasciato su alt.comp.sources di Usenet nel 1987.
Al momento della stesura di questo tutorial, l'ultima versione di perl era la 5.16.2.
Perl è elencato nell'Oxford English Dictionary .

PC Magazine ha annunciato Perl come finalista per il suo premio per l'eccellenza tecnica 1998 nella categoria Strumenti di sviluppo.

Funzionalità Perl

Perl prende le migliori caratteristiche da altri linguaggi, come C, awk, sed, sh e BASIC, tra gli altri.
Interfaccia di integrazione del database Perls DBI supporta database di terze parti inclusi Oracle, Sybase, Postgres, MySQL e altri.
Perl funziona con HTML, XML e altri linguaggi di markup.
Perl supporta Unicode.
Perl è conforme a Y2K.
Perl supporta sia la programmazione procedurale che quella orientata agli oggetti.
Perl si interfaccia con le librerie C / C ++ esterne tramite XS o SWIG.
Perl è estensibile. Sono disponibili oltre 20.000 moduli di terze parti dalla Comprehensive Perl Archive Network ( CPAN ).
L'interprete Perl può essere incorporato in altri sistemi.

Perl e il Web

Perl era il linguaggio di programmazione web più popolare grazie alle sue capacità di manipolazione del testo e al rapido ciclo di sviluppo.
Perl è ampiamente conosciuto come " il nastro adesivo di Internet ".
Perl può gestire dati Web crittografati, comprese le transazioni di e-commerce.
Perl può essere incorporato nei server web per accelerare l'elaborazione fino al 2000%.
Il mod_perl di Perl consente al server web Apache di incorporare un interprete Perl.
Il pacchetto DBI di Perl semplifica l'integrazione del database web.

Perl è interpretato

Perl è un linguaggio interpretato, il che significa che il codice può essere eseguito così com'è, senza una fase di compilazione che crei un programma eseguibile non portabile.

I compilatori tradizionali convertono i programmi in linguaggio macchina. Quando si esegue un programma Perl, viene prima compilato in un codice byte, che viene quindi convertito (durante l'esecuzione del programma) in istruzioni macchina. Quindi non è proprio la stessa cosa delle shell, o Tcl, che sonostrictly interpretato senza una rappresentazione intermedia.

Inoltre non è come la maggior parte delle versioni di C o C ++, che sono compilate direttamente in un formato dipendente dalla macchina. È da qualche parte nel mezzo, insieme ai file Python e awk ed Emacs .elc.

Prima di iniziare a scrivere i nostri programmi Perl, capiamo come configurare il nostro ambiente Perl. Perl è disponibile su un'ampia varietà di piattaforme:

Unix (Solaris, Linux, FreeBSD, AIX, HP / UX, SunOS, IRIX ecc.)
Win 9x / NT / 2000 /
WinCE
Macintosh (PPC, 68K)
Solaris (x86, SPARC)
OpenVMS
Alpha (7.2 e versioni successive)
Symbian
Debian GNU / kFreeBSD
MirOS BSD
E molti altri...

È più probabile che il tuo sistema abbia installato perl su di esso. Prova a dare il seguente comando al $ prompt -

$perl -v

Se hai installato perl sulla tua macchina, riceverai un messaggio come segue:

This is perl 5, version 16, subversion 2 (v5.16.2) built for i686-linux

Copyright 1987-2012, Larry Wall

Perl may be copied only under the terms of either the Artistic License or the
GNU General Public License, which may be found in the Perl 5 source kit.

Complete documentation for Perl, including FAQ lists, should be found on
this system using "man perl" or "perldoc perl".  If you have access to the
Internet, point your browser at http://www.perl.org/, the Perl Home Page.

Se non hai già installato perl, procedi alla sezione successiva.

Ottenere l'installazione di Perl

Il codice sorgente più aggiornato e attuale, i binari, la documentazione, le notizie, ecc. Sono disponibili sul sito web ufficiale di Perl.

Perl Official Website - https://www.perl.org/

È possibile scaricare la documentazione Perl dal seguente sito.

Perl Documentation Website - https://perldoc.perl.org

Installa Perl

La distribuzione di Perl è disponibile per un'ampia varietà di piattaforme. Devi scaricare solo il codice binario applicabile alla tua piattaforma e installare Perl.

Se il codice binario per la tua piattaforma non è disponibile, è necessario un compilatore C per compilare manualmente il codice sorgente. La compilazione del codice sorgente offre una maggiore flessibilità in termini di scelta delle funzionalità richieste durante l'installazione.

Ecco una rapida panoramica dell'installazione di Perl su varie piattaforme.

Installazione di Unix e Linux

Ecco i semplici passaggi per installare Perl su macchine Unix / Linux.

Apri un browser Web e vai a https://www.perl.org/get.html.
Segui il link per scaricare il codice sorgente zippato disponibile per Unix / Linux.
Scarica perl-5.x.y.tar.gz file ed emettere i seguenti comandi al $ prompt.

$tar -xzf perl-5.x.y.tar.gz
$cd perl-5.x.y $./Configure -de
$make $make test
$make install

NOTE - Qui $ è un prompt Unix in cui digiti il tuo comando, quindi assicurati di non digitare $ mentre digiti i comandi sopra menzionati.

Questo installerà Perl in una posizione standard / usr / local / bin e le sue librerie saranno installate in / usr / local / lib / perlXX , dove XX è la versione di Perl che stai usando.

Ci vorrà un po 'di tempo per compilare il codice sorgente dopo aver emesso il makecomando. Una volta completata l'installazione, puoi emettereperl -vcomando al prompt $ per controllare l'installazione di perl. Se tutto va bene, verrà visualizzato il messaggio come mostrato sopra.

Installazione di Windows

Ecco i passaggi per installare Perl su macchina Windows.

Segui il collegamento per l'installazione di Strawberry Perl su Windows http://strawberryperl.com
Scarica la versione di installazione a 32 o 64 bit.
Eseguire il file scaricato facendo doppio clic su di esso in Esplora risorse. Questo fa apparire la procedura guidata di installazione di Perl, che è davvero facile da usare. Accetta le impostazioni predefinite, attendi fino al termine dell'installazione e sei pronto per partire!

Installazione su Macintosh

Per creare la tua versione di Perl, avrai bisogno di "make", che fa parte degli strumenti di sviluppo di Apples solitamente forniti con i DVD di installazione di Mac OS. Non è necessaria l'ultima versione di Xcode (che ora è a pagamento) per installare make.

Ecco i semplici passaggi per installare Perl su macchina Mac OS X.

Apri un browser Web e vai a https://www.perl.org/get.html.
Segui il link per scaricare il codice sorgente zippato disponibile per Mac OS X.
Scarica perl-5.x.y.tar.gz file ed emettere i seguenti comandi al $ prompt.

$tar -xzf perl-5.x.y.tar.gz
$cd perl-5.x.y $./Configure -de
$make $make test
$make install

Questo installerà Perl in una posizione standard / usr / local / bin e le sue librerie saranno installate in / usr / local / lib / perlXX , dove XX è la versione di Perl che stai usando.

Eseguire Perl

I seguenti sono i diversi modi per avviare Perl.

Interprete interattivo

Puoi entrare perle inizia subito a scrivere codice nell'interprete interattivo avviandolo dalla riga di comando. Puoi farlo da Unix, DOS o qualsiasi altro sistema, che ti fornisce un interprete della riga di comando o una finestra della shell.

$perl  -e <perl code>           # Unix/Linux

or 

C:>perl -e <perl code>          # Windows/DOS

Ecco l'elenco di tutte le opzioni disponibili della riga di comando:

Sr.No.	Opzione e descrizione
1	-d[:debugger] Esegue il programma sotto il debugger
2	-Idirectory Specifica la directory @ INC / # include
3	-T Consente i controlli di contaminazione
4	-t Abilita gli avvisi di contaminazione
5	-U Consente operazioni non sicure
6	-w Abilita molti avvisi utili
7	-W Abilita tutti gli avvisi
8	-X Disabilita tutti gli avvisi
9	-e program Esegue lo script Perl inviato come programma
10	file Esegue lo script Perl da un dato file

Script dalla riga di comando

Uno script Perl è un file di testo, che mantiene il codice Perl al suo interno e può essere eseguito dalla riga di comando invocando l'interprete sulla tua applicazione, come di seguito:

$perl  script.pl          # Unix/Linux

or 

C:>perl script.pl         # Windows/DOS

Ambiente di sviluppo integrato

È possibile eseguire Perl anche da un ambiente con interfaccia utente grafica (GUI). Tutto ciò di cui hai bisogno è un'applicazione GUI sul tuo sistema che supporti Perl. È possibile scaricare Padre, l'IDE Perl . Puoi anche usare Eclipse Plugin EPIC - Perl Editor e IDE for Eclipse se hai familiarità con Eclipse.

Prima di procedere al capitolo successivo, assicurati che il tuo ambiente sia configurato correttamente e funzioni perfettamente. Se non sei in grado di configurare l'ambiente correttamente, puoi chiedere aiuto al tuo amministratore di sistema.

Tutti gli esempi forniti nei capitoli successivi sono stati eseguiti con la versione v5.16.2 disponibile sulla versione CentOS di Linux.

Perl prende in prestito la sintassi e i concetti da molti linguaggi: awk, sed, C, Bourne Shell, Smalltalk, Lisp e persino l'inglese. Tuttavia, ci sono alcune differenze nette tra le lingue. Questo capitolo è stato progettato per metterti rapidamente al passo con la sintassi che ci si aspetta da Perl.

Un programma Perl consiste in una sequenza di dichiarazioni e istruzioni, che vengono eseguite dall'alto verso il basso. I loop, le subroutine e altre strutture di controllo ti consentono di saltare all'interno del codice. Ogni semplice istruzione deve terminare con un punto e virgola (;).

Perl è un linguaggio in formato libero: puoi formattarlo e indentarlo come preferisci. Lo spazio vuoto serve principalmente per separare i token, a differenza di linguaggi come Python dove è una parte importante della sintassi, o Fortran dove è immateriale.

Primo programma Perl

Programmazione in modalità interattiva

Puoi usare l'interprete Perl con -eopzione nella riga di comando, che consente di eseguire istruzioni Perl dalla riga di comando. Proviamo qualcosa a $ prompt come segue:

$perl -e 'print "Hello World\n"'

Questa esecuzione produrrà il seguente risultato:

Hello, world

Programmazione in modalità script

Supponendo che tu sia già su $ prompt, apriamo un file di testo hello.pl usando vi o vim editor e inseriamo le seguenti righe nel tuo file.

#!/usr/bin/perl

# This will print "Hello, World"
print "Hello, world\n";

Qui /usr/bin/perlè attuale il binario dell'interprete perl. Prima di eseguire lo script, assicurati di cambiare la modalità del file di script e di dare il privilegio di esecuzione, generalmente un'impostazione di 0755 funziona perfettamente e alla fine esegui lo script sopra come segue:

$chmod 0755 hello.pl $./hello.pl

Questa esecuzione produrrà il seguente risultato:

Hello, world

È possibile utilizzare le parentesi per gli argomenti delle funzioni o ometterle in base ai propri gusti personali. Sono richiesti solo occasionalmente per chiarire le questioni di precedenza. Le seguenti due affermazioni producono lo stesso risultato.

print("Hello, world\n");
print "Hello, world\n";

Estensione del file Perl

Uno script Perl può essere creato all'interno di qualsiasi normale programma di editor di testo semplice. Sono disponibili diversi programmi per ogni tipo di piattaforma. Ci sono molti programmi progettati per i programmatori disponibili per il download sul web.

Come convenzione Perl, un file Perl deve essere salvato con estensione .pl o .PL per essere riconosciuto come uno script Perl funzionante. I nomi dei file possono contenere numeri, simboli e lettere ma non devono contenere uno spazio. Usa un trattino basso (_) nelle posizioni degli spazi.

Commenti in Perl

I commenti in qualsiasi linguaggio di programmazione sono amici degli sviluppatori. I commenti possono essere utilizzati per rendere il programma facile da usare e vengono semplicemente ignorati dall'interprete senza influire sulla funzionalità del codice. Ad esempio, nel programma sopra, una riga che inizia con hash# è un commento.

Dicendo semplicemente che i commenti in Perl iniziano con un simbolo cancelletto e corrono fino alla fine della riga -

# This is a comment in perl

Le righe che iniziano con = vengono interpretate come l'inizio di una sezione di documentazione incorporata (pod) e tutte le righe successive fino al taglio successivo = vengono ignorate dal compilatore. Di seguito è riportato l'esempio:

#!/usr/bin/perl

# This is a single line comment
print "Hello, world\n";

=begin comment
This is all part of multiline comment.
You can use as many lines as you like
These comments will be ignored by the 
compiler until the next =cut is encountered.
=cut

Questo produrrà il seguente risultato:

Hello, world

Whitespaces in Perl

Un programma Perl non si preoccupa degli spazi bianchi. Il seguente programma funziona perfettamente -

#!/usr/bin/perl

print       "Hello, world\n";

Ma se gli spazi sono all'interno delle stringhe tra virgolette, verrebbero stampati così come sono. Ad esempio:

#!/usr/bin/perl

# This would print with a line break in the middle
print "Hello
          world\n";

Questo produrrà il seguente risultato:

Hello
          world

Tutti i tipi di spazi bianchi come spazi, tabulazioni, nuove righe, ecc. Sono equivalenti per l'interprete quando vengono utilizzati al di fuori delle virgolette. Una riga contenente solo spazi bianchi, possibilmente con un commento, è conosciuta come una riga vuota e Perl la ignora completamente.

Virgolette singole e doppie in Perl

È possibile utilizzare virgolette doppie o virgolette singole attorno a stringhe letterali come segue:

#!/usr/bin/perl

print "Hello, world\n";
print 'Hello, world\n';

Questo produrrà il seguente risultato:

Hello, world
Hello, world\n$

C'è una differenza importante tra virgolette singole e doppie. Solo virgolette doppieinterpolatevariabili e caratteri speciali come le nuove righe \ n, mentre le virgolette singole non interpola alcuna variabile o carattere speciale. Controlla l'esempio di seguito in cui stiamo usando $ a come variabile per memorizzare un valore e successivamente stampare quel valore -

#!/usr/bin/perl

$a = 10; print "Value of a = $a\n";
print 'Value of a = $a\n';

Questo produrrà il seguente risultato:

Value of a = 10
Value of a = $a\n$

Documenti "qui"

È possibile memorizzare o stampare testo multilinea con grande comodità. Anche tu puoi usare le variabili all'interno del documento "qui". Di seguito è riportata una semplice sintassi, verificare attentamente che non vi siano spazi tra << e l'identificatore.

Un identificatore può essere una semplice parola o un testo citato come abbiamo usato EOF di seguito. Se l'identificatore è citato, il tipo di citazione che usi determina il trattamento del testo all'interno del here docoment, proprio come nelle normali citazioni. Un identificatore non quotato funziona come virgolette doppie.

#!/usr/bin/perl

$a = 10;
$var = <<"EOF"; This is the syntax for here document and it will continue until it encounters a EOF in the first line. This is case of double quote so variable value will be interpolated. For example value of a = $a
EOF
print "$var\n"; $var = <<'EOF';
This is case of single quote so variable value will be 
interpolated. For example value of a = $a EOF print "$var\n";

Questo produrrà il seguente risultato:

This is the syntax for here document and it will continue
until it encounters a EOF in the first line.
This is case of double quote so variable value will be
interpolated. For example value of a = 10

This is case of single quote so variable value will be
interpolated. For example value of a = $a

Caratteri in fuga

Perl utilizza il carattere barra rovesciata (\) per eseguire l'escape di qualsiasi tipo di carattere che potrebbe interferire con il nostro codice. Facciamo un esempio in cui vogliamo stampare virgolette doppie e $ segno -

#!/usr/bin/perl

$result = "This is \"number\""; print "$result\n";
print "\$result\n";

Questo produrrà il seguente risultato:

This is "number"
$result

Identificatori Perl

Un identificatore Perl è un nome utilizzato per identificare una variabile, una funzione, una classe, un modulo o un altro oggetto. Un nome di variabile Perl inizia con $, @ o% seguito da zero o più lettere, trattini bassi e cifre (da 0 a 9).

Perl non consente caratteri di punteggiatura come @, $ e% all'interno degli identificatori. Perl è un filecase sensitivelinguaggio di programmazione. Così$Manpower e $manpower sono due identificatori differenti in Perl.

Perl è un linguaggio vagamente tipizzato e non è necessario specificare un tipo per i dati durante l'utilizzo nel programma. L'interprete Perl sceglierà il tipo in base al contesto dei dati stessi.

Perl ha tre tipi di dati di base: scalari, array di scalari e hash di scalari, noti anche come array associativi. Ecco un piccolo dettaglio su questi tipi di dati.

Sr.No.	Tipi e descrizione
1	Scalar Gli scalari sono variabili semplici. Sono preceduti da un segno di dollaro ($). Uno scalare è un numero, una stringa o un riferimento. Un riferimento è in realtà un indirizzo di una variabile, che vedremo nei prossimi capitoli.
2	Arrays Gli array sono elenchi ordinati di scalari a cui si accede con un indice numerico, che inizia con 0. Sono preceduti da un segno "a" (@).
3	Hashes Gli hash sono set non ordinati di coppie chiave / valore a cui si accede utilizzando le chiavi come pedici. Sono preceduti da un segno di percentuale (%).

Letterali numerici

Perl memorizza tutti i numeri internamente come interi con segno o come valori in virgola mobile a doppia precisione. I valori letterali numerici sono specificati in uno dei seguenti formati a virgola mobile o intero:

genere	Valore
Numero intero	1234
Numero intero negativo	-100
Virgola mobile	2000
Notazione scientifica	16.12E14
Esadecimale	0xffff
Octal	0577

Valori letterali stringa

Le stringhe sono sequenze di caratteri. Di solito sono valori alfanumerici delimitati da virgolette singole (') o doppie ("). Funzionano in modo molto simile alle virgolette di shell UNIX in cui è possibile utilizzare stringhe con virgolette singole e stringhe con virgolette doppie.

I valori letterali di stringa tra virgolette doppie consentono l'interpolazione delle variabili e le stringhe con apici singoli non lo sono. Ci sono alcuni caratteri quando sono preceduti da una barra rovesciata, hanno un significato speciale e sono usati per rappresentare come una nuova riga (\ n) o una tabulazione (\ t).

Puoi incorporare le nuove righe o una qualsiasi delle seguenti sequenze di escape direttamente nelle stringhe tra virgolette doppie:

Sequenza di escape	Senso
\\	Barra rovesciata
\ '	Virgoletta singola
\ "	Virgolette doppie
\un	Allerta o campanello
\ b	Backspace
\ f	Avanzamento modulo
\ n	Nuova linea
\ r	Ritorno in carrozza
\ t	Tab orizzontale
\ v	Scheda verticale
\ 0nn	Crea numeri in formato ottale
\ xnn	Crea numeri in formato Hexideciamal
\ cX	Controlla i caratteri, x può essere qualsiasi carattere
\ u	Forza il carattere successivo in maiuscolo
\ l	Forza il carattere successivo in minuscolo
\ U	Forza tutti i seguenti caratteri in maiuscolo
\ L	Forza tutti i caratteri seguenti in minuscolo
\ Q	Barra rovesciata su tutti i caratteri non alfanumerici seguenti
\ E	Fine \ U, \ L o \ Q

Esempio

Vediamo ancora come si comportano le stringhe con virgolette singole e virgolette doppie. Qui useremo gli escape di stringa menzionati nella tabella sopra e utilizzeremo la variabile scalare per assegnare valori di stringa.

#!/usr/bin/perl

# This is case of interpolation.
$str = "Welcome to \ntutorialspoint.com!";
print "$str\n"; # This is case of non-interpolation. $str = 'Welcome to \ntutorialspoint.com!';
print "$str\n"; # Only W will become upper case. $str = "\uwelcome to tutorialspoint.com!";
print "$str\n"; # Whole line will become capital. $str = "\UWelcome to tutorialspoint.com!";
print "$str\n"; # A portion of line will become capital. $str = "Welcome to \Ututorialspoint\E.com!"; 
print "$str\n"; # Backsalash non alpha-numeric including spaces. $str = "\QWelcome to tutorialspoint's family";
print "$str\n";

Questo produrrà il seguente risultato:

Welcome to
tutorialspoint.com!
Welcome to \ntutorialspoint.com!
Welcome to tutorialspoint.com!
WELCOME TO TUTORIALSPOINT.COM!
Welcome to TUTORIALSPOINT.com!
Welcome\ to\ tutorialspoint\'s\ family

Le variabili sono le posizioni di memoria riservate per memorizzare i valori. Ciò significa che quando crei una variabile riservi dello spazio in memoria.

In base al tipo di dati di una variabile, l'interprete alloca la memoria e decide cosa può essere memorizzato nella memoria riservata. Pertanto, assegnando diversi tipi di dati alle variabili, è possibile memorizzare numeri interi, decimali o stringhe in queste variabili.

Abbiamo appreso che Perl ha i seguenti tre tipi di dati di base:

Scalars
Arrays
Hashes

Di conseguenza, useremo tre tipi di variabili in Perl. UNscalarla variabile precederà un segno di dollaro ($) e può memorizzare un numero, una stringa o un riferimento. Unarrayla variabile precederà il segno @ e memorizzerà elenchi ordinati di scalari. Infine, ilHash variabile precederà dal segno% e verrà utilizzata per memorizzare set di coppie chiave / valore.

Perl mantiene ogni tipo di variabile in uno spazio dei nomi separato. Quindi puoi, senza paura di conflitti, usare lo stesso nome per una variabile scalare, un array o un hash. Ciò significa che $ foo e @foo sono due variabili diverse.

Creazione di variabili

Le variabili Perl non devono essere dichiarate esplicitamente per riservare spazio di memoria. La dichiarazione avviene automaticamente quando si assegna un valore a una variabile. Il segno di uguale (=) viene utilizzato per assegnare valori alle variabili.

Tieni presente che questo è obbligatorio per dichiarare una variabile prima di usarla se la usiamo use strict dichiarazione nel nostro programma.

L'operando a sinistra dell'operatore = è il nome della variabile e l'operando a destra dell'operatore = è il valore memorizzato nella variabile. Ad esempio:

$age = 25;             # An integer assignment
$name = "John Paul"; # A string $salary = 1445.50;     # A floating point

Qui 25, "John Paul" e 1445.50 sono i valori assegnati rispettivamente alle variabili $ age , $ name e $ salary . Tra poco vedremo come possiamo assegnare valori ad array e hash.

Variabili scalari

Uno scalare è una singola unità di dati. Tali dati potrebbero essere un numero intero, una virgola mobile, un carattere, una stringa, un paragrafo o un'intera pagina web. Semplicemente dicendo che potrebbe essere qualsiasi cosa, ma solo una cosa.

Ecco un semplice esempio di utilizzo delle variabili scalari:

#!/usr/bin/perl

$age = 25;             # An integer assignment
$name = "John Paul"; # A string $salary = 1445.50;     # A floating point

print "Age = $age\n"; print "Name = $name\n";
print "Salary = $salary\n";

Questo produrrà il seguente risultato:

Age = 25
Name = John Paul
Salary = 1445.5

Variabili di matrice

Un array è una variabile che memorizza un elenco ordinato di valori scalari. Le variabili di matrice sono precedute da un segno "at" (@). Per fare riferimento a un singolo elemento di un array, utilizzerai il simbolo del dollaro ($) con il nome della variabile seguito dall'indice dell'elemento tra parentesi quadre.

Ecco un semplice esempio di utilizzo delle variabili array:

#!/usr/bin/perl

@ages = (25, 30, 40);             
@names = ("John Paul", "Lisa", "Kumar");

print "\$ages[0] = $ages[0]\n";
print "\$ages[1] = $ages[1]\n";
print "\$ages[2] = $ages[2]\n";
print "\$names[0] = $names[0]\n";
print "\$names[1] = $names[1]\n";
print "\$names[2] = $names[2]\n";

Qui abbiamo usato il segno di escape (\) prima del segno $ solo per stamparlo. Un altro Perl lo interpreterà come una variabile e ne stamperà il valore. Quando viene eseguito, questo produrrà il seguente risultato:

$ages[0] = 25
$ages[1] = 30 $ages[2] = 40
$names[0] = John Paul $names[1] = Lisa
$names[2] = Kumar

Variabili hash

Un hash è un insieme di file key/valuecoppie. Le variabili hash sono precedute da un segno di percentuale (%). Per fare riferimento a un singolo elemento di un hash, utilizzerai il nome della variabile hash seguito dalla "chiave" associata al valore tra parentesi graffe.

Ecco un semplice esempio di utilizzo delle variabili hash:

#!/usr/bin/perl

%data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);

print "\$data{'John Paul'} = $data{'John Paul'}\n"; print "\$data{'Lisa'} = $data{'Lisa'}\n"; print "\$data{'Kumar'} = $data{'Kumar'}\n";

Questo produrrà il seguente risultato:

$data{'John Paul'} = 45
$data{'Lisa'} = 30 $data{'Kumar'} = 40

Contesto variabile

Perl tratta la stessa variabile in modo diverso in base al contesto, cioè alla situazione in cui viene utilizzata una variabile. Controlliamo il seguente esempio:

#!/usr/bin/perl

@names = ('John Paul', 'Lisa', 'Kumar');

@copy = @names;
$size = @names; print "Given names are : @copy\n"; print "Number of names are : $size\n";

Questo produrrà il seguente risultato:

Given names are : John Paul Lisa Kumar
Number of names are : 3

Qui @names è un array, che è stato utilizzato in due diversi contesti. Per prima cosa l'abbiamo copiato in qualsiasi altro array, cioè list, quindi ha restituito tutti gli elementi assumendo che il contesto sia il contesto della lista. Successivamente abbiamo usato lo stesso array e provato a memorizzare questo array in uno scalare, quindi in questo caso ha restituito solo il numero di elementi in questo array assumendo che il contesto sia un contesto scalare. La tabella seguente elenca i vari contesti:

Sr.No.	Contesto e descrizione
1	Scalar L'assegnazione a una variabile scalare valuta il lato destro in un contesto scalare.
2	List L'assegnazione a un array o un hash valuta il lato destro in un contesto di elenco.
3	Boolean Il contesto booleano è semplicemente qualsiasi luogo in cui un'espressione viene valutata per vedere se è vera o falsa.
4	Void Questo contesto non solo non si preoccupa di quale sia il valore di ritorno, ma non vuole nemmeno un valore di ritorno.
5	Interpolative Questo contesto si verifica solo tra virgolette o cose che funzionano come virgolette.

Uno scalare è una singola unità di dati. Tali dati potrebbero essere un numero intero, una virgola mobile, un carattere, una stringa, un paragrafo o un'intera pagina web.

Ecco un semplice esempio di utilizzo delle variabili scalari:

#!/usr/bin/perl

$age = 25; # An integer assignment $name = "John Paul";   # A string 
$salary = 1445.50; # A floating point print "Age = $age\n";
print "Name = $name\n"; print "Salary = $salary\n";

Questo produrrà il seguente risultato:

Age = 25
Name = John Paul
Salary = 1445.5

Scalari numerici

Uno scalare è molto spesso un numero o una stringa. L'esempio seguente dimostra l'utilizzo di vari tipi di scalari numerici:

#!/usr/bin/perl

$integer = 200; $negative = -300;
$floating = 200.340; $bigfloat = -1.2E-23;

# 377 octal, same as 255 decimal
$octal = 0377; # FF hex, also 255 decimal $hexa = 0xff;

print "integer = $integer\n"; print "negative = $negative\n";
print "floating = $floating\n"; print "bigfloat = $bigfloat\n";
print "octal = $octal\n"; print "hexa = $hexa\n";

Questo produrrà il seguente risultato:

integer = 200
negative = -300
floating = 200.34
bigfloat = -1.2e-23
octal = 255
hexa = 255

Scalari di stringa

L'esempio seguente dimostra l'utilizzo di vari tipi di scalari di stringa. Notare la differenza tra stringhe con virgolette singole e stringhe con virgolette doppie -

#!/usr/bin/perl

$var = "This is string scalar!"; $quote = 'I m inside single quote - $var'; $double = "This is inside single quote - $var"; $escape = "This example of escape -\tHello, World!";

print "var = $var\n"; print "quote = $quote\n";
print "double = $double\n"; print "escape = $escape\n";

Questo produrrà il seguente risultato:

var = This is string scalar!
quote = I m inside single quote - $var
double = This is inside single quote - This is string scalar!
escape = This example of escape -       Hello, World

Operazioni scalari

Vedrai un dettaglio dei vari operatori disponibili in Perl in un capitolo separato, ma qui elencheremo alcune operazioni numeriche e sulle stringhe.

#!/usr/bin/perl

$str = "hello" . "world";       # Concatenates strings.
$num = 5 + 10; # adds two numbers. $mul = 4 * 5;                   # multiplies two numbers.
$mix = $str . $num; # concatenates string and number. print "str = $str\n";
print "num = $num\n"; print "mix = $mix\n";

Questo produrrà il seguente risultato:

str = helloworld
num = 15
mul = 20
mix = helloworld15

Stringhe multilinea

Se vuoi introdurre stringhe multilinea nei tuoi programmi, puoi usare le virgolette singole standard come di seguito -

#!/usr/bin/perl

$string = 'This is a multiline string'; print "$string\n";

Questo produrrà il seguente risultato:

This is
a multiline
string

Puoi usare anche la sintassi del documento "qui" per memorizzare o stampare multilinee come di seguito -

#!/usr/bin/perl

print <<EOF;
This is
a multiline
string
EOF

Anche questo produrrà lo stesso risultato:

This is
a multiline
string

V-Strings

Un valore letterale nella forma v1.20.300.4000 viene analizzato come una stringa composta da caratteri con gli ordinali specificati. Questa forma è nota come v-string.

Una v-string fornisce un modo alternativo e più leggibile per costruire stringhe, piuttosto che usare la forma di interpolazione un po 'meno leggibile "\ x {1} \ x {14} \ x {12c} \ x {fa0}".

Sono qualsiasi valore letterale che inizia con av ed è seguito da uno o più elementi separati da punti. Ad esempio:

#!/usr/bin/perl

$smile = v9786; $foo    = v102.111.111;
$martin = v77.97.114.116.105.110; print "smile = $smile\n";
print "foo = $foo\n"; print "martin = $martin\n";

Anche questo produrrà lo stesso risultato:

smile = ☺
foo = foo
martin = Martin
Wide character in print at main.pl line 7.

Letterali speciali

Finora devi avere un'idea degli scalari delle stringhe e della sua concatenazione e interpolazione. Quindi lasciate che vi parli di tre letterali speciali __FILE__, __LINE__ e __PACKAGE__ rappresentano il nome del file corrente, il numero di riga e il nome del pacchetto a quel punto nel vostro programma.

Possono essere usati solo come token separati e non verranno interpolati in stringhe. Controlla l'esempio seguente:

#!/usr/bin/perl

print "File name ". __FILE__ . "\n";
print "Line Number " . __LINE__ ."\n";
print "Package " . __PACKAGE__ ."\n";

# they can not be interpolated
print "__FILE__ __LINE__ __PACKAGE__\n";

Questo produrrà il seguente risultato:

File name hello.pl
Line Number 4
Package main
__FILE__ __LINE__ __PACKAGE__

Ecco un semplice esempio di utilizzo delle variabili array:

#!/usr/bin/perl

@ages = (25, 30, 40);             
@names = ("John Paul", "Lisa", "Kumar");

print "\$ages[0] = $ages[0]\n"; print "\$ages[1] = $ages[1]\n"; print "\$ages[2] = $ages[2]\n"; print "\$names[0] = $names[0]\n"; print "\$names[1] = $names[1]\n"; print "\$names[2] = $names[2]\n";

$ages[0] = 25 $ages[1] = 30
$ages[2] = 40 $names[0] = John Paul
$names[1] = Lisa $names[2] = Kumar

In Perl, i termini List e Array sono spesso usati come se fossero intercambiabili. Ma l'elenco è i dati e l'array è la variabile.

Creazione di array

Le variabili array sono precedute dal segno @ e vengono popolate utilizzando le parentesi o l'operatore qw. Ad esempio:

@array = (1, 2, 'Hello');
@array = qw/This is an array/;

La seconda riga utilizza l'operatore qw //, che restituisce un elenco di stringhe, separando la stringa delimitata da uno spazio bianco. In questo esempio, ciò porta a una matrice di quattro elementi; il primo elemento è "this" e l'ultimo (quarto) è "array". Ciò significa che puoi utilizzare linee diverse come segue:

@days = qw/Monday
Tuesday
...
Sunday/;

È anche possibile popolare un array assegnando ogni valore individualmente come segue:

$array[0] = 'Monday'; ... $array[6] = 'Sunday';

Accesso agli elementi dell'array

Quando si accede a singoli elementi da un array, è necessario anteporre alla variabile un segno di dollaro ($) e quindi aggiungere l'indice dell'elemento tra parentesi quadre dopo il nome della variabile. Ad esempio:

#!/usr/bin/perl

@days = qw/Mon Tue Wed Thu Fri Sat Sun/;

print "$days[0]\n";
print "$days[1]\n"; print "$days[2]\n";
print "$days[6]\n"; print "$days[-1]\n";
print "$days[-7]\n";

Questo produrrà il seguente risultato:

Mon
Tue
Wed
Sun
Sun
Mon

Gli indici degli array iniziano da zero, quindi per accedere al primo elemento è necessario fornire 0 come indici. Puoi anche dare un indice negativo, nel qual caso selezioni l'elemento dalla fine, piuttosto che dall'inizio, dell'array. Ciò significa quanto segue:

print $days[-1]; # outputs Sun
print $days[-7]; # outputs Mon

Matrici di numeri sequenziali

Perl offre una scorciatoia per numeri e lettere sequenziali. Invece di digitare ogni elemento quando si conta fino a 100, ad esempio, possiamo fare qualcosa di simile a quanto segue:

#!/usr/bin/perl

@var_10 = (1..10);
@var_20 = (10..20);
@var_abc = (a..z);

print "@var_10\n";   # Prints number from 1 to 10
print "@var_20\n";   # Prints number from 10 to 20
print "@var_abc\n";  # Prints number from a to z

Qui viene chiamato il doppio punto (..) range operator. Questo produrrà il seguente risultato:

1 2 3 4 5 6 7 8 9 10
10 11 12 13 14 15 16 17 18 19 20
a b c d e f g h i j k l m n o p q r s t u v w x y z

Dimensione array

La dimensione di un array può essere determinata utilizzando il contesto scalare sull'array - il valore restituito sarà il numero di elementi nell'array -

@array = (1,2,3);
print "Size: ",scalar @array,"\n";

Il valore restituito sarà sempre la dimensione fisica dell'array, non il numero di elementi validi. Puoi dimostrarlo, e la differenza tra scalar @array e $ # array, usando questo frammento è la seguente:

#!/usr/bin/perl

@array = (1,2,3);
$array[50] = 4; $size = @array;
$max_index = $#array;

print "Size:  $size\n"; print "Max Index: $max_index\n";

Questo produrrà il seguente risultato:

Size: 51
Max Index: 50

Ci sono solo quattro elementi nell'array che contiene informazioni, ma l'array è lungo 51 elementi, con un indice massimo di 50.

Aggiunta e rimozione di elementi in array

Perl fornisce una serie di funzioni utili per aggiungere e rimuovere elementi in un array. Potresti avere una domanda che cos'è una funzione? Finora hai usatoprintfunzione per stampare vari valori. Allo stesso modo ci sono varie altre funzioni o talvolta chiamate sotto-routine, che possono essere utilizzate per varie altre funzionalità.

Sr.No.	Tipi e descrizione
1	push @ARRAY, LIST Inserisce i valori dell'elenco alla fine dell'array.
2	pop @ARRAY Si apre e restituisce l'ultimo valore dell'array.
3	shift @ARRAY Sposta il primo valore dell'array e lo restituisce, accorciando l'array di 1 e spostando tutto verso il basso.
4	unshift @ARRAY, LIST Antepone l'elenco all'inizio dell'array e restituisce il numero di elementi nel nuovo array.

#!/usr/bin/perl

# create a simple array
@coins = ("Quarter","Dime","Nickel");
print "1. \@coins  = @coins\n";

# add one element at the end of the array
push(@coins, "Penny");
print "2. \@coins  = @coins\n";

# add one element at the beginning of the array
unshift(@coins, "Dollar");
print "3. \@coins  = @coins\n";

# remove one element from the last of the array.
pop(@coins);
print "4. \@coins  = @coins\n";

# remove one element from the beginning of the array.
shift(@coins);
print "5. \@coins  = @coins\n";

Questo produrrà il seguente risultato:

1. @coins = Quarter Dime Nickel
2. @coins = Quarter Dime Nickel Penny
3. @coins = Dollar Quarter Dime Nickel Penny
4. @coins = Dollar Quarter Dime Nickel
5. @coins = Quarter Dime Nickel

Affettare elementi array

Puoi anche estrarre una "fetta" da un array, ovvero puoi selezionare più di un elemento da un array per produrre un altro array.

#!/usr/bin/perl

@days = qw/Mon Tue Wed Thu Fri Sat Sun/;

@weekdays = @days[3,4,5];

print "@weekdays\n";

Questo produrrà il seguente risultato:

Thu Fri Sat

La specifica per una sezione deve avere un elenco di indici validi, positivi o negativi, ciascuno separato da una virgola. Per la velocità, puoi anche usare il.. operatore di gamma -

#!/usr/bin/perl

@days = qw/Mon Tue Wed Thu Fri Sat Sun/;

@weekdays = @days[3..5];

print "@weekdays\n";

Questo produrrà il seguente risultato:

Thu Fri Sat

Sostituzione degli elementi dell'array

Ora introdurremo un'altra funzione chiamata splice(), che ha la seguente sintassi:

splice @ARRAY, OFFSET [ , LENGTH [ , LIST ] ]

Questa funzione rimuoverà gli elementi di @ARRAY designati da OFFSET e LENGTH e li sostituirà con LIST, se specificato. Infine, restituisce gli elementi rimossi dall'array. Di seguito è riportato l'esempio:

#!/usr/bin/perl

@nums = (1..20);
print "Before - @nums\n";

splice(@nums, 5, 5, 21..25); 
print "After - @nums\n";

Questo produrrà il seguente risultato:

Before - 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
After - 1 2 3 4 5 21 22 23 24 25 11 12 13 14 15 16 17 18 19 20

Qui, la sostituzione effettiva inizia con il sesto numero, dopodiché cinque elementi vengono sostituiti da 6 a 10 con i numeri 21, 22, 23, 24 e 25.

Trasforma le stringhe in array

Diamo un'occhiata a un'altra funzione chiamata split(), che ha la seguente sintassi:

split [ PATTERN [ , EXPR [ , LIMIT ] ] ]

Questa funzione divide una stringa in un array di stringhe e la restituisce. Se viene specificato LIMIT, si divide al massimo in quel numero di campi. Se PATTERN viene omesso, si divide in spazi bianchi. Di seguito è riportato l'esempio:

#!/usr/bin/perl

# define Strings
$var_string = "Rain-Drops-On-Roses-And-Whiskers-On-Kittens"; $var_names = "Larry,David,Roger,Ken,Michael,Tom";

# transform above strings into arrays.
@string = split('-', $var_string); @names = split(',', $var_names);

print "$string[3]\n"; # This will print Roses print "$names[4]\n";   # This will print Michael

Questo produrrà il seguente risultato:

Roses
Michael

Trasforma array in stringhe

Possiamo usare il file join()funzione per ricongiungere gli elementi dell'array e formare una lunga stringa scalare. Questa funzione ha la seguente sintassi:

join EXPR, LIST

Questa funzione unisce le stringhe separate di LIST in una singola stringa con campi separati dal valore di EXPR e restituisce la stringa. Di seguito è riportato l'esempio:

#!/usr/bin/perl

# define Strings
$var_string = "Rain-Drops-On-Roses-And-Whiskers-On-Kittens"; $var_names = "Larry,David,Roger,Ken,Michael,Tom";

# transform above strings into arrays.
@string = split('-', $var_string); @names = split(',', $var_names);

$string1 = join( '-', @string ); $string2 = join( ',', @names );

print "$string1\n"; print "$string2\n";

Questo produrrà il seguente risultato:

Rain-Drops-On-Roses-And-Whiskers-On-Kittens
Larry,David,Roger,Ken,Michael,Tom

Ordinamento di array

Il sort()funzione ordina ogni elemento di un array in base agli standard numerici ASCII. Questa funzione ha la seguente sintassi:

sort [ SUBROUTINE ] LIST

Questa funzione ordina la LISTA e restituisce il valore dell'array ordinato. Se si specifica SUBROUTINE, la logica specificata all'interno della SUBTROUTINE viene applicata durante l'ordinamento degli elementi.

#!/usr/bin/perl

# define an array
@foods = qw(pizza steak chicken burgers);
print "Before: @foods\n";

# sort this array
@foods = sort(@foods);
print "After: @foods\n";

Questo produrrà il seguente risultato:

Before: pizza steak chicken burgers
After: burgers chicken pizza steak

Si noti che l'ordinamento viene eseguito in base al valore numerico ASCII delle parole. Quindi l'opzione migliore è trasformare prima ogni elemento dell'array in lettere minuscole e quindi eseguire la funzione di ordinamento.

Unione di matrici

Poiché un array è solo una sequenza di valori separati da virgole, puoi combinarli insieme come mostrato di seguito:

#!/usr/bin/perl

@numbers = (1,3,(4,5,6));

print "numbers = @numbers\n";

Questo produrrà il seguente risultato:

numbers = 1 3 4 5 6

Gli array incorporati diventano solo una parte dell'array principale come mostrato di seguito -

#!/usr/bin/perl

@odd = (1,3,5);
@even = (2, 4, 6);

@numbers = (@odd, @even);

print "numbers = @numbers\n";

Questo produrrà il seguente risultato:

numbers = 1 3 5 2 4 6

Selezione di elementi dagli elenchi

La notazione dell'elenco è identica a quella degli array. Puoi estrarre un elemento da un array aggiungendo parentesi quadre all'elenco e fornendo uno o più indici -

#!/usr/bin/perl

$var = (5,4,3,2,1)[4]; print "value of var = $var\n"

Questo produrrà il seguente risultato:

value of var = 1

Allo stesso modo, possiamo estrarre le sezioni, sebbene senza la necessità di un carattere @ iniziale -

#!/usr/bin/perl

@list = (5,4,3,2,1)[1..3];

print "Value of list = @list\n";

Questo produrrà il seguente risultato:

Value of list = 4 3 2

Un hash è un insieme di file key/valuecoppie. Le variabili hash sono precedute da un segno di percentuale (%). Per fare riferimento a un singolo elemento di un hash, userai il nome della variabile hash preceduto da un segno "$" e seguito dalla "chiave" associata al valore tra parentesi graffe.

Ecco un semplice esempio di utilizzo delle variabili hash:

#!/usr/bin/perl

%data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);

print "\$data{'John Paul'} = $data{'John Paul'}\n"; print "\$data{'Lisa'} = $data{'Lisa'}\n"; print "\$data{'Kumar'} = $data{'Kumar'}\n";

Questo produrrà il seguente risultato:

$data{'John Paul'} = 45
$data{'Lisa'} = 30 $data{'Kumar'} = 40

Creazione di hash

Gli hash vengono creati in uno dei due modi seguenti. Nel primo metodo, assegni un valore a una chiave con nome uno per uno:

$data{'John Paul'} = 45; $data{'Lisa'} = 30;
$data{'Kumar'} = 40;

Nel secondo caso si utilizza una lista, che viene convertita prelevando singole coppie dalla lista: il primo elemento della coppia viene utilizzato come chiave e il secondo come valore. Ad esempio:

%data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);

Per chiarezza, puoi usare => come alias per, per indicare le coppie chiave / valore come segue:

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

Ecco un'altra variante del modulo sopra, dai un'occhiata, qui tutte le chiavi sono state precedute da un trattino (-) e non è richiesta alcuna citazione intorno ad esse -

%data = (-JohnPaul => 45, -Lisa => 30, -Kumar => 40);

Ma è importante notare che c'è una sola parola, cioè senza spazi le chiavi sono state usate in questa forma di formazione hash e se si crea l'hash in questo modo, si accederà alle chiavi usando il trattino solo come mostrato di seguito.

$val = %data{-JohnPaul}
$val = %data{-Lisa}

Accesso agli elementi hash

Quando si accede a singoli elementi da un hash, è necessario anteporre alla variabile un segno di dollaro ($) e quindi aggiungere la chiave dell'elemento tra parentesi graffe dopo il nome della variabile. Ad esempio:

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

print "$data{'John Paul'}\n"; print "$data{'Lisa'}\n";
print "$data{'Kumar'}\n";

Questo produrrà il seguente risultato:

45
30
40

Estrazione di fette

Puoi estrarre fette di un hash proprio come puoi estrarre fette da un array. Sarà necessario utilizzare il prefisso @ per la variabile per memorizzare il valore restituito perché sarà un elenco di valori -

#!/uer/bin/perl


%data = (-JohnPaul => 45, -Lisa => 30, -Kumar => 40);

@array = @data{-JohnPaul, -Lisa};

print "Array : @array\n";

Questo produrrà il seguente risultato:

Array : 45 30

Estrazione di chiavi e valori

È possibile ottenere un elenco di tutte le chiavi da un hash utilizzando keys funzione, che ha la seguente sintassi:

keys %HASH

Questa funzione restituisce un array di tutte le chiavi dell'hash denominato. Di seguito è riportato l'esempio:

#!/usr/bin/perl 

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

@names = keys %data;

print "$names[0]\n";
print "$names[1]\n"; print "$names[2]\n";

Questo produrrà il seguente risultato:

Lisa
John Paul
Kumar

Allo stesso modo, puoi usare valuesfunzione per ottenere un elenco di tutti i valori. Questa funzione ha la seguente sintassi:

values %HASH

Questa funzione restituisce un normale array costituito da tutti i valori dell'hash denominato. Di seguito è riportato l'esempio:

#!/usr/bin/perl 

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

@ages = values %data;

print "$ages[0]\n"; print "$ages[1]\n";
print "$ages[2]\n";

Questo produrrà il seguente risultato:

30
45
40

Controllo dell'esistenza

Se provi ad accedere a una coppia chiave / valore da un hash che non esiste, normalmente otterrai l'estensione undefinedvalore e se hai attivato gli avvisi, riceverai un avviso generato in fase di esecuzione. Puoi aggirare questo problema usando ilexists funzione, che restituisce true se la chiave denominata esiste, indipendentemente da quale potrebbe essere il suo valore -

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

if( exists($data{'Lisa'} ) ) {
   print "Lisa is $data{'Lisa'} years old\n";
} else {
   print "I don't know age of Lisa\n";
}

Qui abbiamo introdotto l'affermazione IF ... ELSE, che studieremo in un capitolo separato. Per ora lo presumiif( condition ) parte verrà eseguita solo quando la condizione data è vera altrimenti elseparte verrà eseguita. Quindi, quando eseguiamo il programma sopra, produce il seguente risultato perché qui esiste la condizione data ($ data {'Lisa'} restituisce true -

Lisa is 30 years old

Ottenere dimensioni hash

È possibile ottenere la dimensione, ovvero il numero di elementi da un hash, utilizzando il contesto scalare su chiavi o valori. Semplicemente dicendo prima devi ottenere un array di chiavi o valori e quindi puoi ottenere la dimensione dell'array come segue:

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

@keys = keys %data;
$size = @keys; print "1 - Hash size: is $size\n";

@values = values %data;
$size = @values; print "2 - Hash size: is $size\n";

Questo produrrà il seguente risultato:

1 - Hash size: is 3
2 - Hash size: is 3

Aggiungi e rimuovi elementi negli hash

L'aggiunta di una nuova coppia chiave / valore può essere eseguita con una riga di codice utilizzando l'operatore di assegnazione semplice. Ma per rimuovere un elemento dall'hash è necessario utilizzaredelete funziona come mostrato di seguito nell'esempio:

#!/usr/bin/perl

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@keys = keys %data;
$size = @keys; print "1 - Hash size: is $size\n";

# adding an element to the hash;
$data{'Ali'} = 55; @keys = keys %data; $size = @keys;
print "2 - Hash size:  is $size\n"; # delete the same element from the hash; delete $data{'Ali'};
@keys = keys %data;
$size = @keys; print "3 - Hash size: is $size\n";

Questo produrrà il seguente risultato:

1 - Hash size: is 3
2 - Hash size: is 4
3 - Hash size: is 3

Le istruzioni condizionali Perl aiutano nel processo decisionale, che richiede che il programmatore specifichi una o più condizioni che devono essere valutate o testate dal programma, insieme a una o più istruzioni da eseguire se la condizione è determinata essere vera e, facoltativamente, altre istruzioni da eseguire se si determina che la condizione è falsa.

Di seguito è riportato il generale di una tipica struttura decisionale presente nella maggior parte dei linguaggi di programmazione:

Il numero 0, le stringhe "0" e "", l'elenco vuoto () e undef sono tutti false in un contesto booleano e tutti gli altri valori lo sono true. Negazione di un valore reale da parte di! o not restituisce un valore falso speciale.

Il linguaggio di programmazione Perl fornisce i seguenti tipi di istruzioni condizionali.

Sr.No.	Dichiarazione e descrizione
1	istruzione if Un if statement consiste in un'espressione booleana seguita da una o più istruzioni.
2	if ... else dichiarazione Un if statement può essere seguito da un optional else statement.
3	if ... elsif ... else istruzione Un if statement può essere seguito da un optional elsif statement e poi da un optional else statement.
4	salvo dichiarazione Un unless statement consiste in un'espressione booleana seguita da una o più istruzioni.
5	a meno che ... altra dichiarazione Un unless statement può essere seguito da un optional else statement.
6	a meno che ... elsif..else dichiarazione Un unless statement può essere seguito da un optional elsif statement e poi da un optional else statement.
7	istruzione switch Con le ultime versioni di Perl, puoi usare il switchdichiarazione. che consente un modo semplice di confrontare un valore variabile con varie condizioni.

Il ? : Operatore

Controlliamo il file conditional operator ? :che può essere utilizzato per sostituire if...elsedichiarazioni. Ha la seguente forma generale:

Exp1 ? Exp2 : Exp3;

Dove Exp1, Exp2 e Exp3 sono espressioni. Notare l'uso e il posizionamento dei due punti.

Il valore di un? l'espressione è determinata in questo modo: viene valutata Exp1. Se è vero, allora Exp2 viene valutato e diventa il valore dell'intero? espressione. Se Exp1 è falso, viene valutato Exp3 e il suo valore diventa il valore dell'espressione. Di seguito è riportato un semplice esempio che utilizza questo operatore:

#!/usr/local/bin/perl
 
$name = "Ali"; $age = 10;

$status = ($age > 60 )? "A senior citizen" : "Not a senior citizen";

print "$name is - $status\n";

Questo produrrà il seguente risultato:

Ali is - Not a senior citizen

Potrebbe esserci una situazione in cui è necessario eseguire un blocco di codice più volte. In generale, le istruzioni vengono eseguite in sequenza: la prima istruzione in una funzione viene eseguita per prima, seguita dalla seconda e così via.

I linguaggi di programmazione forniscono varie strutture di controllo che consentono percorsi di esecuzione più complicati.

Un'istruzione loop ci consente di eseguire un'istruzione o un gruppo di istruzioni più volte e la seguente è la forma generale di un'istruzione loop nella maggior parte dei linguaggi di programmazione:

Il linguaggio di programmazione Perl fornisce i seguenti tipi di loop per gestire i requisiti di loop.

Sr.No.	Tipo e descrizione del loop
1	while loop Ripete un'istruzione o un gruppo di istruzioni finché una determinata condizione è vera. Verifica la condizione prima di eseguire il corpo del ciclo.
2	fino al ciclo Ripete un'affermazione o un gruppo di affermazioni finché una determinata condizione non diventa vera. Verifica la condizione prima di eseguire il corpo del ciclo.
3	per loop Esegue una sequenza di istruzioni più volte e abbrevia il codice che gestisce la variabile del ciclo.
4	ciclo foreach Il ciclo foreach itera su un normale valore di elenco e imposta la variabile VAR in modo che sia a turno ogni elemento dell'elenco.
5	fare ... mentre loop Come un'istruzione while, tranne per il fatto che verifica la condizione alla fine del corpo del ciclo
6	loop annidati È possibile utilizzare uno o più cicli all'interno di un altro ciclo while, for o do.. while.

Dichiarazioni di controllo del loop

Le istruzioni di controllo del ciclo cambiano l'esecuzione dalla sua sequenza normale. Quando l'esecuzione esce da un ambito, tutti gli oggetti automatici creati in tale ambito vengono eliminati.

Perl supporta le seguenti istruzioni di controllo. Fare clic sui seguenti collegamenti per verificarne i dettagli.

Sr.No.	Dichiarazione di controllo e descrizione
1	dichiarazione successiva Fa sì che il ciclo salti il resto del suo corpo e ritorni immediatamente le sue condizioni prima di ripetere.
2	ultima dichiarazione Termina l'istruzione loop e trasferisce l'esecuzione all'istruzione immediatamente successiva al loop.
3	continua dichiarazione Un BLOCCO continuo, viene sempre eseguito appena prima che il condizionale stia per essere valutato di nuovo.
4	redo statement Il comando redo riavvia il blocco del loop senza valutare nuovamente il condizionale. L'eventuale blocco continue non viene eseguito.
5	istruzione goto Perl supporta un comando goto con tre forme: goto label, goto expr e goto & name.

Il ciclo infinito

Un ciclo diventa ciclo infinito se una condizione non diventa mai falsa. Ilforloop è tradizionalmente utilizzato per questo scopo. Poiché nessuna delle tre espressioni che formano il filefor loop sono obbligatori, puoi creare un loop infinito lasciando vuota l'espressione condizionale.

#!/usr/local/bin/perl
 
for( ; ; ) {
   printf "This loop will run forever.\n";
}

È possibile terminare il ciclo infinito precedente premendo i tasti Ctrl + C.

Quando l'espressione condizionale è assente, si presume che sia vera. Potresti avere un'inizializzazione e un'espressione di incremento, ma come programmatore usa più comunemente il costrutto for (;;) per indicare un ciclo infinito.

Cos'è un operatore?

La risposta semplice può essere data usando l'espressione 4 + 5 è uguale a 9 . Qui 4 e 5 sono chiamati operandi e + è chiamato operatore. Il linguaggio Perl supporta molti tipi di operatori, ma di seguito è riportato un elenco di operatori importanti e utilizzati più di frequente:

Operatori aritmetici
Operatori di uguaglianza
Operatori logici
Operatori di assegnazione
Operatori bit per bit
Operatori logici
Operatori simili a virgolette
Operatori vari

Diamo uno sguardo a tutti gli operatori uno per uno.

Operatori aritmetici Perl

Assumi variabile $a holds 10 and variable $b contiene 20, quindi i seguenti sono gli operatori aritmatici Perl:

Mostra esempio

Sr.No.	Operatore e descrizione
1	+ ( Addition ) Aggiunge valori su entrambi i lati dell'operatore Example - $a + $b darà 30
2	- (Subtraction) Sottrae l'operando della mano destra dall'operando della mano sinistra Example - $a - $b darà -10
3	* (Multiplication) Moltiplica i valori su entrambi i lati dell'operatore Example - $a * $b darà 200
4	/ (Division) Divide l'operando sinistro per l'operando destro Example - $b / $un darà 2
5	% (Modulus) Divide l'operando di sinistra per l'operando di destra e restituisce il resto Example - $b % $un darà 0
6	(Exponent) Esegue il calcolo esponenziale (potenza) sugli operatori Example - $a$b darà 10 alla potenza 20

Operatori di uguaglianza Perl

Questi sono anche chiamati operatori relazionali. Assumi variabile$a holds 10 and variable $b contiene 20 quindi, controlliamo i seguenti operatori di uguaglianza numerica -

Mostra esempio

Sr.No.	Operatore e descrizione
1	== (equal to) Controlla se il valore di due operandi è uguale o meno, in caso affermativo la condizione diventa vera. Example - ($a == $b) non è vero.
2	!= (not equal to) Controlla se il valore di due operandi è uguale o meno, se i valori non sono uguali la condizione diventa vera. Example - ($a != $b) è vero.
3	<=> Controlla se il valore di due operandi è uguale o meno e restituisce -1, 0 o 1 a seconda che l'argomento di sinistra sia numericamente minore, uguale o maggiore dell'argomento destro. Example - ($a <=> $b) restituisce -1.
4	> (greater than) Controlla se il valore dell'operando sinistro è maggiore del valore dell'operando destro, in caso affermativo la condizione diventa vera. Example - ($a > $b) non è vero.
5	< (less than) Controlla se il valore dell'operando sinistro è inferiore al valore dell'operando destro, in caso affermativo la condizione diventa vera. Example - ($a < $b) è vero.
6	>= (greater than or equal to) Controlla se il valore dell'operando sinistro è maggiore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera. Example - ($a >= $b) non è vero.
7	<= (less than or equal to) Controlla se il valore dell'operando sinistro è minore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera. Example - ($a <= $b) è vero.

Di seguito è riportato un elenco di operatori azionari. Assumi variabile$a holds "abc" and variable $b contiene "xyz" quindi, controlliamo i seguenti operatori di uguaglianza delle stringhe -

Mostra esempio

Sr.No.	Operatore e descrizione
1	lt Restituisce vero se l'argomento di sinistra è inferiore in senso stringa rispetto all'argomento di destra. Example - ($a lt $b) è vero.
2	gt Restituisce vero se l'argomento di sinistra è maggiore nel senso della stringa dell'argomento di destra. Example - ($a gt $b) è falso.
3	le Restituisce vero se l'argomento di sinistra è inferiore o uguale all'argomento di destra in senso stringa. Example - ($a le $b) è vero.
4	ge Restituisce vero se l'argomento di sinistra è maggiore o uguale all'argomento di destra in senso stringa. Example - ($a ge $b) è falso.
5	eq Restituisce vero se l'argomento di sinistra è uguale all'argomento di destra in senso stringa. Example - ($a eq $b) è falso.
6	ne Restituisce vero se l'argomento di sinistra non è uguale all'argomento di destra in senso stringa. Example - ($a ne $b) è vero.
7	cmp Restituisce -1, 0 o 1 a seconda che l'argomento di sinistra sia minore, uguale o maggiore dell'argomento di destra in senso stringa. Example - ($a cmp $b) è -1.

Operatori di assegnazione Perl

Assumi variabile $a holds 10 and variable $b ne contiene 20, quindi di seguito sono riportati gli operatori di assegnazione disponibili in Perl e il loro utilizzo:

Mostra esempio

Sr.No.	Operatore e descrizione
1	= Operatore di assegnazione semplice, Assegna i valori dagli operandi del lato destro all'operando del lato sinistro Example - $c = $a + $b will assigned value of $a + $b into $c
2	+= Aggiungi operatore di assegnazione AND, aggiunge l'operando destro all'operando sinistro e assegna il risultato all'operando sinistro Example - $c += $a è equivalente a $c = $c + $ a
3	-= Sottrai AND operatore di assegnazione, sottrae l'operando destro dall'operando sinistro e assegna il risultato all'operando sinistro Example - $ c - = $a is equivalent to $c = $c - $un
4	= Moltiplica AND operatore di assegnazione, moltiplica l'operando destro con l'operando sinistro e assegna il risultato all'operando sinistro Example* - $c = $a è equivalente a $c = $c $ a
5	/= Divide AND operatore di assegnazione, divide l'operando sinistro con l'operando destro e assegna il risultato all'operando sinistro Example - $ c / = $a is equivalent to $c = $c / $un
6	%= Modulo AND operatore di assegnazione, richiede il modulo utilizzando due operandi e assegna il risultato all'operando sinistro Example - $c %= $a è equivalente a $c = $circa
7	= Operatore di assegnazione AND esponenziale, esegue il calcolo esponenziale (potenza) sugli operatori e assegna un valore all'operando sinistro Example - $c = $a è equivalente a $c = $c ** $ a

Operatori bit per bit Perl

Bitwise operator works on bits and perform bit by bit operation. Assume if $a = 60; and $b = 13; Now in binary format they will be as follows −

$a = 0011 1100

$b = 0000 1101

-----------------

$a&$b = 0000 1100

$a|$b = 0011 1101

$a^$b = 0011 0001

~$a = 1100 0011

There are following Bitwise operators supported by Perl language, assume if $a = 60; and $b = 13

Show Example

Sr.No.	Operator & Description
1	& Binary AND Operator copies a bit to the result if it exists in both operands. Example − ($a & $b) will give 12 which is 0000 1100
2	\| Binary OR Operator copies a bit if it exists in eather operand. Example − ($a \| $b) will give 61 which is 0011 1101
3	^ Binary XOR Operator copies the bit if it is set in one operand but not both. Example − ($a ^ $b) will give 49 which is 0011 0001
4	~ Binary Ones Complement Operator is unary and has the efect of 'flipping' bits. Example − (~$a ) will give -61 which is 1100 0011 in 2's complement form due to a signed binary number.
5	<< Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand. Example − $a << 2 will give 240 which is 1111 0000
6	>> Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand. Example − $a >> 2 will give 15 which is 0000 1111

Perl Logical Operators

There are following logical operators supported by Perl language. Assume variable $a holds true and variable $b holds false then −

Show Example

Sr.No.	Operator & Description
1	and Called Logical AND operator. If both the operands are true then then condition becomes true. Example − ($a and $b) is false.
2	&& C-style Logical AND operator copies a bit to the result if it exists in both operands. Example − ($a && $b) is false.
3	or Called Logical OR Operator. If any of the two operands are non zero then then condition becomes true. Example − ($a or $b) is true.
4	\|\| C-style Logical OR operator copies a bit if it exists in eather operand. Example − ($a \|\| $b) is true.
5	not Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. Example − not($a and $b) is true.

Quote-like Operators

There are following Quote-like operators supported by Perl language. In the following table, a {} represents any pair of delimiters you choose.

Show Example

Sr.No.	Operator & Description
1	q{ } Encloses a string with-in single quotes Example − q{abcd} gives 'abcd'
2	qq{ } Encloses a string with-in double quotes Example − qq{abcd} gives "abcd"
3	qx{ } Encloses a string with-in invert quotes Example − qx{abcd} gives `abcd`

Miscellaneous Operators

There are following miscellaneous operators supported by Perl language. Assume variable a holds 10 and variable b holds 20 then −

Show Example

Sr.No.	Operator & Description
1	. Binary operator dot (.) concatenates two strings. Example − If $a = "abc", $b = "def" then $a.$b will give "abcdef"
2	x The repetition operator x returns a string consisting of the left operand repeated the number of times specified by the right operand. Example − ('-' x 3) will give ---.
3	.. The range operator .. returns a list of values counting (up by ones) from the left value to the right value Example − (2..5) will give (2, 3, 4, 5)
4	++ Auto Increment operator increases integer value by one Example − $a++ will give 11
5	-- Auto Decrement operator decreases integer value by one Example − $a-- will give 9
6	-> The arrow operator is mostly used in dereferencing a method or variable from an object or a class name Example − $obj->$a is an example to access variable $a from object $obj.

Perl Operators Precedence

The following table lists all operators from highest precedence to lowest.

Show Example

left	terms and list operators (leftward)
left	->
nonassoc	++ --
right	**
right	! ~ \ and unary + and -
left	=~ !~
left	* / % x
left	+ - .
left	<< >>
nonassoc	named unary operators
nonassoc	< > <= >= lt gt le ge
nonassoc	== != <=> eq ne cmp ~~
left	&
left	| ^
left	&&
left	|| //
nonassoc	..  ...
right	?:
right	= += -= *= etc.
left	, =>
nonassoc	list operators (rightward)
right	not
left	and
left	or xor

This chapter will give you the basic understanding on how to process and manipulate dates and times in Perl.

Current Date and Time

Let's start with localtime() function, which returns values for the current date and time if given no arguments. Following is the 9-element list returned by the localtime function while using in list context −

sec,     # seconds of minutes from 0 to 61
min,     # minutes of hour from 0 to 59
hour,    # hours of day from 0 to 24
mday,    # day of month from 1 to 31
mon,     # month of year from 0 to 11
year,    # year since 1900
wday,    # days since sunday
yday,    # days since January 1st
isdst    # hours of daylight savings time

Try the following example to print different elements returned by localtime() function −

#!/usr/local/bin/perl
 
@months = qw( Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec );
@days = qw(Sun Mon Tue Wed Thu Fri Sat Sun);

($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime();
print "$mday $months[$mon] $days[$wday]\n";

When the above code is executed, it produces the following result −

16 Feb Sat

If you will use localtime() function in scalar context, then it will return date and time from the current time zone set in the system. Try the following example to print current date and time in full format −

#!/usr/local/bin/perl
 
$datestring = localtime();
print "Local date and time $datestring\n";

When the above code is executed, it produces the following result −

Local date and time Sat Feb 16 06:50:45 2013

GMT Time

The function gmtime() works just like localtime() function but the returned values are localized for the standard Greenwich time zone. When called in list context, $isdst, the last value returned by gmtime, is always 0. There is no Daylight Saving Time in GMT.

You should make a note on the fact that localtime() will return the current local time on the machine that runs the script and gmtime() will return the universal Greenwich Mean Time, or GMT (or UTC).

Try the following example to print the current date and time but on GMT scale −

#!/usr/local/bin/perl

$datestring = gmtime(); print "GMT date and time $datestring\n";

When the above code is executed, it produces the following result −

GMT date and time Sat Feb 16 13:50:45 2013

Format Date and Time

You can use localtime() function to get a list of 9-elements and later you can use the printf() function to format date and time based on your requirements as follows −

#!/usr/local/bin/perl
 
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(); printf("Time Format - HH:MM:SS\n"); printf("%02d:%02d:%02d", $hour, $min, $sec);

When the above code is executed, it produces the following result −

Time Format - HH:MM:SS
06:58:52

Epoch time

You can use the time() function to get epoch time, i.e., the numbers of seconds that have elapsed since a given date, in Unix is January 1, 1970.

#!/usr/local/bin/perl
 
$epoc = time(); print "Number of seconds since Jan 1, 1970 - $epoc\n";

When the above code is executed, it produces the following result −

Number of seconds since Jan 1, 1970 - 1361022130

You can convert a given number of seconds into date and time string as follows −

#!/usr/local/bin/perl

$datestring = localtime(); print "Current date and time $datestring\n";

$epoc = time(); $epoc = $epoc - 24 * 60 * 60; # one day before of current date. $datestring = localtime($epoc); print "Yesterday's date and time $datestring\n";

When the above code is executed, it produces the following result −

Current date and time Tue Jun  5 05:54:43 2018
Yesterday's date and time Mon Jun  4 05:54:43 2018

POSIX Function strftime()

You can use the POSIX function strftime() to format date and time with the help of the following table. Please note that the specifiers marked with an asterisk (*) are locale-dependent.

Specifier	Replaced by	Example
`%a`	Abbreviated weekday name *	`Thu`
`%A`	Full weekday name *	`Thursday`
`%b`	Abbreviated month name *	`Aug`
`%B`	Full month name *	`August`
`%c`	Date and time representation *	`Thu Aug 23 14:55:02 2001`
`%C`	Year divided by 100 and truncated to integer (`00-99`)	`20`
`%d`	Day of the month, zero-padded (`01-31`)	`23`
`%D`	Short `MM/DD/YY` date, equivalent to `%m/%d/%y`	`08/23/01`
`%e`	Day of the month, space-padded (`1-31`)	`23`
`%F`	Short `YYYY-MM-DD` date, equivalent to `%Y-%m-%d`	`2001-08-23`
`%g`	Week-based year, last two digits (`00-99`)	`01`
`%G`	Week-based year	`2001`
`%h`	Abbreviated month name * (same as `%b`)	`Aug`
`%H`	Hour in 24h format (`00-23`)	`14`
`%I`	Hour in 12h format (`01-12`)	`02`
`%j`	Day of the year (`001-366`)	`235`
`%m`	Month as a decimal number (`01-12`)	`08`
`%M`	Minute (`00-59`)	`55`
`%n`	New-line character (`'\n'`)
`%p`	AM or PM designation	`PM`
`%r`	12-hour clock time *	`02:55:02 pm`
`%R`	24-hour `HH:MM` time, equivalent to `%H:%M`	`14:55`
`%S`	Second (`00-61`)	`02`
`%t`	Horizontal-tab character (`'\t'`)
`%T`	ISO 8601 time format (`HH:MM:SS`), equivalent to `%H:%M:%S`	`14:55`
`%u`	ISO 8601 weekday as number with Monday as `1` (`1-7`)	`4`
`%U`	Week number with the first Sunday as the first day of week one (`00-53`)	`33`
`%V`	ISO 8601 week number (`00-53`)	`34`
`%w`	Weekday as a decimal number with Sunday as `0` (`0-6`)	`4`
`%W`	Week number with the first Monday as the first day of week one (`00-53`)	`34`
`%x`	Date representation *	`08/23/01`
`%X`	Time representation *	`14:55:02`
`%y`	Year, last two digits (`00-99`)	`01`
`%Y`	Year	`2001`
`%z`	ISO 8601 offset from UTC in timezone (1 minute = 1, 1 hour = 100) If timezone cannot be termined, no characters	`+100`
`%Z`	Timezone name or abbreviation * If timezone cannot be termined, no characters	`CDT`
`%%`	A `%` sign	`%`

Let's check the following example to understand the usage −

#!/usr/local/bin/perl
use POSIX qw(strftime);

$datestring = strftime "%a %b %e %H:%M:%S %Y", localtime; printf("date and time - $datestring\n");

# or for GMT formatted appropriately for your locale:
$datestring = strftime "%a %b %e %H:%M:%S %Y", gmtime; printf("date and time - $datestring\n");

When the above code is executed, it produces the following result −

date and time - Sat Feb 16 07:10:23 2013
date and time - Sat Feb 16 14:10:23 2013

A Perl subroutine or function is a group of statements that together performs a task. You can divide up your code into separate subroutines. How you divide up your code among different subroutines is up to you, but logically the division usually is so each function performs a specific task.

Perl uses the terms subroutine, method and function interchangeably.

Define and Call a Subroutine

The general form of a subroutine definition in Perl programming language is as follows −

sub subroutine_name {
   body of the subroutine
}

The typical way of calling that Perl subroutine is as follows −

subroutine_name( list of arguments );

In versions of Perl before 5.0, the syntax for calling subroutines was slightly different as shown below. This still works in the newest versions of Perl, but it is not recommended since it bypasses the subroutine prototypes.

&subroutine_name( list of arguments );

Let's have a look into the following example, which defines a simple function and then call it. Because Perl compiles your program before executing it, it doesn't matter where you declare your subroutine.

#!/usr/bin/perl

# Function definition
sub Hello {
   print "Hello, World!\n";
}

# Function call
Hello();

When above program is executed, it produces the following result −

Hello, World!

Passing Arguments to a Subroutine

You can pass various arguments to a subroutine like you do in any other programming language and they can be acessed inside the function using the special array @_. Thus the first argument to the function is in $_[0], the second is in $_[1], and so on.

You can pass arrays and hashes as arguments like any scalar but passing more than one array or hash normally causes them to lose their separate identities. So we will use references ( explained in the next chapter ) to pass any array or hash.

Let's try the following example, which takes a list of numbers and then prints their average −

#!/usr/bin/perl

# Function definition
sub Average {
   # get total number of arguments passed.
   $n = scalar(@_); $sum = 0;

   foreach $item (@_) { $sum += $item; } $average = $sum / $n;

   print "Average for the given numbers : $average\n";
}

# Function call
Average(10, 20, 30);

When above program is executed, it produces the following result −

Average for the given numbers : 20

Passing Lists to Subroutines

Because the @_ variable is an array, it can be used to supply lists to a subroutine. However, because of the way in which Perl accepts and parses lists and arrays, it can be difficult to extract the individual elements from @_. If you have to pass a list along with other scalar arguments, then make list as the last argument as shown below −

#!/usr/bin/perl

# Function definition
sub PrintList {
   my @list = @_;
   print "Given list is @list\n";
}
$a = 10;
@b = (1, 2, 3, 4);

# Function call with list parameter
PrintList($a, @b);

When above program is executed, it produces the following result −

Given list is 10 1 2 3 4

Passing Hashes to Subroutines

When you supply a hash to a subroutine or operator that accepts a list, then hash is automatically translated into a list of key/value pairs. For example −

#!/usr/bin/perl

# Function definition
sub PrintHash {
   my (%hash) = @_;

   foreach my $key ( keys %hash ) {
      my $value = $hash{$key}; print "$key : $value\n";
   }
}
%hash = ('name' => 'Tom', 'age' => 19);

# Function call with hash parameter
PrintHash(%hash);

When above program is executed, it produces the following result −

name : Tom
age : 19

Returning Value from a Subroutine

You can return a value from subroutine like you do in any other programming language. If you are not returning a value from a subroutine then whatever calculation is last performed in a subroutine is automatically also the return value.

You can return arrays and hashes from the subroutine like any scalar but returning more than one array or hash normally causes them to lose their separate identities. So we will use references ( explained in the next chapter ) to return any array or hash from a function.

Let's try the following example, which takes a list of numbers and then returns their average −

#!/usr/bin/perl

# Function definition
sub Average {
   # get total number of arguments passed.
   $n = scalar(@_);
   $sum = 0; foreach $item (@_) {
      $sum += $item;
   }
   $average = $sum / $n; return $average;
}

# Function call
$num = Average(10, 20, 30); print "Average for the given numbers : $num\n";

When above program is executed, it produces the following result −

Average for the given numbers : 20

Private Variables in a Subroutine

By default, all variables in Perl are global variables, which means they can be accessed from anywhere in the program. But you can create private variables called lexical variables at any time with the my operator.

The my operator confines a variable to a particular region of code in which it can be used and accessed. Outside that region, this variable cannot be used or accessed. This region is called its scope. A lexical scope is usually a block of code with a set of braces around it, such as those defining the body of the subroutine or those marking the code blocks of if, while, for, foreach, and eval statements.

Following is an example showing you how to define a single or multiple private variables using my operator −

sub somefunc {
   my $variable; # $variable is invisible outside somefunc()
   my ($another, @an_array, %a_hash); # declaring many variables at once
}

Let's check the following example to distinguish between global and private variables −

#!/usr/bin/perl

# Global variable
$string = "Hello, World!";

# Function definition
sub PrintHello {
   # Private variable for PrintHello function
   my $string; $string = "Hello, Perl!";
   print "Inside the function $string\n"; } # Function call PrintHello(); print "Outside the function $string\n";

When above program is executed, it produces the following result −

Inside the function Hello, Perl!
Outside the function Hello, World!

Temporary Values via local()

The local is mostly used when the current value of a variable must be visible to called subroutines. A local just gives temporary values to global (meaning package) variables. This is known as dynamic scoping. Lexical scoping is done with my, which works more like C's auto declarations.

If more than one variable or expression is given to local, they must be placed in parentheses. This operator works by saving the current values of those variables in its argument list on a hidden stack and restoring them upon exiting the block, subroutine, or eval.

Let's check the following example to distinguish between global and local variables −

#!/usr/bin/perl

# Global variable
$string = "Hello, World!"; sub PrintHello { # Private variable for PrintHello function local $string;
   $string = "Hello, Perl!"; PrintMe(); print "Inside the function PrintHello $string\n";
}
sub PrintMe {
   print "Inside the function PrintMe $string\n"; } # Function call PrintHello(); print "Outside the function $string\n";

When above program is executed, it produces the following result −

Inside the function PrintMe Hello, Perl!
Inside the function PrintHello Hello, Perl!
Outside the function Hello, World!

State Variables via state()

There are another type of lexical variables, which are similar to private variables but they maintain their state and they do not get reinitialized upon multiple calls of the subroutines. These variables are defined using the state operator and available starting from Perl 5.9.4.

Let's check the following example to demonstrate the use of state variables −

#!/usr/bin/perl

use feature 'state';

sub PrintCount {
   state $count = 0; # initial value print "Value of counter is $count\n";
   $count++;
}

for (1..5) {
   PrintCount();
}

When above program is executed, it produces the following result −

Value of counter is 0
Value of counter is 1
Value of counter is 2
Value of counter is 3
Value of counter is 4

Prior to Perl 5.10, you would have to write it like this −

#!/usr/bin/perl

{
   my $count = 0; # initial value

   sub PrintCount {
      print "Value of counter is $count\n"; $count++;
   }
}

for (1..5) {
   PrintCount();
}

Subroutine Call Context

The context of a subroutine or statement is defined as the type of return value that is expected. This allows you to use a single function that returns different values based on what the user is expecting to receive. For example, the following localtime() returns a string when it is called in scalar context, but it returns a list when it is called in list context.

my $datestring = localtime( time );

In this example, the value of $timestr is now a string made up of the current date and time, for example, Thu Nov 30 15:21:33 2000. Conversely −

($sec,$min,$hour,$mday,$mon, $year,$wday,$yday,$isdst) = localtime(time);

Now the individual variables contain the corresponding values returned by localtime() subroutine.

A Perl reference is a scalar data type that holds the location of another value which could be scalar, arrays, or hashes. Because of its scalar nature, a reference can be used anywhere, a scalar can be used.

You can construct lists containing references to other lists, which can contain references to hashes, and so on. This is how the nested data structures are built in Perl.

Create References

It is easy to create a reference for any variable, subroutine or value by prefixing it with a backslash as follows −

$scalarref = \$foo; $arrayref  = \@ARGV;
$hashref = \%ENV; $coderef   = \&handler;
$globref   = \*foo;

You cannot create a reference on an I/O handle (filehandle or dirhandle) using the backslash operator but a reference to an anonymous array can be created using the square brackets as follows −

$arrayref = [1, 2, ['a', 'b', 'c']];

Similar way you can create a reference to an anonymous hash using the curly brackets as follows −

$hashref = {
   'Adam'  => 'Eve',
   'Clyde' => 'Bonnie',
};

A reference to an anonymous subroutine can be created by using sub without a subname as follows −

$coderef = sub { print "Boink!\n" };

Dereferencing

Dereferencing returns the value from a reference point to the location. To dereference a reference simply use $, @ or % as prefix of the reference variable depending on whether the reference is pointing to a scalar, array, or hash. Following is the example to explain the concept −

#!/usr/bin/perl

$var = 10;

# Now $r has reference to $var scalar.
$r = \$var;

# Print value available at the location stored in $r. print "Value of $var is : ", $$r, "\n"; @var = (1, 2, 3); # Now $r has reference to @var array.
$r = \@var; # Print values available at the location stored in $r.
print "Value of @var is : ",  @$r, "\n"; %var = ('key1' => 10, 'key2' => 20); # Now $r has reference to %var hash.
$r = \%var; # Print values available at the location stored in $r.
print "Value of %var is : ", %$r, "\n";

When above program is executed, it produces the following result −

Value of 10 is : 10
Value of 1 2 3 is : 123
Value of %var is : key220key110

If you are not sure about a variable type, then its easy to know its type using ref, which returns one of the following strings if its argument is a reference. Otherwise, it returns false −

SCALAR
ARRAY
HASH
CODE
GLOB
REF

Let's try the following example −

#!/usr/bin/perl

$var = 10;
$r = \$var;
print "Reference type in r : ", ref($r), "\n"; @var = (1, 2, 3); $r = \@var;
print "Reference type in r : ", ref($r), "\n"; %var = ('key1' => 10, 'key2' => 20); $r = \%var;
print "Reference type in r : ", ref($r), "\n";

When above program is executed, it produces the following result −

Reference type in r : SCALAR
Reference type in r : ARRAY
Reference type in r : HASH

Circular References

A circular reference occurs when two references contain a reference to each other. You have to be careful while creating references otherwise a circular reference can lead to memory leaks. Following is an example −

#!/usr/bin/perl

 my $foo = 100;
 $foo = \$foo;
 
 print "Value of foo is : ", $$foo, "\n";

Quando viene eseguito il programma sopra, produce il seguente risultato:

Value of foo is : REF(0x9aae38)

Riferimenti a funzioni

Ciò potrebbe accadere se è necessario creare un gestore di segnali in modo da poter produrre un riferimento a una funzione facendo precedere il nome della funzione con \ & e per dereferenziare quel riferimento è sufficiente aggiungere un prefisso alla variabile di riferimento utilizzando la e commerciale &. Di seguito è riportato un esempio:

#!/usr/bin/perl

# Function definition
sub PrintHash {
   my (%hash) = @_;
   
   foreach $item (%hash) {
      print "Item : $item\n"; } } %hash = ('name' => 'Tom', 'age' => 19); # Create a reference to above function. $cref = \&PrintHash;

# Function call using reference.
&$cref(%hash);

Quando viene eseguito il programma sopra, produce il seguente risultato:

Item : name
Item : Tom
Item : age
Item : 19

Perl utilizza un modello di scrittura chiamato "formato" per generare report. Per usare la funzionalità di formattazione di Perl, devi prima definire un formato e poi puoi usare quel formato per scrivere dati formattati.

Definisci un formato

Di seguito è riportata la sintassi per definire un formato Perl:

format FormatName =
fieldline
value_one, value_two, value_three
fieldline
value_one, value_two
.

Qui FormatNamerappresenta il nome del formato. Ilfieldlineè il modo specifico, i dati dovrebbero essere formattati. Le righe dei valori rappresentano i valori che verranno inseriti nella riga del campo. Finisci il formato con un solo punto.

Il prossimo fieldlinepuò contenere qualsiasi testo o fieldholder. I titolari di campo mantengono lo spazio per i dati che verranno inseriti lì in un secondo momento. Un titolare di campo ha il formato:

@<<<<

Questo segnaposto è giustificato a sinistra, con uno spazio del campo pari a 5. È necessario contare i segni @ e <per conoscere il numero di spazi nel campo. Altri detentori di campo includono:

@>>>> right-justified
@|||| centered
@####.## numeric field holder
@* multiline field holder

Un formato di esempio potrebbe essere:

format EMPLOYEE =
===================================
@<<<<<<<<<<<<<<<<<<<<<< @<< 
$name $age @#####.## $salary
===================================
.

In questo esempio, $ nome verrebbe scritto come giustificato a sinistra entro 22 spazi di caratteri e dopo tale età verrà scritto in due spazi.

Utilizzando il formato

Per richiamare questa dichiarazione di formato, utilizzeremo il write parola chiave -

write EMPLOYEE;

Il problema è che il nome del formato è in genere il nome di un handle di file aperto e l'istruzione write invierà l'output a questo handle di file. Poiché vogliamo che i dati vengano inviati allo STDOUT, dobbiamo associare EMPLOYEE al filehandle STDOUT. Per prima cosa, tuttavia, dobbiamo assicurarci che STDOUT sia il nostro handle di file selezionato, utilizzando la funzione select ().

select(STDOUT);

Assoceremo quindi EMPLOYEE a STDOUT impostando il nome del nuovo formato con STDOUT, utilizzando la variabile speciale $ ~ o $ FORMAT_NAME come segue:

$~ = "EMPLOYEE";

Quando ora eseguiamo un write (), i dati verranno inviati a STDOUT. Ricorda: se hai intenzione di scrivere il tuo report in qualsiasi altro handle di file invece di STDOUT, puoi usare la funzione select () per selezionare quell'handle di file e il resto della logica rimarrà la stessa.

Prendiamo il seguente esempio. Qui abbiamo valori hard coded solo per mostrare l'utilizzo. Nell'utilizzo effettivo leggerai i valori da un file o database per generare rapporti effettivi e potrebbe essere necessario scrivere nuovamente il rapporto finale in un file.

#!/usr/bin/perl

format EMPLOYEE =
===================================
@<<<<<<<<<<<<<<<<<<<<<< @<< 
$name $age
@#####.##
$salary =================================== . select(STDOUT); $~ = EMPLOYEE;

@n = ("Ali", "Raza", "Jaffer");
@a  = (20,30, 40);
@s = (2000.00, 2500.00, 4000.000);

$i = 0; foreach (@n) { $name = $_; $age = $a[$i];
   $salary = $s[$i++];
   write;
}

Quando viene eseguito, questo produrrà il seguente risultato:

===================================
Ali                     20
  2000.00
===================================
===================================
Raza                    30
  2500.00
===================================
===================================
Jaffer                  40
  4000.00
===================================

Definisci un'intestazione del rapporto

Sembra tutto a posto. Ma ti interesserebbe aggiungere un'intestazione al tuo rapporto. Questa intestazione verrà stampata nella parte superiore di ogni pagina. È molto semplice farlo. Oltre a definire un modello, dovresti definire un'intestazione e assegnarla alla variabile $ ^ o $ FORMAT_TOP_NAME -

#!/usr/bin/perl

format EMPLOYEE =
===================================
@<<<<<<<<<<<<<<<<<<<<<< @<< 
$name $age @#####.## $salary
===================================
.

format EMPLOYEE_TOP =
===================================
Name                    Age
===================================
.

select(STDOUT);
$~ = EMPLOYEE; $^ = EMPLOYEE_TOP;

@n = ("Ali", "Raza", "Jaffer");
@a  = (20,30, 40);
@s = (2000.00, 2500.00, 4000.000);

$i = 0; foreach (@n) { $name = $_; $age = $a[$i];
   $salary = $s[$i++];
   write;
}

Ora il tuo rapporto avrà il seguente aspetto:

===================================
Name                    Age
===================================
===================================
Ali                     20
  2000.00
===================================
===================================
Raza                    30
  2500.00
===================================
===================================
Jaffer                  40
  4000.00
===================================

Definisci un'impaginazione

E se il tuo rapporto occupa più di una pagina? Hai una soluzione per questo, usa semplicemente$% o $ FORMAT_PAGE_NUMBER vairable insieme all'intestazione come segue -

format EMPLOYEE_TOP =
===================================
Name                    Age Page @<
                                 $%
===================================                               
.

Ora il tuo output sarà come segue:

===================================
Name                    Age Page 1
===================================
===================================
Ali                     20
  2000.00
===================================
===================================
Raza                    30
  2500.00
===================================
===================================
Jaffer                  40
  4000.00
===================================

Numero di righe su una pagina

È possibile impostare il numero di righe per pagina utilizzando una variabile speciale $= (o $ FORMAT_LINES_PER_PAGE), per impostazione predefinita $ = sarà 60.

Definisci un piè di pagina del rapporto

Mentre $ ^ o $FORMAT_TOP_NAME contains the name of the current header format, there is no corresponding mechanism to automatically do the same thing for a footer. If you have a fixed-size footer, you can get footers by checking variable $- oppure $ FORMAT_LINES_LEFT prima di ogni write () e stampa tu stesso il piè di pagina se necessario utilizzando un altro formato definito come segue -

format EMPLOYEE_BOTTOM =
End of Page @<
            $%
.

Per un set completo di variabili relative alla formattazione, fare riferimento alla sezione Variabili speciali di Perl .

Le basi della gestione dei file sono semplici: associ un file filehandle con un'entità esterna (solitamente un file) e quindi utilizzare una varietà di operatori e funzioni all'interno di Perl per leggere e aggiornare i dati memorizzati nel flusso di dati associato al filehandle.

Un filehandle è una struttura Perl interna denominata che associa un file fisico a un nome. Tutti i filehandle sono in grado di accedere in lettura / scrittura, quindi puoi leggere e aggiornare qualsiasi file o dispositivo associato a un filehandle. Tuttavia, quando si associa un filehandle, è possibile specificare la modalità in cui viene aperto il filehandle.

Tre handle di file di base sono: STDIN, STDOUT, e STDERR, che rappresentano rispettivamente i dispositivi di input standard, output standard e standard di errore.

Apertura e chiusura di file

Ci sono le seguenti due funzioni con più moduli, che possono essere usati per aprire qualsiasi file nuovo o esistente in Perl.

open FILEHANDLE, EXPR
open FILEHANDLE

sysopen FILEHANDLE, FILENAME, MODE, PERMS
sysopen FILEHANDLE, FILENAME, MODE

Qui FILEHANDLE è l'handle di file restituito da open funzione ed EXPR è l'espressione con nome file e modalità di apertura del file.

Apri funzione

Di seguito è riportata la sintassi per aprire file.txtin modalità di sola lettura. Qui il segno meno di <indica che il file deve essere aperto in modalità di sola lettura.

open(DATA, "<file.txt");

Qui DATA è l'handle del file, che verrà utilizzato per leggere il file. Ecco l'esempio, che aprirà un file e ne stamperà il contenuto sullo schermo.

#!/usr/bin/perl

open(DATA, "<file.txt") or die "Couldn't open file file.txt, $!"; while(<DATA>) { print "$_";
}

Di seguito è riportata la sintassi per aprire file.txt in modalità di scrittura. Qui il segno meno di> indica che il file deve essere aperto in modalità di scrittura.

open(DATA, ">file.txt") or die "Couldn't open file file.txt, $!";

Questo esempio in realtà tronca (svuota) il file prima di aprirlo per la scrittura, il che potrebbe non essere l'effetto desiderato. Se desideri aprire un file in lettura e scrittura, puoi inserire un segno più prima dei caratteri> o <.

Ad esempio, per aprire un file per l'aggiornamento senza troncarlo:

open(DATA, "+<file.txt"); or die "Couldn't open file file.txt, $!";

Per troncare prima il file:

open DATA, "+>file.txt" or die "Couldn't open file file.txt, $!";

È possibile aprire un file in modalità di aggiunta. In questa modalità, il punto di scrittura verrà impostato alla fine del file.

open(DATA,">>file.txt") || die "Couldn't open file file.txt, $!";

Un doppio >> apre il file per l'aggiunta, posizionando il puntatore del file alla fine, in modo da poter iniziare immediatamente ad aggiungere informazioni. Tuttavia, non puoi leggere da esso a meno che non ci metti anche un segno più -

open(DATA,"+>>file.txt") || die "Couldn't open file file.txt, $!";

Di seguito è riportata la tabella, che fornisce i possibili valori delle diverse modalità

Sr.No.	Entità e definizione
1	< or r Accesso in sola lettura
2	> or w Crea, scrive e tronca
3	>> or a Scrive, aggiunge e crea
4	+< or r+ Legge e scrive
5	+> or w+ Legge, scrive, crea e tronca
6	+>> or a+ Legge, scrive, aggiunge e crea

Funzione Sysopen

Il sysopen è simile alla funzione principale di apertura, tranne per il fatto che utilizza il sistema open() funzione, utilizzando i parametri forniti come parametri per la funzione di sistema -

Ad esempio, per aprire un file da aggiornare, emulando il file +<filename formato da aperto -

sysopen(DATA, "file.txt", O_RDWR);

O per troncare il file prima dell'aggiornamento -

sysopen(DATA, "file.txt", O_RDWR|O_TRUNC );

È possibile utilizzare O_CREAT per creare un nuovo file e O_WRONLY per aprire il file in modalità di sola scrittura e O_RDONLY per aprire il file in modalità di sola lettura.

Il PERMSL'argomento specifica i permessi del file per il file specificato, se deve essere creato. Per impostazione predefinita ci vuole0x666.

Di seguito è riportata la tabella, che fornisce i possibili valori di MODE.

Sr.No.	Entità e definizione
1	O_RDWR Leggere e scrivere
2	O_RDONLY Sola lettura
3	O_WRONLY Solo scrittura
4	O_CREAT Crea il file
5	O_APPEND Aggiungi il file
6	O_TRUNC Tronca il file
7	O_EXCL Si ferma se il file esiste già
8	O_NONBLOCK Usabilità non bloccante

Chiudi funzione

Per chiudere un filehandle, e quindi dissociare il filehandle dal file corrispondente, si utilizza il closefunzione. Questo svuota i buffer del filehandle e chiude il descrittore di file del sistema.

close FILEHANDLE
close

Se non è specificato alcun FILEHANDLE, chiude il filehandle attualmente selezionato. Restituisce true solo se può svuotare correttamente i buffer e chiudere il file.

close(DATA) || die "Couldn't close file properly";

Lettura e scrittura di file

Una volta che hai un filehandle aperto, devi essere in grado di leggere e scrivere informazioni. Esistono diversi modi per leggere e scrivere i dati nel file.

L'operatore <FILEHANDL>

Il metodo principale per leggere le informazioni da un filehandle aperto è l'operatore <FILEHANDLE>. In un contesto scalare, restituisce una singola riga dal filehandle. Ad esempio:

#!/usr/bin/perl

print "What is your name?\n";
$name = <STDIN>;
print "Hello $name\n";

Quando si utilizza l'operatore <FILEHANDLE> in un contesto di elenco, restituisce un elenco di righe dal filehandle specificato. Ad esempio, per importare tutte le righe da un file in un array:

#!/usr/bin/perl

open(DATA,"<import.txt") or die "Can't open data";
@lines = <DATA>;
close(DATA);

Funzione getc

La funzione getc restituisce un singolo carattere dal FILEHANDLE specificato o STDIN se non è specificato nessuno -

getc FILEHANDLE
getc

Se si è verificato un errore o il filehandle si trova alla fine del file, viene restituito undef.

leggere la funzione

La funzione di lettura legge un blocco di informazioni dal filehandle memorizzato nel buffer: Questa funzione viene utilizzata per leggere i dati binari dal file.

read FILEHANDLE, SCALAR, LENGTH, OFFSET
read FILEHANDLE, SCALAR, LENGTH

La lunghezza dei dati letti è definita da LENGTH, e il dato viene posizionato all'inizio di SCALAR se non viene specificato alcun OFFSET. In caso contrario, i dati vengono inseriti dopo i byte OFFSET in SCALARE. La funzione restituisce il numero di byte letti in caso di successo, zero alla fine del file o undef se si è verificato un errore.

Funzione di stampa

Per tutti i diversi metodi usati per leggere le informazioni dai filehandle, la funzione principale per riscrivere le informazioni è la funzione di stampa.

print FILEHANDLE LIST
print LIST
print

La funzione print stampa il valore valutato di LIST su FILEHANDLE o sul filehandle di output corrente (STDOUT per impostazione predefinita). Ad esempio:

print "Hello World!\n";

Copia di file

Ecco l'esempio, che apre un file esistente file1.txt e lo legge riga per riga e genera un altro file di copia file2.txt.

#!/usr/bin/perl

# Open file to read
open(DATA1, "<file1.txt");

# Open new file to write
open(DATA2, ">file2.txt");

# Copy data from one file to another.
while(<DATA1>) {
   print DATA2 $_;
}
close( DATA1 );
close( DATA2 );

Rinominare un file

Ecco un esempio, che mostra come possiamo rinominare un file file1.txt in file2.txt. Supponendo che il file sia disponibile nella directory / usr / test.

#!/usr/bin/perl

rename ("/usr/test/file1.txt", "/usr/test/file2.txt" );

Questa funzione renames accetta due argomenti e rinomina semplicemente il file esistente.

Eliminazione di un file esistente

Ecco un esempio, che mostra come eliminare un file file1.txt utilizzando l'estensione unlink funzione.

#!/usr/bin/perl

unlink ("/usr/test/file1.txt");

Posizionamento all'interno di un file

Puoi usare per tell funzione per conoscere la posizione corrente di un file e seek funzione per puntare una particolare posizione all'interno del file.

Tell Function

Il primo requisito è trovare la tua posizione all'interno di un file, cosa che fai usando la funzione tell -

tell FILEHANDLE
tell

Questo restituisce la posizione del puntatore del file, in byte, all'interno di FILEHANDLE se specificato, o il filehandle selezionato di default corrente se non è specificato nessuno.

cercare la funzione

La funzione di ricerca posiziona il puntatore del file sul numero di byte specificato all'interno di un file -

seek FILEHANDLE, POSITION, WHENCE

La funzione utilizza la funzione di sistema fseek e hai la stessa capacità di posizionare in relazione a tre diversi punti: l'inizio, la fine e la posizione corrente. Puoi farlo specificando un valore per WHENCE.

Zero imposta il posizionamento relativo all'inizio del file. Ad esempio, la riga imposta il puntatore del file al 256 ° byte nel file.

seek DATA, 256, 0;

Informazioni sui file

È possibile testare alcune funzionalità molto rapidamente in Perl utilizzando una serie di operatori di test noti collettivamente come test -X. Ad esempio, per eseguire un rapido test delle varie autorizzazioni su un file, potresti utilizzare uno script come questo:

#/usr/bin/perl

my $file = "/usr/test/file1.txt"; my (@description, $size);
if (-e $file) { push @description, 'binary' if (-B _); push @description, 'a socket' if (-S _); push @description, 'a text file' if (-T _); push @description, 'a block special file' if (-b _); push @description, 'a character special file' if (-c _); push @description, 'a directory' if (-d _); push @description, 'executable' if (-x _); push @description, (($size = -s _)) ? "$size bytes" : 'empty'; print "$file is ", join(', ',@description),"\n";
}

Ecco l'elenco delle funzionalità, che puoi controllare per un file o una directory:

Sr.No.	Operatore e definizione
1	-A Ora di inizio dello script meno l'ora dell'ultimo accesso al file, in giorni.
2	-B È un file binario?
3	-C Ora di inizio dello script meno l'ora dell'ultima modifica dell'inode del file, in giorni.
3	-M Ora di inizio dello script meno l'ora di modifica del file, in giorni.
4	-O Il file è di proprietà dell'ID utente reale?
5	-R Il file è leggibile dall'ID utente reale o dal gruppo reale?
6	-S Il file è un socket?
7	-T È un file di testo?
8	-W Il file è scrivibile dall'ID utente reale o dal gruppo reale?
9	-X Il file è eseguibile dall'ID utente reale o dal gruppo reale?
10	-b È un file speciale a blocchi?
11	-c È un file speciale di caratteri?
12	-d Il file è una directory?
13	-e Il file esiste?
14	-f È un file semplice?
15	-g Il file ha il bit setgid impostato?
16	-k Il file ha il bit appiccicoso impostato?
17	-l Il file è un collegamento simbolico?
18	-o Il file è di proprietà dell'ID utente effettivo?
19	-p Il file è una pipe con nome?
20	-r Il file è leggibile dall'utente effettivo o dall'ID gruppo?
21	-s Restituisce la dimensione del file, zero size = file vuoto.
22	-t Il filehandle è aperto da un TTY (terminale)?
23	-u Il file ha il bit setuid impostato?
24	-w Il file è scrivibile dall'utente o dall'ID gruppo effettivo?
25	-x Il file è eseguibile dall'utente effettivo o dall'ID gruppo?
26	-z La dimensione del file è zero?

Di seguito sono riportate le funzioni standard utilizzate per giocare con le directory.

opendir DIRHANDLE, EXPR  # To open a directory
readdir DIRHANDLE        # To read a directory
rewinddir DIRHANDLE      # Positioning pointer to the begining
telldir DIRHANDLE        # Returns current position of the dir
seekdir DIRHANDLE, POS   # Pointing pointer to POS inside dir
closedir DIRHANDLE       # Closing a directory.

Visualizza tutti i file

Esistono vari modi per elencare tutti i file disponibili in una determinata directory. Per prima cosa usiamo il modo semplice per ottenere ed elencare tutti i file utilizzando l'estensioneglob operatore -

#!/usr/bin/perl

# Display all the files in /tmp directory.
$dir = "/tmp/*"; my @files = glob( $dir );

foreach (@files ) {
   print $_ . "\n"; } # Display all the C source files in /tmp directory. $dir = "/tmp/*.c";
@files = glob( $dir ); foreach (@files ) { print $_ . "\n";
}

# Display all the hidden files.
$dir = "/tmp/.*"; @files = glob( $dir );
foreach (@files ) {
   print $_ . "\n"; } # Display all the files from /tmp and /home directories. $dir = "/tmp/* /home/*";
@files = glob( $dir ); foreach (@files ) { print $_ . "\n";
}

Ecco un altro esempio, che apre una directory ed elenca tutti i file disponibili all'interno di questa directory.

#!/usr/bin/perl

opendir (DIR, '.') or die "Couldn't open directory, $!"; while ($file = readdir DIR) {
   print "$file\n";
}
closedir DIR;

Un altro esempio per stampare l'elenco dei file sorgente C che potresti utilizzare è:

#!/usr/bin/perl

opendir(DIR, '.') or die "Couldn't open directory, $!";
foreach (sort grep(/^.*\.c$/,readdir(DIR))) { print "$_\n";
}
closedir DIR;

Crea nuova directory

Puoi usare mkdirfunzione per creare una nuova directory. Sarà necessario disporre dell'autorizzazione richiesta per creare una directory.

#!/usr/bin/perl

$dir = "/tmp/perl"; # This creates perl directory in /tmp directory. mkdir( $dir ) or die "Couldn't create $dir directory, $!";
print "Directory created successfully\n";

Rimuovi una directory

Puoi usare rmdirfunzione per rimuovere una directory. Sarà necessario disporre dell'autorizzazione richiesta per rimuovere una directory. Inoltre, questa directory dovrebbe essere vuota prima di provare a rimuoverla.

#!/usr/bin/perl

$dir = "/tmp/perl"; # This removes perl directory from /tmp directory. rmdir( $dir ) or die "Couldn't remove $dir directory, $!";
print "Directory removed successfully\n";

Cambia una directory

Puoi usare chdirfunzione per cambiare una directory e andare in una nuova posizione. Sarà necessario disporre dell'autorizzazione richiesta per modificare una directory e accedere alla nuova directory.

#!/usr/bin/perl

$dir = "/home"; # This changes perl directory and moves you inside /home directory. chdir( $dir ) or die "Couldn't go inside $dir directory, $!";
print "Your new location is $dir\n";

L'esecuzione e gli errori vanno sempre insieme. Se stai aprendo un file che non esiste. quindi se non hai gestito correttamente questa situazione, il tuo programma è considerato di scarsa qualità.

Il programma si interrompe se si verifica un errore. Quindi una corretta gestione degli errori viene utilizzata per gestire vari tipi di errori, che possono verificarsi durante l'esecuzione di un programma e intraprendere l'azione appropriata invece di interrompere completamente il programma.

È possibile identificare e intercettare un errore in molti modi diversi. È molto facile intercettare gli errori in Perl e quindi gestirli correttamente. Ecco alcuni metodi che possono essere utilizzati.

L'istruzione if

Il if statementè la scelta più ovvia quando è necessario controllare il valore restituito da un'istruzione; per esempio -

if(open(DATA, $file)) {
   ...
} else {
   die "Error: Couldn't open the file - $!";
}

Qui la variabile $! restituisce il messaggio di errore effettivo. In alternativa, possiamo ridurre l'affermazione a una riga nelle situazioni in cui ha senso farlo; per esempio -

open(DATA, $file) || die "Error: Couldn't open the file $!";

La funzioneless

Il unlessla funzione è l'opposto logico di if: le istruzioni possono ignorare completamente lo stato di successo ed essere eseguite solo se l'espressione restituisce false. Ad esempio:

unless(chdir("/etc")) {
   die "Error: Can't change directory - $!";
}

Il unlessè meglio utilizzare quando si desidera sollevare un errore o un'alternativa solo se l'espressione fallisce. L'affermazione ha senso anche se usata in un'istruzione di una sola riga:

die "Error: Can't change directory!: $!" unless(chdir("/etc"));

Qui moriamo solo se l'operazione chdir fallisce e si legge bene.

L'operatore ternario

Per test molto brevi, puoi usare l'operatore condizionale ?:

print(exists($hash{value}) ? 'There' : 'Missing',"\n");

Non è così chiaro qui cosa stiamo cercando di ottenere, ma l'effetto è lo stesso dell'uso di un file if o unlessdichiarazione. L'operatore condizionale viene utilizzato al meglio quando si desidera restituire rapidamente uno dei due valori all'interno di un'espressione o un'istruzione.

La funzione warn

La funzione warn genera solo un avviso, un messaggio viene stampato su STDERR, ma non viene intrapresa alcuna azione. Quindi è più utile se vuoi solo stampare un avviso per l'utente e procedere con il resto dell'operazione -

chdir('/etc') or warn "Can't change directory";

La funzione die

La funzione die funziona proprio come warn, tranne per il fatto che chiama anche exit. All'interno di uno script normale, questa funzione ha l'effetto di terminare immediatamente l'esecuzione. Dovresti usare questa funzione nel caso in cui sia inutile procedere se c'è un errore nel programma -

chdir('/etc') or die "Can't change directory";

Errori all'interno dei moduli

Ci sono due diverse situazioni che dovremmo essere in grado di gestire:

Segnalare un errore in un modulo che cita il nome del file e il numero di riga del modulo: è utile quando si esegue il debug di un modulo o quando si desidera specificamente sollevare un errore relativo al modulo, piuttosto che relativo allo script.
Segnalazione di un errore all'interno di un modulo che cita le informazioni del chiamante in modo da poter eseguire il debug della riga all'interno dello script che ha causato l'errore. Gli errori generati in questo modo sono utili all'utente finale, perché evidenziano l'errore in relazione alla riga di origine dello script chiamante.

Il warn e diele funzioni funzionano in modo leggermente diverso da quello che ti aspetteresti quando chiamate dall'interno di un modulo. Ad esempio, il modulo semplice -

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp;

sub function {
   warn "Error in module!";
}
1;

Quando viene chiamato da uno script come di seguito -

use T;
function();

Produrrà il seguente risultato:

Error in module! at T.pm line 9.

Questo è più o meno quello che potresti aspettarti, ma non necessariamente quello che vuoi. Dal punto di vista di un programmatore di moduli, le informazioni sono utili perché aiutano a indicare un bug all'interno del modulo stesso. Per un utente finale, le informazioni fornite sono abbastanza inutili e per tutti tranne che per i programmatori incalliti, sono completamente inutili.

La soluzione a questi problemi è il modulo Carp, che fornisce un metodo semplificato per segnalare errori all'interno dei moduli che restituiscono informazioni sullo script chiamante. Il modulo Carp fornisce quattro funzioni: carpa, cluck, gracidare e confessare. Queste funzioni sono discusse di seguito.

La funzione carpa

La funzione carp è l'equivalente di base di warn e stampa il messaggio su STDERR senza effettivamente uscire dallo script e stampare il nome dello script.

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp;

sub function {
   carp "Error in module!";
}
1;

Quando viene chiamato da uno script come di seguito -

use T;
function();

Produrrà il seguente risultato:

Error in module! at test.pl line 4

La funzione cluck

La funzione cluck è una sorta di carpa sovralimentata, segue lo stesso principio di base ma stampa anche una traccia dello stack di tutti i moduli che hanno portato alla chiamata della funzione, comprese le informazioni sullo script originale.

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp qw(cluck);

sub function {
   cluck "Error in module!";
}
1;

Quando viene chiamato da uno script come di seguito -

use T;
function();

Produrrà il seguente risultato:

Error in module! at T.pm line 9
   T::function() called at test.pl line 4

La funzione gracchiare

Il croak funzione è equivalente a die, tranne per il fatto che segnala il chiamante di un livello superiore. Come die, anche questa funzione esce dallo script dopo aver segnalato l'errore a STDERR -

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp;

sub function {
   croak "Error in module!";
}
1;

Quando viene chiamato da uno script come di seguito -

use T;
function();

Produrrà il seguente risultato:

Error in module! at test.pl line 4

Come per le carpe, si applicano le stesse regole di base per quanto riguarda l'inclusione delle informazioni sulla linea e sul file in base alle funzioni di avvertimento e di matrice.

La funzione confessare

Il confess la funzione è simile cluck; chiama die e quindi stampa una traccia dello stack fino allo script di origine.

package T;

require Exporter;
@ISA = qw/Exporter/;
@EXPORT = qw/function/;
use Carp;

sub function {
   confess "Error in module!";
}
1;

Quando viene chiamato da uno script come di seguito -

use T;
function();

Produrrà il seguente risultato:

Error in module! at T.pm line 9
   T::function() called at test.pl line 4

Ci sono alcune variabili che hanno un significato predefinito e speciale in Perl. Sono le variabili che utilizzano i caratteri di punteggiatura dopo il solito indicatore di variabile ($, @ o%), come $ _ (spiegato di seguito).

La maggior parte delle variabili speciali ha un nome lungo come l'inglese, ad esempio, variabile di errore del sistema operativo $! può essere scritto come $ OS_ERROR. Ma se hai intenzione di usare nomi simili all'inglese, dovresti inserire una rigause English;all'inizio del file di programma. Questo guida l'interprete a cogliere il significato esatto della variabile.

La variabile speciale più comunemente usata è $ _, che contiene l'input predefinito e la stringa di ricerca del modello. Ad esempio, nelle righe seguenti:

#!/usr/bin/perl

foreach ('hickory','dickory','doc') {
   print $_;
   print "\n";
}

Quando viene eseguito, questo produrrà il seguente risultato:

hickory
dickory
doc

Di nuovo, controlliamo lo stesso esempio senza usare esplicitamente la variabile $ _ -

#!/usr/bin/perl

foreach ('hickory','dickory','doc') {
   print;
   print "\n";
}

Quando viene eseguito, questo produrrà anche il seguente risultato:

hickory
dickory
doc

La prima volta che il ciclo viene eseguito, viene stampato "hickory". La seconda volta viene stampato "dickory" e la terza volta "doc". Questo perché in ogni iterazione del ciclo, viene inserita la stringa corrente$_, and is used by default by print. Here are the places where Perl will assume $_ anche se non lo specifichi -

Varie funzioni unarie, incluse funzioni come ord e int, nonché tutti i test di file (-f, -d) eccetto -t, che per impostazione predefinita è STDIN.
Varie funzioni di elenco come stampa e scollega.
Le operazioni di corrispondenza dei modelli m //, s /// e tr /// se usate senza un operatore = ~.
La variabile iteratore predefinita in un ciclo foreach se non viene fornita alcuna altra variabile.
La variabile iteratore implicita nelle funzioni grep e map.
La posizione predefinita in cui inserire un record di input quando il risultato di un'operazione di input di riga viene testato da solo come unico criterio di un test while (cioè). Si noti che al di fuori di un breve test, ciò non accadrà.

Tipi di variabili speciali

In base all'uso e alla natura delle variabili speciali, possiamo classificarle nelle seguenti categorie:

Variabili speciali scalari globali.
Variabili speciali dell'array globale.
Variabili speciali hash globali.
Filehandle speciali globali.
Costanti speciali globali.
Variabili speciali delle espressioni regolari.
Variabili speciali Filehandle.

Variabili speciali scalari globali

Ecco l'elenco di tutte le variabili speciali scalari. Abbiamo elencato i nomi simili in inglese insieme ai nomi simbolici.

$ _	Lo spazio di input e di ricerca pattern predefinito.
$ ARG	Lo spazio di input e di ricerca pattern predefinito.
$.	Il numero di riga di input corrente dell'ultimo filehandle letto. Una chiusura esplicita sul filehandle ripristina il numero di riga.
$ NR
$ /	Il separatore di record di input; nuova riga per impostazione predefinita. Se impostato sulla stringa nulla, tratta le righe vuote come delimitatori.
$ RS
$,	Il separatore del campo di output per l'operatore di stampa.
$ OFS
$ \	Il separatore di record di output per l'operatore di stampa.
$ ORS
$ "	Come "$", tranne per il fatto che si applica ai valori di elenco interpolati in una stringa tra virgolette (o una stringa interpretata simile). L'impostazione predefinita è uno spazio.
$ LIST_SEPARATOR
$;	Il separatore di pedici per l'emulazione di array multidimensionali. L'impostazione predefinita è "\ 034".
$ SUBSCRIPT_SEPARATOR
$ ^ L	Che formato produce per eseguire un formfeed. L'impostazione predefinita è "\ f".
$ FORMAT_FORMFEED
$:	Il set corrente di caratteri dopo il quale una stringa può essere interrotta per riempire i campi di continuazione (che iniziano con ^) in un formato. L'impostazione predefinita è "\ n" ".
$ FORMAT_LINE_BREAK_CHARACTERS
$ ^ A	Il valore corrente dell'accumulatore di scrittura per le righe di formato.
$ ACCUMULATORE
$ #	Contiene il formato di output per i numeri stampati (deprecato).
$ OFMT
$?	Lo stato restituito dall'ultima chiusura pipe, comando backtick (``) o operatore di sistema.
$ CHILD_ERROR
$!	Se utilizzato in un contesto numerico, restituisce il valore corrente della variabile errno, identificando l'ultimo errore della chiamata di sistema. Se utilizzato in un contesto stringa, restituisce la stringa di errore di sistema corrispondente.
$OS_ERROR or $ERRNO
$ @	Il messaggio di errore di sintassi Perl dall'ultimo comando eval.
$ EVAL_ERROR
$$	Il pid del processo Perl che esegue questo script.
$ PROCESS_ID o $ PID	Il pid del processo Perl che esegue questo script.
$ <	L'ID utente reale (uid) di questo processo.
$REAL_USER_ID or $UID	L'ID utente reale (uid) di questo processo.
$>	L'ID utente effettivo di questo processo.
$ EFFECTIVE_USER_ID o $ EUID	L'ID utente effettivo di questo processo.
$ (	Il vero ID gruppo (gid) di questo processo.
$REAL_GROUP_ID or $GID	Il vero ID gruppo (gid) di questo processo.
$)	Il gid efficace di questo processo.
$ EFFECTIVE_GROUP_ID o $ EGID	Il gid efficace di questo processo.
$ 0	Contiene il nome del file contenente lo script Perl in esecuzione.
$ PROGRAM_NAME
$ [	L'indice del primo elemento in una matrice e del primo carattere in una sottostringa. L'impostazione predefinita è 0.
$]	Restituisce la versione più il livello di patch diviso per 1000.
$ PERL_VERSION
$ ^ D	Il valore corrente dei flag di debug.
$ DEBUGGING	Il valore corrente dei flag di debug.
$ ^ E	Messaggio di errore esteso su alcune piattaforme.
$ EXTENDED_OS_ERROR	Messaggio di errore esteso su alcune piattaforme.
$ ^ F	Il descrittore di file di sistema massimo, normalmente 2.
$ SYSTEM_FD_MAX	Il descrittore di file di sistema massimo, normalmente 2.
$ ^ H	Contiene suggerimenti interni per il compilatore abilitati da alcuni moduli pragmatici.
$ ^ I	Il valore corrente dell'estensione inplace-edit. Usa undef per disabilitare la modifica sul posto.
$ INPLACE_EDIT
$ ^ M	Il contenuto di $M can be used as an emergency memory pool in case Perl dies with an out-of-memory error. Use of $M richiede una compilazione speciale di Perl. Vedere il documento INSTALL per ulteriori informazioni.
$ ^ O	Contiene il nome del sistema operativo per cui è stato compilato il binario Perl corrente.
$ OSNAME
$ ^ P	Il flag interno che il debugger cancella in modo che non esegua il debug da solo.
$ PERLDB
$ ^ T	L'ora in cui lo script ha iniziato a essere eseguito, in secondi dall'epoca.
$ BASETIME
$ ^ W	Il valore corrente dell'interruttore di avviso, vero o falso.
$ ATTENZIONE
$ ^ X	Il nome con cui è stato eseguito il binario Perl stesso.
$ EXECUTABLE_NAME	Il nome con cui è stato eseguito il binario Perl stesso.
$ ARGV	Contiene il nome del file corrente durante la lettura da <ARGV>.

Variabili speciali dell'array globale

@ARGV	L'array contenente gli argomenti della riga di comando destinati allo script.
@INC	L'array contenente l'elenco delle posizioni in cui cercare gli script Perl che devono essere valutati dai costrutti do, require o use.
@F	L'array in cui vengono suddivise le righe di input quando viene fornita l'opzione -a della riga di comando.

Variabili speciali hash globali

% INC	L'hash contenente le voci per il nome del file di ogni file che è stato incluso tramite do o require.
% ENV	L'hash contenente l'ambiente corrente.
% SIG	L'hash utilizzato per impostare i gestori di segnali per vari segnali.

Filehandle speciali globali

ARGV	Il filehandle speciale che itera sui nomi dei file della riga di comando in @ARGV. Di solito scritto come filehandle nullo in <>.
STDERR	Il filehandle speciale per l'errore standard in qualsiasi pacchetto.
STDIN	Lo speciale filehandle per lo standard input in qualsiasi pacchetto.
STDOUT	Lo speciale filehandle per lo standard output in qualsiasi pacchetto.
DATI	Lo speciale filehandle che fa riferimento a tutto ciò che segue il token __END__ nel file contenente lo script. Oppure, il filehandle speciale per qualsiasi cosa che segue il token __DATA__ in un file richiesto, purché tu stia leggendo i dati nello stesso pacchetto in cui è stato trovato __DATA__.
_ (trattino basso)	Lo speciale filehandle utilizzato per memorizzare nella cache le informazioni dall'ultimo operatore di test stat, lstat o file.

Costanti speciali globali

__FINE__	Indica la fine logica del programma. Qualsiasi testo seguente viene ignorato, ma può essere letto tramite il filehandle DATA.
__FILE__	Rappresenta il nome del file nel punto del programma in cui viene utilizzato. Non interpolato in stringhe.
__LINEA__	Rappresenta il numero di riga corrente. Non interpolato in stringhe.
__PACCHETTO__	Rappresenta il nome del pacchetto corrente in fase di compilazione o non definito se non è presente alcun pacchetto corrente. Non interpolato in stringhe.

Variabili speciali delle espressioni regolari

$ cifra	Contiene il testo abbinato dal set di parentesi corrispondente nell'ultimo modello trovato. Ad esempio, $ 1 corrisponde a tutto ciò che era contenuto nella prima serie di parentesi nell'espressione regolare precedente.
$ &	La stringa corrispondente all'ultima corrispondenza di pattern riuscita.
$ MATCH
$ `	La stringa che precede ciò che è stato trovato per l'ultima corrispondenza di pattern riuscita.
$ PREMATCH
$ '	La stringa che segue ciò che è stato trovato nell'ultima corrispondenza di pattern riuscita.
$ POSTMATCH
$ +	L'ultima parentesi corrispondente all'ultimo pattern di ricerca. Questo è utile se non sai quale di un insieme di modelli alternativi è stato abbinato. Ad esempio: / Version: (. ) \| Revision: (. ) / && ($rev = $+);
$ LAST_PAREN_MATCH

Variabili speciali Filehandle

$ \|	Se impostato su diverso da zero, forza un fflush (3) dopo ogni scrittura o stampa sul canale di output attualmente selezionato.
$ OUTPUT_AUTOFLUSH
$%	Il numero di pagina corrente del canale di uscita attualmente selezionato.
$ FORMAT_PAGE_NUMBER
$ =	La lunghezza della pagina corrente (righe stampabili) del canale di output attualmente selezionato. L'impostazione predefinita è 60.
$ FORMAT_LINES_PER_PAGE
$ -	Il numero di righe rimaste nella pagina del canale di uscita attualmente selezionato.
$ FORMAT_LINES_LEFT
$ ~	Il nome del formato di report corrente per il canale di output attualmente selezionato. Il valore predefinito è il nome del filehandle.
$ FORMAT_NAME
$ ^	Il nome del formato di inizio pagina corrente per il canale di output attualmente selezionato. Il valore predefinito è il nome del filehandle con _TOP aggiunto.
$ FORMAT_TOP_NAME

Ogni programmatore, ovviamente, avrà le sue preferenze riguardo alla formattazione, ma ci sono alcune linee guida generali che renderanno i tuoi programmi più facili da leggere, capire e mantenere.

La cosa più importante è eseguire i programmi sempre sotto il flag -w. Puoi disattivarlo esplicitamente per particolari parti di codice tramite il pragma no warnings o la variabile $ ^ W se necessario. Dovresti anche eseguire sempre in use strict o conoscere il motivo per cui no. Anche l'uso di sigtrap e persino l'uso di pragmi diagnostici possono rivelarsi utili.

Per quanto riguarda l'estetica del layout del codice, l'unica cosa a cui Larry tiene fortemente è che la parentesi graffa di chiusura di un BLOCCO multilinea deve allinearsi con la parola chiave che ha iniziato il costrutto. Oltre a ciò, ha altre preferenze che non sono così forti -

Rientro a 4 colonne.
Se possibile, aprire ricci sulla stessa riga della parola chiave, altrimenti allineare.
Spazio prima del ricciolo di apertura di un BLOCCO multilinea.
BLOCCO di una riga può essere messo su una riga, compresi i ricci.
Nessuno spazio prima del punto e virgola.
Punto e virgola omesso in BLOCCO "breve" di una riga.
Spazio intorno alla maggior parte degli operatori.
Spazio attorno a un pedice "complesso" (tra parentesi).
Linee vuote tra blocchi che fanno cose diverse.
Altri non coccolati.
Nessuno spazio tra il nome della funzione e la sua parentesi di apertura.
Spazio dopo ogni virgola.
Linee lunghe interrotte dopo un operatore (tranne e e o).
Spazio dopo l'ultima parentesi corrispondente sulla riga corrente.
Allinea verticalmente gli elementi corrispondenti.
Ometti punteggiatura ridondante finché la chiarezza non ne risente.

Ecco alcune altre questioni di stile più sostanziali su cui riflettere: solo perché PUOI fare qualcosa in un modo particolare non significa che DOVRESTI farlo in quel modo. Perl è progettato per darti diversi modi per fare qualsiasi cosa, quindi considera di scegliere quello più leggibile. Ad esempio:

open(FOO,$foo) || die "Can't open $foo: $!";

È meglio di -

die "Can't open $foo: $!" unless open(FOO,$foo);

Perché il secondo modo nasconde il punto principale dell'istruzione in un modificatore. D'altra parte,

print "Starting analysis\n" if $verbose;

È meglio di -

$verbose && print "Starting analysis\n";

Perché il punto principale non è se l'utente ha digitato -v o meno.

Non passare attraverso stupide contorsioni per uscire da un ciclo in alto o in basso, quando Perl fornisce l'ultimo operatore in modo da poter uscire nel mezzo. Basta "rimpicciolirlo" un po 'per renderlo più visibile -

LINE:
for (;;) {
   statements;
   last LINE if $foo;
   next LINE if /^#/;
   statements;
}

Vediamo alcuni punti più importanti:

Non aver paura di usare le etichette di loop: sono lì per migliorare la leggibilità e per consentire interruzioni di loop multilivello. Vedi l'esempio precedente.
Evita di usare grep () (o map ()) o `backtick` in un contesto void, cioè quando butti via i loro valori di ritorno. Queste funzioni hanno tutte valori di ritorno, quindi usale. Altrimenti usa un ciclo foreach () o la funzione system ().
Per la portabilità, quando si utilizzano funzionalità che potrebbero non essere implementate su ogni macchina, testare il costrutto in una valutazione per vedere se fallisce. Se sai quale versione o livello di patch è stata implementata una particolare funzionalità, puoi testare $] ($ PERL_VERSION in inglese) per vedere se sarà presente. Il modulo Config vi permetterà anche di interrogare i valori determinati dal programma Configure al momento dell'installazione di Perl.
Scegli identificatori mnemonici. Se non ricordi cosa significa mnemonico, hai un problema.
Anche se gli identificatori brevi come $ gotit sono probabilmente ok, usa i trattini bassi per separare le parole in identificatori più lunghi. In genere è più facile da leggere$var_names_like_this than $VarNamesLikeThis, soprattutto per i non madrelingua inglese. È anche una semplice regola che funziona in modo coerente con VAR_NAMES_LIKE_THIS.
I nomi dei pacchetti a volte sono un'eccezione a questa regola. Perl informalmente riserva nomi di moduli in minuscolo per i moduli "pragma" come integer e strict. Altri moduli dovrebbero iniziare con una lettera maiuscola e utilizzare maiuscole e minuscole, ma probabilmente senza trattini bassi a causa delle limitazioni nelle rappresentazioni dei file system primitivi dei nomi dei moduli come file che devono rientrare in pochi byte sparsi.
Se hai un'espressione regolare davvero pelosa, usa il modificatore / x e inserisci degli spazi bianchi per far sembrare un po 'meno rumore di linea. Non utilizzare la barra come delimitatore quando la tua espressione regolare ha barre o barre rovesciate.
Controlla sempre i codici di ritorno delle chiamate di sistema. I buoni messaggi di errore dovrebbero andare a STDERR, includere il programma che ha causato il problema, quali erano la chiamata di sistema fallita e gli argomenti e (MOLTO IMPORTANTE) dovrebbe contenere il messaggio di errore di sistema standard per ciò che è andato storto. Ecco un esempio semplice ma sufficiente:

opendir(D, $dir) or die "can't opendir $dir: $!";

Pensa alla riutilizzabilità. Perché sprecare le capacità intellettuali in un colpo solo quando potresti voler fare di nuovo qualcosa del genere? Considera l'idea di generalizzare il tuo codice. Considera l'idea di scrivere un modulo o una classe di oggetti. Considera la possibilità di eseguire il codice in modo pulito con use strict e use warnings (o -w) in vigore. Considera l'idea di regalare il tuo codice. Considera l'idea di cambiare tutta la tua visione del mondo. Considera ... oh, non importa.
Sii coerente.
Sii gentile.

Un'espressione regolare è una stringa di caratteri che definisce il modello o i modelli visualizzati. La sintassi delle espressioni regolari in Perl è molto simile a quella che troverai in altri programmi di supporto di espressioni regolari, comesed, grep, e awk.

Il metodo di base per applicare un'espressione regolare consiste nell'usare gli operatori di associazione del modello = ~ e !~. Il primo operatore è un operatore di test e assegnazione.

Ci sono tre operatori di espressioni regolari in Perl.

Match Regular Expression - m //
Espressione regolare sostitutiva - s ///
Espressione regolare traslitterata - tr ///

Le barre in avanti in ogni caso fungono da delimitatori per l'espressione regolare (regex) che stai specificando. Se ti senti a tuo agio con qualsiasi altro delimitatore, puoi usarlo al posto della barra in avanti.

L'operatore di corrispondenza

L'operatore di corrispondenza, m //, viene utilizzato per abbinare una stringa o un'istruzione a un'espressione regolare. Ad esempio, per abbinare la sequenza di caratteri "pippo" alla barra $ scalare, potresti usare un'istruzione come questa:

#!/usr/bin/perl

$bar = "This is foo and again foo"; if ($bar =~ /foo/) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo"; if ($bar =~ /foo/) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Quando viene eseguito il programma sopra, produce il seguente risultato:

First time is matching
Second time is matching

In realtà, m // funziona allo stesso modo della serie di operatori q //. Puoi utilizzare qualsiasi combinazione di caratteri che corrispondono naturalmente per agire come delimitatori per l'espressione. Ad esempio, m {}, m () e m> <sono tutti validi. Quindi l'esempio sopra può essere riscritto come segue:

#!/usr/bin/perl

$bar = "This is foo and again foo"; if ($bar =~ m[foo]) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo"; if ($bar =~ m{foo}) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Puoi omettere m da m // se i delimitatori sono barre, ma per tutti gli altri delimitatori devi usare il prefisso m.

Si noti che l'intera espressione di corrispondenza, ovvero l'espressione a sinistra di = ~ o! ~ E l'operatore di corrispondenza, restituisce true (in un contesto scalare) se l'espressione corrisponde. Pertanto la dichiarazione -

$true = ($foo =~ m/foo/);

sarà impostato $true to 1 if $foo corrisponde alla regex o 0 se la corrispondenza fallisce. In un contesto di elenco, la corrispondenza restituisce il contenuto di qualsiasi espressione raggruppata. Ad esempio, quando si estraggono ore, minuti e secondi da una stringa temporale, è possibile utilizzare:

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Modificatori dell'operatore di corrispondenza

L'operatore di corrispondenza supporta il proprio set di modificatori. Il modificatore / g consente la corrispondenza globale. Il modificatore / i renderà la corrispondenza senza distinzione tra maiuscole e minuscole. Ecco l'elenco completo dei modificatori

Sr.No.	Modificatore e descrizione
1	i Rende la corrispondenza senza distinzione tra maiuscole e minuscole.
2	m Specifica che se la stringa ha caratteri di ritorno a capo o di ritorno a capo, gli operatori ^ e $ ora corrisponderanno a un limite di nuova riga, anziché a un limite di stringa.
3	o Valuta l'espressione solo una volta.
4	s Consente l'uso di. per abbinare un carattere di nuova riga.
5	x Consente di utilizzare lo spazio bianco nell'espressione per maggiore chiarezza.
6	g Globalmente trova tutte le corrispondenze.
7	cg Consente la ricerca di continuare anche dopo che una corrispondenza globale fallisce.

Corrispondenza solo una volta

Esiste anche una versione più semplice dell'operatore di corrispondenza: il? PATTERN? operatore. Questo è fondamentalmente identico all'operatore m // tranne per il fatto che corrisponde solo una volta all'interno della stringa che stai cercando tra ogni chiamata da reimpostare.

Ad esempio, puoi usarlo per ottenere il primo e l'ultimo elemento all'interno di un elenco -

#!/usr/bin/perl

@list = qw/food foosball subeo footnote terfoot canic footbrdige/;

foreach (@list) {
   $first = $1 if /(foo.*?)/; $last = $1 if /(foo.*)/; } print "First: $first, Last: $last\n";

Quando viene eseguito il programma sopra, produce il seguente risultato:

First: foo, Last: footbrdige

Variabili delle espressioni regolari

Le variabili delle espressioni regolari includono $, che contiene qualunque sia l'ultima corrispondenza di raggruppamento abbinata; $&, che contiene l'intera stringa corrispondente; $`, che contiene tutto prima della stringa corrispondente; e$', che contiene tutto ciò che segue la stringa corrispondente. Il codice seguente mostra il risultato:

#!/usr/bin/perl

$string = "The food is in the salad bar";
$string =~ m/foo/; print "Before: $`\n";
print "Matched: $&\n"; print "After: $'\n";

Quando viene eseguito il programma sopra, produce il seguente risultato:

Before: The
Matched: foo
After: d is in the salad bar

L'operatore di sostituzione

L'operatore di sostituzione, s ///, è in realtà solo un'estensione dell'operatore di corrispondenza che consente di sostituire il testo abbinato con del nuovo testo. La forma base dell'operatore è:

s/PATTERN/REPLACEMENT/;

Il PATTERN è l'espressione regolare per il testo che stiamo cercando. REPLACEMENT è una specifica per il testo o l'espressione regolare che vogliamo utilizzare per sostituire il testo trovato. Ad esempio, possiamo sostituire tutte le occorrenze didog con cat utilizzando la seguente espressione regolare:

#/user/bin/perl

$string = "The cat sat on the mat"; $string =~ s/cat/dog/;

print "$string\n";

Quando viene eseguito il programma sopra, produce il seguente risultato:

The dog sat on the mat

Modificatori dell'operatore di sostituzione

Ecco l'elenco di tutti i modificatori usati con l'operatore di sostituzione.

Sr.No.	Modificatore e descrizione
1	i Rende la corrispondenza senza distinzione tra maiuscole e minuscole.
2	m Specifica che se la stringa ha caratteri di ritorno a capo o di ritorno a capo, gli operatori ^ e $ ora corrisponderanno a un limite di nuova riga, anziché a un limite di stringa.
3	o Valuta l'espressione solo una volta.
4	s Consente l'uso di. per abbinare un carattere di nuova riga.
5	x Consente di utilizzare lo spazio bianco nell'espressione per maggiore chiarezza.
6	g Sostituisce tutte le occorrenze dell'espressione trovata con il testo sostitutivo.
7	e Valuta la sostituzione come se fosse un'istruzione Perl e utilizza il valore restituito come testo di sostituzione.

L'operatore di traduzione

La traduzione è simile, ma non identica, ai principi di sostituzione, ma a differenza della sostituzione, la traduzione (o traslitterazione) non utilizza espressioni regolari per la ricerca sui valori di sostituzione. Gli operatori di traduzione sono:

tr/SEARCHLIST/REPLACEMENTLIST/cds
y/SEARCHLIST/REPLACEMENTLIST/cds

La traduzione sostituisce tutte le occorrenze dei caratteri in SEARCHLIST con i caratteri corrispondenti in REPLACEMENTLIST. Ad esempio, utilizzando "Il gatto seduto sul tappeto". stringa che abbiamo usato in questo capitolo -

#/user/bin/perl

$string = 'The cat sat on the mat'; $string =~ tr/a/o/;

print "$string\n";

Quando viene eseguito il programma sopra, produce il seguente risultato:

The cot sot on the mot.

È possibile utilizzare anche intervalli Perl standard, che consentono di specificare intervalli di caratteri tramite lettera o valore numerico. Per modificare il caso della stringa, potresti utilizzare la seguente sintassi al posto diuc funzione.

$string =~ tr/a-z/A-Z/;

Modificatori dell'operatore di traduzione

Di seguito è riportato l'elenco degli operatori relativi alla traduzione.

Sr.No.	Modificatore e descrizione
1	c Complementi SEARCHLIST.
2	d Elimina i caratteri trovati ma non sostituiti.
3	s Le zucche duplicano i caratteri sostituiti.

Il modificatore / d elimina i caratteri che corrispondono a SEARCHLIST che non hanno una voce corrispondente in REPLACEMENTLIST. Ad esempio:

#!/usr/bin/perl 

$string = 'the cat sat on the mat.'; $string =~ tr/a-z/b/d;

print "$string\n";

Quando viene eseguito il programma sopra, produce il seguente risultato:

b b   b.

L'ultimo modificatore, / s, rimuove le sequenze duplicate di caratteri che sono stati sostituiti, quindi -

#!/usr/bin/perl

$string = 'food';
$string = 'food'; $string =~ tr/a-z/a-z/s;

print "$string\n";

Quando viene eseguito il programma sopra, produce il seguente risultato:

fod

Espressioni regolari più complesse

Non devi solo abbinare stringhe fisse. In effetti, puoi abbinare praticamente qualsiasi cosa tu possa sognare usando espressioni regolari più complesse. Ecco un breve cheat sheet:

La tabella seguente elenca la sintassi delle espressioni regolari disponibile in Python.

Sr.No.	Modello e descrizione
1	^ Corrisponde all'inizio della riga.
2	$ Corrisponde alla fine della riga.
3	. Corrisponde a qualsiasi carattere singolo tranne la nuova riga. L'uso dell'opzione m consente anche di abbinare la nuova riga.
4	[...] Corrisponde a qualsiasi singolo carattere tra parentesi.
5	[^...] Corrisponde a qualsiasi carattere singolo non tra parentesi.
6	* Corrisponde a 0 o più occorrenze dell'espressione precedente.
7	+ Corrisponde a 1 o più occorrenze dell'espressione precedente.
8	? Corrisponde a 0 o 1 occorrenza dell'espressione precedente.
9	{ n} Corrisponde esattamente al numero n di occorrenze dell'espressione precedente.
10	{ n,} Corrisponde a n o più occorrenze dell'espressione precedente.
11	{ n, m} Corrisponde ad almeno n e al massimo m occorrenze dell'espressione precedente.
12	a\| b Corrisponde a a o b.
13	\w Corrisponde ai caratteri delle parole.
14	\W Corrisponde a caratteri non di parole.
15	\s Corrisponde allo spazio bianco. Equivalente a [\ t \ n \ r \ f].
16	\S Corrisponde a spazi non bianchi.
17	\d Corrisponde alle cifre. Equivalente a [0-9].
18	\D Corrisponde a non cifre.
19	\A Corrisponde all'inizio della stringa.
20	\Z Corrisponde alla fine della stringa. Se esiste una nuova riga, corrisponde appena prima della nuova riga.
21	\z Corrisponde alla fine della stringa.
22	\G Punto delle partite in cui è finita l'ultima partita.
23	\b Corrisponde ai confini delle parole quando sono al di fuori delle parentesi. Corrisponde a backspace (0x08) quando è racchiuso tra parentesi.
24	\B Corrisponde ai confini non di parole.
25	\n, \t, etc. Trova nuove righe, ritorni a capo, tabulazioni, ecc.
26	\1...\9 Corrisponde all'ennesima sottoespressione raggruppata.
27	\10 Corrisponde all'ennesima sottoespressione raggruppata se corrisponde già. Altrimenti si riferisce alla rappresentazione ottale di un codice carattere.
28	[aeiou] Corrisponde a un singolo carattere nel set specificato
29	[^aeiou] Corrisponde a un singolo carattere al di fuori del set specificato

Il metacarattere ^ corrisponde all'inizio della stringa e il metasimbolo $ corrisponde alla fine della stringa. Ecco alcuni brevi esempi.

# nothing in the string (start and end are adjacent)
/^$/   

# a three digits, each followed by a whitespace
# character (eg "3 4 5 ")
/(\d\s) {3}/  

# matches a string in which every
# odd-numbered letter is a (eg "abacadaf")
/(a.)+/  

# string starts with one or more digits
/^\d+/

# string that ends with one or more digits
/\d+$/

Diamo un'occhiata a un altro esempio.

#!/usr/bin/perl

$string = "Cats go Catatonic\nWhen given Catnip";
($start) = ($string =~ /\A(.*?) /);
@lines = $string =~ /^(.*?) /gm; print "First word: $start\n","Line starts: @lines\n";

Quando viene eseguito il programma sopra, produce il seguente risultato:

First word: Cats
Line starts: Cats When

Confini corrispondenti

Il \bcorrisponde a qualsiasi confine di parola, come definito dalla differenza tra la classe \ w e la classe \ W. Poiché \ w include i caratteri per una parola e \ W il contrario, questo normalmente significa la fine di una parola. Il\Bl'asserzione corrisponde a qualsiasi posizione che non sia un confine di parola. Ad esempio:

/\bcat\b/ # Matches 'the cat sat' but not 'cat on the mat'
/\Bcat\B/ # Matches 'verification' but not 'the cat on the mat'
/\bcat\B/ # Matches 'catatonic' but not 'polecat'
/\Bcat\b/ # Matches 'polecat' but not 'catatonic'

Selezione di alternative

Il | carattere è proprio come lo standard o l'OR bit per bit all'interno di Perl. Specifica corrispondenze alternative all'interno di un'espressione regolare o di un gruppo. Ad esempio, per abbinare "gatto" o "cane" in un'espressione, potresti usare questo:

if ($string =~ /cat|dog/)

È possibile raggruppare insieme singoli elementi di un'espressione per supportare corrispondenze complesse. La ricerca dei nomi di due persone potrebbe essere ottenuta con due test separati, come questo:

if (($string =~ /Martin Brown/) ||  ($string =~ /Sharon Brown/)) This could be written as follows if ($string =~ /(Martin|Sharon) Brown/)

Corrispondenza di raggruppamento

Da un punto di vista delle espressioni regolari, non c'è differenza tra tranne, forse, che il primo è leggermente più chiaro.

$string =~ /(\S+)\s+(\S+)/; and $string =~ /\S+\s+\S+/;

Tuttavia, il vantaggio del raggruppamento è che ci consente di estrarre una sequenza da un'espressione regolare. I raggruppamenti vengono restituiti come un elenco nell'ordine in cui sono visualizzati nell'originale. Ad esempio, nel frammento seguente abbiamo estratto le ore, i minuti e i secondi da una stringa.

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Oltre a questo metodo diretto, i gruppi corrispondenti sono disponibili anche all'interno delle speciali variabili $ x, dove x è il numero del gruppo all'interno dell'espressione regolare. Potremmo quindi riscrivere l'esempio precedente come segue:

#!/usr/bin/perl

$time = "12:05:30";

$time =~ m/(\d+):(\d+):(\d+)/; my ($hours, $minutes, $seconds) = ($1, $2, $3); print "Hours : $hours, Minutes: $minutes, Second: $seconds\n";

Quando viene eseguito il programma sopra, produce il seguente risultato:

Hours : 12, Minutes: 05, Second: 30

Quando i gruppi vengono utilizzati nelle espressioni di sostituzione, la sintassi $ x può essere utilizzata nel testo di sostituzione. Quindi, potremmo riformattare una stringa di data usando questo -

#!/usr/bin/perl

$date = '03/26/1999';
$date =~ s#(\d+)/(\d+)/(\d+)#$3/$1/$2#;

print "$date\n";

Quando viene eseguito il programma sopra, produce il seguente risultato:

1999/03/26

L'asserzione \ G

L'asserzione \ G ti consente di continuare la ricerca dal punto in cui si è verificata l'ultima corrispondenza. Ad esempio, nel codice seguente, abbiamo usato \ G in modo da poter cercare nella posizione corretta e quindi estrarre alcune informazioni, senza dover creare una singola espressione regolare più complessa -

#!/usr/bin/perl

$string = "The time is: 12:31:02 on 4/12/00";

$string =~ /:\s+/g; ($time) = ($string =~ /\G(\d+:\d+:\d+)/); $string =~ /.+\s+/g;
($date) = ($string =~ m{\G(\d+/\d+/\d+)});

print "Time: $time, Date: $date\n";

Quando viene eseguito il programma sopra, produce il seguente risultato:

Time: 12:31:02, Date: 4/12/00

L'asserzione \ G è in realtà solo l'equivalente metasimbolo della funzione pos, quindi tra le chiamate di espressioni regolari puoi continuare a usare pos e persino modificare il valore di pos (e quindi \ G) usando pos come subroutine lvalue.

Esempi di espressioni regolari

Personaggi letterali

Sr.No.	Esempio e descrizione
1	Perl Trova "Perl".

Classi di caratteri

Sr.No.	Esempio e descrizione
1	[Pp]ython Corrisponde a "Python" o "python"
2	rub[ye] Corrisponde a "ruby" o "rube"
3	[aeiou] Corrisponde a una vocale qualsiasi minuscola
4	[0-9] Corrisponde a qualsiasi cifra; uguale a [0123456789]
5	[a-z] Corrisponde a qualsiasi lettera ASCII minuscola
6	[A-Z] Corrisponde a qualsiasi lettera ASCII maiuscola
7	[a-zA-Z0-9] Corrisponde a uno dei precedenti
8	[^aeiou] Corrisponde a qualsiasi cosa diversa da una vocale minuscola
9	[^0-9] Corrisponde a qualsiasi cosa diversa da una cifra

Classi di caratteri speciali

Sr.No.	Esempio e descrizione
1	. Corrisponde a qualsiasi carattere tranne la nuova riga
2	\d Corrisponde a una cifra: [0-9]
3	\D Corrisponde a una non cifra: [^ 0-9]
4	\s Corrisponde a uno spazio vuoto: [\ t \ r \ n \ f]
5	\S Corrisponde a spazi non bianchi: [^ \ t \ r \ n \ f]
6	\w Corrisponde a un carattere di una sola parola: [A-Za-z0-9_]
7	\W Corrisponde a un carattere diverso da una parola: [^ A-Za-z0-9_]

Casi di ripetizione

Sr.No.	Esempio e descrizione
1	ruby? Corrisponde a "rub" o "ruby": la y è facoltativa
2	ruby* Corrisponde a "strofinare" più 0 o più anni
3	ruby+ Corrisponde a "strofinare" più 1 o più anni
4	\d{3} Corrisponde esattamente a 3 cifre
5	\d{3,} Corrisponde a 3 o più cifre
6.	\d{3,5} Corrisponde a 3, 4 o 5 cifre

Ripetizione di Nongreedy

Corrisponde al minor numero di ripetizioni -

Sr.No.	Esempio e descrizione
1	*<.>** Ripetizione avida: corrisponde a "<python> perl>"
2	*<.?>** Nongreedy: trova "<python>" in "<python> perl>"

Raggruppamento con parentesi

Sr.No.	Esempio e descrizione
1	\D\d+ Nessun gruppo: + si ripete \ d
2	(\D\d)+ Raggruppato: + ripete la coppia \ D \ d
3	([Pp]ython(, )?)+ Trova "Python", "Python, python, python", ecc.

Backreferences

Questo corrisponde di nuovo a un gruppo precedentemente abbinato -

Sr.No.	Esempio e descrizione
1	([Pp])ython&\1ails Corrisponde a Python e Pails o Python e Pails
2	*(['"])[^\1]\1** Stringa tra virgolette singole o doppie. \ 1 corrisponde a qualsiasi corrispondenza del primo gruppo. \ 2 corrisponde a qualunque sia il 2 ° gruppo abbinato, ecc.

Alternative

Sr.No.	Esempio e descrizione
1	python\|perl Corrisponde a "python" o "perl"
2	rub(y\|le)) Corrisponde a "rubino" o "rublo"
3	Python(!+\|\?) "Python" seguito da uno o più! o uno?

Ancore

Questa necessità di specificare le posizioni delle partite.

Sr.No.	Esempio e descrizione
1	^Python Trova "Python" all'inizio di una stringa o di una riga interna
2	Python$ Trova "Python" alla fine di una stringa o di una riga
3	\APython Trova "Python" all'inizio di una stringa
4	Python\Z Trova "Python" alla fine di una stringa
5	\bPython\b Corrisponde a "Python" in corrispondenza del confine di una parola
6	\brub\B \ B è un confine non di parole: trova "rub" in "rube" e "ruby" ma non da solo
7	Python(?=!) Corrisponde a "Python", se seguito da un punto esclamativo
8	Python(?!!) Corrisponde a "Python", se non seguito da un punto esclamativo

Sintassi speciale con parentesi

Sr.No.	Esempio e descrizione
1	R(?#comment) Corrisponde a "R". Tutto il resto è un commento
2	R(?i)uby Non distingue tra maiuscole e minuscole durante la corrispondenza di "uby"
3	R(?i:uby) Come sopra
4	rub(?:y\|le)) Raggruppa solo senza creare \ 1 backreference

Utilizzo dell'utilità sendmail

Invio di un messaggio semplice

Se stai lavorando su una macchina Linux / Unix, puoi semplicemente usare sendmailutility all'interno del programma Perl per inviare e-mail. Di seguito è riportato uno script di esempio che può inviare un'e-mail a un determinato ID e-mail. Assicurati solo che il percorso specificato per l'utilità sendmail sia corretto. Questo potrebbe essere diverso per la tua macchina Linux / Unix.

#!/usr/bin/perl
 
$to = '[email protected]';
$from = '[email protected]'; $subject = 'Test Email';
$message = 'This is test email sent by Perl Script'; open(MAIL, "|/usr/sbin/sendmail -t"); # Email Header print MAIL "To: $to\n";
print MAIL "From: $from\n"; print MAIL "Subject: $subject\n\n";
# Email Body
print MAIL $message;

close(MAIL);
print "Email Sent Successfully\n";

In realtà, lo script sopra è uno script di posta elettronica client, che redigerà la posta elettronica e invierà al server in esecuzione localmente sulla tua macchina Linux / Unix. Questo script non sarà responsabile dell'invio di e-mail alla destinazione effettiva. Quindi devi assicurarti che il server di posta elettronica sia configurato correttamente e in esecuzione sulla tua macchina per inviare e-mail all'ID e-mail fornito.

Invio di un messaggio HTML

Se desideri inviare e-mail in formato HTML utilizzando sendmail, devi semplicemente aggiungere Content-type: text/html\n nella parte dell'intestazione dell'email come segue:

#!/usr/bin/perl
 
$to = '[email protected]';
$from = '[email protected]'; $subject = 'Test Email';
$message = '<h1>This is test email sent by Perl Script</h1>'; open(MAIL, "|/usr/sbin/sendmail -t"); # Email Header print MAIL "To: $to\n";
print MAIL "From: $from\n"; print MAIL "Subject: $subject\n\n";
print MAIL "Content-type: text/html\n";
# Email Body
print MAIL $message;

close(MAIL);
print "Email Sent Successfully\n";

Utilizzo del modulo MIME :: Lite

Se stai lavorando su una macchina Windows, non avrai accesso all'utilità sendmail. Ma hai un'alternativa per scrivere il tuo client di posta elettronica usando il modulo MIME: Lite perl. Puoi scaricare questo modulo da MIME-Lite-3.01.tar.gz e installarlo sulla tua macchina Windows o Linux / Unix. Per installarlo segui i semplici passaggi:

$tar xvfz MIME-Lite-3.01.tar.gz
$cd MIME-Lite-3.01 $perl Makefile.PL
$make $make install

Questo è tutto e avrai il modulo MIME :: Lite installato sulla tua macchina. Ora sei pronto per inviare la tua email con semplici script spiegati di seguito.

Invio di un messaggio semplice

Ora di seguito è riportato uno script che si occuperà di inviare e-mail all'ID e-mail fornito -

#!/usr/bin/perl
use MIME::Lite;
 
$to = '[email protected]'; $cc = '[email protected]';
$from = '[email protected]'; $subject = 'Test Email';
$message = 'This is test email sent by Perl Script'; $msg = MIME::Lite->new(
                 From     => $from, To => $to,
                 Cc       => $cc, Subject => $subject,
                 Data     => $message ); $msg->send;
print "Email Sent Successfully\n";

Invio di un messaggio HTML

Se desideri inviare e-mail in formato HTML utilizzando sendmail, devi semplicemente aggiungere Content-type: text/html\nnella parte di intestazione dell'email. Di seguito è riportato lo script, che si occuperà di inviare e-mail in formato HTML -

#!/usr/bin/perl
use MIME::Lite;
 
$to = '[email protected]'; $cc = '[email protected]';
$from = '[email protected]'; $subject = 'Test Email';
$message = '<h1>This is test email sent by Perl Script</h1>'; $msg = MIME::Lite->new(
                 From     => $from, To => $to,
                 Cc       => $cc, Subject => $subject,
                 Data     => $message ); $msg->attr("content-type" => "text/html");         
$msg->send;
print "Email Sent Successfully\n";

Invio di un allegato

Se desideri inviare un allegato, il seguente script serve allo scopo:

#!/usr/bin/perl
use MIME::Lite;
 
$to = '[email protected]';
$cc = '[email protected]'; $from = '[email protected]';
$subject = 'Test Email'; $message = 'This is test email sent by Perl Script';

$msg = MIME::Lite->new( From => $from,
                 To       => $to, Cc => $cc,
                 Subject  => $subject, Type => 'multipart/mixed' ); # Add your text message. $msg->attach(Type         => 'text',
             Data         => $message ); # Specify your file as attachement. $msg->attach(Type         => 'image/gif',
             Path         => '/tmp/logo.gif',
             Filename     => 'logo.gif',
             Disposition  => 'attachment'
            );       
$msg->send;
print "Email Sent Successfully\n";

Puoi allegare tutti i file che desideri nella tua e-mail utilizzando il metodo attach ().

Utilizzo del server SMTP

Se la tua macchina non esegue un server di posta elettronica, puoi utilizzare qualsiasi altro server di posta disponibile nella posizione remota. Ma per utilizzare qualsiasi altro server di posta elettronica è necessario disporre di un ID, la sua password, URL, ecc. Una volta che hai tutte le informazioni richieste, devi semplicemente fornire quelle informazioni insend() metodo come segue -

$msg->send('smtp', "smtp.myisp.net", AuthUser=>"id", AuthPass=>"password" );

Puoi contattare l'amministratore del tuo server di posta per avere le informazioni sopra utilizzate e se un ID utente e una password non sono già disponibili, il tuo amministratore può crearli in pochi minuti.

Cos'è un socket?

Socket è un meccanismo UNIX di Berkeley per creare una connessione duplex virtuale tra diversi processi. Questo è stato successivamente trasferito su tutti i sistemi operativi noti consentendo la comunicazione tra i sistemi in posizioni geografiche in esecuzione su diversi software del sistema operativo. Se non fosse stato per il socket, la maggior parte della comunicazione di rete tra i sistemi non sarebbe mai avvenuta.

Guardando più da vicino; un tipico sistema informatico su una rete riceve e invia le informazioni desiderate dalle varie applicazioni in esecuzione su di esso. Queste informazioni vengono instradate al sistema, poiché ad esso viene designato un indirizzo IP univoco. Sul sistema, queste informazioni vengono fornite alle applicazioni pertinenti, che ascoltano su porte diverse. Ad esempio, un browser Internet ascolta sulla porta 80 le informazioni ricevute dal server web. Inoltre possiamo scrivere le nostre applicazioni personalizzate che possono ascoltare e inviare / ricevere informazioni su un numero di porta specifico.

Per ora, riassumiamo che un socket è un indirizzo IP e una porta, che consente alla connessione di inviare e ricevere dati su una rete.

Per spiegare il concetto di socket sopra menzionato, prenderemo un esempio di Programmazione client - server utilizzando Perl. Per completare un'architettura client server dovremmo seguire i seguenti passaggi:

Per creare un server

Crea un socket usando socket chiamata.
Associare il socket a un indirizzo di porta utilizzando bind chiamata.
Ascolta il socket all'indirizzo della porta utilizzando listen chiamata.
Accetta le connessioni client utilizzando accept chiamata.

Per creare un cliente

Crea un socket con socket chiamata.
Connetti (il socket) al server usando connect chiamata.

Il diagramma seguente mostra la sequenza completa delle chiamate utilizzate da Client e Server per comunicare tra loro:

Server Side Socket Calls

The socket() call

The socket() call is the first call in establishing a network connection is creating a socket. This call has the following syntax −

socket( SOCKET, DOMAIN, TYPE, PROTOCOL );

The above call creates a SOCKET and other three arguments are integers which should have the following values for TCP/IP connections.

DOMAIN should be PF_INET. It's probable 2 on your computer.
TYPE should be SOCK_STREAM for TCP/IP connection.
PROTOCOL should be (getprotobyname('tcp'))[2]. It is the particular protocol such as TCP to be spoken over the socket.

So socket function call issued by the server will be something like this −

use Socket     # This defines PF_INET and SOCK_STREAM

socket(SOCKET,PF_INET,SOCK_STREAM,(getprotobyname('tcp'))[2]);

The bind() call

The sockets created by socket() call are useless until they are bound to a hostname and a port number. Server uses the following bind() function to specify the port at which they will be accepting connections from the clients.

bind( SOCKET, ADDRESS );

Here SOCKET is the descriptor returned by socket() call and ADDRESS is a socket address ( for TCP/IP ) containing three elements −

The address family (For TCP/IP, that's AF_INET, probably 2 on your system).
The port number (for example 21).
The internet address of the computer (for example 10.12.12.168).

As the bind() is used by a server, which does not need to know its own address so the argument list looks like this −

use Socket        # This defines PF_INET and SOCK_STREAM

$port = 12345; # The unique port used by the sever to listen requests $server_ip_address = "10.12.12.168";
bind( SOCKET, pack_sockaddr_in($port, inet_aton($server_ip_address)))
   or die "Can't bind to port $port! \n";

The or die clause is very important because if a server dies without outstanding connections, the port won't be immediately reusable unless you use the option SO_REUSEADDR using setsockopt() function. Here pack_sockaddr_in() function is being used to pack the Port and IP address into binary format.

The listen() call

If this is a server program, then it is required to issue a call to listen() on the specified port to listen, i.e., wait for the incoming requests. This call has the following syntax −

listen( SOCKET, QUEUESIZE );

The above call uses SOCKET descriptor returned by socket() call and QUEUESIZE is the maximum number of outstanding connection request allowed simultaneously.

The accept() call

If this is a server program then it is required to issue a call to the access() function to accept the incoming connections. This call has the following syntax −

accept( NEW_SOCKET, SOCKET );

The accept call receive SOCKET descriptor returned by socket() function and upon successful completion, a new socket descriptor NEW_SOCKET is returned for all future communication between the client and the server. If access() call fails, then it returns FLASE which is defined in Socket module which we have used initially.

Generally, accept() is used in an infinite loop. As soon as one connection arrives the server either creates a child process to deal with it or serves it himself and then goes back to listen for more connections.

while(1) {
   accept( NEW_SOCKET, SOCKT );
   .......
}

Now all the calls related to server are over and let us see a call which will be required by the client.

Client Side Socket Calls

The connect() call

If you are going to prepare client program, then first you will use socket() call to create a socket and then you would have to use connect() call to connect to the server. You already have seen socket() call syntax and it will remain similar to server socket() call, but here is the syntax for connect() call −

connect( SOCKET, ADDRESS );

Here SCOKET is the socket descriptor returned by socket() call issued by the client and ADDRESS is a socket address similar to bind call, except that it contains the IP address of the remote server.

$port = 21;    # For example, the ftp port
$server_ip_address = "10.12.12.168"; connect( SOCKET, pack_sockaddr_in($port, inet_aton($server_ip_address))) or die "Can't connect to port $port! \n";

If you connect to the server successfully, then you can start sending your commands to the server using SOCKET descriptor, otherwise your client will come out by giving an error message.

Client - Server Example

Following is a Perl code to implement a simple client-server program using Perl socket. Here server listens for incoming requests and once connection is established, it simply replies Smile from the server. The client reads that message and print on the screen. Let's see how it has been done, assuming we have our server and client on the same machine.

Script to Create a Server

#!/usr/bin/perl -w
# Filename : server.pl

use strict;
use Socket;

# use port 7890 as default
my $port = shift || 7890; my $proto = getprotobyname('tcp');
my $server = "localhost"; # Host IP running the server # create a socket, make it reusable socket(SOCKET, PF_INET, SOCK_STREAM, $proto)
   or die "Can't open socket $!\n"; setsockopt(SOCKET, SOL_SOCKET, SO_REUSEADDR, 1) or die "Can't set socket option to SO_REUSEADDR $!\n";

# bind to a port, then listen
bind( SOCKET, pack_sockaddr_in($port, inet_aton($server)))
   or die "Can't bind to port $port! \n"; listen(SOCKET, 5) or die "listen: $!";
print "SERVER started on port $port\n"; # accepting a connection my $client_addr;
while ($client_addr = accept(NEW_SOCKET, SOCKET)) { # send them a message, close connection my $name = gethostbyaddr($client_addr, AF_INET ); print NEW_SOCKET "Smile from the server"; print "Connection recieved from $name\n";
   close NEW_SOCKET;
}

To run the server in background mode issue the following command on Unix prompt −

$perl sever.pl&

Script to Create a Client

!/usr/bin/perl -w
# Filename : client.pl

use strict;
use Socket;

# initialize host and port
my $host = shift || 'localhost';
my $port = shift || 7890; my $server = "localhost";  # Host IP running the server

# create the socket, connect to the port
socket(SOCKET,PF_INET,SOCK_STREAM,(getprotobyname('tcp'))[2])
   or die "Can't create a socket $!\n"; connect( SOCKET, pack_sockaddr_in($port, inet_aton($server))) or die "Can't connect to port $port! \n";

my $line; while ($line = <SOCKET>) {
   print "$line\n"; } close SOCKET or die "close: $!";

Now let's start our client at the command prompt, which will connect to the server and read message sent by the server and displays the same on the screen as follows −

$perl client.pl
Smile from the server

NOTE − If you are giving the actual IP address in dot notation, then it is recommended to provide IP address in the same format in both client as well as server to avoid any confusion.

We have already studied references in Perl and Perl anonymous arrays and hashes. Object Oriented concept in Perl is very much based on references and anonymous array and hashes. Let's start learning basic concepts of Object Oriented Perl.

Object Basics

There are three main terms, explained from the point of view of how Perl handles objects. The terms are object, class, and method.

An object within Perl is merely a reference to a data type that knows what class it belongs to. The object is stored as a reference in a scalar variable. Because a scalar only contains a reference to the object, the same scalar can hold different objects in different classes.
A class within Perl is a package that contains the corresponding methods required to create and manipulate objects.
A method within Perl is a subroutine, defined with the package. The first argument to the method is an object reference or a package name, depending on whether the method affects the current object or the class.

Perl provides a bless() function, which is used to return a reference which ultimately becomes an object.

Defining a Class

It is very simple to define a class in Perl. A class is corresponding to a Perl Package in its simplest form. To create a class in Perl, we first build a package.

A package is a self-contained unit of user-defined variables and subroutines, which can be re-used over and over again.

Perl Packages provide a separate namespace within a Perl program which keeps subroutines and variables independent from conflicting with those in other packages.

To declare a class named Person in Perl we do −

package Person;

The scope of the package definition extends to the end of the file, or until another package keyword is encountered.

Creating and Using Objects

To create an instance of a class (an object) we need an object constructor. This constructor is a method defined within the package. Most programmers choose to name this object constructor method new, but in Perl you can use any name.

You can use any kind of Perl variable as an object in Perl. Most Perl programmers choose either references to arrays or hashes.

Let's create our constructor for our Person class using a Perl hash reference. When creating an object, you need to supply a constructor, which is a subroutine within a package that returns an object reference. The object reference is created by blessing a reference to the package's class. For example −

package Person;
sub new {
   my $class = shift;
   my $self = { _firstName => shift, _lastName => shift, _ssn => shift, }; # Print all the values just for clarification. print "First Name is $self->{_firstName}\n";
   print "Last Name is $self->{_lastName}\n"; print "SSN is $self->{_ssn}\n";
   bless $self, $class;
   return $self;
}

Now Let us see how to create an Object.

$object = new Person( "Mohammad", "Saleem", 23234345);

You can use simple hash in your consturctor if you don't want to assign any value to any class variable. For example −

package Person;
sub new {
   my $class = shift; my $self = {};
   bless $self, $class;
   return $self;
}

Defining Methods

Other object-oriented languages have the concept of security of data to prevent a programmer from changing an object data directly and they provide accessor methods to modify object data. Perl does not have private variables but we can still use the concept of helper methods to manipulate object data.

Lets define a helper method to get person’s first name −

sub getFirstName {
   return $self->{_firstName};
}

Another helper function to set person’s first name −

sub setFirstName {
   my ( $self, $firstName ) = @_;
   $self->{_firstName} = $firstName if defined($firstName); return $self->{_firstName};
}

Now lets have a look into complete example: Keep Person package and helper functions into Person.pm file.

#!/usr/bin/perl 

package Person;

sub new {
   my $class = shift; my $self = {
      _firstName => shift,
      _lastName  => shift,
      _ssn       => shift,
   };
   # Print all the values just for clarification.
   print "First Name is $self->{_firstName}\n"; print "Last Name is $self->{_lastName}\n";
   print "SSN is $self->{_ssn}\n"; bless $self, $class; return $self;
}
sub setFirstName {
   my ( $self, $firstName ) = @_;
   $self->{_firstName} = $firstName if defined($firstName); return $self->{_firstName};
}

sub getFirstName {
   my( $self ) = @_; return $self->{_firstName};
}
1;

Now let's make use of Person object in employee.pl file as follows −

#!/usr/bin/perl

use Person;

$object = new Person( "Mohammad", "Saleem", 23234345); # Get first name which is set using constructor. $firstName = $object->getFirstName(); print "Before Setting First Name is : $firstName\n";

# Now Set first name using helper function.
$object->setFirstName( "Mohd." ); # Now get first name set by helper function. $firstName = $object->getFirstName(); print "Before Setting First Name is : $firstName\n";

When we execute above program, it produces the following result −

First Name is Mohammad
Last Name is Saleem
SSN is 23234345
Before Setting First Name is : Mohammad
Before Setting First Name is : Mohd.

Inheritance

Object-oriented programming has very good and useful concept called inheritance. Inheritance simply means that properties and methods of a parent class will be available to the child classes. So you don't have to write the same code again and again, you can just inherit a parent class.

For example, we can have a class Employee, which inherits from Person. This is referred to as an "isa" relationship because an employee is a person. Perl has a special variable, @ISA, to help with this. @ISA governs (method) inheritance.

Following are the important points to be considered while using inheritance −

Perl searches the class of the specified object for the given method or attribute, i.e., variable.
Perl searches the classes defined in the object class's @ISA array.
If no method is found in steps 1 or 2, then Perl uses an AUTOLOAD subroutine, if one is found in the @ISA tree.
If a matching method still cannot be found, then Perl searches for the method within the UNIVERSAL class (package) that comes as part of the standard Perl library.
If the method still has not found, then Perl gives up and raises a runtime exception.

So to create a new Employee class that will inherit methods and attributes from our Person class, we simply code as follows: Keep this code into Employee.pm.

#!/usr/bin/perl

package Employee;
use Person;
use strict;
our @ISA = qw(Person);    # inherits from Person

Now Employee Class has all the methods and attributes inherited from Person class and you can use them as follows: Use main.pl file to test it −

#!/usr/bin/perl

use Employee;

$object = new Employee( "Mohammad", "Saleem", 23234345); # Get first name which is set using constructor. $firstName = $object->getFirstName(); print "Before Setting First Name is : $firstName\n";

# Now Set first name using helper function.
$object->setFirstName( "Mohd." ); # Now get first name set by helper function. $firstName = $object->getFirstName(); print "After Setting First Name is : $firstName\n";

When we execute above program, it produces the following result −

First Name is Mohammad
Last Name is Saleem
SSN is 23234345
Before Setting First Name is : Mohammad
Before Setting First Name is : Mohd.

Method Overriding

The child class Employee inherits all the methods from the parent class Person. But if you would like to override those methods in your child class then you can do it by giving your own implementation. You can add your additional functions in child class or you can add or modify the functionality of an existing methods in its parent class. It can be done as follows: modify Employee.pm file.

#!/usr/bin/perl

package Employee;
use Person;
use strict;
our @ISA = qw(Person);    # inherits from Person

# Override constructor
sub new {
   my ($class) = @_; # Call the constructor of the parent class, Person. my $self = $class->SUPER::new( $_[1], $_[2], $_[3] );
   # Add few more attributes
   $self->{_id} = undef; $self->{_title} = undef;
   bless $self, $class;
   return $self; } # Override helper function sub getFirstName { my( $self ) = @_;
   # This is child class function.
   print "This is child class helper function\n";
   return $self->{_firstName}; } # Add more methods sub setLastName{ my ( $self, $lastName ) = @_; $self->{_lastName} = $lastName if defined($lastName);
   return $self->{_lastName}; } sub getLastName { my( $self ) = @_;
   return $self->{_lastName};
}

1;

Ora proviamo di nuovo a utilizzare l'oggetto Employee nel nostro file main.pl ed eseguiamolo.

#!/usr/bin/perl

use Employee;

$object = new Employee( "Mohammad", "Saleem", 23234345);
# Get first name which is set using constructor.
$firstName = $object->getFirstName();

print "Before Setting First Name is : $firstName\n"; # Now Set first name using helper function. $object->setFirstName( "Mohd." );

# Now get first name set by helper function.
$firstName = $object->getFirstName();
print "After Setting First Name is : $firstName\n";

Quando eseguiamo il programma sopra, produce il seguente risultato:

First Name is Mohammad
Last Name is Saleem
SSN is 23234345
This is child class helper function
Before Setting First Name is : Mohammad
This is child class helper function
After Setting First Name is : Mohd.

Caricamento automatico predefinito

Perl offre una funzionalità che non troveresti in nessun altro linguaggio di programmazione: una subroutine predefinita. Ciò significa che, se definisci una funzione chiamataAUTOLOAD(),quindi qualsiasi chiamata a subroutine non definite chiamerà automaticamente la funzione AUTOLOAD (). Il nome della subroutine mancante è accessibile all'interno di questa subroutine come $ AUTOLOAD.

La funzionalità di caricamento automatico predefinita è molto utile per la gestione degli errori. Ecco un esempio per implementare AUTOLOAD, puoi implementare questa funzione a modo tuo.

sub AUTOLOAD {
   my $self = shift; my $type = ref ($self) || croak "$self is not an object";
   my $field = $AUTOLOAD;
   $field =~ s/.*://; unless (exists $self->{$field}) { croak "$field does not exist in object/class $type"; } if (@_) { return $self->($name) = shift; } else { return $self->($name);
   }
}

Distruttori e Garbage Collection

Se in precedenza hai programmato utilizzando la programmazione orientata agli oggetti, sarai consapevole della necessità di creare un file destructorper liberare la memoria allocata all'oggetto al termine dell'utilizzo. Perl lo fa automaticamente non appena l'oggetto esce dall'ambito.

Nel caso in cui desideri implementare il tuo distruttore, che dovrebbe occuparsi di chiudere i file o eseguire un'elaborazione extra, devi definire un metodo speciale chiamato DESTROY. Questo metodo verrà chiamato sull'oggetto appena prima che Perl liberi la memoria assegnata all'oggetto. Sotto tutti gli altri aspetti, il metodo DESTROY è proprio come qualsiasi altro metodo e puoi implementare qualsiasi logica tu voglia all'interno di questo metodo.

Un metodo distruttore è semplicemente una funzione membro (subroutine) denominata DESTROY, che verrà chiamata automaticamente nei seguenti casi:

Quando la variabile del riferimento all'oggetto esce dall'ambito.
Quando la variabile del riferimento all'oggetto è indefinita.
Quando lo script termina
Quando termina l'interprete perl

Ad esempio, puoi semplicemente inserire il seguente metodo DESTROY nella tua classe:

package MyClass;
...
sub DESTROY {
   print "MyClass::DESTROY called\n";
}

Esempio di Perl orientato agli oggetti

Ecco un altro bell'esempio, che ti aiuterà a comprendere i concetti orientati agli oggetti di Perl. Metti questo codice sorgente in qualsiasi file perl ed eseguilo.

#!/usr/bin/perl

# Following is the implementation of simple Class.
package MyClass;

sub new {
   print "MyClass::new called\n";
   my $type = shift;            # The package/type name
   my $self = {}; # Reference to empty hash return bless $self, $type; } sub DESTROY { print "MyClass::DESTROY called\n"; } sub MyMethod { print "MyClass::MyMethod called!\n"; } # Following is the implemnetation of Inheritance. package MySubClass; @ISA = qw( MyClass ); sub new { print "MySubClass::new called\n"; my $type = shift;            # The package/type name
   my $self = MyClass->new; # Reference to empty hash return bless $self, $type; } sub DESTROY { print "MySubClass::DESTROY called\n"; } sub MyMethod { my $self = shift;
   $self->SUPER::MyMethod(); print " MySubClass::MyMethod called!\n"; } # Here is the main program using above classes. package main; print "Invoke MyClass method\n"; $myObject = MyClass->new();
$myObject->MyMethod(); print "Invoke MySubClass method\n"; $myObject2 = MySubClass->new();
$myObject2->MyMethod(); print "Create a scoped object\n"; { my $myObject2 = MyClass->new();
}
# Destructor is called automatically here

print "Create and undef an object\n";
$myObject3 = MyClass->new(); undef $myObject3;

print "Fall off the end of the script...\n";
# Remaining destructors are called automatically here

Quando eseguiamo il programma sopra, produce il seguente risultato:

Invoke MyClass method
MyClass::new called
MyClass::MyMethod called!
Invoke MySubClass method
MySubClass::new called
MyClass::new called
MyClass::MyMethod called!
MySubClass::MyMethod called!
Create a scoped object
MyClass::new called
MyClass::DESTROY called
Create and undef an object
MyClass::new called
MyClass::DESTROY called
Fall off the end of the script...
MyClass::DESTROY called
MySubClass::DESTROY called

Questo capitolo ti insegna come accedere a un database all'interno del tuo script Perl. A partire da Perl 5 è diventato molto facile scrivere applicazioni di database utilizzandoDBImodulo. DBI sta perDatabase Independent Interface per Perl, il che significa che DBI fornisce un livello di astrazione tra il codice Perl e il database sottostante, consentendo di cambiare le implementazioni del database molto facilmente.

Il DBI è un modulo di accesso al database per il linguaggio di programmazione Perl. Fornisce una serie di metodi, variabili e convenzioni che forniscono un'interfaccia di database coerente, indipendentemente dal database effettivamente utilizzato.

Architettura di un'applicazione DBI

DBI è indipendente da qualsiasi database disponibile nel backend. È possibile utilizzare DBI sia che si lavori con Oracle, MySQL o Informix, ecc. Questo è chiaro dal seguente diagramma dell'architettura.

Qui DBI è responsabile di prendere tutti i comandi SQL attraverso l'API, (cioè, Application Programming Interface) e di inviarli al driver appropriato per l'esecuzione effettiva. Infine, DBI è responsabile di prendere i risultati dal driver e restituirli allo scritp chiamante.

Notazione e convenzioni

In questo capitolo verranno utilizzate le seguenti notazioni e si raccomanda di seguire la stessa convenzione.

$dsn Database source name $dbh    Database handle object
$sth Statement handle object $h      Any of the handle types above ($dbh, $sth, or $drh) $rc     General Return Code  (boolean: true=ok, false=error)
$rv General Return Value (typically an integer) @ary List of values returned from the database. $rows   Number of rows processed (if available, else -1)
$fh     A filehandle
undef   NULL values are represented by undefined values in Perl
\%attr  Reference to a hash of attribute values passed to methods

Connessione al database

Supponendo che lavoreremo con il database MySQL. Prima di collegarti a un database, assicurati di quanto segue. Puoi prendere l'aiuto del nostro tutorial MySQL nel caso in cui non sei a conoscenza di come creare database e tabelle nel database MySQL.

Hai creato un database con un nome TESTDB.
Hai creato una tabella con un nome TEST_TABLE in TESTDB.
Questa tabella contiene i campi FIRST_NAME, LAST_NAME, AGE, SEX e INCOME.
L'ID utente "testuser" e la password "test123" sono impostati per accedere a TESTDB.
Perl Module DBI è installato correttamente sulla macchina.
Hai seguito il tutorial di MySQL per comprendere le basi di MySQL.

Di seguito è riportato l'esempio di connessione con il database MySQL "TESTDB" -

#!/usr/bin/perl

use DBI
use strict;

my $driver = "mysql"; 
my $database = "TESTDB"; my $dsn = "DBI:$driver:database=$database";
my $userid = "testuser"; my $password = "test123";

my $dbh = DBI->connect($dsn, $userid, $password ) or die $DBI::errstr;

Se viene stabilita una connessione con l'origine dati, viene restituito un handle di database e salvato in $ dbh per un ulteriore utilizzo, altrimenti $ dbh viene impostato sul valore undef e $ DBI :: errstr restituisce una stringa di errore.

Operazione INSERT

L'operazione INSERT è necessaria quando si desidera creare alcuni record in una tabella. Qui stiamo usando la tabella TEST_TABLE per creare i nostri record. Quindi, una volta stabilita la connessione al database, siamo pronti per creare record in TEST_TABLE. Di seguito è riportata la procedura per creare un singolo record in TEST_TABLE. Puoi creare tutti i record che desideri utilizzando lo stesso concetto.

La creazione di record richiede i seguenti passaggi:

Preparazione dell'istruzione SQL con l'istruzione INSERT. Questo sarà fatto usandoprepare() API.
Esecuzione di query SQL per selezionare tutti i risultati dal database. Questo sarà fatto usandoexecute() API.
Rilascio della maniglia di stato. Questo sarà fatto usandofinish() API.
Se tutto va bene allora commit questa operazione altrimenti puoi rollbacktransazione completa. Il commit e il rollback sono spiegati nelle sezioni successive.

my $sth = $dbh->prepare("INSERT INTO TEST_TABLE
                       (FIRST_NAME, LAST_NAME, SEX, AGE, INCOME )
                         values
                       ('john', 'poul', 'M', 30, 13000)");
$sth->execute() or die $DBI::errstr;
$sth->finish(); $dbh->commit or die $DBI::errstr;

Utilizzo dei valori di associazione

Potrebbe esserci un caso in cui i valori da inserire non vengono forniti in anticipo. Quindi puoi usare le variabili di bind che prenderanno i valori richiesti in fase di esecuzione. I moduli Perl DBI fanno uso di un punto interrogativo al posto del valore effettivo e quindi i valori effettivi vengono passati tramite l'API execute () in fase di esecuzione. Di seguito è riportato l'esempio:

my $first_name = "john";
my $last_name = "poul"; my $sex = "M";
my $income = 13000; my $age = 30;
my $sth = $dbh->prepare("INSERT INTO TEST_TABLE
                        (FIRST_NAME, LAST_NAME, SEX, AGE, INCOME )
                          values
                        (?,?,?,?)");
$sth->execute($first_name,$last_name,$sex, $age, $income) 
          or die $DBI::errstr; $sth->finish();
$dbh->commit or die $DBI::errstr;

Operazione READ

LETTURA Operare su una qualsiasi banca dati significa prelevare alcune informazioni utili dal database, ovvero uno o più record da una o più tabelle. Quindi, una volta stabilita la connessione al database, siamo pronti per eseguire una query in questo database. Di seguito è riportata la procedura per interrogare tutti i record con ETÀ maggiore di 20. Questo richiederà quattro passaggi:

Preparazione della query SQL SELECT in base alle condizioni richieste. Questo sarà fatto usandoprepare() API.
Esecuzione di query SQL per selezionare tutti i risultati dal database. Questo sarà fatto usandoexecute() API.
Recuperare tutti i risultati uno per uno e stamparli. Questo sarà fatto usando fetchrow_array() API.
Rilascio della maniglia di stato. Questo sarà fatto usandofinish() API.

my $sth = $dbh->prepare("SELECT FIRST_NAME, LAST_NAME
                        FROM TEST_TABLE 
                        WHERE AGE > 20");
$sth->execute() or die $DBI::errstr;
print "Number of rows found :" + $sth->rows; while (my @row = $sth->fetchrow_array()) {
   my ($first_name, $last_name ) = @row;
   print "First Name = $first_name, Last Name = $last_name\n";
}
$sth->finish();

Utilizzo dei valori di associazione

Potrebbe esserci un caso in cui la condizione non viene fornita in anticipo. Quindi puoi usare le variabili di bind, che assumeranno i valori richiesti in fase di esecuzione. I moduli Perl DBI utilizzano un punto interrogativo al posto del valore effettivo e quindi i valori effettivi vengono passati tramite l'API execute () in fase di esecuzione. Di seguito è riportato l'esempio:

$age = 20;
my $sth = $dbh->prepare("SELECT FIRST_NAME, LAST_NAME
                        FROM TEST_TABLE
                        WHERE AGE > ?");
$sth->execute( $age ) or die $DBI::errstr; print "Number of rows found :" + $sth->rows;
while (my @row = $sth->fetchrow_array()) { my ($first_name, $last_name ) = @row; print "First Name = $first_name, Last Name = $last_name\n"; } $sth->finish();

Operazione UPDATE

AGGIORNAMENTO Operare su qualsiasi database significa aggiornare uno o più record già disponibili nelle tabelle del database. Di seguito è riportata la procedura per aggiornare tutti i record che hanno SEX come "M". Qui aumenteremo l'ETÀ di tutti i maschi di un anno. Questo richiederà tre passaggi:

Preparazione di query SQL in base alle condizioni richieste. Questo sarà fatto usandoprepare() API.
Esecuzione di query SQL per selezionare tutti i risultati dal database. Questo sarà fatto usandoexecute() API.
Rilascio della maniglia di stato. Questo sarà fatto usandofinish() API.
Se tutto va bene allora commit questa operazione altrimenti puoi rollbacktransazione completa. Vedere la sezione successiva per le API di commit e rollback.

my $sth = $dbh->prepare("UPDATE TEST_TABLE
                        SET   AGE = AGE + 1 
                        WHERE SEX = 'M'");
$sth->execute() or die $DBI::errstr;
print "Number of rows updated :" + $sth->rows; $sth->finish();
$dbh->commit or die $DBI::errstr;

Utilizzo dei valori di associazione

Potrebbe esserci un caso in cui la condizione non viene fornita in anticipo. Quindi puoi usare le variabili di bind, che assumeranno i valori richiesti in fase di esecuzione. I moduli Perl DBI fanno uso di un punto interrogativo al posto del valore effettivo e quindi i valori effettivi vengono passati tramite l'API execute () in fase di esecuzione. Di seguito è riportato l'esempio:

$sex = 'M'; my $sth = $dbh->prepare("UPDATE TEST_TABLE SET AGE = AGE + 1 WHERE SEX = ?"); $sth->execute('$sex') or die $DBI::errstr;
print "Number of rows updated :" + $sth->rows; $sth->finish();
$dbh->commit or die $DBI::errstr;

In alcuni casi si desidera impostare un valore, che non viene fornito in anticipo, quindi è possibile utilizzare il valore di associazione come segue. In questo esempio il reddito di tutti i maschi sarà impostato a 10000.

$sex = 'M'; $income = 10000;
my $sth = $dbh->prepare("UPDATE TEST_TABLE
                        SET   INCOME = ?
                        WHERE SEX = ?");
$sth->execute( $income, '$sex') or die $DBI::errstr;
print "Number of rows updated :" + $sth->rows; $sth->finish();

Operazione DELETE

L'operazione DELETE è necessaria quando si desidera eliminare alcuni record dal database. Di seguito è riportata la procedura per eliminare tutti i record da TEST_TABLE dove AGE è uguale a 30. Questa operazione eseguirà i seguenti passaggi.

Preparazione di query SQL in base alle condizioni richieste. Questo sarà fatto usandoprepare() API.
Esecuzione di query SQL per eliminare i record richiesti dal database. Questo sarà fatto usandoexecute() API.
Rilascio della maniglia di stato. Questo sarà fatto usandofinish() API.
Se tutto va bene allora commit questa operazione altrimenti puoi rollback transazione completa.

$age = 30; my $sth = $dbh->prepare("DELETE FROM TEST_TABLE WHERE AGE = ?"); $sth->execute( $age ) or die $DBI::errstr;
print "Number of rows deleted :" + $sth->rows; $sth->finish();
$dbh->commit or die $DBI::errstr;

Utilizzando do Statement

Se stai eseguendo un UPDATE, INSERT o DELETE non ci sono dati che tornano dal database, quindi c'è una scorciatoia per eseguire questa operazione. Puoi usaredo istruzione per eseguire uno qualsiasi dei comandi come segue.

$dbh->do('DELETE FROM TEST_TABLE WHERE age =30');

dorestituisce un valore vero se è riuscito e un valore falso se non è riuscito. In realtà, se ha successo, restituisce il numero di righe interessate. Nell'esempio restituirà il numero di righe che sono state effettivamente eliminate.

Operazione COMMIT

Commit è l'operazione che dà un segnale verde al database per finalizzare le modifiche e dopo questa operazione nessuna modifica può essere riportata alla sua posizione originale.

Ecco un semplice esempio da chiamare commit API.

$dbh->commit or die $dbh->errstr;

Operazione ROLLBACK

Se non sei soddisfatto di tutte le modifiche o riscontri un errore tra un'operazione e l'altra, puoi ripristinare tali modifiche per l'uso rollback API.

Ecco un semplice esempio da chiamare rollback API.

$dbh->rollback or die $dbh->errstr;

Inizia transazione

Molti database supportano le transazioni. Ciò significa che puoi fare un sacco di query che modificherebbero i database, ma nessuna delle modifiche viene effettivamente apportata. Quindi, alla fine, emetti la query SQL specialeCOMMITe tutte le modifiche vengono apportate contemporaneamente. In alternativa, puoi emettere la query ROLLBACK, nel qual caso tutte le modifiche vengono eliminate e il database rimane invariato.

Modulo DBI Perl fornito begin_workAPI, che abilita le transazioni (disattivando AutoCommit) fino alla chiamata successiva per il commit o il rollback. Dopo il successivo commit o rollback, AutoCommit verrà riattivato automaticamente.

$rc  = $dbh->begin_work or die $dbh->errstr;

Opzione AutoCommit

Se le tue transazioni sono semplici, puoi risparmiarti la fatica di dover emettere molti commit. Quando si effettua la chiamata di connessione, è possibile specificare un fileAutoCommitopzione che eseguirà un'operazione di commit automatico dopo ogni query riuscita. Ecco come appare:

my $dbh = DBI->connect($dsn, $userid, $password,
              {AutoCommit => 1}) 
              or die $DBI::errstr;

Qui AutoCommit può assumere valore 1 o 0, dove 1 significa che AutoCommit è attivo e 0 significa che AutoCommit è disattivato.

Gestione automatica degli errori

Quando si effettua la chiamata di connessione, è possibile specificare un'opzione RaiseErrors che gestisce gli errori automaticamente. Quando si verifica un errore, DBI interromperà il programma invece di restituire un codice di errore. Se tutto ciò che vuoi è interrompere il programma in caso di errore, questo può essere conveniente. Ecco come appare:

my $dbh = DBI->connect($dsn, $userid, $password, {RaiseError => 1}) or die $DBI::errstr;

Qui RaiseError può assumere valore 1 o 0.

Disconnessione del database

Per disconnettere la connessione al database, utilizzare disconnect API come segue -

$rc = $dbh->disconnect  or warn $dbh->errstr;

Il comportamento della transazione del metodo di disconnessione è, purtroppo, indefinito. Alcuni sistemi di database (come Oracle e Ingres) eseguiranno automaticamente il commit delle modifiche in sospeso, ma altri (come Informix) annulleranno tutte le modifiche in sospeso. Le applicazioni che non utilizzano AutoCommit devono chiamare esplicitamente il commit o il rollback prima di chiamare la disconnessione.

Utilizzo di valori NULL

I valori non definiti o undef vengono utilizzati per indicare i valori NULL. È possibile inserire e aggiornare colonne con un valore NULL come si farebbe con un valore non NULL. Questi esempi inseriscono e aggiornano l'età della colonna con un valore NULL -

$sth = $dbh->prepare(qq { INSERT INTO TEST_TABLE (FIRST_NAME, AGE) VALUES (?, ?) }); $sth->execute("Joe", undef);

Qui qq{} viene utilizzato per restituire una stringa tra virgolette prepareAPI. Tuttavia, è necessario prestare attenzione quando si tenta di utilizzare valori NULL in una clausola WHERE. Considera -

SELECT FIRST_NAME FROM TEST_TABLE WHERE age = ?

Associare un undef (NULL) al segnaposto non selezionerà le righe, che hanno un'età NULL! Almeno per i motori di database conformi allo standard SQL. Fare riferimento al manuale SQL per il motore di database o qualsiasi libro SQL per le ragioni di ciò. Per selezionare esplicitamente NULL devi dire "WHERE age IS NULL".

Un problema comune è che un frammento di codice gestisca un valore che può essere definito o undef (non NULL o NULL) in fase di esecuzione. Una tecnica semplice consiste nel preparare l'istruzione appropriata in base alle esigenze e sostituire il segnaposto per i casi non NULL -

$sql_clause = defined $age? "age = ?" : "age IS NULL";
$sth = $dbh->prepare(qq {
         SELECT FIRST_NAME FROM TEST_TABLE WHERE $sql_clause }); $sth->execute(defined $age ? $age : ());

Alcune altre funzioni DBI

driver_disponibili

@ary = DBI->available_drivers;
@ary = DBI->available_drivers($quiet);

Restituisce un elenco di tutti i driver disponibili cercando i moduli DBD :: * attraverso le directory in @INC. Per impostazione predefinita, viene fornito un avviso se alcuni driver sono nascosti da altri con lo stesso nome nelle directory precedenti. Il passaggio di un valore vero per $ quiet inibirà l'avviso.

driver_installati

%drivers = DBI->installed_drivers();

Restituisce un elenco di nomi di driver e coppie di handle di driver per tutti i driver "installati" (caricati) nel processo corrente. Il nome del driver non include il prefisso "DBD ::".

Origine dei dati

@ary = DBI->data_sources($driver);

Restituisce un elenco di origini dati (database) disponibili tramite il driver denominato. Se $ driver è vuoto o undef, viene utilizzato il valore della variabile di ambiente DBI_DRIVER.

citazione

$sql = $dbh->quote($value); $sql = $dbh->quote($value, $data_type);

Indicare un valore letterale stringa da utilizzare come valore letterale in un'istruzione SQL, eseguendo l'escape di eventuali caratteri speciali (come le virgolette) contenuti nella stringa e aggiungendo il tipo richiesto di virgolette esterne.

$sql = sprintf "SELECT foo FROM bar WHERE baz = %s",
                $dbh->quote("Don't");

Per la maggior parte dei tipi di database, le virgolette restituiscono "Non" (comprese le virgolette esterne). È valido per il metodo quote () restituire un'espressione SQL che restituisce la stringa desiderata. Ad esempio:

$quoted = $dbh->quote("one\ntwo\0three")

may produce results which will be equivalent to

CONCAT('one', CHAR(12), 'two', CHAR(0), 'three')

Metodi comuni a tutte le maniglie

err

$rv = $h->err; or $rv = $DBI::err or $rv = $h->err

Restituisce il codice di errore del motore di database nativo dall'ultimo metodo del driver chiamato. Il codice è in genere un numero intero, ma non dovresti assumerlo. Ciò è equivalente a $ DBI :: err o $ h-> err.

errstr

$str = $h->errstr; or $str = $DBI::errstr or $str = $h->errstr

Restituisce il messaggio di errore del motore di database nativo dall'ultimo metodo DBI chiamato. Questo ha gli stessi problemi di durata del metodo "err" descritto sopra. Questo è equivalente a $ DBI :: errstr o $ h-> errstr.

righe

$rv = $h->rows; or $rv = $DBI::rows

Restituisce il numero di righe influenzate dalla precedente istruzione SQL ed è equivalente a $ DBI :: righe.

traccia

$h->trace($trace_settings);

DBI mette in mostra una capacità estremamente utile di generare informazioni di tracciamento del runtime di ciò che sta facendo, che può essere un enorme risparmio di tempo quando si cerca di rintracciare strani problemi nei programmi DBI. È possibile utilizzare valori diversi per impostare il livello di traccia. Questi valori variano da 0 a 4. Il valore 0 significa disabilitare la traccia e 4 significa generare la traccia completa.

Le dichiarazioni interpolate sono vietate

Si consiglia vivamente di non utilizzare istruzioni interpolate come segue:

while ($first_name = <>) { my $sth = $dbh->prepare("SELECT * FROM TEST_TABLE WHERE FIRST_NAME = '$first_name'");
   $sth->execute();
   # and so on ...
}

Quindi non usare l'istruzione interpolata invece usa bind value per preparare l'istruzione SQL dinamica.

Cos'è la CGI?

Una Common Gateway Interface, o CGI, è un insieme di standard che definisce il modo in cui le informazioni vengono scambiate tra il server Web e uno script personalizzato.
Le specifiche CGI sono attualmente mantenute dall'NCSA e NCSA definisce CGI come segue:
Common Gateway Interface, o CGI, è uno standard per i programmi gateway esterni per interfacciarsi con i server di informazioni come i server HTTP.
La versione corrente è CGI / 1.1 e CGI / 1.2 è in fase di elaborazione.

Navigare su Internet

Per comprendere il concetto di CGI, vediamo cosa succede quando facciamo clic su un collegamento ipertestuale disponibile su una pagina web per sfogliare una particolare pagina web o URL.

Il browser contatta il server Web utilizzando il protocollo HTTP e richiede l'URL, ovvero il nome del file della pagina Web.
Web Server controllerà l'URL e cercherà il nome del file richiesto. Se il server web trova quel file, invia il file al browser senza alcuna ulteriore esecuzione, altrimenti invia un messaggio di errore che indica che hai richiesto un file sbagliato.
Il browser Web riceve la risposta dal server Web e visualizza il contenuto del file ricevuto o un messaggio di errore nel caso in cui il file non venga trovato.

Tuttavia, è possibile impostare il server HTTP in modo tale che ogni volta che viene richiesto un file in una determinata directory, quel file non viene restituito; invece viene eseguito come un programma, e qualunque cosa quel programma emetta come risultato, viene rimandata indietro per la visualizzazione del browser. Questo può essere fatto utilizzando una funzionalità speciale disponibile nel server web e si chiamaCommon Gateway Interfaceo CGI e tali programmi che vengono eseguiti dal server per produrre il risultato finale, sono chiamati script CGI. Questi programmi CGI possono essere uno script PERL, uno script shell, un programma C o C ++, ecc.

Diagramma di architettura CGI

Supporto e configurazione del server Web

Prima di procedere con la programmazione CGI, assicurati che il tuo server web supporti la funzionalità CGI e che sia configurato per gestire i programmi CGI. Tutti i programmi CGI che devono essere eseguiti dal web server sono conservati in una directory preconfigurata. Questa directory è chiamata directory CGI e per convenzione è chiamata / cgi-bin. Per convenzione i file CGI Perl avranno l'estensione come.cgi.

Primo programma CGI

Ecco un semplice collegamento che è collegato a uno script CGI chiamato hello.cgi . Questo file è stato conservato/cgi-bin/directory e ha il seguente contenuto. Prima di eseguire il programma CGI, assicurati di aver cambiato la modalità di utilizzo del filechmod 755 hello.cgi Comando UNIX.

#!/usr/bin/perl

print "Content-type:text/html\r\n\r\n";
print '<html>';
print '<head>';
print '<title>Hello Word - First CGI Program</title>';
print '</head>';
print '<body>';
print '<h2>Hello Word! This is my first CGI program</h2>';
print '</body>';
print '</html>';

1;

Ora se fai clic su hello.cgi il collegamento quindi la richiesta va al server web che cerca hello.cgi nella directory / cgi-bin, lo esegue e qualunque sia il risultato generato, il server web invia quel risultato al browser web, che è il seguente:

Hello Word! This is my first CGI program

Questo script hello.cgi è un semplice script Perl che scrive il suo output su un file STDOUT, cioè screen. C'è una caratteristica importante ed extra disponibile che è la prima riga da stampareContent-type:text/html\r\n\r\n. Questa riga viene rinviata al browser e specifica il tipo di contenuto da visualizzare nella schermata del browser. Ora devi aver compreso il concetto di base di CGI e puoi scrivere molti programmi CGI complicati usando Perl. Questo script può interagire con qualsiasi altro sistema fisico anche per scambiare informazioni come database, servizi web o altre interfacce complesse.

Comprensione dell'intestazione HTTP

La prima riga Content-type:text/html\r\n\r\nè una parte dell'intestazione HTTP, che viene inviata al browser in modo che il browser possa comprendere il contenuto in arrivo dal lato server. Tutta l'intestazione HTTP avrà la seguente forma:

HTTP Field Name: Field Content

Ad esempio -

Content-type:text/html\r\n\r\n

Ci sono poche altre importanti intestazioni HTTP, che userete frequentemente nella vostra programmazione CGI.

Sr.No.	Intestazione e descrizione
1	Content-type: String Una stringa MIME che definisce il formato del contenuto restituito. L'esempio è Content-type: text / html
2	Expires: Date String La data in cui le informazioni diventano non valide. Questo dovrebbe essere utilizzato dal browser per decidere quando una pagina deve essere aggiornata. Una stringa di data valida deve essere nel formato 01 gen 1998 12:00:00 GMT.
3	Location: URL String L'URL che dovrebbe essere restituito al posto dell'URL richiesto. È possibile utilizzare questo file per reindirizzare una richiesta a qualsiasi altra posizione.
4	Last-modified: String La data dell'ultima modifica del file.
5	Content-length: String La lunghezza, in byte, dei dati restituiti. Il browser utilizza questo valore per segnalare il tempo di download stimato per un file.
6	Set-Cookie: String Imposta il cookie passato attraverso la stringa

Variabili d'ambiente CGI

Tutto il programma CGI avrà accesso alle seguenti variabili d'ambiente. Queste variabili giocano un ruolo importante durante la scrittura di qualsiasi programma CGI.

Sr.No.	Nomi e descrizione delle variabili
1	CONTENT_TYPE Il tipo di dati del contenuto. Utilizzato quando il client invia il contenuto allegato al server. Ad esempio caricamento di file, ecc.
2	CONTENT_LENGTH La lunghezza delle informazioni sulla query. È disponibile solo per le richieste POST
3	HTTP_COOKIE Restituisce i cookie impostati sotto forma di coppia chiave e valore.
4	HTTP_USER_AGENT Il campo dell'intestazione della richiesta dell'agente utente contiene informazioni sull'agente utente che ha originato la richiesta. Il suo nome del browser web.
5	PATH_INFO Il percorso per lo script CGI.
6	QUERY_STRING Le informazioni con codifica URL inviate con la richiesta del metodo GET.
7	REMOTE_ADDR L'indirizzo IP dell'host remoto che effettua la richiesta. Questo può essere utile per la registrazione o per scopi di autenticazione.
8	REMOTE_HOST Il nome completo dell'host che effettua la richiesta. Se queste informazioni non sono disponibili, è possibile utilizzare REMOTE_ADDR per ottenere l'indirizzo IR.
9	REQUEST_METHOD Il metodo utilizzato per effettuare la richiesta. I metodi più comuni sono GET e POST.
10	SCRIPT_FILENAME Il percorso completo dello script CGI.
11	SCRIPT_NAME Il nome dello script CGI.
12	SERVER_NAME Il nome host o l'indirizzo IP del server.
13	SERVER_SOFTWARE Il nome e la versione del software in esecuzione sul server.

Ecco un piccolo programma CGI per elencare tutte le variabili CGI supportate dal tuo server web. Fare clic su questo collegamento per visualizzare il risultato Ottieni ambiente

#!/usr/bin/perl

print "Content-type: text/html\n\n";
print "<font size=+1>Environment</font>\n";
foreach (sort keys %ENV) {
   print "<b>$_</b>: $ENV{$_}<br>\n";
}

1;

Sollevare una finestra di dialogo "Download file"?

A volte si desidera dare un'opzione in cui un utente farà clic su un collegamento e verrà visualizzata una finestra di dialogo "Download file" per l'utente invece di visualizzare il contenuto effettivo. Questo è molto semplice e verrà ottenuto tramite l'intestazione HTTP.

Questa intestazione HTTP sarà diversa dall'intestazione menzionata nella sezione precedente. Ad esempio, se vuoi creare un fileFileName file scaricabile da un determinato collegamento, la sua sintassi sarà la seguente:

#!/usr/bin/perl

# HTTP Header
print "Content-Type:application/octet-stream; name = \"FileName\"\r\n";
print "Content-Disposition: attachment; filename = \"FileName\"\r\n\n";

# Actual File Content will go hear.
open( FILE, "<FileName" );
while(read(FILE, $buffer, 100) ) { print("$buffer");
}

Metodi GET e POST

Devi esserti imbattuto in molte situazioni in cui hai bisogno di passare alcune informazioni dal tuo browser al server web e infine al tuo programma CGI che gestisce le tue richieste. Il più delle volte il browser utilizza due metodi per passare queste informazioni al server web. Questi metodi sonoGET Metodo e POSTMetodo. Controlliamoli uno per uno.

Passaggio di informazioni utilizzando il metodo GET

Il metodo GET invia le informazioni utente codificate aggiunte all'URL della pagina stessa. La pagina e le informazioni codificate sono separate dal? carattere come segue -

http://www.test.com/cgi-bin/hello.cgi?key1=value1&key2=value2

Il metodo GET è il metodo predefinito per passare le informazioni da un browser al server web e produce una lunga stringa che appare nella casella Posizione: del browser. Non utilizzare mai il metodo GET se si dispone di password o altre informazioni sensibili da passare al server. Il metodo GET ha limiti di dimensione: possono essere passati solo 1024 caratteri in una stringa di richiesta.

Queste informazioni vengono passate utilizzando QUERY_STRING intestazione e sarà accessibile nel tuo programma CGI tramite la variabile d'ambiente QUERY_STRING che puoi analizzare e utilizzare nel tuo programma CGI.

Puoi passare le informazioni semplicemente concatenando coppie di chiavi e valori insieme a qualsiasi URL oppure puoi utilizzare i tag HTML <FORM> per passare le informazioni utilizzando il metodo GET.

Esempio di URL semplice: metodo Get

Ecco un semplice URL che passerà due valori al programma hello_get.cgi utilizzando il metodo GET.

http://www.tutorialspoint.com/cgi-bin/hello_get.cgi?first_name=ZARA&last_name=ALI

Sotto è hello_get.cgi script per gestire l'input fornito dal browser web.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM);
# Read in text
$ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/; if ($ENV{'REQUEST_METHOD'} eq "GET") {
   $buffer = $ENV{'QUERY_STRING'};
}
# Split information into name/value pairs
@pairs = split(/&/, $buffer); foreach $pair (@pairs) {
   ($name, $value) = split(/=/, $pair); $value =~ tr/+/ /;
   $value =~ s/%(..)/pack("C", hex($1))/eg;
   $FORM{$name} = $value; } $first_name = $FORM{first_name}; $last_name  = $FORM{last_name}; print "Content-type:text/html\r\n\r\n"; print "<html>"; print "<head>"; print "<title>Hello - Second CGI Program</title>"; print "</head>"; print "<body>"; print "<h2>Hello $first_name $last_name - Second CGI Program</h2>";
print "</body>";
print "</html>";

1;

Esempio di FORM semplice: metodo GET

Ecco un semplice esempio, che trasmette due valori utilizzando HTML FORM e il pulsante di invio. Useremo lo stesso script CGI hello_get.cgi per gestire questo input.

<FORM action = "/cgi-bin/hello_get.cgi" method = "GET">
First Name: <input type = "text" name = "first_name">  <br>

Last Name: <input type = "text" name = "last_name">
<input type = "submit" value = "Submit">
</FORM>

Ecco l'output effettivo della codifica del modulo sopra. Ora puoi inserire Nome e Cognome e quindi fare clic sul pulsante Invia per vedere il risultato.

Passaggio di informazioni utilizzando il metodo POST

Un metodo più affidabile per passare informazioni a un programma CGI è il POSTmetodo. Questo impacchetta le informazioni esattamente allo stesso modo dei metodi GET, ma invece di inviarle come stringa di testo dopo un file?nell'URL, lo invia come messaggio separato come parte dell'intestazione HTTP. Il server Web fornisce questo messaggio allo script CGI sotto forma di input standard.

Di seguito è il modificato hello_post.cgiscript per gestire l'input fornito dal browser web. Questo script gestirà GET e il metodo POST.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM); # Read in text $ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/;
if ($ENV{'REQUEST_METHOD'} eq "POST") { read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'}); } else { $buffer = $ENV{'QUERY_STRING'}; } # Split information into name/value pairs @pairs = split(/&/, $buffer);
foreach $pair (@pairs) { ($name, $value) = split(/=/, $pair);
   $value =~ tr/+/ /; $value =~ s/%(..)/pack("C", hex($1))/eg; $FORM{$name} = $value;
}
$first_name = $FORM{first_name};
$last_name = $FORM{last_name};

print "Content-type:text/html\r\n\r\n";
print "<html>";
print "<head>";
print "<title>Hello - Second CGI Program</title>";
print "</head>";
print "<body>";
print "<h2>Hello $first_name $last_name - Second CGI Program</h2>";
print "</body>";
print "</html>";

1;

Riprendiamo lo stesso esempio di cui sopra, che trasmette due valori utilizzando HTML FORM e il pulsante di invio. Useremo lo script CGI hello_post.cgi per gestire questo input.

<FORM action = "/cgi-bin/hello_post.cgi" method = "POST">
First Name: <input type = "text" name = "first_name">  <br>

Last Name: <input type = "text" name = "last_name">

<input type = "submit" value = "Submit">
</FORM>

Ecco l'output effettivo della codifica del modulo sopra, inserisci Nome e Cognome e quindi fai clic sul pulsante Invia per vedere il risultato.

Passaggio dei dati della casella di controllo al programma CGI

Le caselle di controllo vengono utilizzate quando è necessario selezionare più di un'opzione. Ecco un esempio di codice HTML per un modulo con due caselle di controllo.

<form action = "/cgi-bin/checkbox.cgi" method = "POST" target = "_blank">
<input type = "checkbox" name = "maths" value = "on"> Maths
<input type = "checkbox" name = "physics" value = "on"> Physics
<input type = "submit" value = "Select Subject">
</form>

Il risultato di questo codice è il seguente modulo:

Sotto è checkbox.cgi script per gestire l'input fornito dal browser web per il pulsante di opzione.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM);
# Read in text
$ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/; if ($ENV{'REQUEST_METHOD'} eq "POST") {
   read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'});
} else {
   $buffer = $ENV{'QUERY_STRING'};
}
# Split information into name/value pairs
@pairs = split(/&/, $buffer); foreach $pair (@pairs) {
   ($name, $value) = split(/=/, $pair); $value =~ tr/+/ /;
   $value =~ s/%(..)/pack("C", hex($1))/eg;
   $FORM{$name} = $value; } if( $FORM{maths} ) {
   $maths_flag ="ON"; } else { $maths_flag ="OFF";
}
if( $FORM{physics} ) { $physics_flag ="ON";
} else {
   $physics_flag ="OFF"; } print "Content-type:text/html\r\n\r\n"; print "<html>"; print "<head>"; print "<title>Checkbox - Third CGI Program</title>"; print "</head>"; print "<body>"; print "<h2> CheckBox Maths is : $maths_flag</h2>";
print "<h2> CheckBox Physics is : $physics_flag</h2>";
print "</body>";
print "</html>";

1;

Passaggio dei dati del pulsante di opzione al programma CGI

I pulsanti di opzione vengono utilizzati quando è necessario selezionare una sola opzione. Ecco un esempio di codice HTML per un modulo con due pulsanti di opzione:

<form action = "/cgi-bin/radiobutton.cgi" method = "POST" target = "_blank">
<input type = "radio" name = "subject" value = "maths"> Maths
<input type = "radio" name = "subject" value = "physics"> Physics
<input type = "submit" value = "Select Subject">
</form>

Il risultato di questo codice è il seguente modulo:

Sotto è radiobutton.cgi script per gestire l'input fornito dal browser web per il pulsante di opzione.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM); # Read in text $ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/;
if ($ENV{'REQUEST_METHOD'} eq "POST") { read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'}); } else { $buffer = $ENV{'QUERY_STRING'}; } # Split information into name/value pairs @pairs = split(/&/, $buffer);
foreach $pair (@pairs) { ($name, $value) = split(/=/, $pair);
   $value =~ tr/+/ /; $value =~ s/%(..)/pack("C", hex($1))/eg; $FORM{$name} = $value;
}
$subject = $FORM{subject};

print "Content-type:text/html\r\n\r\n";
print "<html>";
print "<head>";
print "<title>Radio - Fourth CGI Program</title>";
print "</head>";
print "<body>";
print "<h2> Selected Subject is $subject</h2>";
print "</body>";
print "</html>";

1;

Passaggio dei dati dell'area di testo al programma CGI

Un elemento textarea viene utilizzato quando il testo multilinea deve essere passato al programma CGI. Ecco un esempio di codice HTML per un modulo con una casella TEXTAREA -

<form action = "/cgi-bin/textarea.cgi" method = "POST" target = "_blank">
<textarea name = "textcontent" cols = 40 rows = 4>
Type your text here...
</textarea>
<input type = "submit" value = "Submit">
</form>

Il risultato di questo codice è il seguente modulo:

Di seguito è riportato il file textarea.cgi script per gestire l'input fornito dal browser web.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM); # Read in text $ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/;
if ($ENV{'REQUEST_METHOD'} eq "POST") { read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'}); } else { $buffer = $ENV{'QUERY_STRING'}; } # Split information into name/value pairs @pairs = split(/&/, $buffer);
foreach $pair (@pairs) { ($name, $value) = split(/=/, $pair);
   $value =~ tr/+/ /; $value =~ s/%(..)/pack("C", hex($1))/eg; $FORM{$name} = $value;
}
$text_content = $FORM{textcontent};

print "Content-type:text/html\r\n\r\n";
print "<html>";
print "<head>";
print "<title>Text Area - Fifth CGI Program</title>";
print "</head>";
print "<body>";
print "<h2> Entered Text Content is $text_content</h2>";
print "</body>";
print "</html>";

1;

Passaggio dei dati della casella a discesa al programma CGI

Una casella a discesa viene utilizzata quando abbiamo molte opzioni disponibili ma ne verranno selezionate solo una o due. Ecco un esempio di codice HTML per un modulo con una casella a discesa

<form action = "/cgi-bin/dropdown.cgi" method = "POST" target = "_blank">
<select name = "dropdown">
<option value = "Maths" selected>Maths</option>
<option value = "Physics">Physics</option>
</select>
<input type = "submit" value = "Submit">
</form>

Il risultato di questo codice è il seguente modulo:

Di seguito è riportato il file dropdown.cgi script per gestire l'input fornito dal browser web.

#!/usr/bin/perl

local ($buffer, @pairs, $pair, $name, $value, %FORM); # Read in text $ENV{'REQUEST_METHOD'} =~ tr/a-z/A-Z/;
if ($ENV{'REQUEST_METHOD'} eq "POST") { read(STDIN, $buffer, $ENV{'CONTENT_LENGTH'}); } else { $buffer = $ENV{'QUERY_STRING'}; } # Split information into name/value pairs @pairs = split(/&/, $buffer);
foreach $pair (@pairs) { ($name, $value) = split(/=/, $pair);
   $value =~ tr/+/ /; $value =~ s/%(..)/pack("C", hex($1))/eg; $FORM{$name} = $value;
}
$subject = $FORM{dropdown};

print "Content-type:text/html\r\n\r\n";
print "<html>";
print "<head>";
print "<title>Dropdown Box - Sixth CGI Program</title>";
print "</head>";
print "<body>";
print "<h2> Selected Subject is $subject</h2>";
print "</body>";
print "</html>";

1;

Utilizzo dei cookie in CGI

Il protocollo HTTP è un protocollo senza stato. Ma per un sito web commerciale è necessario mantenere le informazioni sulla sessione tra pagine diverse. Ad esempio, la registrazione di un utente termina dopo transazioni che si estendono su molte pagine. Ma come mantenere le informazioni sulla sessione dell'utente in tutte le pagine web?

In molte situazioni, l'utilizzo dei cookie è il metodo più efficiente per ricordare e tracciare preferenze, acquisti, commissioni e altre informazioni necessarie per una migliore esperienza dei visitatori o statistiche del sito.

Come funziona

Il tuo server invia alcuni dati al browser del visitatore sotto forma di cookie. Il browser può accettare il cookie. In caso affermativo, viene archiviato come record di testo normale sul disco rigido del visitatore. Ora, quando il visitatore arriva a un'altra pagina del tuo sito, il cookie è disponibile per il recupero. Una volta recuperato, il tuo server sa / ricorda cosa è stato memorizzato.

I cookie sono un record di dati di testo semplice di 5 campi di lunghezza variabile -

Expires- La data in cui scadrà il cookie. Se questo è vuoto, il cookie scadrà quando il visitatore chiude il browser.
Domain - Il nome di dominio del tuo sito.
Path- Il percorso della directory o della pagina web che ha impostato il cookie. Questo può essere vuoto se desideri recuperare il cookie da qualsiasi directory o pagina.
Secure- Se questo campo contiene la parola "secure", il cookie può essere recuperato solo con un server sicuro. Se questo campo è vuoto, non esiste alcuna restrizione di questo tipo.
Name = Value - I cookie vengono impostati e riesaminati sotto forma di coppie chiave e valore.

Configurazione dei cookie

È molto semplice inviare cookie al browser. Questi cookie verranno inviati insieme all'intestazione HTTP. Supponendo che si desideri impostare UserID e Password come cookie. Quindi sarà fatto come segue:

#!/usr/bin/perl

print "Set-Cookie:UserID = XYZ;\n";
print "Set-Cookie:Password = XYZ123;\n";
print "Set-Cookie:Expires = Tuesday, 31-Dec-2007 23:12:40 GMT";\n";
print "Set-Cookie:Domain = www.tutorialspoint.com;\n";
print "Set-Cookie:Path = /perl;\n";
print "Content-type:text/html\r\n\r\n";
...........Rest of the HTML Content goes here....

Qui abbiamo usato Set-CookieIntestazione HTTP per impostare i cookie. È facoltativo impostare gli attributi dei cookie come Expires, Domain e Path. È importante notare che i cookie vengono impostati prima dell'invio di magic line"Content-type:text/html\r\n\r\n.

Recupero dei cookie

È molto facile recuperare tutti i cookie impostati. I cookie sono memorizzati nella variabile d'ambiente CGI HTTP_COOKIE e avranno la seguente forma.

key1 = value1;key2 = value2;key3 = value3....

Ecco un esempio di come recuperare i cookie.

#!/usr/bin/perl
$rcvd_cookies = $ENV{'HTTP_COOKIE'}; @cookies = split /;/, $rcvd_cookies;
foreach $cookie ( @cookies ) { ($key, $val) = split(/=/, $cookie); # splits on the first =.
   $key =~ s/^\s+//; $val =~ s/^\s+//;
   $key =~ s/\s+$//;
   $val =~ s/\s+$//;
   if( $key eq "UserID" ) { $user_id = $val; } elsif($key eq "Password") {
      $password = $val;
   }
}
print "User ID  = $user_id\n"; print "Password = $password\n";

Ciò produrrà il seguente risultato, a condizione che i cookie sopra siano stati impostati prima di chiamare lo script di recupero dei cookie.

User ID = XYZ
Password = XYZ123

Moduli e librerie CGI

Troverai molti moduli incorporati su Internet che ti forniscono funzioni dirette da usare nel tuo programma CGI. Di seguito sono riportati gli importanti una volta.

Modulo CGI
Berkeley cgi-lib.pl

Cosa sono i pacchetti?

Il packageL'istruzione cambia il contesto dei nomi corrente in uno spazio dei nomi specificato (tabella dei simboli). Quindi -

Un pacchetto è una raccolta di codice che risiede nel proprio spazio dei nomi.
Uno spazio dei nomi è una raccolta denominata di nomi di variabili univoci (chiamata anche tabella dei simboli).
Gli spazi dei nomi prevengono i conflitti di nomi di variabili tra i pacchetti.
I pacchetti consentono la costruzione di moduli che, se usati, non sovrascriveranno variabili e funzioni al di fuori dello spazio dei nomi dei moduli.
Il pacchetto rimane in vigore finché non viene richiamata un'altra istruzione del pacchetto o fino alla fine del blocco o del file corrente.
È possibile fare riferimento esplicito alle variabili all'interno di un pacchetto utilizzando il :: qualificatore del pacchetto.

Di seguito è riportato un esempio con i pacchetti main e Foo in un file. Qui è stata usata la variabile speciale __PACKAGE__ per stampare il nome del pacchetto.

#!/usr/bin/perl

# This is main package
$i = 1; print "Package name : " , __PACKAGE__ , " $i\n"; 

package Foo;
# This is Foo package
$i = 10; print "Package name : " , __PACKAGE__ , " $i\n"; 

package main;
# This is again main package
$i = 100; print "Package name : " , __PACKAGE__ , " $i\n"; 
print "Package name : " , __PACKAGE__ ,  " $Foo::i\n"; 

1;

Quando viene eseguito il codice sopra, produce il seguente risultato:

Package name : main 1
Package name : Foo 10
Package name : main 100
Package name : main 10

Blocchi BEGIN e END

È possibile definire un numero qualsiasi di blocchi di codice denominati BEGIN e END, che agiscono rispettivamente come costruttori e distruttori.

BEGIN { ... }
END { ... }
BEGIN { ... }
END { ... }

Ogni BEGIN block viene eseguito dopo che lo script perl è stato caricato e compilato ma prima che venga eseguita qualsiasi altra istruzione.
Ogni blocco END viene eseguito appena prima che l'interprete perl esca.
I blocchi BEGIN e END sono particolarmente utili quando si creano moduli Perl.

L'esempio seguente mostra il suo utilizzo:

#!/usr/bin/perl

package Foo;
print "Begin and Block Demo\n";

BEGIN { 
   print "This is BEGIN Block\n" 
}

END { 
   print "This is END Block\n" 
}

1;

Quando viene eseguito il codice sopra, produce il seguente risultato:

This is BEGIN Block
Begin and Block Demo
This is END Block

Cosa sono i moduli Perl?

Un modulo Perl è un pacchetto riutilizzabile definito in un file di libreria il cui nome è uguale al nome del pacchetto con estensione .pm.

Un file di modulo Perl chiamato Foo.pm potrebbe contenere affermazioni come questa.

#!/usr/bin/perl

package Foo;
sub bar { 
   print "Hello $_[0]\n" 
}

sub blat { 
   print "World $_[0]\n" 
}
1;

Pochi punti importanti sui moduli Perl

Le funzioni require e use caricherà un modulo.
Entrambi usano l'elenco dei percorsi di ricerca in @INC per trovare il modulo.
Entrambe le funzioni require e use chiama il eval funzione per elaborare il codice.
Il 1; in fondo fa sì che eval restituisca TRUE (e quindi non fallisca).

La funzione Richiedi

Un modulo può essere caricato chiamando il file require funzionare come segue -

#!/usr/bin/perl

require Foo;

Foo::bar( "a" );
Foo::blat( "b" );

Avrai notato che i nomi delle subroutine devono essere pienamente qualificati per chiamarli. Sarebbe bello abilitare la subroutinebar e blat da importare nel nostro spazio dei nomi in modo da non dover usare il qualificatore Foo ::.

La funzione Use

Un modulo può essere caricato chiamando il file use funzione.

#!/usr/bin/perl

use Foo;

bar( "a" );
blat( "b" );

Si noti che non è stato necessario qualificare completamente i nomi delle funzioni del pacchetto. Iluse funzione esporterà un elenco di simboli da un modulo dato alcune istruzioni aggiunte all'interno di un modulo.

require Exporter;
@ISA = qw(Exporter);

Quindi, fornire un elenco di simboli (scalari, elenchi, hash, subroutine, ecc.) Compilando la variabile di elenco denominata @EXPORT: Ad esempio -

package Module;

require Exporter;
@ISA = qw(Exporter);
@EXPORT = qw(bar blat);

sub bar { print "Hello $_[0]\n" }
sub blat { print "World $_[0]\n" } sub splat { print "Not $_[0]\n" }  # Not exported!

1;

Crea l'albero dei moduli Perl

Quando sei pronto per spedire il tuo modulo Perl, esiste un modo standard per creare un albero del modulo Perl. Questo viene fatto usandoh2xsutilità. Questa utility viene fornita con Perl. Ecco la sintassi per usare h2xs -

$h2xs -AX -n  ModuleName

Ad esempio, se il tuo modulo è disponibile in Person.pm file, quindi emetti semplicemente il seguente comando:

$h2xs -AX -n Person

Questo produrrà il seguente risultato:

Writing Person/lib/Person.pm
Writing Person/Makefile.PL
Writing Person/README
Writing Person/t/Person.t
Writing Person/Changes
Writing Person/MANIFEST

Ecco la descrizione di queste opzioni:

-A omette il codice del caricatore automatico (utilizzato al meglio dai moduli che definiscono un gran numero di subroutine usate di rado).
-X omette gli elementi XS (eXternal Subroutine, dove eXternal significa esterno a Perl, cioè C).
-n specifica il nome del modulo.

Quindi il comando sopra crea la seguente struttura all'interno della directory Person. Il risultato effettivo è mostrato sopra.

Changes
Makefile.PL
MANIFEST (contiene l'elenco di tutti i file nel pacchetto)
README
t / (file di prova)
lib / (Il codice sorgente effettivo va qui

Quindi finalmente tu tarquesta struttura di directory in un file Person.tar.gz e puoi inviarlo. Dovrai aggiornare il file README con le istruzioni appropriate. Puoi anche fornire alcuni file di esempi di test nella directory t.

Installazione del modulo Perl

Scarica un modulo Perl nel file tar.gz. Utilizzare la seguente sequenza per installare qualsiasi modulo PerlPerson.pm che è stato scaricato in formato Person.tar.gz file.

tar xvfz Person.tar.gz
cd Person
perl Makefile.PL
make
make install

L'interprete Perl ha un elenco di directory in cui cerca i moduli (array globale @INC).

È possibile utilizzare Perl in vari modi per creare nuovi processi secondo le proprie esigenze. Questo tutorial elencherà alcuni metodi importanti e usati più di frequente per creare e gestire processi Perl.

Puoi usare variabili speciali $$ o $PROCESS_ID per ottenere l'ID del processo corrente.
Ogni processo creato utilizzando uno dei metodi menzionati, mantiene il proprio ambiente virtuale all'interno %ENV variabile.
Il exit() funzione esce sempre solo dal processo figlio che esegue questa funzione e il processo principale nel suo insieme non uscirà a meno che tutti i processi figlio in esecuzione non siano terminati.
Tutti gli handle aperti sono dup () - ed nei processi figlio, in modo che la chiusura di qualsiasi handle in un processo non influisca sugli altri.

Operatore Backstick

Questo modo più semplice di eseguire qualsiasi comando Unix è usare l'operatore backstick. Metti semplicemente il tuo comando all'interno dell'operatore backstick, che comporterà l'esecuzione del comando e restituirà il suo risultato che può essere memorizzato come segue:

#!/usr/bin/perl

@files = `ls -l`;

foreach $file (@files) { print $file;
}

1;

Quando il codice sopra viene eseguito, elenca tutti i file e le directory disponibili nella directory corrente -

drwxr-xr-x 3 root root 4096 Sep 14 06:46 9-14
drwxr-xr-x 4 root root 4096 Sep 13 07:54 android
-rw-r--r-- 1 root root  574 Sep 17 15:16 index.htm
drwxr-xr-x 3  544  401 4096 Jul  6 16:49 MIME-Lite-3.01
-rw-r--r-- 1 root root   71 Sep 17 15:16 test.pl
drwx------ 2 root root 4096 Sep 17 15:11 vAtrJdy

La funzione system ()

Puoi anche usare system()funzione per eseguire qualsiasi comando Unix, il cui output andrà all'output dello script perl. Per impostazione predefinita, è lo schermo, cioè STDOUT, ma puoi reindirizzarlo a qualsiasi file utilizzando l'operatore di reindirizzamento> -

#!/usr/bin/perl

system( "ls -l")

1;

Quando viene eseguito il codice sopra, elenca tutti i file e le directory disponibili nella directory corrente -

drwxr-xr-x 3 root root 4096 Sep 14 06:46 9-14
drwxr-xr-x 4 root root 4096 Sep 13 07:54 android
-rw-r--r-- 1 root root  574 Sep 17 15:16 index.htm
drwxr-xr-x 3  544  401 4096 Jul  6 16:49 MIME-Lite-3.01
-rw-r--r-- 1 root root   71 Sep 17 15:16 test.pl
drwx------ 2 root root 4096 Sep 17 15:11 vAtrJdy

Fai attenzione quando il tuo comando contiene variabili ambientali di shell come $PATH or $CASA. Prova a seguire tre scenari:

#!/usr/bin/perl

$PATH = "I am Perl Variable"; system('echo $PATH');  # Treats $PATH as shell variable system("echo $PATH");  # Treats $PATH as Perl variable system("echo \$PATH"); # Escaping $ works.

1;

Quando viene eseguito il codice precedente, produce il seguente risultato a seconda di cosa è impostato nella variabile di shell $ PATH.

/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin
I am Perl Variable
/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin

La funzione fork ()

Perl fornisce un file fork()funzione che corrisponde alla chiamata di sistema Unix con lo stesso nome. Sulla maggior parte delle piattaforme Unix in cui è disponibile la chiamata di sistema fork (), fork () di Perl la chiama semplicemente. Su alcune piattaforme come Windows dove la chiamata di sistema fork () non è disponibile, Perl può essere costruito per emulare fork () a livello di interprete.

La funzione fork () viene utilizzata per clonare un processo corrente. Questa chiamata crea un nuovo processo che esegue lo stesso programma nello stesso punto. Restituisce il pid figlio al processo padre, 0 al processo figlio o undef se il fork non ha successo.

Puoi usare exec() all'interno di un processo per avviare l'eseguibile richiesto, che verrà eseguito in un'area del processo separata ed exec () attenderà il completamento prima di uscire con lo stesso stato di uscita di quel processo.

#!/usr/bin/perl

if(!defined($pid = fork())) { # fork returned undef, so unsuccessful die "Cannot fork a child: $!";
} elsif ($pid == 0) { print "Printed by child process\n"; exec("date") || die "can't exec date: $!";
  
} else {
   # fork returned 0 nor undef
   # so this branch is parent
   print "Printed by parent process\n";
   $ret = waitpid($pid, 0);
   print "Completed process id: $ret\n";

}

1;

Quando viene eseguito il codice sopra, produce il seguente risultato:

Printed by parent process
Printed by child process
Tue Sep 17 15:41:08 CDT 2013
Completed process id: 17777

Il wait() e waitpid()può essere passato come ID pseudo-processo restituito da fork (). Queste chiamate attenderanno correttamente la fine dello pseudo-processo e restituiranno il suo stato. Se forzi senza mai aspettare che i tuoi figli usinowaitpid()funzione, accumulerai zombi. Sui sistemi Unix, puoi evitarlo impostando $ SIG {CHLD} su "IGNORE" come segue:

#!/usr/bin/perl

local $SIG{CHLD} = "IGNORE"; if(!defined($pid = fork())) {
   # fork returned undef, so unsuccessful
   die "Cannot fork a child: $!"; } elsif ($pid == 0) {
   print "Printed by child process\n";
   exec("date") || die "can't exec date: $!"; } else { # fork returned 0 nor undef # so this branch is parent print "Printed by parent process\n"; $ret = waitpid($pid, 0); print "Completed process id: $ret\n";

}

1;

Quando viene eseguito il codice sopra, produce il seguente risultato:

Printed by parent process
Printed by child process
Tue Sep 17 15:44:07 CDT 2013
Completed process id: -1

La funzione kill ()

Perl kill('KILL', (Process List)) può essere usata per terminare uno pseudo-processo passandogli l'ID restituito da fork ().

Notare che l'utilizzo di kill ('KILL', (Process List)) su uno pseudo-processo () può in genere causare perdite di memoria, perché il thread che implementa lo pseudo-processo non ha la possibilità di ripulire le sue risorse.

Puoi usare kill() funzione per inviare qualsiasi altro segnale ai processi di destinazione, ad esempio il seguente invierà SIGINT a un processo ID 104 e 102 -

#!/usr/bin/perl

kill('INT', 104, 102);
 
1;

Puoi incorporare la documentazione Pod (Plain Old Text) nei tuoi moduli e script Perl. Di seguito è riportata la regola per utilizzare la documentazione incorporata nel codice Perl:

Inizia la tua documentazione con una riga vuota, a =head1 comando all'inizio e terminarlo con un =cut

Perl ignorerà il testo del pod che hai inserito nel codice. Di seguito è riportato un semplice esempio di utilizzo della documentazione incorporata nel codice Perl:

#!/usr/bin/perl

print "Hello, World\n";

=head1 Hello, World Example
This example demonstrate very basic syntax of Perl.
=cut

print "Hello, Universe\n";

Quando viene eseguito il codice sopra, produce il seguente risultato:

Hello, World
Hello, Universe

Se hai intenzione di mettere il tuo Pod alla fine del file e stai usando un segno di taglio __END__ o __DATA__, assicurati di mettere una riga vuota lì prima del primo comando Pod come segue, altrimenti senza una riga vuota prima il =head1, molti traduttori non avrebbero riconosciuto il =head1 come avviare un blocco pod.

#!/usr/bin/perl

print "Hello, World\n";

while(<DATA>) {
  print $_;
}

__END__

=head1 Hello, World Example
This example demonstrate very basic syntax of Perl.
print "Hello, Universe\n";

Quando viene eseguito il codice sopra, produce il seguente risultato:

Hello, World

=head1 Hello, World Example
This example demonstrate very basic syntax of Perl.
print "Hello, Universe\n";

Facciamo un altro esempio per lo stesso codice senza leggere la parte DATA -

#!/usr/bin/perl

print "Hello, World\n";

__END__

=head1 Hello, World Example
This example demonstrate very basic syntax of Perl.
print "Hello, Universe\n";

Quando viene eseguito il codice sopra, produce il seguente risultato:

Hello, World

Cos'è il POD?

Pod è un linguaggio di markup semplice da usare utilizzato per scrivere documentazione per Perl, programmi Perl e moduli Perl. Sono disponibili vari traduttori per convertire Pod in vari formati come testo normale, HTML, pagine man e altro. Il markup del pod è costituito da tre tipi fondamentali di paragrafi:

Ordinary Paragraph - È possibile utilizzare codici di formattazione in paragrafi ordinari, per grassetto, corsivo, stile codice, collegamenti ipertestuali e altro.
Verbatim Paragraph - I paragrafi Verbatim vengono solitamente utilizzati per presentare un blocco di codice o altro testo che non richiede alcuna analisi o formattazione speciale e che non deve essere avvolto.
Command Paragraph- Un paragrafo di comando viene utilizzato per il trattamento speciale di intere porzioni di testo, solitamente come intestazioni o parti di elenchi. Tutti i paragrafi del comando iniziano con =, seguito da un identificatore, seguito da testo arbitrario che il comando può utilizzare come preferisce. I comandi attualmente riconosciuti sono:

=pod
=head1 Heading Text
=head2 Heading Text
=head3 Heading Text
=head4 Heading Text
=over indentlevel
=item stuff
=back
=begin format
=end format
=for format text...
=encoding type
=cut

Esempi di POD

Considera il seguente POD:

=head1 SYNOPSIS
Copyright 2005 [TUTORIALSOPOINT].
=cut

Puoi usare pod2html utility disponibile su Linux per convertire sopra POD in HTML, quindi produrrà il seguente risultato:

Quindi, considera il seguente esempio:

=head2 An Example List

=over 4
=item * This is a bulleted list.
=item * Here's another item.
=back
=begin html
<p>
Here's some embedded HTML.  In this block I can
include images, apply <span style="color: green">
styles</span>, or do anything else I can do with
HTML.  pod parsers that aren't outputting HTML will
completely ignore it.
</p>

=end html

Quando converti il POD sopra in HTML usando pod2html, produrrà il seguente risultato:

An Example List
   This is a bulleted list.
   Here's another item.
Here's some embedded HTML. In this block I can include images, apply 
styles, or do anything else I can do with HTML. pod parsers that aren't 
outputting HTML will completely ignore it.

Ecco l'elenco di tutte le funzioni importanti supportate dal Perl standard.

abs - funzione valore assoluto
accetta - accetta una connessione socket in entrata
allarme - programma un SIGALRM
atan2 - arcotangente di Y / X nell'intervallo da -PI a PI
bind : associa un indirizzo a un socket
binmode - prepara i file binari per I / O
benedica : crea un oggetto
caller - ottiene il contesto della chiamata della subroutine corrente
chdir - cambia la tua directory di lavoro corrente
chmod : modifica le autorizzazioni su un elenco di file
chomp - rimuove un separatore di record finale da una stringa
chop - rimuove l'ultimo carattere da una stringa
chown - cambia la nave in un elenco di file
chr - ottieni il carattere rappresentato da questo numero
chroot - crea una nuova directory root per le ricerche di percorso
close - chiude l'handle del file (o pipe o socket)
closedir - chiude l'handle della directory
connect - connettersi a una presa remota
continue - blocco finale opzionale tra un po 'o foreach
cos - funzione coseno
crypt - crittografia unidirezionale in stile passwd
dbmclose - interrompe il binding su un file dbm legato
dbmopen : crea l'associazione su un file dbm legato
definito : verifica se un valore, una variabile o una funzione è definito o meno
elimina : elimina un valore da un hash
muori - solleva un'eccezione o salva
fare - trasformare un BLOCCO in un TERMINE
dump : crea un core dump immediato
each - recupera la successiva coppia chiave / valore da un hash
endgrent - essere fatto usando il file di gruppo
endhostent - essere fatto usando il file hosts
endnetent - essere fatto utilizzando il file di rete
endprotoent - essere fatto utilizzando il file dei protocolli
endpwent - essere fatto usando il file passwd
endservent - essere eseguito utilizzando il file dei servizi
eof - verifica la fine di un filehandle
eval - cattura le eccezioni o compila ed esegui il codice
exec - abbandona questo programma per eseguirne un altro
esiste : verifica se è presente una chiave hash
exit - termina questo programma
exp - alza I a un potere
fcntl - chiamata di sistema di controllo file
fileno - restituisce il descrittore di file dal filehandle
flock - blocca un intero file con un blocco consultivo
fork : crea un nuovo processo proprio come questo
format - dichiara un formato immagine con l'uso dalla funzione write ()
formline - funzione interna utilizzata per i formati
getc - ottiene il carattere successivo dal filehandle
getgrent : ottieni il record del gruppo successivo
getgrgid - ottiene il record del gruppo dato l'ID utente del gruppo
getgrnam - ottiene il record del gruppo dato il nome del gruppo
gethostbyaddr - ottiene il record dell'host dato il suo indirizzo
gethostbyname - ottiene il nome dato dal record host
gethostent : ottieni il record del prossimo host
getlogin - restituisci chi ha effettuato l'accesso a questa tty
getnetbyaddr - ottiene il record di rete dato il suo indirizzo
getnetbyname - ottiene il nome dato dal record di rete
getnetent : ottieni il record successivo della rete
getpeername - trova l'altra estremità di una connessione socket
getpgrp - ottieni il gruppo di processi
getppid : ottieni l'ID del processo genitore
getpriority : ottieni il valore attuale
getprotobyname - ottiene il nome dato dal record del protocollo
getprotobynumber - ottiene il protocollo numerico del record del protocollo
getprotoent - ottiene il record dei protocolli successivi
getpwent - ottiene il record successivo di passwd
getpwnam - ottiene il record passwd dato il nome di accesso dell'utente
getpwuid - ottiene il record passwd dato l'ID utente
getservbyname - ottiene il record dei servizi dato il suo nome
getservbyport - ottiene il record dei servizi data la porta numerica
getservent - ottiene il record dei servizi successivi
getsockname - recupera il sockaddr per un dato socket
getsockopt - ottiene le opzioni del socket su un dato socket
glob - espande i nomi dei file utilizzando i caratteri jolly
gmtime : converte l'ora UNIX in record o stringa utilizzando il formato dell'ora di Greenwich.
goto - crea codice per spaghetti
grep - individua gli elementi in una lista verifica vero rispetto a un dato criterio
hex : converte una stringa in un numero esadecimale
import : applica lo spazio dei nomi di un modulo al tuo
index : trova una sottostringa all'interno di una stringa
int - ottiene la parte intera di un numero
ioctl - chiamata di sistema di controllo del dispositivo dipendente dal sistema
join : unisce un elenco in una stringa utilizzando un separatore
chiavi : recupera l'elenco degli indici da un hash
kill - invia un segnale a un processo o gruppo di processi
ultimo - esci prematuramente da un blocco
lc - restituisce la versione minuscola di una stringa
lcfirst - restituisce una stringa con solo la lettera successiva in minuscolo
length - restituisce il numero di byte in una stringa
link - crea un hard link nel filesytem
ascolta : registra il tuo socket come server
locale : crea un valore temporaneo per una variabile globale (ambito dinamico)
localtime - converte l'ora UNIX in record o stringa utilizzando l'ora locale
lock : consente di ottenere un thread lock su una variabile, una subroutine o un metodo
log : recupera il logaritmo naturale di un numero
lstat - stat un collegamento simbolico
m - corrisponde a una stringa con un modello di espressione regolare
mappa : applica una modifica a un elenco per ottenere un nuovo elenco con le modifiche
mkdir : crea una directory
msgctl - Operazioni di controllo dei messaggi IPC SysV
msgget : ottieni la coda dei messaggi IPC di SysV
msgrcv - riceve un messaggio IPC SysV da una coda messaggi
msgsnd - invia un messaggio IPC SysV a una coda di messaggi
my - dichiara e assegna una variabile locale (ambito lessicale)
next - itera un blocco prematuramente
no - annulla l'importazione di alcuni simboli di modulo o semantica in fase di compilazione
ott - converte una stringa in un numero ottale
open : apre un file, pipe o descrittore
opendir - apre una directory
ord : trova la rappresentazione numerica di un carattere
our - dichiara e assegna una variabile del pacchetto (ambito lessicale)
pack - converte un elenco in una rappresentazione binaria
pacchetto : dichiara uno spazio dei nomi globale separato
pipe - apre un paio di filehandle collegati
pop - rimuove l'ultimo elemento da un array e lo restituisce
pos - trova o imposta l'offset per l'ultima / successiva ricerca m // g
print - emette un elenco in un filehandle
printf - emette un elenco formattato in un filehandle
prototype : ottieni il prototipo (se presente) di una subroutine
push - aggiunge uno o più elementi a un array
q - cita singolarmente una stringa
qq - cita doppiamente una stringa
qr - Compila pattern
quotemeta - cita caratteri magici di espressioni regolari
qw - cita un elenco di parole
qx - apice inverso cita una stringa
rand - recupera il numero pseudocasuale successivo
read - input bufferizzato a lunghezza fissa da un filehandle
readdir - ottiene una directory da un handle di directory
readline - recupera un record da un file
readlink - determina dove punta un link simbolico
readpipe - esegue un comando di sistema e raccoglie l'output standard
recv - riceve un messaggio su un Socket
redo - avvia di nuovo questa iterazione del ciclo
ref : scopri il tipo di oggetto a cui si fa riferimento
rinomina - cambia il nome di un file
require - carica le funzioni esterne da una libreria in fase di runtime
reset - cancella tutte le variabili di un dato nome
return - esci presto da una funzione
reverse - capovolge una stringa o un elenco
rewinddir - reimposta l'handle della directory
rindex - ricerca di sottostringhe da destra a sinistra
rmdir - rimuove una directory
s - sostituisci un pattern con una stringa
scalare : forza un contesto scalare
seek - riposiziona il puntatore al file per I / O ad accesso casuale
seekdir - riposiziona il puntatore alla directory
seleziona - ripristina l'uscita predefinita o effettua il multiplexing degli I / O
semctl - operazioni di controllo del semaforo SysV
semget - ottiene l'insieme dei semafori SysV
semop - operazioni sul semaforo di SysV
send - invia un messaggio tramite un socket
setgrent - prepara il file di gruppo per l'uso
sethostent - prepara il file hosts per l'uso
setnetent - prepara il file di rete per l'uso
setpgrp - imposta il gruppo di processi di un processo
setpriority - imposta il valore corretto di un processo
setprotoent - prepara il file dei protocolli per l'uso
setpwent - prepara il file passwd per l'uso
setservent - prepara il file dei servizi per l'uso
setsockopt - imposta alcune opzioni del socket
shift : rimuove il primo elemento di un array e lo restituisce
shmctl - operazioni di memoria condivisa SysV
shmget - ottiene l'identificatore del segmento di memoria condivisa SysV
shmread - legge la memoria condivisa di SysV
shmwrite - scrive la memoria condivisa SysV
shutdown - chiude solo la metà di una connessione socket
sin - restituisce il seno di un numero
sleep - blocca per un certo numero di secondi
socket : crea un socket
socketpair : crea una coppia di socket
sort - ordina un elenco di valori
splice : aggiungi o rimuovi elementi ovunque in un array
split - divide una stringa usando un delimitatore regexp
sprintf - stampa formattata in una stringa
sqrt - funzione radice quadrata
srand - seed il generatore di numeri casuali
stat - ottiene le informazioni sullo stato di un file
studio : ottimizza i dati di input per ricerche ripetute
sub - dichiara una subroutine, possibilmente anonima
substr - ottiene o altera una porzione di un mescolamento
collegamento simbolico : crea un collegamento simbolico a un file
syscall - esegue una chiamata di sistema arbitraria
sysopen : apre un file, pipe o descrittore
sysread - input senza buffer di lunghezza fissa da un filehandle
sysseek - posiziona il puntatore I / O sull'handle usato con sysread e syswrite
sistema - esegui un programma separato
syswrite - output non bufferizzato a lunghezza fissa in un filehandle
tell - ottiene il seekpointer corrente su un filehandle
telldir - ottiene il seekpointer corrente su un handle di directory
tie - lega una variabile a una classe di oggetti
legato - ottiene un riferimento all'oggetto sottostante una variabile legata
time - restituisce il numero di secondi dal 1970
volte - restituisce il tempo trascorso per i processi personali e figli
tr - traslittera una stringa
truncate - accorcia un file
uc - restituisce la versione in maiuscolo di una stringa
ucfirst - restituisce una stringa con solo la lettera successiva in maiuscolo
umask - imposta la maschera della modalità di creazione del file
undef - rimuove una definizione di variabile o funzione
scollega : rimuove un collegamento a un file
unpack - converte la struttura binaria in normali variabili Perl
unshift : antepone più elementi all'inizio di un elenco
untie - interrompe un legame vincolante a una variabile
use - carica un modulo in fase di compilazione
utime - imposta l'ultimo accesso di un file e modifica i tempi
valori : restituisce un elenco dei valori in un hash
vec - verifica o imposta particolari bit in una stringa
aspetta - aspetta che muoia qualsiasi processo figlio
waitpid - aspetta che un particolare processo figlio muoia
wantarray - ottiene il contesto void vs scalare vs elenco della chiamata di subroutine corrente
warn - stampa le informazioni di debug
scrivi : stampa una registrazione dell'immagine
-X - un file di test (-r, -x, ecc.)
y - traslittera una stringa

Sr.No.	Esempio e descrizione
1	python\|perl Corrisponde a "python" o "perl"
2	rub(y\|le)) Corrisponde a "rubino" o "rublo"
3	Python(!+\|\?) "Python" seguito da uno o più! o uno?