Tür kontrolü

Luau, tür anotasyonlarının ve tür tahmininin kullanımıyla yavaş yavaş bir tür sistemi destekler.Bu tipler Kod Editörü 'de daha iyi uyarılar, hatalar ve öneriler sağlamak için kullanılır.

Bir yaztanımla

Kendi tiplerinizi tanımlamak için type anahtar kelimesini kullanın:

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

Tahmin modları

Bir Script 'in ilk satırında ayarlanabilecek üç Luau tür tahmin modu vardır:

• --!nocheck — Türleri kontrol etmeyin.
• --!nonstrict — Sadece açıkça annot edilirse değişken türlerini iddia eder.
• --!strict — Tahmin edilen veya açıkça annotasyonlu yazyola çıkan tüm türleri iddia eder.

The --!nonstrict ve --!strict modları, değişkenler ve işlevler için tür denetleyicisinin tahmin ve kontrol ile ne kadar sıkı olduğunu kontrol eder.Kodlarda herhangi bir tür eşleşme ihlali, Kod Editörü 'de vurgulanır ve Kod Analizi penceresinde uyarı olarak görünür.

Türler

Yerel bir değişkenin ardından : operatörü kullanılarak bir tür anotasyon tanımlanabilir ve bunu bir tür tanımı izleyebilir.Varsayılan olarak, nonstrict modunda tüm değişkenlere any tipi atanır.

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

Bir anotasyonda kullanılabilecek dört temel tür vardır:

• nil - değer yok
• boolean - true or false
• number - sayısal bir değer
• string - metin

Roblox içinde, tüm sınıflar, veri türleri ve enum'lerin kendi kontrol edebileceğiniz türleri vardır:

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

Bir tipi zorunlu olmaktan çıkarmak için, notasyonun sonunda bir ? kullanın:

local foo: string? = nil

Bu, değişkenin belirtilen tür (bu durumda string ) veya nil olmasına izin verecektir.

Sözcük tipleri

Ayrıca string ve boolean kullanarak yerel değerlere dize ve booleans atayabilirsiniz:

local alwaysHelloWorld: "Hello world!" = "Hello world!"
alwaysHelloWorld = "Just hello!"  -- Hata türü: 'Sadece merhaba!' tipi 'Merhaba dünya!'ye dönüştürülemedi

local alwaysTrue: true = false  -- Type error: Type 'false' could not be converted into 'true'

Tür atışları

Bazen, değer doğrulayıcıya açıkça bir değeri farklı bir tipe yansıtarak yardım etmeniz gerekebilir: :: operatörüyle:

local myNumber = 1
local myString: string

myString = myNumber  -- Tamam değil; dönüşüm hatası yaz
myString = myNumber :: any  -- Tamam; tüm ifadeler 'herhangi biri'ne yönlendirilebilir
local myFlag = myNumber :: boolean  -- Not OK; types are unrelated

Fonksiyon tiplemesi

Aşağıdaki işlevi düşünün:

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

Bu işlev x 'ye ekler y , ancak bir veya her ikisi de bir diziise hata verir.Luau, bu işlevin sadece sayıları kullanabileceğini bilmiyor.Bu sorun kategorisini önlemek için, parametrelere türler ekleyin:

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

Luau artık işlevin iki sayı aldığını ve bir sayı olmayan herhangi bir şeyi işlevine geçmeye çalışırsanız uyarı verdiğini biliyor:

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

Bir dönüş yaztanımlamak için, işlev tanımının sonuna bir : operatörü yerleştirin:

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

Birden fazla tür iade etmek için, türleri parantezler içine yerleştirin:

local function FindSource(script: BaseScript, pattern: string): (string, number)
	return 42, true  -- Türde hata yap
end

İşlevsel bir yaztanımlayın

İşlevsel bir tür, syntax (in) -> out kullanarak tanımlanabilir. Önceki örneklerden işlevlerin türleri şunlardır:

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

Tablo türleri

Luau'nun bir table yazyok; bunun yerine, tablo türleri {} söntaxı kullanılarak tanımlanır.Tabloları tanımlamanın bir yolu, bir liste türünü tanımlayan {type} sözdizimi kullanıyor, ki bu bir liste yaz.

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

