Learning Perl - Dữ liệu mảng và Danh sách ppt

Diễn đàn tin học | Tutorial Room
Mục lục «« Chương 2 »» Chương 4
Learning Perl - Chương 3: Dữ liệu mảng và Danh sách
1. Mảng
2. Biểu diễn hằng ký hiệu
3. Biến mảng
4. Các hàm và phép toán trên mảng
5. Hoàn cảnh vô hướng và mảng
6. <STDIN> như một mảng
7. Xen lẫn biến mảng
8. Bài tập
3.1 Mảng
Mảng là một danh sách có thứ tự các dữ liệu vô hướng. Mỗi phần tử của mảng đều là một biến vô
hướng tách biệt với một giá trị vô hướng độc lập. Các giá trị này là được sắp thứ tự - tức là chúng có
một trình tự đặc biệt từ phần tử thấp nhất đến cao nhất.
Mảng có thể có bất kì số phần tử nào. Mảng nhỏ nhất không có phần tử nào, trong khi mảng lớn nhất
thì có thể lấp kín toàn bộ bộ nhớ có sẵn.
3.2 Biểu diễn hằng kí hiệu
Một hằng kí hiệu mảng (cách thức bạn biểu diễn giá trị của một mảng bên trong chương trình) là một
danh sách các giá trị tách nhau bằng dấu phẩy và được bao trong dấu ngoặc tròn. Những giá trị này
tạo nên các phần tử của danh sách. Chẳng hạn:
(1,2,3)
#
mảng gồm ba giá trị 1, 2 và 3
("jerry", 4.5)
#
hai giá trị, "jerry" và 4.5
Các phần tử của mảng không nhất thiết là hằng - chúng có thể là biểu thức mà sẽ được tính mới lại
mỗi lần mảng được sử dụng. Chẳng hạn:
($a, 17)
#

hai giá trị: giá trị hiện tại của $a, và 17
($b+$c,$d+$e)
#
hai giá trị
Mảng rỗng (mảng không có phần tử nào) được biểu diễn bằng một cặp dấu ngoặc rỗng:
()
#
mảng rỗng (không phần tử)
Một phần tử của mảng có thể bao gồm toán tử cấu thành mảng, được chỉ ra bởi hai giá trị vô hướng
tách nhau bởi hai dấu chấm liên tiếp ( ). Toán tử này tạo ra một danh sách các giá trị bắt đầu tại giá
trị vô hướng bên trái kéo cho tới gía trị vô hướng bên phải, mỗi lần tăng lên một. Chẳng hạn:
(1 5)
#
giống như (1, 2, ,3 ,4, 5)
(1.2 5.2)
#
giống như (1.2, 2.2, 3.2, 4.2, 5.2)
(2 6,10,12)
#
giống như (2,3,4,5,6,10,12)
($a $b)
#
phạm vi được xác định bởi giá trị hiện tại của $a và $b
Nếu giá trị vô hướng bên phải bé hơn vô hướng bên trái thì sẽ tạo ra danh sách rỗng - bạn không thể
đếm ngược trật tự của các giá trị. Nếu giá trị cuối cùng không phải là toàn bộ số bước trên giá trị ban
đầu thì danh sách sẽ dừng chỉ ngay trước giá trị tiếp mà sẽ vượt ra ngoài phạm vi:
(1.3 6.1)
#
giống như (1.3, 2.3, 3.3, 4.3, 5.3)
Một cách dùng của hằng kí hiệu mảng là như tham số của toán tử print() đã được giới thiệu trước đây.

