Les références peuvent être complexes, c'est pourquoi nous avons simplifié toutes les informations que nous avons trouvées pour les rendre plus accessibles. Leur puissance est indéniable et elles sont essentielles pour la programmation en Perl. Cependant, nous sommes conscients qu'il est possible que nous ayons omis des détails importants. N'hésitez pas à nous faire part de vos commentaires et suggestions.

$array_ref  = \@array;         # $array_ref est une référence vers @array
$hash_ref   = \%hash;          # $hash_ref est une référence vers %hash
$scalar_ref = \$scalar;        # $scalar_ref est une référence vers $scalar

$xy         = $array_ref;      # $xy est une copie d'une référence vers @array          => c'est une référence vers @array
$array[2]   = $hash_ref;       # $array[3] est une copie d'une référence vers %hash           => c'est une référence vers %hash
$scalar     = $array[2]        # $scalar est une copie d'une copie d'une référence vers %hash => c'est une référence vers %hash

$array_ref  = [ 1, "foo", undef, 13 ]; # $array_ref est une référence vers le tableau (1, "foo", undef, 13)
$hash_ref   = { APR => 4, AUG => 8 };  # $hash_ref est une référence vers le hachage (APR => 4, AUG => 8) ou (APR, 4, AUG, 8)
Note : les crochets sont les mêmes que ceux utilisés pour accéder à un élément !

@array      = (1, 2, 3);        $array_ref = \@array;  peut être écrit    $array_ref = [ 1, 2, 3 ];
%hash       = (APR, 4, AUG, 8); $hash_ref  = \%hash;   peut être écrit    $hash_ref  = { APR => 4, AUG => 8 }

Dans la deuxième forme (abrégée), nous n'avons pas de variable de tableau ou de hachage explicitement : nous appelons cela "tableau anonyme" et "hachage anonyme".

Inversion de règle ou déséréférencement : (Alternative : Déséréférencement avec une flèche : recommandé)

@a = @{$array_ref};          Une copie du tableau  qui est référencé (peut être une structure de bug donc soyez prudent)
%h = %{$hash_ref};           Une copie du hachage   qui est référencé (peut être une structure de bug donc soyez prudent)
$s = ${$scalar_ref};         Une copie du scalaire qui est référencé (pas si grand...)

et maintenant pour les éléments du tableau ou du hachage :
avec : $arref = \@array; $href  = \%hash; $scaref = \$scalar

                      $array[3]=2;  $  array [3]=2
est équivalent à   ${$arref}[3]=2;  ${$arref}[3]=2
                       $hash{3}=2;  $   hash {3}=2
est équivalent à    ${$href}{3}=2;  ${$ href}{3}=2

                                    @  array  =
                                    @{$arref} =
                                    %  hash   =
                                    %{$ href}  =
                                    $  scala  =
                                    ${$scref} =

                                     {$     }

Cela signifie que nous pouvons coder sans référence et changer votre variable à la fin de var en {$var_ref} dans tous les cas !!!

Note2 : une référence est également un scalaire, mais faites attention :
avec : $array_ref = \@array; $hash_ref  = \%hash; $scalar_ref = \$scalar
$a = ${$array_ref};  $a est un tableau dans un "contexte scalaire", donc équivalent à "scalaire @array" ou $(@array) ou $a = @array; $a est le nombre d'éléments du tableau !
$h = ${$hash_ref};   $h est un hachage dans un "contexte scalaire", donc équivalent à "scalaire $hash" ou $(%hash) ou $h = %hash;  $h a une taille de stockage du hachage (à éviter)
$s = ${$scalar_ref}; $s est une copie du scalaire, donc équivalent à "$s = $scalar... donc ${\$scalar} est équivalent à $scalar !

Note1 : si nous déséférencions une référence, nous obtenons la variable qui peut être de tous types ! Logique
Note2 : si nous référençons une déséférenciation, nous obtenons la référence, logique !
Note3 : Pourquoi feriez-vous cela ?...

Cas trivial et simplification, même si cela fonctionne...
${\$scalar} => $scalar
@{\@array}  => @array
%{\%hash}   => %array

\${$scalar_ref} => $scalar_ref
\@{$array_ref}  => $array_ref
\%{$hash_ref}   => $array_ref

Vous ne devriez donc jamais avoir ceci :
${\$ sûr à supprimer si la variable est un scalaire
@{\@ sûr à supprimer si la variable est un tableau
%{\% sûr à supprimer si la variable est un hachage
\${$ sûr à supprimer si la variable est une référence scalaire
\@{$ sûr à supprimer si la variable est une référence de tableau
\%{$ sûr à supprimer si la variable est une référence de hachage

Note1 : n'oubliez pas de supprimer le crochet de fin !

mais qu'en est-il de cela :
\${$array_ref}[1]         la référence est appliquée à la fin alors

1. ${$array_ref}[1]       nous avons un élément du tableau
2. \${$array_ref}[1]      nous avons une référence scalaire de l'élément du tableau

Comme vous pouvez le voir, il n'est pas sûr de le supprimer car la variable n'est pas un scalaire....