/ 
POD2-IT-0.13
River stage zero No dependents
/ IT::perlvar

NOME

perlvar - Variabili predefinite in Perl

DESCRIZIONE

Nomi Predefiniti

I nomi illustrati in seguito hanno un significato particolare in Perl. La maggior parte dei nomi con caratteri di punteggiatura sono ragionevolmente memorizzabili, oppure hanno degli analoghi nelle shell. Tuttavia, se desiderate utilizzare nomi lunghi per le variabili, non avete che da dichiarare

use English;

all'inizio del programma. Questa direttiva fa in modo da creare un alias di tutti i nomi corti ai corrispondenti nomi lunghi, all'interno del pacchetto corrente. Alcune variabili hanno perfino dei nomi di media lunghezza, generalmente presi a prestito da awk. In generale è meglio utilizzare la direttiva modificata

use English '-no_match_vars';

se non avete bisogno di $PREMATCH, $MATCH o $POSTMATCH, poichè in questo modo si evita una degradazione delle prestazioni nell'utilizzo delle espressioni regolari. Consultate English per maggiori dettagli.

Le variabili che dipendono dal filehandle selezionato in un dato momento possono essere impostate anche chiamando un metodo appropriato sull'oggetto IO::Handle, sebbene ciò risulti meno efficiente rispetto ad utilizzare le normali variabili interne. (Per gli aspetti collegati, le righe di sommario nel seguito del documento contengono la parola HANDLE). Prima di tutto dovete dichiarare

use IO::Handle;

dopo di che potete utilizzare

metodo HANDLE ESPRESSIONE

o, in maniera più sicura,

HANDLE->metodo(ESPRESSIONE)

Ciascun metodo restituisce il vecchio valore dell'attributo di IO::Handle. Ciascun metodo supporta una ESPRESSIONE opzionale che, se fornita, specifica il nuovo valore per l'attributo IO::Handle in questione. Se non viene fornita, invece, la maggior parte dei metodi non altera il valore corrente -- eccetto autoflush(), che assumerà che sia stato passato un 1 al posto vostro, tanto per essere differente.

Poichè caricare la classe IO::Handle è un'operazione costosa, è meglio che impariate come utilizzare le variabili interne normali.

Alcune di queste variabili sono considerate "di sola lettura". Ciò significa che se provate ad assegnare loro un valore, direttamente o indirettamente attraverso un riferimento, vi ritroverete con un'eccezione a run-time.

Dovete prestare particolare attenzione quando modificate il valore di default della maggior parte delle variabili speciali descritte in questo documento. Nella maggior parte dei casi sarà meglio che localizziate queste variabili prima di cambiarle, perchè altrimenti il cambiamento potrebbe alterare il funzionamento di altri moduli che si basano sui valori di default. Ecco ad esempio il modo corretto per leggere un file tutto in una volta:

open my $fh, "pippo" or die $!;
local $/; # abilita la modalita' "risucchio" localizzata
my $contenuto = <$fh>;
close $fh;

Al contrario, quanto segue è da evitare:

open my $fh, "pippo" or die $!;
undef $/; # abilita la modalita' "risucchio"
my $contenuto = <$fh>;
close $fh;

poichè qualche altro modulo potrebbe voler leggere i dati da qualche file in ingresso nella modalità "per linea" di default , così se abbiamo già eseguito il codice presentato, il valore globale di $/ è stato cambiato per qualsiasi altro pezzo di codice eseguito all'interno del medesimo interprete Perl.

Di solito, quando una variabile è localizzata, è buona norma assicurarsi che questo cambiamento abbia impatto nello scope più ristretto possibile. Per questo motivo, a meno che non vi troviate già all'interno di un blocco {} breve, dovreste crearne uno appositamente. Ad esempio:

my $contenuto = '';
open my $fh, "pippo" or die $!;
{
    local $/;
    $contenuto = <$fh>;
}
close $fh;

Ecco un esempio di come il vostro codice può rovinare tutto:

for (1..5){
    diversione_pericolosa();
    print "$_ ";
}
sub diversione_pericolosa {
    $_ = 5;
    # qui si fa qualcosa con $_
}

Probabilmente vi aspettate che sia stampato:

1 2 3 4 5

ma vi ritrovate con:

5 5 5 5 5

Perchè? Per il motivo che diversione_pericolosa() modifica $_ senza prima localizzarla. La soluzione consiste nell'utilizzare local():

local $_ = 5;

È facile notare il problema in un esempio così breve, ma in codice più complesso andate a caccia di guai se non localizzate i cambiamenti delle variabili speciali.

La lista che segue è ordinata inserendo prima le variabili scalari, poi gli array, poi le hash.

$ARG
$_

L'ingresso e lo spazio per la ricerca di una espressione regolare predefiniti. Le seguenti coppie di righe di codice sono equivalenti:

while (<>) {...}	# equivalenti solo con while!
while (defined($_ = <>)) {...}

/^Subject:/
$_ =~ /^Subject:/

tr/a-z/A-Z/
$_ =~ tr/a-z/A-Z/

chomp
chomp($_)

Quelli che seguono sono i posti dove Perl assumerà di dover lavorare su $_ anche se non l'avete dichiarato esplicitamente:

  • Varie funzioni unarie, incluse ord() ed int(), così come tutti i test sui file (-f, -d) ad eccezione di -t, che per default lavora su STDIN.

  • Varie funzioni su liste come print() e unlink().

  • Gli operatori di pattern matching m//, s/// e tr///, quando utilizzati senza l'operatore =~.

  • La variabile di iterazione di default in un ciclo foreach se non viene specificata nessun'altra variabile.

  • La variabile di iterazione implicita nelle funzioni grep() e map().

  • La destinazione di default dove inserire un record in ingresso quando il risultato di un'operazione <FH> viene utilizzato come unico criterio di test in un ciclo while. Al di fuori di un test per un ciclo while questo comportamento non ha luogo.

(Memo: sottolineato è compreso in certe operazioni.)

$a
$b

Variabili di pacchetto speciali associate all'utilizzo di sort(), come da "sort" in perlfunc. A causa di questa loro peculiarità, $a e $b non necessitano di dichiarazione preventiva (con use vars o our), anche quando è in atto la direttiva strict 'vars'. Non create variabili lessicali con my $a o my $b se volete essere in grado di utilizzarle nel blocco o nella funzione di comparazione di sort().

$<cifre>

Contiene il sotto-pattern proveniente dalla corrispondente coppia di parentesi di cattura dall'ultimo pattern match, senza contare pattern verificati in blocchi più interni dai quali si è già usciti. (Memo: come \cifre.) Queste variabili sono tutte in sola lettura e vengono ristrette dinamicamente al BLOCCO corrente.

$MATCH
$&

La stringa che ha verificato il pattern match più recente (senza contare quanto avvenuto di nascosto in un BLOCCO o in una eval() racchiusi dal BLOCCO corrente). (Memo: come & in alcuni editor). Questa variabile è in sola lettura e ristretta dinamicamente al BLOCCO corrente.

L'utilizzo di questa variabile in un qualsiasi posto nel programma ha come conseguenza una considerevole diminuzione di prestazioni su tutte le applicazioni di espressioni regolari. Consultate la sezione BUG.

$PREMATCH
$`

La stringa che precede ciò che è stato verificato dall'ultimo pattern match effettuato con successo (senza contare quanto avvenuto di nascosto in un BLOCCO o in una eval() racchiusi dal BLOCCO corrente). (Memo: ` spesso PRECEDE una stringa di citazione). Questa variabile è in sola lettura.

L'utilizzo di questa variabile in un qualsiasi posto nel programma ha come conseguenza una considerevole diminuzione di prestazioni su tutte le applicazioni di espressioni regolari. Consultate la sezione BUG.

$POSTMATCH
$'

La stringa che segue ciò che è stato verificato dall'ultimo pattern match effettuato con successo (senza contare quanto avvenuto di nascosto in un BLOCCO o in una eval() racchiusi dal BLOCCO corrente). (Memo: ' spesso SEGUE una stringa di citazione). Esempio:

local $_ = 'abcdefghi';
/def/;
print "$`:$&:$'\n";  	# stampa abc:def:ghi

Questa variabile è in sola lettura e ristretta dinamicamente al BLOCCO corrente.

L'utilizzo di questa variabile in un qualsiasi posto nel programma ha come conseguenza una considerevole diminuzione di prestazioni su tutte le applicazioni di espressioni regolari. Consultate la sezione BUG.

$LAST_PAREN_MATCH
$+

Il testo corrispondente all'ultima alternativa nell'ultima ricerca di pattern effettuata con successo. Risulta particolarmente utile quando non sapete quale sia stata verificata fra una rosa di alternative. Ad esempio:

/Versione: (.*)|Revisione: (.*)/ && ($rev = $+);

(Memo: sii positivo e guarda avanti.)

Questa variabile è in sola lettura e ristretta dinamicamente al BLOCCO corrente.

$^N

Il testo corrispondente al gruppo utilizzato e chiuso più di recente (ossia, il gruppo che ha la parentesi di chiusura più a destra) dell'ultima ricerca di pattern che ha avuto successo. (Memo: la (possibilmente) parentesi iNnestata che si è chiusa più di recente).

È principalmente utilizzata all'interno di blocchi (?{...}) per esaminare il testo che ha verificato il pattern più di recente. Ad esempio, per catturare il testo in una variabile in maniera efficace (al di là di $1, $2, ecc.), potete rimpiazzare (...) con

(?:(...)(?{ $var = $^N }))

Impostando e poi utilizzando $var in questo modo vi toglie dall'impaccio di preoccuparvi di quale sia l'esatto numero del gruppo di parentesi che vi interessa.

Questa variabile è in sola lettura e ristretta dinamicamente al BLOCCO corrente.

@LAST_MATCH_END
@+

Questo array contiene gli spostamenti dei punti terminali degli ultimi sotto-match avvenuti con successo all'interno dello scope dinamico correntemente attivo. $+[0] è lo spostamento nella stringa della fine del match intero stesso. Ciò corrisponde allo stesso valore restituito dalla funzione pos() quando viene chiamata sulla variabile oggetto dell'ultimo match. L'elemento nesimo di questo array contiene lo spostamento del sotto-match nesimo, quindi $+[1] è lo spostamento dove termina $1, $+[2] lo spostamento dove termina $2 e così via. Potete utilizzare $#+ per determinare quanti sottogruppi erano presenti nell'ultimo pattern match che ha avuto successo. Consultate anche gli esempi dati per la variabile @-.

$*

Impostate questa variabile ad un valore intero non nullo per effettuare match multilinea in una stringa, a 0 (o undef) per dire a Perl che può assumere che le stringhe contengono linee singole, in modo da ottimizzare le ricerche di espressioni regolari. Pattern match su stringhe che contengono caratteri "a capo" multipli possono produrre risultati confusi quando $* è 0 o undef. Per default il valore di questa variabile è undef. (Memo: * corrisponde a varie cose). Questa variabile influenza solo l'interpretazione di ^ e $. Un "a capo" letterale può essere ricercato anche quando $* == 0.

L'utilizzo di $* è deprecato nel Perl moderno, soppiantato dai modificatori /s e /m nel pattern matching.

Assegnando un valore non numerico a $* comporta un avvertimento testuale (e fa sì che $* si comporti come se $* == 0), mentre assegnando un valore numerico comporta l'applicazione implicita della funzione int().

HANDLE->input_line_number(ESPRESSIONE)
$INPUT_LINE_NUMBER
$NR
$.

Il numero di linea corrente per l'ultimo filehandle utilizzato.

