view release on metacpan or  search on metacpan

IT/perlfunc.pod  view on Meta::CPAN

Ogni funzione dell'elenco sottostante puE<ograve> essere usata o 
meno con parentesi attorno ai propri argomenti. (La
descrizione della sintassi omette le parentesi). Se usate
le parentesi, la semplice regola (benchE<eacute> talvolta sorprendente)
E<egrave> questa: I<sembra> una funzione, dunque I<E<egrave>> una funzione,
e la precedenza non importa. Altrimenti E<egrave> un operatore di
lista o un operatore unario, e allora la precedenza conta.
Ed uno spazio vuoto tra la funzione e la parentesi aperta
non conta, quindi a volte dovete stare attenti:

  print 1+2+4;      # Stampa 7.
  print(1+2) + 4;   # Stampa 3.
  print (1+2)+4;    # Anche questo stampa 3!
  print +(1+2)+4;   # Stampa 7.
  print ((1+2)+4);  # Stampa 7.

Se lanciate Perl con lo switch B<-w>, allora vi puE<ograve> avvertire
a questo proposito. Per esempio, la terza linea produce:

    print (...) interpreted as function at - line 1.
    Useless use of integer addition in void context at - line 1

[print (...) E<egrave> interpretato come funzione alla linea 1.
Utilizzo inutile di una addizione intera in un contesto vuoto alla linea 1, NdT]

Un esiguo numero di funzioni non accetta alcun argomento, e
quindi non funziona nE<eacute> come operatore di lista nE<eacute> 
come operatore unario. Sono incluse in questo gruppo funzioni come 
C<time> e C<endpwent>. Per esempio, C<time+86_400> vuol dire sempre
C<time() + 86_400>.

Per le funzioni che possono essere usate in un contesto scalare o di
lista, un fallimento non bloccante viene generalmente indicato restituendo 
il valore indefinito in un contesto scalare, e la lista nulla in un contesto 
di lista.

Ricordate la seguente importante regola: Non esiste B<alcuna regola>
che correla il comportamento di un'espressione in un contesto di lista
al suo comportamento in un contesto scalare, o viceversa. Potrebbe
comportarsi in due maniere totalmente differenti.
Ogni operatore e ogni funzione decidono quale genere di valore sia piE<ugrave>
appropriato restituire in un contesto scalare. Alcuni operatori 
restituiscono la lunghezza della lista che sarebbe stata restituita
in un contesto di lista. Alcuni operatori restituiscono il primo 
valore nella lista. Alcuni restituiscono l'ultimo. Alcuni operatori
restituiscono il conto delle operazioni eseguite con successo.
In generale, fanno quello che volete, a meno che non vogliate la
consistenza.
X<contesto>

Un array dotato di nome, in un contesto scalare E<egrave> piuttosto 
differente da quella che a prima vista potrebbe apparire come una lista in un
contesto scalare. Non potete fare in modo che una lista come C<(1,2,3)> 
si trovi in un contesto scalare, poichE<eacute> il compilatore conosce il
contesto al momento della compilazione. Genererebbe l'operatore scalare virgola, 
non l'operatore virgola che costruisce una lista. 
CiE<ograve> significa che quella non era una lista nemmeno in partenza.

In generale, le funzioni Perl che fungono da wrapper [involucro, interfaccia 
tra un programma ed un altro, NdT] per le chiamate di sistema che hanno lo 
stesso nome (come chown(2), fork(2), closedir(2), ecc.) restituiscono tutte 
vero quando hanno successo e C<undef> in caso contrario, come viene solitamente 
menzionato nelle descrizioni che seguono. CiE<ograve> differisce dall'interfaccia 
C, che restituisce C<-1> in caso di fallimento. Le eccezioni a questa regola sono 
C<wait>, C<waitpid> e C<syscall>. Le chiamate di sistema inoltre impostano la variabile
speciale C<$!> in caso di fallimento. Altre funzioni non lo fanno,
se non accidentalmente.