{[indexType]: valueType} kullanarak indeks türlerini tanımlayın: define index types using :

local numberList: {[string]: number} = {
	Foo = 1,
	Baz = 10
}

numberList["bar"] = true  -- Type error: boolean can't convert to number

Tablolar ayrıca bir yaztanımlanmış açık metin indekslerine sahip olabilir.

type Car = {
	Speed: number,
	Drive: (Car) -> ()
}

local function drive(car)
	-- Hız sınırına daima git
end

local taxi: Car = {Speed = 30, Drive = drive}

Değişkenler

İşte rastgele bir sayının toplamını hesaplayan bir işlev:

local function addLotsOfNumbers(...)
	local sum = 0

	for _, v in {...} do
		sum += v
	end

	return sum
end

Beklendiği gibi, bu işlev herhangi bir değer alabilir ve yazdenetleyicisi, bir string gibi geçersiz bir tür sağlarsanız uyarı çıkarmayacaktır.

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

Bunun yerine, herhangi bir diğer yazatadığınız gibi ... 'ye bir tür atayın:

local function addLotsOfNumbers(...: number)

Ve şimdi, ikinci satır bir tür hata yükseltiyor.

print(addLotsOfNumbers(1, 2, 3, 4, 5))
print(addLotsOfNumbers(1, 2, "car", 4, 5))  -- Hata türü: dize sayıya dönüştürülemedi

Ancak, bu işlevsel bir tip tanımı yazarken çalışmaz:

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

Bunun yerine, çeşitli bir yaztanımlamak için syntax ...type kullanın.

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

Sendikalar ve kesişimler

Bir birleşim veya kesişim kullanarak bir türü iki veya daha fazla tür olarak tanımlayabilirsiniz:

type numberOrString = number | string
type type1 = {foo: string}
type type2 = {bar: number}
type type1and2 = type1 & type2  -- {foo: dizi} ve {bar: number}

local numString1: numberOrString = true  -- Hata türü
local numString2: type1and2 = {foo = "hello", bar = 1}

Tahmin edilen bir yaztanımlayın

Yorumlanmış türler için bir tip tanımında typeof işlevini kullanabilirsiniz:

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

typeof kullanmanın bir yolu, setmetatable içindeki typeof işlevi kullanarak bir metatable türünü tanımlamaktır:

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

-- Vector + Vector would return a Vector type

Jenerikler

Jenerikler, türler için temel seviye parametrelerdir. Aşağıdaki State nesneyi düşünün:

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

Jenerik olmadan, bu nesne için tür şöyle olurdu:

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

Bununla birlikte, Value tipinin gelen değere dayanmasını isteyebilirsiniz, ki bu noktada genellemeler devreye girer:

type GenericType<T> = T

The <T> herhangi bir şeye ayarlanabilen bir türü belirtir. Bunu görselleştirmenin en iyi yolu, bir değiştirme yazolarak.

type List<T> = {T}

local Names: List<string> = {"Bob", "Dan", "Mary"}  -- Tür {dizi} olur
local Fibonacci: List<number> = {1, 1, 2, 3, 5, 8, 13}  -- Type becomes {number}

Jenerikler ayrıca parantezler içinde çok sayıda değişiklik yapabilir.

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

Genel bir yazkullanmak için daha önceki State nesnesini yeniden işlemek:

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

Fonksiyon generikleri

Fonksiyonlar da genellemeleri kullanabilir. State örneği, fonksiyonun gelen argümanlarından T değerini çıkarır.

Genel bir işlev tanımlamak için, işlev adına <> ekleyin:

local function State<T>(key: string, value: T): State<T>
	return {
		Key = key,
		Value = value
	}
end

local Activated = State("Activated", false)  -- Devlet<boolean>
local TimesClicked = State("TimesClicked", 0)  -- State<number>

Türkiye ihracatı

Böylece bir türün ModuleScript dışında kullanılabilmesi için, export anahtar kelimesini kullanın:

ReplicatedStorage'ta Tür Modülü
export type Cat = {
	Name: string,
	Meow: (Cat) -> ()
}

Türler Modülü Kullanan Komut Dosyası
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()