Verificação de Tipo

*Este conteúdo é traduzido por IA (Beta) e pode conter erros. Para ver a página em inglês, clique aqui.

Luau suporta um sistema de tipo gradual através do uso de anotações de tipo e inferência de tipo. Esses tipos são usados para fornecer melhores avisos, erros e sugestões no Editor de Script .

Definindo um Tipo

Use a palavra-chave type para definir seus próprios tipos:


type Vector2 = {x: number, y: number}

Modos de Referência

Existem três modos de inferência do tipo Luau que podem ser definidos na primeira linha de um Script :

  • --!nocheck - Não verifique os tipos
  • --!nonstrict - Modo padrão para todos os scripts, atribui apenas tipos variáveis se forem explicitamente anotados
  • --!strict - Assusta todos os tipos com base no digitarinferido ou explicitamente anotado

O modo padrão para o verificador de tipo é --!nonstrict. Os outros dois modos controlem o quão rigoroso o verificador de tipo é com a inferência e verificação de tipos para variáveis e funções. Quaisquer incompatibilidades de tipo em scripts são destacadas no Script Editor e aparecem como avisos na janela Script Analysis.

Tipos

Uma anotação de tipo pode ser definida usando o operador : após uma variável local, seguido por uma definição de tipo. Por padrão, no modo nonstrict, todas as variáveis são atribuídas ao tipo any.


local foo: string = "bar"
local x: number = 5

Existem quatro tipos primitivos que podem ser usados em uma anotação:

  • nil - sem valor
  • boolean - true ou false
  • number - um valor numérico
  • string - texto

Dentro do Roblox, todas as Classes, tipos de dados e enums têm seus próprios tipos que você pode verificar:


local somePart: Part = Instance.new("Part")
local brickColor: BrickColor = somePart.BrickColor
local material: Enum.Material = somePart.Material

Para tornar um tipo opcional, use um ? no final da anotação:


local foo: string? = nil

Isso permitirá que a variável seja do tipo especificado (neste caso string ) ou nil .

Tipos Literais

Você também pode lançar string / cadeia / textoe booleanos em valores literais em vez de usar string e boolean:


local alwaysHelloWorld: "Hello world!" = "Hello world!"
alwaysHelloWorld = "Just hello!" -- Erro de digitação: A digitação '"Just hello!"' não pôde ser convertida em '"Hello mundo!"'
local alwaysTrue: true = false -- Type error: Type 'false' could not be converted into 'true'

Digite os Casts

Às vezes, você pode precisar ajudar o typechecker jogando explicitamente um valor em um tipo diferente com o :: operador:


local myNumber = 1
local myString: string
myString = myNumber -- Não está OK; digite erro de conversão
myString = myNumber :: any -- OK; todas as expressões podem ser lançadas para 'qualquer'
local myFlag = myNumber :: boolean -- Not OK; types are unrelated

Função de Digitação

Considere a seguinte função:


local function add(x, y)
return x + y
end

Esta função adiciona x a y , mas erros se um ou ambos forem uma string / cadeia / texto. Luau não sabe que esta função só pode usar números. Para evitar essa categoria de problema, adicione tipos aos parâmetros:


local function add(x: number, y: number)
return x + y
end

Luau agora sabe que a função leva dois números e lança um aviso se você tentar passar algo que não seja um número na função:


add(5, 10)
add(5, "foo") -- Type error: string could not be converted into number

Para definir um digitarde retorno, coloque um operador : no final da definição da função:


local function add(x: number, y: number): number

Para retornar vários tipos, coloque os tipos entre parênteses:


local function FindSource(script: BaseScript, pattern: string): (string, number)
return 42, true -- Erros de digitação
end

Definindo um Tipo Funcional

Um tipo funcional pode ser definido usando a sintaxe (in) -> out . Usando as funções dos exemplos anteriores, os tipos das funções são:


type add = (x: number, y: number) -> number
type FindSource = (script: BaseScript, pattern: string) -> (string, number)

Tipos de Mesa

Luau não tem um digitartable; em vez disso, os tipos de tabela são definidos usando a sintaxe {}. Uma maneira de definir tabelas é usar a sintaxe digitar , que define um digitarde lista.


local numbers: {number} = {1, 2, 3, 4, 5}
local characterParts: {Instance} = LocalPlayer.Character:GetChildren()

Defina tipos de índice usando {[indexType]: valueType} :


