Chuỗi định nghĩa hàm python

Lua là ngôn ngữ lập trình mở rộng được thiết kế để hỗ trợ lập trình thủ tục chung với các phương tiện mô tả dữ liệu. Nó cũng hỗ trợ tốt cho lập trình hướng đối tượng, lập trình chức năng và lập trình hướng dữ liệu. Lua nhằm mục đích sử dụng như một ngôn ngữ kịch bản nhẹ, mạnh mẽ cho bất kỳ chương trình nào cần. Lua được triển khai dưới dạng thư viện, được viết bằng ngôn ngữ C sạch (tức là trong tập hợp con chung của ANSI C và C++)

Là một ngôn ngữ mở rộng, Lua không có khái niệm về một chương trình "chính". nó chỉ hoạt động được nhúng trong một máy khách chủ, được gọi là chương trình nhúng hoặc đơn giản là máy chủ. Chương trình máy chủ này có thể gọi các hàm để thực thi một đoạn mã Lua, có thể viết và đọc các biến Lua cũng như có thể đăng ký các hàm C để mã Lua gọi. Thông qua việc sử dụng các hàm C, Lua có thể được tăng cường để xử lý nhiều miền khác nhau, do đó tạo ra các ngôn ngữ lập trình tùy chỉnh chia sẻ một khung cú pháp. Bản phân phối Lua bao gồm một chương trình lưu trữ mẫu có tên là

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
66, chương trình này sử dụng thư viện Lua để cung cấp một trình thông dịch Lua hoàn chỉnh, độc lập

Lua là phần mềm miễn phí và được cung cấp như thường lệ mà không có bảo đảm, như đã nêu trong giấy phép của nó. Việc triển khai được mô tả trong sách hướng dẫn này có tại trang web chính thức của Lua,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
67

Giống như bất kỳ tài liệu hướng dẫn tham khảo nào khác, tài liệu này còn khô khan ở những chỗ. Để thảo luận về các quyết định đằng sau thiết kế của Lua, hãy xem các tài liệu kỹ thuật có sẵn trên trang web của Lua. Để có phần giới thiệu chi tiết về lập trình trong Lua, hãy xem cuốn sách của Roberto, Lập trình trong Lua (Ấn bản thứ hai)

Phần này mô tả từ vựng, cú pháp và ngữ nghĩa của Lua. Nói cách khác, phần này mô tả mã thông báo nào hợp lệ, cách chúng có thể được kết hợp và ý nghĩa của sự kết hợp của chúng

