Vind de grootte van een array in Perl

Het lijkt erop dat ik verschillende manieren ben tegengekomen om de grootte van een array te bepalen. Wat is het verschil tussen deze drie methoden?

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

Antwoord 1, autoriteit 100%

De eerste en derde manier zijn hetzelfde: ze evalueren een array in scalaire context. Ik zou dit beschouwen als de standaardmanier om de grootte van een array te krijgen.

De tweede manier retourneert in feite de laatste index van de array, die (meestal) niet hetzelfde is als de grootte van de array.

Antwoord 2, autoriteit 18%

Ten eerste is de tweede niet gelijk aan de andere twee. $#arrayretourneert de laatste index van de array, die één kleiner is dan de grootte van de array.

De andere twee zijn vrijwel hetzelfde. U gebruikt eenvoudig twee verschillende middelen om scalaire context te creëren. Het komt neer op een kwestie van leesbaarheid.

Persoonlijk geef ik de voorkeur aan het volgende:

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

Ik vind het duidelijker dan

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

en

my $size = @array;
say $size;

De laatste ziet er op zichzelf al vrij duidelijk uit, maar ik vind dat de extra regel de duidelijkheid wegneemt wanneer deze deel uitmaakt van andere code. Het is handig om te leren wat @arraydoet in scalaire context, en misschien als je $sizemeer dan eens wilt gebruiken.

Antwoord 3, autoriteit 13%

Dit krijgt de grootte door de array in een scalaire context te forceren, waarin deze wordt geëvalueerd als zijn grootte:

print scalar @arr;

Dit is een andere manier om de array in een scalaire context te forceren, aangezien deze wordt toegewezen aan een scalaire variabele:

my $arrSize = @arr;

Dit krijgt de index van het laatste element in de array, dus het is eigenlijk de grootte min 1 (ervan uitgaande dat indexen beginnen bij 0, wat aanpasbaar is in Perl, hoewel dit meestal een slecht idee is):

print $#arr;

Deze laatste is niet echt goed om te gebruiken voor het verkrijgen van de arraygrootte. Het zou handig zijn als je alleen het laatste element van de array wilt krijgen:

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

Ook, zoals je hier op Stack Overflow kunt zien, wordt deze constructie niet correct afgehandeld door de meeste syntaxis-highlighters…

Antwoord 4, autoriteit 3%

Als u de tweede manier wilt gebruiken, voegt u 1 toe:

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

Antwoord 5, autoriteit 2%

Alle drie geven hetzelfde resultaat als we de tweede een beetje aanpassen:

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;

Antwoord 6, autoriteit 2%

Voorbeeld:

my @a = (undef, undef);
my $size = @a;
warn "Size: " . $#a;   # Size: 1. It's not the size
warn "Size: " . $size; # Size: 2

Antwoord 7

De “Perl-variabele typen” sectie van de Perlintro Documentation bevat

De speciale variabele $#arrayvertelt u de index van het laatste element van een array:

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

U kunt in de verleiding komen om $#array + 1te gebruiken om u te vertellen hoeveel items er in een array zitten. Doe geen moeite. Zoals het gebeurt, met behulp van @arraywaar Perl verwacht een scalaire waarde te vinden (“in Scalar Context”) geeft u het aantal elementen in de array:

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

De PERLDATA-documentatie dekt dit ook in de ” scalaire waarden “sectie .

Als u een array in Scalaire context evalueert, retourneert deze de lengte van de array. (Merk op dat dit niet waar is voor lijsten, die de laatste waarde retourneren, zoals de C-komma-operator, noch van ingebouwde functies, die terugkomen wat ze voelen als retourneren.) Het volgende is altijd waar:

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

Sommige programmeurs kiezen ervoor om een expliciete conversie te gebruiken om niets te twijfelen:

$element_count = scalar(@whatever);

Eerder in dezelfde sectie wordt beschreven hoe u de index van het laatste element van een array kunt verkrijgen.