Các phần tử của danh sách này được in ra mà không có bất kì khoảng trống xen thêm vào:
print ("Câu trả lời là ", $a, "\n");
Câu lệnh này in ra Câu trả lời là, theo sau bởi một dấu cách, giá trị của $a, và xuống dòng mới. Ta hãy
chuyển sang cách dùng khác cho hằng kí hiệu mảng.
3.3 Biến mảng
Một biến mảng giữ một giá trị mảng riêng. Các tên biến mảng là tương tự với các tên biến vô hướng,
chỉ khác kí tự khởi đầu, là một dấu @ chứ không phải là dấu $. Chẳng hạn:
@jerry
#
biến mảng @jerry
@A_Very_Long_Array_Variable_Name
@A_Very_Long_Array_Variable_Name_that_is_different
Lưu ý rằng biến mảng @jerry là không có quan hệ gì theo bất kì cách nào với biến vô hướng $jerry. Perl
duy trì không gian tên tách biệt cho các kiểu đối tượng khác nhau.
Giá trị của một biến mảng mà chưa được gán là (), danh sách rỗng.
Một biểu thức có thể tham khảo tới các biến mảng như một tổng thể, hoặc nó có thể xem xét và thay
đổi từng phần tử của mảng đó.
3.4 Các hàm và phép toán trên mảng
Các toán tử mảng hành động trên các mảng như một tổng thể. Một số toán tử mảng có thể cho lại
một giá trị mảng, mà có thể hoặc được dùng như một giá trị cho toán tử mảng khác, hoặc được gán
vào một biến mảng khác.
3.4.1 Phép gán
Có lẽ toán tử mảng quan trọng nhất là toán tử gán mảng, cho mảng một giá trị. Nó là dấu bằng, giống
như toán tử gán vô hướng. Perl xác định liệu phép gán có là phép gán vô hướng hay phép gán mảng
bằng việc để ý xem liệu phép gán là cho biến vô hướng hay mảng. Chẳng hạn:
@jerry = (1,2,3);
#
mảng jerry nhận ba phần tử 1, 2 và 3
@tom = @jerry;
#

bây giờ được sao sang @tom
Nếu một giá trị vô hướng được gán vào trong một biến mảng thì giá trị vô hướng trở thành phần tử duy
nhất của mảng:
@huh = 1;
#
1 được đặt chuyển thành (1) và gán cho @huh
Tên biến mảng có thể xuất hiện trong danh sách hằng kí hiệu mảng. Khi giá trị của danh sách được
tính thì Perl thay thế tên biến mảng bằng giá trị hiện tại của mảng đó, giống vậy:
@jerry = ("một", "hai");
@tom = (4,5,@jerry, 6, 7);
#
@tom trở thành (4,5,"một","hai",6,7)
@tom = (8, @tom);
#
đặt 8 vào trước @tom
@tom = (@tom, “cuối”);
#
và "cuối" vào phía sau @tom
# @tom bây giờ là (8,4,5,"một","hai",6,7,"cuối")
Lưu ý rằng các phần tử mảng được thêm vào đều ở cùng mức như phần còn lại của hằng kí hiệu - một
danh sách không thể chứa một danh sách khác như một phần tử.
Nếu một mảng hằng kí hiệu chỉ chứa các tham khảo biến (không phải là biểu thức) thì mảng hằng kí
hiệu ấy cũng có thể được xử lí như một biến. Nói cách khác, một mảng hằng kí hiệu như thế có thể
được dùng ở vế bên trái của phép gán. Mỗi biến vô hướng trong mảng kí hiệu nhận một giá trị tương
ứng từ danh sách ở vế phải của phép gán. Chẳng hạn:
($a, $b, $c) = (1, 2, 3);
# gán
1 cho $a, 2 cho $b, 3 cho $c
($a, $b) = ($b, $a);
#

tráo đổi $a và $b
($d, @jerry) = ($a, $b, $c);
#
gán $a cho $d, và ($b,$c) cho @jerry
($e, @jerry) = @jerry;
#
loại bỏ phần tử thứ nhất của @jerry là $e
# điều này làm cho @jerry = ($c) và $e = $b
Nếu số phần tử được gán không sánh đúng với số các biến để giữ các giá trị thì mọi giá trị vượt quá
(vế phải) đều bị loại bỏ, và bất kì biến vượt quá nào (ở vế trái của dấu bằng) đều được cho giá trị
undef.
Một biến mảng xuất hiện trong danh sách mảng hằng kí hiệu đều phải ở cuối, vì biến mảng nó tiêu thụ
tất cả các giá trị còn lại (bạn có thể đặt các biến khác sau nó, nhưng chúng sẽ chỉ nhận giá trị undef
mà thôi).
Nếu một biến mảng được gán cho một biến vô hướng thì số được gán là chiều dài của mảng, như
trong:
@jerry = (4, 5, 6);
#
khởi đầu @jerry mang giá trị (4,5,6)
$a = @jerry;
#
$a = 3, là số lượng các phần tử có trong @jerry
Chiều dài cũng được cho lại nếu một tên biến mảng được dùng trong hầu hết mọi chỗ mà một giá trị vô
hướng đang được cần tới. (Trong mục dưới đây có tên "Hoàn cảnh vô hướng mảng", chúng ta sẽ thấy
rằng điều này quả là được gọi như vậy với việc dùng tên mảng trong hoàn cảnh vô hướng). Chẳng hạn,
để lấy giá trị bé hơn chiều dài mảng một đơn vị, bạn có thể dùng @jerry-1, vì toán tử trừ vô hướng
cần các vô hướng cho cả hai toán hạng của nó. Chú ý điều sau:
@jerry = (4, 5, 6);
#
khởi đầu @jerry mang giá trị (1,2,3)

