Resúmenes

Perl è un linguaggio di programmazione/scripting generico e, quindi, è un linguaggio interpretato (il codice sorgente viene tradotto da un interprete in linguaggio macchina al momento dell'esecuzione senza necessità di compilatore). Originariamente usato per la manipolazione di testi ed è oggi impiegato per una ampia gamma di attività come, per esempio, system administration, web development, network programming, GUI development, ecc.

Vantaggi e svantaggi

I vantaggi di Perl sono:

• pratico;
• efficiente: integra delle macro istruzioni già pronte per essere utilizzate;
• completo: fornisce array, liste, mappe, RegExp, manipolazione di stringhe, pattern matching, ecc.

Lo svantaggio è che principalmente è minimale e conciso.

Espressività

Imparare Perl è come imparare un qualsiasi linguaggio parlato. L'espressività di Perl consente a chi ha poca esperienza di scrivere buoni programmi senza avere una completa conoscenza di tutto il linguaggio. Vediamo i livelli di competenza per triplicare una lista di interi:

• Se sei all'inizio dell'utilizzo di Perl:

  my @tripled;
  for (my $i = 0; $i < scalar @numbers; $i++) {
  $tripled[$i] = $numbers[$i] * 3;
  }

• Se invece sei già abile con Perl:

  my @tripled;
  for my $num (@numbers) {
  push @tripled, $num * 3;
  }

• Se invece siamo molto esperti di Perl:

  my @tripled = map { $_ * 3 } @numbers;

Le basi di Perl

Primo Script

Per vedere la versione di Perl, scriviamo sul terminale:

perl -v

Per vedere il percorso dell'interprete di Perl, scriviamo sul terminale:

which perl

Inseriamo il "path" corretto per l'interprete Perl, sulla prima riga del file:

#!/usr/bin/perl

Utilizziamo la funzione "print" per stampare del testo su standard output:

print "Hello World!";

Ci sono due modi per lanciare uno script Perl:

• Richiamando direttamente l'interprete Perl sullo script:

  perl nome_file.pl

• Rendendo eseguibile il file ed eseguendolo successivamente:

  chmod u+x nome_file.pl

  ./nome_file.pl

È possibile nel terminale utilizzare l'opzione -w per ottenere più informazioni in caso di errori:

perl -w nome_file.pl

È possibile lanciare nel terminale lo script in debug mode usando l'opzione -d:

perl -d nome_file.pl

È possibile includere strict e warnings per ricevere "suggerimenti" su possibili errori comuni durante la scrittura di script in Perl:

#!/usr/bin/perl
use strict;
use warnings;
print "Hello World !";

Nomi delle variabili

I nomi delle variabili sono sempre preceduti da un identificatore (un simbolo) che indica il tipo della variabile:

my $variabile_scalare = "Ciao"; # scalari
my @array = (23, 42, 69); # array
my %array_associativo = (1 => "A", 2 => "B"); # mappe

Tutti i nomi di variabili/strutture dati in Perl iniziano con una lettera o con un underscore "_". Successivamente possono includere qualsiasi combinazione di lettere, numeri e underscores. Di seguito di identificatori validi in Perl:

my $name;
my @_private_names;
my %Names_to_Addresses;
sub function;

Di seguito, invece, un esempio di identificatori non validi in Perl:

my $invalid name; # gli spazi non sono ammessi nei nomi
my @3; # non si inizia con un numero
my %~flags; # i simboli non sono ammessi

Tipi di variabili in Perl

Le variabili in Perl sono contenitori per dei valori Values:

• Stringhe:

  my $name = 'Francesco, Giovanni';
  my $address = "Corso Mazzini, Cosenza (CS), 87100";
  my $reminder = 'Laboratorio Lab 31b' . 'Lun. Mattina 8:30';

• Numeri:

  my $integer = 42;
  my $float = 0.007;
  my $sci_float = 1.02e14;
  my $binary = 0b101010;
  my $octal = 052;
  my $hex = 0x20;

• Undef:

  my $name = undef; # non necessario
  my $rank; # contiene anch'esso undef

• List:

  my @fibonacci = (1, 1, 2, 3, 5, 8, 13);

Le variabili scalari contengono un singolo valore discreto, che può essere string, integer or floating-point e filehandle. Sono preceduti dal simbolo $. Ecco alcuni esempi di definizione e inizializzazione:

my $value;

$value = 123.456;
print "$value\n";

$value = 77;
print "$value\n";

$value = "I am Chuck's big toe.";
print "$value\n";

Gli array contengono uno o più scalari, rappresentano una lista di valori, la numerazione parte da 0 (sono zero-indexed) e La variabile speciale $#array ritorna l'indice dell'ultimo elemento di un array. Sono preceduti dal simbolo @.

Ecco abbiamo due tipologie di assegnamento:

my @gatti;
$gatti[3] = 'Jack';
$gatti[2] = 'Tuxedo';
$gatti[0] = 'Daisy';
$gatti[1] = 'Petunia';
$gatti[4] = 'Brad';

-

my @gatti = ('Daisy','Petunia','Tuxedo', ...);

Se vogliamo stampare, in modo semplice, un array:

print "@gatti\n";

Se vogliamo impostare un array vuoto:

@gatti = ();

Se vogliamo aggiungere e rimuovere elementi dalla fine di un array:

my @meals;
push @meals, ( hamburgers', 'spinach');
pop @meals;

Se vogliamo aggiungere e rimuovere elementi dall'inizio di un array:

unshift @meals, ('tofu', 'taquitos');
shift @meals;

Gli hash (array associativi) rappresenta un insieme di coppie chiave/valore, è una struttura dati che associa una chiave (string) ad una variabile scalare ed è possibile usare l'operatore => per associare un valore ad una chiave in maniera più chiara. Sono preceduti dal simbolo %.

Ecco abbiamo due tipologie di dichiarazione:

my %cibo_preferito;
$cibo_preferito{Francesco} = 'Pizza';
$cibo_preferito{Giovanni} = 'Ciambella';

-

my %cibo_preferito = (
    'Francesco', 'Pizza',
    'Giovanni', 'Ciambella',
);

-

my %cibo_preferito = (
    Francesco => 'Pizza',
    Giovanni => 'Ciambella',
);

Se vogliamo impostare un array associativo vuoto:

%cibo_preferito = ();

Operatori

Le caratteristiche principale sono:

• Precedenza: la precedenza di un operatore decide l'ordine in cui valutare una espressione;
• Associatività: la proprietà associativa di un operatore decide se valutare una espressione da sinistra verso destra o da destra verso sinistra;
• Arietà: l'arietà di un operatore indica il numero di operandi sul quale esso opera:
  • un operatore "nullary" opera su zero operandi;
  • un operatore "unary" opera su un operandi;
  • un operatore "binary" opera su due operandi;
  • un operatore "trinary" opera su tre operandi;
  • un operatore "listary" opera su lista di zero o più operandi.
• Fixity: gli operatori infissi appaiono al centro tra 2 operandi come, per esempio:

  $length * $width;

  Gli operatori prefissi precedono gli operandi:

  -$x # negazione matematica
  !$y # negazione booleana

  Gli operatori postfissi seguono i loro operandi:

  $z++ # incremento postfisso

  Gli operatori postcircumfix seguono determinati operandi e ne racchiudono altri:

  $hash{$x} # accesso agli elementi di un hash
  $array[$y] # accesso agli elementi di un array

Operatori numerici

Gli operatori numerici impongono il contesto numeric sui loro operandi:

• operatori aritmetici standard +, -, *, /, **, %;
• varianti degli operatori aritmetici (+=, -=, *=, /=, **=, %=);
• operatori di comparazione eguaglianza numerica (==), ineguaglianza numerica (!=), maggiore/minore di (>, <), maggiore/minore o uguale (>=, <=);
• operatore di comparazione per ordinamento (<=>).

Operatori per stringhe

Gli operatori per le stringhe impongono il contesto string sui loro operandi:

• operatori specifici per le stringhe binding per espressioni regolari (=~ and !~), concatenazione (.);
• operatori di comparazione eguaglianza su stringhe (eq), ineguaglianza su stringhe (ne), maggiore/minore di (gt, lt), maggiore/minore o uguale (ge, le);
• operatore di comparazione per ordinamento (cmp).

Operatori logici

Gli operatori booleani impongono il contesto boolean sui loro operandi:

• operatori booleani standard: &&, ||, !, and, or, not, xor;
• operatori booleani speciali operatori condizionali ternari (? :).

Altri operatori

• Operatori bitwise: trattano i loro operandi numericamente a livello di bit left shift (<<), right shift (>>), bitwise and, bitwise or (|) and bitwise xor (^), e le loro varianti con assegnamento (<<=, >>=, &=, |=);
• Operatore di ripetizione:

  my @test = ('nights') x 1001;
  # conterra' ('nights', 'nights', ...)
  my $calendar = 'nights' x 1001;
  # conterra' "nightsnights..."

• Operatore di range infisso:

  my @cards = ( 2 .. 10, 'J', 'Q', 'K', 'A' );

Control Flow

Il control flow identifica l'ordine in cui le istruzioni o le funzioni di un programma imperativo sono eseguite o valutate. I programmi imperativi sono eseguiti a partire dalla prima istruzione fino ad arrivare all'ultima, ad esempio:

print ("Inizio\n");
print ("Centro\n");
print ("Fine\n");

Alcune direttive in Perl cambiano l'ordine di ciò che potrebbe accadere più in là nel programma e prendono il nome di Perl control flow.

If statement

Può essere:

• postfix:

  print $cont if $cont > 10;

• prefix:

  if ($cont > 10) {
  print $cont;
  }

Espressioni (expression) condizionali

Può essere:

• postfix:

  greet_bob() if ($name eq 'Bob' && not greeted_bob());

• prefix:

  if ($name eq 'Bob' && not greeted_bob()) {
  print 'Hello, Bob!';
  found_bob();
  }

Unless statement

È un if con il not. Può essere:

• postfix:

  print "You're not Bob!" unless $name eq 'Bob';

• prefix:

  unless ($name eq 'Bob') {
  print "You're not Bob!"
  }

If-else statement

Un esempio di implementazione postfix è la seguente:

if ($name eq 'Bob') {
    print 'Hi, Bob!';
} else {
    print "I don't know you.";
}

Unless-else statement

Un esempio di implementazione è la seguente:

unless ($name eq 'Bob') {
    print "I don't know you.";
} else {
    print 'Hi, Bob!';
}

If-elsif-else statement

Un esempio di implementazione è la seguente:

if ($name eq 'Robert') {
    print 'Hi, Robert !';
} elsif ($name eq 'James') # Attenzione "else if" NON e' corretto
{
    print 'Hi, James !';
} else {
    print "You're not my friend.";
}

Operatore ternario condizionale

Un esempio di implementazione è la seguente:

my $time_suffix = after_noon($time)
                    ? 'afternoon'
                    : 'morning';

Equivale a:

my $time_suffix;
if (after_noon($time)) {
    $time_suffix = 'afternoon';
} else {
    $time_suffix = 'morning';
}

Variabili di default

In Perl le variabili $_ e @_ sono variabili globali di default:

• $_ è usata per le variabili scalari;
• @_ è usata per gli array.

Construtti per il loop

Può essere:

• prefix:

  # fare il quadrato dei primi 10 numeri
  foreach (1 .. 10) {
  print '$_ * $_ = ' . $_ * $_ . "\n";
  }

• postfix:

  print '$_ * $_ = ' . $_ * $_ . "\n" for 1 .. 10;

  for my $i (1 .. 10) {
  print '$i * $i = ' . $i * $i . "\n";
  }

Iterare su un array

Abbiamo tre versioni possibili per iterare su un array:

• versione 1:

  my @nums = 1 .. 10;
  $_ **= 2 for @nums;
  print join(", ", @nums);

• versione 2:

  for my $num (@nums) {
  $num **= 2;
  }
  print join(", ", @nums);
  for (@nums) {
  $_ **= 2;
  }
  print join(", ", @nums);

• versione 3:

  for (my $i = 0; $i <= 10; $i += 2) {
  print '$i * $i = ' . $i * $i . "\n";
  }

Loop

Possiamo utilizzare vari tipi di loop:

• while loop:

  while (@values)
  {
  my $value = shift @values; # Attenzione: senza shift diventa un loop infinito
  print $value;
  }

• until loop:

  until ($finished_running) { ... }

• postfix until loop:

  print "Hello, world!" until !$stop;

• infinite for loop:

  for (;;) { ... }

• infinite while loop:

  while (1) { ... }

• postfix infinite while loop:

  print "Hello, world!" while 1;

Controllo sui loop

• next: salta una iterazione del loop (simile al continue in C);
• last: esce immediatamente dal ciclo più interno (simile al break in C);
• redo: restart del loop senza valutare nuovamente la condizione.

Files

Molti programmi interagiscono con il mondo reale per lo più leggendo, scrivendo e naturalmente manipolando i files.

Perl era inizialmente usato come un tool di programmazione per gli amministratori di sistemi e continua ad essere ancora oggi un ottimo linguaggio utilizzato per la manipolazione di testi.

Filehandle

Il filehandle rappresenta lo stato corrente di uno specifico canale di input o output. Ci sono 3 canali standard (default) per il filehandle:

• STDIN - Input
• STDOUT - Output
• STDERR - Errore

Un esempio di lettura da STDIN è il seguente:

print "Inserisci una frase \n";
$line = <STDIN>; # Legge la successiva riga inserita da standard input
print "linea ricevuta:\n$line";
print "inserisci le righe successive!\n";
@lines = <STDIN>; # Legge tutte le righe inserite da standard input fino all'inserimento di ^D
print "restanti linee ricevute:\n@lines";

Input e Output

Se vogliamo aprire un file in lettura:

open(my $fh, "<", "input.txt") or die "Can't open < input.txt: $!";

Se vogliamo aprire un file in scrittura:

open(my $fh, ">", "ouput.txt") or die "Can't open > output.txt: $!";

Se vogliamo chiudere un file sia in lettura che in scrittura:

close $fh;

Le principali modalità di apertura dei files sono:

• <: apre un file in modalità solo lettura;
• >: apre un file in modalità solo scrittura cancellandone il contenuto se il file era già esistente, altrimenti ne crea uno nuovo;
• >>: apre un file in modalità solo scrittura appendendo il nuovo testo a quello esistente; se il file non era presente ne viene creato uno nuovo;
• +<: apre il file sia in lettura che in scrittura;
• -|: legge l'output prodotto dalla shell pipeline;
• |-: scrive sulla shell pipeline.

Se vogliamo leggere un file:

while (my $line = <$fh>) {
    chomp $line; # remuove i newlines
    ...

Se vogliamo leggere un file usando la variabile di default $_:

while (<$fh>) {
    chomp;
    ...

Perchè si usa il while e NON il for? for impone il contesto list sugli operandi. Quando si è in list context, la funzione readline leggerà l'intero file prima di processarlo. while effettua l'iterazione e legge una linea per volta. Quando è importante risparmiare memoria, è preferibile usare il while.

Se vogliamo scrivere su un file:

print $out_fh "Questa linea sara' scritta sul file\n";

Espressioni Regolari e Matching

Perl è talvolta chiamato Practical Extraction and Reporting Language. Una espressione regolare (chiamata anche regex o regexp) è un pattern che descrive le caratteristiche di un particolare pezzo di testo. Il regular expression engine di Perl applica questo pattern al fine di trovare un matching tra determinate porzioni di testo. Una espressione regolare è racchiusa tra 2 slash '/':

/ ESPRESSIONE REGOLARE /

Gli elementi principale di una espressione regolare sono:

• elementi (literals): rappresentano una parte di testo;
• quantificatori (quantifiers): indicano quante volte ci si aspetta che un certo elemento (o gruppo di elementi) possa essere ripetuto.

Gli elementi più semplici sono i caratteri alfanumerici. Ad esempio, l'espressione regolare /a/ indica che una stringa soddisfa il pattern se contiene almeno una a.

Pattern Matching

Un pattern matching si definisce mediate l'operatore di ricerca m, del tipo:

# m/REGEXP/

L'operatore =~ verifica se esiste una corrispondenza tra una stringa ed una certa espressione regolare, avverte Perl che la parte successiva è una espressione regolare. Questo operatore si chiama operatore di binding, per il fatto che effettua una connessione (binding) fra la variabile $testo e l'espressione regolare /la/.

In sostanza, può essere letto come "applica l'espressione regolare a destra sul testo della variabile a sinistra".

Non si tratta di un assegnamento!

Modificatori

I modificatori di una REGEXP ne determinano il comportamento:

• /REGEXP[/SUBST]/g: g è il modificatore globale: sarà ricercata o sostituita ogni evenienza;
• /REGEXP[/SUBST]/i: i è il modificatore case-insensitive: l'espressione regolare sarà case-insensitive.

Facciamo un esempio:

$testo = "Oggi e' una bella giornata!";
print "$testo verifica il match /LA/ case-insensitive. \n" if $testo !~ m/LA/i;

Come avviene la verifica del match? Viene cercata la posizione più a sinistra in cui si riscontra l'intera espressione regolare. La stringa viene esaminata da sinistra a destra finché non viene trovato un riscontro di regexp o finché il confronto fallisce.

Metacaratteri

-

\

annulla gli effetti del metacarattere successivo;

^

identifica l'inizio di una riga; inoltre all'inizio di un gruppo nega il gruppo stesso;

.

qualsiasi carattere ad eccezione di quelli che identificano una riga nuova;

$

identifica la fine di una riga;

|

indica una condizione OR;

()

indicano un gruppo di caratteri;

[]

indicano intervalli e classi di caratteri;

Quantificatori

• \: indica 0 o tante occorrenze;
• *+: indica 1 o tante occorrenze;
• *?: indica al massimo 1 occorrenza;
• {n}: ricerca esattamente n* occorrenze;
• {n,}: ricerca minimo n* occorrenze;
• {n,m}: ricerca minimo n e massimo m* occorrenze;

Tabulazioni e newlines

• *\t: tab (HT, TAB);
• *\n: newline (LF, NL);
• *\r: return (CR).

Altri metacaratteri

• *\d: ricerca un numero (d sta per digit);
• \D: opposto di \d*, ricerca qualsiasi cosa che non sia un numero;
• \w: ricerca un carattere "parola" (w* sta per word), ovvero lettere, numeri e "" -> [a-zA-Z0-9];
• \W: ricerca un carattere che non sia \w*, ovvero tutto quello che non sia lettere, numeri o "_";
• *\s: ricerca uno spazio, comprese tabulazioni e caratteri di fine riga;
• \S: opposto di \s*. Ricerca qualsiasi cosa che non sia uno spazio, una tabulazione o dei caratteri di fine riga;
• *\N: ricerca un carattere che non sia newline.

Esempi di REGEXP

-

o.a

"o" seguita da qualsiasi carattere seguito da "a";

^f

"f" all'inizio di una riga;

^yogi

yogi all'inizio di una riga;

e$

"e" alla fine di una riga;

notte$

notte a fine riga;

aiuto*

aiuto seguito da zero o piu' caratteri "o";

.*

qualsiasi stringa senza un newline;

^$

una riga vuota;

[qjk]

alternativamente q oppure j oppure k;

[^qjk]

ne' q, ne' j, ne' k;

[a-z]

qualsiasi carattere tra a e z inclusi;

[^a-z]

nessuna lettera minuscola;

[a-zA-Z]

qualsiasi lettera;

[a-z]+

qualsiasi sequenza non vuota di lettere minuscole;

arancia|limone

alternativamente arancia o limone;

cas(a|erma)

casa oppure caserma;

(la)+

la oppure lala oppure lalala oppure ...;

Catturare parti del matching

Spesso è utile potersi ricordare dei pattern per cui c'è stato un match, così da poterli ri-utilizzare.

Ciò che avviene è che qualsiasi stringa che soddisfa un match è memorizzata da Perl nelle variabili speciali $1,...,$9. In pratica, le variabili $1, $2, etc. funzionano all'esterno di un criterio di ricerca e contengono le sequenze effettivamente riscontrate nei vari raggruppamenti in () dell'espressione regolare e contate da sinistra a destra.

Questo meccanismo consente di "catturare" singole parti dell'espressione regolare per cui si verifica il match.

Quantificatore "ingordo"

Il meccanismo dei quantificatori è "ingordo", ovvero esamina riscontrati. Se questa sequenza non soddisfa l'espressione regolare allora diminuisce il numero di atomi fino al minimo consentito finché non riesce a soddisfare la regex.

$testo = '"Ciao!", gli disse lei, "Ciao." rispose lui.';
$testo =~ /"(.+)"/;
print "$1\n"; # Ciao!", gli disse lei, "Ciao.

Quantificatore "minimale"

Posticipando il carattere ? ad un quantificatore lo si rende quantificatore minimale, ovvero verrà cercata la prima occorrenza possibile del carattere/gruppo, minimizzando il risultato.

$testo = '"Ciao!", gli disse lei, "Ciao." rispose lui.';
$testo =~ /"(.+?)"/;
print "$1\n"; # Ciao!

Espressioni Regolari

Sostituzioni

Oltre a poter trovare se una stringa soddisfa una particolare espressione regolare, Perl permette di fare sostituzioni basate sulle corrispondenze individuate. Il modo per fare questo è usare l'operatore s. Un esempio:

$frase = "Universita' degli Studi della Calabria";
print "PRIMA => $frase \n"; # Uni... degli ...
$frase =~ s/degli/Degli/g;
print "DOPO => $frase \n"; # Uni... Degli ...

Le variabili speciali $1, $2, etc. possono essere usate nelle espressioni regolari o nelle sostituzioni mediante i codici speciali \1, ..., \9.

Facciamo un esempio per racchiudere le lettere maiuscole tra i due punti ":":

$frase = "Universita' degli Studi della Calabria";
print "PRIMA => $frase \n";
$frase =~ s/([A-Z])/:\1:/g;
print "DOPO => $frase \n"; # :U:niversita' degli :S:tudi della :C:alabria

Facciamo un esempio per invertire l'ordine delle parole:

$frase = "Universita' degli Studi della Calabria";
print "PRIMA => $frase \n";
$frase =~ s/(.*) (.*) (.*) (.*) (.*)/\5 \4 \3 \2 \1/g;
print "DOPO => $frase \n"; # Calabria della Studi degli Universita'

Traslitterazione

La funzione tr permette una traduzione (traslitterazione) carattere per carattere. Il modo per fare questo è usare l'operatore tr.

Un esempio di traslitterazione è il seguente:

$frase = "Universita' degli Studi della Calabria"; print "PRIMA => $frase \n";
$frase =~ tr/USC/OTZ/;
print "DOPO => $frase \n"; # Oniversita' degli Ttudi della Zalabria

Un altro esempio di traslitterazione è il seguente:

$frase = "Universita' degli Studi della Calabria"; print "PRIMA => $frase \n";
$frase =~ tr/a-z/A-Z/;
print "DOPO => $frase \n"; # UNIVERSITA' DEGLI STUDI DELLA CALABRIA

Funzioni avanzate di Perl

Esecuzione di comandi shell

Una stringa racchiusa tra apici inversi (backticks ' '), oppure indicata attraverso l'operatore qx, viene interpolata ed il risultato viene fatto eseguire dal sistema operativo.

L'output del comando è il risultato della valutazione della stringa e il valore restituito dal comando può essere letto.

Un esempio d'implementazione è il seguente:

@output = 'ls -l';
# oppure
@output = qx(ls -l);
print "output del comando @output\n";

Sorting di array associativi

Di seguito, un esempio d'implementazione per ordinare un array associativi:

%studenti = (
    "ale", 10567,
    "cla", 1789,
    "adri", 6443
);
# Stampa ordinata in base alla chiave (nome)
foreach $nome (sort keys %studenti) {
    print "$nome - $studenti{$nome}.\n";
}

Abbiamo vari tipi di metodi sort:

sort {$a cmp $b}

ordinamento lessicografico;

sort {$b cmp $a}

come prima ma in ordine inverso;

sort {$a <=> $b}

ordinamento numerico ascendente;

sort {$b <=> $a}

ordinamento numerico discendente;

sort {($hash{$b} <=> $hash{$a}) || ($a cmp $b) }

ordinamento prima per valore e poi per chiave in array associativi;

Facciamo l'esempio di fare una stampa ordinata in base al valore (matricola), ascendente:

foreach $nome (sort { $studenti{$a} <=> $studenti{$b} } keys %studenti) {
    print "$nome - $studenti{$nome}.\n";
}

Split su stringhe

La funzione split "spezza una stringa in pezzi mettendoli in un array". Per specificare cosa deve essere considerato come separatore si passa a questa funzione un'espressione regolare. Facciamo l'esempio di fare il sorting delle chiavi:

$info = "root:x:0:0:root:/root:/bin/bash";
@dati = split( /:/, $info );
print "i dati sono @dati\n";

L'array @ARGV contiente gli argomenti passati allo script tramite linea di comando. $#ARGV* è pari al numero di argomenti meno 1 perchè in *$ARGV[0] è contenuto il primo argomento.

Le operazioni su array in Perl (incluse shift e pop) operano su @ARGV implicitamente al di fuori delle funzioni.

Facciamo l'esempio di fare la stampa di tutti gli argomenti:

foreach (@ARGV) {
    print "$_\n";
}

Facciamo l'esempio di prendere il primo argomento:

my $number = shift or die "Usage: $0 NUMBER\n";

Caso Speciale

ARGV ha un caso speciale. Se si legge da un null file handle <>, Perl tratterà ogni elemento in @ARGV come se fosse il nome di un file da aprire in lettura.

Se @ARGV è vuoto, Perl leggerà da standard input . Nota che $ARGV contiene il nome del file corrente mentre si legge da <>.

Un esempio di processare il contenuto di ogni file passato come argomento è il seguente:

while (<>) {
    ...
}