Ai chưa bit lua thì cùng học nào!

[huongphieubat]

Bài viết về các biểu thức (Expressions)

Các biều thức được ước tạo để thi hành các tính toán có thể gán các giá trị cho các biến hoặc truyền các tham số vào các hàm.
Các giá trị có thể được gán vào các biến 1 cách dễ dàng, ví dụ,

> x = 7
> print(x)
7
> = 7
7

Các biểu thức toán học (Arithmetic expressions)

Lua có các toán tử nhị phân thông dụng.

> = 2+3, 5-12, 2*7, 7/8
5 -7 14 0.875
> = 5*(2-8.3)/77.7+99.1
98.694594594595

Phủ định đơn nguyên:

> = -(-10), -(10)
10 -10

Lũy thừa:
> = 7^2, 107^0, 2^8
49 1 256

Các biểu thức tương quan (Relational expressions)


Các biểu thức tương quan được cung cấp để trả về các giá trị luận lý true hoặc false.

• == bằng nhau
• ~= không bằng nhau
• < nhỏ hơn
• > lớn hơn
• <= nhỏ hơn hoặc bằng
• >= lớn hơn hoặc bằng

Ví dụ:


> = 1 == 1, 1 == 0
true false
> = 1 ~= 1, 1 ~= 0
false true
> = 2 < 7, 2 > 7
true false
> = 3 <= 7, 7 <= 7, 8 <= 7
true true false
> = 3 >= 7, 7 >= 7, 8 >= 7
false true true

Các biểu thức này cũng làm việc được với các chuỗi và các kiểu khác.

> = "abc" < "def"
true
> = "abc" > "def"
false
> = "abc" == "abc"
true
> = "abc" == "a".."bc"
true

Các đối tượng sẽ không bằng nhau nếu khác kiểu hay khác đối tượng tham chiếu.

> = {} == "table"
false
> = {} == {} -- 2 bảng khác nhau được tao ở đây
false
> t = {}
> t2 = t
> = t == t2 -- chúng ta đang tham chiếu cùng bảng
true

Tính gượng ép không có tác dụng ở đây, các kiểu phải được chuyển đổi phù hợp.

> = "10" == 10
false
> = tonumber("10") == 10
true

Các toán tử logic (Logical operators)

Lua cung cấp các toán tử logic and, or và not. Trong Lua cả nil và giá trị luận lý false đều biểu thị false trong biểu thức logic. Mọi thứ không phải false thì là true.

> = false==nil -- Dù chúng biểu diễn cùng 1 thứ chúng vẫn ko tương đương
false
> = true==false, true~=false
false true
> = 1==0
false
> = does_this_exist -- kiểm tra sự tồn tại của biến “does_this_exist”, không là false.
nil

not

Từ khóa not đảo ngược 1 giá trị biểu thức logic:

> = true, false, not true, not false
true false false true
> = not nil -- nil biểu thị false
true
> = not not true -- true thì không không true!
true
> = not "foo" -- mọi thứ không phải false hoặc nil là true
false

and

Toán tử nhị phân and không nhất thiết trả về 1 giá trị luận lý true hay false cho biểu thức logic x and y. Trong một số ngôn ngữ, toán tử and trả về 1 giá trị luận lý tùy thuộc vào 2 thành phần truyền vào. Lua thì khác, nó trả về tham số đầu nếu giá trị của nó là false hoặc nil và tham số thứ 2 nếu tham số đầu không phải là false hoặc nil. Vì vậy 1 mệnh đề luận lý chỉ được trả về nếu tham số thứ nhất là false hoặc tham số thứ 2 là 1 mệnh đề luận lý.

> = false and true -- trả về false vì nó là tham số thứ nhất
false
> = nil and true -- như trên
nil
> = nil and false
nil
> = nil and "hello", false and "hello"
nil false

Tất cả các biểu thức trên đều trả về tham số thứ nhất. Tất cả các biểu thức sau trả về tham số thứ 2 vì tham số thứ nhất là true.

> = true and false
false
> = true and true
true
> = 1 and "hello", "hello" and "there"
hello there
> = true and nil
nil

or