Ciascun filehandle in Perl tiene conto del numero di linee che sono stati letti. (Dipendentemente dal valore di $/, l'idea di Perl di cosa sia una linea potrebbe non corrispondere alla vostra). Quando viene letta una riga da un filehandle (attraverso readline o <>), o quando tell() o seek() sono chiamate sul filehandle stesso, $. diviene un alias per il contatore di linea del filehandle stesso.

Potete modificare il contatore assegnando un nuovo valore a $., ma ciò non sposterà il puntatore all'interno del filehandle. Localizzare $. non localizza il contatore di linea del filehandle. Piuttosto, localizzerà la visione interna di perl di quale filehandle $. stia puntando al momento.

$. viene riazzerato quando il filehandle viene chiuso, ma non quando un filehandle aperto viene riaperto senza che ci sia stata una close(). Per maggiori dettagli, consultate "Operatori di I/O" in perlop. Poichè <> non porta mai a chiusure esplicite, i numeri di linea si incrementano attraverso i file di ARGV (ma controllate gli esempi in perlfunc/eof).

Potete anche utilizzare solamente HANDLE->input_line_number(ESPRESSIONE> per accedere al contatore di linea di un dato filehandle senza dovervi preoccupare di quale sia l'handle acceduto più di recente.

(Memo: molti programmi usano "." per intendere il numero di linea corrente).

IO::Handle->input_record_separator(ESPRESSIONE)
$INPUT_RECORD_SEPARATOR
$RS
$/

Il separatore di record di ingresso, "a capo" per default. Questa variabile influenza l'idea di Perl su cosa sia una "linea". Funziona in maniera simile alla variabile RS di awk, incluso il trattare righe vuote come terminatrici quando la variabile è impostata alla stringa vuota. (Una riga vuota non può contenere spazi o tabulazioni). Potete impostare il valore di questa variabile ad una stringa con più caratteri per ottenere un terminatore con più caratteri, o ad undef per leggere fino alla fine del file. Impostarla a "\n\n" ha un significato leggermente differente rispetto a "" nel caso che il file contenga linee vuote consecutive. Impostare "" significa trattare due o più linee vuote consecutive con un terminatore unico, mentre impostare "\n\n" significa ciecamente che il prossimo carattere in ingresso appartiene al prossimo paragrafo, anche se è di nuovo un "a capo". (Memo: / delimita le righe quando si scrivono le poesie)

local $/;           # abilita la modalitE<agrave> "risucchio"
local $_ = <FH>;    # ora c'e` tutto il file qui
s/\n[ \t]+/ /g;

Ricordate: il valore di $/ è una stringa, non un'espressione regolare. awk doveva pur essere migliore in qualcosa. :-)

Impostando $/ ad un riferimento ad un intero, ad uno scalare che contiene un intero, o ad uno scalare che può essere convertito in un intero, farà in modo che si cerchi di leggere record invece che linee, laddove la massima dimensione per un record è quella del valore intero puntato dal riferimento. Per cui quanto segue:

local $/ = \32768; # o \"32768", o \$variabile_contenente_32768
open my $fh, $myfile or die $!;
local $_ = <$fh>;

leggerà un record di non più di 32768 byte da FILE. Se non state leggendo da un file orientato al record (oppure il vostro sistema operativo non ha file orientati al record), allora molto probabilmente vi ritroverete con un bel pezzo di dati ad ogni lettura. Se un record è più grande della dimensione del record che avete impostato vi ritroverete il record a pezzetti.

Su VMS, le letture orientate al record sono effettuate con l'equivalente di sysread(), per cui è buona norma evitare di mischiare letture di record e letture non di record sullo stesso file. (Difficilmente sarà un problema, perchè un qualsiasi file che volete leggere in modalità record è probabilmente inutilizzabile in modalità linea). I sistemi non-VMS effettuano l'I/O normalmente, per cui è sicuro mischiare letture di record e non record di un file.

Consultate anche "Newlines" in perlport e $..

HANDLE->autoflush(ESPRESSIONE)
$OUTPUT_AUTOFLUSH
$|

Se impostato ad un valore non nullo, forza un flush [svuotamento del buffer di scrittura, N.d.T.] immediato e dopo ciascuna scrittura o print() sul canale di uscita correntemente selezionato. Per default è 0 (indipendentemente dal fatto che il canale sia effettivamente bufferizzato o meno; $| vi dice solamente se avete chiesto esplicitamente a Perl di effettuare un flush dopo ogni scrittura). STDOUT sarà tipicamente bufferizzato alla riga se l'uscita è verso un terminale e bufferizzato al blocco altrimenti. Impostare questa variabile è principalmente utile quando state inviando dati ad una pipe o ad un socket, come quando state facendo girare un programma Perl sotto rsh e volete vedere l'output appena viene generato. Questa variabile non ha alcun effetto sul buffering in ingresso. Consultate perlfunc/getc per questo. (Memo: quando volete che le vostre tubature [pipe in inglese, che è lo stesso nome del carattere |, N.d.T.] scarichino pesante).

IO::Handle->output_field_separator ESPRESSIONE
$OUTPUT_FIELD_SEPARATOR
$OFS
$,

Il separatore dei campi di uscita per l'operatore print(). Se definito, questo valore viene stampato fra ogni parametro passato a print(). Per default è undef. (Memo: ciò che viene stampato quando c'è una "," nell'istruzione di print()).

IO::Handle->output_record_separator ESPRESSIONE
$OUTPUT_RECORD_SEPARATOR
$ORS
$\

Il separatore dei record di uscita per l'operatore print(). Se definito, questo valore è stampato dopo l'ultimo dei parametri di print(). Per default è undef. (Memo: impostate $\ invece di aggiungere "\n" alla fine della print(). Inoltre, è più o meno come $/, ma è ciò che vi viene dato "dietro" da Perl [gioco di parole intraducibile, perchè "dietro" in inglese è "back", come in "backslash" che è il carattere \, N.d.T.]).

$LIST_SEPARATOR
$"

È come $, eccetto che si applica ad array e valori slice interpolati all'interno di una stringa in virgolette doppie (o stringhe che vengono interpretate analogamente a virgolette doppie). Per default è uno spazio. (Memo: ovvio, penso).

$SUBSCRIPT_SEPARATOR
$SUBSEP
$;

Il separatore di pedice per l'emulazione di array multidimensionali. Se vi riferite ad un elemento di una hash come segue

$pippo{$a,$b,$c}

in realtà state intendendo

$pippo{join($;, $a, $b, $c)}

Ma non mettete

@pippo{$a,$b,$c}	# una slice -- notare il carattere "@"

che significa

($pippo{$a},$pippo{$b},$pippo{$c})

Per default è "\034", lo stesso di SUBSEP in awk. Se le vostre chiavi contengono dati binari potrebbe non esistere un valore sicuro per $;. (Memo: la virgola (il separatore sintattico dei pedici) è un mezzo punto-e-virgola. Lo so, è piuttosto stupido come memo, ma $, è già preso per qualcosa di più importante).

Prendete comunque in considerazione l'utilizzo degli array multidimensionali "reali" descritti in perllol.

$#

Il formato di uscita per i numeri stampati. Questa variabile è un tentativo un po' goffo di emulare la variabile OFMT di awk. Ci sono volte, però, in cui awk e Perl hanno differenti punti di vista su cosa sia da considerare "numerico". Il valore iniziale è "%.ng", ove n è il valore della macro DBL_DIG dall'header file float.h del vostro sistema. In questo differisce da awk, in cui OFMT ha valore di default "%.6g", per cui avrete bisogno di impostare $# esplicitamente per avere il valore di awk. (Memo: # è il segno per i numeri).

L'utilizzo di $# è deprecato.

HANDLE->format_page_number(ESPRESSIONE)
$FORMAT_PAGE_NUMBER
$%

Il numero di pagina corrente nel canale di uscita selezionato al momento. Utilizzato con i format. (Memo: % è il numero di pagina in nroff).

HANDLE->format_lines_per_page(ESPRESSIONE)
$FORMAT_LINES_PER_PAGE
$=

La lunghezza di pagina corrente (in termini di linee stampabili) del canale di uscita selezionato al momento. Per default vale 60. Utilizzato con i format. (Memo: = ha righe orizzontali).

HANDLE->format_lines_left(ESPRESSIONE)
$FORMAT_LINES_LEFT
$-

Il numero di righe rimaste sulla pagina del canale di uscita selezionato al momento. Utilizzato con i format. (Memo: linee_sulla_pagina - linee_stampate).

@LAST_MATCH_START
@-

$-[0] è lo scostamento dell'inizio dell'ultimo match avvenuto con successo. $-[n] è lo scostamento dell'inizio della sottostringa "colpita" dal sotto-pattern nesimo, o undef se il sotto-pattern non è stato verificato.

Per questo motivo dopo un match su $_, $& coincide con substr $_, $-[0], $+[0] - $-[0]. Similmente, $n coincide con substr $_, $-[n], $+[n] - $-[n] se $-[n] è definito e $+ coincide con substr $_, $-[$#-], $+[$#-] - $-[$#-]. Si può utilizzare $#- per trovare l'ultimo sottogruppo "colpito" nell'ultimo match che ha avuto successo. Confrontatelo con $#+, il numero di sottogruppi dell'espressione regolare. Confrontatelo con @+.

Questo array contiene gli scostamenti degli inizi dei sotto-match che hanno avuto successo più di recente nello scope dinamico attivo al momento. $-[0] è lo scostamento nella stringa dell'inizio del match intero. L'elemento nesimo di questo array contiene lo scostamento del sotto-match nesimo, per cui $-[1] è lo scostamento dove inizia $1, $-[2] è lo scostamento dove inizia $2 e così via.

Dopo un match su una variabile qualsiasi $var:

$` è uguale a substr($var, 0, $-[0])
$& è uguale a substr($var, $-[0], $+[0] - $-[0])
$' è uguale a substr($var, $+[0])
$1 è uguale a substr($var, $-[1], $+[1] - $-[1])
$2 è uguale a substr($var, $-[2], $+[2] - $-[2])
$3 è uguale a substr($var, $-[3], $+[3] - $-[3])
HANDLE->format_name(ESPRESSIONE)
$FORMAT_NAME
$~

Il nome del formato di report corrente per il canale di uscita selezionato al momento. Per default è il nome del filehandle. (Memo: fratello di $^).

HANDLE->format_top_name(ESPRESSIONE)
$FORMAT_TOP_NAME
$^

Il nome del formato di inizio-pagina per il canale di uscita selezionato al momento. Per default è il nome del filehandle con _TOP aggiunto alla fine. (Memo: punta all'inizio della pagina).

IO::Handle->format_line_break_characters ESPRESSIONE
$FORMAT_LINE_BREAK_CHARACTERS
$:

L'insieme di caratteri corrente dopo i quali una stringa può essere interrotta per riempire i campi di continuazione (che iniziano con ^) in un format. Per default è " \n-", per interrompere su spazi vuoti e "-". (Memo: una "colonna" [":" in inglese si chiama colon, N.d.T.] in poesia è una parte di una linea).

IO::Handle->format_formfeed ESPRESSIONE
$FORMAT_FORMFEED
$^L

Ciò che viene stampato come form feed [carattere di avanzamento, N.d.T.] dai format. Per default è \f.

$ACCUMULATOR
$^A

Il valore corrente dell'accumulatore write() per le righe di format(). Un format contiene un numero formline() di chiamate che inseriscono il proprio risultato in $^A. Dopo aver chiamato il proprio format, write() stampa il contenuto di $^A e lo svuota. Per questo motivo non vedrete mai il contenuto di $^A a meno che non chiamiate formline() per conto vostro e poi andate a vederne il valore. Consultate perlform e "formline()" in perlfunc.

$CHILD_ERROR
$?

Lo stato restituito dall'ultima operazione di chiusura di una pipe, comando backtick (``), chiamata con successo a wait() o waitpid(), o dall'operatore system(). Contiene la parola a 16 bit di stato restituita dalla chiamata wait() (o perlomeno è costruita in modo da assomigliarle). Per questo motivo, il valore di uscita del sottoprocesso in realtà è ($? >> 8), e $? & 127 indica quale segnale, se ce n'è stato, ha causato la terminazione del processo, mentre $? & 128 indica se c'è stato un core dump. (Memo: simile alle shell sh e ksh)

In più, se la variabile h_errno è supportata in C, il suo valore viene restituito via $? se una qualsiasi funzione della famiglia gethost*() fallisce.

Se avete installato un handler di segnale per SIGCHLD, il valore di $? sarà generalmente sbagliato al di fuori dell'handler stesso.

All'interno di una subroutine END, $? contiene il valore che verrà passato ad exit(). Potete modificare $? in una subroutine END per cambiare lo stato di uscita del vostro programma. Ad esempio:

END {
    $? = 1 if $? == 255;  # die lo imposta a 255
}

Sotto VMS, la direttiva use vmsish 'status' fa sì che $? rifletta il valore di uscita VMS reale, invece che quello di emulazione POSIX che si avrebbe di default; consultate "$?" in perlvms per i dettagli.

Consultate anche "Indicatori di Errore".

${^ENCODING}

Il riferimento-oggetto all'oggetto Encode che è utilizzato per convertire il codice sorgente in Unicode. Grazie a questa variabile il vostro script perl non ha bisogno di essere scritto in UTF-8. Per default è undef. La manipolazione diretta di questa variabile è caldamente scoraggiata. Consultate anche encoding per maggiori dettagli.

$OS_ERROR
$ERRNO
$!

Se utilizzata numericamente, restituisce il valore corrente della variabile C errno, o, in altre parole, se una chiamata di sistema o di libreria fallisce, imposta questa variabile. Ciò significa che il valore di $! ha senso solo immediatamente dopo un fallimento:

    if (open(FH, $nomefile)) {
        # Qui $! non ha senso.
	...
    } else {
        # SOLO qui $! ha senso.
	...
        # Gia' qui $! potrebbe aver perso ogni senso.
    }
    # Poiche' qui potremmo aver avuto un successo o un fallimento,
    # qui $! non ha senso.

Nell'esempio non ha senso indica qualunque valore: zero, non zero, undef. Una chiamata di sistema o di libreria completata con successo non imposta la variabile a zero.

Se utilizzata come una stringa, restituisce la corrispondente stringa di errore di sistema. Potete assegnare un valore numerico n a $! per impostare errno se, ad esempio, volete che "$!" restituisca la stringa per l'errore n, o se volete impostare il valore di uscita per l'operatore die(). (Memo: cos'è che è appena esploso? [il carattere "!" è anche detto "bang" in inglese, e "bang" è il nome onomatopeico per l'esplosione, N.d.T.]).

Consultate anche "Indicatori di Errore".

%!

Ciascun elemento di %! ha un valore "vero" solo se $! è impostato al dato valore. Ad esempio, $!{ENOENT} è vera se e solo se il valore corrente di $! è ENOENT; in altri termini, se l'errore occorso più di recente è stato "No such file or directory" ["Nome di file o directory inesistente", N.d.T.] (o il suo equivalente "morale": non tutti i sistemi operativi danno questo errore con questa stringa esatta, e sicuramente non tutte le lingue). Per verificare se una particolare chiave ha senso nel vostro sistema, utilizzate exists $!{la_chiave}; per una lista di chiavi ammissibili utilizzate keys %!. Consultate Errno per maggiori informazioni, e consultate quanto detto sopra circa la validità di $!.

$EXTENDED_OS_ERROR
$^E

Informazione di errore specifica per il sistema operativo in uso. Al momento, il valore di questa variabile differisce da $! solo sotto VMS, OS/2 e Win32 (e per MacPerl). Su tutte le altre piattaforme, $^E è sempre semplicemente uguale a $!.

Sotto VMS, c<$^E> fornisce il valore di status VMS risultante dall'ultimo errore di sistema. Tale informazione risulta un'indicazione più specifica sull'ultimo errore di sistema rispetto a quella data da $!. Ciò risulta particolarmente importante quando $! è impostato a EVMSERR.

Sotto OS/2, $^E è impostata al codice di errore dell'ultima chiamata all'API OS/2 o attraverso CRT o direttamente da perl.

Sotto Win32, $^E restituisce sempre l'ultima informazione di errore riportata dalla chiamata Win32 GetLastError(), che descrive l'ultimo errore riportato dall'interno dell'API Win32. La maggior parte del codice specifico per Win32 riporterà i propri errori attraverso $^E. Le chiamate C ANSI e quelle di tipo Unix impostano errno e per questo motivo il codice Perl più portabile riporterà gli errori attraverso $!.

Le avvertenze date nella descrizione di $! si applicano, in generale, anche a $^E. (Memo: spiegazione di errore Extra).

Consultate anche "Indicatori di Errore".

$EVAL_ERROR
$@

Il messaggio di errore di sintassi di Perl risultante dall'ultimo operatore eval(). Se $@ è la stringa vuota, l'ultima chiamata a eval() è stata interpretata ["parsed" nell'originale inglese, N.d.T.] ed eseguita correttamente (per quanto le operazioni invocate potrebbero esser fallite nella maniera usuale). (Memo: "a" che punto era l'errore di sintassi? [il segno "@" in inglese è chiamato "at", che corrisponde alla preposizione "a" italiana, N.d.T.])

I messaggi di avvertimento non sono raccolti da questa variabile. In ogni caso, potete impostare una routine per processare gli avvertimenti impostando $SIG{__WARN__} come descritto in seguito.

Consultate anche "Indicatori di Errore".

$PROCESS_ID
$PID
$$

L'identificativo numerico del processo Perl che sta eseguendo lo script. Questa variabile va considerata in sola lettura, sebbene risulti alterata dalle chiamate a fork(). (Memo: come per le shell).

Nota per gli utenti Linux: in Linux, le funzioni C getpid() e getppid() restituiscono valori differenti da thread differenti. Perchè sia portabile, questo comportamento non è replicato per $$, il cui valore rimane consistente attraverso i thread. Se volete chiamare la getpid() sottostante, potete utilizzare il modulo CPAN Linux::Pid.

$REAL_USER_ID
$UID
$<

L'UID reale di questo processo. (Memo: è l'UID da cui provenite se state utilizzando setuid). Potete cambiare sia l'UID reale che l'UID effettivo in un colpo solo utilizzando POSIX::setuid(). Poichè le modifiche a $< richiedono una chiamata di sistema, controllate $! dopo un tentativo di cambiamento per individuare possibili errori.

$EFFECTIVE_USER_ID
$EUID
$>

L'UID effettivo di questo processo. Ad esempio:

$< = $>;		# Imposta l'UID reale uguale a quello effettivo
($<,$>) = ($>,$<);	# scambia UID reale ed effettivo

Potete cambiare sia l'UID effettivo che quello reale allo stesso tempo utilizzando POSIX::setuid(). I cambiamenti a $> richiedono un controllo su $! per individuare qualsiasi possibile errore conseguente da un tentativo di cambiamento.

(Memo: è l'UID verso il quale siete andati, se state girando setuid). $< e $> possono essere scambiati solo su macchine che supportano setreuid().

$REAL_GROUP_ID
$GID
$(

Il GID reale di questo processo. Se vi trovate su una macchina che supporta l'appartenenza a più gruppi contemporaneamente, restituisce una lista dei gruppi a cui appartenete, con gli elementi separati da spazi. Il primo numero è quello restituito da getgid(), mentre i seguenti sono quelli dati da getgroups(), uno dei quali potrebbe essere uguale al primo valore.

In ogni caso, il valore assegnato a $( deve essere un unico numero utilizzato per impostare il GID reale. Per questo motivo il valore dato da $( non deve essere mai utilizzato per una successiva assegnazione a $( stesso senza che sia stato forzato ad essere un numero, ad esempio mediante una somma con zero.

Potete modificare sia il valore di GID reale che quello effettivo in sol colpo utilizzando POSIX::setgid(). I cambiamenti a $( richiedono un controllo di $! per individuare qualsiasi possibile errore derivante dal tentativo di cambiamento.

(Memo: le parentesi sono utilizzate per raggruppare. Il GID reale è quello che avete lasciato se state girando setgid ["lasciato" in inglese è "left", che vuol dire anche "sinistra", come la parentesi utilizzata per questa variabile, N.d.T.]

$EFFECTIVE_GROUP_ID
$EGID
$)

Il GID effettivo di questo processo. Se vi trovate su una macchina che supporta l'appartenenza a più gruppi contemporaneamente, restituisce una lista dei gruppi a cui appartenete, con gli elementi separati da spazi. Il primo numero è quello restituito da getgid(), mentre i seguenti sono quelli dati da getgroups(), uno dei quali potrebbe essere uguale al primo valore.

In maniera analoga, un valore assegnato a $) deve essere anch'esso una lista di valori numerici separati da spazi. Il primo valore va ad impostare il valore del GID effettivo, ed i rimanenti (se presenti) sono passati a setgroups(). Per ottenere una lista vuota per setgroups() vi basterà ripetere il GID effettivo nuovo; ossia, per forzare un GID effettivo pari a 5 e svuotare la lista di setgroups() in maniera efficace, chiamate $) = "5 5" .

Potete cambiare il GID effettivo e quello reale in sol colpo utilizzando la funzione POSIX::setgid() (utilizzate solo un unico argomento numerico). I cambiamenti a $) richiedono un controllo su $! per individuare qualsiasi possibile errore dopo un tentativo di cambiamento.

(Memo: le parentesi sono utilizzate per raggruppare. Il GID effettivo è quello giusto per voi, se state girando setgid ["giusto" in inglese è "right", che vuol dire anche "destra", come la parentesi utilizzata per questa variabile, N.d.T.]).

$<, $>, $( e $) possono essere impostate solo su macchine che supportano le corrispondenti routine set[re][ug]id(). $( e $) possono essere scambiate solo su macchine che supportano setregid().

$PROGRAM_NAME
$0

Contiene il nome del programma in esecuzione.

Su alcuni (attenzione: non tutti) sistemi operativi l'assegnazione a $0 modifica l'area argomenti vista dal programma ps. Su alcune piattaforme potreste dover utilizzare opzioni speciali di ps o un programma ps differente per poter osservare il cambiamento. La modifica di $0 è più utile come mezzo per indicare lo stato corrente del programma che per nascondere il programma stesso. (Memo: uguale a sh e ksh).

Osservate che ci sono limitazione specifiche per ciascuna piattaforma per la lunghezza massima di $0. Nel caso più estremo potrebbe essere limitata allo spazio occupato dal valore originario di $0.

In alcune piattaforme potrebbero esserci padding variabili [aggiunte di caratteri riempitivi all'inizio o alla fine, N.d.T.], ad esempio spazi, dopo il nome modificato così come mostrato da ps. In alcune piattaforme queste aggiunte potrebbero estendersi per la lunghezza originale dell'area argomenti, indipendentemente da quel che potete fare (ad esempio questo è il caso di Linux 2.2).

Nota per gli utenti BSD: impostare $0 non rimuove completamente la stringa "perl" dall'uscita di ps(1). Ad esempio, impostando $0 a "pippopluto" potrebbe risultare in "perl: pippopluto (perl)" (la presenza di entrambe le stringhe "perl: " e " (perl)" dipendono dalla variante e dalla versione esatte di BSD che state utilizzando). Questa è una caratteristica del sistema operativo, Perl non può farci niente.

In script multithread, Perl coordina i thread in modo che ciascuno di essi possa modificare la propria copia di $0 ed il cambiamento diventa visibile in ps(1) (assumendo che il sistema operativo collabori). Notate che quel che gli altri thread vedono di $0 non cambia, perchè ciascuno di essi ha la propria copia di questa variabile.

$[

L'indice del primo elemento in un array, ed il primo carattere in una sottostringa. Per default vale 0, ma potreste teoricamente impostarlo ad 1 per far sì che Perl si comporti similmente a awk (o Fortran) quando indicizzate un array e quando utilizzate le funzioni index() e substr(). (Memo: [ inizia l'indicizzazione di un array).

A partire dalla release 5 di Perl, l'assegnazione alla variabile $[ viene trattata come una direttiva di compilazione, e non può influenzare il comportamento in un qualsiasi altro file. (Per questo motivo potete solamente assegnarle costanti disponibili al tempo di compilazione). Il suo utilizzo è caldamente scoraggiato.

Osservate che, diversamente da altre direttive di compilazione (come strict), l'assegnazione a $[ può essere vista al di fuori dello scope lessicale all'interno dello stesso file. In ogni caso potete utilizzare local() per restringere il suo nuovo valore ad un blocco lessicale.

$]

Il valore di versione e livello di patch / 1000 dell'interprete Perl. Questa variabile può essere utilizzata per determinare se l'interprete Perl che sta eseguendo uno script è compreso in un intervallo di versioni ammissibili. (Memo: questa versione di perl si trova nell'intervallo giusto? [la parentesi quadra chiusa indica la chiusura di un intervallo, N.d.T.]). Esempio:

warn "Niente checksum!\n" if $] < 3.019;

Consultate anche la documentazione di use VERSIONE e require VERSIONE per un modo conveniente di fallire se l'interprete Perl è troppo antiquato.

Quando effettuate i test sulla variabile, per evitare le inaccuratezze derivanti dalla rappresentazione dei reali in virgola mobile è meglio che preferiate dei controlli di diseguaglianza < e > rispetto ai test che contengono uguaglianze: <=, == e >=.

La rappresentazione in virgola mobile può a volte portare a confronti numerici inaccurati. Controllate $^V per una rappresentazione più moderna della versione Perl, che consente di effettuare comparazioni di stringa accurate.

$COMPILING
$^C

Il valore correntemente associato al flag associato all'opzione a linea di comando -c. Principalmente utilizzata con -MO=... per consentire al codice di alterare il proprio comportamento in fase di compilazione, come ad esempio per AUTOLOAD [autocaricare, N.d.T.] in fase di compilazione piuttosto che effettuare in normali caricamenti differiti a tempo di esecuzione. Consultate perlcc. Impostare $^C = 1 è simile a chiamare B::minus_c.

$DEBUGGING
$^D

Il valore corrente dei flag di debugging. (Memo: il valore dell'opzione -D). Può essere letto ed impostato. Come il suo equivalente a linea di comando, potete utilizzare valori numerici o simbolici, ad esempio $^D = 10 oppure $^D = "st".

$SYSTEM_FD_MAX
$^F

Il massimo descrittore di file di sistema, usualmente pari a 2. I descrittori di file di sistema sono passati ai processi eseguiti con exec(), mentre i descrittori di file più alti non lo sono. In più, durante una open(), i descrittori di file di sistema sono preservati anche se open() fallisce. (I descrittori di file ordinari sono chiusi prima di un tentativo di open()). Lo status di close-on-exec [chiudi quando esegui, N.d.T.] verrà deciso in base al valore di $^F quando il file, la pipe o il socket corrispondenti sono stati aperti, non quello trovato al momento della exec().

$^H

ATTENZIONE: questa variabile è strettamente ad uso interno. La sua disponibilità, comportamento e contenuto sono soggetti a variazioni senza preavviso.

Questa variabile contiene suggerimenti per l'interprete Perl utilizzati in fase di compilazione. Alla fine della compilazione di un BLOCCO il valore di questa variabile viene ripristinato a quello di quando l'interprete ha iniziato a compilare il BLOCCO stesso.

Quando perl inizia ad interpretare ["parse" nell'originale inglese, N.d.T.] un qualsiasi costrutto di blocco che dà luogo ad uno scope lessicale (ad esempio il corpo di una eval(), un file incluso con require(), il corpo di una sub, il corpo di un ciclo, o un blocco condizionale), il valore corrente di $^H viene salvato, ma il suo valore è lasciato immodificato. Quando la compilazione del blocco ha avuto termine, viene ripristinato il valore salvato. Fra questi due punti, il codice che viene eseguito all'interno dei blocchi BEGIN è libero di cambiare il valore di $^H.

Questo comportamento è alla base dello scoping lessicale, ed è utilizzato, ad esempio, nella direttiva use strict.

Il contenuto dovrebbe consistere di un intero: i diversi bit sono utilizzati per differenti flag di direttiva. Ecco un esempio:

sub aggiungi_100 { $^H |= 0x100 }

sub pippo {
    BEGIN { aggiungi_100() }
    pluto->topolino($paperino);
}

Considerate quel che accade durante l'esecuzione del blocco BEGIN. A questo punto il blocco BEGIN è già stato compilato, ma il corpo di pippo() è ancora in fase di compilazione. Il nuovo valore di $^H sarà pertanto visibile solo durante la compilazione di pippo().

La sostituzione del blocco BEGIN con questo:

BEGIN { require strict; strict->import('vars') }

dimostra come use strict 'vars' è implementato. Ecco una versione condizionale della stessa direttiva lessicale:

BEGIN { require strict; strict->import('vars') if $condizione }
%^H

ATTENZIONE: questa variabile è strettamente ad uso interno. La sua disponibilità, comportamento e contenuto sono soggetti a variazioni senza preavviso.

La hash %^H fornisce lo stesso raggio semantico di $^H. Ciò la rende utile per implementare direttive lessicalmente ristrette.

$INPLACE_EDIT
$^I

Il valore corrente dell'estensione di modifica diretta di un file. Utilizzate undef per disabilitare questa caratteristica. (Memo: il valore dell'opzione -i).

["inplace-edit" è la caratteristica di Perl di poter agire direttamente su un file che normalmente utilizzerebbe in sola lettura, ad esempio per operare modifiche sul file stesso, N.d.T.].

$^M

Per default, l'errore di "memoria terminata" non può essere impedito e risulta fatale. In ogni caso, se compilato in maniera adeguata, Perl può utilizzare il contenuto di $^M come riserva di memoria di emergenza dopo die(). Supponete che il vostro Perl sia stato compilato con -DPERL_EMERGENCY_SBRK e che utilizzi la malloc() di Perl. Allora

$^M = 'a' x (1 << 16);

allocherebbe un buffer di 64K da utilizzare nelle emergenze. Consultate il file INSTALL nella distribuzione di Perl per informazioni su come aggiungere flag di compilazione personalizzati quando compilate perl. Per scoraggiare l'utilizzo casuale di questa caratteristica avanzata, per questa variabile non esiste un nome lungo corrispondente nel modulo English.

$OSNAME
$^O

Il nome del sistema operativo nel quale è stata compilata questa copia dell'interprete Perl, così come determinato durante il processo di configurazione. Il valore è identico a $Config{'osname'}. Consultate anche Config e l'opzione a linea di comando -V documentata in perlrun.

Nelle piattaforme Windows, $^O non è molto d'aiuto: essa vale infatti sempre MSWin32, e non vi dice la differenza fra 95/98/ME/NT/2000/XP/CE/.NET. Utilizzate Win32::GetOSName() o Win32::GetOSVersion() (consultate Win32 e perlport) per distinguere fra le differenti varianti.

${^OPEN}

Variabile interna utilizzata da PerlIO. Consiste di una stringa formata da due parti, separate da un byte \0. La prima parte descrive i layer [strati, N.d.T.] di ingresso, la seconda quelli di uscita.

$PERLDB
$^P

Variabile interna per il supporto al debugging. Il significato dei vari bit è soggetto a cambiamento, ma al momento indica:

0x01

Debug di ingresso/uscita da subroutine.

0x02

Debug riga-per-riga.

0x04

Disabilita le ottimizzazioni.

0x08

Conserva più dati per future ispezioni interattive.

0x10

Mantieni informazioni sulle linee nel programma sorgente dove una subroutine è definita.

0x20

Inizia con la modalità singolo-passo.

0x40

Utilizza l'indirizzo della subroutine invece del nome quando si stampa.

0x80

Fai rapporto anche di goto &subroutine.

0x100

Fornisci nomi di "file" informativi per eval(), basati sul posto dove sono state compilate.

0x200

Fornisci nomi informativi alle subroutine anonime, basati sul posto dove sono state compilate.

0x400

Debug di ingresso/uscita delle subroutine di asserzione.

Alcuni bit possono essere rilevanti solo in fase di compilazione, alcuni solo in fase di esecuzione. Si tratta di un meccanismo nuovo ed i dettagli potrebbero cambiare.

$LAST_REGEXP_CODE_RESULT
$^R

Il risultato della valutazione dell'ultima asserzione (?{ codice }) in un'espressione regolare eseguita con successo (consultate perlre). Potete assegnarle un valore.

$EXCEPTIONS_BEING_CAUGHT
$^S

Stato corrente dell'interprete.

$^S         State
---------   -------------------
undef       In fase di interpretazione di un modulo o di una eval
vero (1)    In fase di valutazione di una eval
falso (0)   Altrimenti

Il primo stato può essere riscontrato in handler $SIG{__DIE__} e $SIG{__WARN__}.

$BASETIME
$^T

Il tempo al quale è iniziata l'esecuzione del programma, espresso in secondi a partire dalla epoch (inizio del 1970). I valori restituiti dai test su file -M, -A e -C sono basati su questo valore.

${^TAINT}

Riflette se la modalità taint è attiva o meno. Il valore 1 indica che è attiva (il programma è stato lanciato con -T), 0 indica che non è attiva, -1 quando sono abilitati solo gli avvertimenti di taint (ossia con le opzioni -t o -TU).

${^UNICODE}

Riflette lo stato di determinate impostazioni di Unicode di Perl. Consultate la documentazione perlrun riguardo l'opzione -C per maggiori informazioni sui possibili valori. Questa variabili viene impostata all'avvio di Perl ed è pertanto in sola lettura.

${^UTF8LOCALE}

Questa variabile indica se perl ha individuato un locale UTF-8 all'avviamento. Tale informazione viene usata da perl quando è in modalità adegua-uso-utf8-al-locale (come quando si lancia con l'opzione a linea di comando -CL); consultate perlrun per maggiori informazioni.

$PERL_VERSION
$^V

Revisione, versione e sottoversione dell'interprete Perl, rappresentate come stringa composta da caratteri con questi ordinali. Ad esempio, Perl v5.6.0 corrisponde a chr(5) . chr(6) . chr(0) e restituirà un valore vero per il test $^V eq v5.6.0. Notare che i caratteri in questa stringa possono ricadere, potenzialmente, nell'intervallo Unicode.

Questa variabile può essere utilizzata per determinare se l'interprete Perl che sta eseguendo il nostro script ricade nell'intervallo corretto di versioni ammissibili. (Memo: usa ^V per il Controllo Versione). Esempio:

warn "Niente dichiarazioni \"our\"!\n" if $^V and $^V lt v5.6.0;

Per convertire $^V nella sua rappresentazione in forma di stringa utilizzate la conversione "%vd" di sprintf():

printf "la versione e` v%vd\n", $^V;  # versione di Perl

Consultate la documentazione di use VERSIONE e require VERSIONE per un modo conveniente di fallire nel caso che l'interprete Perl che sta eseguendo il vostro script sia troppo datato.

Consultate anche $] per una rappresentazione più obsoleta della versione dell'interprete Perl.

$WARNING
$^W

Il valore corrente dell'impostazione di stampa degli avvertimenti, inizialmente vera se è stato utilizzato -w, falsa altrimenti ma modificabile direttamente. (Memo: correlata all'opzione -w). Consultate anche warnings.

${^WARNING_BITS}

L'insieme attuale di controlli di avvertimento abilitati dalla direttiva use warnings. Consultate la documentazione per warnings per maggiori dettagli.

$EXECUTABLE_NAME
$^X

Il nome utilizzato per eseguire la copia corrente di Perl, presa da argv[0] del C o (laddove supportato) da /proc/self/exe.

Dipendentemente dal sistema operativo ospite, il valore di $^X può essere il percorso relativo o assoluto del file del programma perl, o può essere la stringa utilizzata per chiamare per ma non il percorso del file del programma. In più, la maggior parte dei sistemi operativi consente di eseguire programmi che non sono nella variabile d'ambiente PATH, per cui non c'è garanzia che il valore di $^X sia in PATH. Per il VMS, il valore può includere un numero di versione come può non includerlo.

Di solito potete utilizzare il valore di $^X per richiamare una copia indipendente dello stesso perl che sta girando al momento, ad esempio

@prima_girata = `$^X -le "print int rand 100 for 1..100"`;

Ricordate però che non tutti i sistemi operativi supportano fork() o la cattura dell'uscita dei comandi, per cui questa istruzione complessa potrebbe non essere portabile.

Non è sicuro utilizzare il valore di $^X come percorso di un file, perchè alcuni sistemi operativi che hanno un suffisso obbligatorio per i file eseguibili non richiedono l'uso di questo suffisso quando si lancia un comando. Per convertire il valore di $^X in un percorso utilizzate le seguenti istruzioni:

# Costruisci un insieme di nomi di file (non di nomi di comandi).
use Config;
$questo_perl = $^X;
if ($^O ne 'VMS')
   {$questo_perl .= $Config{_exe}
        unless $questo_perl =~ m/$Config{_exe}$/i;}

Poichè molti sistemi operativi consentono a chiunque con permessi di lettura al programma Perl di farne una copia, modificarla e poi eseguirla, il programmatore Perl che ha attenzione per la sicurezza dovrebbe procedere con cautela per chiamare la copia installata di perl, non quella riferita da $^X. Le istruzioni che seguono raggiungono questo scopo, e producono un percorso che può essere chiamato come comando o riferito come file.

use Config;
$percorso_a_perl_sicuro = $Config{perlpath};
if ($^O ne 'VMS')
   {$percorso_a_perl_sicuro .= $Config{_exe}
        unless $percorso_a_perl_sicuro =~ m/$Config{_exe}$/i;}
ARGV

Il filehandle speciale che itera sui nomi di file della linea di comando contenuti in @ARGV. Usualmente scritto come filehandle vuoto nell'operatore diamante <>. Notate che ARGV corrente ha il suo valore magico solamente all'interno dell'operatore <>; altrove è solo un filehandle come altri, corrispondente all'ultimo file aperto con <>. In particolare, passando \*ARGV come parametro ad una funzione che si aspetta di ricevere un filehandle può far sì che la vostra funzione non legga automaticamente il contenuto di tutti i file in @ARGV.

$ARGV

contiene il nome del file attualmente letto con <>.

@ARGV

L'array @ARGV contiene gli argomenti a linea di comando diretti allo script [ossia intesi per essere passati allo script piuttosto che all'interprete Perl, N.d.T.]. $#ARGV è, generalmente, il numero di argomenti meno uno, perchè $ARGV[0] è il primo argomento, non il nome stesso del programma. Consultate $0 per il nome del comando.

