Sepertinya aku telah menemukan beberapa cara yang berbeda untuk menemukan ukuran dari sebuah array. Apa perbedaan antara ketiga metode?
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
Cara pertama dan ketiga, mereka sama-sama mengevaluasi sebuah array dalam konteks skalar. Saya akan menganggap hal ini menjadi cara standar untuk mendapatkan array's ukuran.
Cara kedua sebenarnya mengembalikan indeks terakhir dari array, yang tidak (biasanya) sama seperti ukuran array.
Pertama, yang kedua adalah tidak setara dengan dua lainnya. $#array
kembali indeks terakhir dari array, yang merupakan salah satu kurang dari ukuran array.
Dua lainnya adalah hampir sama. Anda hanya menggunakan dua cara yang berbeda untuk menciptakan konteks skalar. Ia datang ke sebuah pertanyaan mudah dibaca.
Saya pribadi lebih suka yang berikut ini:
say 0+@array; # Represent @array as a number
Aku menemukan hal yang lebih jelas dari
say scalar(@array); # Represent @array as a scalar
dan
my $size = @array;
say $size;
Yang terakhir terlihat cukup jelas sendirian seperti ini, tapi saya menemukan bahwa garis ekstra mengambil dari kejelasan ketika bagian dari kode lainnya. It's berguna untuk mengajar apa yang @array
tidak dalam konteks skalar, dan mungkin jika anda ingin menggunakan $
ukuran lebih dari sekali.
Ini mendapat ukuran dengan memaksa array ke dalam sebuah skalar konteks, di mana hal ini dievaluasi sebagai ukurannya:
print scalar @arr;
Ini adalah cara lain untuk memaksa array ke dalam sebuah konteks skalar, karena itu's yang ditugaskan untuk variabel skalar:
my $arrSize = @arr;
Ini mendapat indeks elemen terakhir dalam array, sehingga's benar-benar ukuran minus 1 (dengan asumsi indeks dimulai dari 0, yang disesuaikan dalam Perl meskipun demikian biasanya ide yang buruk):
print $#arr;
Yang terakhir ini isn't benar-benar baik untuk digunakan untuk mendapatkan ukuran array. Ini akan berguna jika anda hanya ingin mendapatkan elemen terakhir dari array:
my $lastElement = $arr[$#arr];
Juga, seperti yang dapat anda lihat di sini pada Stack Overflow, membangun ini isn't ditangani dengan benar oleh sebagian besar sintaks highlighter...
Ketiganya memberikan hasil yang sama jika kita memodifikasi kedua sedikit:
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;
The "Perl jenis variabel" bagian dari perlintro dokumentasi berisi
khusus variabel
$#array
memberitahu anda indeks elemen terakhir dari array:
print $dicampur[$#dicampur]; # elemen terakhir, cetakan 1.23
Anda mungkin akan tergoda untuk menggunakan
$#array + 1
untuk memberitahu anda berapa banyak item yang ada dalam array. Jangan repot-repot. Seperti yang terjadi, menggunakan@menginap
di mana Perl mengharapkan untuk menemukan nilai skalar ("dalam konteks skalar") akan memberikan anda jumlah elemen dalam array:
if (@hewan < 5) { ... }
The perldata dokumentasi juga mencakup ini di "nilai Skalar" bagian.
Jika anda mengevaluasi sebuah array dalam konteks skalar, ia mengembalikan panjang dari array. (Catatan bahwa ini tidak benar dari daftar, yang mengembalikan nilai terakhir, seperti C operator koma, juga built-in fungsi, yang kembali apa pun yang mereka merasa seperti kembali.) Berikut adalah selalu benar:
skalar(@apapun) == $#dengan + 1;
Beberapa programmer yang memilih untuk menggunakan konversi eksplisit sehingga meninggalkan apa-apa untuk meragukan:
$element_count = skalar(@apapun);
Sebelumnya di bagian yang sama dokumen cara mendapatkan indeks dari elemen terakhir dari array.
panjang array adalah nilai skalar. Anda mungkin menemukan panjang dari array
@hari
dengan mengevaluasi$#hari
, seperti dalamcsh
. Namun, hal ini tidak panjang array; hal ini subskrip dari elemen terakhir, yang merupakan nilai yang berbeda karena tidak biasanya elemen 0.
Dari perldoc perldata, yang harus aman untuk kutipan:
berikut ini adalah selalu benar:
skalar(@apapun) == $#dengan + 1;
Hanya selama anda don't $#apapun++ dan misterius meningkatkan ukuran atau array.
indeks array dimulai dengan 0.
dan
Anda dapat memotong sebuah array ke apa-apa dengan menetapkan null daftar () untuk itu. Berikut adalah ekuivalen:
@dengan = (); $#apapun = -1;
Yang membawa saya untuk apa yang saya cari yang bagaimana mendeteksi array kosong. Aku menemukannya jika $#kosong == -1;
Ada berbagai cara untuk mencetak ukuran dari array. Berikut ini adalah makna dari semua:
Katakanlah array kita adalah saya @arr = (3,4);
Ini adalah cara yang tepat untuk mendapatkan ukuran dari array.
print scalar @arr; # prints size, here 2
$#arr
memberikan indeks terakhir dari array. jadi jika menginap lebih dari ukuran 10, maka yang terakhir akan menjadi 9.
print $#arr; # prints 1, as last index is 1
print $#arr + 1; # Add 1 to last index to get array size
Kami menambahkan 1 berikut ini mengingat array sebagai 0-diindeks. Tapi, jika tidak nol didasarkan kemudian, logika ini akan gagal.
perl -le 'local $[ = 4; my @arr=(3,4); print $#arr + 1;' # prints 6
Contoh di atas cetakan 6, karena kami telah menetapkan awal indeks ke-4. Sekarang indeks akan berada 5 dan 6, dengan unsur-unsur 3 dan 4 masing-masing.
Ketika sebuah array yang digunakan dalam konteks skalar, maka ia mengembalikan ukuran dari array
my $size = @arr;
print $size; # prints size, here 2
Sebenarnya metode 3 dan 1 metode yang sama.
Untuk menemukan ukuran dari sebuah array menggunakan skalar
kata kunci:
print scalar @array;
Untuk mengetahui indeks terakhir dari array ada $#
(Perl variabel default). Ini memberikan indeks terakhir dari array. Sebagai array dimulai dari 0, kita mendapatkan ukuran dari array dengan menambahkan satu ke $#
:
print "$#array+1";
Contoh:
my @a = qw(1 3 5);
print scalar @a, "\n";
print $#a+1, "\n";
Output:
3
3