Parece que me deparei com várias maneiras diferentes de encontrar o tamanho de uma matriz. Qual é a diferença entre esses três métodos?

my @arr = (2);
print scalar @arr; # First way to print array size

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

my $arrSize = @arr;
print $arrSize; # Third way to print array size

A primeira e a terceira maneira são as mesmas: elas avaliam uma matriz no contexto escalar. Eu consideraria essa a maneira padrão de obter o tamanho de uma matriz.

A segunda maneira, na verdade, retorna o último índice da matriz, que não é (geralmente) o mesmo que o tamanho da matriz.

Primeiro, o segundo não é equivalente aos outros dois. $#arrayretorna o último índice da matriz, que é um a menos que o tamanho da matriz.

Os outros dois são praticamente iguais. Você está simplesmente usando dois meios diferentes para criar um contexto escalar. Tudo se resume a uma questão de legibilidade.

Pessoalmente, prefiro o seguinte:

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

Acho mais claro que

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

e

my $size = @array;
say $size;

O último parece bem claro sozinho assim, mas acho que a linha extra tira a clareza quando parte de outro código. É útil para ensinar o que @arrayfaz no contexto escalar, e talvez se você quiser usar $sizemais de uma vez.

Isso obtém o tamanho forçando a matriz em um contexto escalar, no qual é avaliada como seu tamanho:

print scalar @arr;

Essa é outra maneira de forçar a matriz para um contexto escalar, pois está sendo atribuída a uma variável escalar:

my $arrSize = @arr;

Isso obtém o índice do último elemento da matriz, então, na verdade, é o tamanho menos 1 (assumindo que os índices iniciam em 0, o que é ajustável no Perl, embora isso seja geralmente uma má idéia):

print $#arr;

Este último não é realmente bom para obter o tamanho da matriz. Seria útil se você apenas deseja obter o último elemento da matriz:

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

Além disso, como você pode ver aqui no Stack Overflow, essa construção não é tratada corretamente pela maioria dos marcadores de sintaxe ...

Para usar a segunda maneira, adicione 1:

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

Todos os três dão o mesmo resultado se modificarmos um pouco o segundo:

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;

Exemplo:

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

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

A seção “Tipos de variáveis ​​Perl” da documentação do perlintro contém

A variável especial $#arrayinforma o índice do último elemento de uma matriz:

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

Você pode ser tentado a usar $#array + 1para informar quantos itens existem em uma matriz. Não se incomode. Por acaso, o uso de @arrayonde o Perl espera encontrar um valor escalar ("no contexto escalar") fornecerá o número de elementos na matriz:

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

A documentação da perldata também cobre isso na seção "Valores escalares" .

Se você avaliar uma matriz no contexto escalar, ela retornará o comprimento da matriz. (Observe que isso não é verdade para listas, que retornam o último valor, como o operador vírgula C, nem para funções internas, que retornam o que lhes apetecer retornar.) O seguinte sempre é verdadeiro:

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

Alguns programadores optam por usar uma conversão explícita para não deixar dúvidas:

$element_count = scalar(@whatever);

Anteriormente, na mesma seção, documenta como obter o índice do último elemento de uma matriz.

O comprimento de uma matriz é um valor escalar. Você pode encontrar o comprimento da matriz @daysavaliando $#days, como emcsh . No entanto, esse não é o comprimento da matriz; é o subscrito do último elemento, que é um valor diferente, pois normalmente existe um 0º elemento.

Existem várias maneiras de imprimir o tamanho da matriz. Aqui estão os significados de todos: Vamos dizer que nossa matriz émy @arr = (3,4);

Método 1: escalar

Este é o caminho certo para obter o tamanho das matrizes.

print scalar @arr;  # prints size, here 2

Método 2: número do índice

$#arrfornece o último índice de uma matriz. portanto, se a matriz tiver tamanho 10, seu último índice será 9.

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

Estamos adicionando 1 aqui, considerando a matriz como indexada em 0 . Mas, se não for zero, então, essa lógica falhará .

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

O exemplo acima imprime 6, porque definimos seu índice inicial como 4. Agora, o índice seria 5 e 6, com os elementos 3 e 4, respectivamente.

Método 3:

Quando uma matriz é usada no contexto escalar, ela retorna o tamanho da matriz

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

Na verdade, o método 3 e o método 1 são iguais.

De perldoc perldata , que deve ser seguro citar:

O seguinte é sempre verdadeiro:

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

Contanto que você não adicione $ # qualquer que seja ++ e aumente misteriosamente o tamanho ou sua matriz.

Os índices da matriz começam com 0.

e

Você pode truncar uma matriz para nada atribuindo a lista nula () a ela. Os seguintes são equivalentes:

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

O que me leva ao que eu estava procurando e como detectar a matriz está vazia. Eu encontrei se $ # empty == -1;

Que int(@array)tal ameaçar o argumento como escalar.

Para encontrar o tamanho de uma matriz, use a scalarpalavra-chave:

print scalar @array;

Para descobrir o último índice de uma matriz, existe $#(variável padrão Perl). Fornece o último índice de uma matriz. Quando uma matriz começa em 0, obtemos o tamanho da matriz adicionando uma a $#:

print "$#array+1";

Exemplo:

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

Resultado:

3

3