premièrement, le second n'est pas équivalent aux deux autres. $#array renvoie le dernier indice du tableau, qui est inférieur à la taille du tableau.

les deux autres sont pratiquement identiques. Vous utilisez simplement deux moyens différents pour créer un contexte scalaire. C'est une question de lisibilité.

je préfère personnellement ce qui suit:

say 0+@array;          # Represent @array as a number

je le trouve plus clair que

say scalar(@array);    # Represent @array as a scalar

et

my $size = @array;
say $size;

ce dernier a l'air assez clair seul comme ceci, mais je trouve que la ligne supplémentaire enlève de la clarté quand une partie d'un autre code. Il est utile pour enseigner ce que @array fait dans un contexte scalaire, et peut-être si vous voulez utiliser $size plus d'une fois.

cela obtient la taille en forçant le tableau dans un contexte scalaire, dans lequel il est évalué comme sa taille:

print scalar @arr;

c'est une autre façon de forcer le tableau dans un contexte scalaire, puisqu'il est assigné à une variable scalaire:

my $arrSize = @arr;

cela obtient l'indice du dernier élément dans le tableau, donc c'est en fait la taille moins 1 (en supposant que les indices commencent à 0, qui est réglable en Perl bien que faisant ainsi est habituellement une mauvaise idée):

print $#arr;

ce dernier n'est pas vraiment bon à utiliser pour obtenir la taille du tableau. Il serait utile si vous voulez juste pour obtenir le dernier élément du tableau:

my $lastElement = $arr[$#arr];

aussi, comme vous pouvez le voir ici sur le débordement de la pile, cette construction n'est pas gérée correctement par la plupart des surligneurs de syntaxe...

tous les trois donnent le même résultat si nous modifions un peu le second:

my @arr = (2, 4, 8, 10);

print "First result:\n";
print scalar @arr; 

print "\n\nSecond result:\n";
print $#arr + 1; # Shift numeration with +1 as it shows last index that starts with 0.

print "\n\nThird result:\n";
my $arrSize = @arr;
print $arrSize;

exemple:

my @a = (undef, undef);
my $size = @a;

warn "Size: " . $#a;   # Size: 1. It's not the size
warn "Size: " . $size; # Size: 2

pour utiliser la seconde voie, ajouter 1:

print $#arr + 1; # Second way to print array size

Le "Perl types de variables" de la section de la perlintro documentation contient

La variable spéciale $#array vous indique l'index du dernier élément d'un tableau:

print $mixed[$#mixed];       # last element, prints 1.23

Vous pourriez être tenté d'utiliser $#array + 1 pour vous indiquer le nombre d'éléments dans un tableau. Ne vous embêtez pas. Il se trouve que L'utilisation de @array où Perl s'attend à trouver un valeur scalaire ("dans un contexte scalaire") vous donne le nombre d'éléments dans le tableau:

if (@animals < 5) { ... }

la documentation perldata couvre également ce point dans la " section "valeurs scalaires".

Si vous évaluez un tableau dans un contexte scalaire, retourne la longueur de la matrice. (Notez que ce n'est pas le cas des listes, qui renvoient la dernière valeur, comme l'opérateur de virgule C, ni de fonctions intégrées, qui rendent ce qu'elles veulent.) Ce qui suit est toujours vrai:

scalar(@whatever) == $#whatever + 1;

certains programmeurs choisissent d'utiliser une conversion explicite pour ne laisser aucun doute:

$element_count = scalar(@whatever);

plus tôt dans la même section documente comment obtenir l'index du dernier élément d'un tableau.

La longueur d'un tableau est une valeur scalaire. Vous pouvez trouver la longueur du tableau @days en évaluant $#days , comme dans csh . Cependant, ce n'est pas la longueur du tableau; c'est l'indice du dernier élément, qui est un autre de valeur, car il ya habituellement un 0e élément.

il y a plusieurs façons d'Imprimer la taille du tableau. Voici les significations de tous: Disons que notre tableau est my @arr = (3,4);

Méthode 1: scalaire

Ce est la bonne façon d'obtenir la taille des tableaux.

print scalar @arr;  # prints size, here 2

Méthode 2: indice 151990920"

$#arr donne le dernier index d'un tableau. donc si array est de taille 10 alors son dernier indice serait 9.

print $#arr;     # prints 1, as last index is 1
print $#arr + 1; # Add 1 to last index to get array size

nous ajoutons 1 ici, considérant array comme 0-indexé . Mais, si elle n'est pas basée sur zéro alors, cette logique échouera .

perl -le 'local $[ = 4; my @arr=(3,4); print $#arr + 1;'   # prints 6

au-dessus de l'exemple imprime 6, parce que nous avons réglé son index initial à 4. Maintenant, l'indice serait de 5 et 6, avec les éléments 3 et 4 respectivement.

Méthode 3:

quand un tableau est utilisé dans un contexte scalaire, alors il renvoie la taille du tableau

my $size = @arr;
print $size;   # prints size, here 2

en fait, la méthode 3 et la méthode 1 sont les mêmes.

De perldoc perldata , qui devrait être bon pour la citation:

ce qui suit est toujours vrai:

scalar(@whatever) == $#whatever + 1;

juste tant que vous ne faites pas $#whatever++ et augmentez mystérieusement la taille ou votre tableau.

les indices des tableaux commencent par 0.

et

Vous pouvez tronquer un tableau vers le bas à zéro en lui assignant la liste nulle (). Sont équivalents:

    @whatever = ();
    $#whatever = -1;

ce qui m'amène à ce que je cherchais qui est comment détecter le tableau est vide. Je l'ai trouvé si $#vide == -1;

pour trouver la taille d'un tableau utilisez le scalar mot clé:

print scalar @array;

pour connaître le dernier index d'un tableau il y a $# (variable Perl par défaut). Il donne le dernier index d'un tableau. Comme un tableau commence à partir de 0, nous obtenons la taille du tableau en ajoutant un à $# :

print "$#array+1";

exemple:

my @a = qw(1 3 5);
print scalar @a, "\n";
print $#a+1, "\n";

sortie:

3

3

Qu'en est-il de int(@array) comme il menace l'argument comme scalaire.