Toán tử nhị phân or cũng không nhất thiết trả về 1 giá trị luận lý. Nếu tham số thứ nhất không phải false hoặc nil thì nó được trả về, ngược lại tham số thứ 2 được trả về. Vì vậy, 1 mệnh đề luận lý chỉ được trả về nếu tham số thứ nhất là true hoặc tham số thứ 2 là 1 mệnh đề luận lý.

> = true or false
true
> = true or nil
true
> = "hello" or "there", 1 or 0
hello 1

Tất cả các biểu thức trên đều trả về tham số thứ nhất. Tất cả các biểu thức sau sẽ trả về tham số thứ 2 do tham số thứ nhất là false hoặc nil.

> = false or true
true
> = nil or true
true
> = nil or "hello"
hello

Đây là 1 thuộc tính rất hữu ích. Ví dụ, đặt giá trị mặc định trong 1 hàm:

> function foo(x)
>> local value = x or "default" -- Nếu tham số x là false hoặc nil, giá trị trở thành "default"
>> print(value, x)
>> end
>> foo() -- không tham số nên x là nil
default nil
> foo(1)
1 1
> foo(true)
true true
> foo("hello")
hello hello

Những toán tử tam phân (Ternary operators)

Các toán tử tam phân là những toán tử nhận vào 3 tham số là 1 đặc tính hữu ích trong C thường có dạng "điều kiện ? biểu thức1 : biểu thức2" và trả về biểu thức1 nếu điều kiện đúng ngược lại trả về biểu thức2. Nó giống với If điều kiện then bt1 else bt2. Ví dụ

int value = x>3 ? 1 : 0;

Dạng này trong Lua cũng có thể biểu diễn qua 2 toán tử and và or. Dạng trong C:

value = test ? x : y;

được chuyển sang Lua:

value = test and x or y

Ví dụ.

> print( 3>1 and 1 or 0 )
1
> print( 3<1 and 1 or 0 )
0
> print( 3<1 and "True" or "False" )
False
> print( 3>1 and true or "false" )
true

Tuy nhiên, có 1 cảnh báo: Điều này chỉ hoạt động khi phần đầu trả về giá trị không phải nil hay false.

> print( 3>1 and 1 or "False" ) -- hoạt động
1
> print( 3>1 andfalseor"oops" ) -- sai, đáng lý trả về false
oops
> print( 3>1 andnilor"oops" ) -- sai, đáng lý trả về nil
oops

Chú ý về các biểu thức kiểm tra và nil

1 chú ý quan trọng là trong Lua, giá trị 0 không phải là 1 điều kiện kiểm tra false. Trong 1 số ngôn ngữ như C, 1 kiểm tra:

if (0) printf("true"); else printf("false");

sẽ hiển thị "false". Trong Lua,

> if 0 then
>> print("true")
>> else
>> print("false")
>> end
true

xuất ra "true"! Bạn nên dùng false, hay nil thay cho 0:

> if false then print("true") else print("false") end
false
> if nil then print("true") else print("false") end
false

Tại sao?

Lý do cho điều này là lịch sử. Lua đã không hỗ trợ kiểu luận lý (như true và false) trước version 5.0. Trước version 5.0, 1 giá trị của nil được biểu thị là false. Bây giờ, cả nil và false sẽ hoạt động như 1 điều kiện sai trong biểu thức kiểm tra. Ví dụ,

> if nil then print("true") else print("false") end
false
> if 1 then print("true") else print("false") end
true
> if 0 then print("true") else print("false") end
true
> if 1==2 then print("true") else print("false") end
false

1 chú ý khác là true và flse không phải giá trị số như 1 và 0 trong 1 số ngôn ngữ.

> = true, false
true false
> = 1 + true
stdin:1: attempt to perform arithmetic on a boolean valuestack
traceback: stdin:1: in main chunk
[C]: ?

và như thế, nil cũng bị ép thành 1 giá trị luận lý khi được sử dụng với 1 toán tử logic:

> = not nil
true
> = not 1
false
> = not 0
false

Còn tiếp ...

[thuyvyetm]

hix nhìu quá! đọc đui mắt lun, anh cho em Yh đi, giảng cho e cái, đọc ko hỉu

[tinhlagi_true]