ARGVOUT

Il filehandle speciale che punta al file di uscita attualmente aperto quando si sta effettuando il processamento di modifica in linea con -i. Utile quando dovete effettuare molti inserimenti e non volete continuare a modificare $_. Consultate perlrun ove si descrive l'opzione -i.

@F

L'array @F contiene i campi di ciascuna riga letta quando la modalità di autodivisione è attiva. Consultate perlrun per dettagli sull'opzione -a. Questo array è specifico per pacchetto, e deve essere dichiarato o utilizzato con il nome di pacchetto completo se non vi trovate nel pacchetto main e state lavorando sotto strict 'vars'.

@INC

L'array @INC contiene la lista dei posti dove i costrutti do ESPRESSIONE, require o use vanno a guardare quando cercano i file di libreria. Inizialmente consiste degli argomenti di tutte le opzioni -I a linea di comando, seguite dalla libreria di default di Perl, probabilmente /usr/local/lib/perl, seguite da ".", per rappresentare la directory corrente. ("." non verrà aggiunta se sono attivi i controlli di taint, sia da -T che da -t). Se avete bisogno di modificare questa variabile durante l'esecuzione, dovreste utilizzare la direttiva use lib per far sì da caricare le librerie dipendenti dalla macchina in maniera appropriata:

use lib '/miopercorso/libdir/';
use QualcheMod;