Các cấu trúc ngôn ngữ sẽ được giải thích bằng cách sử dụng ký hiệu BNF mở rộng thông thường, trong đó {a} có nghĩa là 0 hoặc nhiều a và [a] có nghĩa là một tùy chọn a. Các ký hiệu không phải thiết bị đầu cuối được hiển thị giống như không phải thiết bị đầu cuối, các từ khóa được hiển thị như kword và các ký hiệu thiết bị đầu cuối khác được hiển thị như `=´. Cú pháp hoàn chỉnh của Lua có thể được tìm thấy trong §8 ở cuối sách hướng dẫn này

Tên (còn được gọi là định danh) trong Lua có thể là bất kỳ chuỗi chữ cái, chữ số và dấu gạch dưới nào, không bắt đầu bằng một chữ số. Điều này trùng khớp với định nghĩa về tên trong hầu hết các ngôn ngữ. (Định nghĩa của chữ cái phụ thuộc vào ngôn ngữ hiện tại. bất kỳ ký tự nào được coi là chữ cái theo ngôn ngữ hiện tại đều có thể được sử dụng trong mã định danh. ) Định danh được sử dụng để đặt tên cho các biến và trường bảng

Các từ khóa sau được dành riêng và không thể được sử dụng làm tên

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while

Lua là ngôn ngữ phân biệt chữ hoa chữ thường.

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
68 là một từ dành riêng, nhưng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
69 và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
70 là hai tên hợp lệ khác nhau. Theo quy ước, các tên bắt đầu bằng dấu gạch dưới theo sau là các chữ cái viết hoa (chẳng hạn như
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
71) được dành riêng cho các biến toàn cục nội bộ được Lua sử dụng

Các chuỗi sau biểu thị các mã thông báo khác

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...

Các chuỗi ký tự có thể được phân tách bằng cách khớp các dấu ngoặc đơn hoặc kép và có thể chứa các chuỗi thoát giống như C sau đây. '_______072' (chuông), '

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
73' (xóa lùi), '
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
74' (nguồn cấp dữ liệu biểu mẫu), '
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
75' (dòng mới), '
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
76' (xuống dòng), '
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
77' (tab ngang), '
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
78' (dọc . Ngoài ra, dấu gạch chéo ngược theo sau bởi một dòng mới thực sự dẫn đến một dòng mới trong chuỗi. Một ký tự trong một chuỗi cũng có thể được chỉ định bởi giá trị số của nó bằng cách sử dụng chuỗi thoát
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
82, trong đó ddd là một chuỗi có tối đa ba chữ số thập phân. (Lưu ý rằng nếu một số thoát được theo sau bởi một chữ số, thì nó phải được thể hiện bằng chính xác ba chữ số. ) Các chuỗi trong Lua có thể chứa bất kỳ giá trị 8 bit nào, kể cả các số 0 được nhúng, có thể được chỉ định là '
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
83'

Các chuỗi ký tự cũng có thể được xác định bằng cách sử dụng định dạng dài được đặt trong dấu ngoặc dài. Chúng tôi định nghĩa một dấu ngoặc dài mở cấp n là một dấu ngoặc vuông mở, theo sau là n dấu bằng, theo sau là một dấu ngoặc vuông mở khác. Vì vậy, một dấu ngoặc dài mở đầu của cấp 0 được viết là

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
84, một dấu ngoặc dài mở đầu của cấp 1 được viết là
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
85, v.v. Một dấu ngoặc dài đóng được xác định tương tự; . Một chuỗi dài bắt đầu bằng một dấu ngoặc dài mở ở bất kỳ cấp nào và kết thúc ở dấu ngoặc dài đóng đầu tiên cùng cấp. Chữ ở dạng ngoặc đơn này có thể chạy trong một số dòng, không diễn giải bất kỳ chuỗi thoát nào và bỏ qua dấu ngoặc dài ở bất kỳ cấp độ nào khác. Chúng có thể chứa bất cứ thứ gì ngoại trừ dấu ngoặc đóng ở mức phù hợp

Để thuận tiện, khi dấu ngoặc dài mở ngay sau đó là một dòng mới, dòng mới không được bao gồm trong chuỗi. Ví dụ: trong một hệ thống sử dụng ASCII (trong đó '_______087' được mã hóa là 97, dòng mới được mã hóa là 10 và '

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
88' được mã hóa là 49), năm chuỗi ký tự bên dưới biểu thị cùng một chuỗi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]

Một hằng số có thể được viết với phần thập phân tùy chọn và số mũ thập phân tùy chọn. Lua cũng chấp nhận các hằng số thập lục phân số nguyên, bằng cách thêm tiền tố vào trước chúng là

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
89. Ví dụ về các hằng số hợp lệ là

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
7

Nhận xét bắt đầu bằng dấu gạch ngang kép (

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
90) ở bất kỳ đâu bên ngoài chuỗi. Nếu văn bản ngay sau
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
90 không phải là một dấu ngoặc dài mở đầu, bình luận là một bình luận ngắn, chạy cho đến cuối dòng. Mặt khác, đó là một nhận xét dài, chạy cho đến khi đóng dấu ngoặc dài tương ứng. Bình luận dài thường được sử dụng để tắt mã tạm thời

Lua là một ngôn ngữ gõ động. Điều này có nghĩa là các biến không có kiểu; . Không có định nghĩa loại trong ngôn ngữ. Tất cả các giá trị mang loại riêng của họ

Tất cả các giá trị trong Lua đều là giá trị hạng nhất. Điều này có nghĩa là tất cả các giá trị có thể được lưu trữ trong các biến, được truyền dưới dạng đối số cho các hàm khác và được trả về dưới dạng kết quả

Có tám loại cơ bản trong Lua. nil, boolean, số, chuỗi, hàm, dữ liệu người dùng, chủ đề và bảng. Nil là loại giá trị nil, có thuộc tính chính là khác với bất kỳ giá trị nào khác; . Boolean là loại giá trị sai và đúng. Cả nil và false đều tạo ra một điều kiện sai; . Số đại diện cho các số thực (dấu phẩy động có độ chính xác kép). (Thật dễ dàng để xây dựng các trình thông dịch Lua sử dụng các biểu diễn bên trong khác cho các số, chẳng hạn như số thực float hoặc số nguyên dài có độ chính xác đơn; xem tệp

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
92. ) Chuỗi đại diện cho mảng ký tự. Lua là 8-bit sạch. các chuỗi có thể chứa bất kỳ ký tự 8-bit nào, kể cả các số 0 được nhúng ('
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
83') (xem §2. 1)

Lua có thể gọi (và thao tác) các hàm viết bằng Lua và các hàm viết bằng C (xem §2. 5. số 8)

Loại dữ liệu người dùng được cung cấp để cho phép dữ liệu C tùy ý được lưu trữ trong các biến Lua. Loại này tương ứng với một khối bộ nhớ thô và không có thao tác được xác định trước trong Lua, ngoại trừ phép thử gán và nhận dạng. Tuy nhiên, bằng cách sử dụng các metatable, lập trình viên có thể định nghĩa các thao tác cho các giá trị dữ liệu người dùng (xem §2. số 8). Giá trị dữ liệu người dùng không thể được tạo hoặc sửa đổi trong Lua, chỉ thông qua C API. Điều này đảm bảo tính toàn vẹn của dữ liệu thuộc sở hữu của chương trình máy chủ

Chủ đề loại đại diện cho các chủ đề thực thi độc lập và nó được sử dụng để triển khai các coroutine (xem §2. 11). Đừng nhầm lẫn luồng Lua với luồng hệ điều hành. Lua hỗ trợ coroutine trên tất cả các hệ thống, ngay cả những hệ thống không hỗ trợ luồng

Bảng kiểu thực hiện các mảng kết hợp, nghĩa là các mảng có thể được lập chỉ mục không chỉ bằng số mà còn với bất kỳ giá trị nào (ngoại trừ nil). Các bảng có thể không đồng nhất; . Các bảng là cơ chế cấu trúc dữ liệu duy nhất trong Lua; . Để đại diện cho các bản ghi, Lua sử dụng tên trường làm chỉ mục. Ngôn ngữ hỗ trợ biểu diễn này bằng cách cung cấp

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
94 dưới dạng đường cú pháp cho
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
95. Có một số cách thuận tiện để tạo bảng trong Lua (xem §2. 5. 7)

Giống như các chỉ mục, giá trị của trường bảng có thể thuộc bất kỳ loại nào (ngoại trừ nil). Đặc biệt, vì các hàm là giá trị hạng nhất nên các trường bảng có thể chứa các hàm. Do đó, các bảng cũng có thể mang các phương thức (xem §2. 5. 9)

Các bảng, hàm, luồng và giá trị dữ liệu người dùng (đầy đủ) là các đối tượng. các biến không thực sự chứa các giá trị này, chỉ tham chiếu đến chúng. Phép gán, truyền tham số và trả về hàm luôn thao tác với các tham chiếu đến các giá trị đó;

Hàm thư viện

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
96 trả về một chuỗi mô tả loại của một giá trị đã cho

Lua cung cấp chuyển đổi tự động giữa các giá trị chuỗi và số trong thời gian chạy. Bất kỳ phép toán số học nào được áp dụng cho một chuỗi đều cố gắng chuyển đổi chuỗi này thành một số, tuân theo các quy tắc chuyển đổi thông thường. Ngược lại, bất cứ khi nào một số được sử dụng khi một chuỗi được mong đợi, thì số đó sẽ được chuyển đổi thành một chuỗi, ở định dạng hợp lý. Để kiểm soát hoàn toàn cách số được chuyển đổi thành chuỗi, hãy sử dụng hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
97 từ thư viện chuỗi (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
98)

Biến là nơi lưu trữ giá trị. Có ba loại biến trong Lua. biến toàn cục, biến cục bộ và trường bảng

Một tên duy nhất có thể biểu thị biến toàn cục hoặc biến cục bộ (hoặc tham số chính thức của hàm, là một loại biến cục bộ cụ thể)

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
7

Tên biểu thị định danh, như được định nghĩa trong §2. 1

Bất kỳ biến nào được coi là toàn cục trừ khi được khai báo rõ ràng là cục bộ (xem §2. 4. 7). Các biến cục bộ có phạm vi từ vựng. các biến cục bộ có thể được truy cập tự do bởi các hàm được định nghĩa bên trong phạm vi của chúng (xem §2. 6)

Trước lần gán đầu tiên cho một biến, giá trị của nó là không

Dấu ngoặc vuông được sử dụng để lập chỉ mục cho bảng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
8

Ý nghĩa của việc truy cập vào các biến toàn cục và trường bảng có thể được thay đổi thông qua metatables. Quyền truy cập vào một biến được lập chỉ mục

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
99 tương đương với một cuộc gọi
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
700. (Xem §2. 8 để biết mô tả đầy đủ về hàm
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
701. Hàm này không được xác định hoặc không thể gọi được trong Lua. Chúng tôi sử dụng nó ở đây chỉ cho mục đích giải thích. )

Cú pháp

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
702 chỉ là đường cú pháp cho
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
703

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
4

Tất cả các biến toàn cục tồn tại dưới dạng các trường trong bảng Lua thông thường, được gọi là bảng môi trường hoặc đơn giản là môi trường (xem §2. 9). Mỗi hàm có tham chiếu riêng đến một môi trường, do đó tất cả các biến toàn cục trong hàm này sẽ tham chiếu đến bảng môi trường này. Khi một hàm được tạo, nó sẽ kế thừa môi trường từ hàm đã tạo ra nó. Để lấy bảng môi trường của một hàm Lua, bạn gọi

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
704. Để thay thế nó, bạn gọi
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
705. (Bạn chỉ có thể thao tác với môi trường của các hàm C thông qua thư viện gỡ lỗi; (xem §5. 9). )

Quyền truy cập vào biến toàn cục

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 tương đương với
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
707, do đó tương đương với

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
9

trong đó

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
708 là môi trường của chức năng đang chạy. (Xem §2. 8 để biết mô tả đầy đủ về hàm
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
701. Hàm này không được xác định hoặc không thể gọi được trong Lua. Tương tự, biến
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
708 không được định nghĩa trong Lua. Chúng tôi sử dụng chúng ở đây chỉ cho mục đích giải thích. )

Lua hỗ trợ một tập hợp các câu lệnh gần như thông thường, tương tự như trong Pascal hoặc C. Bộ này bao gồm các phép gán, cấu trúc điều khiển, lời gọi hàm và khai báo biến

Đơn vị thực hiện Lua được gọi là chunk. Một đoạn chỉ đơn giản là một chuỗi các câu lệnh, được thực hiện tuần tự. Mỗi câu lệnh có thể được tùy chọn theo sau bởi dấu chấm phẩy

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
3

Không có tuyên bố trống và do đó '______2711' là không hợp pháp

Lua xử lý một đoạn dưới dạng phần thân của hàm ẩn danh với số lượng đối số thay đổi (xem §2. 5. 9). Như vậy, các khối có thể xác định các biến cục bộ, nhận đối số và trả về giá trị

Một đoạn có thể được lưu trữ trong một tệp hoặc trong một chuỗi bên trong chương trình máy chủ. Để thực thi một đoạn mã, trước tiên, Lua biên dịch trước đoạn mã đó thành các hướng dẫn dành cho máy ảo, sau đó nó thực thi mã đã biên dịch bằng một trình thông dịch cho máy ảo

Các khối cũng có thể được biên dịch trước thành dạng nhị phân; . Các chương trình ở dạng mã nguồn và biên dịch có thể hoán đổi cho nhau;

Một khối là một danh sách các câu lệnh;

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
6

Một khối có thể được phân định rõ ràng để tạo ra một câu lệnh

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
0

Các khối rõ ràng rất hữu ích để kiểm soát phạm vi khai báo biến. Các khối rõ ràng đôi khi cũng được sử dụng để thêm câu lệnh return hoặc break vào giữa một khối khác (xem §2. 4. 4)

Lua cho phép nhiều nhiệm vụ. Do đó, cú pháp gán định nghĩa một danh sách các biến ở bên trái và một danh sách các biểu thức ở bên phải. Các phần tử trong cả hai danh sách được phân tách bằng dấu phẩy

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
1

Biểu thức được thảo luận trong §2. 5

Trước khi gán, danh sách các giá trị được điều chỉnh theo độ dài của danh sách các biến. Nếu có nhiều giá trị hơn mức cần thiết, các giá trị dư thừa sẽ bị loại bỏ. Nếu có ít giá trị hơn mức cần thiết, danh sách sẽ được mở rộng với bao nhiêu giá trị không cần thiết. Nếu danh sách các biểu thức kết thúc bằng một lời gọi hàm, thì tất cả các giá trị được trả về bởi lời gọi đó sẽ nhập danh sách các giá trị, trước khi điều chỉnh (ngoại trừ khi lời gọi được đặt trong ngoặc đơn; xem §2. 5)

Câu lệnh gán trước tiên đánh giá tất cả các biểu thức của nó và chỉ sau đó các phép gán mới được thực hiện. Như vậy mã

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
2

đặt

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
713 thành 20 mà không ảnh hưởng đến
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
714 vì
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
715 trong
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
716 được đánh giá (thành 3) trước khi được chỉ định 4. Tương tự, dòng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
3

trao đổi các giá trị của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 và
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
718, và

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
4

hoán vị theo chu kỳ các giá trị của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706,
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
718 và
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
721

Ý nghĩa của việc gán cho các biến toàn cục và các trường bảng có thể được thay đổi thông qua metatables. Một phép gán cho một biến được lập chỉ mục

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
722 tương đương với
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
723. (Xem §2. 8 để biết mô tả đầy đủ về hàm
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
724. Hàm này không được xác định hoặc không thể gọi được trong Lua. Chúng tôi sử dụng nó ở đây chỉ cho mục đích giải thích. )

Phép gán cho một biến toàn cục

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
725 tương đương với phép gán
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
726, đến lượt nó tương đương với

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
5

trong đó

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
708 là môi trường của chức năng đang chạy. (Biến
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
708 không được định nghĩa trong Lua. Chúng tôi sử dụng nó ở đây chỉ cho mục đích giải thích. )

Các cấu trúc điều khiển if, while và repeat có nghĩa thông thường và cú pháp quen thuộc

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
6

Lua cũng có một câu lệnh for, có hai dạng (xem §2. 4. 5)

Biểu thức điều kiện của cấu trúc điều khiển có thể trả về bất kỳ giá trị nào. Cả sai và không đều được coi là sai. Mọi giá trị khác nil và false đều được coi là đúng (đặc biệt số 0 và chuỗi rỗng cũng đúng)

Trong vòng lặp repeat–until, khối bên trong không kết thúc ở từ khóa until mà chỉ kết thúc sau điều kiện. Vì vậy, điều kiện có thể tham chiếu đến các biến cục bộ được khai báo bên trong khối vòng lặp

Câu lệnh return được sử dụng để trả về các giá trị từ một hàm hoặc một đoạn (chỉ là một hàm). Các hàm và khối có thể trả về nhiều hơn một giá trị, do đó, cú pháp của câu lệnh trả về là

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
7

Câu lệnh break được sử dụng để kết thúc việc thực hiện vòng lặp while, repeat hoặc for, chuyển sang câu lệnh tiếp theo sau vòng lặp

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
8

Một sự phá vỡ kết thúc vòng lặp kèm theo trong cùng

Câu lệnh return và break chỉ có thể được viết dưới dạng câu lệnh cuối cùng của khối. Nếu thực sự cần thiết phải quay lại hoặc ngắt ở giữa một khối, thì có thể sử dụng khối bên trong rõ ràng, như trong thành ngữ

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
729 và
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
730, bởi vì bây giờ trả về và ngắt là câu lệnh cuối cùng trong khối (bên trong) của chúng

Câu lệnh for có hai dạng. một số và một chung chung

Vòng lặp số cho lặp lại một khối mã trong khi một biến điều khiển chạy qua một cấp số cộng. Nó có cú pháp sau

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
9

Khối được lặp lại cho tên bắt đầu từ giá trị của điểm kinh nghiệm đầu tiên, cho đến khi nó vượt qua điểm kinh nghiệm thứ hai theo các bước của điểm kinh nghiệm thứ ba. Chính xác hơn, một câu lệnh for như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
0

tương đương với mã

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
1

Lưu ý những điều dưới đây

  • Tất cả ba biểu thức điều khiển chỉ được đánh giá một lần, trước khi vòng lặp bắt đầu. Tất cả chúng đều phải dẫn đến những con số
  •      and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    731,
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    732 và
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    733 là các biến vô hình. Tên hiển thị ở đây chỉ nhằm mục đích giải thích
  • Nếu biểu thức thứ ba (bước) không có, thì bước 1 được sử dụng
  • Bạn có thể sử dụng break để thoát khỏi vòng lặp for
  • Biến vòng lặp
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    734 là cục bộ của vòng lặp; . Nếu bạn cần giá trị này, hãy gán nó cho một biến khác trước khi ngắt hoặc thoát khỏi vòng lặp

Câu lệnh for chung hoạt động trên các hàm, được gọi là trình vòng lặp. Trên mỗi lần lặp, hàm lặp được gọi để tạo ra một giá trị mới, dừng khi giá trị mới này bằng không. Vòng lặp for chung có cú pháp sau

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
2

Một tuyên bố cho như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
3

tương đương với mã

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
4

Lưu ý những điều dưới đây

  •      and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    735 chỉ được đánh giá một lần. Kết quả của nó là một hàm lặp, trạng thái và giá trị ban đầu cho biến lặp đầu tiên
  •      and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    736,
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    737 và
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    731 là các biến vô hình. Các tên ở đây chỉ nhằm mục đích giải thích
  • Bạn có thể sử dụng break để thoát khỏi vòng lặp for
  • Các biến vòng lặp
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    739 là cục bộ của vòng lặp; . Nếu bạn cần những giá trị này, hãy gán chúng cho các biến khác trước khi ngắt hoặc thoát khỏi vòng lặp

Để cho phép các tác dụng phụ có thể xảy ra, các lệnh gọi hàm có thể được thực hiện dưới dạng các câu lệnh

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
5

Trong trường hợp này, tất cả các giá trị trả về sẽ bị loại bỏ. Các cuộc gọi chức năng được giải thích trong §2. 5. 8

Các biến cục bộ có thể được khai báo ở bất cứ đâu bên trong một khối. Tuyên bố có thể bao gồm một nhiệm vụ ban đầu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
6

Nếu có, phép gán ban đầu có cùng ngữ nghĩa của phép gán nhiều lần (xem §2. 4. 3). Mặt khác, tất cả các biến được khởi tạo bằng nil

Một đoạn cũng là một khối (xem §2. 4. 1) và vì vậy các biến cục bộ có thể được khai báo trong một đoạn bên ngoài bất kỳ khối rõ ràng nào. Phạm vi của các biến cục bộ như vậy kéo dài cho đến khi kết thúc đoạn

Các quy tắc hiển thị cho các biến cục bộ được giải thích trong §2. 6

Các biểu thức cơ bản trong Lua như sau

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
7

Số và chuỗi ký tự được giải thích trong §2. 1; . 3; . 5. 9; . 5. số 8; . 5. 7. Các biểu thức Vararg, được biểu thị bằng ba dấu chấm ('______2740'), chỉ có thể được sử dụng khi trực tiếp bên trong một hàm vararg; . 5. 9

Các toán tử nhị phân bao gồm các toán tử số học (xem §2. 5. 1), toán tử quan hệ (xem §2. 5. 2), toán tử logic (xem §2. 5. 3) và toán tử nối (xem §2. 5. 4). Toán tử đơn nguyên bao gồm phép trừ đơn nguyên (xem §2. 5. 1), đơn thức không (xem §2. 5. 3) và toán tử độ dài một ngôi (xem §2. 5. 5)

Cả lệnh gọi hàm và biểu thức vararg đều có thể dẫn đến nhiều giá trị. Nếu một biểu thức được sử dụng như một câu lệnh (chỉ khả thi đối với các lời gọi hàm (xem §2. 4. 6)), thì danh sách trả về của nó được điều chỉnh thành các phần tử bằng 0, do đó loại bỏ tất cả các giá trị được trả về. Nếu một biểu thức được sử dụng làm thành phần cuối cùng (hoặc duy nhất) của danh sách các biểu thức, thì không có điều chỉnh nào được thực hiện (trừ khi lệnh gọi được đặt trong ngoặc đơn). Trong tất cả các ngữ cảnh khác, Lua điều chỉnh danh sách kết quả thành một phần tử, loại bỏ tất cả các giá trị ngoại trừ phần tử đầu tiên

Dưới đây là một số ví dụ

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
8

Bất kỳ biểu thức nào được đặt trong ngoặc đơn luôn chỉ dẫn đến một giá trị. Do đó,

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
741 luôn là một giá trị duy nhất, ngay cả khi
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 trả về một số giá trị. (Giá trị của
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
741 là giá trị đầu tiên được trả về bởi
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 hoặc nil nếu
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 không trả về bất kỳ giá trị nào. )

Lua hỗ trợ các toán tử số học thông thường. nhị phân

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
746 (cộng),
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
747 (phép trừ),
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
748 (nhân),
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
749 (chia),
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
750 (mô đun) và
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
751 (lũy thừa); . Nếu toán hạng là số hoặc chuỗi có thể chuyển đổi thành số (xem §2. 2. 1), sau đó tất cả các hoạt động có ý nghĩa thông thường. Lũy thừa hoạt động cho bất kỳ số mũ nào. Chẳng hạn,
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
753 tính nghịch đảo của căn bậc hai của
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706. Modulo được định nghĩa là

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
9

Nghĩa là, phần còn lại của một phép chia làm tròn thương số về âm vô cực

Các toán tử quan hệ trong Lua là

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
70

Các toán tử này luôn cho kết quả sai hoặc đúng

Đẳng thức (

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
755) trước tiên so sánh loại toán hạng của nó. Nếu các loại khác nhau, thì kết quả là sai. Mặt khác, các giá trị của toán hạng được so sánh. Số và chuỗi được so sánh theo cách thông thường. Các đối tượng (bảng, dữ liệu người dùng, luồng và hàm) được so sánh bằng tham chiếu. hai đối tượng được coi là bằng nhau chỉ khi chúng là cùng một đối tượng. Mỗi khi bạn tạo một đối tượng mới (bảng, dữ liệu người dùng, chuỗi hoặc hàm), đối tượng mới này sẽ khác với bất kỳ đối tượng nào đã tồn tại trước đó

Bạn có thể thay đổi cách Lua so sánh các bảng và dữ liệu người dùng bằng cách sử dụng siêu phương thức "eq" (xem §2. số 8)

Quy tắc chuyển đổi của §2. 2. 1 không áp dụng cho so sánh bình đẳng. Do đó,

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
756 đánh giá là sai và
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
757 và
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
758 biểu thị các mục khác nhau trong một bảng

Toán tử

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
759 chính xác là phủ định của đẳng thức (
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
755)

Các toán tử đặt hàng hoạt động như sau. Nếu cả hai đối số là số, thì chúng được so sánh như vậy. Mặt khác, nếu cả hai đối số đều là chuỗi, thì giá trị của chúng được so sánh theo ngôn ngữ hiện tại. Mặt khác, Lua cố gắng gọi siêu phương thức "lt" hoặc "le" (xem §2. số 8). Một so sánh

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
761 được dịch sang
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
762 và
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
763 được dịch sang
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
764

Các toán tử logic trong Lua là và, hoặc, và không. Giống như các cấu trúc điều khiển (xem §2. 4. 4), tất cả các toán tử logic coi cả false và nil là false và bất kỳ thứ gì khác là true

Toán tử phủ định không phải lúc nào cũng trả về false hoặc true. Toán tử kết hợp và trả về đối số đầu tiên của nó nếu giá trị này là sai hoặc không; . Toán tử phân tách hoặc trả về đối số đầu tiên của nó nếu giá trị này khác với nil và false; . Cả hai và và hoặc sử dụng đánh giá ngắn gọn; . Dưới đây là một số ví dụ

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
71

(Trong sách hướng dẫn này,

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
765 biểu thị kết quả của biểu thức trước. )

Toán tử nối chuỗi trong Lua được biểu thị bằng hai dấu chấm ('

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
766'). Nếu cả hai toán hạng đều là chuỗi hoặc số, thì chúng được chuyển đổi thành chuỗi theo các quy tắc được đề cập trong §2. 2. 1. Mặt khác, siêu phương thức "concat" được gọi (xem §2. số 8)

Toán tử độ dài được biểu thị bằng toán tử một ngôi

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
767. Độ dài của một chuỗi là số byte của nó (nghĩa là ý nghĩa thông thường của độ dài chuỗi khi mỗi ký tự là một byte)

Độ dài của bảng

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768 được định nghĩa là bất kỳ chỉ số số nguyên nào
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 sao cho
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
770 không phải là số không và
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
771 là số không; . Đối với một mảng thông thường, với các giá trị khác không từ 1 đến một
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 đã cho, độ dài của nó chính xác là
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769, chỉ mục của giá trị cuối cùng của nó. Nếu mảng có "lỗ hổng" (nghĩa là giá trị nil giữa các giá trị không phải nil khác), thì
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
776 có thể là bất kỳ chỉ số nào trực tiếp đứng trước giá trị nil (nghĩa là, nó có thể coi bất kỳ giá trị nil nào như vậy là kết thúc của

Thứ tự ưu tiên của toán tử trong Lua tuân theo bảng bên dưới, từ mức ưu tiên thấp hơn đến cao hơn

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
72

Như thường lệ, bạn có thể sử dụng dấu ngoặc đơn để thay đổi thứ tự ưu tiên của một biểu thức. Toán tử nối ('

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
766') và lũy thừa ('
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
751') là phép kết hợp đúng. Tất cả các toán tử nhị phân khác được để lại kết hợp

Hàm tạo bảng là các biểu thức tạo bảng. Mỗi khi một hàm tạo được đánh giá, một bảng mới sẽ được tạo. Một hàm tạo có thể được sử dụng để tạo một bảng trống hoặc để tạo một bảng và khởi tạo một số trường của nó. Cú pháp chung cho các hàm tạo là

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
73

Mỗi trường của biểu mẫu

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
779 thêm vào bảng mới một mục có khóa
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
780 và giá trị
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
781. Một trường có dạng ________ 2782 tương đương với ________ 2783. Cuối cùng, các trường có dạng
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
784 tương đương với
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
785, trong đó
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
715 là các số nguyên liên tiếp, bắt đầu bằng 1. Các trường ở các định dạng khác không ảnh hưởng đến việc đếm này. Ví dụ,

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
74

tương đương với

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
75

Nếu trường cuối cùng trong danh sách có dạng

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
784 và biểu thức là một lệnh gọi hàm hoặc biểu thức vararg, thì tất cả các giá trị do biểu thức này trả về sẽ liên tiếp vào danh sách (xem §2. 5. số 8). Để tránh điều này, hãy đặt lệnh gọi hàm hoặc biểu thức vararg trong ngoặc đơn (xem §2. 5)

Danh sách trường có thể có dấu phân tách ở cuối tùy chọn, để thuận tiện cho mã do máy tạo

Một lời gọi hàm trong Lua có cú pháp như sau

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
76

Trong một lệnh gọi hàm, tiền tố đầu tiên và args được đánh giá. Nếu giá trị của prefixexp có kiểu hàm, thì hàm này được gọi với các đối số đã cho. Mặt khác, siêu phương thức "gọi" prefixexp được gọi, có tham số đầu tiên là giá trị của prefixexp, theo sau là các đối số gọi ban đầu (xem §2. số 8)

Hình thức

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
77

có thể được sử dụng để gọi "phương thức". Cuộc gọi

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
788 là đường cú pháp cho
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
789, ngoại trừ việc
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
734 chỉ được đánh giá một lần

Các đối số có cú pháp sau

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
78

Tất cả các biểu thức đối số được đánh giá trước cuộc gọi. Một lệnh gọi có dạng

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
791 là đường cú pháp cho
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
792; . Một lệnh gọi có dạng
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
793 (hoặc
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
794 hoặc
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
795) là đường cú pháp cho
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
796;

Là một ngoại lệ đối với cú pháp định dạng tự do của Lua, bạn không thể đặt dấu ngắt dòng trước '

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
797' trong lệnh gọi hàm. Hạn chế này tránh một số sự mơ hồ trong ngôn ngữ. Nếu bạn viết

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
79

Lua sẽ coi đó là một câu lệnh duy nhất,

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
798. Vì vậy, nếu bạn muốn có hai câu lệnh, bạn phải thêm dấu chấm phẩy giữa chúng. Nếu bạn thực sự muốn gọi
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742, bạn phải xóa ngắt dòng trước
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
700

Một lời gọi hàm có dạng ________ 3701 lời gọi hàm được gọi là một lời gọi đuôi. Lua thực hiện các cuộc gọi đuôi thích hợp (hoặc đệ quy đuôi thích hợp). trong một cuộc gọi đuôi, chức năng được gọi sử dụng lại mục ngăn xếp của chức năng gọi. Do đó, không có giới hạn về số lần gọi đuôi lồng nhau mà một chương trình có thể thực hiện. Tuy nhiên, một cuộc gọi đuôi sẽ xóa mọi thông tin gỡ lỗi về chức năng gọi. Lưu ý rằng lệnh gọi đuôi chỉ xảy ra với một cú pháp cụ thể, trong đó lệnh trả về có một lệnh gọi hàm duy nhất làm đối số; . Vì vậy, không có ví dụ nào sau đây là các cuộc gọi đuôi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
70

Cú pháp định nghĩa hàm là

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
71

Đường cú pháp sau đây đơn giản hóa các định nghĩa hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
72

tuyên bố

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
73

Dịch sang

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
74

tuyên bố

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
75

Dịch sang

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
76

tuyên bố

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
77

Dịch sang

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
78

không

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
79

(Điều này chỉ tạo ra sự khác biệt khi phần thân của hàm chứa các tham chiếu đến

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742. )

Một định nghĩa hàm là một biểu thức thực thi, có giá trị có kiểu hàm. Khi Lua biên dịch trước một đoạn, tất cả các thân hàm của nó cũng được biên dịch trước. Sau đó, bất cứ khi nào Lua thực thi định nghĩa hàm, hàm đó sẽ được khởi tạo (hoặc đóng). Thể hiện hàm này (hoặc bao đóng) là giá trị cuối cùng của biểu thức. Các phiên bản khác nhau của cùng một chức năng có thể tham chiếu đến các biến cục bộ bên ngoài khác nhau và có thể có các bảng môi trường khác nhau

Các tham số hoạt động như các biến cục bộ được khởi tạo với các giá trị đối số

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
80

Khi một hàm được gọi, danh sách các đối số được điều chỉnh theo độ dài của danh sách các tham số, trừ khi hàm đó là một hàm biến thiên hoặc biến đổi, được biểu thị bằng ba dấu chấm ('

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
740') ở cuối danh sách tham số của nó. Hàm vararg không điều chỉnh danh sách đối số của nó; . Giá trị của biểu thức này là danh sách tất cả các đối số phụ thực tế, tương tự như một hàm có nhiều kết quả. Nếu một biểu thức vararg được sử dụng bên trong một biểu thức khác hoặc ở giữa danh sách các biểu thức, thì danh sách trả về của nó được điều chỉnh thành một phần tử. Nếu biểu thức được sử dụng làm thành phần cuối cùng của danh sách các biểu thức, thì không có điều chỉnh nào được thực hiện (trừ khi biểu thức cuối cùng đó được đặt trong ngoặc đơn)

Ví dụ, hãy xem xét các định nghĩa sau

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
81

Sau đó, chúng ta có ánh xạ sau từ đối số đến tham số và biểu thức vararg

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
82

Kết quả được trả về bằng câu lệnh return (xem §2. 4. 4). Nếu điều khiển đến cuối hàm mà không gặp câu lệnh trả về, thì hàm đó sẽ trả về mà không có kết quả

Cú pháp dấu hai chấm được sử dụng để xác định các phương thức, nghĩa là các hàm có tham số phụ ngầm định

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
704. Như vậy, tuyên bố

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
83

là đường cú pháp cho

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
84

Lua là một ngôn ngữ có phạm vi từ vựng. Phạm vi của các biến bắt đầu từ câu lệnh đầu tiên sau phần khai báo của chúng và kéo dài cho đến hết khối trong cùng chứa phần khai báo. Xem xét ví dụ sau

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
85

Lưu ý rằng, trong một khai báo như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
705, biến
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 mới được khai báo chưa nằm trong phạm vi, và vì vậy, biến
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 thứ hai đề cập đến biến bên ngoài

Do các quy tắc phạm vi từ vựng, các biến cục bộ có thể được truy cập tự do bởi các hàm được xác định bên trong phạm vi của chúng. Biến cục bộ được sử dụng bởi hàm bên trong được gọi là giá trị tăng hoặc biến cục bộ bên ngoài, bên trong hàm bên trong

Lưu ý rằng mỗi lần thực thi câu lệnh cục bộ sẽ xác định các biến cục bộ mới. Xem xét ví dụ sau

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
86

Vòng lặp tạo ra mười bao đóng (nghĩa là mười trường hợp của hàm ẩn danh). Mỗi lần đóng này sử dụng một biến

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
718 khác nhau, trong khi tất cả chúng đều có chung một biến
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706

Vì Lua là một ngôn ngữ tiện ích được nhúng, nên tất cả các hành động của Lua đều bắt đầu từ mã C trong chương trình máy chủ gọi một hàm từ thư viện Lua (xem

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
710). Bất cứ khi nào xảy ra lỗi trong quá trình biên dịch hoặc thực thi Lua, quyền điều khiển sẽ trở về C, có thể thực hiện các biện pháp thích hợp (chẳng hạn như in thông báo lỗi)

Mã Lua rõ ràng có thể tạo ra lỗi bằng cách gọi hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
711. Nếu bạn cần bắt lỗi trong Lua, bạn có thể sử dụng hàm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
712

Mỗi giá trị trong Lua có thể có một metatable. Bảng siêu dữ liệu này là một bảng Lua thông thường xác định hành vi của giá trị ban đầu trong các thao tác đặc biệt nhất định. Bạn có thể thay đổi một số khía cạnh của hành vi hoạt động đối với một giá trị bằng cách đặt các trường cụ thể trong khả năng thay đổi của nó. Chẳng hạn, khi một giá trị không phải là số là toán hạng của một phép cộng, Lua sẽ kiểm tra một hàm trong trường

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
713 trong bảng siêu dữ liệu của nó. Nếu tìm thấy, Lua gọi hàm này để thực hiện phép cộng

Chúng tôi gọi các khóa trong một sự kiện có thể thay đổi và các giá trị siêu dữ liệu. Trong ví dụ trước, sự kiện là

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
714 và metamethod là hàm thực hiện phép cộng

Bạn có thể truy vấn metatable của bất kỳ giá trị nào thông qua hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
715

Bạn có thể thay thế metatable của các bảng thông qua hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
716. Bạn không thể thay đổi siêu dữ liệu của các loại khác từ Lua (ngoại trừ bằng cách sử dụng thư viện gỡ lỗi);

Các bảng và dữ liệu người dùng đầy đủ có các bảng siêu dữ liệu riêng lẻ (mặc dù nhiều bảng và dữ liệu người dùng có thể chia sẻ các bảng siêu dữ liệu của chúng). Giá trị của tất cả các loại khác chia sẻ một siêu dữ liệu duy nhất cho mỗi loại;

Một metatable kiểm soát cách một đối tượng hoạt động trong các phép toán số học, so sánh thứ tự, nối, thao tác độ dài và lập chỉ mục. Một metatable cũng có thể xác định một chức năng sẽ được gọi khi dữ liệu người dùng được thu thập rác. Đối với mỗi hoạt động này, Lua liên kết một khóa cụ thể được gọi là sự kiện. Khi Lua thực hiện một trong những thao tác này trên một giá trị, nó sẽ kiểm tra xem giá trị này có khả năng thay đổi giá trị với sự kiện tương ứng hay không. Nếu vậy, giá trị được liên kết với khóa đó (siêu phương thức) kiểm soát cách Lua sẽ thực hiện thao tác

Metatables kiểm soát các hoạt động được liệt kê tiếp theo. Mỗi hoạt động được xác định bởi tên tương ứng của nó. Chìa khóa cho mỗi thao tác là một chuỗi có tên bắt đầu bằng hai dấu gạch dưới, '

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
717'; . Ngữ nghĩa của các thao tác này được giải thích rõ hơn bằng hàm Lua mô tả cách trình thông dịch thực hiện thao tác

Mã hiển thị ở đây trong Lua chỉ mang tính minh họa; . Tất cả các chức năng được sử dụng trong các mô tả này (______3719,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
720, v.v. ) được mô tả trong §5. 1. Đặc biệt, để truy xuất siêu phương thức của một đối tượng nhất định, chúng ta sử dụng biểu thức

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
87

Điều này nên được đọc như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
88

Nghĩa là, quyền truy cập vào một siêu phương thức không gọi các siêu phương thức khác và quyền truy cập vào các đối tượng không có siêu dữ liệu không bị lỗi (nó chỉ đơn giản dẫn đến con số không)

  • "cộng". hoạt động của
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    746

    Hàm

         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    722 bên dưới xác định cách Lua chọn trình xử lý cho thao tác nhị phân. Đầu tiên, Lua thử toán hạng đầu tiên. Nếu kiểu của nó không xác định trình xử lý cho thao tác, thì Lua sẽ thử toán hạng thứ hai

         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    89

    Bằng cách sử dụng chức năng này, hành vi của

         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    723 là

         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    40
  • "phụ". hoạt động của
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    747. Hành vi tương tự như thao tác "thêm"
  • "mụ". hoạt động của
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    748. Hành vi tương tự như thao tác "thêm"
  • "div". hoạt động của
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    749. Hành vi tương tự như thao tác "thêm"
  • "chế độ". hoạt động của
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    750. Hành vi tương tự như thao tác "thêm", với thao tác
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    728 là thao tác nguyên thủy
  • "phập". phép toán
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    751 (lũy thừa). Hành vi tương tự như thao tác "thêm", với hàm
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    730 (từ thư viện C math) là thao tác nguyên thủy
  • "ừm". phép toán
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    747 đơn nguyên.
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    41
  • "concat". hoạt động
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    766 (nối).
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    42
  • "len". hoạt động của
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    767.
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    43

    Xem §2. 5. 5 để biết mô tả về chiều dài của bàn

  • "eq". hoạt động của
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    755. Hàm
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    735 định nghĩa cách Lua chọn siêu phương thức cho các toán tử so sánh. Một siêu phương thức chỉ được chọn khi cả hai đối tượng được so sánh có cùng loại và cùng một siêu phương thức cho thao tác đã chọn.
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    44

    Sự kiện "eq" được định nghĩa như sau

         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    45

         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    736 tương đương với
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    737

  • "nó". hoạt động của
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    738.
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    46

         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    761 tương đương với
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    762

  • "le". hoạt động của
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    741.
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    47

         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    763 tương đương với
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    764. Lưu ý rằng, trong trường hợp không có siêu phương thức "le", Lua sẽ thử "lt", giả sử rằng
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    744 tương đương với
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    745

  • "mục lục". Truy cập lập chỉ mục
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    746.
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    48
  • "chỉ mục mới". Nhiệm vụ lập chỉ mục
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    747.
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    49
  • "cuộc gọi". được gọi khi Lua gọi một giá trị.
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    90

Bên cạnh các metatable, các đối tượng kiểu luồng, hàm và dữ liệu người dùng có một bảng khác được liên kết với chúng, được gọi là môi trường của chúng. Giống như metatables, môi trường là các bảng thông thường và nhiều đối tượng có thể chia sẻ cùng một môi trường

Chủ đề được tạo chia sẻ môi trường của chủ đề tạo. Dữ liệu người dùng và hàm C được tạo chia sẻ môi trường của hàm C tạo. Các hàm Lua không lồng nhau (được tạo bởi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
748,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
749 hoặc
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
750) được tạo chia sẻ môi trường của chuỗi tạo. Các hàm Lua lồng nhau được tạo chia sẻ môi trường của hàm Lua đang tạo

Các môi trường liên kết với dữ liệu người dùng không có ý nghĩa gì đối với Lua. Nó chỉ là một tính năng thuận tiện cho các lập trình viên để liên kết một bảng với dữ liệu người dùng

Môi trường liên quan đến luồng được gọi là môi trường toàn cầu. Chúng được sử dụng làm môi trường mặc định cho các luồng và các hàm Lua không lồng nhau được tạo bởi luồng và có thể được truy cập trực tiếp bằng mã C (xem §3. 3)

Môi trường được liên kết với hàm C có thể được truy cập trực tiếp bằng mã C (xem §3. 3). Nó được sử dụng làm môi trường mặc định cho các hàm C khác và dữ liệu người dùng do hàm tạo

Các môi trường liên kết với các hàm Lua được sử dụng để giải quyết tất cả các truy cập đến các biến toàn cục bên trong hàm (xem §2. 3). Chúng được sử dụng làm môi trường mặc định cho các hàm Lua lồng nhau được tạo bởi hàm

Bạn có thể thay đổi môi trường của hàm Lua hoặc chuỗi đang chạy bằng cách gọi ____

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
705. Bạn có thể lấy môi trường của một hàm Lua hoặc luồng đang chạy bằng cách gọi _
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
704. Để thao tác với môi trường của các đối tượng khác (dữ liệu người dùng, hàm C, các luồng khác), bạn phải sử dụng API C

Lua thực hiện quản lý bộ nhớ tự động. Điều này có nghĩa là bạn không phải lo lắng về việc phân bổ bộ nhớ cho các đối tượng mới hay giải phóng nó khi các đối tượng không còn cần thiết nữa. Lua tự động quản lý bộ nhớ bằng cách thỉnh thoảng chạy trình thu gom rác để thu thập tất cả các đối tượng đã chết (nghĩa là các đối tượng không còn có thể truy cập được từ Lua). Tất cả bộ nhớ được Lua sử dụng đều được quản lý tự động. bảng, dữ liệu người dùng, chức năng, chủ đề, chuỗi, v.v.

Lua triển khai bộ sưu tập đánh dấu và quét gia tăng. Nó sử dụng hai số để kiểm soát chu kỳ thu gom rác của nó. tạm dừng trình thu gom rác và hệ số nhân bước thu gom rác. Cả hai đều sử dụng điểm phần trăm làm đơn vị (để giá trị 100 có nghĩa là giá trị bên trong là 1)

Việc tạm dừng bộ thu gom rác kiểm soát khoảng thời gian bộ thu gom đợi trước khi bắt đầu một chu kỳ mới. Giá trị lớn hơn làm cho bộ sưu tập ít tích cực hơn. Các giá trị nhỏ hơn 100 có nghĩa là bộ thu sẽ không đợi để bắt đầu một chu kỳ mới. Giá trị 200 có nghĩa là bộ thu đợi tổng bộ nhớ đang sử dụng tăng gấp đôi trước khi bắt đầu một chu kỳ mới

Hệ số bước kiểm soát tốc độ tương đối của bộ thu so với cấp phát bộ nhớ. Các giá trị lớn hơn làm cho bộ thu tích cực hơn nhưng cũng tăng kích thước của từng bước gia tăng. Các giá trị nhỏ hơn 100 làm cho bộ thu quá chậm và có thể dẫn đến việc bộ thu không bao giờ kết thúc một chu kỳ. Giá trị mặc định, 200, có nghĩa là bộ sưu tập chạy với tốc độ cấp phát bộ nhớ "gấp đôi"

Bạn có thể thay đổi những số này bằng cách gọi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
753 bằng C hoặc
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
754 bằng Lua. Với các chức năng này, bạn cũng có thể điều khiển trực tiếp bộ thu (e. g. , dừng và khởi động lại nó)

Sử dụng C API, bạn có thể đặt siêu phương thức thu gom rác cho dữ liệu người dùng (xem §2. số 8). Các metamethods này còn được gọi là finalizers. Bộ hoàn thiện cho phép bạn phối hợp bộ sưu tập rác của Lua với quản lý tài nguyên bên ngoài (chẳng hạn như đóng tệp, kết nối mạng hoặc cơ sở dữ liệu hoặc giải phóng bộ nhớ của riêng bạn)

Dữ liệu người dùng rác có trường

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
755 trong bảng siêu dữ liệu của họ không được bộ thu gom rác thu thập ngay lập tức. Thay vào đó, Lua đặt chúng trong một danh sách. Sau khi thu thập, Lua thực hiện tương đương với chức năng sau cho mỗi dữ liệu người dùng trong danh sách đó

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
91

Vào cuối mỗi chu kỳ thu gom rác, các bộ hoàn thiện cho dữ liệu người dùng được gọi theo thứ tự ngược với quá trình tạo của chúng, trong số những bộ được thu thập trong chu kỳ đó. Nghĩa là, bộ hoàn thiện đầu tiên được gọi là bộ được liên kết với dữ liệu người dùng được tạo lần cuối trong chương trình. Bản thân dữ liệu người dùng chỉ được giải phóng trong chu kỳ thu gom rác tiếp theo

Bảng yếu là bảng có các phần tử là tham chiếu yếu. Một tài liệu tham khảo yếu bị bỏ qua bởi bộ thu gom rác. Nói cách khác, nếu các tham chiếu duy nhất đến một đối tượng là các tham chiếu yếu, thì trình thu gom rác sẽ thu thập đối tượng này

Một bảng yếu có thể có khóa yếu, giá trị yếu hoặc cả hai. Một bảng có các khóa yếu cho phép thu thập các khóa của nó, nhưng ngăn chặn việc thu thập các giá trị của nó. Một bảng có cả khóa yếu và giá trị yếu cho phép thu thập cả khóa và giá trị. Trong mọi trường hợp, nếu khóa hoặc giá trị được thu thập, toàn bộ cặp sẽ bị xóa khỏi bảng. Điểm yếu của một bảng được kiểm soát bởi trường

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
756 của metatable của nó. Nếu trường
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
756 là một chuỗi chứa ký tự '
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
758', thì các khóa trong bảng yếu. Nếu
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
756 chứa '
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
734', các giá trị trong bảng yếu

Sau khi bạn sử dụng bảng làm bảng siêu dữ liệu, bạn không nên thay đổi giá trị của trường

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
756 của bảng đó. Mặt khác, hành vi yếu của các bảng được kiểm soát bởi siêu dữ liệu này là không xác định

Lua hỗ trợ coroutines, còn được gọi là đa luồng hợp tác. Một coroutine trong Lua đại diện cho một luồng thực thi độc lập. Tuy nhiên, không giống như các luồng trong các hệ thống đa luồng, một coroutine chỉ tạm dừng việc thực thi của nó bằng cách gọi rõ ràng một hàm năng suất

Bạn tạo một coroutine với lệnh gọi tới

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
762. Đối số duy nhất của nó là một chức năng là chức năng chính của coroutine. Hàm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
763 chỉ tạo một coroutine mới và trả về một handle cho nó (một đối tượng kiểu thread);

Khi bạn gọi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
764 lần đầu tiên, chuyển đối số đầu tiên của nó là một luồng được trả về bởi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
762, coroutine bắt đầu thực thi, tại dòng đầu tiên của chức năng chính của nó. Các đối số bổ sung được chuyển đến
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
764 được chuyển đến chức năng chính của coroutine. Sau khi coroutine bắt đầu chạy, nó sẽ chạy cho đến khi nó kết thúc hoặc mang lại

Một coroutine có thể chấm dứt thực thi của nó theo hai cách. thông thường, khi chức năng chính của nó trả về (rõ ràng hoặc ngầm định, sau lệnh cuối cùng); . Trong trường hợp đầu tiên,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
764 trả về true, cộng với bất kỳ giá trị nào được trả về bởi hàm main coroutine. Trong trường hợp có lỗi,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
764 trả về false cộng với thông báo lỗi

Một coroutine mang lại lợi nhuận bằng cách gọi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
769. Khi một coroutine có kết quả, thì giá trị tương ứng của
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
764 sẽ trả về ngay lập tức, ngay cả khi kết quả xảy ra bên trong các lệnh gọi hàm lồng nhau (nghĩa là không phải trong hàm chính, mà trong một hàm được gọi trực tiếp hoặc gián tiếp bởi hàm chính). Trong trường hợp lợi nhuận,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
764 cũng trả về true, cộng với bất kỳ giá trị nào được chuyển đến
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
769. Lần tới khi bạn tiếp tục lại quy trình tương tự, nó sẽ tiếp tục thực thi từ điểm mà nó mang lại, với lời gọi tới ____3769 trả về bất kỳ đối số bổ sung nào được chuyển tới ____3764

Giống như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
762, hàm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
776 cũng tạo một coroutine, nhưng thay vì trả về chính coroutine, nó trả về một hàm mà khi được gọi, sẽ tiếp tục coroutine. Mọi đối số được truyền cho hàm này sẽ trở thành đối số phụ cho
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
764.
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
776 trả về tất cả các giá trị được trả về bởi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
764, ngoại trừ giá trị đầu tiên (mã lỗi boolean). Không giống như
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
764,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
776 không bắt lỗi;

Như một ví dụ, hãy xem xét đoạn mã sau

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
92

Khi bạn chạy nó, nó tạo ra đầu ra sau

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
93

Phần này mô tả C API cho Lua, tức là tập hợp các hàm C có sẵn cho chương trình máy chủ để giao tiếp với Lua. Tất cả các hàm API, các loại và hằng số liên quan được khai báo trong tệp tiêu đề

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
782

Ngay cả khi chúng tôi sử dụng thuật ngữ "chức năng", bất kỳ cơ sở nào trong API có thể được cung cấp dưới dạng macro thay thế. Tất cả các macro như vậy sử dụng mỗi đối số của chúng đúng một lần (ngoại trừ đối số đầu tiên, luôn ở trạng thái Lua) và do đó không tạo ra bất kỳ tác dụng phụ ẩn nào

Như trong hầu hết các thư viện C, các hàm Lua API không kiểm tra đối số của chúng về tính hợp lệ hoặc nhất quán. Tuy nhiên, bạn có thể thay đổi hành vi này bằng cách biên dịch Lua với định nghĩa thích hợp cho macro

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
783, trong tệp
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
92

Lua sử dụng ngăn xếp ảo để chuyển các giá trị đến và từ C. Mỗi phần tử trong ngăn xếp này đại diện cho một giá trị Lua (không, số, chuỗi, v.v. )

Bất cứ khi nào Lua gọi C, hàm được gọi sẽ nhận một ngăn xếp mới, độc lập với các ngăn xếp trước đó và ngăn xếp của các hàm C vẫn đang hoạt động. Ngăn xếp này ban đầu chứa bất kỳ đối số nào đối với hàm C và đó là nơi hàm C đẩy kết quả của nó để trả về trình gọi (xem

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
785)

Để thuận tiện, hầu hết các hoạt động truy vấn trong API không tuân theo kỷ luật ngăn xếp nghiêm ngặt. Thay vào đó, chúng có thể tham chiếu đến bất kỳ phần tử nào trong ngăn xếp bằng cách sử dụng chỉ mục. Chỉ mục dương biểu thị vị trí ngăn xếp tuyệt đối (bắt đầu từ 1); . Cụ thể hơn, nếu ngăn xếp có n phần tử, thì chỉ mục 1 đại diện cho phần tử đầu tiên (nghĩa là phần tử được đẩy lên ngăn xếp trước) và chỉ mục n đại diện cho phần tử cuối cùng; . Chúng tôi nói rằng một chỉ mục hợp lệ nếu nó nằm giữa 1 và đỉnh ngăn xếp (nghĩa là nếu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
786)

Khi tương tác với Lua API, bạn chịu trách nhiệm đảm bảo tính nhất quán. Cụ thể, bạn chịu trách nhiệm kiểm soát tràn ngăn xếp. Bạn có thể sử dụng hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
787 để tăng kích thước ngăn xếp

Bất cứ khi nào Lua gọi C, nó đảm bảo rằng có ít nhất

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
788 vị trí ngăn xếp.
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
788 được định nghĩa là 20, do đó thông thường bạn không phải lo lắng về dung lượng ngăn xếp trừ khi mã của bạn có vòng lặp đẩy các phần tử vào ngăn xếp

Hầu hết các hàm truy vấn chấp nhận bất kỳ giá trị nào bên trong không gian ngăn xếp có sẵn dưới dạng chỉ mục, nghĩa là chỉ mục lên đến kích thước ngăn xếp tối đa mà bạn đã đặt thông qua

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
787. Các chỉ số như vậy được gọi là chỉ số chấp nhận được. Chính thức hơn, chúng tôi xác định một chỉ số chấp nhận được như sau

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
94

Lưu ý rằng 0 không bao giờ là chỉ số được chấp nhận

Trừ khi có ghi chú khác, bất kỳ chức năng nào chấp nhận chỉ số hợp lệ cũng có thể được gọi bằng chỉ số giả, đại diện cho một số giá trị Lua mà mã C có thể truy cập được nhưng không có trong ngăn xếp. Chỉ số giả được sử dụng để truy cập vào môi trường luồng, môi trường hàm, sổ đăng ký và giá trị tăng của hàm C (xem §3. 4)

Môi trường luồng (nơi các biến toàn cục hoạt động) luôn ở chỉ số giả

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
791. Môi trường của hàm C đang chạy luôn ở pseudo-index
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
792

Để truy cập và thay đổi giá trị của các biến toàn cục, bạn có thể sử dụng các thao tác bảng thông thường trên bảng môi trường. Chẳng hạn, để truy cập giá trị của một biến toàn cục, hãy làm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
95

Khi một hàm C được tạo, có thể liên kết một số giá trị với hàm đó, do đó tạo ra một bao đóng C;

Bất cứ khi nào một hàm C được gọi, các giá trị tăng của nó được đặt tại các chỉ số giả cụ thể. Các chỉ số giả này được tạo bởi macro

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
794. Giá trị đầu tiên được liên kết với một hàm là ở vị trí
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
795, v.v. Bất kỳ quyền truy cập nào vào
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
796, trong đó n lớn hơn số lượng giá trị tăng của hàm hiện tại (nhưng không lớn hơn 256), sẽ tạo ra một chỉ mục có thể chấp nhận được (nhưng không hợp lệ)

Lua cung cấp sổ đăng ký, một bảng được xác định trước có thể được sử dụng bởi bất kỳ mã C nào để lưu trữ bất kỳ giá trị Lua nào mà nó cần lưu trữ. Bảng này luôn nằm ở pseudo-index

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
797. Bất kỳ thư viện C nào cũng có thể lưu trữ dữ liệu vào bảng này, nhưng bạn nên cẩn thận chọn các khóa khác với các khóa được các thư viện khác sử dụng để tránh xung đột. Thông thường, bạn nên sử dụng chuỗi chứa tên thư viện của mình hoặc dữ liệu người dùng nhẹ với địa chỉ của đối tượng C trong mã của bạn làm khóa

Các khóa số nguyên trong sổ đăng ký được sử dụng bởi cơ chế tham chiếu, được triển khai bởi thư viện phụ trợ và do đó không được sử dụng cho các mục đích khác

Trong nội bộ, Lua sử dụng cơ sở C

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
798 để xử lý lỗi. (Bạn cũng có thể chọn sử dụng ngoại lệ nếu bạn sử dụng C++; xem tệp
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
92. ) Khi Lua gặp bất kỳ lỗi nào (chẳng hạn như lỗi cấp phát bộ nhớ, lỗi loại, lỗi cú pháp và lỗi thời gian chạy), nó sẽ báo lỗi; . Môi trường được bảo vệ sử dụng ________ 3800 để đặt điểm khôi phục;

Hầu hết các chức năng trong API có thể gây ra lỗi, chẳng hạn như do lỗi cấp phát bộ nhớ. Tài liệu cho từng chức năng cho biết liệu nó có thể gây ra lỗi hay không

Bên trong hàm C, bạn có thể đưa ra lỗi bằng cách gọi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
801

Ở đây chúng tôi liệt kê tất cả các chức năng và loại từ C API theo thứ tự bảng chữ cái. Mỗi chức năng có một chỉ số như thế này. [-o, +p, x]

Trường đầu tiên,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
802, là số lượng phần tử mà hàm bật ra khỏi ngăn xếp. Trường thứ hai,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
803, là số lượng phần tử mà hàm đẩy vào ngăn xếp. (Bất kỳ chức năng nào cũng luôn đẩy kết quả của nó sau khi bật đối số của nó. ) Một trường ở dạng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
804 có nghĩa là hàm có thể đẩy (hoặc bật) các phần tử
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 hoặc
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
718, tùy thuộc vào tình huống; . g. , chúng có thể phụ thuộc vào những gì có trong ngăn xếp). Trường thứ ba,
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706, cho biết liệu hàm có thể đưa ra lỗi hay không. '______2747' có nghĩa là hàm không bao giờ đưa ra bất kỳ lỗi nào;


     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
96

Loại chức năng cấp phát bộ nhớ được sử dụng bởi trạng thái Lua. Hàm cấp phát phải cung cấp chức năng tương tự như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
813, nhưng không hoàn toàn giống. Các đối số của nó là
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
814, một con trỏ mờ được truyền tới
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
815; .
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
816 là
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820 khi và chỉ khi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
817 bằng 0. Khi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
818 bằng 0, bộ cấp phát phải trả về
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820; . Khi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
818 khác 0, bộ cấp phát trả về
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820 khi và chỉ khi nó không thể đáp ứng yêu cầu. Khi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
818 không bằng 0 và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
817 bằng 0, bộ cấp phát sẽ hoạt động như
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
830. Khi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
818 và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
817 khác không, bộ cấp phát hoạt động như
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
813. Lua giả định rằng bộ cấp phát không bao giờ lỗi khi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
834

Đây là một triển khai đơn giản cho chức năng cấp phát. Nó được sử dụng trong thư viện phụ trợ bởi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
835

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
97

Mã này giả định rằng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
836 không có hiệu lực và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
837 tương đương với
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
838. ANSI C đảm bảo cả hai hành vi


[-0, +0, -]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
98

Đặt chức năng hoảng loạn mới và trả về chức năng cũ

Nếu một lỗi xảy ra bên ngoài bất kỳ môi trường được bảo vệ nào, Lua sẽ gọi một hàm hoảng loạn và sau đó gọi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
839, do đó thoát khỏi ứng dụng máy chủ. Chức năng hoảng loạn của bạn có thể tránh lối thoát này bằng cách không bao giờ quay lại (e. g. , nhảy xa)

Chức năng hoảng loạn có thể truy cập thông báo lỗi ở đầu ngăn xếp


[-(nargs + 1), +nresults, e]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
99

Gọi một chức năng

Để gọi một chức năng, bạn phải sử dụng giao thức sau. đầu tiên, chức năng được gọi được đẩy lên ngăn xếp; . Cuối cùng, bạn gọi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
840; . Tất cả các đối số và giá trị hàm được bật ra khỏi ngăn xếp khi hàm được gọi. Kết quả hàm được đẩy lên ngăn xếp khi hàm trả về. Số lượng kết quả được điều chỉnh thành
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
842, trừ khi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
842 là
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
844. Trong trường hợp này, tất cả các kết quả từ chức năng được đẩy. Lua đảm bảo rằng các giá trị được trả về phù hợp với không gian ngăn xếp. Các kết quả của hàm được đẩy vào ngăn xếp theo thứ tự trực tiếp (kết quả đầu tiên được đẩy lên trước), để sau khi gọi, kết quả cuối cùng sẽ ở trên cùng của ngăn xếp

Bất kỳ lỗi nào bên trong hàm được gọi đều được lan truyền lên trên (với

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
798)

Ví dụ sau đây cho thấy chương trình chủ có thể thực hiện tương đương với mã Lua này như thế nào

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
30

Nó ở đây trong C

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
31

Lưu ý rằng đoạn mã trên là "cân bằng". khi kết thúc, ngăn xếp trở lại cấu hình ban đầu. Đây được coi là thực hành lập trình tốt


     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
32

Nhập cho hàm C

Để giao tiếp đúng cách với Lua, một hàm C phải sử dụng giao thức sau, giao thức này xác định cách truyền tham số và kết quả. một hàm C nhận các đối số của nó từ Lua trong ngăn xếp của nó theo thứ tự trực tiếp (đối số đầu tiên được đẩy trước). Vì vậy, khi hàm bắt đầu,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
846 trả về số lượng đối số mà hàm nhận được. Đối số đầu tiên (nếu có) nằm ở chỉ mục 1 và đối số cuối cùng của nó nằm ở chỉ số
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
846. Để trả về giá trị cho Lua, một hàm C chỉ cần đẩy chúng vào ngăn xếp, theo thứ tự trực tiếp (kết quả đầu tiên được đẩy trước) và trả về số lượng kết quả. Bất kỳ giá trị nào khác trong ngăn xếp bên dưới kết quả sẽ bị Lua loại bỏ đúng cách. Giống như hàm Lua, hàm C do Lua gọi cũng có thể trả về nhiều kết quả

Ví dụ: hàm sau nhận một số lượng đối số số khác nhau và trả về giá trị trung bình và tổng của chúng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
33

[-0, +0, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
34

Đảm bảo rằng có ít nhất

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
848 vị trí ngăn xếp miễn phí trong ngăn xếp. Nó trả về false nếu nó không thể phát triển ngăn xếp đến kích thước đó. Hàm này không bao giờ thu nhỏ ngăn xếp;


[-0, +0, -]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
35

Hủy tất cả các đối tượng trong trạng thái Lua nhất định (gọi siêu phương thức thu gom rác tương ứng, nếu có) và giải phóng tất cả bộ nhớ động được sử dụng bởi trạng thái này. Trên một số nền tảng, bạn có thể không cần gọi chức năng này, vì tất cả tài nguyên được giải phóng tự nhiên khi chương trình chủ kết thúc. Mặt khác, các chương trình chạy lâu, chẳng hạn như daemon hoặc máy chủ web, có thể cần giải phóng trạng thái ngay khi không cần thiết, để tránh phát triển quá lớn.


[-n, +1, e]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
36

Nối các giá trị

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 ở đầu ngăn xếp, bật chúng và để kết quả ở trên cùng. Nếu
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 là 1, thì kết quả là một giá trị duy nhất trên ngăn xếp (nghĩa là hàm không làm gì cả); . Phép nối được thực hiện theo ngữ nghĩa thông thường của Lua (xem §2. 5. 4)


[-0, +(0. 1), -]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
37

Gọi hàm C

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
852 ở chế độ được bảo vệ.
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
852 bắt đầu chỉ với một phần tử trong ngăn xếp của nó, một userdata nhẹ chứa
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
814. Trong trường hợp có lỗi,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
855 trả về các mã lỗi giống như
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
710, cộng với đối tượng lỗi ở trên cùng của ngăn xếp; . Tất cả các giá trị được trả về bởi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
852 đều bị loại bỏ


[-0, +1, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
38

Tạo một bảng trống mới và đẩy nó vào ngăn xếp. Bảng mới có không gian được phân bổ trước cho các phần tử mảng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
858 và phần tử không phải mảng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
859. Việc phân bổ trước này rất hữu ích khi bạn biết chính xác bảng sẽ có bao nhiêu phần tử. Nếu không, bạn có thể sử dụng chức năng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
860


[-0, +0, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
39

Kết xuất một hàm dưới dạng một đoạn nhị phân. Nhận một hàm Lua ở trên cùng của ngăn xếp và tạo ra một đoạn mã nhị phân, nếu được tải lại, sẽ dẫn đến một hàm tương đương với hàm đã đổ. Khi nó tạo ra các phần của khối,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
861 gọi hàm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
862 (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
863) với
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
864 đã cho để viết chúng

Giá trị được trả về là mã lỗi được trả về bởi lệnh gọi cuối cùng tới người viết;

Chức năng này không bật chức năng Lua từ ngăn xếp


[-0, +0, e]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
60

Trả về 1 nếu hai giá trị trong các chỉ số được chấp nhận là

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
865 và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
866 bằng nhau, tuân theo ngữ nghĩa của toán tử Lua
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
755 (nghĩa là có thể gọi siêu phương thức). Nếu không trả về 0. Cũng trả về 0 nếu bất kỳ chỉ số nào không hợp lệ


[-1, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
61

Tạo lỗi Lua. Thông báo lỗi (có thể thực sự là một giá trị Lua thuộc bất kỳ loại nào) phải nằm trên đỉnh ngăn xếp. Hàm này thực hiện một bước nhảy dài và do đó không bao giờ trả về. (xem

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
868)


[-0, +0, e]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
62

Điều khiển bộ thu gom rác

Hàm này thực hiện một số tác vụ, theo giá trị của tham số

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
869

  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    870. dừng bộ thu gom rác
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    871. khởi động lại bộ thu gom rác
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    872. thực hiện một chu kỳ thu gom rác đầy đủ
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    873. trả về dung lượng bộ nhớ hiện tại (tính bằng Kbyte) mà Lua đang sử dụng
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    874. trả về phần còn lại của việc chia số byte bộ nhớ hiện tại đang được Lua sử dụng cho 1024
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    875. thực hiện một bước tăng dần của việc thu gom rác. "Kích thước" bước được kiểm soát bởi
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    864 (giá trị lớn hơn có nghĩa là nhiều bước hơn) theo cách không được chỉ định. Nếu bạn muốn kiểm soát kích thước bước, bạn phải điều chỉnh bằng thực nghiệm giá trị của
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    864. Hàm trả về 1 nếu bước kết thúc chu trình thu gom rác
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    878. đặt
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    864 làm giá trị mới cho việc tạm dừng bộ thu (xem §2. 10). Hàm trả về giá trị tạm dừng trước đó
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    880. đặt
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    864 làm giá trị mới cho hệ số nhân bước của bộ thu (xem §2. 10). Hàm trả về giá trị trước đó của hệ số bậc thang

[-0, +0, -]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
63

Trả về chức năng cấp phát bộ nhớ của một trạng thái nhất định. Nếu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
814 không phải là
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820, Lua lưu trữ trong
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
884 con trỏ mờ được truyền tới
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
815


[-0, +1, -]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
64

Đẩy vào ngăn xếp bảng môi trường của giá trị tại chỉ mục đã cho


[-0, +1, e]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
65

Đẩy vào ngăn xếp giá trị

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
886, trong đó
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768 là giá trị tại chỉ mục hợp lệ đã cho. Như trong Lua, chức năng này có thể kích hoạt siêu phương thức cho sự kiện "chỉ mục" (xem §2. số 8)


[-0, +1, e]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
66

Đẩy vào ngăn xếp giá trị của

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
888 toàn cầu. Nó được định nghĩa là một macro

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
67

[-0, +(0. 1), -]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
68

Đẩy vào ngăn xếp giá trị có thể thay đổi được tại chỉ mục được chấp nhận. Nếu chỉ mục không hợp lệ hoặc nếu giá trị không có bảng chuyển đổi, hàm sẽ trả về 0 và không đẩy gì vào ngăn xếp


[-1, +1, e]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
69

Đẩy vào ngăn xếp giá trị

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
886, trong đó
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768 là giá trị tại chỉ mục hợp lệ đã cho và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
758 là giá trị ở đầu ngăn xếp

Hàm này bật khóa từ ngăn xếp (đặt giá trị kết quả vào vị trí của nó). Như trong Lua, chức năng này có thể kích hoạt siêu phương thức cho sự kiện "chỉ mục" (xem §2. số 8)


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
00

Trả về chỉ số của phần tử trên cùng trong ngăn xếp. Vì các chỉ số bắt đầu từ 1, nên kết quả này bằng với số phần tử trong ngăn xếp (và 0 có nghĩa là ngăn xếp trống)


[-1, +1, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
01

Di chuyển phần tử trên cùng vào chỉ mục hợp lệ đã cho, chuyển các phần tử phía trên chỉ mục này sang không gian mở. Không thể được gọi với chỉ mục giả, vì chỉ mục giả không phải là vị trí ngăn xếp thực tế


     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
02

Loại được API Lua sử dụng để biểu thị các giá trị tích phân

Theo mặc định, nó là

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
892, thường là loại tích phân có dấu lớn nhất mà máy xử lý "thoải mái"


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
03

Trả về 1 nếu giá trị tại chỉ mục được chấp nhận đã cho có kiểu boolean và 0 nếu không


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
04

Trả về 1 nếu giá trị tại chỉ mục được chấp nhận đã cho là một hàm C và 0 nếu không


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
05

Trả về 1 nếu giá trị tại chỉ mục được chấp nhận đã cho là một hàm (C hoặc Lua) và 0 nếu không


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
06

Trả về 1 nếu giá trị tại chỉ mục được chấp nhận đã cho là dữ liệu người dùng nhẹ và 0 nếu không


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
07

Trả về 1 nếu giá trị tại chỉ mục được chấp nhận đã cho là 0 và 0 nếu không


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
08

Trả về 1 nếu chỉ mục được chấp nhận đã cho không hợp lệ (nghĩa là nó đề cập đến một phần tử bên ngoài ngăn xếp hiện tại) và 0 nếu không


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
09

Trả về 1 nếu chỉ mục được chấp nhận đã cho không hợp lệ (nghĩa là nó đề cập đến một phần tử bên ngoài ngăn xếp hiện tại) hoặc nếu giá trị tại chỉ mục này là 0 và 0 nếu không


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
10

Trả về 1 nếu giá trị tại chỉ mục được chấp nhận đã cho là một số hoặc một chuỗi có thể chuyển đổi thành một số và 0 nếu không


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
11

Trả về 1 nếu giá trị tại chỉ mục được chấp nhận đã cho là một chuỗi hoặc một số (luôn có thể chuyển đổi thành chuỗi) và 0 nếu không


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
12

Trả về 1 nếu giá trị tại chỉ mục được chấp nhận đã cho là một bảng và 0 nếu không


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
13

Trả về 1 nếu giá trị tại chỉ mục được chấp nhận đã cho là một chuỗi và 0 nếu không


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
14

Trả về 1 nếu giá trị tại chỉ mục được chấp nhận đã cho là dữ liệu người dùng (đầy đủ hoặc nhẹ) và 0 nếu không


[-0, +0, e]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
15

Trả về 1 nếu giá trị tại chỉ số chấp nhận được

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
865 nhỏ hơn giá trị tại chỉ số chấp nhận được
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
866, tuân theo ngữ nghĩa của toán tử Lua
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
738 (nghĩa là có thể gọi siêu phương thức). Nếu không trả về 0. Cũng trả về 0 nếu bất kỳ chỉ số nào không hợp lệ


[-0, +1, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
16

Tải một đoạn Lua. Nếu không có lỗi,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
896 đẩy đoạn đã biên dịch dưới dạng hàm Lua lên trên cùng của ngăn xếp. Nếu không, nó đẩy một thông báo lỗi. Các giá trị trả về của
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
896 là

Chức năng này chỉ tải một đoạn;

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
896 tự động phát hiện xem đoạn đó là văn bản hay nhị phân và tải nó cho phù hợp (xem chương trình
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
712)

Hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
896 sử dụng hàm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
401 do người dùng cung cấp để đọc đoạn mã (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
402). Đối số
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
864 là một giá trị không rõ ràng được truyền cho hàm đọc

Đối số

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
404 đặt tên cho đoạn, được sử dụng cho các thông báo lỗi và thông tin gỡ lỗi (xem §3. số 8)


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
17

Tạo ra một quốc gia mới, độc lập. Trả về

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820 nếu không thể tạo trạng thái (do thiếu bộ nhớ). Đối số
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 là hàm cấp phát; . Đối số thứ hai,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
814, là một con trỏ không rõ ràng mà Lua chỉ cần chuyển đến bộ cấp phát trong mỗi lệnh gọi


[-0, +1, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
18

Tạo một bảng trống mới và đẩy nó vào ngăn xếp. Nó tương đương với

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
408


[-0, +1, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
19

Tạo một luồng mới, đẩy nó vào ngăn xếp và trả về một con trỏ tới

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
409 đại diện cho luồng mới này. Trạng thái mới được hàm này trả về chia sẻ với trạng thái ban đầu tất cả các đối tượng chung (chẳng hạn như bảng), nhưng có ngăn xếp thực thi độc lập

Không có chức năng rõ ràng để đóng hoặc hủy một luồng. Chủ đề có thể được thu gom rác, giống như bất kỳ đối tượng Lua nào


[-0, +1, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
20

Hàm này phân bổ một khối bộ nhớ mới với kích thước đã cho, đẩy vào ngăn xếp một dữ liệu người dùng đầy đủ mới với địa chỉ khối và trả về địa chỉ này

Dữ liệu người dùng đại diện cho các giá trị C trong Lua. Dữ liệu người dùng đầy đủ đại diện cho một khối bộ nhớ. Nó là một đối tượng (như một cái bàn). bạn phải tạo nó, nó có thể có metatable riêng và bạn có thể phát hiện khi nào nó đang được thu thập. Một dữ liệu người dùng đầy đủ chỉ bằng chính nó (dưới đẳng thức thô)

Khi Lua thu thập đầy đủ dữ liệu người dùng bằng siêu phương thức

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
410, Lua gọi siêu phương thức đó và đánh dấu dữ liệu người dùng là đã hoàn tất. Khi dữ liệu người dùng này được thu thập lại thì Lua sẽ giải phóng bộ nhớ tương ứng của nó


[-1, +(2. 0), e]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
21

Bật một khóa từ ngăn xếp và đẩy một cặp khóa-giá trị từ bảng tại chỉ mục đã cho (cặp "tiếp theo" sau khóa đã cho). Nếu không có thêm phần tử nào trong bảng, thì

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
411 trả về 0 (và không đẩy gì cả)

Một giao dịch điển hình trông như thế này

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
22

Trong khi duyệt qua một bảng, không gọi trực tiếp

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
412 trên một khóa, trừ khi bạn biết rằng khóa đó thực sự là một chuỗi. Nhớ lại rằng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
412 thay đổi giá trị tại chỉ mục đã cho;


     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
23

Các loại số trong Lua. Theo mặc định, nó là gấp đôi, nhưng có thể thay đổi trong

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
92

Thông qua tệp cấu hình, bạn có thể thay đổi Lua để hoạt động với kiểu khác cho số (e. g. , nổi hoặc dài)


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
24

Trả về "độ dài" của giá trị tại chỉ mục được chấp nhận đã cho. đối với chuỗi, đây là độ dài chuỗi;


[-(nargs + 1), +(nkết quả. 1), -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
25

Gọi một chức năng trong chế độ được bảo vệ

Cả

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
841 và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
842 đều có nghĩa giống như trong
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
840. Nếu không có lỗi trong khi gọi,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
710 hoạt động giống hệt như
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
840. Tuy nhiên, nếu có bất kỳ lỗi nào,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
710 sẽ bắt nó, đẩy một giá trị vào ngăn xếp (thông báo lỗi) và trả về mã lỗi. Giống như
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
840,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
710 luôn xóa hàm và đối số của nó khỏi ngăn xếp

Nếu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
425 là 0, thì thông báo lỗi được trả về trên ngăn xếp chính xác là thông báo lỗi ban đầu. Mặt khác,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
425 là chỉ số ngăn xếp của hàm xử lý lỗi. (Trong triển khai hiện tại, chỉ mục này không thể là chỉ mục giả. ) Trong trường hợp có lỗi thời gian chạy, chức năng này sẽ được gọi với thông báo lỗi và giá trị trả về của nó sẽ là thông báo được trả về trên ngăn xếp bởi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
710

Thông thường, chức năng xử lý lỗi được sử dụng để thêm thông tin gỡ lỗi vào thông báo lỗi, chẳng hạn như truy nguyên ngăn xếp. Những thông tin như vậy không thể được thu thập sau khi trả lại

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
710, vì sau đó ngăn xếp đã được gỡ bỏ

Hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
710 trả về 0 trong trường hợp thành công hoặc một trong các mã lỗi sau (được định nghĩa trong
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
782)

  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    431. một lỗi thời gian chạy
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    432. lỗi cấp phát bộ nhớ. Đối với những lỗi như vậy, Lua không gọi hàm xử lý lỗi
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    433. lỗi khi chạy chức năng xử lý lỗi

[-n, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
26

Pops

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 phần tử từ ngăn xếp


[-0, +1, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
27

Đẩy một giá trị boolean có giá trị

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
435 vào ngăn xếp


[-n, +1, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
28

Đẩy một C đóng mới vào ngăn xếp

Khi một hàm C được tạo, có thể liên kết một số giá trị với nó, do đó tạo ra một bao đóng C (xem §3. 4); . Để liên kết các giá trị với hàm C, trước tiên, các giá trị này phải được đẩy vào ngăn xếp (khi có nhiều giá trị, giá trị đầu tiên sẽ được đẩy trước). Sau đó,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
793 được gọi để tạo và đẩy hàm C vào ngăn xếp, với đối số
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 cho biết có bao nhiêu giá trị sẽ được liên kết với hàm.
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
793 cũng bật các giá trị này từ ngăn xếp

Giá trị tối đa cho

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 là 255


[-0, +1, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
29

Đẩy một hàm C vào ngăn xếp. Hàm này nhận một con trỏ tới một hàm C và đẩy vào ngăn xếp một giá trị Lua thuộc loại

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
440, khi được gọi, sẽ gọi hàm C tương ứng

Bất kỳ chức năng nào được đăng ký trong Lua đều phải tuân theo đúng giao thức để nhận các tham số và trả về kết quả của nó (xem

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
785)

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
442 được định nghĩa là macro

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
30

[-0, +1, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
31

Đẩy vào ngăn xếp một chuỗi đã định dạng và trả về một con trỏ tới chuỗi này. Nó tương tự như hàm C _______4443, nhưng có một số điểm khác biệt quan trọng

  • Bạn không phải phân bổ không gian cho kết quả. kết quả là một chuỗi Lua và Lua đảm nhiệm việc cấp phát bộ nhớ (và cấp phát, thông qua thu gom rác)
  • Các công cụ xác định chuyển đổi khá hạn chế. Không có cờ, chiều rộng hoặc độ chính xác. Các chỉ định chuyển đổi chỉ có thể là '
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    444' (chèn '
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    750' vào chuỗi), '
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    446' (chèn chuỗi có đầu cuối bằng 0, không có giới hạn về kích thước), '
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    447' (chèn
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    448), '
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    449' (

[-0, +1, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
32

Đẩy một số có giá trị

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 vào ngăn xếp


[-0, +1, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
33

Đẩy một dữ liệu người dùng nhẹ vào ngăn xếp

Dữ liệu người dùng đại diện cho các giá trị C trong Lua. Một userdata nhẹ đại diện cho một con trỏ. Đó là một giá trị (như một số). bạn không tạo nó, nó không có khả năng thay đổi riêng lẻ và nó không được thu thập (vì nó chưa bao giờ được tạo). Dữ liệu người dùng nhẹ bằng với dữ liệu người dùng nhẹ "bất kỳ" có cùng địa chỉ C


[-0, +1, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
34

Macro này tương đương với

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
455, nhưng chỉ có thể được sử dụng khi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 là một chuỗi ký tự. Trong những trường hợp này, nó sẽ tự động cung cấp độ dài chuỗi


[-0, +1, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
35

Đẩy chuỗi được trỏ tới bởi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 với kích thước
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
458 vào ngăn xếp. Lua tạo (hoặc sử dụng lại) một bản sao bên trong của chuỗi đã cho, vì vậy bộ nhớ tại
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 có thể được giải phóng hoặc sử dụng lại ngay sau khi hàm trả về. Chuỗi có thể chứa các số 0 được nhúng


[-0, +1, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
36

Đẩy một giá trị nil vào ngăn xếp


[-0, +1, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
37

Đẩy một số có giá trị

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 vào ngăn xếp


[-0, +1, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
38

Đẩy chuỗi kết thúc bằng 0 được chỉ ra bởi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 vào ngăn xếp. Lua tạo (hoặc sử dụng lại) một bản sao bên trong của chuỗi đã cho, vì vậy bộ nhớ tại
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 có thể được giải phóng hoặc sử dụng lại ngay sau khi hàm trả về. Chuỗi không được chứa các số 0 được nhúng;


[-0, +1, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
39

Đẩy chuỗi được đại diện bởi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
463 vào ngăn xếp. Trả về 1 nếu luồng này là luồng chính của trạng thái của nó


[-0, +1, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
40

Đẩy một bản sao của phần tử tại chỉ mục hợp lệ đã cho vào ngăn xếp


[-0, +1, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
41

Tương đương với

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
464, ngoại trừ việc nó nhận được một
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
465 thay vì một số đối số khác nhau


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
42

Trả về 1 nếu hai giá trị trong các chỉ số được chấp nhận là

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
865 và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
866 về cơ bản bằng nhau (nghĩa là không gọi siêu phương thức). Nếu không trả về 0. Cũng trả về 0 nếu bất kỳ chỉ số nào không hợp lệ


[-1, +1, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
43

Tương tự như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
468, nhưng có quyền truy cập thô (i. e. , không có siêu phương thức)


[-0, +1, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
44

Đẩy vào ngăn xếp giá trị

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
770, trong đó
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768 là giá trị tại chỉ mục hợp lệ đã cho. Quyền truy cập là thô;


[-2, +0, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
45

Tương tự như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
471, nhưng thực hiện phép gán thô (i. e. , không có siêu phương thức)


[-1, +0, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
46

Có tương đương với

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
472 không, trong đó
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768 là giá trị tại chỉ mục hợp lệ đã cho và
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
734 là giá trị ở đầu ngăn xếp

Hàm này bật giá trị từ ngăn xếp. Nhiệm vụ là thô;


     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
47

Chức năng đọc được sử dụng bởi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
896. Mỗi khi nó cần một đoạn khác,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
896 gọi trình đọc, truyền tham số
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
864 của nó. Người đọc phải trả về một con trỏ tới một khối bộ nhớ với một phần mới của đoạn và đặt
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
478 thành kích thước khối. Khối phải tồn tại cho đến khi chức năng đọc được gọi lại. Để báo hiệu sự kết thúc của đoạn, đầu đọc phải trả lại
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820 hoặc đặt
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
478 thành 0. Chức năng đọc có thể trả về các phần có kích thước bất kỳ lớn hơn 0


[-0, +0, e]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
48

Đặt hàm C

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 làm giá trị mới của toàn cầu
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
888. Nó được định nghĩa là một macro

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
49

[-1, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
50

Xóa phần tử tại chỉ mục hợp lệ đã cho, chuyển các phần tử phía trên chỉ mục này xuống để lấp đầy khoảng trống. Không thể được gọi với chỉ mục giả, vì chỉ mục giả không phải là vị trí ngăn xếp thực tế


[-1, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
51

Di chuyển phần tử trên cùng vào vị trí đã cho (và bật nó lên) mà không dịch chuyển bất kỳ phần tử nào (do đó thay thế giá trị tại vị trí đã cho)


[-?, +?, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
52

Bắt đầu và tiếp tục một coroutine trong một chủ đề nhất định

Để bắt đầu một quy trình đăng quang, trước tiên bạn tạo một chủ đề mới (xem

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
483); . Cuộc gọi này trả về khi quy trình đăng ký tạm dừng hoặc kết thúc quá trình thực hiện. Khi nó trả về, ngăn xếp chứa tất cả các giá trị được chuyển đến
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
486 hoặc tất cả các giá trị được trả về bởi hàm body.
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
484 trả về
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
488 nếu coroutine mang lại kết quả, 0 nếu coroutine kết thúc quá trình thực thi mà không có lỗi hoặc mã lỗi trong trường hợp có lỗi (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
710). Trong trường hợp có lỗi, ngăn xếp không được mở ra, vì vậy bạn có thể sử dụng API gỡ lỗi trên nó. Thông báo lỗi ở trên cùng của ngăn xếp. Để khởi động lại một coroutine, bạn chỉ đặt vào ngăn xếp của nó các giá trị sẽ được truyền dưới dạng kết quả từ
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
490, sau đó gọi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
484


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
53

Thay đổi chức năng cấp phát của một trạng thái nhất định thành

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 với dữ liệu người dùng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
814


[-1, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
54

Bật một bảng từ ngăn xếp và đặt nó làm môi trường mới cho giá trị tại chỉ mục đã cho. Nếu giá trị tại chỉ mục đã cho không phải là hàm, chuỗi cũng không phải dữ liệu người dùng, thì

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
494 trả về 0. Nếu không, nó trả về 1


[-1, +0, e]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
55

Tương đương với

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
495, trong đó
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768 là giá trị tại chỉ mục hợp lệ đã cho và
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
734 là giá trị ở đầu ngăn xếp

Hàm này bật giá trị từ ngăn xếp. Như trong Lua, hàm này có thể kích hoạt siêu phương thức cho sự kiện "newindex" (xem §2. số 8)


[-1, +0, e]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
56

Bật một giá trị từ ngăn xếp và đặt nó làm giá trị mới của toàn cầu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
888. Nó được định nghĩa là một macro

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
57

[-1, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
58

Bật một bảng từ ngăn xếp và đặt nó làm bảng có thể chuyển đổi mới cho giá trị tại chỉ mục được chấp nhận đã cho


[-2, +0, e]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
59

Tương đương với

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
495, trong đó
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768 là giá trị tại chỉ mục hợp lệ đã cho,
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
734 là giá trị ở đầu ngăn xếp và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
758 là giá trị ngay dưới đầu

Hàm này bật cả khóa và giá trị từ ngăn xếp. Như trong Lua, hàm này có thể kích hoạt siêu phương thức cho sự kiện "newindex" (xem §2. số 8)


[-?, +?, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
60

Chấp nhận mọi chỉ mục được chấp nhận hoặc 0 và đặt đỉnh ngăn xếp thành chỉ mục này. Nếu đỉnh mới lớn hơn đỉnh cũ, thì các phần tử mới được lấp đầy bằng không. Nếu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
903 là 0, thì tất cả phần tử ngăn xếp sẽ bị xóa


     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
61

Cấu trúc trong suốt giữ toàn bộ trạng thái của trình thông dịch Lua. Thư viện Lua được đăng lại đầy đủ. nó không có biến toàn cầu. Tất cả thông tin về một trạng thái được giữ trong cấu trúc này

Một con trỏ tới trạng thái này phải được chuyển làm đối số đầu tiên cho mọi hàm trong thư viện, ngoại trừ

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
815, hàm tạo trạng thái Lua từ đầu


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
62

Trả về trạng thái của luồng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
463

Trạng thái có thể là 0 đối với luồng bình thường, mã lỗi nếu luồng kết thúc quá trình thực thi có lỗi hoặc

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
488 nếu luồng bị treo


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
63

Chuyển đổi giá trị Lua tại chỉ mục được chấp nhận đã cho thành giá trị C boolean (0 hoặc 1). Giống như tất cả các phép thử trong Lua,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
907 trả về 1 cho bất kỳ giá trị Lua nào khác với false và nil; . Nó cũng trả về 0 khi được gọi với chỉ mục không hợp lệ. (Nếu bạn chỉ muốn chấp nhận các giá trị boolean thực tế, hãy sử dụng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
908 để kiểm tra loại giá trị. )


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
64

Chuyển đổi một giá trị tại chỉ mục có thể chấp nhận được thành một hàm C. Giá trị đó phải là hàm C;


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
65

Chuyển đổi giá trị Lua tại chỉ mục được chấp nhận đã cho thành loại tích phân có dấu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
910. Giá trị Lua phải là một số hoặc một chuỗi có thể chuyển đổi thành một số (xem §2. 2. 1);

Nếu số không phải là số nguyên, nó sẽ bị cắt bớt theo một số cách không xác định


[-0, +0, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
66

Chuyển đổi giá trị Lua tại chỉ mục được chấp nhận đã cho thành chuỗi C. Nếu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
458 không phải là
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820, nó cũng đặt
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
914 với độ dài chuỗi. Giá trị Lua phải là một chuỗi hoặc một số; . Nếu giá trị là một số, thì
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
412 cũng thay đổi giá trị thực trong ngăn xếp thành một chuỗi. (Thay đổi này gây nhầm lẫn cho
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
411 khi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
412 được áp dụng cho các khóa trong quá trình duyệt bảng. )

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
412 trả về một con trỏ được căn chỉnh hoàn toàn thành một chuỗi bên trong trạng thái Lua. Chuỗi này luôn có số 0 ('
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
83') sau ký tự cuối cùng (như trong C), nhưng có thể chứa các số 0 khác trong phần thân của nó. Bởi vì Lua có bộ sưu tập rác, không đảm bảo rằng con trỏ được trả về bởi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
412 sẽ hợp lệ sau khi giá trị tương ứng bị xóa khỏi ngăn xếp


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
67

Chuyển đổi giá trị Lua tại chỉ mục được chấp nhận đã cho thành loại C

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
448 (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
448). Giá trị Lua phải là một số hoặc một chuỗi có thể chuyển đổi thành một số (xem §2. 2. 1);


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
68

Chuyển đổi giá trị tại chỉ mục được chấp nhận đã cho thành con trỏ C chung (

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
925). Giá trị có thể là dữ liệu người dùng, bảng, chuỗi hoặc hàm; . Các đối tượng khác nhau sẽ cho các con trỏ khác nhau. Không có cách nào để chuyển con trỏ về giá trị ban đầu

Thông thường, chức năng này chỉ được sử dụng cho thông tin gỡ lỗi


[-0, +0, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
69

Tương đương với

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
412 với
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
458 bằng với
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
70

Chuyển đổi giá trị tại chỉ mục được chấp nhận đã cho thành chuỗi Lua (được biểu thị là

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
931). Giá trị này phải là một chủ đề;


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
71

Nếu giá trị tại chỉ mục được chấp nhận đã cho là dữ liệu người dùng đầy đủ, hãy trả về địa chỉ khối của nó. Nếu giá trị là một userdata nhẹ, trả về con trỏ của nó. Nếu không, trả về

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
72

Trả về loại giá trị trong chỉ mục được chấp nhận đã cho hoặc

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
934 cho chỉ mục không hợp lệ (nghĩa là chỉ mục cho vị trí ngăn xếp "trống"). Các loại được trả về bởi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
935 được mã hóa bởi các hằng số sau được xác định trong
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
782.
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
937,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
938,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
939,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
940,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
941,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
942,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
943,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
944 và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
945


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
73

Trả về tên của loại được mã hóa bởi giá trị

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
946, giá trị này phải là một trong những giá trị được trả về bởi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
935


     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
74

Loại hàm ghi được sử dụng bởi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
861. Mỗi khi nó tạo ra một đoạn mã khác,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
861 gọi bộ ghi, chuyển bộ đệm được ghi (
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
803), kích thước của nó (
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
951) và tham số
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
864 được cung cấp cho
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
861

Người viết trả về một mã lỗi. 0 có nghĩa là không có lỗi;


[-?, +?, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
75

Trao đổi giá trị giữa các luồng khác nhau của cùng một trạng thái toàn cầu

Hàm này bật các giá trị

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 từ ngăn xếp
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
956 và đẩy chúng vào ngăn xếp
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
957


[-?, +?, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
76

Mang lại một coroutine

Hàm này chỉ nên được gọi là biểu thức trả về của hàm C, như sau

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
77

Khi một hàm C gọi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
486 theo cách đó, quy trình đăng ký đang chạy sẽ tạm dừng thực thi và lệnh gọi tới
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
484 đã bắt đầu quy trình đăng ký này sẽ trả về. Tham số
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
842 là số lượng giá trị từ ngăn xếp được chuyển thành kết quả cho
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
484

Lua không có tiện ích sửa lỗi tích hợp. Thay vào đó, nó cung cấp một giao diện đặc biệt bằng các chức năng và hook. Giao diện này cho phép xây dựng các loại trình gỡ lỗi, trình lược tả và các công cụ khác cần "thông tin nội bộ" từ trình thông dịch


     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
78

Một cấu trúc được sử dụng để mang các mẩu thông tin khác nhau về một chức năng đang hoạt động.

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
962 chỉ điền vào phần riêng tư của cấu trúc này, để sử dụng sau này. Để điền thông tin hữu ích vào các trường khác của ________ 4963, hãy gọi cho số ________ 4964

Các trường của

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
963 có ý nghĩa như sau

  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    966. Nếu hàm được định nghĩa trong một chuỗi, thì
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    966 chính là chuỗi đó. Nếu chức năng được xác định trong một tệp, thì
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    966 bắt đầu bằng '
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    969' theo sau là tên tệp
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    970. phiên bản "có thể in được" của
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    966, được sử dụng trong các thông báo lỗi
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    972. số dòng nơi định nghĩa của hàm bắt đầu
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    973. số dòng nơi định nghĩa của hàm kết thúc
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    869. chuỗi
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    975 nếu hàm là hàm Lua,
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    976 nếu là hàm C,
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    977 nếu là phần chính của đoạn và
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    978 nếu là hàm thực hiện lệnh gọi đuôi. Trong trường hợp sau, Lua không có thông tin nào khác về chức năng
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    979. dòng hiện tại nơi hàm đã cho đang thực thi. Khi không có thông tin dòng nào,
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    979 được đặt thành -1
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    888. một tên hợp lý cho các chức năng nhất định. Vì các hàm trong Lua là các giá trị hạng nhất nên chúng không có tên cố định. một số hàm có thể là giá trị của nhiều biến toàn cục, trong khi các hàm khác chỉ có thể được lưu trữ trong một trường bảng. Hàm
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    964 kiểm tra cách hàm được gọi để tìm tên phù hợp. Nếu nó không thể tìm thấy tên, thì
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    888 được đặt thành
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    820
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    985. giải thích trường
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    888. Giá trị của
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    985 có thể là
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    988,
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    989,
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    990,
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    991,
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    992 hoặc
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    993 (chuỗi rỗng), tùy theo cách gọi hàm. (Lua sử dụng chuỗi rỗng khi dường như không có tùy chọn nào khác được áp dụng. )
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    994. số lượng giá trị tăng của hàm

[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
79

Trả về hàm hook hiện tại


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
80

Trả về số hook hiện tại


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
81

Trả về mặt nạ móc hiện tại


[-(0. 1), +(0. 1. 2), m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
82

Trả về thông tin về một hàm cụ thể hoặc lời gọi hàm

Để nhận thông tin về một lời gọi hàm, tham số

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
995 phải là một bản ghi kích hoạt hợp lệ đã được điền bởi một lời gọi trước đó tới
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
962 hoặc được cung cấp làm đối số cho hook (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
997)

Để lấy thông tin về một chức năng, bạn đẩy nó vào ngăn xếp và bắt đầu chuỗi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
869 với ký tự '
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
999'. (Trong trường hợp đó,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
964 bật chức năng ở trên cùng của ngăn xếp. ) Chẳng hạn, để biết hàm
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 được xác định ở dòng nào, bạn có thể viết đoạn mã sau

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
83

Mỗi ký tự trong chuỗi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
869 chọn một số trường của cấu trúc
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
995 để điền hoặc một giá trị sẽ được đẩy vào ngăn xếp

  • '______2769'. điền vào trường
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    888 và
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    985;
  • '____5307'. điền vào các trường
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    966,
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    970,
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    972,
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    973 và
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    869;
  • '____5313'. điền vào trường
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    979;
  • '____5315'. điền vào trường
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    994;
  • '______2742'. đẩy vào ngăn xếp chức năng đang chạy ở mức nhất định;
  • '______4463'. đẩy vào ngăn xếp một bảng có chỉ số là số dòng hợp lệ trên hàm. (Dòng hợp lệ là dòng có một số mã được liên kết, nghĩa là dòng mà bạn có thể đặt điểm ngắt. Các dòng không hợp lệ bao gồm các dòng trống và nhận xét. )

Hàm này trả về 0 nếu có lỗi (ví dụ: một tùy chọn không hợp lệ trong

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
869)


[-0, +(0. 1), -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
84

Nhận thông tin về một biến cục bộ của một bản ghi kích hoạt nhất định. Tham số

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
995 phải là một bản ghi kích hoạt hợp lệ đã được điền bởi lệnh gọi trước đó tới
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
962 hoặc được cung cấp dưới dạng đối số cho hook (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
997). Chỉ số
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 chọn biến cục bộ cần kiểm tra (1 là tham số đầu tiên hoặc biến cục bộ đang hoạt động, v.v. cho đến biến cục bộ đang hoạt động cuối cùng).
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
324 đẩy giá trị của biến vào ngăn xếp và trả về tên của nó

Tên biến bắt đầu bằng '

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
797' (mở ngoặc đơn) đại diện cho các biến nội bộ (biến điều khiển vòng lặp, biến tạm thời và cục bộ hàm C)

Trả về

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820 (và không đẩy gì cả) khi chỉ mục lớn hơn số lượng biến cục bộ đang hoạt động


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
85

Nhận thông tin về ngăn xếp thời gian chạy trình thông dịch

Hàm này lấp đầy các phần của cấu trúc

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
963 với nhận dạng bản ghi kích hoạt của hàm đang thực thi ở một mức nhất định. Cấp 0 là chức năng đang chạy hiện tại, trong khi cấp n+1 là chức năng đã gọi cấp n. Khi không có lỗi,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
962 trả về 1;


[-0, +(0. 1), -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
86

Nhận thông tin về giá trị tăng của lần đóng cửa. (Đối với các hàm Lua, giá trị tăng là các biến cục bộ bên ngoài mà hàm sử dụng và do đó được bao gồm trong bao đóng của nó. )

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
329 lấy chỉ số
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 của một giá trị tăng, đẩy giá trị của giá trị tăng lên vào ngăn xếp và trả về tên của nó.
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
331 trỏ đến sự đóng cửa trong ngăn xếp. (Các giá trị tăng không có thứ tự cụ thể, vì chúng hoạt động thông qua toàn bộ chức năng. Vì vậy, chúng được đánh số theo thứ tự tùy ý. )

Trả về

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820 (và không đẩy gì cả) khi chỉ mục lớn hơn số lượng giá trị tăng. Đối với các hàm C, hàm này sử dụng chuỗi rỗng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
993 làm tên cho tất cả các giá trị tăng


     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
87

Loại để gỡ lỗi các chức năng hook

Bất cứ khi nào hook được gọi, đối số ________ 4995 của nó có trường ________ 5335 được đặt thành sự kiện cụ thể đã kích hoạt hook. Lua xác định các sự kiện này bằng các hằng số sau.

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
336,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
337,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
338,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
339 và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
340. Ngoài ra, đối với các sự kiện theo dòng, trường
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
979 cũng được đặt. Để lấy giá trị của bất kỳ trường nào khác trong
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
995, hook phải gọi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
964. Đối với các sự kiện trả lại,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
335 có thể là
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
337, giá trị bình thường hoặc
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
338. Trong trường hợp sau, Lua đang mô phỏng một kết quả trả về từ một hàm đã thực hiện lệnh gọi đuôi;

Trong khi Lua đang chạy hook, nó sẽ vô hiệu hóa các lệnh gọi hook khác. Do đó, nếu một hook gọi lại Lua để thực thi một hàm hoặc một đoạn, thì quá trình thực thi này diễn ra mà không có bất kỳ lệnh gọi nào đến hook.


[-0, +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
88

Đặt chức năng móc gỡ lỗi

Đối số

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 là hàm hook.
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
349 chỉ định những sự kiện hook sẽ được gọi. nó được hình thành bởi một bitwise hoặc của các hằng số
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
350,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
351,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
352 và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
353. Đối số
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
354 chỉ có ý nghĩa khi mặt nạ bao gồm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
353. Đối với mỗi sự kiện, hook được gọi như giải thích bên dưới

  • Móc cuộc gọi. được gọi khi trình thông dịch gọi một hàm. Móc được gọi ngay sau khi Lua nhập chức năng mới, trước khi chức năng nhận đối số của nó
  • móc trở lại. được gọi khi trình thông dịch trở về từ một hàm. Hook được gọi ngay trước khi Lua rời chức năng. Bạn không có quyền truy cập vào các giá trị được hàm trả về
  • móc câu. được gọi khi trình thông dịch sắp bắt đầu thực thi một dòng mã mới hoặc khi nó quay lại mã (thậm chí đến cùng một dòng). (Sự kiện này chỉ xảy ra khi Lua đang thực hiện một chức năng Lua. )
  • móc đếm. được gọi sau khi trình thông dịch thực hiện mọi hướng dẫn
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    354. (Sự kiện này chỉ xảy ra khi Lua đang thực hiện một chức năng Lua. )

Móc bị vô hiệu hóa bằng cách đặt

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
349 thành 0


[-(0. 1), +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
89

Đặt giá trị của một biến cục bộ của một bản ghi kích hoạt nhất định. Các tham số

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
995 và
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 giống như trong
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
324 (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
324).
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
362 gán giá trị ở đầu ngăn xếp cho biến và trả về tên của nó. Nó cũng bật giá trị từ ngăn xếp

Trả về

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820 (và không xuất hiện gì) khi chỉ mục lớn hơn số lượng biến cục bộ đang hoạt động


[-(0. 1), +0, -]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
90

Đặt giá trị của giá trị tăng của đóng. Nó gán giá trị ở đầu ngăn xếp cho giá trị tăng và trả về tên của nó. Nó cũng bật giá trị từ ngăn xếp. Các tham số

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
331 và
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 giống như trong
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
329 (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
329)

Trả về

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820 (và không xuất hiện gì) khi chỉ mục lớn hơn số lượng giá trị tăng

Thư viện phụ trợ cung cấp một số chức năng thuận tiện để giao tiếp C với Lua. Trong khi API cơ bản cung cấp các chức năng cơ bản cho tất cả các tương tác giữa C và Lua, thư viện phụ trợ cung cấp các chức năng cấp cao hơn cho một số tác vụ phổ biến

Tất cả các chức năng từ thư viện phụ trợ được xác định trong tệp tiêu đề

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
369 và có tiền tố
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
370

Tất cả các chức năng trong thư viện phụ trợ được xây dựng dựa trên API cơ bản và do đó, chúng cung cấp không có gì không thể thực hiện được với API này

Một số hàm trong thư viện phụ trợ được sử dụng để kiểm tra đối số hàm C. Tên của họ luôn là

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
371 hoặc
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
372. Tất cả các chức năng này sẽ báo lỗi nếu kiểm tra không hài lòng. Bởi vì thông báo lỗi được định dạng cho các đối số (e. g. , "
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
373"), bạn không nên sử dụng các hàm này cho các giá trị ngăn xếp khác

Ở đây chúng tôi liệt kê tất cả các chức năng và loại từ thư viện phụ trợ theo thứ tự bảng chữ cái


[-0, +0, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
91

Thêm ký tự

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
374 vào bộ đệm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
375 (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
376)


[-0, +0, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
92

Thêm chuỗi được trỏ tới bởi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 với độ dài
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
313 vào bộ đệm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
375 (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
376). Chuỗi có thể chứa các số 0 được nhúng


[-0, +0, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
93

Thêm vào vùng đệm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
375 (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
376) một chuỗi có độ dài
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 đã được sao chép trước đó vào vùng đệm (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
384)


[-0, +0, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
94

Thêm chuỗi kết thúc bằng 0 được chỉ ra bởi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 vào bộ đệm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
375 (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
376). Chuỗi có thể không chứa số 0 được nhúng


[-1, +0, m]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
95

Thêm giá trị ở đầu ngăn xếp vào bộ đệm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
375 (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
376). Bật giá trị

Đây là chức năng duy nhất trên bộ đệm chuỗi có thể (và phải) được gọi với một phần tử phụ trên ngăn xếp, là giá trị được thêm vào bộ đệm


[-0, +0, v]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
96

Kiểm tra xem

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
390 có đúng không. Nếu không, sẽ báo lỗi với thông báo sau, trong đó
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
852 được truy xuất từ ​​ngăn xếp cuộc gọi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
97

[-0, +0, v]

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
98

Phát sinh lỗi với thông báo sau, trong đó

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
852 được truy xuất từ ​​ngăn xếp cuộc gọi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
97

Hàm này không bao giờ trả về, nhưng nó là một thành ngữ để sử dụng nó trong các hàm C như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
393


     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
00

Nhập cho bộ đệm chuỗi

Bộ đệm chuỗi cho phép mã C xây dựng chuỗi Lua từng phần. Mô hình sử dụng của nó như sau

  • Đầu tiên bạn khai báo một biến
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    435 kiểu
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    376
  • Sau đó, bạn khởi tạo nó bằng một cuộc gọi
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    396
  • Sau đó, bạn thêm các đoạn chuỗi vào bộ đệm gọi bất kỳ hàm
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    397 nào
  • Bạn kết thúc bằng cách gọi
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    398. Cuộc gọi này để lại chuỗi cuối cùng trên đỉnh ngăn xếp

Trong quá trình hoạt động bình thường của nó, bộ đệm chuỗi sử dụng một số lượng khe ngăn xếp khác nhau. Vì vậy, trong khi sử dụng bộ đệm, bạn không thể cho rằng mình biết đỉnh của ngăn xếp ở đâu. Bạn có thể sử dụng ngăn xếp giữa các lần gọi liên tiếp để thực hiện các thao tác đệm miễn là việc sử dụng đó được cân bằng; . (Ngoại lệ duy nhất cho quy tắc này là

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
399. ) Sau khi gọi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
600, ngăn xếp trở lại mức của nó khi bộ đệm được khởi tạo, cộng với chuỗi cuối cùng ở trên cùng của nó


[-0, +0, -]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
01

Khởi tạo bộ đệm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
375. Chức năng này không phân bổ bất kỳ không gian nào;


[-0, +(0. 1), e]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
02

Gọi một siêu phương thức

Nếu đối tượng tại chỉ mục

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
603 có một metatable và metatable này có một trường
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
811, thì hàm này gọi trường này và chuyển đối tượng làm đối số duy nhất của nó. Trong trường hợp này, hàm này trả về 1 và đẩy vào ngăn xếp giá trị được trả về bởi lệnh gọi. Nếu không có metatable hoặc không có metamethod, hàm này trả về 0 (không đẩy bất kỳ giá trị nào vào ngăn xếp)


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
03

Kiểm tra xem hàm có đối số thuộc bất kỳ loại nào không (kể cả nil) tại vị trí

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
04

Kiểm tra xem đối số của hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 có phải là một số hay không và trả về số này được truyền cho một
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
451


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
05

Kiểm tra xem đối số của hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 có phải là một số hay không và trả về số này được chuyển thành một
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
910


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
06

Kiểm tra xem đối số của hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 có phải là một số hay không và trả về số này được truyền cho một
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
611


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
07

Kiểm tra xem đối số của hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 có phải là một chuỗi hay không và trả về chuỗi này;

Hàm này sử dụng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
412 để nhận kết quả, vì vậy tất cả chuyển đổi và cảnh báo của hàm đó sẽ áp dụng tại đây


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
08

Kiểm tra xem đối số của hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 có phải là một số hay không và trả về số này


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
09

Kiểm tra xem đối số của hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 có phải là một chuỗi hay không và tìm kiếm chuỗi này trong mảng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
619 (phải được kết thúc bằng NULL). Trả về chỉ mục trong mảng nơi tìm thấy chuỗi. Phát sinh lỗi nếu đối số không phải là một chuỗi hoặc nếu không tìm thấy chuỗi

Nếu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
620 không phải là
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820, thì hàm sử dụng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
620 làm giá trị mặc định khi không có đối số
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 hoặc nếu đối số này bằng không

Đây là một hàm hữu ích để ánh xạ chuỗi tới C enums. (Quy ước thông thường trong các thư viện Lua là sử dụng chuỗi thay vì số để chọn tùy chọn. )


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
10

Tăng kích thước ngăn xếp lên

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
624 phần tử, gây ra lỗi nếu ngăn xếp không thể tăng đến kích thước đó.
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
625 là một văn bản bổ sung để đi vào thông báo lỗi


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
11

Kiểm tra xem đối số của hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 có phải là một chuỗi hay không và trả về chuỗi này

Hàm này sử dụng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
412 để nhận kết quả, vì vậy tất cả chuyển đổi và cảnh báo của hàm đó sẽ áp dụng tại đây


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
12

Kiểm tra xem đối số hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 có loại
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768 không. Xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
935 để biết cách mã hóa các loại cho
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
13

Kiểm tra xem đối số hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 có phải là dữ liệu người dùng thuộc loại
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
633 hay không (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
634)


[-0, +?, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
14

Tải và chạy tệp đã cho. Nó được định nghĩa là macro sau

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
15

Nó trả về 0 nếu không có lỗi hoặc 1 trong trường hợp có lỗi


[-0, +?, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
16

Tải và chạy chuỗi đã cho. Nó được định nghĩa là macro sau

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
17

Nó trả về 0 nếu không có lỗi hoặc 1 trong trường hợp có lỗi


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
18

Tăng một lỗi. Định dạng thông báo lỗi được cung cấp bởi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
635 cộng với bất kỳ đối số bổ sung nào, tuân theo các quy tắc tương tự của
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
464. Nó cũng thêm vào đầu thông báo tên tệp và số dòng xảy ra lỗi, nếu thông tin này có sẵn

Hàm này không bao giờ trả về, nhưng nó là một thành ngữ để sử dụng nó trong các hàm C như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
637


[-0, +(0. 1), m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
19

Đẩy vào ngăn xếp trường

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
811 từ metatable của đối tượng tại chỉ mục
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
603. Nếu đối tượng không có metatable hoặc nếu metatable không có trường này, trả về 0 và không đẩy gì


[-0, +1, -]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
20

Đẩy vào ngăn xếp metatable được liên kết với tên

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
633 trong sổ đăng ký (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
634)


[-0, +1, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
21

Tạo một bản sao của chuỗi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 bằng cách thay thế bất kỳ lần xuất hiện nào của chuỗi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
803 bằng chuỗi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
644. Đẩy chuỗi kết quả vào ngăn xếp và trả về nó


[-0, +1, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
22

Tải bộ đệm dưới dạng đoạn Lua. Hàm này sử dụng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
896 để tải đoạn trong bộ đệm được chỉ định bởi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
646 với kích thước
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
951

Hàm này trả về kết quả tương tự như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
896.
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
888 là tên đoạn, được sử dụng cho thông tin gỡ lỗi và thông báo lỗi


[-0, +1, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
23

Tải một tập tin dưới dạng Lua chunk. Hàm này sử dụng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
896 để tải đoạn trong tệp có tên
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
651. Nếu
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
651 là
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820, thì nó sẽ tải từ đầu vào tiêu chuẩn. Dòng đầu tiên trong tệp bị bỏ qua nếu nó bắt đầu bằng
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
767

Hàm này trả về kết quả giống như hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
896 nhưng có thêm mã lỗi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
656 nếu không thể mở/đọc tệp

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
896, chức năng này chỉ tải đoạn;


[-0, +1, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
24

Tải một chuỗi dưới dạng một đoạn Lua. Hàm này sử dụng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
896 để tải đoạn mã trong chuỗi có đầu cuối bằng 0
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456

Hàm này trả về kết quả tương tự như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
896

Cũng như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
896, hàm này chỉ tải đoạn dữ liệu;


[-0, +1, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
25

Nếu sổ đăng ký đã có khóa

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
633, trả về 0. Nếu không, hãy tạo một bảng mới để sử dụng làm bảng siêu dữ liệu cho dữ liệu người dùng, thêm bảng đó vào sổ đăng ký bằng khóa
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
633 và trả về 1

Trong cả hai trường hợp, đẩy vào ngăn xếp giá trị cuối cùng được liên kết với

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
633 trong sổ đăng ký


[-0, +0, -]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
26

Tạo một trạng thái Lua mới. Nó gọi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
815 bằng một bộ cấp phát dựa trên hàm C
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
813 tiêu chuẩn, sau đó đặt một hàm hoảng loạn (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
667) để in thông báo lỗi ra đầu ra lỗi tiêu chuẩn trong trường hợp xảy ra lỗi nghiêm trọng

Trả về trạng thái mới hoặc

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820 nếu có lỗi cấp phát bộ nhớ


[-0, +0, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
27

Mở tất cả các thư viện Lua tiêu chuẩn vào trạng thái nhất định


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
28

Nếu đối số của hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 là một số, trả về số này chuyển thành một số
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
451. Nếu đối số này vắng mặt hoặc không, trả về
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
671. Mặt khác, gây ra lỗi


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
29

Nếu đối số của hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 là một số, trả về số này chuyển thành một số
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
910. Nếu đối số này vắng mặt hoặc không, trả về
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
671. Mặt khác, gây ra lỗi


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
30

Nếu đối số của hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 là một số, trả về số này được chuyển thành một số
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
611. Nếu đối số này vắng mặt hoặc không, trả về
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
671. Mặt khác, gây ra lỗi


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
31

Nếu đối số hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 là một chuỗi, trả về chuỗi này. Nếu đối số này vắng mặt hoặc không, trả về
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
671. Mặt khác, gây ra lỗi

Nếu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
313 không phải là
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820, điền vào vị trí
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
615 với độ dài của kết quả


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
32

Nếu đối số hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 là một số, trả về số này. Nếu đối số này vắng mặt hoặc không, trả về
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
671. Mặt khác, gây ra lỗi


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
33

Nếu đối số hàm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
485 là một chuỗi, trả về chuỗi này. Nếu đối số này vắng mặt hoặc không, trả về
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
671. Mặt khác, gây ra lỗi


[-0, +0, -]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
34

Trả về một địa chỉ cho một không gian có kích thước

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
687 nơi bạn có thể sao chép một chuỗi sẽ được thêm vào bộ đệm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
375 (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
376). Sau khi sao chép chuỗi vào không gian này, bạn phải gọi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
690 với kích thước của chuỗi để thực sự thêm nó vào bộ đệm


[-?, +1, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
35

Kết thúc việc sử dụng bộ đệm

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
375 để lại chuỗi cuối cùng ở trên cùng của ngăn xếp


[-1, +0, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
36

Tạo và trả về một tham chiếu, trong bảng tại chỉ mục

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768, cho đối tượng ở đầu ngăn xếp (và bật đối tượng)

Một tham chiếu là một khóa số nguyên duy nhất. Miễn là bạn không tự thêm các khóa số nguyên vào bảng ________ 2768, thì ________ 5694 đảm bảo tính duy nhất của khóa mà nó trả về. Bạn có thể truy xuất một đối tượng được gọi bằng tham chiếu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
644 bằng cách gọi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
696. Hàm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
697 giải phóng một tham chiếu và đối tượng liên quan của nó

Nếu đối tượng ở trên cùng của ngăn xếp là không, thì

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
694 trả về hằng số
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
699. Hằng số
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
000 được đảm bảo khác với bất kỳ tham chiếu nào được trả về bởi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
694


     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
37

Nhập các mảng chức năng được đăng ký bởi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
002.
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
888 là tên hàm và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
852 là con trỏ tới hàm. Bất kỳ mảng nào của
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
005 đều phải kết thúc bằng một mục nhập canh gác trong đó cả
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
888 và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
852 đều là
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820


[-(0. 1), +1, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
38

Mở một thư viện

Khi được gọi với

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
009 bằng với
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
820, nó chỉ cần đăng ký tất cả các chức năng trong danh sách
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
313 (xem
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
005) vào bảng trên cùng của ngăn xếp

Khi được gọi với một giá trị khác null

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
009,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
002 tạo một bảng mới
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768, đặt nó làm giá trị của biến toàn cục
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
009, đặt nó làm giá trị của
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
017 và đăng ký tất cả các hàm trong danh sách
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
313 trên đó. Nếu có một bảng trong
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
017 hoặc trong biến
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
009, hãy sử dụng lại bảng này thay vì tạo một bảng mới

Trong mọi trường hợp, hàm rời khỏi bảng trên đỉnh ngăn xếp


[-0, +0, -]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
39

Trả về tên của loại giá trị tại chỉ mục đã cho


[-0, +0, v]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
40

Tạo lỗi với thông báo như sau

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
41

trong đó

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
021 được tạo bởi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
022,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
023 là tên của hàm hiện tại và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
024 là tên loại của đối số thực tế


[-0, +0, -]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
42

Phát hành tài liệu tham khảo

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
025 từ bảng tại chỉ mục
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768 (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
694). Mục nhập được xóa khỏi bảng để có thể thu thập đối tượng được giới thiệu. Tài liệu tham khảo
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
025 cũng được giải phóng để sử dụng lại

Nếu

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
025 là
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
000 hoặc
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
699, thì
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
697 không làm gì cả


[-0, +1, m]

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
43

Đẩy vào ngăn xếp một chuỗi xác định vị trí hiện tại của điều khiển ở cấp độ

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
033 trong ngăn xếp cuộc gọi. Thông thường chuỗi này có định dạng sau

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
44

Cấp 0 là chức năng đang chạy, cấp 1 là chức năng được gọi là chức năng đang chạy, v.v.

Chức năng này được sử dụng để tạo tiền tố cho các thông báo lỗi

Các thư viện Lua tiêu chuẩn cung cấp các chức năng hữu ích được triển khai trực tiếp thông qua C API. Một số chức năng này cung cấp các dịch vụ thiết yếu cho ngôn ngữ (e. g. ,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
96 và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
715); . g. , vào/ra); . g. ,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
036)

Tất cả các thư viện đều được triển khai thông qua C API chính thức và được cung cấp dưới dạng các mô-đun C riêng biệt. Hiện tại Lua có các thư viện chuẩn sau

  • thư viện cơ bản, bao gồm thư viện con coroutine;
  • thư viện gói;
  • thao tác chuỗi;
  • thao tác trên bàn;
  • các hàm toán học (sin, log, v.v. );
  • đầu vào và đầu ra;
  • điều hành hệ thống cơ sở vật chất;
  • cơ sở gỡ lỗi

Ngoại trừ các thư viện cơ bản và gói, mỗi thư viện cung cấp tất cả các chức năng của nó dưới dạng các trường của bảng toàn cục hoặc dưới dạng phương thức của các đối tượng của nó

Để có quyền truy cập vào các thư viện này, chương trình lưu trữ C phải gọi hàm

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
037 để mở tất cả các thư viện tiêu chuẩn. Ngoài ra, nó có thể mở chúng riêng lẻ bằng cách gọi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
038 (đối với thư viện cơ bản),
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
039 (đối với thư viện gói),
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
040 (đối với thư viện chuỗi),
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
041 (đối với thư viện bảng),
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
042 (đối với thư viện toán học),
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
043 . Các hàm này được khai báo trong
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
046 và không được gọi trực tiếp. bạn phải gọi chúng giống như bất kỳ hàm Lua C nào khác, e. g. , bằng cách sử dụng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
840

Thư viện cơ bản cung cấp một số chức năng cốt lõi cho Lua. Nếu bạn không đưa thư viện này vào ứng dụng của mình, bạn nên kiểm tra cẩn thận xem bạn có cần cung cấp triển khai cho một số cơ sở của nó không


Phát sinh lỗi khi giá trị đối số của nó là
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
734 sai (i. e. , không hoặc sai); .
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
049 là một thông báo lỗi; . "

Chức năng này là một giao diện chung cho bộ thu gom rác. Nó thực hiện các chức năng khác nhau theo đối số đầu tiên của nó,

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
050

  • "sưu tầm". thực hiện một chu kỳ thu gom rác đầy đủ. Đây là tùy chọn mặc định
  • "dừng lại". dừng bộ thu gom rác
  • "khởi động lại". khởi động lại bộ thu gom rác
  • "đếm". trả về tổng bộ nhớ đang được Lua sử dụng (tính bằng Kbyte)
  • "bươc". thực hiện một bước thu gom rác. "Kích thước" của bước được kiểm soát bởi
         +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    051 (giá trị lớn hơn có nghĩa là nhiều bước hơn) theo cách không được chỉ định. Nếu bạn muốn kiểm soát kích thước bước, bạn phải điều chỉnh bằng thực nghiệm giá trị của
         +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    051. Trả về true nếu bước kết thúc một chu kỳ thu thập
  • "tạm dừng". đặt
         +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    051 làm giá trị mới cho việc tạm dừng bộ thu (xem §2. 10). Trả về giá trị tạm dừng trước đó
  • "setstepmul". đặt
         +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    051 làm giá trị mới cho hệ số nhân bước của bộ thu (xem §2. 10). Trả về giá trị trước đó cho bước

Mở tệp được đặt tên và thực thi nội dung của nó dưới dạng đoạn Lua. Khi được gọi mà không có đối số,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
055 thực thi nội dung của đầu vào tiêu chuẩn (
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
056). Trả về tất cả các giá trị được trả về bởi chunk. Trong trường hợp có lỗi,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
055 sẽ truyền lỗi cho người gọi của nó (nghĩa là,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
055 không chạy ở chế độ được bảo vệ)
Chấm dứt chức năng được bảo vệ cuối cùng được gọi và trả về
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
049 dưới dạng thông báo lỗi. Hàm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
711 không bao giờ trả về

Thông thường,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
711 thêm một số thông tin về vị trí lỗi ở đầu tin nhắn. Đối số
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
062 chỉ định cách lấy vị trí lỗi. Với cấp 1 (mặc định), vị trí lỗi là nơi hàm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
711 được gọi. Cấp 2 chỉ ra lỗi ở vị trí gọi hàm có tên là
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
711; . Vượt qua mức 0 sẽ tránh thêm thông tin vị trí lỗi vào thông báo


Biến toàn cục (không phải hàm) chứa môi trường toàn cầu (tức là,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
065). Bản thân Lua không sử dụng biến này; . (Sử dụng
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
705 để thay đổi môi trường. )
Trả về môi trường hiện tại đang được hàm sử dụng.
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 có thể là một hàm Lua hoặc một số chỉ định hàm ở cấp độ ngăn xếp đó. Cấp 1 là chức năng gọi
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
704. Nếu hàm đã cho không phải là hàm Lua hoặc nếu
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 bằng 0, thì
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
704 trả về môi trường chung. Giá trị mặc định cho
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 là 1

Nếu

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
072 không có metatable, trả về nil. Mặt khác, nếu metatable của đối tượng có trường
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
073, trả về giá trị được liên kết. Mặt khác, trả về metatable của đối tượng đã cho


Trả về ba giá trị. một hàm lặp, bảng

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768 và 0, để việc xây dựng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
45

sẽ lặp qua các cặp (

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
075), (
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
076), ···, cho đến khóa số nguyên đầu tiên không có trong bảng


Tải một đoạn sử dụng chức năng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
852 để lấy các phần của nó. Mỗi cuộc gọi đến
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
852 phải trả về một chuỗi nối với các kết quả trước đó. Việc trả về một chuỗi rỗng, nil hoặc không có giá trị báo hiệu sự kết thúc của đoạn

Nếu không có lỗi, hãy trả về đoạn đã biên dịch dưới dạng một hàm; . Môi trường của hàm trả về là môi trường toàn cầu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
404 được sử dụng làm tên đoạn cho thông báo lỗi và thông tin gỡ lỗi. Khi vắng mặt, nó mặc định là "______7080"


Tương tự như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
750, nhưng lấy đoạn từ tệp
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
651 hoặc từ đầu vào tiêu chuẩn, nếu không có tên tệp nào được cung cấp


Tương tự như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
750, nhưng lấy đoạn từ chuỗi đã cho

Để tải và chạy một chuỗi nhất định, hãy sử dụng thành ngữ

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
46

Khi vắng mặt,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
404 mặc định là chuỗi đã cho


Cho phép chương trình duyệt qua tất cả các trường của bảng. Đối số đầu tiên của nó là một bảng và đối số thứ hai của nó là một chỉ mục trong bảng này.

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
085 trả về chỉ mục tiếp theo của bảng và giá trị được liên kết của nó. Khi được gọi với nil làm đối số thứ hai,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
085 trả về một chỉ mục ban đầu và giá trị liên quan của nó. Khi được gọi với chỉ mục cuối cùng hoặc với nil trong một bảng trống,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
085 trả về nil. Nếu đối số thứ hai vắng mặt, thì nó được hiểu là không. Đặc biệt, bạn có thể sử dụng
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
088 để kiểm tra xem một bảng có trống không

Thứ tự mà các chỉ số được liệt kê không được chỉ định, ngay cả đối với các chỉ số số. (Để duyệt qua một bảng theo thứ tự số, hãy sử dụng một số cho hoặc hàm

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
089. )

Hành vi của

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
085 không được xác định nếu trong quá trình truyền tải, bạn chỉ định bất kỳ giá trị nào cho trường không tồn tại trong bảng. Tuy nhiên, bạn có thể sửa đổi các trường hiện có. Cụ thể, bạn có thể xóa các trường hiện có


Trả về ba giá trị. hàm

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
085, bảng
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768 và nil, do đó việc xây dựng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
47

sẽ lặp qua tất cả các cặp khóa-giá trị của bảng

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768

Xem chức năng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
085 để biết trước việc sửa đổi bảng trong quá trình truyền tải


Gọi hàm

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 với các đối số đã cho ở chế độ được bảo vệ. Điều này có nghĩa là bất kỳ lỗi nào bên trong
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 đều không được lan truyền; . Kết quả đầu tiên của nó là mã trạng thái (boolean), điều này đúng nếu cuộc gọi thành công mà không có lỗi. Trong trường hợp như vậy,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
712 cũng trả về tất cả kết quả từ cuộc gọi, sau kết quả đầu tiên này. Trong trường hợp có bất kỳ lỗi nào,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
712 trả về false cộng với thông báo lỗi


Nhận bất kỳ số lượng đối số nào và in các giá trị của chúng thành
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
100, sử dụng hàm
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
101 để chuyển đổi chúng thành chuỗi.
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
102 không dành cho đầu ra được định dạng mà chỉ là một cách nhanh chóng để hiển thị một giá trị, thường là để gỡ lỗi. Đối với đầu ra được định dạng, hãy sử dụng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
98
Kiểm tra xem
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
104 có bằng
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
105 hay không mà không cần gọi bất kỳ siêu phương thức nào. Trả về một boolean
Nhận giá trị thực của
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
106 mà không cần gọi bất kỳ siêu dữ liệu nào.
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
107 phải là một bảng;
Đặt giá trị thực của
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
106 thành
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
110 mà không cần gọi bất kỳ siêu dữ liệu nào.
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
107 phải là một bảng,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
903 bất kỳ giá trị nào khác với nil và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
110 bất kỳ giá trị Lua nào

Hàm này trả về

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
107


Nếu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
903 là một số, trả về tất cả các đối số sau số đối số
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
903. Mặt khác,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
903 phải là chuỗi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
118 và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
119 trả về tổng số đối số bổ sung mà nó nhận được


Đặt môi trường được sử dụng bởi hàm đã cho.

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 có thể là một hàm Lua hoặc một số chỉ định hàm ở cấp độ ngăn xếp đó. Cấp 1 là chức năng gọi
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
705.
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
705 trả về hàm đã cho

Trong trường hợp đặc biệt, khi

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 bằng 0 thì
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
705 sẽ thay đổi môi trường của luồng đang chạy. Trong trường hợp này,
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
705 không trả về giá trị nào


Đặt metatable cho bảng đã cho. (Bạn không thể thay đổi metatable của các loại khác từ Lua, chỉ từ C. ) Nếu

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
126 bằng 0, hãy xóa metatable của bảng đã cho. Nếu metatable ban đầu có trường
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
073, sẽ phát sinh lỗi

Hàm này trả về

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
107


Cố gắng chuyển đổi đối số của nó thành một số. Nếu đối số đã là một số hoặc một chuỗi có thể chuyển đổi thành một số, thì
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
720 trả về số này;

Một đối số tùy chọn chỉ định cơ sở để diễn giải số. Cơ sở có thể là bất kỳ số nguyên nào trong khoảng từ 2 đến 36, bao gồm cả. Trong các cơ sở trên 10, chữ cái '

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
130' (viết hoa hoặc viết thường) đại diện cho 10, '_______5375' đại diện cho 11, v.v., với '
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
132' đại diện cho 35. Trong cơ số 10 (mặc định), số có thể có phần thập phân, cũng như phần số mũ tùy chọn (xem §2. 1). Trong các cơ sở khác, chỉ các số nguyên không dấu được chấp nhận


Nhận một đối số thuộc bất kỳ loại nào và chuyển đổi nó thành một chuỗi ở định dạng hợp lý. Để kiểm soát hoàn toàn cách các số được chuyển đổi, hãy sử dụng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
98

Nếu siêu dữ liệu của

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
811 có trường
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
135, thì
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
101 gọi giá trị tương ứng với đối số là
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
811 và sử dụng kết quả của lệnh gọi làm kết quả


Trả về loại đối số duy nhất của nó, được mã hóa dưới dạng một chuỗi. Các kết quả có thể có của hàm này là "
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
138" (một chuỗi, không phải giá trị nil), "
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
139", "
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
140", "
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
141", "
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
107", "
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
440", "
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
144" và "
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
145"
Trả về các phần tử từ bảng đã cho. Hàm này tương đương với
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
48

ngoại trừ đoạn mã trên chỉ có thể được viết cho một số phần tử cố định. Theo mặc định,

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
715 là 1 và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
147 là độ dài của danh sách, như được xác định bởi toán tử độ dài (xem §2. 5. 5)


Biến toàn cục (không phải hàm) chứa chuỗi chứa phiên bản trình thông dịch hiện tại. Nội dung hiện tại của biến này là "
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
148"

Chức năng này tương tự như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
712, ngoại trừ việc bạn có thể đặt trình xử lý lỗi mới

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
150 gọi hàm
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 ở chế độ được bảo vệ, sử dụng
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
152 làm trình xử lý lỗi. Bất kỳ lỗi nào bên trong
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 đều không được lan truyền; . Kết quả đầu tiên của nó là mã trạng thái (boolean), điều này đúng nếu cuộc gọi thành công mà không có lỗi. Trong trường hợp này,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
150 cũng trả về tất cả các kết quả từ cuộc gọi, sau kết quả đầu tiên này. Trong trường hợp có bất kỳ lỗi nào,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
150 trả về false cộng với kết quả từ
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
152

Các hoạt động liên quan đến coroutines bao gồm một thư viện con của thư viện cơ bản và nằm trong bảng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
159. Xem §2. 11 để biết mô tả chung về coroutines


Tạo một coroutine mới, với phần thân

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742.
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 phải là một hàm Lua. Trả về coroutine mới này, một đối tượng có loại
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
162


Bắt đầu hoặc tiếp tục thực thi quy trình đăng quang

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
163. Lần đầu tiên bạn tiếp tục một coroutine, nó sẽ bắt đầu chạy phần thân của nó. Các giá trị
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
164, ··· được truyền dưới dạng đối số cho hàm body. Nếu quy trình đăng ký đã mang lại kết quả,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
165 sẽ khởi động lại nó;

Nếu coroutine chạy mà không có bất kỳ lỗi nào,

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
165 trả về true cộng với bất kỳ giá trị nào được chuyển đến
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
490 (nếu coroutine mang lại lợi nhuận) hoặc bất kỳ giá trị nào được trả về bởi hàm body (nếu coroutine kết thúc). Nếu có bất kỳ lỗi nào,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
165 trả về false cộng với thông báo lỗi


Trả về coroutine đang chạy hoặc nil khi được gọi bởi luồng chính


Trả về trạng thái của quy trình đăng ký

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
163, dưới dạng một chuỗi.
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
171, nếu coroutine đang chạy (tức là, nó được gọi là
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
172);


Tạo một coroutine mới, với phần thân

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742.
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742 phải là một hàm Lua. Trả về một chức năng tiếp tục coroutine mỗi khi nó được gọi. Bất kỳ đối số nào được chuyển đến hàm sẽ hoạt động như các đối số phụ cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
165. Trả về các giá trị tương tự được trả về bởi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
165, ngoại trừ giá trị boolean đầu tiên. Trong trường hợp có lỗi, lan truyền lỗi


Đình chỉ việc thực hiện cuộc gọi coroutine. Coroutine không được chạy hàm C, metamethod hoặc iterator. Bất kỳ đối số nào đối với

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
490 đều được chuyển dưới dạng kết quả bổ sung cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
165

Thư viện gói cung cấp các phương tiện cơ bản để tải và xây dựng các mô-đun trong Lua. Nó xuất hai chức năng của nó trực tiếp trong môi trường toàn cầu.

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
184. Mọi thứ khác được xuất trong một bảng
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
185


Tạo một mô-đun. Nếu có một bảng trong

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
186, thì bảng này là mô-đun. Mặt khác, nếu có một bảng toàn cục
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768 với tên đã cho, thì bảng này là mô-đun. Mặt khác, tạo một bảng mới
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768 và đặt nó làm giá trị của
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
888 toàn cầu và giá trị của
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
186. Hàm này cũng khởi tạo
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
191 với tên đã cho,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
192 với mô-đun (chính
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768) và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
194 với tên gói (tên đầy đủ của mô-đun trừ đi thành phần cuối cùng; xem bên dưới). Cuối cùng,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
184 đặt
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768 làm môi trường mới của hàm hiện tại và giá trị mới của
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
186, để
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 trả về
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768

Nếu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
888 là một tên ghép (nghĩa là một tên có các thành phần được phân tách bằng dấu chấm), thì
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
184 sẽ tạo (hoặc sử dụng lại, nếu chúng đã tồn tại) bảng cho từng thành phần. Chẳng hạn, nếu
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
888 là
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
203, thì
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
184 lưu bảng mô-đun trong trường
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
374 của trường
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
435 của
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
87 toàn cầu

Chức năng này có thể nhận các tùy chọn tùy chọn sau tên mô-đun, trong đó mỗi tùy chọn là một chức năng được áp dụng trên mô-đun


Tải mô-đun đã cho. Hàm bắt đầu bằng cách xem bảng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
208 để xác định xem
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
209 đã được tải chưa. Nếu đúng như vậy, thì
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 trả về giá trị được lưu trữ tại
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
211. Mặt khác, nó sẽ cố gắng tìm một trình tải cho mô-đun

Để tìm bộ tải,

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 được hướng dẫn bởi mảng
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
213. Bằng cách thay đổi mảng này, chúng ta có thể thay đổi cách
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 tìm kiếm một mô-đun. Giải thích sau đây dựa trên cấu hình mặc định cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
213

Truy vấn

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 đầu tiên
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
217. Nếu nó có một giá trị, thì giá trị này (phải là một hàm) là trình tải. Mặt khác,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 tìm kiếm trình tải Lua bằng đường dẫn được lưu trữ trong
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
219. Nếu điều đó cũng không thành công, nó sẽ tìm kiếm trình tải C bằng đường dẫn được lưu trữ trong
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
220. Nếu điều đó cũng không thành công, nó sẽ thử trình tải tất cả trong một (xem
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
213)

Sau khi tìm thấy trình tải,

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 gọi trình tải bằng một đối số duy nhất,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
209. Nếu bộ nạp trả về bất kỳ giá trị nào, thì
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 sẽ gán giá trị được trả về cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
211. Nếu trình tải không trả về giá trị nào và chưa gán bất kỳ giá trị nào cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
211, thì
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 sẽ gán true cho mục nhập này. Trong mọi trường hợp,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 trả về giá trị cuối cùng của
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
211

Nếu có bất kỳ lỗi nào khi tải hoặc chạy mô-đun hoặc nếu nó không thể tìm thấy bất kỳ trình tải nào cho mô-đun, thì

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 báo hiệu lỗi


Đường dẫn được sử dụng bởi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 để tìm kiếm trình tải C

Lua khởi tạo đường dẫn C

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
220 giống như cách nó khởi tạo đường dẫn Lua
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
219, sử dụng biến môi trường
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
234 hoặc đường dẫn mặc định được xác định trong
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
92


Một bảng được sử dụng bởi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 để kiểm soát những mô-đun nào đã được tải. Khi bạn yêu cầu một mô-đun
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
209 và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
211 không sai,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 chỉ cần trả về giá trị được lưu trữ ở đó


Một bảng được sử dụng bởi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 để kiểm soát cách tải các mô-đun

Mỗi mục trong bảng này là một chức năng tìm kiếm. Khi tìm kiếm một mô-đun,

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 gọi từng trình tìm kiếm này theo thứ tự tăng dần, với tên mô-đun (đối số được cung cấp cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183) làm tham số duy nhất của nó. Hàm có thể trả về một hàm khác (trình tải mô-đun) hoặc một chuỗi giải thích lý do tại sao nó không tìm thấy mô-đun đó (hoặc không nếu nó không có gì để nói). Lua khởi tạo bảng này với bốn chức năng

Người tìm kiếm đầu tiên chỉ cần tìm một trình tải trong bảng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
243

Người tìm kiếm thứ hai tìm kiếm trình tải dưới dạng thư viện Lua, sử dụng đường dẫn được lưu trữ tại

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
219. Đường dẫn là một chuỗi các mẫu được phân tách bằng dấu chấm phẩy. Đối với mỗi mẫu, người tìm kiếm sẽ thay đổi từng dấu hỏi trong mẫu bằng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
651, là tên mô-đun với mỗi dấu chấm được thay thế bằng "dấu phân cách thư mục" (chẳng hạn như "
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
749" trong Unix); . Vì vậy, ví dụ, nếu đường dẫn Lua là chuỗi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
49

việc tìm kiếm tệp Lua cho mô-đun

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
247 sẽ cố gắng mở các tệp
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
248,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
249 và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
250 theo thứ tự đó

Người tìm kiếm thứ ba tìm kiếm trình tải dưới dạng thư viện C, sử dụng đường dẫn được cung cấp bởi biến

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
220. Chẳng hạn, nếu đường dẫn C là chuỗi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
50

người tìm kiếm mô-đun

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
247 sẽ cố mở các tệp
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
253,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
254 và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
255 theo thứ tự đó. Sau khi tìm thấy thư viện C, người tìm kiếm này trước tiên sử dụng tiện ích liên kết động để liên kết ứng dụng với thư viện. Sau đó, nó cố gắng tìm một hàm C bên trong thư viện để sử dụng làm trình tải. Tên của hàm C này là chuỗi "______7256" được nối với một bản sao của tên mô-đun trong đó mỗi dấu chấm được thay thế bằng dấu gạch dưới. Ngoài ra, nếu tên mô-đun có dấu gạch nối, tiền tố của nó cho đến (và bao gồm) dấu gạch nối đầu tiên sẽ bị xóa. Chẳng hạn, nếu tên mô-đun là
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
257, tên hàm sẽ là
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
258

Người tìm kiếm thứ tư thử trình tải tất cả trong một. Nó tìm kiếm thư viện trong đường dẫn C để tìm tên gốc của mô-đun đã cho. Chẳng hạn, khi yêu cầu

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
203, nó sẽ tìm kiếm thư viện C cho
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
87. Nếu tìm thấy, nó sẽ xem xét nó để tìm một chức năng mở cho mô hình con; . Với cơ sở này, một gói có thể đóng gói một số mô-đun con C vào một thư viện duy nhất, với mỗi mô-đun con giữ chức năng mở ban đầu của nó


Tự động liên kết chương trình máy chủ với thư viện C

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
009. Trong thư viện này, hãy tìm hàm
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
263 và trả về hàm này dưới dạng hàm C. (Vì vậy,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
263 phải tuân theo giao thức (xem
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
785))

Đây là một chức năng cấp thấp. Nó hoàn toàn bỏ qua hệ thống gói và mô-đun. Không giống như

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183, nó không thực hiện bất kỳ tìm kiếm đường dẫn nào và không tự động thêm tiện ích mở rộng.
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
009 phải là tên tệp hoàn chỉnh của thư viện C, bao gồm cả đường dẫn và phần mở rộng nếu cần.
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
263 phải là tên chính xác được xuất bởi thư viện C (có thể phụ thuộc vào trình biên dịch C và trình liên kết được sử dụng)

Chức năng này không được hỗ trợ bởi ANSI C. Do đó, nó chỉ khả dụng trên một số nền tảng (Windows, Linux, Mac OS X, Solaris, BSD, cùng với các hệ thống Unix khác hỗ trợ tiêu chuẩn

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
269)


Đường dẫn được sử dụng bởi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183 để tìm kiếm trình tải Lua

Khi khởi động, Lua khởi tạo biến này với giá trị của biến môi trường

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
271 hoặc với đường dẫn mặc định được xác định trong
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
92, nếu biến môi trường không được xác định. Bất kỳ "
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
711" nào trong giá trị của biến môi trường được thay thế bằng đường dẫn mặc định


Một bảng để lưu trữ các bộ tải cho các mô-đun cụ thể (xem

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
183)


Đặt một siêu dữ liệu cho

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
184 với trường
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
276 của nó đề cập đến môi trường toàn cầu, để mô-đun này kế thừa các giá trị từ môi trường toàn cầu. Được sử dụng như một tùy chọn để hoạt động
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
184

Thư viện này cung cấp các hàm chung để thao tác chuỗi, chẳng hạn như tìm và trích xuất các chuỗi con và so khớp mẫu. Khi lập chỉ mục một chuỗi trong Lua, ký tự đầu tiên ở vị trí 1 (không phải vị trí 0, như trong C). Các chỉ số được phép âm và được hiểu là lập chỉ mục ngược, từ cuối chuỗi. Do đó, ký tự cuối cùng ở vị trí -1, v.v.

Thư viện chuỗi cung cấp tất cả các chức năng của nó bên trong bảng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
140. Nó cũng đặt một metatable cho các chuỗi trong đó trường
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
276 trỏ đến bảng
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
140. Do đó, bạn có thể sử dụng các hàm chuỗi theo kiểu hướng đối tượng. Chẳng hạn,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
281 có thể được viết là
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
282

Thư viện chuỗi giả định mã hóa ký tự một byte


Trả về mã số nội bộ của các ký tự
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
283,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
284, ···,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
285. Giá trị mặc định cho
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
715 là 1;

Lưu ý rằng mã số không nhất thiết phải di động trên các nền tảng


Nhận không hoặc nhiều số nguyên. Trả về một chuỗi có độ dài bằng số lượng đối số, trong đó mỗi ký tự có mã số bên trong bằng với đối số tương ứng của nó

Lưu ý rằng mã số không nhất thiết phải di động trên các nền tảng


Trả về một chuỗi chứa biểu diễn nhị phân của hàm đã cho, sao cho sau đó,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
749 trên chuỗi này sẽ trả về một bản sao của hàm.
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
440 phải là một hàm Lua không có giá trị gia tăng


Tìm kiếm trận đấu đầu tiên của
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
291 trong chuỗi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456. Nếu tìm thấy kết quả trùng khớp, thì
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
293 trả về các chỉ số của 
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 nơi sự kiện này bắt đầu và kết thúc; . Đối số số thứ ba, tùy chọn
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
295 chỉ định nơi bắt đầu tìm kiếm; . Giá trị true làm đối số thứ tư, tùy chọn
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
296 sẽ tắt các tiện ích so khớp mẫu, do đó, hàm thực hiện thao tác "tìm chuỗi con" đơn giản, không có ký tự nào trong
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
291 được coi là "phép thuật". Lưu ý rằng nếu cung cấp
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
296 thì cũng phải cung cấp
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
295

Nếu mẫu đã chụp, thì khi khớp thành công, các giá trị đã chụp cũng được trả về, sau hai chỉ số


Trả về phiên bản đã định dạng của số lượng đối số thay đổi theo mô tả được đưa ra trong đối số đầu tiên của nó (phải là một chuỗi). Chuỗi định dạng tuân theo các quy tắc giống như họ hàm
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
300 của C tiêu chuẩn. Sự khác biệt duy nhất là các tùy chọn/công cụ sửa đổi
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
748,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
313,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
463,
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
803 và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
306 không được hỗ trợ và có một tùy chọn bổ sung,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
307. Tùy chọn
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
307 định dạng một chuỗi ở dạng phù hợp để trình thông dịch Lua đọc lại một cách an toàn. chuỗi được viết giữa dấu ngoặc kép và tất cả dấu ngoặc kép, dòng mới, số 0 được nhúng và dấu gạch chéo ngược trong chuỗi được thoát chính xác khi được viết. Chẳng hạn, cuộc gọi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
51

sẽ tạo ra chuỗi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
52

Các tùy chọn

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
374,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
671,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
311,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
811,
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
314,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
315,
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
715,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
802,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
315,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
319 và
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 đều mong đợi một số làm đối số, trong khi đó
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
307 và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 mong đợi một chuỗi

Hàm này không chấp nhận các giá trị chuỗi chứa các số 0 được nhúng, ngoại trừ các đối số cho tùy chọn

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
307


Trả về một hàm lặp, mỗi lần nó được gọi, sẽ trả về các lần chụp tiếp theo từ
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
291 qua chuỗi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456. Nếu
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
291 chỉ định không chụp, thì toàn bộ trận đấu được tạo ra trong mỗi cuộc gọi

Ví dụ, vòng lặp sau

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
53

sẽ lặp lại tất cả các từ trong chuỗi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456, in một từ trên mỗi dòng. Ví dụ tiếp theo thu thập tất cả các cặp
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
328 từ chuỗi đã cho vào một bảng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
54

Đối với chức năng này, '

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
751' ở đầu mẫu không hoạt động như một điểm neo, vì điều này sẽ ngăn quá trình lặp lại


Trả về một bản sao của
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 trong đó tất cả (hoặc
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 đầu tiên, nếu được cung cấp) của
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
291 đã được thay thế bằng một chuỗi thay thế được chỉ định bởi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
333, có thể là một chuỗi, một bảng hoặc một hàm.
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
334 cũng trả về, như giá trị thứ hai của nó, tổng số trận đấu đã xảy ra

Nếu

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
333 là một chuỗi thì giá trị của nó được dùng để thay thế. Ký tự
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
750 hoạt động như một ký tự thoát. bất kỳ chuỗi nào trong
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
333 có dạng
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
338, với n nằm trong khoảng từ 1 đến 9, là viết tắt của giá trị của chuỗi con được bắt thứ n (xem bên dưới). Dãy
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
339 là viết tắt của cả trận. Trình tự _______4444 là viết tắt của một ______2750

Nếu

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
333 là một bảng, thì bảng được truy vấn cho mọi kết quả khớp, sử dụng lần chụp đầu tiên làm khóa;

Nếu

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
333 là một hàm, thì hàm này được gọi mỗi khi khớp xảy ra, với tất cả các chuỗi con đã bắt được chuyển dưới dạng đối số, theo thứ tự;

Nếu giá trị được trả về bởi truy vấn bảng hoặc bởi lệnh gọi hàm là một chuỗi hoặc một số, thì giá trị đó được sử dụng làm chuỗi thay thế;

Dưới đây là một số ví dụ

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
55
Nhận một chuỗi và trả về độ dài của nó. Chuỗi rỗng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
993 có độ dài 0. Các số 0 nhúng được tính, vì vậy
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
345 có độ dài 5
Nhận một chuỗi và trả về một bản sao của chuỗi này với tất cả các chữ hoa được đổi thành chữ thường. Tất cả các ký tự khác không thay đổi. Định nghĩa về chữ hoa là gì tùy thuộc vào ngôn ngữ hiện tại
Tìm kiếm trận đấu đầu tiên của
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
291 trong chuỗi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456. Nếu tìm thấy, thì
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
348 trả về các ảnh chụp được từ mẫu; . Nếu
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
291 chỉ định không có ảnh chụp nào, thì toàn bộ kết quả khớp sẽ được trả về. Đối số số thứ ba, tùy chọn
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
295 chỉ định nơi bắt đầu tìm kiếm;
Trả về một chuỗi là nối của các bản sao của
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 của chuỗi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456
Trả về một chuỗi là chuỗi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 bị đảo ngược
Trả về chuỗi con của
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 bắt đầu từ
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
715 và tiếp tục cho đến
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
147; . Nếu không có
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
147, thì nó được coi là bằng -1 (bằng với độ dài chuỗi). Cụ thể, cuộc gọi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
360 trả về tiền tố của
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 với độ dài
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
147 và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
363 trả về hậu tố của
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
456 với độ dài
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
715
Nhận một chuỗi và trả về một bản sao của chuỗi này với tất cả các chữ thường được đổi thành chữ hoa. Tất cả các ký tự khác không thay đổi. Định nghĩa về chữ thường là gì tùy thuộc vào ngôn ngữ hiện tại

lớp nhân vật

Một lớp ký tự được sử dụng để đại diện cho một tập hợp các ký tự. Các kết hợp sau đây được phép mô tả một lớp ký tự

  • x. (trong đó x không phải là một trong các ký tự ma thuật
         +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    366) đại diện cho chính ký tự x
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    367. (một dấu chấm) đại diện cho tất cả các ký tự
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    368. đại diện cho tất cả các chữ cái
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    452. đại diện cho tất cả các ký tự điều khiển
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    450. đại diện cho tất cả các chữ số
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    371. đại diện cho tất cả các chữ thường
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    449. đại diện cho tất cả các ký tự dấu câu
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    446. đại diện cho tất cả các ký tự khoảng trắng
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    374. đại diện cho tất cả các chữ hoa
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    375. đại diện cho tất cả các ký tự chữ và số
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    376. đại diện cho tất cả các chữ số thập lục phân
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    377. đại diện cho ký tự với đại diện 0
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    378. (trong đó x là bất kỳ ký tự không phải chữ và số nào) đại diện cho ký tự x. Đây là cách tiêu chuẩn để thoát khỏi các ký tự ma thuật. Bất kỳ ký tự dấu chấm câu nào (ngay cả ký tự không phải phép thuật) đều có thể đứng trước '
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    750' khi được sử dụng để thể hiện chính nó trong một mẫu
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    380. đại diện cho lớp là sự kết hợp của tất cả các ký tự trong tập hợp. Một phạm vi ký tự có thể được chỉ định bằng cách tách các ký tự cuối của phạm vi bằng '
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    747'. Tất cả các lớp
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    750x được mô tả ở trên cũng có thể được sử dụng làm thành phần trong bộ. Tất cả các ký tự khác trong bộ đại diện cho chính họ. Ví dụ:
         +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    383 (hoặc
         +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    384) đại diện cho tất cả các ký tự chữ và số cộng với dấu gạch dưới,
         +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    385 đại diện cho các chữ số bát phân và
         +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    386 đại diện cho các chữ số bát phân cộng với các chữ cái viết thường cộng với ký tự '
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    747'

    Sự tương tác giữa các phạm vi và các lớp không được xác định. Do đó, các mẫu như

         +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    388 hoặc
         +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    389 không có ý nghĩa

  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    390. đại diện cho phần bù của tập hợp, trong đó tập hợp được hiểu như trên

Đối với tất cả các lớp được đại diện bởi các chữ cái đơn lẻ (______7368,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
452, v.v. ), chữ hoa tương ứng biểu thị phần bù của lớp. Chẳng hạn,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
393 đại diện cho tất cả các ký tự không phải khoảng trắng

Các định nghĩa về chữ cái, dấu cách và các nhóm ký tự khác phụ thuộc vào ngôn ngữ hiện tại. Đặc biệt, lớp

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
394 có thể không tương đương với
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
371

Mục mẫu

Một mục mẫu có thể được

  • một lớp ký tự đơn, khớp với bất kỳ ký tự đơn nào trong lớp;
  • một lớp ký tự duy nhất theo sau là '
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    748', khớp với 0 hoặc nhiều ký tự lặp lại trong lớp. Các mục lặp lại này sẽ luôn khớp với chuỗi dài nhất có thể;
  • một lớp ký tự duy nhất theo sau là '
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    746', khớp với 1 hoặc nhiều lần lặp lại ký tự trong lớp. Các mục lặp lại này sẽ luôn khớp với chuỗi dài nhất có thể;
  • một lớp ký tự duy nhất theo sau là '
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    747', cũng khớp với 0 hoặc nhiều ký tự lặp lại trong lớp. Không giống như '
         and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    748', các mục lặp lại này sẽ luôn khớp với trình tự ngắn nhất có thể;
  • một lớp ký tự duy nhất theo sau là '
         a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    807', khớp với 0 hoặc 1 lần xuất hiện của một ký tự trong lớp;
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    338, cho n từ 1 đến 9;
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    402, trong đó x và y là hai ký tự riêng biệt; . Điều này có nghĩa là, nếu một người đọc chuỗi từ trái sang phải, đếm +1 cho x và -1 cho y, thì y kết thúc là y đầu tiên mà số đếm tiến tới 0. Chẳng hạn, mục
         +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    403 khớp với các biểu thức có dấu ngoặc đơn cân đối

Họa tiết

Một mẫu là một chuỗi các mục mẫu. Một '

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
751' ở đầu một mẫu neo khớp ở đầu chuỗi chủ đề. Một '
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
405' ở cuối mẫu neo kết quả khớp ở cuối chuỗi chủ đề. Ở các vị trí khác, '
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
751' và '______7405' không có ý nghĩa đặc biệt và tự đại diện

chụp

Một mẫu có thể chứa các mẫu con được đặt trong dấu ngoặc đơn; . Khi khớp thành công, các chuỗi con của chuỗi chủ đề khớp với ảnh chụp được lưu trữ (đã chụp) để sử dụng trong tương lai. Ảnh chụp được đánh số theo dấu ngoặc đơn bên trái của chúng. Chẳng hạn, trong mẫu

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
408, một phần của chuỗi khớp với
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
409 được lưu trữ dưới dạng lần chụp đầu tiên (và do đó có số 1);

Trong trường hợp đặc biệt, bản ghi trống

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
412 ghi lại vị trí chuỗi hiện tại (một số). Chẳng hạn, nếu chúng ta áp dụng mẫu
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
413 trên chuỗi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
414, sẽ có hai lần chụp. 3 và 5

Một mẫu không thể chứa các số 0 được nhúng. Sử dụng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
377 để thay thế

Thư viện này cung cấp các chức năng chung cho thao tác bảng. Nó cung cấp tất cả các chức năng của nó bên trong bảng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
107

Hầu hết các hàm trong thư viện bảng giả định rằng bảng đại diện cho một mảng hoặc một danh sách. Đối với các hàm này, khi chúng ta nói về "độ dài" của bảng, chúng ta muốn nói đến kết quả của toán tử độ dài


Đưa ra một mảng trong đó tất cả các phần tử là chuỗi hoặc số, trả về
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
417. Giá trị mặc định cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
418 là chuỗi rỗng, mặc định cho
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
715 là 1 và mặc định cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
147 là độ dài của bảng. Nếu
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
715 lớn hơn
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
147, trả về chuỗi rỗng

Chèn phần tử

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
110 vào vị trí
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
424 trong
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
107, dịch chuyển các phần tử khác lên khoảng trống, nếu cần. Giá trị mặc định cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
424 là
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
427, trong đó
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 là độ dài của bảng (xem §2. 5. 5), sao cho lệnh gọi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
429 chèn
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 vào cuối bảng
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768


Trả về chỉ số số dương lớn nhất của bảng đã cho hoặc 0 nếu bảng không có chỉ số số dương. (Để thực hiện công việc của mình, hàm này thực hiện duyệt tuyến tính toàn bộ bảng. )


Xóa khỏi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
107 phần tử ở vị trí
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
424, dịch chuyển các phần tử khác xuống để đóng khoảng trống, nếu cần. Trả về giá trị của phần tử đã loại bỏ. Giá trị mặc định cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
424 là
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769, trong đó
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 là độ dài của bảng, do đó lệnh gọi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
437 sẽ loại bỏ phần tử cuối cùng của bảng
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
768


Sắp xếp các phần tử của bảng theo thứ tự nhất định, tại chỗ, từ
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
439 đến
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
440, trong đó
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769 là độ dài của bảng. Nếu
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
442 được đưa ra, thì đó phải là một hàm nhận hai phần tử bảng và trả về true khi phần tử đầu tiên nhỏ hơn phần tử thứ hai (do đó,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
443 sẽ là true sau khi sắp xếp). Nếu không cung cấp
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
442, thì toán tử Lua tiêu chuẩn
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
738 sẽ được sử dụng để thay thế

Thuật toán sắp xếp không ổn định;

Thư viện này là giao diện của thư viện C math tiêu chuẩn. Nó cung cấp tất cả các chức năng của nó bên trong bảng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
446


Trả về giá trị tuyệt đối của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706


Trả về cung cosin của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 (tính bằng radian)


Trả về cung sin của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 (tính bằng radian)


Trả về tang cung của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 (tính bằng radian)


Trả về tang cung của

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
451 (tính bằng radian), nhưng sử dụng dấu của cả hai tham số để tìm góc tọa độ của kết quả. (Nó cũng xử lý chính xác trường hợp
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 bằng 0. )


Trả về số nguyên nhỏ nhất lớn hơn hoặc bằng

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706


Trả về cosin của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 (được cho là tính bằng radian)


Trả về cosin hyperbol của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706


Trả về góc

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 (tính bằng radian) theo độ


Trả về giá trị cũ


Trả về số nguyên lớn nhất nhỏ hơn hoặc bằng

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706


Trả về phần còn lại của phép chia của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 cho
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
718 làm tròn thương số về 0


Trả về

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
810 và
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
811 sao cho x = m2e,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
811 là số nguyên và giá trị tuyệt đối của
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
810 nằm trong khoảng [0. 5, 1) (hoặc 0 khi
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 bằng 0)


Giá trị

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
465, một giá trị lớn hơn hoặc bằng bất kỳ giá trị số nào khác


Trả về m2e (

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
811 phải là số nguyên)


Trả về logarit tự nhiên của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706


Trả về logarit cơ số 10 của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706


Trả về giá trị lớn nhất trong số các đối số của nó


Trả về giá trị nhỏ nhất trong số các đối số của nó


Trả về hai số, phần nguyên của ________ 2706 và phần phân số của ________ 2706


giá trị của pi


Trả về xy. (Bạn cũng có thể sử dụng biểu thức

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
471 để tính giá trị này. )


Trả về góc

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 (tính theo độ) tính bằng radian


Hàm này là giao diện của hàm tạo giả ngẫu nhiên đơn giản

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
473 do ANSI C cung cấp. (Không thể đảm bảo cho các thuộc tính thống kê của nó. )

Khi được gọi mà không có đối số, trả về một số thực giả ngẫu nhiên thống nhất trong phạm vi [0,1). Khi được gọi với một số nguyên

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
810,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
475 trả về một số nguyên giả ngẫu nhiên thống nhất trong phạm vi [1, m]. Khi được gọi với hai số nguyên
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
810 và
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
769,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
475 trả về một số nguyên giả ngẫu nhiên thống nhất trong phạm vi [m, n]


Đặt

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 làm "hạt giống" cho trình tạo giả ngẫu nhiên. các hạt giống nhau tạo ra các chuỗi số bằng nhau


Trả về sin của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 (được cho là tính bằng radian)


Trả về sin hyperbol của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706


Trả về căn bậc hai của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706. (Bạn cũng có thể sử dụng biểu thức
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
483 để tính giá trị này. )


Trả về tang của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706 (được cho là tính bằng radian)


Trả về tang hyperbol của

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
706

Thư viện I/O cung cấp hai kiểu khác nhau để thao tác tệp. Cái đầu tiên sử dụng bộ mô tả tệp ẩn; . Kiểu thứ hai sử dụng các bộ mô tả tệp rõ ràng

Khi sử dụng bộ mô tả tệp ẩn, tất cả các hoạt động được cung cấp bởi bảng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
486. Khi sử dụng bộ mô tả tệp rõ ràng, hoạt động
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
487 trả về một bộ mô tả tệp và sau đó tất cả các hoạt động được cung cấp dưới dạng phương thức của bộ mô tả tệp

Bảng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
486 cũng cung cấp ba bộ mô tả tệp được xác định trước với ý nghĩa thông thường của chúng từ C.
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
489,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
490 và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
491. Thư viện I/O không bao giờ đóng các tệp này

Trừ khi có quy định khác, tất cả các chức năng I/O đều trả về 0 khi thất bại (cộng với thông báo lỗi ở kết quả thứ hai và mã lỗi phụ thuộc vào hệ thống ở kết quả thứ ba) và một số giá trị khác với 0 khi thành công


Tương đương với

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
492. Không có
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
493, hãy đóng tệp đầu ra mặc định


Tương đương với

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
494 trên tệp đầu ra mặc định


Khi được gọi với tên tệp, nó sẽ mở tệp được đặt tên (ở chế độ văn bản) và đặt tay cầm của nó làm tệp đầu vào mặc định. Khi được gọi với phần xử lý tệp, nó chỉ cần đặt phần xử lý tệp này làm tệp đầu vào mặc định. Khi được gọi mà không có tham số, nó sẽ trả về tệp đầu vào mặc định hiện tại

Trong trường hợp có lỗi, chức năng này sẽ báo lỗi thay vì trả về mã lỗi


Mở tên tệp đã cho ở chế độ đọc và trả về một hàm lặp, mỗi khi được gọi, nó sẽ trả về một dòng mới từ tệp. Vì vậy, việc xây dựng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
56

sẽ lặp lại trên tất cả các dòng của tệp. Khi hàm iterator phát hiện kết thúc tệp, nó trả về nil (để kết thúc vòng lặp) và tự động đóng tệp

Cuộc gọi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
495 (không có tên tệp) tương đương với
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
496; . Trong trường hợp này, nó không đóng tệp khi vòng lặp kết thúc


Hàm này mở một tệp, ở chế độ được chỉ định trong chuỗi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
497. Nó trả về một xử lý tệp mới hoặc, trong trường hợp có lỗi, không cộng với một thông báo lỗi

Chuỗi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
497 có thể là bất kỳ chuỗi nào sau đây

  • "r". chế độ đọc (mặc định);
  • "w". chế độ viết;
  • "một". chế độ nối thêm;
  • "r+". chế độ cập nhật, tất cả dữ liệu trước đó được giữ nguyên;
  • "w+". chế độ cập nhật, tất cả dữ liệu trước đó sẽ bị xóa;
  • "a+". chế độ cập nhật nối thêm, dữ liệu trước đó được giữ nguyên, chỉ được phép ghi ở cuối tệp

Chuỗi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
497 cũng có thể có '
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
435' ở cuối, cần thiết trong một số hệ thống để mở tệp ở chế độ nhị phân. Chuỗi này chính xác là chuỗi được sử dụng trong hàm C tiêu chuẩn
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
501


Tương tự như

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
502, nhưng hoạt động trên tệp đầu ra mặc định


Bắt đầu chương trình

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
503 trong một quy trình riêng biệt và trả về một điều khiển tệp mà bạn có thể sử dụng để đọc dữ liệu từ chương trình này (nếu
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
497 là
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
505, mặc định) hoặc để ghi dữ liệu vào chương trình này (nếu
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
497 là
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
507)

Chức năng này phụ thuộc vào hệ thống và không khả dụng trên tất cả các nền tảng


Tương đương với

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
508


Trả về một điều khiển cho một tập tin tạm thời. Tệp này được mở ở chế độ cập nhật và nó sẽ tự động bị xóa khi chương trình kết thúc


Kiểm tra xem

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
603 có phải là một tệp xử lý hợp lệ không. Trả về chuỗi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
510 nếu
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
603 là phần xử lý tệp mở,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
512 nếu
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
603 là phần xử lý tệp đóng hoặc nil nếu
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
603 không phải là phần xử lý tệp


Tương đương với

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
515


Đóng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
493. Lưu ý rằng các tệp sẽ tự động đóng khi phần xử lý của chúng được thu gom rác, nhưng điều đó sẽ mất một khoảng thời gian không thể đoán trước để xảy ra


Lưu mọi dữ liệu bằng văn bản vào

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
493


Trả về một hàm lặp mà mỗi khi nó được gọi, nó sẽ trả về một dòng mới từ tệp. Vì vậy, việc xây dựng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
57

sẽ lặp lại trên tất cả các dòng của tệp. (Không giống như

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
518, chức năng này không đóng tệp khi vòng lặp kết thúc. )


Đọc tệp

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
493, theo các định dạng đã cho, chỉ định nội dung cần đọc. Đối với mỗi định dạng, hàm trả về một chuỗi (hoặc một số) với các ký tự được đọc hoặc nil nếu nó không thể đọc dữ liệu với định dạng được chỉ định. Khi được gọi mà không có định dạng, nó sử dụng định dạng mặc định để đọc toàn bộ dòng tiếp theo (xem bên dưới)

Các định dạng có sẵn là

  • "*N". đọc một số;
  • "*một". đọc toàn bộ tập tin, bắt đầu từ vị trí hiện tại. Ở cuối tệp, nó trả về chuỗi rỗng
  • "*l". đọc dòng tiếp theo (bỏ qua cuối dòng), trả về nil ở cuối tệp. Đây là định dạng mặc định
  • con số. đọc một chuỗi có tối đa số ký tự này, trả về nil ở cuối tệp. Nếu số bằng 0, nó không đọc gì và trả về một chuỗi trống hoặc nil ở cuối tệp

Đặt và nhận vị trí tệp, được đo từ đầu tệp, đến vị trí được cung cấp bởi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
520 cộng với một cơ sở được chỉ định bởi chuỗi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
521, như sau

  • "bộ". cơ sở là vị trí 0 (đầu tệp);
  • "hay gây". cơ sở là vị trí hiện tại;
  • "chấm dứt". cơ sở là cuối tập tin;

Trong trường hợp thành công, hàm

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
522 trả về vị trí tệp cuối cùng, được đo bằng byte từ đầu tệp. Nếu chức năng này không thành công, nó sẽ trả về con số không, cộng với một chuỗi mô tả lỗi

Giá trị mặc định cho

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
521 là
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
524 và cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
520 là 0. Do đó, cuộc gọi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
526 trả về vị trí tệp hiện tại mà không thay đổi nó;


Đặt chế độ đệm cho tệp đầu ra. Có ba chế độ có sẵn

  • "không". không đệm;
  • "đầy". đệm đầy đủ;
  • "hàng". đệm dòng;

Đối với hai trường hợp cuối cùng,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
478 chỉ định kích thước của bộ đệm, tính bằng byte. Mặc định là một kích thước phù hợp


Ghi giá trị của từng đối số của nó vào

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
493. Các đối số phải là chuỗi hoặc số. Để viết các giá trị khác, hãy sử dụng
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
101 hoặc
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
98 trước
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
535

Thư viện này được thực hiện thông qua bảng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
536


Trả về giá trị xấp xỉ của số giây thời gian CPU mà chương trình sử dụng


Trả về một chuỗi hoặc một bảng chứa ngày và giờ, được định dạng theo chuỗi đã cho

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
97

Nếu có đối số

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
538, đây là lúc được định dạng (xem hàm
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
539 để biết mô tả về giá trị này). Mặt khác,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
540 định dạng thời gian hiện tại

Nếu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
97 bắt đầu bằng '
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
542', thì ngày được định dạng theo Giờ Phối hợp Quốc tế. Sau ký tự tùy chọn này, nếu
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
97 là chuỗi "
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
544", thì
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
540 trả về một bảng có các trường sau.
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
546 (bốn chữ số),
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
547 (1--12),
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
548 (1--31),
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
549 (0--23),
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
550 (0--59),
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
551 (0--61),
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
552 (ngày trong tuần,

Nếu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
97 không phải là "
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
544", thì
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
540 trả về ngày ở dạng chuỗi, được định dạng theo cùng quy tắc như hàm C _______7558

Khi được gọi mà không có đối số,

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
540 trả về biểu diễn ngày và giờ hợp lý tùy thuộc vào hệ thống máy chủ và ngôn ngữ hiện tại (nghĩa là,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
560 tương đương với
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
561)


Trả về số giây từ thời điểm

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
562 đến thời điểm
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
563. Trong POSIX, Windows và một số hệ thống khác, giá trị này chính xác là ____7563-
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
562


Chức năng này tương đương với chức năng C

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
566. Nó vượt qua
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
567 để được thực thi bởi hệ điều hành Shell. Nó trả về một mã trạng thái, phụ thuộc vào hệ thống. Nếu không có
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
567, thì nó trả về giá trị khác 0 nếu có shell và 0 nếu không có


Gọi hàm C

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
569, với một tùy chọn
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
570, để kết thúc chương trình máy chủ. Giá trị mặc định cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
570 là mã thành công


Trả về giá trị của biến môi trường quy trình

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
572 hoặc nil nếu biến không được xác định


Xóa tệp hoặc thư mục với tên đã cho. Thư mục phải trống để được gỡ bỏ. Nếu chức năng này không thành công, nó sẽ trả về con số không, cộng với một chuỗi mô tả lỗi


Đổi tên tệp hoặc thư mục có tên

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
573 thành
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
574. Nếu chức năng này không thành công, nó sẽ trả về con số không, cộng với một chuỗi mô tả lỗi


Đặt ngôn ngữ hiện tại của chương trình.

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
575 là một chuỗi chỉ định ngôn ngữ; .
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
577,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
578,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
579,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
580,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
581 hoặc
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
582; . Hàm trả về tên của ngôn ngữ mới hoặc nil nếu yêu cầu không thể được thực hiện

Nếu

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
575 là chuỗi trống, ngôn ngữ hiện tại được đặt thành ngôn ngữ gốc do triển khai xác định. Nếu
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
575 là chuỗi "
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
586", ngôn ngữ hiện tại được đặt thành ngôn ngữ C tiêu chuẩn

Khi được gọi với nil làm đối số đầu tiên, hàm này chỉ trả về tên của ngôn ngữ hiện tại cho danh mục đã cho


Trả về thời gian hiện tại khi được gọi mà không có đối số hoặc thời gian biểu thị ngày và giờ được chỉ định bởi bảng đã cho. Bảng này phải có các trường

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
546,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
547 và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
548 và có thể có các trường
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
549,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
550,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
551 và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
554 (để biết mô tả về các trường này, hãy xem hàm
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
594)

Giá trị được trả về là một số, có ý nghĩa tùy thuộc vào hệ thống của bạn. Trong POSIX, Windows và một số hệ thống khác, con số này đếm số giây kể từ thời điểm bắt đầu nhất định ("kỷ nguyên"). Trong các hệ thống khác, ý nghĩa không được chỉ định và số được trả về bởi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
538 chỉ có thể được sử dụng làm đối số cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
540 và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
597


Trả về một chuỗi có tên tệp có thể được sử dụng cho tệp tạm thời. Tệp phải được mở rõ ràng trước khi sử dụng và xóa rõ ràng khi không còn cần thiết

Trên một số hệ thống (POSIX), chức năng này cũng tạo một tệp có tên đó, để tránh rủi ro bảo mật. (Người khác có thể tạo tệp với quyền sai trong khoảng thời gian từ khi nhận tên đến khi tạo tệp. ) Bạn vẫn phải mở file để sử dụng và gỡ bỏ nó (ngay cả khi bạn không sử dụng nó)

Khi có thể, bạn có thể sử dụng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
598 để tự động xóa tệp khi chương trình kết thúc

Thư viện này cung cấp chức năng của giao diện gỡ lỗi cho các chương trình Lua. Bạn nên hết sức cẩn thận khi sử dụng thư viện này. Các chức năng được cung cấp ở đây chỉ nên được sử dụng để gỡ lỗi và các tác vụ tương tự, chẳng hạn như lập hồ sơ. Hãy chống lại sự cám dỗ để sử dụng chúng như một công cụ lập trình thông thường. chúng có thể rất chậm. Hơn nữa, một số chức năng này vi phạm một số giả định về mã Lua (e. g. , các biến cục bộ của một hàm không thể được truy cập từ bên ngoài hoặc các bảng siêu dữ liệu người dùng không thể thay đổi bằng mã Lua) và do đó có thể ảnh hưởng đến mã an toàn

Tất cả các chức năng trong thư viện này được cung cấp bên trong bảng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
599. Tất cả các chức năng hoạt động trên một luồng có một đối số đầu tiên tùy chọn là luồng sẽ hoạt động trên. Mặc định luôn là chủ đề hiện tại


Vào chế độ tương tác với người dùng, chạy từng chuỗi mà người dùng nhập. Sử dụng các lệnh đơn giản và các tiện ích sửa lỗi khác, người dùng có thể kiểm tra các biến cục bộ và toàn cục, thay đổi giá trị của chúng, đánh giá các biểu thức, v.v. Một dòng chỉ chứa từ

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
600 kết thúc chức năng này để người gọi tiếp tục thực hiện

Lưu ý rằng các lệnh cho

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
601 không được lồng vào nhau về mặt từ vựng trong bất kỳ chức năng nào và do đó không có quyền truy cập trực tiếp vào các biến cục bộ


Trả về môi trường của đối tượng
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
802

Trả về cài đặt hook hiện tại của luồng, dưới dạng ba giá trị. hàm móc hiện tại, mặt nạ móc hiện tại và số lượng móc hiện tại (như được đặt bởi hàm

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
603)


Trả về một bảng có thông tin về một chức năng. Bạn có thể cung cấp chức năng trực tiếp hoặc bạn có thể cung cấp một số dưới dạng giá trị của

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
440, có nghĩa là chức năng chạy ở cấp độ
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
440 của ngăn xếp cuộc gọi của chuỗi đã cho. cấp 0 là chức năng hiện tại (chính ____7606); . Nếu
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
440 là một số lớn hơn số hàm đang hoạt động, thì
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
606 trả về nil

Bảng được trả về có thể chứa tất cả các trường được trả về bởi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
964, với chuỗi
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
869 mô tả các trường cần điền vào. Mặc định cho
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
869 là lấy tất cả thông tin có sẵn, ngoại trừ bảng các dòng hợp lệ. Nếu có, tùy chọn '
     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
742' sẽ thêm trường có tên
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
852 với chính chức năng đó. Nếu có, tùy chọn '
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
463' sẽ thêm trường có tên
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
616 với bảng các dòng hợp lệ

Chẳng hạn, biểu thức

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
617 trả về một bảng có tên cho hàm hiện tại, nếu có thể tìm thấy một tên hợp lý và biểu thức
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
618 trả về một bảng có tất cả thông tin có sẵn về hàm
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
102


Hàm này trả về tên và giá trị của biến cục bộ có chỉ số

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
620 của hàm ở mức
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
062 của ngăn xếp. (Thông số đầu tiên hoặc biến cục bộ có chỉ số 1, v.v. cho đến biến cục bộ hoạt động cuối cùng. ) Hàm trả về nil nếu không có biến cục bộ với chỉ mục đã cho và gây ra lỗi khi được gọi với một giá trị nằm ngoài phạm vi của
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
062. (Bạn có thể gọi cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
623 để kiểm tra xem cấp độ có hợp lệ không. )

Tên biến bắt đầu bằng '

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
797' (mở ngoặc đơn) đại diện cho các biến nội bộ (biến điều khiển vòng lặp, biến tạm thời và cục bộ hàm C)


Trả về metatable của

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
072 đã cho hoặc nil nếu nó không có metatable


Trả về bảng đăng ký (xem §3. 5)


Hàm này trả về tên và giá trị của giá trị tăng với chỉ số

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
626 của hàm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
852. Hàm trả về nil nếu không có giá trị tăng với chỉ mục đã cho


Đặt môi trường của

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
072 đã cho thành
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
107 đã cho. Trả về
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
072


Đặt hàm đã cho dưới dạng hook. Chuỗi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
349 và số
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
354 mô tả thời điểm hook sẽ được gọi. Mặt nạ chuỗi có thể có các ký tự sau, với ý nghĩa đã cho

  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    633. hook được gọi mỗi khi Lua gọi một hàm;
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    505. cái móc được gọi mỗi khi Lua trở về từ một hàm;
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    635. móc được gọi mỗi khi Lua nhập một dòng mã mới

Với một

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
354 khác 0, hook được gọi sau mỗi lệnh của
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
354

Khi được gọi mà không có đối số,

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
603 sẽ tắt hook

Khi hook được gọi, tham số đầu tiên của nó là một chuỗi mô tả sự kiện đã kích hoạt cuộc gọi của nó.

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
639,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
640 (hoặc
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
641, khi mô phỏng quay lại từ cuộc gọi đuôi),
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
642 và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
643. Đối với các sự kiện dòng, hook cũng lấy số dòng mới làm tham số thứ hai. Bên trong hook, bạn có thể gọi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
606 với cấp độ 2 để biết thêm thông tin về hàm đang chạy (cấp độ 0 là hàm
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
606 và cấp độ 1 là hàm hook), trừ khi sự kiện là
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
641. Trong trường hợp này, Lua chỉ mô phỏng trả về và lệnh gọi tới ____7606 sẽ trả về dữ liệu không hợp lệ


Hàm này gán giá trị

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
110 cho biến cục bộ có chỉ số
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
620 của hàm ở mức
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
062 của ngăn xếp. Hàm trả về nil nếu không có biến cục bộ với chỉ mục đã cho và phát sinh lỗi khi được gọi với giá trị ngoài phạm vi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
062. (Bạn có thể gọi tới
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
606 để kiểm tra xem mức độ có hợp lệ không. ) Ngược lại, nó trả về tên của biến cục bộ


Đặt metatable cho

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
072 đã cho thành
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
107 đã cho (có thể là không)


Hàm này gán giá trị

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
110 cho giá trị tăng với chỉ số
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
626 của hàm
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
852. Hàm trả về nil nếu không có giá trị tăng với chỉ mục đã cho. Mặt khác, nó trả về tên của giá trị tăng


Trả về một chuỗi có dấu vết của ngăn xếp cuộc gọi. Một chuỗi

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
049 tùy chọn được thêm vào đầu truy nguyên. Một số
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
062 tùy chọn cho biết mức bắt đầu truy nguyên (mặc định là 1, chức năng gọi
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
660)

Mặc dù Lua đã được thiết kế như một ngôn ngữ mở rộng, được nhúng trong chương trình máy chủ C, nhưng nó cũng thường được sử dụng như một ngôn ngữ độc lập. Một trình thông dịch cho Lua như một ngôn ngữ độc lập, được gọi đơn giản là

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
66, được cung cấp cùng với bản phân phối tiêu chuẩn. Trình thông dịch độc lập bao gồm tất cả các thư viện tiêu chuẩn, bao gồm cả thư viện gỡ lỗi. cách sử dụng của nó là

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
58

Các tùy chọn là

  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    662. thực thi chuỗi stat;
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    663. "yêu cầu" chế độ;
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    664. vào chế độ tương tác sau khi chạy tập lệnh;
  •      +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    665. in thông tin phiên bản;
  •      a = 'alo\n123"'
         a = "alo\n123\""
         a = '\97lo\10\04923"'
         a = [[alo
         123"]]
         a = [==[
         alo
         123"]==]
    
    90. dừng xử lý tùy chọn;
  •      and       break     do        else      elseif
         end       false     for       function  if
         in        local     nil       not       or
         repeat    return    then      true      until     while
    
    747. thực thi
         +     -     *     /     %     ^     #
         ==    ~=    <=    >=    <     >     =
         (     )     {     }     [     ]
         ;     :     ,     .     .    ...
    
    056 dưới dạng tệp và dừng xử lý các tùy chọn

Sau khi xử lý các tùy chọn của nó,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
66 chạy tập lệnh đã cho, chuyển cho nó các đối số đã cho dưới dạng đối số chuỗi. Khi được gọi mà không có đối số,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
66 hoạt động như
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
671 khi đầu vào tiêu chuẩn (
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
056) là một thiết bị đầu cuối và như
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
673 nếu không

Trước khi chạy bất kỳ đối số nào, trình thông dịch sẽ kiểm tra biến môi trường

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
674. Nếu định dạng của nó là
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
675, thì
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
66 sẽ thực thi tệp. Mặt khác,
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
66 tự thực thi chuỗi

Tất cả các tùy chọn được xử lý theo thứ tự, ngoại trừ

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
664. Chẳng hạn, một lời gọi như

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
59

trước tiên sẽ đặt

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
87 thành 1, sau đó in giá trị của
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
87 (là '
     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
88') và cuối cùng chạy tệp
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
682 mà không có đối số. (Ở đây
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
405 là dấu nhắc trình bao. Lời nhắc của bạn có thể khác. )

Trước khi bắt đầu chạy tập lệnh,

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
66 thu thập tất cả các đối số trong dòng lệnh trong một bảng chung có tên là
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
051. Tên tập lệnh được lưu trữ ở chỉ mục 0, đối số đầu tiên sau tên tập lệnh chuyển sang chỉ mục 1, v.v. Bất kỳ đối số nào trước tên tập lệnh (nghĩa là tên trình thông dịch cộng với các tùy chọn) đều chuyển đến các chỉ số phủ định. Ví dụ, trong cuộc gọi

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
60

đầu tiên trình thông dịch chạy tệp

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
686, sau đó tạo một bảng

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
61

và cuối cùng chạy tệp

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
687. Tập lệnh được gọi với
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
688,
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
689, ··· làm đối số;

Trong chế độ tương tác, nếu bạn viết một câu lệnh chưa hoàn chỉnh, trình thông dịch sẽ đợi nó hoàn thành bằng cách đưa ra một lời nhắc khác

Nếu biến toàn cục

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
691 chứa một chuỗi thì giá trị của nó được sử dụng làm lời nhắc. Tương tự, nếu biến toàn cục
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
692 chứa một chuỗi, thì giá trị của nó được sử dụng làm lời nhắc phụ (được đưa ra trong các câu lệnh không đầy đủ). Do đó, cả hai lời nhắc có thể được thay đổi trực tiếp trên dòng lệnh hoặc trong bất kỳ chương trình Lua nào bằng cách gán cho
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
691. Xem ví dụ tiếp theo

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
62

(Cặp trích dẫn bên ngoài dành cho Shell, cặp bên trong dành cho Lua. ) Lưu ý việc sử dụng

     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
664 để vào chế độ tương tác;

Để cho phép sử dụng Lua làm trình thông dịch tập lệnh trong các hệ thống Unix, trình thông dịch độc lập sẽ bỏ qua dòng đầu tiên của đoạn nếu nó bắt đầu bằng

     and       break     do        else      elseif
     end       false     for       function  if
     in        local     nil       not       or
     repeat    return    then      true      until     while
767. Do đó, các tập lệnh Lua có thể được tạo thành các chương trình thực thi bằng cách sử dụng biểu mẫu
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
697 và
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
698, như trong

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
63

(Tất nhiên, vị trí của trình thông dịch Lua có thể khác trong máy của bạn. Nếu

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
66 nằm trong số
     +     -     *     /     %     ^     #
     ==    ~=    <=    >=    <     >     =
     (     )     {     }     [     ]
     ;     :     ,     .     .    ...
700 của bạn, thì

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
64

là một giải pháp di động hơn. )

Ở đây chúng tôi liệt kê những điểm không tương thích mà bạn có thể tìm thấy khi di chuyển một chương trình từ Lua 5. 0 đến Lua 5. 1. Bạn có thể tránh hầu hết sự không tương thích khi biên dịch Lua với các tùy chọn thích hợp (xem tệp

     a = 'alo\n123"'
     a = "alo\n123\""
     a = '\97lo\10\04923"'
     a = [[alo
     123"]]
     a = [==[
     alo
     123"]==]
92). Tuy nhiên, tất cả các tùy chọn tương thích này sẽ bị loại bỏ trong phiên bản tiếp theo của Lua