• 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 è 5.16.2

  • Perl è elencato nell'Oxford English Dictionary .

  • 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 integrato in altri sistemi.

  • 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.

Sì! Perl è un linguaggio di programmazione case sensitive.

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 ha tre tipi di dati di base: scalari, array di scalari e hash di scalari, noti anche come array associativi.

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.

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" (@).

Gli hash sono insiemi non ordinati di coppie chiave / valore a cui accedi utilizzando le chiavi come pedici. Sono preceduti da un segno di percentuale (%).

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.

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

L'assegnazione a una variabile scalare valuta il lato destro in un contesto scalare.

L'assegnazione a un array o un hash valuta il lato destro in un contesto di elenco.

Il contesto booleano è semplicemente qualsiasi luogo in cui un'espressione viene valutata per vedere se è vera o falsa.

Questo contesto non solo non si preoccupa di quale sia il valore di ritorno, ma non vuole nemmeno un valore di ritorno.

Questo contesto accade solo all'interno di virgolette o cose che funzionano come virgolette.

La stringa tra virgolette singole stampa la variabile perl come una stringa mentre la stringa tra virgolette doppie valuta la variabile e viene utilizzata per ottenere il valore della variabile.

#!/usr/bin/perl

$var = "This is string scalar!";
$quote = 'I m inside single quote - $var';
$double = "This is inside double quote - $var";

$escape = "This example of escape -\tHello, World!";

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

Questo produrrà il seguente risultato:

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

Un 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}".

Viene utilizzato per ottenere il nome del file corrente.

Viene utilizzato per ottenere il numero di riga corrente.

Viene utilizzato per ottenere il nome del pacchetto corrente.

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";

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

L'operatore di intervallo (..) viene utilizzato per creare array sequenziali.

#!/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 il doppio punto (..) è chiamato operatore di intervallo. 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

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.

push @ARRAY, LIST - Inserisce i valori dell'elenco alla fine dell'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";

Questo produrrà il seguente risultato:

1. @coins = Quarter Dime Nickel
2. @coins = Quarter Dime Nickel Penny

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 beginning of the array
unshift(@coins, "Dollar");
print "2. \@coins  = @coins\n";

Questo produrrà il seguente risultato:

1. @coins = Quarter Dime Nickel
2. @coins = Dollar Quarter Dime Nickel

pop @ARRAY - Si apre e restituisce l'ultimo valore dell'array.

#!/usr/bin/perl

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

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

Questo produrrà il seguente risultato:

1. @coins = Quarter Dime Nickel
2. @coins = Quarter Dime

shift @ARRAY - Sposta il primo valore dell'array e lo restituisce, accorciando l'array di 1 e spostando tutto verso il basso.

#!/usr/bin/perl

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

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

Questo produrrà il seguente risultato:

1. @coins = Quarter Dime Nickel
2. @coins = Dime Nickel

Puoi anche estrarre una "sezione" 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 funzione splice () rimuoverà gli elementi di @ARRAY designati da OFFSET e LENGTH, e li sostituirà con LIST, se specificato. Infine, restituisce gli elementi rimossi dall'array.

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

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

split () 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.

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

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

La funzione join () unisce le stringhe separate di LIST in una singola stringa con campi separati dal valore di EXPR e restituisce la stringa.

join EXPR, LIST

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";
print "$string[3]\n";  # This will print Roses
print "$names[4]\n";   # This will print Michael

Questo produrrà il seguente risultato:

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

La funzione sort () ordina ogni elemento di un array secondo gli 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 viene specificato SUBROUTINE, la logica specificata all'interno di 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