Potete anche inserire degli "agganci" nel sistema di inclusione dei file inserendo codice Perl direttamente in @INC. Questi "agganci" possono essere riferimenti a subroutine, riferimenti ad array o oggetti su cui è stata chiamata bless(). Consultate "require" in perlfunc per i dettagli.

@_

In una subroutine, l'array @_ contiene i parametri passati alla subroutine stessa. Consultate perlsub.

%INC

La hash %INC contiene elementi per ciascun nome di file incluso attraverso gli operatori do, require o use. La chiave è il nome del file che avete specificato (con i nomi dei moduli convertiti a percorsi di file), ed il valore è la posizione del file trovato. L'operatore require utilizza questa hash per determinare se un file particolare è stato già incluso.

Se il file è stato caricato attraverso un "aggancio" (ad esempio un riferimento a subroutine, consultate "require" in perlfunc per una descrizione di questi "agganci"), l'"aggancio" stesso è inserito per default all'interno di %INC al posto di un nome di file. Osservate, comunque, che l'"aggancio" può aver impostato l'elemento in %INC di per se per fornire informazioni più specifiche.

%ENV
$ENV{espressione}

La hash %ENV contiene il vostro ambiente corrente. Impostare un valore in %ENV cambia l'ambiente per tutti i processi figli che genererete da qui in avanti con fork().