=head2 Elenco delle funzioni Perl per categoria
X<funzione>

Ecco le funzioni del Perl (incluse certe cose che assomigliano a funzioni,
come alcune parole chiave e operatori dotati di nome) ordinate per
categoria. Alcune funzioni appaiono in piE<ugrave> di una posizione.

=over 4

=item Funzioni per SCALARI o stringhe
X<scalare> X<stringa> X<carattere>

C<chomp>, C<chop>, C<chr>, C<crypt>, C<hex>, C<index>, C<lc>, C<lcfirst>,
C<length>, C<oct>, C<ord>, C<pack>, C<q/STRINGA/>, C<qq/STRINGA/>, C<reverse>,
C<rindex>, C<sprintf>, C<substr>, C<tr///>, C<uc>, C<ucfirst>, C<y///>

=item Espressioni regolari e ricerca di pattern
X<espressione regolare> X<regex> X<regexp>

C<m//>, C<pos>, C<quotemeta>, C<s///>, C<split>, C<study>, C<qr//>

=item Funzioni numeriche
X<numerico> X<numero> X<trigonometrico> X<trigonometria>

C<abs>, C<atan2>, C<cos>, C<exp>, C<hex>, C<int>, C<log>, C<oct>, C<rand>,
C<sin>, C<sqrt>, C<srand>

=item Funzioni per @ARRAY effettivi
X<array>

C<pop>, C<push>, C<shift>, C<splice>, C<unshift>

=item Funzioni per liste di dati
X<lista>

C<grep>, C<join>, C<map>, C<qw/STRINGA/>, C<reverse>, C<sort>, C<unpack>

=item Funzioni per %HASH effettivi
X<hash>

C<delete>, C<each>, C<exists>, C<keys>, C<values>

=item Funzioni di input e output
X<I/O> X<input> X<output> X<dbm>

C<binmode>, C<close>, C<closedir>, C<dbmclose>, C<dbmopen>, C<die>, C<eof>,
C<fileno>, C<flock>, C<format>, C<getc>, C<print>, C<printf>, C<read>,
C<readdir>, C<rewinddir>, C<seek>, C<seekdir>, C<select>, C<syscall>,
C<sysread>, C<sysseek>, C<syswrite>, C<tell>, C<telldir>, C<truncate>,
C<warn>, C<write>

=item Funzioni per dati a lunghezza fissa o record

C<pack>, C<read>, C<syscall>, C<sysread>, C<syswrite>, C<unpack>, C<vec>

=item Funzioni per filehandle, file o directory
X<file> X<filehandle> X<directory> X<pipe> X<link> X<symlink>

C<-I<X>>, C<chdir>, C<chmod>, C<chown>, C<chroot>, C<fcntl>, C<glob>,
C<ioctl>, C<link>, C<lstat>, C<mkdir>, C<open>, C<opendir>,
C<readlink>, C<rename>, C<rmdir>, C<stat>, C<symlink>, C<sysopen>,
C<umask>, C<unlink>, C<utime>

=item Parole chiave relative al controllo di flusso del vostro programma Perl
X<controllo di flusso>

C<caller>, C<continue>, C<die>, C<do>, C<dump>, C<eval>, C<exit>,
C<goto>, C<last>, C<next>, C<redo>, C<return>, C<sub>, C<wantarray>

=item Parole chiave relative alla visibilitE<agrave> delle variabili (scoping)

C<caller>, C<import>, C<local>, C<my>, C<our>, C<package>, C<use>

=item Funzioni varie

C<defined>, C<dump>, C<eval>, C<formline>, C<local>, C<my>, C<our>, C<reset>,
C<scalar>, C<undef>, C<wantarray>

=item Funzioni per processi e gruppi di processi
X<processo> X<pid> X<id di processo>

C<alarm>, C<exec>, C<fork>, C<getpgrp>, C<getppid>, C<getpriority>, C<kill>,
C<pipe>, C<qx/STRINGA/>, C<setpgrp>, C<setpriority>, C<sleep>, C<system>,
C<times>, C<wait>, C<waitpid>

