Tutoriel de référence et de déréférencement des tableaux Perl avec des exemples pratiques

Dans cet article, voyons comment référencer et déréférencer un tableau Perl avec des exemples. La référence n'est rien d'autre que l'emplacement ( adresse ) d'une autre variable. Les références peuvent être des tableaux, des hachages ou un extrait de code Perl. Les références accélèrent l'exécution du code Perl.

Référence Perl au tableau

Normalement, nous stockons la liste des éléments dans un tableau comme indiqué ci-dessous.

@array =  (“one”,”two”,”three”,”four”,”five”);

Pour affecter une référence de tableau dans une variable, utilisez l'opérateur barre oblique inverse (\) comme indiqué ci-dessous

$array_ref = \@array;

Si vous essayez d'imprimer la variable $array_ref, vous obtiendrez quelque chose comme ce qui suit.

ARRAY(0x1a2b3c)

La référence de tableau Perl peut également être transmise à une sous-routine comme indiqué ci-dessous.

sub add_numbers
{
  my $array_ref =  shift;
  .....
}  

@numbers = (11,2,3,45);

$array_ref = add_numbers(\@numbers);

Dans l'extrait de code ci-dessus, nous devons déréférencer le tableau, afin que la sous-routine puisse prendre les éléments du tableau d'origine.

Voici quelques-uns des avantages de passer la référence à un sous-programme, au lieu de passer le tableau entier.

Si nous passons le tableau à un sous-programme, Perl copie le tableau entier dans la variable @_. Lorsque le tableau est grand, ce n'est pas une méthode efficace.
Lorsque nous voulons que le tableau d'origine soit modifié par la sous-routine, nous devons passer la référence du tableau.
Les références jouent un rôle essentiel dans la construction de structures de données complexes.

Nous pouvons prendre la référence d'un tableau anonyme dans la variable scalaire comme indiqué ci-dessous.

$array_ref = [ 11,2,3,45];

Remarque :Cet article fait partie de la série de didacticiels Perl en cours.

Tableau de déréférencement Perl

À l'intérieur du sous-programme, le déréférencement peut être effectué en utilisant l'une des méthodes indiquées ci-dessous.

La variable de référence peut être déréférencée comme indiqué ci-dessous. En utilisant cette méthode, nous pouvons prendre tous les éléments du tableau. C'est la même chose que @numbers.

@{ $array_ref };

Pour obtenir un élément particulier dans un tableau, procédez comme suit. Cette instruction donne le premier élément du tableau @numbers. C'est la même chose que $numbers[0]

$ { $array_ref }[0]

Au lieu de stocker la référence dans la variable, les éléments du tableau sont accessibles directement à partir de la variable intégrée Perl.

# Get all the elements of @numbers array.
@ { $_[0] }

# Get a particular element. This gives the first element of the array.
$ { $_[0] } [0]

Remarque : Si nous déréférencons une simple variable scalaire, nous pouvons omettre les accolades comme indiqué ci-dessous.

@$array_ref  # same as @{ $array_ref }

$$array_ref  # same as $ { $array_ref }

$_[0]         # not a simple scalar variable and this cant be dereferenced,

Stocker plusieurs références dans le tableau Perl

Utilisons l'extrait de code Perl suivant.

#Array contains source ip and destination ip
@IP = ('192.168.1.10','192.168.1.15'); 

#Array contains the source port and destination port numbers
@PORT = ("5000","5002"); 

#Sublayers of TCP layer
@TCP = ("Q931","H225","H245"); 

#Common layers are available in a TCP packet.
@LAYER = ("ETHERNET","IP",\@TCP); 

@PKT = (
         \@IP,
         \@PORT,
         \@LAYER
        );
#Storing the reference of @PKT array into the scalar variable.
$array_ref = \@PKT;

Pour comprendre le référencement du tableau, supposons qu'à partir de l'extrait de code ci-dessus, nous souhaitons accéder à la deuxième sous-couche ("H225") de la couche TCP. Cela peut être fait comme expliqué ci-dessous.

Tout d'abord, nous devons accéder au tableau LAYER. Ceci renvoie une référence du tableau @LAYER.

$ { $array_ref } [2]

Le $array_ref est une simple variable scalaire. Ainsi, les accolades peuvent être omises et elles peuvent également être écrites comme indiqué ci-dessous.

$$array_ref[2]

Ensuite, pour accéder au troisième élément/calque (de @LAYER) via cette référence.

$ { $ { $array_ref } [2] } [2]

Ceci renvoie l'adresse du tableau @TCP.

Enfin, nous pouvons obtenir la deuxième sous-couche de la couche TCP (à partir du tableau @TCP) comme indiqué ci-dessous.

$ { $ { $ { $array_ref } [2] } [2] } [1]

Ce qui précède semble assez compliqué et réduit la modularité du code. Il existe une disposition pour réécrire les déclarations ci-dessus et le rend plus facile pour les yeux de la manière suivante.

En Perl, $ { VAR } [ $y] peut être écrit comme VAR->[$y].

$ { $array_ref } [2]  is same as $array_ref->[2]

$ { $ { $array_ref } [2] } [2] is same as $array_ref->[2]->[2]

$ { $ { $ { $array_ref } [2] } [2] } [1] is same as $array_ref->[2]->[2]->[1]

Maintenant, en utilisant la règle de la "flèche vers le bas", nous pouvons la réécrire comme indiqué ci-dessous. Conformément à la règle de la "flèche tombante", nous ne pouvons pas supprimer la première flèche. C'est beaucoup plus facile à lire.

$array_ref->[2][2][1]