4.4. Lua data type

Lua is a dynamically typed language, variables do not need type definition, only need to assign values to variables. The value can be stored in a variable, passed as a parameter or returned as a result.

There are eight basic types in Lua: nil , boolean , number , string , userdata , function , thread and table .

Data type	Description
nil	This is the simplest, and only the value nil belongs to this class, representing an invalid value (equivalent to false in a conditional expression).
boolean	Contains two values: false and true.
Number	A real floating point number representing a double precision type
string	A string is represented by a pair of double or single quotation marks
function	Functions written by C or Lua
userdata	Represents a C data structure arbitrarily stored in a variable
thread	Represents an independent line for execution, used to execute collaborative programs
table	A table in Lua is actually an “associative array” (associative arrays), and the index of the array can be a number, a string, or a table type. In Lua, table is created through a “construction expression”. The simplest construction expression is {}, which is used to create an empty table.

We can use type function tests the type of a given variable or value:

4.4.1. Example #

print(type("Hello world"))      --> string
print(type(10.4*3))             --> number
print(type(print))              --> function
print(type(type))               --> function
print(type(true))               --> boolean
print(type(nil))                --> nil
print(type(type(X)))            --> string

nil #

nil type represents a type that does not have any valid value, it has only one value – nil , for example, if you print a variable with no assignment, you will output a nil value:

> print(type(a))
nil
>

For global variables and table , nil also has a “delete” function. Assigning a nil value to a global variable or variable in a table isequivalent to deleting them. Execute the following code to determine:

tab1 = { key1 = "val1", key2 = "val2", "val3" }
for k, v in pairs(tab1) do
    print(k .. " - " .. v)
end

tab1.key1 = nil
for k, v in pairs(tab1) do
    print(k .. " - " .. v)
end

nil should be compared in double quotation marks `"：` #

> type(X)
nil
> type(X)==nil
false
> type(X)=="nil"
true
>

type(X)==nil result is false , type(X) essentially, it is a string returned "nil" , which is a string type:

type(type(X))==string

Boolean (Bull) #

boolean has only two optional values for the type true (true) and false (fake) , Lua regard false and nil as false , the rest are for true , number 0 and true :

4.4.2. Example #

print(type(true))
print(type(false))
print(type(nil))

if false or nil then
    print("At least one is true")
else
    print("Both false and nil are false")
end
if 0 then
    print("The number 0 is true")
else
    print("The number 0 is false")
end

The execution result of the above code is as follows:

$ lua test.lua
boolean
boolean
nil
Both false and nil are false
The number 0 is true

number (digital) #

Lua has only one kind by default. number type– double (doubleprecision) type (default type can be modified luaconf.h , the following ways of writing are regarded as number type:

4.4.3. Example #

print(type(2))
print(type(2.2))
print(type(0.2))
print(type(2e+1))
print(type(0.2e-1))
print(type(7.8263692594256e-06))

The result of the above code execution:

number
number
number
number
number
number

string #

The string is represented by a pair of double or single quotation marks.

string1 = "this is string1"
string2 = 'this is string2'

You can also use 2 square brackets "[[]]" to represent a “piece” string.

Example #

html = [[
<html>
<head></head>
<body>
    <a href="http://www.runoob.com/">Novice Tutorial</a>
</body>
</html>
]]
print(html)

The following code execution results are:

<html>
<head></head>
<body>
    <a href="http://www.runoob.com/">Novice Tutorial</a>
</body>
</html>

When performing an arithmetic operation on a numeric string Lua attempts to convert this number string to a number:

> print("2" + 6)
8.0
> print("2" + "6")
8.0
> print("2 + 6")
2 + 6
> print("-2e2" * "6")
-1200.0
> print("error" + 1)
stdin:1: attempt to perform arithmetic on a string value
stack traceback:
        stdin:1: in main chunk
        [C]: in ?
>

The “error” + 1 execution in the above code reported an error, and string concatenation uses the .. , such as:

> print("a" .. 'b')
ab
> print(157 .. 428)
157428
>

Use # to calculate the length of the string, put it in front of the string, as an example:

4.4.4. Example #

> len = "www.runoob.com"
> print(#len)
14
> print(#"www.runoob.com")
14
>

table #

In Lua , table is created through a “construction expression”, and the simplest construction expression is {} to create an empty table, you can also add some data to the table to initialize the table directly:

4.4.5. Example #

-- Create an empty table
local tbl1 = {}

-- Direct Initial Table
local tbl2 = {"apple", "pear", "orange", "grape"}

The table in Lua is actually an “associative arrays” whose index can be either a number or a string.