The functions listed below aren't in any specific library, but are global in the script's environment. These are general purpose functions that don't fit into any of the other categories.
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. message is an error message; when absent, it defaults to "assertion failed!"
collectgarbage (opt [, arg])
This function is a generic interface to the garbage collector. It performs different functions according to its first argument, opt:
Note that the only option that works is count. All of the others will error as an invalid option.
Opens the named file and executes its contents as a chunk. When called without arguments, 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).
error (message [, level])
Terminates the last protected function called and returns message as the error message. If the function containing the error is not called in a protected function (pcall), then the script which called the function will terminate.
The error function itself never returns and acts like a script error.
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.
A table that is shared between all scripts in one instance of Roblox. Scripts can use this to share data, including functions, between them.
See also Global Functions.
Returns amount of dynamic memory in use. This is deprecated. Use collectgarbage ("count") instead.
Returns the current environment in use by the function. f can be a 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 function, or if f is 0, getfenv returns the global environment. The default for f is 1. While you can technically create spaced variables with getfenv, the only possible way to access this variable would be to get the index in getfenv. When using getfenv to get the current environment of a script, it will return the same table every time within the specific thread.
If object does not have a metatable, returns nil. Otherwise, if the object's metatable has a "__metatable" field, returns the associated value. Otherwise, returns the metatable of the given object.
for i,v in ipairs(t) do --body end
will iterate over the pairs (1,t), (2,t), ···, up to the first integer key absent from the table.
load (func [, chunkname])
chunkname is used as the chunk name for error messages and debug information.
Similar to load, but gets the chunk from file filename or from the standard input, if no file name is given.
loadstring (string [, chunkname])
Unlike standard Lua 5.1, ROBLOX Lua cannot load bytecode using loadstring.
To load and run a given string, use the idiom
newproxy (boolean or proxy)
Undocumented feature of Lua.
Creates a blank userdata with an empty metatable, or with the metatable of another proxy. Note that, in ROBLOX, creating a proxy with another proxy is disabled and will error.
next (table [, index])
Allows a program to traverse all fields of a table. Its first argument is a table and its second argument is an index in this table. 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.
os.time( [date_table] )
When called without arguments, returns the number of seconds since the epoch (1 January 1970, 00:00:00). This differs from tick(): tick() returns the number of seconds since the epoch from the current system time. os.time() returns this time of seconds since the UTC time, meaning that this will (theoretically) be the same on all systems. In practice, this will often differ with some seconds. os.time() should be used for cases where you want to get a time difference between two visits - think about giving players a bonus for coming back every day.
When called with a date table, os.time will return the timestamp which belongs to that date table. This date table can hold the following fields:
|Field||Valid values||Default values or mandatory|
|year||A full year number (ex. 2014)||Mandatory|
|isdst||True if daylight saving is on||false|
os.difftime( t1, t2 )
for k,v in pairs(t) do body end
will iterate over all key–value pairs of table t.
pcall (f, arg1, ···)
Calls function f with the given arguments in protected mode. This means that any error inside 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.
Receives any number of arguments, and prints their values to the output, 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)
Checks whether v1 is equal to v2, without invoking any metamethod. Returns a boolean.
rawget (table, index)
rawset (table, index, value)
This function returns table.
select (index, ···)
setfenv (f, table)
Sets the environment to be used by the given function. f can be a function or a number that specifies the function at that stack level: Level 1 is the function calling setfenv. setfenv returns the given function.
As a special case, when f is 0 setfenv changes the environment of the running thread. In this case, setfenv returns no values.
See PIL's Non-Global Environments for more info
setmetatable (table, metatable)
Sets the metatable for the given table. (You cannot change the metatable of other types from Lua, only from C.) If metatable is nil, removes the metatable of the given table. If the original metatable has a "__metatable" field, raises an error.
This function returns table.
tonumber (e [, base])
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 may have a decimal part, as well as an optional exponent part (see §2.1). In other bases, only unsigned integers are accepted.
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.
Returns the type of its only argument, coded as a string. The possible results of this function are "nil" (a string, not the value nil), "number", "string", "boolean", "table", "function", "thread", and "userdata".
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.
xpcall (f, err)
This function is similar to 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.