Variabili e struttura dei dati

Negli script in perl, i dati temporanei sono tenuti in variabili; queste si comportano a grandi linee come le variabili d'ambiente, ma non sono la stessa cosa.

Il tipo principale di variabile, in perl, è lo scalare. Uno scalare è una stringa o un numero, che non ha bisogno di essere convertito come in C. Inoltre, tutti gli scalari possono essere interi o numeri in virgola mobile, che perl proverà a rappresentare come interi, se possibile, per migliorare la velocità di esecuzione.

Ogni variabile ha un nome, che inizia sempre con un carattere speciale, che ne indica il tipo, seguito da un nome di almeno una lettera. Tutti i nomi delle variabili sono case-sensitive, per cui $variabile è diverso da $Variabile e da $VaRiAbIlE.

Il carattere speciale di cui si parlava è il simbolo del dollaro ($), ed è utilizzato sia quando si assegna una variabile, sia quando si usa il suo valore.

Ecco qualche esempio:

$bla = 1;

$bla = 1;

$ops = $bla +1;

$bla = "ciaon";
print $bla;

Negli script di shell, il carattere $ è utilizzato solo quando si richiede il valore di una variabile, non quando lo si assegna:

bla = 1
echo $bla

Negli script, le stringhe sono racchiuse tra apici ('') o doppi apici (""), con la differenza che tra doppi apici ("") le variabili verranno interpolate, mentre tra apici singoli ('') le variabili verranno considerate letteralmente.

Ogni volta che può nascere un'ambiguità come quanto lungo può essere il nome di una variabile, $variabile può essere scritto come ${variabile}.

$bla = "eeek!";
$blabla = "uff!";
print "$blablan";

print "${bla}blan"

$bla = "eeek!";
$msg = "$bla mi hai spaventato";

$msg2 = '$bla mi hai spaventato';

In perl, come anche nello shell scripting (e diversamente dal C) le variabili non hanno bisogno di essere dichiarate prima di essere usate: la prima volta che si utilizza una variabile, la si dichiara. Tentare di leggere un valore inesistente porta ad avere una stringa vuota che, in contesto numerico, è interpretata come 0.

Le variabili il cui nome inizia (dopo il canonico $) con un carattere speciale, che non è una lettera, sono considerate 'riservate' (una lista la si può trovare digitando man perlvar con perl5). Queste variabili cambiano alcuni comportamenti del perl a seconda del proprio valore. Una di queste è la variabile $_ , che è lasciata libera in modo da permettere all'utente di inserirvi dati in modo temporaneo, ed è utile anche per un altro aspetto: molte funzioni operano con $_ se non è fornito alcun valore.

$_ = "bla bla blan";
print;

Non tutte le funzioni assumono $_ come parametro di default, anche se questo funziona con tutte le funzioni in cui ha senso assumere la variabile $_. In caso di dubbio, si può ricorrere ad un piccolo script di un paio di righe per vedere se la funzione che interessa può lavorare con $_.

Altre importanti variabili riservate sono:

Un altro tipo di dato è l'array; un array è una lista numerata di scalari. L'array è identificato dal simbolo chiocciola (@), allo stesso modi in cui dollaro ($) indica lo scalare.

Tutti gli array sono numerati a partire da 0: il primo elemento assume indice 0, il secondo 1 e così via. Gli elementi sono inseriti in un array sotto forma di una lista separata da virgole e tra parentesi. L'elemento n-esimo del generico array @array è definito come $array[n]. In questo caso si utilizza $ al posto di @ perchè ci si riferisce ad uno scalare, e non a tutto l'array.

Facciamo qualche esempio. Cominciamo col definire una variabile $var:

$var = 1;

Vediamo ora come definire un array. Un elemento è definito con il valore di $var:

@array = ("bla", 34, "uff", $var);

Ora prendiamo il secondo valore dell'array e lo assegnamo alla variabile $secondo, che diventa 34:

$secondo = $array[1];

Ora definiamo un nuovo array @eek, che prenda un sottoinsieme degli elementi di @array, definito in precedenza:

@eek = @array[0, 2];

@eek diventa ("bla", "uff"), poichè prende il primo e terzo valore di @array.

Vediamo come collegare due array:

@urka = (@array, @eek);

Questo NON è un array di array, poichè gli array sono sempre array di scalari. Quello che succede, è che tutti i valori di @array e @eek sono copiati in @urka, che contiene ("bla", 34, "uff", 1, "bla", "uff").