hay nhỉ, chắc ông dịch cực lắm, tui từng đọc bài Tiếng Anh quá chaj lun! nản. h có bài TV rùi thanks nhìu!

[huongphieubat]

hix nhìu quá! đọc đui mắt lun, anh cho em Yh đi, giảng cho e cái, đọc ko hỉu

Hix cái này giảng hiểu phải nhờ khả năng truyền đạt nữa, tui dở cái này lắm, và cũng chưa chắc tui đã hiểu hết những ji đã viết. Bạn cứ dùng ctrinh chạy thử thì sẽ từ từ hiểu, chúc thành công!!

hay nhỉ, chắc ông dịch cực lắm, tui từng đọc bài Tiếng Anh quá chaj lun! nản. h có bài TV rùi thanks nhìu!

Cũng ko quá cực, nói chung để cùng nhau học thui, chẳng có ji đáng nói lắm. Vì tui thấy trên mạng gần như ko có tài liệu Lua TV đầy đủ nên post lên cho những ai dev game có thể tham khảo thêm. Dẫu sao cũng cám ơn bạn

[GooglePro]

bài viết rất hay, rất có ý nghĩa, ngôn ngữ thần về bên C,C++

[huongphieubat]

Bài viết về các hàm (Functions)

Xác định hàm (Defining functions)

Các hàm trong Lua được xác định với từ khóa function như sau:

function tên hàm ( các tham số ) phần thân end

Ví dụ sau cho thấy 1 đơn giản được gọi là "foo" nhận 1 tham số và trả về 2 lần giá trị của nó:

> function foo(n) return n*2 end
> = foo(7)
14

Các hàm là các giá trị (Functions are values)

Cấu trúc tương đương cấu trúc sau:

Tên hàm= function( các tham số) phần thân end

Vì thế nên hàm trên được viết lại như sau:

> foo = function(n) return n*2 end
> = foo(4)
8

Cú pháp này cho thấy rõ nhất bản chất thực của các hàm trong Lua. function(n) return n*2 end bản thân nó là 1 biểu thức mà khi thực hiện sẽ ước tính ra 1 giá trị (ở đây là 1 hàm). Chỉ riêng đều này đã đủ tạo thành 1 hàm. Phát biểu này sẽ gán hàm vào biến foo. Tuy nhiên, trước khi hàm được gán vào foo, hàm không có tên, nó là 1 hàm vô danh, dù nó vẫn là 1 hàm sử dụng được, nhưng khi được gán vào biến foo, hàm lấy tên foo and và dùng làm tên của nó.
Đôi khi không cần đặt tên khi dùng hàm. Ví dụ sau tạo ra 1 hàm vô danh và gọi nó trong biểu thức:

> = 1 + (function(n) return n*2 end)(4)
9

Phải thật khéo léo khi truyền 1 hàm (thậm chí 1 hàm vô danh) trực tiếp vào 1 hàm khác, như hàm table.foreach truyền mỗi cặp khóa – giá trị trong bảng truyền vào cho hàm nhập vào:

> table.foreach({'a',2,foo}, function(key, value)
> print(key, value)
> end)
1 a
2 2
3 function: 0x687f10

Điểm quan trọng trên hết là các hàm trong Lua là các giá trị, cũng như chuỗi và số là các giá trị. Khi là các giá trị, chúng có thể được khởi tạo lúc thực hiện, lưu trữ trong các biến, truyền vào các hàm khác cũng như nhận giá trị từ hàm khác. Do các hàm trong Lua có đủ đặc tính để làm mọi thứ mà các giá trị khác có thể làm nên nó không bị đối xử như những thành phần thứ cấp (như trong C), chúng được gọi là các giá trị lớp đầu (first class values)