Questa variabile speciale è uno scalare contenente il primo indice di tutti gli array. Poiché gli array Perl hanno un'indicizzazione in base zero, $ [sarà quasi sempre 0. Ma se imposti $ [a 1, tutti gli array useranno l'indicizzazione in base. Si consiglia di non utilizzare nessun'altra indicizzazione diversa da zero. Tuttavia, facciamo un esempio per mostrare l'utilizzo di $ [variabile -

#!/usr/bin/perl

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

# Let's reset first index of all the arrays.
$[ = 1;

print "Food at \@foods[1]: $foods[1]\n";
print "Food at \@foods[2]: $foods[2]\n";

Questo produrrà il seguente risultato:

Foods: pizza steak chicken burgers
Food at @foods[1]: pizza
Food at @foods[2]: steak

Poiché un array è solo una sequenza di valori separati da virgole, è possibile 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 hash vengono creati in uno dei due modi seguenti. Nel primo metodo, si assegna un valore a una chiave denominata 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);

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

È possibile ottenere un elenco di tutte le chiavi da un hash utilizzando la funzione keys, 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

È possibile ottenere un elenco di tutti i valori da un hash utilizzando la funzione values, che ha la seguente sintassi:

values %HASH

Questa funzione restituisce un array di 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

Utilizzando la funzione exist, 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 presumi solo che la parte if (condition) verrà eseguita solo quando la condizione data è vera, altrimenti la parte else 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

È 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

L'aggiunta di una nuova coppia chiave / valore può essere eseguita con una riga di codice utilizzando un semplice operatore di assegnazione.

#!/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";

Questo produrrà il seguente risultato:

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

Per rimuovere un elemento dall'hash è necessario utilizzare la funzione di cancellazione come mostrato sotto 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";

# delete the same element from the hash;
delete $data{'John Paul'};
@keys = keys %data;
$size = @keys;
print "2 - Hash size:  is $size\n";

Questo produrrà il seguente risultato:

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

Fa sì che il ciclo salti il ​​resto del suo corpo e ritorni immediatamente le sue condizioni prima di ripetere. ultima dichiarazione.

Termina l'istruzione del ciclo e trasferisce l'esecuzione all'istruzione immediatamente successiva al ciclo. continua dichiarazione.

Un BLOCCO continuo, viene sempre eseguito appena prima che il condizionale stia per essere valutato di nuovo.

Il comando redo riavvia il blocco loop senza valutare nuovamente il condizionale. Il blocco continue, se presente, non viene eseguito.

Il modulo goto LABEL salta all'istruzione etichettata con LABEL e riprende l'esecuzione da lì.

Il modulo goto EXPR è solo una generalizzazione di goto LABEL. Si aspetta che l'espressione restituisca un nome di etichetta e quindi salta a quell'istruzione etichettata.

Sostituisce una chiamata alla subroutine denominata per la subroutine attualmente in esecuzione.

Esponente: esegue il calcolo esponenziale (potenza) sugli operatori. Supponiamo che la variabile $ a contenga 10 e la variabile $ b ne contenga 20, quindi $ a ** $ b darà 10 alla potenza 20.

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. Supponiamo che la variabile $ a contenga 10 e la variabile $ b ne contenga 20, quindi ($ a <=> $ b) restituisca -1.

Restituisce vero se l'argomento di sinistra è inferiore a livello di stringa rispetto all'argomento di destra. Supponiamo che la variabile $ a contenga "abc" e la variabile $ b contenga "xyz", quindi ($ a lt $ b) sia vera.

Restituisce vero se l'argomento di sinistra è maggiore in senso stringa dell'argomento di destra. Supponiamo che la variabile $ a contenga "abc" e la variabile $ b contenga "xyz", quindi ($ a gt $ b) sia falsa.

Restituisce vero se l'argomento di sinistra è inferiore o uguale all'argomento di destra in senso stringa. Supponiamo che la variabile $ a contenga "abc" e la variabile $ b contenga "xyz", quindi ($ a le $ b) sia vera.

Restituisce vero se l'argomento di sinistra è maggiore o uguale all'argomento di destra in senso stringa. Supponiamo che la variabile $ a contenga "abc" e la variabile $ b contenga "xyz", quindi ($ a ge $ b) sia falsa.

Restituisce vero se l'argomento di sinistra è uguale a stringa dell'argomento di destra. Supponiamo che la variabile $ a contenga "abc" e la variabile $ b contenga "xyz", quindi ($ a eq $ b) sia falsa.

Restituisce vero se l'argomento di sinistra non è uguale all'argomento di destra in senso stringa. Supponiamo che la variabile $ a contenga "abc" e la variabile $ b contenga "xyz", quindi ($ a ne $ b) sia vera.

Restituisce -1, 0 o 1 a seconda che l'argomento di sinistra sia inferiore, uguale o maggiore dell'argomento di destra in senso stringa. Supponiamo che la variabile $ a contenga "abc" e la variabile $ b contenga "xyz" quindi ($ a cmp $ b) sia -1.

Operatore di assegnazione AND esponenziale, esegue il calcolo esponenziale (potenza) sugli operatori e assegna un valore all'operando sinistro. $ c ** = $ a è equivalente a $ c = $ c ** $ a

Racchiude una stringa con virgolette singole. q {abcd} restituisce "abcd"

Racchiude una stringa tra virgolette doppie. qq {abcd} restituisce "abcd"

Racchiude una stringa con virgolette invertite. qx {abcd} restituisce `abcd`

L'operatore binario punto (.) Concatena due stringhe. Se $ a = "abc", $ b = "def" allora $ a. $ B darà "abcdef"

L'operatore di ripetizione x restituisce una stringa composta dall'operando sinistro ripetuto il numero di volte specificato dall'operando destro. ('-' x 3) darà ---.

L'operatore di intervallo .. restituisce un elenco di valori contando (aumentando di uno) dal valore sinistro al valore destro. (2..5) darà (2, 3, 4, 5).

L'operatore Incremento automatico aumenta il valore intero di uno. $ a ++ darà 11.

L'operatore di decremento automatico riduce il valore intero di uno. $ a−− darà 9

L'operatore freccia viene utilizzato principalmente per dereferenziare un metodo o una variabile da un oggetto o dal nome di una classe. $ obj -> $ a è un esempio per accedere alla variabile $ a dall'oggetto $ obj.

funzione localtime (), che restituisce valori per la data e l'ora correnti se non vengono forniti argomenti.

#!/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";

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

16 Feb Sat

La funzione gmtime () funziona esattamente come la funzione localtime () ma i valori restituiti sono localizzati per il fuso orario standard di Greenwich. Quando viene chiamato nel contesto della lista, $ isdst, l'ultimo valore restituito da gmtime, è sempre 0. Non esiste l'ora legale in GMT.

localtime () restituirà l'ora locale corrente sulla macchina che esegue lo script e gmtime () restituirà l'ora universale di Greenwich, o GMT (o UTC).

È possibile utilizzare la funzione time () per ottenere l'ora dell'epoca, ovvero il numero di secondi trascorsi da una determinata data, in Unix è il 1 gennaio 1970.

È possibile utilizzare la funzione POSIX strftime () per formattare la data e l'ora.

La forma generale della definizione di una subroutine nel linguaggio di programmazione Perl è la seguente:

sub subroutine_name{
   body of the subroutine
}

Il modo tipico di chiamare quella subroutine Perl è il seguente:

subroutine_name( list of arguments );

possono essere acceduti all'interno della funzione utilizzando lo speciale array @_. Pertanto il primo argomento della funzione è in $ _ [0], il secondo in $ _ [1] e così via.

utilizzando scalare (@_), possiamo ottenere il numero totale di argomenti passati.

L'operatore my confina una variabile a una particolare regione di codice in cui è possibile utilizzarla e accedervi. Al di fuori di tale regione, non è possibile utilizzare o accedere a questa variabile.

Per impostazione predefinita, tutte le variabili in Perl sono variabili globali, il che significa che è possibile accedervi da qualsiasi punto del programma.

Le variabili lessicali sono variabili private create utilizzando il mio operatore.

Il locale viene utilizzato quando il valore corrente di una variabile deve essere visibile alle subroutine chiamate.

Un locale fornisce solo valori temporanei alle variabili globali (che significa pacchetto). Questo è noto come ambito dinamico.

Lo scoping lessicale viene eseguito con il mio operatore. Uno scope lessicale è solitamente un blocco di codice con una serie di parentesi graffe intorno, come quelle che definiscono il corpo della subroutine o quelle che contrassegnano i blocchi di codice delle istruzioni if, while, for, foreach ed eval. L'operatore my confina una variabile a una particolare regione di codice in cui è possibile utilizzarla e accedervi. Al di fuori di tale regione, non è possibile utilizzare o accedere a questa variabile.

Esistono un altro tipo di variabili lessicali, che sono simili alle variabili private ma mantengono il loro stato e non vengono reinizializzate su più chiamate delle subroutine. Queste variabili sono definite utilizzando l'operatore di stato e sono disponibili a partire da Perl 5.9.4.

Il contesto di una subroutine o di un'istruzione è definito come il tipo di valore restituito previsto. Ciò consente di utilizzare una singola funzione che restituisce valori diversi in base a ciò che l'utente si aspetta di ricevere. Ad esempio, il seguente localtime () restituisce una stringa quando viene chiamato in contesto scalare, ma restituisce un elenco quando viene chiamato nel contesto di elenco.

my $datestring = localtime( time );

In questo esempio, il valore di $ timestr è ora una stringa composta dalla data e dall'ora correnti, ad esempio Thu Nov 30 15:21:33 2000. Viceversa -

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

Ora le singole variabili contengono i valori corrispondenti restituiti dalla subroutine localtime ().

Un riferimento Perl è un tipo di dati scalare che contiene la posizione di un altro valore che potrebbe essere scalare, array o hash. A causa della sua natura scalare, un riferimento può essere utilizzato ovunque, uno scalare può essere utilizzato.

È possibile creare un riferimento per qualsiasi variabile anteponendogli una barra rovesciata come segue:

$scalarref = \$foo;

È possibile creare un riferimento per qualsiasi array anteponendolo con una barra rovesciata come segue:

$arrayref  = \@ARGV;

Puoi creare un riferimento per qualsiasi hash anteponendolo con una barra rovesciata come segue:

$hashref   = \%ENV;

È possibile creare un riferimento per qualsiasi subrouting anteponendolo con una barra rovesciata come segue:

$cref = \&PrintHash;

Dereferencing restituisce il valore da un punto di riferimento alla posizione.

Per dereferenziare un riferimento è sufficiente utilizzare $, @ o% come prefisso della variabile di riferimento a seconda che il riferimento punti a uno scalare, un array o un hash.

Un riferimento circolare si verifica quando due riferimenti contengono un riferimento reciproco. Devi stare attento durante la creazione dei riferimenti altrimenti un riferimento circolare può portare a perdite di memoria. Di seguito è riportato un esempio:

#!/usr/bin/perl
my $foo = 100;
$foo = \$foo;
 
print "Value of foo is : ", $$foo, "\n";

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

Value of foo is : REF(0x9aae38)

Di seguito è riportata la sintassi per aprire file.txt in 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.

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, $!";

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

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

Per chiudere un filehandle, e quindi disassociare il filehandle dal file corrispondente, si utilizza la funzione close. Questo svuota i buffer del filehandle e chiude il descrittore di file del sistema.

La funzione getc restituisce un singolo carattere dal FILEHANDLE specificato o STDIN se non ne viene specificato nessuno.

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.