=item Parole chiave relative ai moduli perl
X<modulo>

C<do>, C<import>, C<no>, C<package>, C<require>, C<use>

=item Parole chiave relative alle classi e al campo dell'orientamento agli oggetti
X<oggetto> X<classe> X<package>

C<bless>, C<dbmclose>, C<dbmopen>, C<package>, C<ref>, C<tie>, C<tied>,
C<untie>, C<use>

=item Funzioni di basso livello per i socket
X<socket> X<sock>

C<accept>, C<bind>, C<connect>, C<getpeername>, C<getsockname>,
C<getsockopt>, C<listen>, C<recv>, C<send>, C<setsockopt>, C<shutdown>,
C<socket>, C<socketpair>

=item Funzioni di comunicazione tra processi di System V
X<IPC> X<System V> X<semaforo> X<memoria condivisa> X<memoria> X<messaggio>

C<msgctl>, C<msgget>, C<msgrcv>, C<msgsnd>, C<semctl>, C<semget>, C<semop>,
C<shmctl>, C<shmget>, C<shmread>, C<shmwrite>

=item Recupero delle informazioni dell'utente e del gruppo
X<user> X<group> X<password> X<uid> X<gid> X<passwd> X</etc/passwd>

C<endgrent>, C<endhostent>, C<endnetent>, C<endpwent>, C<getgrent>,
C<getgrgid>, C<getgrnam>, C<getlogin>, C<getpwent>, C<getpwnam>,
C<getpwuid>, C<setgrent>, C<setpwent>

=item Recupero delle informazioni di rete
X<rete> X<protocollo> X<host> X<nome dell'host> X<IP> X<indirizzo> X<servizio>

C<endprotoent>, C<endservent>, C<gethostbyaddr>, C<gethostbyname>,
C<gethostent>, C<getnetbyaddr>, C<getnetbyname>, C<getnetent>,
C<getprotobyname>, C<getprotobynumber>, C<getprotoent>,
C<getservbyname>, C<getservbyport>, C<getservent>, C<sethostent>,
C<setnetent>, C<setprotoent>, C<setservent>

=item Funzioni relative al tempo
X<tempo> X<data>

C<gmtime>, C<localtime>, C<time>, C<times>

=item Nuove funzioni in perl5
X<perl5>

C<abs>, C<bless>, C<chomp>, C<chr>, C<exists>, C<formline>, C<glob>,
C<import>, C<lc>, C<lcfirst>, C<map>, C<my>, C<no>, C<our>, C<prototype>,
C<qx>, C<qw>, C<readline>, C<readpipe>, C<ref>, C<sub*>, C<sysopen>, C<tie>,
C<tied>, C<uc>, C<ucfirst>, C<untie>, C<use>

* - C<sub> era una parola chiave in perl4, ma in perl5 E<egrave> un operatore, 
che puE<ograve> essere usato nelle espressioni.

=item Funzioni obsolete in perl5

C<dbmclose>, C<dbmopen>

=back