$a = @jerry;
#
$a nhận chiều dài của @jerry (là 3)
($a) = @jerry;
#
$a nhận phần tử đầu tiên của @jerry (là 4)
Phép gán $a = đầu tiên là phép gán vô hướng, và do vậy @jerry được xem như một vô hướng, cho lại
chiều dài của nó. Phép gán thứ hai là phép gán mảng (cho dù chỉ một giá trị là cần tới), và do vậy là
phần tử đầu tiên của @jerry, bỏ đi tất cả phần còn lại.
Giá trị của phép gán mảng là chính bản thân giá trị mảng, và có thể được xếp tầng như bạn có thể làm
với các phép gán vô hướng. Chẳng hạn:
@jerry = (@tom = (2,3,4));
#
@jerry và @tom mang giá trị (2,3,4)
@jerry = @tom = (2,3,4);
#
tương tự như trên
3.4.2 Truy cập các phần tử của mảng
Cho tới nay, chúng ta vẫn xử lí mảng như một tổng thể, thêm vào và bỏ bớt các giá trị bằng việc thực
hiện gán mảng. Nhiều chương trình có ích đã được xây dựng dùng mảng mà thậm chí chẳng truy cập
vào phần tử mảng nào. Tuy nhiên, Perl cung cấp toán tử chỉ số truyền thống để tham khảo tới một
phần tử mảng theo chỉ số. Với toán tử chỉ số mảng, các phần tử mảng đều được đánh số bằng việc
dùng số nguyên tuần tự, bắt đầu từ không và tăng lên một cho mỗi phần tử. Phần tử đầu tiên của
mảng @jerry mà được truy cập tới là $jerry[0]. Chú ý rằng @ trên tên mảng trở thành $ trên tham
khảo phần tử. Đó là vì việc tham khảo tới một phần tử của mảng xác định ra một biến vô hướng (một
phần của mảng), mà có thể hoặc được gán cho, hoặc có giá trị hiện tại của nó được dùng trong một
biểu thức, kiểu như:
@jerry = (7,8,9);
$b = $jerry[0];
#

đặt 7 vào $b (phần tử đầu tiên của @jerry)
$jerry[0] = 5;
#
bây giờ @jerry = (5,8,9)
Cũng có thể truy cập tới các phần tử khác cũng dễ tương tự, như trong:
$c = $jerry[1];
#
gán $jerry[1] vào $s, lúc này $c = 8
$jerry[2]++;
#
tăng 1 cho phần tử thứ ba của @jerry
$jerry[1] += 4;
#
cộng 4 vào phần tử thứ hai
($jerry[0], $jerry[1]) = ($jerry[1], $jerry[0]);
#
tráo đổi hai phần tử đầu của @jerry
Việc truy cập vào một danh sách các phần tử từ cùng mảng (như trong thí dụ cuối) được gọi là lát
cắt, và thường xuất hiện đến mức có một cách biểu diễn đặc biệt cho nó:
@jerry[0,1]
#
tương tự như ($jerry[0], $jerry[1])
@jerry[0,1] = @jerry[1,0];
#
tráo đổi hai phần tử đầu
@jerry[0,1,2] = @jerry[1,1,1];
#
làm cho cả 3 phần tử đầu tiên giống phần tử thứ hai
@jerry[1,2] = (9,10);
#