Ci sono funzioni che operano sugli array, aggiungendo elementi alla fine, togliendone, estraendo quelli che soddisfano una data condizione, ordinandoli etc. Per conoscere la cardinalità di un array, si utilizza il carattere cancelletto (#) dopo la chiocciola. Ad esempio l'espressione @#array indica il numero di elementi di @array meno uno. Per gli array vuoti, questa viene assunta come -1.

@array = ("bla", "bla", "bla", "bla");
print $#array, "n";

Per esempio questo spezzone di codice visualizzerà 3, e non 4.

Nota: il simbolo cancelletto (#) in questo caso ($#array) non introduce un commento.

Abbiamo visto che in una stringa tra doppi apici (""), le variabili sono interpolate, in modo che "bla$eek" significa "blabla" se $eek contiene "bla". Questo si applica anche agli array.

Bisogna fare però attenzione ad una cosa:

print "il mio indirizzo è root@localhostn"; <- NON funziona
print "il mio indirizzo è root@localhostn"; <- funziona

Questo perché il carattere chiocciola (@) è considerato speciale e, se lo si vuole visualizzare letteralmente (ovvero considerarlo come semplice carattere, non come array), bisogna introdurlo con il carattere back-slash () , che protegge il carattere seguente da un'interpretazione diversa da quella letterale, come succede con altri caratteri come i doppi apici (") o il punto (.). In questo caso, @ è detto carattere di escape; vediamone altri:

Chi vuole divertirsi, provi a lanciare questo script:

#!/usr/bin/perl
print "a";

Qui a è considerato un carattere di escape, e non verrà visualizzato a, come vi sareste potuti aspettare. Per visualizzare 'a', lo script deve essere:

#!/usr/bin/perl
print "an";

n non è strettamente necessario, ma è utile per visualizzare 'a' su una linea vuota senza il prompt

In alternativa, si può scrivere quanto segue:

print 'il mio indirizzo è root@localhost', "n";

che visualizza

il mio indirizzo è root@localhost

Attenzione però a non introdurre nell'espressione precedente variabili che devono essere interpolate: semplicemente non si avrebbe l'interpolazione!

Il terzo (ed ultimo, per quanto ci riguarda) tipo di dati in perl è l'hash, detto anche array associativo. Gli hash sono introdotti dal simbolo percentuale (%) e contengono scalari indicizzati da altri scalari. Il modo migliore per capire gli hash è di pensare ad un vocabolario: ogni hash contiene valori (le definizioni nel vocabolario), assegnati agli identificatori (le parole), e le operazioni base sono aggiungere o rimuovere parole o cambiare il loro valore, controllando se ognuna di queste parole esiste o meno nel vocabolario.

%bla = ("eek", 34, "uff", 18, "zero", "niente);

Nell'espressione precedente tutte le stringhe avrebbero potuto essere scritte anche tra ''.

Per chiarezza, gli hash possono essere scritti anche come:

%bla = (
  "eek" => 34,
  "uff" => 18,
  "zero" => niente,
)

Continuiamo con gli esempi:

print $bla{"eek"}, "n";

visualizza 34

$s = 'zero';
@arr = ($bla{"uff"}, $bla{$s});

@arr diventa (18, "niente")

Questi tre tipi di variabili (scalari, array e hash) possono benissimo avere lo stesso nome: nello stesso codice si possono trovare lo scalare $abc, l'array @abc e l'hash %abc.
Vediamo un'ultima cosa: eseguiamo questo script:

#!/usr/bin/perl
print "Come ti chiami?n";
$nome = <STDIN>;
print "Ciao $nomen";

Lo script si interrompe chiedendoci il nostro nome (ma potrebbe chiedere qualunque altra informazione). Cosa sta succedendo? Beh, basterà sapere che il simbolo <STDIN> è l'handler del file di input standard, ovvero un file sempre aperto durante l'esecuzione del programma e che rappresenta (di default) la tastiera del terminale di chi esegue lo script.

Con la linea $nome = <STDIN> si dice allo script di immagazzinare nella variabile $nome quanto digitato dall'utente finchè conclude con il tasto invio. I canali standard di comunicazione sono 3 ed ad ognuno di questi è associato ad un handler:

STDOUT si può vedere come il canale attraverso il quale viene emesso l'output. STDERR è simile a STDOUT ma viene solitamente utilizzato per visualizzare i messaggi di errore.