Les données en perl ne sont pas typées2.1, mais il existe trois grands types de structure de données : les scalaires, les tableaux et les tableaux associatifs.
Ce sont les chaînes de caractères, les nombres et les références. Voici les conventions utilisées par perl dans leur représentation :
Les chaînes de caractères ne sont limitées en taille que par la mémoire disponible, et elles peuvent contenir le caractère nul.
chaîne se fait de manière automatique :
12345 représente la même chose que "12345". La
différence se fera lors de l'application d'une fonction :
(log() implique un nombre, substr() implique une
chaîne de caractères).
Une valeur scalaire est interprétée comme FALSE dans un contexte booléen si c'est une chaîne vide ou le nombre 0 (ou son équivalent en chaîne "0").
Il y a en fait deux types de scalaires nuls : defined et undefined. La fonction defined() peut être utilisée pour déterminer ce type. Elle renvoie 1 si la valeur est définie, 0 sinon. Une valeur est retournée comme undefined quand elle n'a pas d'existence réelle (erreur, fin de fichier, utilisation d'une variable non initialisée).
Elles sont toujours précédées d'un signe $. Les noms de variables peuvent contenir des caractères numériques ou
alphanumériques. Les noms qui commencent par un chiffre ne peuvent
être composés que de chiffres. Les noms qui ne commencent ni par un
chiffre, ni par une lettre, ni par le caractère _ sont limités
à un caractère (la plupart sont des noms de variables pré-définies de
perl, décrites dans le chapitre 13).
Notons tout de suite l'existence d'une variable scalaire qui a la particularité d'être l'argument par défaut de nombreuses fonctions : $_. Nous reviendrons souvent sur cette variable au caractère particulier.
Pour donner un exemple d'utilisation des variables, nous allons revenir sur la notion d'interpolation de chaînes de caractères exposée plus haut :
$a = 12; $b = "Test"; # Ci-dessous : interpolation de la valeur. $c = "Valeur de a : $a"; # ce qui donne la chaîne "Valeur de a : 12" # Ci-dessous : pas d'interpolation de la valeur. $d = 'Valeur de b : $b'; # ce qui donne la chaîne "Valeur de b : $b"
Une liste est un ensemble de valeurs scalaires2.3, que l'on peut construire de diverses manières. La plus intuitive est l'énumération des éléments entre parenthèses, en les séparant par des virgules :
(1, "chaine", 0x44, $var)
La liste vide est représentée par ().
Il existe également une autre fonction de construction de tableaux, qui clarifie souvent l'écriture des scripts. C'est la fonction qw2.4, qui permet de faire une énumération des éléments de la liste en les séparant uniquement par des espaces, d'où un gain de lisibilité. Par exemple :
@tableau = qw(Facile de construire une liste à 8 éléments.);
Les listes sont stockées dans des variables de type tableau. Ces tableaux, indexés par des entiers et commençant à l'index 0, permettent d'accéder directement à certaines valeurs de la liste.
Les variables sont précédées d'un signe @ lorsqu'on manipule le tableau entier : @tableau2.5
Un tableau étant constitué uniquement de valeurs scalaires, lorsque l'on veut accéder à une des valeurs du tableau, en précisant son index entre crochets, celle-ci est donc scalaire, et il faut donc écrire $tableau[2].
Il existe ce qu'on appelle des tranches de tableaux, qui sont
notées ainsi :
@tableau[2,5], @tableau[2 .. 5].
Pour obtenir le nombre d'éléments d'un tableau, on peut utiliser la notation $#tableau, qui renvoie l'index de fin du tableau (attention, les index commencent à zéro), ou utiliser la fonction scalar(@tableau), qui renvoie le nombre d'éléments contenus dans le tableau.
Certaines personnes vous diront qu'il suffit d'utiliser la variable de tableau dans un contexte scalaire (par exemple une addition), ce qui est syntaxiquement exact, mais mon expérience personnelle m'a conforté dans l'utilisation de scalar, qui a le mérite de rendre la conversion explicite. À vous de choisir... Comme l'exprime de manière appropriée un des slogans de perl : Il y a plus d'une manière de faire2.6.
On peut sans problème effectuer des affectations de liste à liste, ce qui donne par exemple un moyen efficace d'échanger deux variables :
($a, $b) = ($b, $a); @tableau1 = @tableau2;
De la même manière que pour les variables scalaires, la variable @_ est prise comme argument par défaut pour de nombreuses fonctions.
Ce sont des hash-tables (d'autres langages utilisent le terme de dictionnaires) gérées de manière transparente par perl. Ce sont donc des tableaux indexés par des chaînes de caractères.
Ce sont en fait des listes contenant des couples (clé, valeur). Leur construction s'effectue de la même manière que pour une liste :
( "cle1" => "valeur1", "cle2" => "valeur2" );
Il faut noter ici que l'opérateur => n'est en fait qu'un
synonyme de ,. Il est cependant possible qu'il obtienne une
signification particulière dans les prochaines versions de perl.
De manière analogue aux listes, on s'adresse à l'ensemble du tableau associatif en précédant son nom par le caractère % :
%hash = (
"cle1" => "valeur1",
"cle2" => "valeur2"
);
%hash2 = %hash1;
On accède ensuite à chacun de ses éléments en précisant la chaîne
d'indexation entre accolades. N'oubliez pas que comme pour les listes,
les éléments d'un tableau associatif sont des valeurs scalaires, donc
qu'elles doivent être précédées d'un dollar ($).
print $hash{'cle2'};
$hash{"cle3"} = 12;