đổi hai giá trị cuối thành 9 và 10
Chú ý rằng lát cắt này dùng tiền tố @ chứ không là $. Điều này là vì bạn đang tạo ra một biến mảng
bằng việc chọn một phần của mảng chứ không phải là biến vô hướng chỉ thâm nhập vào một phần tử.
Lát cắt cũng làm việc trên danh sách hằng kí hiệu, hay bất kì toán tử nào cho lại một giá trị danh
sách:
@who = ("jerry","tom","chip","dale")[2,3];
#
@who = ("chip", "dale")
Các giá trị chỉ số trong những thí dụ này là các số nguyên hằng kí hiệu, nhưng chỉ số cũng có thể là
bất kì biểu thức nào cho lại một số, mà rồi được dùng để chọn phần tử thích hợp:
@jerry = (7,8,9);
$a = 2;
$b = $jerry[$a];
#
$b = $jerry[2], hay giá trị 9
$c = $jerry[$a-1];
#
$c nhận $jerry[1], hay 8
($c) = (7,8,9) [$a-1];
#
tương tự như trên, nhưng dùng lát cắt
Vậy chương trình Perl có thể có việc thâm nhập mảng tương tự như các ngôn ngữ lập trình truyền
thống. Ý tưởng này về việc dùng một biểu thức cho chỉ số cũng có tác dụng cho các lát cắt. Tuy
nhiên bạn hãy nhớ rằng chỉ số cho lát cắt là một danh sách các giá trị, cho nên biểu thức này là một
biểu thức mảng, thay vì là một biểu thức vô hướng.
@jerry = (7,8,9);
#
như trong thí dụ trước
@tom = (2,1,0);
@backfred = @jerry[@tom];

# giống như @jerry[2,1,0], hay ($jerry[2],$jerry[1],$jerry[0]), hay
(9,8,7)
Nếu bạn thâm nhập vào một phần tử mảng bên ngoài hai đầu của mảng hiện tại (tức là một chỉ số bé
hơn không hay lớn hơn chỉ số của phần tử cuối cùng), thì giá trị undef sẽ được trả về mà không có lời
cảnh báo. Chẳng hạn:
@jerry = (1,2,3);
$tom = $jerry[7];
#
$tom bây giờ là undef
Việc gán một giá trị bên ngoài đầu của mảng hiện tại sẽ tự động mở rộng mảng (cho một giá trị undef
cho tất cả các giá trị trung gian, nếu có). Chẳng hạn:
@jerry = (1,2,3);
$jerry[3] = "hi";
#
@jerry bây giờ là (1,2,3,"h"”)
$jerry[6] = "ho";
#
@jerry bây giờ là (1,2,3,"hi",undef,undef,"ho")
Bạn có thể dùng $#jerry để lấy giá trị chỉ số của phần tử cuối của @jerry (tương tự như trong C-
Shell). Bạn thậm chí còn có thể gán vào trong giá trị này để làm thay đổi chiều dài hiển nhiên của
@jerry, làm cho nó to lên hay co lại, nhưng điều đó nói chung là không cần thiết, vì mảng thường to
lên hay co lại một cách tự động.
3.4.3 Các toán tử push() và pop()
Một cách dùng thông dụng của mảng là như một chồng thông tin, nơi những giá trị mới được thêm vào
và lấy đi từ phía bên phải của danh sách. Những phép toán này thường xuất hiện đến mức chúng có
các hàm đặc biệt của riêng chúng:
push(@mylist,$newvalue);
#
giống @mylist = (@mylist, $newvalue)
$oldvalue = pop(@mylist);

#
lấy ra phần tử cuối của @mylist
Toán tử pop() trả về undef nếu tham số của nó là một danh sách rỗng.
Toán tử push() cũng chấp nhận một danh sách các giá trị cần được đẩy vào danh sách. Các giá trị
được đẩy vào cuối của danh sách. Chẳng hạn:
@mylist = (1,2,3);
push(@mylist,4,5,6);
#
@mylist = (1,2,3,4,5,6)
Chú ý rằng đối thứ nhất phải là một tên biến mảng - đẩy vào và lấy ra sẽ không có ý nghĩa với danh
sách hằng kí hiệu.
3.4.4 Các toán tử shift() và unshift()
Các toán tử push() và pop() làm việc ở bên "phải" của danh sách (phần với chỉ số cao nhất). Tương tự
thế, các toán tử unshift() và shift() thực hiện những hành động tương ứng về bên "trái" của một danh
sách (phần với chỉ số thấp nhất). Sau đây là vài thí dụ:
unshift(@jerry,$a);
#
như @jerry = ($a,@jerry);
unshift(@jerry,$a,$b,$c);
#
như @jerry = ($a, $b, $c, @jerry);
$x = shift(@jerry);
#
như ($x,@jerry) = @jerry;
@jerry = (5,6,7);
unshift(@jerry,2,3,4);
#
@jerry bây giờ là (2,3,4,5,6,7)
$x = shift(@jerry);
#

