perlvar - Variabili predefinite in Perl
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 perlfunc/sort. 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
perlop/``Operatori di I/O''. 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 perlport/``Newlines'' 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 perlfunc/formline().
- $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 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:
- x01
Debug di ingresso/uscita da subroutine.
- x02
Debug riga-per-riga.
- x04
Disabilita le ottimizzazioni.
- x08
Conserva più dati per future ispezioni interattive.
- x10
Mantieni informazioni sulle linee nel programma sorgente dove
una subroutine è definita.
- x20
Inizia con la modalità singolo-passo.
- x40
Utilizza l'indirizzo della subroutine invece del nome quando si stampa.
- x80
Fai rapporto anche di goto &subroutine.
- x100
Fornisci nomi di ``file'' informativi per eval(), basati sul posto
dove sono state compilate.
- x200
Fornisci nomi informativi alle subroutine anonime, basati sul posto
dove sono state compilate.
- x400
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
perlfunc/require 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 perlfunc/require 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 perlfunc/die, perlfunc/warn, perlfunc/eval e
warnings per ulteriori informazioni.
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 $?.
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.
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.
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/ .
Traduzione a cura di Flavio Poletti (re-iniziata da capo dopo una
prima versione parziale a cura di Alberto Re).
Revisione a cura di shishii (Marco Allegretti).
Mon Jun 11 22:02:20 2012
|
