global
Lua global functions.
| _G | A global variable (not a function) that holds the global environment
(that is, _G._G = _G). |
| _VERSION | A global variable (not a function) that holds a string containing the current interpreter version. |
| assert(v, message) | Issues an error when the value of its argument v is false (i.e.,
nil or false); otherwise, returns all its arguments. |
| collectgarbage(opt, arg) | This function is a generic interface to the garbage collector. |
| coroutine | This library provides generic functions for coroutine manipulation. |
| debug | The Debug Library.. |
| dofile(filename) | Opens the named file and executes its contents as a Lua chunk. |
| error(message, level) | Terminates the last protected function called and returns message
as the error message. |
| getfenv(f) | Returns the current environment in use by the function. |
| getmetatable(object) | If object does not have a metatable, returns nil. |
| io | The I/O library provides function for file manipulation. |
| ipairs(t) | Use to iterate over a table by index. |
| load(func, chunkname) | Loads a chunk using function func to get its pieces. |
| loadfile(filename) | Similar to load, but gets the chunk from file filename or from the
standard input, if no file name is given. |
| loadstring(string, chunkname) | Similar to load, but gets the chunk from the given string. |
| math | This library is an interface to the standard C math library. |
| next(table, index) | Allows a program to traverse all fields of a table. |
| os | Operating System Facilities. |
| package | The package library provides basic facilities for loading and building modules in Lua. |
| pairs(t) | Use to iterate over a table. |
| pcall(f, arg1) | Calls function f with the given arguments in protected mode. |
| print() | Receives any number of arguments, and prints their values to stdout,
using the tostring function to convert them to strings. |
| rawequal(v1, v2) | Checks whether v1 is equal to v2, without invoking any
metamethod. |
| rawget(table, index) | Gets the real value of table[index], without invoking any
metamethod. |
| rawset(table, index, value) | Sets the real value of table[index] to value, without invoking any
metamethod. |
| require(modname) | Loads the given module. |
| select(index) | If index is a number, returns all arguments after argument number
index. |
| setfenv(f, table) | Sets the environment to be used by the given function. |
| setmetatable(table, metatable) | Sets the metatable for the given table. |
| string | This library provides generic functions for string manipulation. |
| table | This library provides generic functions for table manipulation. |
| tonumber(e, base) | Tries to convert its argument to a number. |
| tostring(e) | Receives an argument of any type and converts it to a string in a reasonable format. |
| unpack(list, i, j) | Returns the elements from the given table. |
| xpcall(f, err) | This function is similar to pcall, except that you can set a new
error handler. |
_G
_G._G = _G).
setfenv
to change environments.)
function _G end
* _G._G: G.G
_VERSION
Lua 5.1".
function _VERSION end
* _G._VERSION: G.VERSION
assert(v, message)
v is false (i.e.,
nil or false); otherwise, returns all its arguments.
message is an error
message; when absent, it defaults to "assertion failed!"
v
:
message
:
collectgarbage(opt, arg)
It performs different functions according to its first argument, opt:
arg (larger values mean more steps) in a non-specified way. If you
want to control the step size you must experimentally tune the value of
arg. Returns true if the step finished a collection cycle.arg as the new value for the pause of the collector
(see 2.10). Returns the previous value for pause.arg as the new value for the step multiplier
of the collector (see 2.10). Returns the previous value for step.
opt
:
arg
:
coroutine
debug
dofile(filename)
dofile executes the contents of the standard input (stdin). Returns
all values returned by the chunk. In case of errors, dofile propagates
the error to its caller (that is, dofile does not run in protected mode).
filename
:
error(message, level)
message
as the error message.
error never returns.
Usually, error adds some information about the error position at the
beginning of the message. The level argument specifies how to get the
error position. With level 1 (the default), the error position is where the
error function was called. Level 2 points the error to where the function
that called error was called; and so on. Passing a level 0 avoids the
addition of error position information to the message.
message
:
level
:
getfenv(f)
f can be a Lua function or a number that specifies the function at that
stack level: Level 1 is the function calling getfenv. If the given
function is not a Lua function, or if f is 0, getfenv returns the
global environment. The default for f is 1.
f
:
getmetatable(object)
object does not have a metatable, returns nil.
"__metatable" field, returns the associated
value. Otherwise, returns the metatable of the given object.
object
:
io
ipairs(t)
t, and 0,
so that the construction
for i,v in ipairs(t) do *body* end
will iterate over the pairs (1,t[1]), (2,t[2]), ..., up to the
first integer key absent from the table.
t
:
load(func, chunkname)
func to get its pieces.
func must return a string that concatenates with previous results. A
return of an empty string, nil, or no value signals the end of the chunk.
If there are no errors, returns the compiled chunk as a function; otherwise, returns nil plus the error message. The environment of the returned function is the global environment.
chunkname is used as the chunk name for error messages and debug
information. When absent, it defaults to "=(load)".
func
:
chunkname
:
loadfile(filename)
load, but gets the chunk from file filename or from the
standard input, if no file name is given.
filename
:
loadstring(string, chunkname)
load, but gets the chunk from the given string.
assert(loadstring(s))()
When absent, chunkname defaults to the given string.
string
:
chunkname
:
math
next(table, index)
next returns
the next index of the table and its associated value.
When called with nil
as its second argument, next returns an initial index and its associated
value. When called with the last index, or with nil in an empty table, next
returns nil.
If the second argument is absent, then it is interpreted as
nil. In particular, you can use next(t) to check whether a table is empty.
The order in which the indices are enumerated is not specified, even for
numeric indices. (To traverse a table in numeric order, use a numerical
for or the ipairs function.)
The behavior of next is undefined if, during the traversal, you assign
any value to a non-existent field in the table. You may however modify
existing fields. In particular, you may clear existing fields.
table
:
index
:
os
package
pairs(t)
next function, the table t, and nil,
so that the construction
for k,v in pairs(t) do *body* end
will iterate over all key-value pairs of table t.
See function next for the caveats of modifying the table during its
traversal.
t
:
pcall(f, arg1)
f with the given arguments in protected mode.
f is not propagated; instead, pcall catches
the error and returns a status code. Its first result is the status code (a
boolean), which is true if the call succeeds without errors. In such case,
pcall also returns all results from the call, after this first result. In
case of any error, pcall returns false plus the error message.
f
:
arg1
:
print()
stdout,
using the tostring function to convert them to strings.
print is not
intended for formatted output, but only as a quick way to show a value,
typically for debugging. For formatted output, use string.format.
rawequal(v1, v2)
v1 is equal to v2, without invoking any
metamethod.
v1
:
v2
:
rawget(table, index)
table[index], without invoking any
metamethod.
table must be a table; index may be any value.
table
:
index
:
rawset(table, index, value)
table[index] to value, without invoking any
metamethod.
table must be a table, index any value different from nil,
and value any Lua value. table.
table
:
index
:
value
:
require(modname)
package.loaded table to determine whether modname is already
loaded. If it is, then require returns the value stored at
package.loaded[modname]. Otherwise, it tries to find a loader for
the module.
To find a loader, require is guided by the package.loaders array. By
changing this array, we can change how require looks for a module. The
following explanation is based on the default configuration for
package.loaders.
First require queries package.preload[modname]. If it has a value,
this value (which should be a function) is the loader. Otherwise require
searches for a Lua loader using the path stored in package.path. If
that also fails, it searches for a C loader using the path stored in
package.cpath. If that also fails, it tries an all-in-one loader (see
package.loaders).
Once a loader is found, require calls the loader with a single argument,
modname. If the loader returns any value, require assigns the returned
value to package.loaded[modname]. If the loader returns no value and
has not assigned any value to package.loaded[modname], then require
assigns true to this entry. In any case, require returns the final value
of package.loaded[modname].
If there is any error loading or running the module, or if it cannot find
any loader for the module, then require signals an error.
modname
:
select(index)
index is a number, returns all arguments after argument number
index.
index must be the string "#", and select returns
the total number of extra arguments it received.
index
:
setfenv(f, table)
f can be a Lua
function or a number that specifies the function at that stack level: Level
1 is the function calling setfenv. setfenv returns the given function. f is 0 setfenv changes the environment of the
running thread. In this case, setfenv returns no values.
f
:
table
:
setmetatable(table, metatable)
metatable is nil, removes the
metatable of the given table. If the original metatable has a "__metatable"
field, raises an error. table.
table
:
metatable
:
string
table
tonumber(e, base)
tonumber returns this
number; otherwise, it returns nil.
An optional argument specifies the base to interpret the numeral. The base
may be any integer between 2 and 36, inclusive. In bases above 10, the
letter 'A' (in either upper or lower case) represents 10, 'B' represents
11, and so forth, with 'Z' representing 35. In base 10 (the default),
the number can have a decimal part, as well as an optional exponent part
(see 2.1). In other bases, only unsigned integers are accepted.
e
:
base
:
tostring(e)
string.format.
If the metatable of e has a "__tostring" field, then tostring calls
the corresponding value with e as argument, and uses the result of the
call as its result.
e
:
unpack(list, i, j)
return list[i], list[i+1], ..., list[j]
except that the above code can be written only for a fixed number of
elements. By default, i is 1 and j is the length of the list, as
defined by the length operator (see 2.5.5).
list
:
i
:
j
:
xpcall(f, err)
pcall, except that you can set a new
error handler.
xpcall calls function f in protected mode, using err as the error
handler. Any error inside f is not propagated; instead, xpcall catches
the error, calls the err function with the original error object, and
returns a status code. Its first result is the status code (a boolean),
which is true if the call succeeds without errors. In this case, xpcall
also returns all results from the call, after this first result. In case
of any error, xpcall returns false plus the result from err.
f
:
err
: