Tür kontrolü

Luau, tür açıklamaları ve tür çıkarımı aracılığıyla aşamalı bir tür sistemi destekler. Bu türler, Script Editor içinde daha iyi uyarılar, hatalar ve öneriler sağlamak için kullanılır.

Bir tür tanımlama

Kendi türlerinizi tanımlamak için type anahtar kelimesini kullanın:

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

Çıkarım modları

Bir Script'in ilk satırında ayarlanabilen üç Luau tür çıkarım modu vardır:

• --!nocheck — Türleri kontrol etme.
• --!nonstrict — Sadece değişken türleri açıkça açıklanmışsa doğrular.
• --!strict — Tüm türleri, çıkarılan veya açıkça belirtilen türlere dayalı olarak doğrular.

--!nonstrict ve --!strict modları, tür kontrolünün değişkenler ve fonksiyonlar için türleri çıkarmak ve kontrol etmekte ne kadar katı olduğunu kontrol eder. Betiklerdeki herhangi bir tür uyuşmazlığı, Script Editor içinde vurgulanır ve Script Analysis penceresinde uyarılar olarak gösterilir.

Gerekli olduğunda geçersiz kılabileceğiniz tüm betikler için varsayılan bir mod ayarlamak için, Workspace.LuauTypeCheckMode'a bakın.

Türler

Bir tür açıklaması, bir yerel değişkenin sonuna : operatörünü ekleyerek ve ardından bir tür tanımı ekleyerek tanımlanabilir. Varsayılan olarak, nonstrict modunda, tüm değişkenler any türü olarak atanır.

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

Açıklamalarda kullanılabilen dört temel tür vardır:

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

Roblox içinde, tüm sınıflar, veri türleri ve enum'lar, kontrol edebileceğiniz kendi türlerine sahiptir:

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

Bir türü isteğe bağlı hale getirmek için, açıklamanın sonuna ? kullanın:

local foo: string? = nil

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

Literal türler

Ayrıca, string ve boolean yerine, dizeleri ve boolean'ları literal değerlere dönüştürebilirsiniz:

local alwaysHelloWorld: "Hello world!" = "Hello world!"
alwaysHelloWorld = "Just hello!"  -- Tür hatası: Tür '"Just hello!"' '"Hello world!"' içine dönüştürülemedi

local alwaysTrue: true = false  -- Tür hatası: Tür 'false' 'true' içine dönüştürülemedi

Tür dönüşümleri

Bazen, bir değeri farklı bir türe açıkça dönüştürmek için tür denetleyicisine yardımcı olmanız gerekebilir; bunu :: operatörü ile yapabilirsiniz:

local myNumber = 1
local myString: string

myString = myNumber  -- Tamam değil; tür dönüştürme hatası
myString = myNumber :: any  -- Tamam; tüm ifadeler 'any' türüne dönüştürülebilir
local myFlag = myNumber :: boolean  -- Tamam değil; türler birbirine alakasız

Fonksiyon tipleri

Aşağıdaki fonksiyonu düşünün:

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

Bu fonksiyon x'i y'ye ekler, ancak bunlardan biri veya her ikisi bir dize ise hata verir. Luau, bu işlemin sadece sayıları kullanabileceğini bilmez. Bu tür problemleri önlemek için, parametrelere türler ekleyin:

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

Luau şimdi işlevin iki sayı aldığını bilir ve işlevin içine geçerli olmayan bir şey geçirmeye çalışırsanız bir uyarı verir:

add(5, 10)
add(5, "foo")  -- Tür hatası: dize sayıya dönüştürülemedi

Bir dönüş türü tanımlamak için, fonksiyon tanımının sonuna : operatörünü koyun:

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

Birden fazla türü döndürmek için, türleri parantez içinde yerleştirin:

local function FindSource(script: BaseScript, pattern: string): (string, number)
	return 42, true  -- Tür hataları
end

Fonksiyonel bir tür tanımlama

Fonksiyonel bir tür, (in) -> out söz dizimi kullanılarak tanımlanabilir. Önceki örneklerden alınan fonksiyonların türleri şöyle olur:

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

Tablo türleri

Luau'da table türü yoktur; bunun yerine, tablo türleri {} söz dizimi kullanılarak tanımlanır. Tabloları tanımlamanın bir yolu, bir liste tipi tanımlayan {type} söz dizimini kullanmaktır.

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

İndeks türlerini {[indexType]: valueType} kullanarak tanımlayın:

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

numberList["bar"] = true  -- Tür hatası: boolean sayı olarak dönüştürülemez

Tablolar ayrıca bir türde açıkça tanımlanmış dize indekslerine sahip olabilir.

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

local function drive(car)
	-- Her zaman hız limitine uy
end

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

Variadics

Herhangi bir sayıda sayının toplamını hesaplayan bir fonksiyon:

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

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

	return sum
end

Beklendiği gibi, bu fonksiyon herhangi bir değeri alabilir ve tür denetleyicisi geçersiz bir tür sağladığınızda uyarı vermez, örneğin bir string:

print(addLotsOfNumbers(1, 2, 3, 4, 5))  -- 15
print(addLotsOfNumbers(1, 2, "car", 4, 5))  -- Sayıya dize ekleme girişimi

Bunun yerine, ...'e bir tür atayın, tıpkı diğer türleri atadığınız gibi:

local function addLotsOfNumbers(...: number)

Ve şimdi, ikinci satır bir tür hatası alır.

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

Ancak, bu, bir fonksiyonel tür tanımı yazarken çalışmaz:

type addLotsOfNumbers = (...: number) -> number  -- Beklenen tür, ':'

Bunun yerine, bir variadik türü tanımlamak için ...type söz dizimini kullanın.

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

Birlikler ve kesişim

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

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

local numString1: numberOrString = true  -- Tür hatası
local numString2: type1and2 = {foo = "hello", bar = 1}

Çıkarılan bir tür tanımlama

Çıkarılmış türler için tür tanımında typeof fonksiyonunu kullanabilirsiniz:

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

typeof'ı, setmetatable ile bir metatablo türü tanımlamak için kullanmanın bir yolu:

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

-- Vector + Vector, bir Vector türü döndürecektir

Genericler

Genericler, temel seviyede türler için parametrelerdir. Aşağıdaki State nesnesini düşünün:

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

Genericler olmadan, bu nesne için tür şu şekilde olur:

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

Ancak, Value türünün gelen değere dayanmasını isteyebilirsiniz; bu da genericlerin geldiği yerdir:

type GenericType<T> = T

<T> her şey için ayarlanabilen bir türü ifade eder. Bunu bir yer tutucu türü olarak görmek en iyi yoldur.

type List<T> = {T}

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

Genericler, köşeli parantezler içinde birden fazla yer tutucuya sahip de olabilir.

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

Önceki State nesnesini yeniden yapılandırmak için bir generic tür kullanın:

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

Fonksiyon genericleri

Fonksiyonlar da genericleri kullanabilir. State örneği, T'nin değerini işlevin gelen argümanlarından çıkarır.

Generic bir fonksiyon tanımlamak için fonksiyonun adının sonuna <> ekleyin:

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

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

Tür dışa aktarımı

Bir türün ModuleScript dışında kullanılabilmesi için export anahtar kelimesini kullanın:

Types Module in ReplicatedStorage
export type Cat = {
	Name: string,
	Meow: (Cat) -> ()
}

Script Using the Types Module
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()