=head2 PortabilitE<agrave>
X<portabilita`> X<Unix> X<portabile>

Perl E<egrave> nato su Unix e dunque puE<ograve> accedere a tutte le normali 
chiamate di sistema Unix. In ambienti non-Unix, le funzionalitE<agrave> di 
alcune di queste chiamate potrebbe non essere disponibile, oppure i dettagli 
potrebbero essere un po' diversi. Le funzioni Perl influenzate da questo aspetto 
sono:

C<-X>, C<binmode>, C<chmod>, C<chown>, C<chroot>, C<crypt>,
C<dbmclose>, C<dbmopen>, C<dump>, C<endgrent>, C<endhostent>,
C<endnetent>, C<endprotoent>, C<endpwent>, C<endservent>, C<exec>,
C<fcntl>, C<flock>, C<fork>, C<getgrent>, C<getgrgid>, C<gethostbyname>,
C<gethostent>, C<getlogin>, C<getnetbyaddr>, C<getnetbyname>, C<getnetent>,
C<getppid>, C<getpgrp>, C<getpriority>, C<getprotobynumber>,
C<getprotoent>, C<getpwent>, C<getpwnam>, C<getpwuid>,
C<getservbyport>, C<getservent>, C<getsockopt>, C<glob>, C<ioctl>,
C<kill>, C<link>, C<lstat>, C<msgctl>, C<msgget>, C<msgrcv>,
C<msgsnd>, C<open>, C<pipe>, C<readlink>, C<rename>, C<select>, C<semctl>,
C<semget>, C<semop>, C<setgrent>, C<sethostent>, C<setnetent>,
C<setpgrp>, C<setpriority>, C<setprotoent>, C<setpwent>,
C<setservent>, C<setsockopt>, C<shmctl>, C<shmget>, C<shmread>,
C<shmwrite>, C<socket>, C<socketpair>,
C<stat>, C<symlink>, C<syscall>, C<sysopen>, C<system>,
C<times>, C<truncate>, C<umask>, C<unlink>,
C<utime>, C<wait>, C<waitpid>

Per maggiori informazioni riguardanti la portabilitE<agrave> di queste 
funzioni, consultate L<perlport> ed altra documentazione disponibile 
specifica per una data piattaforma.

=head2 Elenco delle funzioni Perl in ordine alfabetico

=over 8

=item -X FILEHANDLE
X<-r>X<-w>X<-x>X<-o>X<-R>X<-W>X<-X>X<-O>X<-e>X<-z>X<-s>X<-f>X<-d>X<-l>X<-p>
X<-S>X<-b>X<-c>X<-t>X<-u>X<-g>X<-k>X<-T>X<-B>X<-M>X<-A>X<-C>

=item -X EXPR

=item -X

Un test sul file, dove X E<egrave> una delle lettere elencate di seguito. Questo
operatore unario opera su un argomento, o un nome di file o un
filehandle, e controlla il file associato per verificare la veritE<agrave> di
una condizione. Se si omette l'argomento, utilizza il valore corrente di
C<$_>; fa eccezione C<-t>, che utilizza STDIN.
A meno di indicazione contraria, restituisce C<1> per indicare la veritE<agrave>
della condizione verificata, e C<''> in caso di falsitE<agrave>, mentre
restituisce un valore non definito se il file non esiste. A dispetto
della stranezza dei nomi, valgono le stesse regole di precedenza di ogni
altro operatore unario, e l'argomento puE<ograve> essere racchiuso fra parentesi
come per qualsiasi altro operatore. L'operatore puE<ograve> essere uno qualsiasi
fra quelli seguenti:

    -r	Il file e` leggibile da parte del uid/gid effettivo.
    -w	Il file e` scrivibile da parte del uid/gid effettivo.
    -x	Il file e` eseguibile da parte del uid/gid effettivo.
    -o	Il file appartiene al uid effettivo.

    -R	Il file e` leggibile da parte del uid/gid reale.
    -W	Il file e` scrivibile da parte del uid/gid reale.
    -X	Il file e` eseguibile da parte del uid/gid reale.
    -O	Il file appartiene al uid reale.

    -e	Il file esiste.
    -z	Il file ha dimensione zero (e` vuoto).
    -s	Il file ha dimensione diversa da zero (restituisce la dimensione in byte).

IT/perlfunc.pod  view on Meta::CPAN

tutti i suoi argomenti. E<Egrave> spesso utilizzato per rimuovere il newline dalla fine di un 
record in input, quando temete che il record possa essere sprovvisto del suo newline. Quando 
E<egrave> utilizzata in paragraph mode [modalitE<agrave> paragrafo, NdT] (C<$/ = "">), rimuove 
tutti i newline in coda ad una stringa. Quando E<egrave> utilizzata in slurp mode 
[modalitE<agrave> slurp, NdT] (C<$/ = undef>) o con una lunghezza di record fissa (C<$/> 
E<egrave> un riferimento ad un intero o a qualcosa di simile, consultate L<perlvar>), chomp() 
non rimuoverE<agrave> nulla. Se VARIABILE viene omessa, chomp agisce su C<$_>. Ad esempio:

    while (<>) {
        chomp; # rimuove \n dall'ultimo campo
        @array = split(/:/);
        # ...
    }