%SIG
$SIG{expr}

La hash %SIG contiene gli handler [funzioni di gestione, N.d.T.] per i segnali. Ad esempio:

sub handler {	# Il primo parametro e` il nome del segnale
    my($seg) = @_;
    print "Ricevuto SIG$seg--chiudo tutto\n";
    close(LOG);
    exit(0);
}

$SIG{'INT'}  = \&handler;
$SIG{'QUIT'} = \&handler;
...
$SIG{'INT'}  = 'DEFAULT';	# ripristina l'azione di default
$SIG{'QUIT'} = 'IGNORE';	# ignora SIGQUIT

Utilizzare un valore di 'IGNORE' usualmente ha l'effetto di ignorare il segnale, eccetto che per il segnale CHLD. Consultate perlipc per maggiori dettagli su questo caso particolare.

Ecco alcuni esempi aggiuntivi:

$SIG{"PIPE"} = "Idraulico";   # assume main::Idraulico (sconsigliato)
$SIG{"PIPE"} = \&Idraulico;   # tutto bene, assume l'Idraulico corrente
$SIG{"PIPE"} = *Idraulico;    # un po' esoterico
$SIG{"PIPE"} = Idraulico();   # oops, cosa restituisce Idraulico()?

Assicuratevi di non utilizzare una parola nuda e cruda come nome di un gestore di segnale, a meno che non vogliate chiamarla inavvertitamente.

