perl:variables_et_structures_de_donnees
Différences
Ci-dessous, les différences entre deux révisions de la page.
Les deux révisions précédentesRévision précédenteProchaine révision | Révision précédente | ||
perl:variables_et_structures_de_donnees [2011/05/18 09:39] – root | perl:variables_et_structures_de_donnees [2013/03/12 23:40] (Version actuelle) – root | ||
---|---|---|---|
Ligne 1: | Ligne 1: | ||
- | ====== 1. Généralités sur les variables ====== | + | ====== Généralités ====== |
+ | |||
+ | ====== 1. Les variables ====== | ||
===== Nommage ===== | ===== Nommage ===== | ||
Ligne 9: | Ligne 11: | ||
Dans le style de programmation Perl traditionnel, | Dans le style de programmation Perl traditionnel, | ||
+ | <code perl> | ||
$scalaire = " | $scalaire = " | ||
@liste = (" | @liste = (" | ||
%hash = (" | %hash = (" | ||
+ | </ | ||
En Perl, on peut utiliser le même nom de variable pour des types de différents de manière indépendante. Par exemple, ces 3 variables co-existent et sont indépendantes : | En Perl, on peut utiliser le même nom de variable pour des types de différents de manière indépendante. Par exemple, ces 3 variables co-existent et sont indépendantes : | ||
+ | <code perl> | ||
$toto = " | $toto = " | ||
@toto = (" | @toto = (" | ||
%toto = (" | %toto = (" | ||
+ | </ | ||
**Note**: il existe quelques exceptions notables, dont le descripteur de fichier qui n'a pas de préfixe particulier et utilise traditionnellement des majuscules (ex: open(HANDLE, | **Note**: il existe quelques exceptions notables, dont le descripteur de fichier qui n'a pas de préfixe particulier et utilise traditionnellement des majuscules (ex: open(HANDLE, | ||
Ligne 23: | Ligne 29: | ||
Les variables en Perl n'ont pas besoin d' | Les variables en Perl n'ont pas besoin d' | ||
+ | <code perl> | ||
for ($i = 0; $i < 5; $i++) { ... } | for ($i = 0; $i < 5; $i++) { ... } | ||
+ | </ | ||
Cependant, en pratique et notamment lorsqu' | Cependant, en pratique et notamment lorsqu' | ||
+ | <code perl> | ||
use strict; | use strict; | ||
my $i; | my $i; | ||
for ($i = 0; $i < 5; $++) ... | for ($i = 0; $i < 5; $++) ... | ||
+ | </ | ||
**Note**: la directive **use strict** dans le dernier exemple indique au compilateur de Perl que nous voulons vérifier que toutes les variables utilisées sont bien déclarées au préalable, et générer une erreur le cas échéant. | **Note**: la directive **use strict** dans le dernier exemple indique au compilateur de Perl que nous voulons vérifier que toutes les variables utilisées sont bien déclarées au préalable, et générer une erreur le cas échéant. | ||
Ligne 35: | Ligne 45: | ||
Une variable peut ne pas avoir de valeur, elle est alors **indéfinie** (on pourrait dire non **initalisée** pour comparer au C). Cela veut dire que d'une part une " | Une variable peut ne pas avoir de valeur, elle est alors **indéfinie** (on pourrait dire non **initalisée** pour comparer au C). Cela veut dire que d'une part une " | ||
+ | <code perl> | ||
# | # | ||
| | ||
my $message; | my $message; | ||
print " | print " | ||
+ | </ | ||
... va générer le //warning// suivant lors de l' | ... va générer le //warning// suivant lors de l' | ||
+ | <code perl> | ||
# $toto n' | # $toto n' | ||
my $toto; # $toto est déclarée et peut être utilisée, mais n'est pas définie | my $toto; # $toto est déclarée et peut être utilisée, mais n'est pas définie | ||
Ligne 47: | Ligne 59: | ||
$toto = 42; # $toto est définie | $toto = 42; # $toto est définie | ||
$toto = undef; # $toto n'est plus définie | $toto = undef; # $toto n'est plus définie | ||
+ | </ | ||
**Note**: on ne peut pas " | **Note**: on ne peut pas " | ||
Ligne 58: | Ligne 71: | ||
* une référence (que nous verrons plus tard) | * une référence (que nous verrons plus tard) | ||
+ | <code perl> | ||
my $int = 42; | my $int = 42; | ||
my $float = 42.53; | my $float = 42.53; | ||
my $string = " | my $string = " | ||
my $string2 = ' | my $string2 = ' | ||
+ | </ | ||
Perl permet de passer d'une représentation à une autre de manière transparente. Le point délicat consiste à comprendre quand le changement de représentation a lieu: on parle alors de contexte d'une opération. Voici par exemple deux façons de considérer la valeur " | Perl permet de passer d'une représentation à une autre de manière transparente. Le point délicat consiste à comprendre quand le changement de représentation a lieu: on parle alors de contexte d'une opération. Voici par exemple deux façons de considérer la valeur " | ||
+ | <code perl> | ||
my $val = 42; | my $val = 42; | ||
print "la valeur numérique n'est pas nulle" if $val != 0; | print "la valeur numérique n'est pas nulle" if $val != 0; | ||
Ligne 70: | Ligne 86: | ||
my $int = $val + 1; # $int vaut 43 | my $int = $val + 1; # $int vaut 43 | ||
my $string = $val . " le monde"; | my $string = $val . " le monde"; | ||
+ | </ | ||
S'il est toujours possible de transformer une valeur entière en une chaîne de caractère (en utilisant sa représentation décimale, éventuellement en " | S'il est toujours possible de transformer une valeur entière en une chaîne de caractère (en utilisant sa représentation décimale, éventuellement en " | ||
+ | <code perl> | ||
print " | print " | ||
print "- 42" + 1; # Affiche 1 | print "- 42" + 1; # Affiche 1 | ||
+ | </ | ||
**Note**: certains opérateurs (comme la division) utilisent un contexte " | **Note**: certains opérateurs (comme la division) utilisent un contexte " | ||
- | < | + | < |
my $age = 24; | my $age = 24; | ||
my $majeur = ($age >= 18) ? true : false; | my $majeur = ($age >= 18) ? true : false; | ||
</ | </ | ||
+ | |||
$majeur prendra la valeur true car 24 supérieur à 18, dans le cas contraire la variable aurait pris la valeur false. | $majeur prendra la valeur true car 24 supérieur à 18, dans le cas contraire la variable aurait pris la valeur false. | ||
Ligne 87: | Ligne 106: | ||
Leur contexte est bien entendu entier, et tout scalaire impliqué dans une opération arithmétique est (éventuellement) converti en valeur numérique. On retrouve les opérateurs classiques : | Leur contexte est bien entendu entier, et tout scalaire impliqué dans une opération arithmétique est (éventuellement) converti en valeur numérique. On retrouve les opérateurs classiques : | ||
+ | <code perl> | ||
$n = ($x / 2 + 5) * 3 - $y; | $n = ($x / 2 + 5) * 3 - $y; | ||
$n += 10; | $n += 10; | ||
$n++; | $n++; | ||
+ | </ | ||
Pour comparer des valeurs arithmétiques, | Pour comparer des valeurs arithmétiques, | ||
- | | + | <code perl> |
+ | my $a = 5; | ||
my $b = 9; | my $b = 9; | ||
print " | print " | ||
print " | print " | ||
print " | print " | ||
+ | </ | ||
===== Opérateurs de chaîne ===== | ===== Opérateurs de chaîne ===== | ||
Leur conversion transforme automatiquement toute valeur numérique impliquée en sa représentation décimale. **Note**: si vous voulez plus de contrôle sur cette conversion, il faut l' | Leur conversion transforme automatiquement toute valeur numérique impliquée en sa représentation décimale. **Note**: si vous voulez plus de contrôle sur cette conversion, il faut l' | ||
+ | <code perl> | ||
$t = " | $t = " | ||
$t = $t . " le monde"; | $t = $t . " le monde"; | ||
+ | </ | ||
La plupart des manipulations intéressantes avec les chaînes se font via les expressions régulières. On trouve bien sûr les fonctions basiques comme //length//, //index// et //substr// par exemple. | La plupart des manipulations intéressantes avec les chaînes se font via les expressions régulières. On trouve bien sûr les fonctions basiques comme //length//, //index// et //substr// par exemple. | ||
Pour comparer des chaînes, on utilise les opérateurs **eq** et **ne** dédiés à cet effet : | Pour comparer des chaînes, on utilise les opérateurs **eq** et **ne** dédiés à cet effet : | ||
+ | <code perl> | ||
my $u = " | my $u = " | ||
my $v = " | my $v = " | ||
print " | print " | ||
print " | print " | ||
+ | </ | ||
====== 3. Les listes ====== | ====== 3. Les listes ====== | ||
Cette structure de donnée permet à la fois de gérer des tableaux et des listes de façon simple. Les éléments d'une liste en Perl sont des scalaires : | Cette structure de donnée permet à la fois de gérer des tableaux et des listes de façon simple. Les éléments d'une liste en Perl sont des scalaires : | ||
+ | <code perl> | ||
my @liste = (1, " | my @liste = (1, " | ||
+ | </ | ||
Pour accéder à un élément de la liste, il existe plusieurs moyens : | Pour accéder à un élément de la liste, il existe plusieurs moyens : | ||
+ | <code perl> | ||
my $a = shift(@liste); | my $a = shift(@liste); | ||
my $b = $liste[0]; # $b vaut " | my $b = $liste[0]; # $b vaut " | ||
my $c = $liste[-1]; # $c vaut " | my $c = $liste[-1]; # $c vaut " | ||
my (undef, $d) = @liste; # $d vaut " | my (undef, $d) = @liste; # $d vaut " | ||
+ | </ | ||
Pour obtenir la taille d'une liste : | Pour obtenir la taille d'une liste : | ||
+ | <code perl> | ||
my $size = @liste; | my $size = @liste; | ||
my $size = scalar(@liste); | my $size = scalar(@liste); | ||
my $size = $#liste + 1; | my $size = $#liste + 1; | ||
+ | </ | ||
**Note**: nous reviendrons sur les conversions entre listes et scalaires plus tard. | **Note**: nous reviendrons sur les conversions entre listes et scalaires plus tard. | ||
Ligne 133: | Ligne 166: | ||
* Méthode alternative pour construire une liste : | * Méthode alternative pour construire une liste : | ||
+ | <code perl> | ||
@liste = qw/Hello world !\n/; | @liste = qw/Hello world !\n/; | ||
@liste = split(/ /, "Hello world !\n"); | @liste = split(/ /, "Hello world !\n"); | ||
+ | </ | ||
* Extraire une partie de la liste (voir //splice// également): | * Extraire une partie de la liste (voir //splice// également): | ||
+ | <code perl> | ||
@extrait = @liste[1..2]; | @extrait = @liste[1..2]; | ||
+ | </ | ||
* Concaténer les éléments d'une liste (dans un scalaire): | * Concaténer les éléments d'une liste (dans un scalaire): | ||
+ | <code perl> | ||
$phrase = join(' ', @mots); | $phrase = join(' ', @mots); | ||
+ | </ | ||
* Ajouter un élément à une liste: | * Ajouter un élément à une liste: | ||
+ | <code perl> | ||
push @liste, ' | push @liste, ' | ||
+ | </ | ||
* Retirer le premier élément de la liste: | * Retirer le premier élément de la liste: | ||
+ | <code perl> | ||
$element = shift @liste; | $element = shift @liste; | ||
+ | </ | ||
* Retirer un élément quelconque: | * Retirer un élément quelconque: | ||
+ | <code perl> | ||
delete $liste[2]; # Différent de $liste[2] = undef; ! | delete $liste[2]; # Différent de $liste[2] = undef; ! | ||
+ | </ | ||
* Trier une liste: | * Trier une liste: | ||
+ | <code perl> | ||
@direct = sort @liste; | @direct = sort @liste; | ||
@inverse = sort { ! $a <=> $b } @liste; | @inverse = sort { ! $a <=> $b } @liste; | ||
+ | </ | ||
* Filtrer une liste: | * Filtrer une liste: | ||
+ | <code perl> | ||
@selection = grep { $_ > 10 } @liste; | @selection = grep { $_ > 10 } @liste; | ||
+ | </ | ||
* Transformer les éléments d'une liste un par un: | * Transformer les éléments d'une liste un par un: | ||
+ | <code perl> | ||
@resultat = map { $_ * 2 } @liste; | @resultat = map { $_ * 2 } @liste; | ||
+ | </ | ||
===== Parcours ===== | ===== Parcours ===== | ||
Une des opérations les plus courantes en Perl consiste à parcourir les éléments d'une liste un par un. Il existe de nombreuses façons de le faire, dont les plus courantes sont : | Une des opérations les plus courantes en Perl consiste à parcourir les éléments d'une liste un par un. Il existe de nombreuses façons de le faire, dont les plus courantes sont : | ||
+ | <code perl> | ||
foreach $mot (@hello) { print " | foreach $mot (@hello) { print " | ||
foreach (@hello) { print $_; } | foreach (@hello) { print $_; } | ||
foreach (@hello) { print; } | foreach (@hello) { print; } | ||
print foreach @hello; | print foreach @hello; | ||
+ | </ | ||
Il est possible dans une structure de contrôle d' | Il est possible dans une structure de contrôle d' | ||
Ligne 171: | Ligne 223: | ||
Exemple de déclaration et d' | Exemple de déclaration et d' | ||
+ | <code perl> | ||
# Intialisation | # Intialisation | ||
my %menu = ( | my %menu = ( | ||
Ligne 185: | Ligne 237: | ||
# Lecture | # Lecture | ||
print "Plat: " | print "Plat: " | ||
+ | </ | ||
**Note**: on peut trouver des intialisations où le symbole **=>** est simplement une virgule, Perl pouvant effectivement considérer un tableau associatif sous sa forme "à plat", c' | **Note**: on peut trouver des intialisations où le symbole **=>** est simplement une virgule, Perl pouvant effectivement considérer un tableau associatif sous sa forme "à plat", c' | ||
Ligne 192: | Ligne 244: | ||
* Obtenir la liste des clés (indices) : | * Obtenir la liste des clés (indices) : | ||
+ | <code perl> | ||
my @cle = keys %menu; | my @cle = keys %menu; | ||
+ | </ | ||
* Vériier la présence d'une clé : | * Vériier la présence d'une clé : | ||
+ | <code perl> | ||
print "Le menu a un prix" if defined $menu{' | print "Le menu a un prix" if defined $menu{' | ||
+ | </ | ||
* Ajouter un élément quelconque : | * Ajouter un élément quelconque : | ||
- | | + | <code perl> |
+ | $menu($info) = " | ||
+ | </ | ||
* Retirer un élément quelconque : | * Retirer un élément quelconque : | ||
+ | <code perl> | ||
delete $menu{' | delete $menu{' | ||
+ | </ | ||
===== Parcours ===== | ===== Parcours ===== | ||
Les hashes Perl ne sont pas " | Les hashes Perl ne sont pas " | ||
+ | <code perl> | ||
while (($cle, $val) = each %menu) { | while (($cle, $val) = each %menu) { | ||
print "$cle: $val\n"; | print "$cle: $val\n"; | ||
} | } | ||
+ | </ | ||
On peut également extraire d' | On peut également extraire d' | ||
+ | <code perl> | ||
print "$_: $menu{$_}\n" | print "$_: $menu{$_}\n" | ||
+ | </ | ||
====== 5. Contextes liste et scalaire ====== | ====== 5. Contextes liste et scalaire ====== | ||
Ligne 221: | Ligne 278: | ||
Par exemple, une liste évaluée dans un contexte scalaire renvoie le nombre de ses éléments. L' | Par exemple, une liste évaluée dans un contexte scalaire renvoie le nombre de ses éléments. L' | ||
+ | <code perl> | ||
if (@ARGV ====== 2) ... # Le nombre d' | if (@ARGV ====== 2) ... # Le nombre d' | ||
+ | </ | ||
On peut changer le contexte simplement en comparant avec une liste, et cette-fois ce sont bien les éléments de //@ARGV// qui seront pris en comptes : | On peut changer le contexte simplement en comparant avec une liste, et cette-fois ce sont bien les éléments de //@ARGV// qui seront pris en comptes : | ||
+ | <code perl> | ||
if (@ARGV ====== (' | if (@ARGV ====== (' | ||
+ | </ | ||
**Note 1**: //print// sait automatiquement afficher une liste, mais il le fait en concaténant les éléments. On peut utiliser //print join(" | **Note 1**: //print// sait automatiquement afficher une liste, mais il le fait en concaténant les éléments. On peut utiliser //print join(" | ||
Ligne 231: | Ligne 292: | ||
Il existe d' | Il existe d' | ||
- |
perl/variables_et_structures_de_donnees.1305711545.txt.gz · Dernière modification : 2011/05/18 09:39 de root