local numberList: {[string]: number} = {
Foo = 1,
Baz = 10
}
numberList["bar"] = true -- Type error: boolean can't convert to number

As tabelas também podem ter índices de string explícitos definidos em um digitar.


type Car = {
Speed: number,
Drive: (Car) -> ()
}
local function drive(car)
-- Sempre vá até o limite de velocidade
end
local taxi: Car = {Speed = 30, Drive = drive}

Variádicas

Aqui está uma função que calcula a soma de uma quantidade arbitrária de números:


local function addLotsOfNumbers(...)
local sum = 0
for _, v in {...} do
sum += v
end
return sum
end

Como esperado, esta função pode assumir qualquer valor, e o typechecker não emitirá um aviso se você fornecer um digitarinválido, como string / cadeia / texto .


print(addLotsOfNumbers(1, 2, 3, 4, 5)) -- 15 pontos
print(addLotsOfNumbers(1, 2, "car", 4, 5)) -- Attempt to add string to number

Em vez disso, atribua um tipo ao ... , assim como você atribui qualquer outro digitar:


local function addLotsOfNumbers(...: number)

E agora, a segunda linha levanta um erro de digitação.


print(addLotsOfNumbers(1, 2, 3, 4, 5))
print(addLotsOfNumbers(1, 2, "car", 4, 5)) -- Erro ao digitar: string não pôde ser convertida em número

No entanto, isso não funciona ao escrever uma definição de tipo funcional:


type addLotsOfNumbers = (...: number) -> number -- Expected type, got ':'

Em vez disso, use a sintaxe ...type para definir um digitarvariádico.


type addLotsOfNumbers = (...number) -> number

Uniões e Intersecções

Você pode até definir um tipo como dois ou mais tipos usando uma união ou interseção:


type numberOrString = number | string
type type1 = {foo: string}
type type2 = {bar: number}
type type1and2 = type1 & type2 -- &
local numString1: numberOrString = true -- Erro ao digitar
local numString2: type1and2 = {foo = "hello", bar = 1}

Definindo um Tipo Inferido

Você pode usar a função typeof em uma definição de tipo para tipos inferidos:


type Car = typeof({
Speed = 0,
Wheels = 4
}) --> Car: {Speed: number, Wheels: number}

Uma maneira de usar typeof é definir um tipo metatável usando setmetatable dentro da função typeof:


type Vector = typeof(setmetatable({}::{
x: number,
y: number
}, {}::{
__add: (Vector, Vector|number) -> Vector
}))
-- Vector + Vector would return a Vector type

Genéricos

Os genéricos estão em um nível básico de parâmetros para tipos. Considere o seguinte State Objeto:


local State = {
Key = "TimesClicked",
Value = 0
}

Sem genéricos, o tipo deste objeto seria o seguinte:


type State = {
Key: string,
Value: number
}

No entanto, você pode querer que o tipo para Value seja baseado no valor recebido, que é onde os genéricos entram:


type GenericType<T> = T

O <T> denota um tipo que pode ser definido para qualquer coisa. A melhor maneira de visualizar isso é como um digitarde substituição.


type List<T> = {T}
local Names: List<string> = {"Bob", "Dan", "Mary"} -- Tipo string / cadeia / texto
local Fibonacci: List<number> = {1, 1, 2, 3, 5, 8, 13} -- Type becomes {number}

Os genéricos também podem ter múltiplas substituições dentro dos colchetes.


type Map<K, V> = {[K]: V}

Para refazer o State objeto de antes para usar um digitargenérico:


type State<T> = {
Key: string,
Value: T
}

Função Genéricos

Funções também podem usar genéricos. O exemplo State infere o valor de T dos argumentos recebidos da função.

Para definir uma função genérica, adicione um <> ao nome da função:


local function State<T>(key: string, value: T): State<T>
return {
Key = key,
Value = value
}
end
local Activated = State("Activated", false) -- Estado<booleano>
local TimesClicked = State("TimesClicked", 0) -- State<number>

Tipo Exportações

Para fazer com que um tipo possa ser usado fora de um ModuleScript , use a export palavra-chave:

Módulo de tipos no ReplicatedStorage

export type Cat = {
Name: string,
Meow: (Cat) -> ()
}
Script Usando o Módulo de Tipos

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Types = require(ReplicatedStorage.Types)
local newCat: Types.Cat = {
Name = "metatablecat",
Meow = function(self)
print(`{self.Name} said meow`)
end
}
newCat:Meow()