Se il vostro sistema supporta la funzione sigaction(), allora l'handler di segnale viene installato utilizzandola. Questo significa avere una gestione dei segnali più robusta.

La politica di consegna dei segnali di default è cambiata in Perl 5.8.0 da immediata (anche nota come "insicura") a differita, anche nota come "segnali sicuri". Consultate perlipc per maggiori ragguagli.

Alcuni "agganci" interni possono essere impostati anche utilizzando la hash %SIG. La routine indicata da $SIG{__WARN__} viene chiamata quando si sta per stampare un messaggio di avvertimento. Il messaggio viene passato come primo parametro. La presenza di "agganci" __WARN__ implica la soppressione dell'ordinaria stampa su STDERR. Potete utilizzare questa tecnica per salvare i messaggi di avvertimento in una variabile, o per trasformare questi messaggi in errori fatali, come ad esempio:

local $SIG{__WARN__} = sub { die $_[0] };
eval $programmino;

La routine indicata da $SIG{__DIE__} è chiamata quando si sta per lanciare un'eccezione fatale. Il messaggio di errore viene passato come primo parametro. Quando si esce da una routine "agganciata" __DIE__, il processamento dell'eccezione prosegue come se l'"aggancio" non ci fosse stato, a meno che la routine stessa non esca con un goto, un'uscita da ciclo o un die(). L'handler __DIE__ è esplicitamente disabilitato durante la chiamata, in modo che possiate chiamare die() all'interno dell'handler. Le cose procedono in maniera simile per __WARN__.

A causa di una stortura di implementazione, l'"aggancio" $SIG{__DIE__} viene chiamato anche quando ci si trova in una eval(). Non vi basate su questo fatto per riscrivere un'eccezione pendente in $@, o come bizzarro sostituto per scavalcare CORE::GLOBAL::die(). Questa strana azione a distanza potrebbe essere sanata in una versione futura, di modo che $SIG{__DIE__} venga chiamata solamente quando il programma sta per uscire, com'era nelle intenzioni originali. Qualsiasi altro utilizzo è deprecato.