Se VARIABILE E<egrave> un hash, chomp() agisce sui valori dell'hash, ma non sulle sue chiavi.

Potete utilizzare chomp su qualsiasi cosa che sia un lvalue [valore a sinistra di 
un'espressione, NdT], incluso un assegnamento:

    chomp($cwd = `pwd`);
    chomp($risposta = <STDIN>);

Se usate chomp() su una lista, viene effettuato il chomp di ogni elemento, e viene restituito il 
numero totale di caratteri rimossi.

Se la direttiva C<encoding> E<egrave> nello scope, allora
le lunghezze che vengono restituite sono calcolate a partire dalla lunghezza di C<$/> in
caratteri Unicode che non E<egrave> sempre la stessa cosa della lunghezza di C<$/> nella
codifica nativa.

Va notato che le parentesi sono necessarie quando usate chomp() su qualsiasi cosa che non sia una 
variabile semplice. CiE<ograve> deriva dal fatto che C<chomp $cwd = `pwd`;> E<egrave> 
interpretato come C<(chomp $cwd) = `pwd`;>, anzichE<eacute> come C<chomp( $cwd = `pwd` )>, come 
vi potreste aspettare. Similmente, C<chomp $a, $b> E<egrave> interpretato come C<chomp($a), $b> 
anzichE<eacute> come C<chomp($a, $b)>.

=item chop VARIABILE
X<chop>

=item chop( LISTA )

=item chop

Taglia via l'ultimo carattere di una stringa e restituisce il carattere
tagliato. E<Egrave> molto piE<ugrave> efficiente di C<s/.$//s> perchE<eacute>
non scandisce nE<eacute> copia la stringa. Se VARIABILE viene omessa,
taglia C<$_>. Se VARIABILE E<egrave> un hash, taglia i valori 
dell'hash, ma non le sue chiavi.

Potete utilizzare chop su qualsiasi cosa che sia un lvalue [valore a sinistra di 
un'espressione, NdT], incluso un assegnamento.

Chiamando chop su una lista, ogni elemento viene tagliato. Viene
restituito solo il valore dell'ultimo C<chop> effettuato.

Va notato che C<chop> restituisce l'ultimo carattere. Per ottenere tutto
tranne l'ultimo carattere, utilizzate C<substr($stringa, 0, -1)>.

Si veda anche L</chomp>.

=item chown LISTA
X<chown> X<owner> X<user> X<group>

Cambia il proprietario (ed il gruppo) di una lista di file. I primi due elementi della lista 
devono essere uid e gid I<numerici>, nell'ordine indicato. Un valore di -1 in una di queste due 
posizioni viene interpretato dalla maggior parte dei sistemi operativi come volontE<agrave> 
di non alterare tale valore. Restituisce il numero di file modificati con successo.

    $cnt = chown $uid, $gid, 'pippo', 'pluto';
    chown $uid, $gid, @nomifile;

Su sistemi che supportano fchown, potreste passare i file handle tra i file.
Su sistemi che non supportano fchmod, passare file handle
produce un errore fatale a tempo di esecuzione.

Di seguito E<egrave> riportato un esempio che risolve le uid non numeriche servendosi del file 
passwd:

    print "Utente: ";
    chomp($utente = <STDIN>);
    print "File: ";
    chomp($pattern = <STDIN>);

    ($login,$pass,$uid,$gid) = getpwnam($utente)
	or die "$utente non e` presente nel file passwd";

    @ary = glob($pattern);	# espande i nomi dei file
    chown $uid, $gid, @ary;

Sulla maggior parte dei sistemi, non E<egrave> consentito cambiare il proprietario dei file a 
meno che non si sia superuser. Dovreste tuttavia essere in grado di cambiare il gruppo 
impostandolo ad uno qualsiasi dei vostri gruppi secondari. Su sistemi non sicuri, queste 
restrizioni potrebbero essere meno rigide, ma assumere una cosa del genere non E<egrave> 
portabile. Sui sistemi POSIX, potete verificare questa condizione in questo modo:

    use POSIX qw(sysconf _PC_CHOWN_RESTRICTED);
    $chown_possibile = not sysconf(_PC_CHOWN_RESTRICTED);

=item chr NUMERO
X<chr> X<carattere> X<ASCII> X<Unicode>

=item chr

Restituisce il carattere rappresentato da NUMERO nell'insieme dei caratteri. Ad esempio, C<chr(65)> 
E<egrave> C<"A"> sia in ASCII che in Unicode, e chr(0x263a) E<egrave> una faccina sorridente in 
Unicode. Va notato che i caratteri da 127 a 255 (inclusi) di default non sono codificati in 
Unicode per ragioni di compatibilitE<agrave> all'indietro (ma consultate L<encoding>).

Se NUMERO viene omesso, utilizza C<$_>.

Per l'inverso di questa funzione, utilizzate L</ord>.

Va notato che mediante la direttiva C<bytes>, il NUMERO viene mascherato dagli otto bit bassi.

Consultate L<perlunicode> e L<encoding> per maggiori informazioni su Unicode.

=item chroot NOMEFILE
X<chroot> X<root>

=item chroot

Questa funzione funziona come la omonima chiamata di sistema: rende la directory data 
come nuova directory principale per tutti i percorsi che cominciano con un C</>, per il vostro 
processo e tutti i suoi figli (Non cambia la vostra directory corrente, che non viene modificata). 
Per motivi di sicurezza, questa chiamata E<egrave> riservata al superuser. Se NOMEFILE viene 
omesso, esegue un C<chroot> su C<$_>.

=item close FILEHANDLE
X<close>

=item close

Chiude il file o la pipe associata con il filehandle, restituisce vero solo se i buffer di IO 
sono stati svuotati con successo e chiude il descrittore di file di sistema. Se l'argomento 
viene omesso, chiude il filehandle correntemente selezionato.

Non E<egrave> necessario che voi chiudiate il FILEHANDLE se immediatamente andrete a fare 
un'altra C<open> sul filehandle perchE<eacute> C<open> lo chiuderE<agrave> per voi. 
(Si veda C<open>). Ad ogni modo, un'esplicita C<close> su di un file di input riazzererE<agrave> 
il contatore di linea (C<$.>), mentre non lo farE<agrave> la close implicita fatta da C<open>.

Se il filehandle proviene da una open su pipe, C<close> restituirE<agrave> in aggiunta falso se 
fallisce una delle altre chiamate di sistema coinvolte, oppure se il programma esce con uno stato 
non-zero. (Se il solo problema E<egrave> che il programma sia uscito come non-zero, C<$!> 
verrE<agrave> impostato a C<0>). Anche chiudere una pipe fa attendere che il processo in 
esecuzione su quella pipe sia completato, nel caso vogliate esaminare successivamente l'output 
della pipe, e implicitamente pone in C<$?> il valore di stato dell'uscita di quel comando.

Chiudere prematuramente la lettura finale di una pipe (cioE<egrave> prima che il processo
che sta scrivendo su di essa dall'altra estremitE<agrave> l'abbia chiusa) si risolverE<agrave> 
in una SIGPIPE che verrE<agrave> recapitata a chi sta scrivendo. Se l'altra estremitE<agrave> 
non puE<ograve> occuparsene, ci si assicuri di leggere tutti i dati prima di chiudere la pipe.

Esempio:

    open(OUTPUT, '|sort >pippo')  # pipe da ordinare
        or die "Non posso avviare sort: $!";