Các giá trị hàm là các tham chiếu (Function values are references

Khi các hàm trong Lua được truyền như các giá trị, chúng được coi như là các giá trị tham chiếu, như các bảng. Tham chiếu để chỉ ra 1 đối tượng, với 1 đơn vị định danh và thời gian hoạt động, chứa phần thân của hàm (sự thi hàn mã lệnh - code implementation). Vì thế khi 1 biến hàm được gán vào hàm khác, mã lệnh hàm bản thân nó không bị sao chép mà chỉ sao chép tham chiếu.

> foo = function(n) return n*2 end -- tạo hàm và gán vào foo
> bar = foo -- bar và foo giờ tham chiếu cùng 1 hàm
> = foo, bar
function: 0x687d20 function: 0x687d20
> = (foo == bar)
true
> =(function(n) return n*2 end)
function: 0x6870c0
> = (foo == (function(n) return n*2 end)) -- không cùng hàm
false

Các hàm được mô tả động (Functions are dynamically typed)

Các hàm cũng như các giá trị khác trong Lua được mô tả động. Điều này có nhĩa là chúng ta tìm ra 1 giá trị có là 1 hàm hay không chỉ khi chúng ta hỏi nó lúc thực hiện:

> x = "onion"
> = type(x) -- Kiểu của ngươi là ji?
string
> x() -- giờ thử gọi ngươi.
stdin:1: attempt to call global `x' (a string value)
stack traceback:
stdin:1: in main chunk
[C]: ?
> x = foo
> = type(x) -- Kiểu của ngươi là ji?
function
> = x(77) -- giờ thử gọi ngươi.
154

Chú ý rằng chúng ta không thể gọi đối tượng x ở trên do nó là 1 chuỗi nhưng khi chúng ta gán hàm foo vào biến x, chúng ta có thể gọi nó. Đây là sự tương phản đối với các ngôn ngữ mô tả thống kê (như C) – khi biên dịch cần phải biết biến x có phải hàm hay không và trạng thái đó không thể thay đổi lúc chạy chương trình.
Chú ý rằng kiểu của 1 hàm thường đơn thuần là "function", không cần phải thu nhặt số và các kiểu của các thông số hàm và trả về giá trị:

> = type(foo) -- kiểu?
function

Điều này khác với C, trong đó kiểu của 1 hàm chứa tham số và trả về thông tin về kiểu phải được chỉ rõ trước khi sử dụng. Trong Lua bạn không cần mô tả kiểu của các giá trị được trả về từ hàm hoặc cho các tham số truyền vào hàm! Điều này cho phép Lua xử lý các tham số hàm và các giá trị trả về một cách linh hoạt.
Nói riêng, chúng ta không có vấn đề trong việc gán các hàm với các danh sách tham số hay trả về các giá trị cho biến x vì x không có khái niệm gì về các đối tượng gán vào nó:

> x = function(a,b) return a+b, a-b end
> = x(5,6)
11 -1
> function x(a,b,c) return a..b..c end
> = x('a','b','c')
abc

Tất nhiên chúng ta phải cẩn thận đối với đặt tên biến để không bị báo lỗi khi đang biên dịch hoặc lúc chạy chương trình như trong các ngôn ngữ kiểu thống kê. Tuy nhiên, điều này rất hữu dụng cho phép chúng ta viết code linh hoạt và đơn giản.

Sự phá hủy hàm (Function destruction)

Các hàm, như các đối tượng, cũng tiêu thụ tài nguyên (bộ nhớ hệ thống). Functions, as objects, consume resources (system memory). Chúng bị phá hủy dần. Như các đối tượng khác, Lua phá hủy các hàm sau khi chúng không còn dùng đến nữa:

> = foo
function: 0x688af8
> bar = foo -- làm bar tham chiếu đến cùng 1 hàm như foo
> foo = nil -- foo không còn tham chiếu hàm nữa...
> = bar -- nhưng bar vẫn còn.
function: 0x688af8
> bar = nil -- bar cũng ko tham chiếu hàm nữa.
= bar, foo -- không còn ji tham chiếu hàm
nil nil
> foo() -- thử kéo theo hàm
stdin:1: attempt to call global `foo' (a nil value)
stack traceback:
stdin:1: in main chunk
[C]: ?

Vì foo chỉ là 1 tham chiếu đến 1 thân của 1 hàm, chúng ta có thể gán các biến khác đến cùng giá trị. Chúng ta cũng có thể xóa tham chiếu đến foo qua việc gán nil cho nó. Điều này hiệu quả để xóa biến foo. Một khi chúng ta xóa tham chiếu từ cả foo và bar, hàm không trở thành mất liên lạc, và Lua sẽ xóa nó.

Truyền tham số (Passing arguments)

Vì Lua được mô tả động và không cần mô tả kiểu hàm, nên việc kiểm tra số và kiểu của các tham số cần thiết cho 1 hàm dường như là thừa. Các tham số hàm hình thức nhận nil làm giá trị mặc định nếu không có giá trị. Chỗ nào quá nhiều tham số được truyền vào, chúng sẽ bị bỏ qua. Không có kiểu nào được chỉ rõ cho tham số vì chúng là dạng mô tả động. Chúng ta hãy xem ví dụ sau:

> function foo(a,b,c) print(a,b,c) end

Và đây là những ji diễn ra khi chúng ta gọi nó mà không có tham số:

> foo()
nil nil nil

Chú ý rằng mỗi tham số được mặc định thành giá trị nil hay ko giá trị, và húng ta cũng ko bị báo lỗi. Còn đây là kết quả khi chúng ta truyền quá nhiều tham số:

> foo(1,2,3,4)
1 2 3

Một lần nữa, không có lỗi và tham số cuối cùng bị bỏ qua. Bởi vì Lua là mô tả động, chúng ta có thể truyền bất cứ kiểu tham số nào. Ví dụ chúng ta có thể truyền các chuỗi vào hàm.

> foo("hello")
hello nil nil
> foo("pi", 3.1415, { comment="this is a table" })
pi 3.1415 table: 002FDBE8

Các tham số biến (Variable arguments)

1 hàm có các tham số biến sẽ rất hữu ích, ví dụ hàm printf(format,...) trong C. 1 cách Lua làm điều này là đặt danh sách biến tham số vào 1 bảng mảng được gọi là arg, có thể được hàm sử dụng, ví dụ,

> function foo(...) print(arg) end
> foo("abc",3,77)
table: 002FD3B8

Trong ví dụ này, chúng ta chỉ thấy 1 bảng. Chúng ta có thể dùng table.foreach(table,function) để xuất ra các giá trị của bảng tham số biến như sau:

> function foo(...) table.foreach(arg,print) end
> foo()
n 0

Từ việc nhìn vào 1 danh sách tham số biến rỗng, dễ dàng nhận ra rằng 1 cặp bảng phụ được thêm vào để cung cấp số lượng các phần tử trong bảng, arg.n. Trong trường hợp này, số lượng tham số là 0. Hãy thử truyền vài tham số biến vào:

> foo(1,2,3)
1 1
2 2
3 3
n 3
> foo("apple",2,"banana",99,3.1415927,foo)
1 apple
2 2
3 banana
4 99
5 3.1415927
6 function: 002FB5C8
n 6
Cách khác là sử dụng ... để thay thế:

> function foo(...) print('x', select(2, ...), 'y', ...) end
> foo("apple",'a',"banana")
x a y apple a banana

Dấu ... có 1 lợi thế trong là nó ngăn hậu quả thực thi trong quá trình xây dựng arg bảng.

unpack

1 hàm hữu dụng cho các tham số biến là unpack(). Hàm này lấy 1 bảng và trả về danh sách các biến, ví dụ:

> = unpack({1,2,3})
1 2 3

Có thể sử dụng với các danh sách tham số biến như sau:

> function listargs(...)
>> return unpack(arg)
>> end
> = listargs(1,2,3)
1 2 3
> = listargs("hello", {1,2,3}, function (x) return x*x end)
hello table: 0035F0B8 function: 00357860

Nhiều giá trị cùng trả về (Multiple return values)

Lua có thể trả hơn 1 giá trị từ 1 hàm. Điều này được thực hiện qua việc trả vế 1 danh sách các giá trị cách nhau bởi dấu “,”:

> function foo(angle)
>> return math.cos(angle), math.sin(angle)
>> end
>> print( foo(1) ) -- trả về 2 giá trị...
0.54030230586814 0.8414709848079
>> c,s = foo(3.142/3) -- gán các giá trị vào các biến
> = math.atan(s/c)
1.0473333333333
> = c,s
0.49988240461137 0.86609328686923
>> function many(x)
>> return x, x*x, x*x*x, x*x*x*x, x*x*x*x*x
>> end> = many(5)
5 25 125 625 3125
> = many(0.9)
0.9 0.81 0.729 0.6561 0.59049

Hàm trên đây có thể có biến số của các giá trị trả về nếu chúng ta tạo 1 bảng chứa các giá trị và sử dụng unpack. Ví dụ.,

> function many2(x,times)
>> local t = { [0]=1 }
>> for i=1,times do t = x*t[i-1] end
>> return unpack(t)
>> end
> = many2(5,10)
5 25 125 625 3125 15625 78125 390625 1953125 9765625
> = many2(0.5,7)
0.5 0.25 0.125 0.0625 0.03125 0.015625 0.0078125

Các giá trị như 1 bảng (Values as a table)

Chúng ta cũng trả về các giá trị trong 1 bảng. Để làm điều này chúng ta thêm các ngoặc nhọn quanh phần gọi hàm, thứ sẽ tạo ra 1 bảng, ví dụ:

{ function_name ( args ) }

Đây là 1 ví dụ sử dụng ví dụ hàm trước:

> = { foo(1.5) }
table: 0035E088
> t = { foo(1.5) }
> table.foreach(t,print)
1 0.070737201667703
2 0.99749498660405

Giá trị đơn (Single Value)

Nếu 1 hàm trả về nhiều giá trị cùng lúc mà ta chỉ muốn giá trị đầu tiên, chúng ta đặt 1 cặp ngoặc đơn quanh phần gọi hàm, ví dụ:

(function_name ( args ) )

Đây là 1 ví dụ:

> = (foo(1.5))
0.070737201667703
> = foo(1.5)
0.070737201667703 0.99749498660405

Điều tương tự có thể thu được khi trả về 1 bảng và lấy phần tử đầu Ví dụ,

> = ({foo(1.5)}) [1]
0.070737201667703

[huongphieubat]

Bài viết về cấu trúc điều khiển

while

Phát biểu lặp có điều kiện while có dạng:

while biểu thức do khối lệnh end

Ví dụ, 1 vòng lặp đơn giản:

> i = 3
> while i>0 do
>> print(i)
>> i = i-1
>> end
3 2 1

Chúng ta có thể thoát điều khiển của phát biểu while bằng từ khóa break. Chú ý, trong Lua, từ khóa break phải ở phát biểu cuối cùng trong 1 khối lệnh – ví dụ, từ khóa end phải theo sau, nếu không bạn sẽ gặp lỗi biên dịch.

> a,b = 0,1
> while true do -- lặp vô hạn
>> io.write(b, ", ")
>> a,b = b,a+b
>> if a>500 then break end -- thoát vòng lặp nếu điều kiện đúng - true
>> end
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, >

repeat

Phái biểu lặp có điều kiện repeat có dạng:

repeat khối lệnh until biểu thức

Ví dụ, 1 vòng lặp đơn giản:

> i = 3
> repeat
>> print(i)
>> i = i-1
>> until i==0
3 2 1

Như phát biểu while, chúng ta có thể thoát 1 vòng lặp repeat bằng 1 phát biểu break:
> i = 1
> repeat
>> print(i)
>> i = i+1
>> if i>3 then break end
>> until cows_come_home
1 2 3

cows_come_home là 1 biến không xác định. Khi chúng ta truy vấn nó, chúng ta sẽ nhận giá trị nil, nhis a variable whichư vậy đoạn code này có nghĩa là "until false", hay là mãi mãi.

for

Phát biểu lặp for có 2 dạng. Đầu tiên là lặp dạng số, ví dụ,

> for count = 1,3 do print(count) end -- lặp dạng số
1 2 3

Thứ 2 là lặp trình tự, ví dụ xuất nội dung của 1 bảng. Ở đây, for được truyền vào 1 hàm lặp là pairs(), mục đích là cung cấp giá trị cho mỗi lần lặp:

> for key,value in pairs({10, math.pi, "banana"}) do print(key, value) end
1 10
2 3.1415926535898
3 banana

Cấp số dạng số (Numeric progression)

Dạng cấp số dạng số của for có cấu trúc:

for variable = từ_biểu thức, đến_biểu thức [, bước nhảy] do khối lệnh end

Phát biểu đặt giá trị của biến vào từ_biểu thức trước khi đi vào khối lệnh for. Khối lệnh chỉ được truy cập vào nếu biến không vượt quá giá trị cuối, đến_biểu thức. Điều này bam gồm lần đầu vòng lặp được lặp qua. Mỗi lần bước nhảy được thêm vào biến. Việc chỉ rõ biểu thức bước nhảy là tùy biến (có thể có, có thể không). Nếu không chỉ rõ thì sử dụng giá trị là 1. Ví dụ,

> for i = 1,3 do print(i) end -- đếm từ 1 đến 3
1 2 3
> for i = 3,1 do print(i) end – đếm từ 3 về 1 trong bước nhảy 1
zero iterations!
> for i = 3,1, -1 do print(i) end -- đếm ngược từ 3 về 1
3 2 1
> for i=1,0,-0.25 do print(i) end – Chúng ta không bị giới hạn trong các số nguyên
1
0.75
0.5
0.25
0

Chú ý rằng biến i sẽ chỉ có giá trị trong phạm vi của vòng lặp for, ví dụ,

> print(i) -- sau đoạn code trên
nil

for i = e1,e2,e3 do myFunction(i) end tương đương đoạn code Lua sau:

do
local i, limit, step = tonumber(e1), tonumber(e2), tonumber(e3)
or 1
if not (i and limit and step) then error() end
while (step>0 and i<=limit) or (step<=0 and i>=limit) do
myFunction(i) i = i + step
end
end

Các công cụ lặp (Iterators)

Dạng lặp for thứ 2 có cấu trúc:

for biến {, biến} in danh sách biểu thức do khối lệnh end

danh sách biểu thức được ước tính 1 lần trước khi đi vào vòng lặp. Kết quả của nó là 1 hàm để lặp (hàm này đặt các giá trị cho biến ), 1 trạng thái (các giá trị có thể được đọc từ đó), và 1 giá trị đầu (từ giá trị này mà lặp tới).

pairs(table)

Lua cung cấp 1 hàm pairs() để tạo ra thông tin danh sách lặp cho chúng ta tặp qua 1 bảng. Hàm pairs() sẽ cho phép lặp qua cặp key-value. Chú ý rằng thứ tự các item được trả về không được xác định, thậm chí đối với bảng đã sắp xếp.

> for key,value in pairs(t) do print(key,value) end
3 10
1 3
4 17
2 7
pi 3.14159
banana yellow

ipairs(table)

Hàm ipairs() sẽ cho phép lặp qua cặp index-value. Thứ tự các phần tử trả về được bảo đảm và các khóa không phải số nguyên bị bỏ qua. Sử dụng cùng bảng trong ví dụ trên cho ví dụ sau:

> for index,value in ipairs(t) do print(index,value) end
1 3
2 7
3 10
4 17

Chú ý cách chỉ phần mảng của bảng được hiển thị vì chi các phần tử này mới có khóa thứ tự.

next()

Hàm next(table [,index]) giúp lặp qua 1 bảng. Khi nhận 1 bảng và 1 liệt kê thứ tự, nó trả về cặp key-value kế tiếp từ bảng, ví dụ,

> = next(t) –- thứ tự sẽ là nil, lấy từ bắt đầu
1 3
> = next(t,4)
pi 3.14159

Như với pairs(), thứ tự các item được trả về không được xác định, các khóa thứ tự có thể được trả về theo bất kỳ thứ tự nào, không chỉ là tăng dần theo dạng số. Hàm pairs() trả về 1 danh sách biểu thức chứa trong next() nên chúng ta có thể lặp qua bảng. Chúng ta có thể truyền danh sách biểu thức của bản thân mình vào phát biểu for như sau:

> for key,value in next,t,nil do print(key,value) end
1 3
2 7
3 10
4 17
pi 3.14159
banana yellow

Chúng ta truyền next,table,nil như danh sách biểu thức vào phát biểu for. Chúng ta đang nói chúng ta muốn sử dụng hàm lặp next(), trên bảng t, bắt đầu tại nil (vị trí bắt đầu). Phát biểu for tiếp tục tiến trình cho đến khi hàm next trả về nil (cuối bảng).

io.lines()

Lua cung cấp các phương thức lặp hữu ích khác như io.lines([filename]) trong thư viện io. Chúng ta có thể biểu diễn hàm này thông qua việc tạo 1 file chứa 1 vài dòng text.

> io.output(io.open("my.txt","w"))
> io.write("This is\nsome sample text\nfor Lua.")
> io.close()

Chúng ta đã tạo ra 1 file gôi là "my.txt", viết 3 dòng vào đó và đóng nó. Giờ chúng ta có thể đọc nó qua vòng lặp io.lines

> for line in io.lines("my.txt") do print(line) end
This is
some sample text
for Lua.

file:lines()

Thư viện io cung cấp cách khác để lặp qua các dòng của 1 file text.

> file = assert(io.open("my.txt", "r"))
> for line in file:lines() do print(line) end
This is
some sample text
for Lua.
> file:close()

Vậy nó khác gì với io.lines()?
Bạn phải mở và đóng file rõ ràng. 1 lợi điểm của điều này là nếu không thể mở file, bạn có thể xử lý thất bại này 1 cách nhẹ nhàng. Ở đây, assert có cùng hiệu quả như io.lines: Công cụ phiên dịch sẽ ngừng với 1 thông báo lỗi chỉ ra dòng bị lỗi, nhưng thêm nữa bạn có thể kiểm tra 1 giá trị nil của file và làm vài chuyện khác.
1 lợi điểm khác là bạn có thể bắt đầu vòng lặp từ bất cứ dòng nào:

file = assert(io.open("list.txt", "r"))
local line = file:read()
if string.sub(line, 1, 1) ~= '#' then ProcessLine(line) -- File không bắt đầu với 1 chú thích, thực hiện dòng đầu
end
-- Chúng ta cũng có thể lặp trên dòng đầu, trong khi chúng là các chú thích
-- Thi hành phần còn lại của file

for line in file:lines() do ProcessLine(line)endfile:close()

Các công cụ lặp tự tạo (Custom iterators)

Chúng ta có thể viết các công cụ lặp cho riêng mình, tương tự như next(), để lặp qua bất cứ chuỗi dữ liệu nào

if ... then ... else ... end

Phát biểu if có dạng:

if biểu thức then khối lệnh { elseif biểu thức then khối lệnh } [ else khối lệnh ] end

Ví dụ, if ... then ... end

> if 10>2 then print("bigger") end
bigger
if ... then ... else ... end
> if 1>10 then print("bigger") else print("smaller") end
smaller
if ... then ... elseif ... else ... end
> number = 3
> if number < 1 then
>> value = "smaller than one"
>> elseif number==1 then
>> value = "one"
>> elseif number==2 then
>> value = "two"
>> elseif number==3 then
>> value = "three"
>> else
>> value = "bigger than three"
>> end
> print(value)
three

[manhtuyen]

huongphieubat chăm chỉ quá
cho hỏi chút nhỉ, Lua có hàm để nhập giá trị vào từ bàn phím ko
giống như pascal có read() ấy

[huongphieubat]

huongphieubat chăm chỉ quá
cho hỏi chút nhỉ, Lua có hàm để nhập giá trị vào từ bàn phím ko
giống như pascal có read() ấy

hi siêng ji đâu, cũng là 1 cách tự học thui ^^ Cái tuyền phải là cái này ko: (io.stdin:read)

> print'enter name:'
>>name = io.stdin:read'*l'
>>print('name',name)
>>print'enter age:'
>>age = io.stdin:read'*l'
>>print('age',age)

enter name:
bill
name bill
enter age:
5
age 5

Hum nay chủ nhật nghỉ xả hơi, hok viết bài nữa ^^
À quên '*l' là format đọc dòng kế tiếp (bỏ phần cuối dòng) là dạng format mặc định. Mình có thể đọc dòng tiếp theo nếu có giá trị nhập vào. Ngoài ra còn '*a" là đọc hết, và '*n' là đọc số. Cái này liên quan đến phần input và output, tui cũng chưa coi kỹ. Đến bài đó viết lại xem sao.

[manhtuyen]

Thanks nhìu
các hàm này hình như là Lua 5, võ lâm dùng lua 4 cơ chắc không được rồi.