English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutorial Básico do Lua

Tipos de Dados do Lua

O Lua é uma linguagem de tipo dinâmico, não há necessidade de definição de tipo de variável, basta atribuir valor à variável. Os valores podem ser armazenados em variáveis, passados como parâmetros ou retornados como resultados.

Na Lua há 8 os tipos básicos são: nil, boolean, number, string, userdata, function, thread e table.

tipo de dadosdescrição
nilEste é o mais simples, apenas o valor nil pertence a essa classe, representando um valor inválido (equivalente a false em expressões condicionais).
booleancontém dois valores: false e true.
numberrepresenta um número de ponto flutuante de precisão dupla
stringas strings são representadas por pares de aspas duplas ou simples
functionfunção escrita em C ou Lua
userdatarepresenta uma estrutura de dados C armazenada em uma variável
threadrepresenta uma linha de execução independente, usada para executar coroutines
tabelaNa Lua, a tabela (table) é na verdade um "array associativo" (associative arrays), os índices podem ser números, strings ou tipos de tabela. Na Lua, a criação de tabela é feita através de "expressões de construção", a mais simples é {}, usada para criar uma tabela vazia.

Podemos usar a função type para testar o tipo de uma variável ou valor dado:

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（vazio）

O tipo nil representa um valor sem valor válido, ele tem apenas um valor -- nil, por exemplo, ao imprimir uma variável não inicializada, será exibido um valor nil:

>　print(type(a))
nil
>

Para as variáveis globais e as tabelas, nil também tem um efeito de "exclusão", atribuir um valor nil a uma variável global ou a uma variável na tabela é equivalente a removê-las, execute o código a seguir para entender:

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

ao comparar com nil, deve-se usar aspas duplas ":

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

o resultado de type(X)==nil é false a razão é que type(X) é na verdade uma string "nil", que é um tipo string:

type(type(X))==string

boolean (booleano)

O tipo boolean tem apenas dois valores possíveis: true (verdadeiro) e false (falso), o Lua considera false e nil como false, tudo o mais é true, o número 0 também é true:

print(type(true))
print(type(false))
print(type(nil))
　
if false or nil then
　　　　print("Pelo menos um é true")
else
　　　　print("false e nil são false")
end
if 0 then
　　　　print("O número 0 é true")
else
　　　　print("O número 0 é false")
end

O resultado da execução do seguinte código é o seguinte:

$ lua test.lua　
boolean
boolean
nil
false e nil são false
O número 0 é true

number (número)

O Lua tem apenas um tipo number padrão -- double (double precisão) tipo (o tipo padrão pode ser modificado no luaconf.h), as seguintes formas são consideradas como tipo number:

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))

O resultado da execução do seguinte código é:

number
number
number
number
number
number

string (string)

As strings são representadas por um par de aspas duplas ou simples.

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

Também pode usar 2 um par de chaves quadradas "[[]]" para representar "um bloco" de string.

Exemplo Online

html = [[
<html>
<head></head>
<body>
　　　　<a href="http://pt.oldtoolbag.com/">Base Tutorial Site</a>
</body>
</html>
]
print(html)
O resultado da execução do seguinte código é:
<html>
<head></head>
<body>
　　　　<a href="http://pt.oldtoolbag.com/">Base Tutorial Site</a>
</body>
</html>

Quando um número string é utilizado em uma operação aritmética, o Lua tenta convertê-lo em um número:

> 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: tentativa de realizar uma operação aritmética em um valor de string
stack traceback:
　　　　　　　　stdin:1: in main chunk
　　　　　　　　[C]: in ?
>

No código acima, "error" + 1O comando falhou, a concatenação de strings usa .., por exemplo:

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

Use # para calcular o comprimento da string, coloque-o antes da string, conforme o exemplo a seguir:

> len = "pt.oldtoolbag.com"
> print(#len)
14
> print(#"pt.oldtoolbag.com)
14
>

tabela（tabela）

Na criação de tabelas no Lua, é feito através de "expressões de construção", a mais simples delas é {}, usada para criar uma tabela vazia. Também é possível adicionar dados diretamente na tabela para inicializá-la:

--　Crie uma tabela vazia
local tbl1　={}
　
--　inicialização direta da tabela
local tbl2　={"apple", "pear", "orange", "grape"}

Na verdade, a tabela (table) no Lua é um "array associativo" (associative arrays), onde os índices podem ser números ou strings.

--　arquivo de script table_test.lua
a = {}
a["key"] = "value"
chave =　10
a[key] =　22
a[key] = a[key]　+　11
para k, v in pairs(a) faça
　　　　print(k .. " : " .. v)
end

O resultado da execução do script é:

$ lua table_test.lua　
chave : valor
10　:　33

Diferente de outras linguagens que usam 0 como índice inicial do array, no Lua, o índice inicial padrão da tabela geralmente é 1 início.

--　table_test2.lua arquivo de script
local tbl = {"apple", "pear", "orange", "grape"}
para key, val in pairs(tbl) faça
　　　　print("Chave", key)
end

O resultado da execução do script é:

$ lua table_test2.lua　
Chave　　　　1
Chave　　　　2
Chave　　　　3
Chave　　　　4

A tabela não tem tamanho fixo, ao adicionar novos dados, o tamanho da tabela aumenta automaticamente, todas as tabelas não inicializadas são nil.

--　table_test3.lua arquivo de script
a3　={}
para i =　1,　10　faça
　　　　a3[i] = i
end
a3["key"] = "val"
print(a3["key"])
print(a3["none"])

O resultado da execução do script é:

$ lua table_test3.lua　
val
nil

função（função）

No Lua, a função é vista como "primeiro tipo de valor (First-Classe Valor）"，a função pode existir em variáveis:

--　arquivo de script function_test.lua
função factorial1(n)
　　　　if n == 0 then
　　　　　　　　return　1
　　　　else
　　　　　　　　return n　*　factorial1(n　-　1)
　　　　end
end
print(factorial1(5))
factorial2　= factorial1
print(factorial2(5))

O resultado da execução do script é:

$ lua function_test.lua　
120
120

A função pode ser passada como função anônima (função anônima) pelo parâmetro:

--　function_test2.lua arquivo de script
function testFun(tab,fun)
　　　　　　　　for k, v in pairs(tab) do
　　　　　　　　　　　　　　　　print(fun(k,v));
　　　　　　　　end
end
tab={key1="val1",key2="val2"};
testFun(tab,
function(key,val)--Função Anônima
　　　　　　　　return key.."="..val;
end
);

O resultado da execução do script é:

$ lua function_test2.lua　
key1　= val1
key2　= val2

thread (thread)

No Lua, a principal thread é a coroutine. Ela é semelhante a uma thread (thread), possui sua pilha independente, variáveis locais e ponteiro de instrução, pode compartilhar variáveis globais e a maioria das outras coisas com outras coroutines.

A diferença entre thread e coroutine: uma thread pode executar várias ao mesmo tempo, enquanto uma coroutine pode executar apenas uma a cada momento e uma coroutine em execução só é pausada (suspendida) quando suspendida.

userdata (tipo customizado)

userdata é um tipo de dados customizado pelo usuário, usado para representar um tipo de dados criado por uma aplicação ou C/C++ Biblioteca de linguagem que cria tipos, pode armazenar qualquer C/C++ de qualquer tipo de dados (comumente struct e ponteiros) armazenados em variáveis Lua.

Variáveis do LuaSintaxe Básica do Lua