De lengte van een array is een scalaire waarde. Je kunt de lengte van array @daysvinden door $#dayste evalueren, zoals in csh. Dit is echter niet de lengte van de array; het is het subscript van het laatste element, wat een andere waarde is omdat er gewoonlijk een 0e element is.

Antwoord 8

Van perldoc perldata, wat veilig zou moeten zijn om te citeren:

Het volgende is altijd waar:

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

Zolang je niet $#whatever++ doet en op mysterieuze wijze de grootte of je array vergroot.

De array-indexen beginnen met 0.

en

Je kunt een array afkappen tot niets door er de null-lijst () aan toe te wijzen. De volgende zijn equivalent:

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

Dat brengt me bij waar ik naar op zoek was, namelijk hoe te detecteren dat de array leeg is. Ik heb het gevonden als $#empty == -1;

Antwoord 9

Er zijn verschillende manieren om de grootte van een array af te drukken. Dit zijn de betekenissen van alles:

Stel dat onze array my @arr = (3,4);

. is

Methode 1: scalair

Dit is de juiste manier om de grootte van arrays te krijgen.

print scalar @arr;  # Prints size, here 2

Methode 2: Indexnummer

$#arrgeeft de laatste index van een array. Dus als de array van grootte 10 is, zou de laatste index 9 zijn.

print $#arr;     # Prints 1, as last index is 1
print $#arr + 1; # Adds 1 to the last index to get the array size

Wij voegen hier 1 toe, gezien de array als 0-geïndexeerd . Maar als het niet op nul is gebaseerd, zal deze logica mislukken .

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

De bovenstaande voorbeeldafdrukken 6, omdat we zijn eerste index hebben ingesteld op 4. Nu zou de index 5 en 6 zijn, met respectievelijk elementen 3 en 4.

Methode 3:

Wanneer een array wordt gebruikt in een scalaire context, wordt het de grootte van de array

retourneert

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

Eigenlijk, methode 3 en methode 1 zijn hetzelfde.

Antwoord 10

Gebruik int(@array)terwijl het het argument als scalair bedreigt.

Antwoord 11

Om de grootte van een array te vinden, gebruik dan de scalartrefwoord:

print scalar @array;

Om de laatste index van een array te achterhalen, is er $#(PERL STANDLAND-variabele). Het geeft de laatste index van een array. Als een array begint van 0, krijgen we de grootte van de array door er een toe te voegen aan $#:

print "$#array+1";

Voorbeeld:

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

Uitgang:

3
3

Antwoord 12

Zoals talrijke antwoorden wezen, zijn de eerste en derde manier de juiste methoden om de array-grootte te krijgen, en op de tweede manier niet.

Hier breid ik deze antwoorden uit met enkele gebruiksvoorbeelden.

@array_nameEvalueert naar de lengte van de array = de grootte van de array = het aantal elementen in de array, bij gebruik in een scalaire context .

Hieronder staan ​​enkele voorbeelden van een scalaire context, zoals @array_nameop zichzelf binnen ifof unless, van in rekenkundige vergelijkingen zoals rekenkundige vergelijkingen zoals ==OF !=.

Al deze voorbeelden zullen werken als u @array_namenaar scalar(@array_name)wijzigt. Dit zou de code explicieter maken, maar ook langer en iets minder leesbaar. Daarom heeft meer idiomatisch gebruik van het weglaten van scalar()hier de voorkeur.

my @a = (undef, q{}, 0, 1);
# All of these test whether 'array' has four elements:
print q{array has four elements} if @a == 4;
print q{array has four elements} unless @a != 4;
@a == 4 and print q{array has four elements};
!(@a != 4) and print q{array has four elements};
# All of the above print:
# array has four elements
# All of these test whether array is not empty:
print q{array is not empty} if @a;
print q{array is not empty} unless !@a;
@a and print q{array is not empty};
!(!@a) and print q{array is not empty};
# All of the above print:
# array is not empty