Gli handler __DIE__/__WARN__ sono particolarmente speciali in un determinato senso: essi possono essere chiamati per riportare (probabili) errori trovati dal parser [la parte dell'interprete che si occupa di effettuare l'analisi del codice, N.d.T.]. In tal caso il parser potrebbe trovarsi in uno stato inconsistente, per cui qualsiasi tentativo di valutare codice Perl da un handler del genere risulterebbe probabilmente in un errore di segmentazione. Ciò significa che gli avvertimenti o gli errori che risultano dal parsing devono essere utilizzati con estrema cautela, come questo:

require Carp if defined $^S;
Carp::confess("Qualcosa di sbagliato") if defined &Carp::confess;
die "Qualcosa di sbagliato, ma non ho potuto caricare Carp
     per avere un backtrace... Per vederlo, provate a far
     partire Perl con -MCarp";

Qui la prima riga carica Carp a meno che non sia il parser a chiamare l'handler. La seconda riga stamperà il backtrace [la lista delle funzioni chiamate fino a questo punto, N.d.T.] e morirà se Carp è disponibile. La terza riga sarà eseguita solamente se Carp non è disponibile.

Consultate "die" in perlfunc, "warn" in perlfunc, "eval" in perlfunc e warnings per ulteriori informazioni.

Indicatori di Errore

Le variabili $@, $!, $^E e $? contengono informazioni sui differenti tipi di condizioni di errore che possono avvenire durante l'esecuzione di un programma Perl. Le variabili sono mostrate in ordine di "distanza" fra il sottosistema che ha generato l'errore ed il processo Perl. Corrispondono rispettivamente ad errori individuati dall'interprete Perl, dalla libreria C, dal sistema operativo o da un programma esterno.

Per illustrare la differenza fra queste variabili, considerate la seguente espressione in Perl, che utilizza stringhe con virgolette semplici:

eval q{
    open my $pipe, "/cdrom/install |" or die $!;
    my @ris = <$pipe>;
    close $pipe or die "pipe guasta: $?, $!";
};

Dopo l'esecuzione di questa istruzione tutte e 4 le variabili potrebbero essere state impostate.

$@ è impostata se la stringa passata ad eval() non è stata compilata correttamente (come accadrebbe ad esempio se open o close fossero importati con prototipi errati), o se il codice Perl eseguito durante la eval() avesse generato un die(). In questi casi il valore di $@ è l'errore di compilazione, o l'argomento fornito a die() (che interpolerà $! e $?). (Consultate però anche Fatal).

Quando l'espressione eval() viene eseguita, open(), <PIPE> e close() sono tradotte in chiamate alla libreria di run-time [fase di esecuzione, N.d.T.] e da qui in chiamate al kernel del sistema operativo. $! viene impostata con il valore della variabile errno della libreria C se una di queste chiamate fallisce.

Sotto alcuni sistemi operativi, $^E potrebbe contenere una descrizione dell'errore un po' più estesa, come ad esempio (in questo caso) "Il cassetto del CDROM non è chiuso". I sistemi che non supportano messaggi di errore estesi lasciano $^E uguale a $!.

Infine, $? potrebbe essere impostata ad un valore diverso da 0 se il programma esterno /cdrom/install fallisce. Gli otto bit superiori riflettono le condizioni di errore specifiche incontrate dal programma (ossia, il valore della exit() del programma stesso). Gli otto bit inferiori riflettono la modalità di fallimento, come una morte a seguito di un segnale e la presenza di informazioni di core dump. Consultate wait(2) per i dettagli. Diversamente da $! e $^E, che sono impostate solo se la condizione di errore è individuata, la variabile $? è impostata per qualunque chiamata a wait() o close() su pipe, sovrascrivendo il vecchio valore. In questo senso è più simile a $@, che per ciascuna eval() viene sempre impostata in caso di fallimento e ripulita in caso di successo.

Per maggiori dettagli, consultate le descrizioni individuali date sopra per $@, $!, $^E e $?.

Nota Tecnica sulla Sintassi dei Nomi di Variabile

I nomi di variabile in Perl possono avere numerosi formati. Di solito, devono iniziare con una lettera o con un underscore [il carattere "_", N.d.T.] nel qual caso possono essere arbitrariamente lunghe (fino ad un limite interno di 251 caratteri) e possono contenere lettere, cifre numeriche, underscore, la sequenza speciale :: o '. In questo caso, la parte prima dell'ultimo :: o ' è considerata essere un qualificatore di pacchetto; consultate perlmod.

I nomi delle variabili Perl possono anche essere una sequenza di cifre numeriche o un singolo carattere di punteggiatura o di controllo. Questi nomi sono riservati per usi speciali da parte di Perl; ad esempio, i nomi costituiti da sole cifre numeriche sono utilizzati per contenere i dati catturati dopo l'applicazione di un'espressione regolare. Perl supporta una sintassi speciale per i nomi costituiti da un singolo carattere di controllo: capisce ^X (il carattere "^" seguito dalla lettera X) per intendere il carattere control-X. Ad esempio, la notazione $^W (segno di dollaro, seguito da "^", seguito da W) è la variabile scalare il cui nome è costituito dal singolo carattere control-W. Capite bene che è meglio che dover digitare un control-W letterale nel vostro programma.

Infine, come novità in Perl 5.6, i nomi delle variabili Perl possono essere stringhe alfanumeriche che iniziano con caratteri di controllo (o ancora meglio con un carattere "^"). Queste variabili devono essere scritte nella forma ${^Pippo}; le graffe non sono opzionali. ${^Pippo} rappresenta la variabile scalare il cui nome è un control-P seguito dalla stringa "ippo". Queste variabili sono riservate per uso speciale futuro da Perl, eccetto quelle che iniziano con ^_ (control-underscore o "^" seguito da underscore). Nessun nome di variabile con carattere di controllo che inizi con un underscore avrà mai un significato speciale in qualsivoglia futura versione di Perl; tali nomi possono pertanto essere utilizzati senza problemi nei programmi. $^_ stessa, comunque, è riservata.

Gli identificatori Perl che iniziano con cifre numeriche, caratteri di controllo o caratteri di interpunzione sono esenti dagli effetti della dichiarazione package e sono sempre forzati ad esistere nel pacchetto main; sono anche esenti da errori associati all'uso della direttiva strict 'vars'. Alcuni altri nomi sono esenti in maniera analoga:

ENV		STDIN
INC		STDOUT
ARGV		STDERR
ARGVOUT		_
SIG

In particolare, le nuove variabili speciali del tipo ${^_XYZ} sono sempre considerate come appartenenti al pacchetto main, indipendentemente da qualsiasi dichiarazione package si possa trovare nello scope corrente.

BUG

Causa uno sfortunato accidente dell'implementazione di Perl, use English impone una penalità considerevole su tutte le espressioni regolari in un programma, senza riguardo al fatto che esse occorrano o meno nello scope di use English. Per questa ragione, utilizzare use English nelle librerie è fortemente scoraggiato. Consultate la documentazione del modulo Devel::SawAmpersand su CPAN ( http://www.cpan.org/modules/by-module/Devel/ ) per maggiori informazioni.

Il fatto che anche solo pensiate alla variabile $^S nei vostri handler di eccezione è semplicemente sbagliato. $SIG{__DIE__}, come implementato al momento, attira errori dolorosi e difficili da scovare. Evitatelo ed utilizzate un blocco END{} o piuttosto ridefinite CORE::GLOBAL::die.

TRADUZIONE

Versione

La versione su cui si basa questa traduzione è ottenibile con:

perl -MPOD2::IT -e print_pod perlvar

Per maggiori informazioni sul progetto di traduzione in italiano si veda http://pod2it.sourceforge.net/ .

Traduttore

Traduzione a cura di Flavio Poletti (re-iniziata da capo dopo una prima versione parziale a cura di Alberto Re).

Revisore

Revisione a cura di shishii (Marco Allegretti).