|
Lua is a dynamically typed language.
This means that
variables do not have types; only values do.
There are no type definitions in the language.
All values carry their own type.
All values in Lua are first-class values.
This means that all values can be stored in variables,
passed as arguments to other functions, and returned as results.
There are eight basic types in Lua:
nil, boolean, number,
string, function, userdata,
thread, and table.
Nil is the type of the value nil,
whose main property is to be different from any other value;
it usually represents the absence of a useful value.
Boolean is the type of the values false and true.
Both nil and false make a condition false;
any other value makes it true.
Number represents real (double-precision floating-point) numbers.
(It is easy to build Lua interpreters that use other
internal representations for numbers,
such as single-precision float or long integers;
see file luaconf.h.)
String represents arrays of characters.
Lua is 8-bit clean:
strings can contain any 8-bit character,
including embedded zeros ('\0') (see §2.1).
Lua can call (and manipulate) functions written in Lua and
functions written in C
(see §2.5.8).
The type userdata is provided to allow arbitrary C data to
be stored in Lua variables.
This type corresponds to a block of raw memory
and has no pre-defined operations in Lua,
except assignment and identity test.
However, by using metatables,
the programmer can define operations for userdata values
(see §2.8).
Userdata values cannot be created or modified in Lua,
only through the C API.
This guarantees the integrity of data owned by the host program.
The type thread represents independent threads of execution
and it is used to implement coroutines (see §2.11).
Do not confuse Lua threads with operating-system threads.
Lua supports coroutines on all systems,
even those that do not support threads.
The type table implements associative arrays,
that is, arrays that can be indexed not only with numbers,
but with any value (except nil).
Tables can be heterogeneous;
that is, they can contain values of all types (except nil).
Tables are the sole data structuring mechanism in Lua;
they can be used to represent ordinary arrays,
symbol tables, sets, records, graphs, trees, etc.
To represent records, Lua uses the field name as an index.
The language supports this representation by
providing a.name as syntactic sugar for a["name"].
There are several convenient ways to create tables in Lua
(see §2.5.7).
Like indices,
the value of a table field can be of any type (except nil).
In particular,
because functions are first-class values,
table fields can contain functions.
Thus tables can also carry methods (see §2.5.9).
Tables, functions, threads, and (full) userdata values are objects:
variables do not actually contain these values,
only references to them.
Assignment, parameter passing, and function returns
always manipulate references to such values;
these operations do not imply any kind of copy.
The library function type returns a string describing the type
of a given value.
Lua provides automatic conversion between
string and number values at run time.
Any arithmetic operation applied to a string tries to convert
this string to a number, following the usual conversion rules.
Conversely, whenever a number is used where a string is expected,
the number is converted to a string, in a reasonable format.
For complete control over how numbers are converted to strings,
use the format function from the string library
(see string.format). |