$x nhận 2, $jerry nhận bây giờ là (3,4,5,6,7)
Tương tự như pop(), shift() sẽ trả về undef nếu tham số của nó là một mảng rỗng.
3.4.5 Toán tử reverse()
Toán tử reverse() đảo ngược trật tự các phần tử của tham số của nó, cho lại danh sách kết quả.
Chẳng hạn:
@a = (7,8,9);
@b = reverse(@a);
#
đặt $b giá trị (9,8,7)
$b = reverse(7,8,9);
#
tương tự như trên
Chú ý rằng danh sách đối là không bị thay đổi - toán tử reverse() chỉ làm việc trên bản sao. Nếu bạn
muốn đảo ngược một mảng "tại chỗ", thì bạn cần gán nó ngược trở lại cho cùng biến:
@b = reverse(@b);
#
đặt @b là đảo ngược của chính nó
3.4.6 Toán tử sort()
Toán tử sort() nhận một danh sách làm tham số, sắp xếp thứ tự danh sách theo thứ tự ASCII và trả
về kết quả sau khi đã sắp xếp tăng dần. sort() không làm thay đổi danh sách gốc. Chẳng hạn:
@x = sort("small", "medium", "large");
#
@x nhận "large", "medium", "small"
@y = (1,2,4,8,16,32,64);
@y = sort(@y);
#
@y nhận 1, 16, 2, 32, 4, 64, 8
Chú ý rằng các số sắp xếp không xuất hiện theo thứ tự số, nhưng theo giá trị xâu của từng số (1, 16,
2, 32, ). Trong mục "Sắp xếp nâng cao", ở Chương 15:Việc biến đổi dữ liệu khác, bạn sẽ học cách
sắp xếp theo số, hoặc theo thứ tự giảm dần, hay theo kí tự thứ ba của từng xâu, hay bất kì phương

pháp nào khác mà bạn chọn.
3.4.7 Toán tử chop() và chomp()
Toán tử chop() và chomp() làm việc trên biến mảng cũng như biến vô hướng. Mỗi phần tử của mảng
đều có kí tự cuối bị bỏ đi. Điều này có thể là thuận tiện khi bạn đọc một danh sách các dòng như các
phần tử mảng tách riêng, và bạn muốn bỏ đi dấu dòng mới trong tất cả các dòng ngay lập tức. Chẳng
hạn:
@stuff = ("hello\n", "world\n", "happy day");
chop(@stuff);
#
@stuff bây giờ là ("hello", "world", "happy da”)
chomp(@stuff);
#
@stuff bây giờ là ("hello", "world", "happy day”)
3.5 Hoàn cảnh vô hướng và mảng
Như bạn có thể thấy, từng toán tử đều được thết kế để hoạt động trên một số tổ hợp xác định các vô
hướng hay mảng, và cho lại một vô hướng hay mảng. Nếu một toán tử trông đợi một toán hạng là vô
hướng thì ta nói rằng toán hạng đó là được tính trong hoàn cảnh vô hướng. Tương tự, nếu một toán
hạng đang trông đợi một giá trị mảng thì ta nói rằng toán hạng đó là được tính trong hoàn cảnh mảng.
Điều này là khá thông thường, nhưng đôi khi bạn nhận được một thao tác hoàn toàn khác tuỳ theo liệu
bạn đang trong hoàn cảnh vô hướng hay mảng. Chẳng hạn, @jerry cho lại nội dung của mảng @jerry
trong hoàn cảnh mảng, nhưng cho lại chiều dài của mảng đó trong hoàn cảnh vô hướng. Nhưng sự
"huyền ảo" này sẽ được chi chú rõ đối với mỗi toán tử và hàm cụ thể.
Nếu bạn muốn buộc một biểu thức phải được tính trong hoàn cảnh vô hướng thì bạn có thể ghép nối
một xâu rỗng vào cho nó. Chẳng hạn:
@a = ('x','y','z');
print ('Tôi thấy ', @a, " phần tử\n");
#
sai, sẽ in là "xyz" cho @a
print ('Tôi thấy ', "".@a, " phần tử\n");
#

đúng, in 3 cho @a
Tại đây, chúng ta đã nối xâu rỗng "" vào @a, làm nảy sinh xâu "3", rồi trở thành một phần của danh
sách cho print.
Một giá trị vô hướng được dùng bên trong một hoàn cảnh mảng thì sẽ được coi như mảng một phần tử.
3.6 <STDIN> như một mảng
Một toán tử ta đã thấy trước đây cũng cho giá trị khác tong hoàn cảnh mảng là <STDIN>. Như đã mô
tả trước đây, <STDIN> cho dòng tiếp của cái vào trong hoàn cảnh vô hướng. Bây giờ, trong hoàn cảnh
mảng, toán tử này cho lại tất cả phần dòng còn lại cho tới cuối tệp. Mỗi dòng đều được cho lại như
một phần tử tách bạch của danh sách. Chẳng hạn:
@a = <STDIN>;
#
tương tự như while ($a = <STDIN>) {@a = (@a, $a);}
Nếu một người chạy chương trình này gõ vào ba dòng, rồi nhấn Control-D (để chỉ ra "cuối tệp"), thì
mảng kết thúc với ba phần tử. Mỗi phần tử sẽ là một xâu mà kết thúc bằng một dấu xuống dòng,
tương ứng với ba dòng có kết thúc là dấu dòng mới đã gõ vào.
3.7 Xen lẫn biến mảng
Giống như các vô hướng, các giá trị mảng có thể được để xen lẫn trong xâu có nháy kép. Một phần tử
riêng của một mảng sẽ được thay thế bởi giá trị của nó, giống như:
@jerry = ("hello", "dolly");
$y = 2;
$x = "This is $jerry[1]’s place";
#
"This is dolly’s place"
$x = "This is $jerry[$y-1]’s place";
#
cũng câu ấy
Chú ý rằng biểu thức chỉ số được tính như một biểu thức thông thường, dường như nó ở bên ngoài
xâu. Nó không phải là biến được xen lẫn trước hết. Nói cách khác, nếu $y chứa xâu "2*4" thì ta vẫn
nói về phần tử 1, chứ không phải là 7, vì xâu "2*4" khi chuyển sang số là 2 (vì * ở đây được xem như
là một ký tự "lạ" chứ không phải là phép nhân.

Nếu bạn muốn đặt sau một tham khảo biến vô hướng đơn dấu ngoặc vuông trái thì bạn cần định biên
cho dấu ngoặc vuông để cho nó không được coi như một phần của một tham khảo mảng, như sau:
@jerry = ("hello", "dolly");
#
đặt giá trị cho @jerry để kiểm thử
$jerry = "right";
#
chúng ta đang định nói "this is right[1]"
$x = "this is $jerry[1]";
#
sai, $x = "this is dolly"
$x = "this is ${jerry}[1]";
#
đúng (được bảo vệ bởi dấu ngoặc nhọn)
$x = "this is $jerry" . "[1]";
#
đúng (dùng cách ghép xâu)
$x = "this is $jerry\[1]";
#
đúng (sổ chéo ngược che dấu nó)
Tương tự, một danh sách các giá trị từ một biến mảng cũng có thể được xen lẫn. Việc xen lẫn đơn
giản nhất là toàn bộ mảng, được chỉ ra bằng việc cho tên mảng (kể cả kí tự @ đứng đầu của nó).
Trong trường hợp này, các phần tử được xen lẫn theo trình tự với một dấu cách giữa chúng, như
trong:
@jerry = ("a", "bb", "ccc", 1, 2, 3);
$all = "Now for @jerry here!";
#
$all = "Now for a bb ccc 1 2 3 here!"
Bạn cũng có thể chọn ra một phần của mảng với lát cắt:
@jerry = ("a", "bb", "ccc", 1,2,3);

$all = "Now for @jerry[2,3] here!";
#
$all = "Now for ccc 1 here!"
$all = "Now for @jerry[@jerry[4,5]] here!";
#
cũng thế
Một lần nữa, bạn có thể dùng nháy kép nào nếu bạn muốn đặt sau một tham khảo tên mảng bằng một
hằng kí hiệu dấu ngoặc nhọn trái thay vì một biểu thức chỉ số.
3.8 Bài tập
1. Bạn hãy viết 1 chương trình đọc vào một danh sách các xâu (mỗi xâu trên 1 dòng) và in ra lại
danh sách đó theo thứ tự đảo ngược
2. Bạn hãy viết 1 chương trình đọc vào một số (gọi là n), và một danh sách các xâu. Sau đó in ra
màn hình xâu thứ n trong danh sách vừa đọc được
3. Bạn hãy viết chương trình đọc vào một danh sách các xâu, sau đó chọn và in ra một xâu ngẫu
nhiên trong danh sách.
Mẹo: để sinh ra một số ngẫu nhiên, bạn gọi hàm srand; ở đầu chương trình.
Sau bạn gọi hàm rand($n) sẽ trả về một số ngẫu nhiên từ 0 cho đến $n-1
Mục lục «« Chương 2 »» Chương 4