Kontrol Tipi

Luau, tip anlatımları ve tip öngörüleri kullanarak yükseltici tip sistemi destekler. Bu türler, Script Editor'da 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 kelimesini kullanın:

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

Algı Modları

Bir Script 'in ilk satırında ayarlanabilen üç Luau tipi öngörü modu vardır:

• --!nocheck - Tipleri kontrol etmeyin
• --!nonstrict - Tüm yazılımlar için varsayılan mod, sadece belirli tipleri açık olarak belirtirse değişken türleri kabul eder
• --!strict - Tahmini veya açıkça belirtilmiş yaztemel alır

Tip kontrolörü için varsayılan mod --!nonstrict . Diğer iki mod, tip kontrolörünün inferring ve检查 types for variables and functions ile ilgili türleri nasıl kısıtlayacağını kontrol eder. Script Editor ve 1>Script Analysis1> pencerelerindeki herhangi bir tip uyumsuzluklarının görüntülenmesi için 4>警告

Türler

Bir tip anotasyonu, bir tip definasyonunun ardından : operatörü kullanılarak yerel değişkenin ardından tanımlanabilir.Varsayılan olarak, nonstrict modunda, tüm değişkenlerin tipi any atanır.

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

Bir anotasyonda kullanılan dört ilkel tip vardır:

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

Roblox'ta, tüm sınıflar, veri türleri ve enums'ların kendi türlerine sahiptir:

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

Bir tipi zorunlu olmayan yapmak için, anotasyonun sonunda bir ? kullanın:

local foo: string? = nil

Bu değişkenin belirli bir tür (burada string ) veya nil olmasını sağlayacaktır.

Kelimsel Tipler

Ayrıca, string ve boolean kullanarak harfiah değerler yerine booleans kullanabilirsiniz:

local alwaysHelloWorld: "Hello world!" = "Hello world!"
alwaysHelloWorld = "Just hello!"  -- Hata türü: "Merhaba dünyası" olarak yazılan hata "Hello world" olarak dönüştürülemedi

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

Cast'ları yaz

Bazen, bir değeri :: operatörü ile açık bir şekilde farklı bir tipe kaydederek tipChecker'a yardımcı olmanız gerekebilir:

local myNumber = 1
local myString: string

myString = myNumber  -- OK değil; dönüşüm hata
myString = myNumber :: any  -- Tamam; tüm ifadeler 'herhangi bir'ye yorumlanabilir
local myFlag = myNumber :: boolean  -- Not OK; types are unrelated

Fonksiyon Yazimi

Aşağıdaki işlevi dikkate alın:

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

Bu işlev x を y に ekler, ancak bir veya her ikisi de bir yapım olarak değerse hatalar olur. Luau bu işlevin sadece sayıları kullanabileceğini bilmez. Bu kategori problemi ile etkili bir çözüm yapmak için, parçalara tip ekleyin:

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

Luau artık işlevin iki sayıyı aldığını ve işlevin içine bir sayı olmadığını bildiğini bir uyarıyı gösterir:

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ü koyun:

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

Birden fazla tür iade etmek için ebeveynlerine yerleştirin:

local function FindSource(script: BaseScript, pattern: string): (string, number)
	return 42, true  -- Hata türleri
end

Bir Fungsional Tipti Tanımlanması

Bir işlevsel tür, (in) -> out sentezini kullanarak tanımlanabilir. Önceki örneklerden işlevsel türleri kullanarak, işlevlerin türleri şu şekildedir:

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

Tablo Türleri

Luau'nun bir table yazyok; yerine, tablo türleri {} sintaksisi kullanılarak tanımlanır. Bir tabloyu tanımlamanın bir yolu, {type} sintaksisini kullanmaktır, bu, bir liste yaztanımlar.

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

[indexType]: valueType ile indeks türlerini tanımlayın:

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

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

Tablolar ayrıca bir yazaçık strung indeksleri de olabilir.

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

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

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

Değişkenler

Burada, bir rastgele sayının toplamını hesaplayan bir işlev var:

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

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

	return sum
end

Beklenildiği gibi, bu işlev herhangi bir değeri alabilir ve typechecker geçersiz bir tür sağlayorsanız bir uyarı çıkartmaz. Görünüm olarak, bu işlev herhangi bir değeri alabilir ve yazgeçersiz bir tür sağlayorsanız bir uyarı çıkartmaz.

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

Bunun yerine, bir türü ... 'a atayın, tıpkı herhangi bir başka yazatadığınız gibi:

local function addLotsOfNumbers(...: number)

Ve şimdi, ikinci satır bir tür hata oluşturur.

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

Ancak, işlevsel bir tip tanımı yazarken bunun işlevini göstermez:

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

Onun yerine, ...type kullanarak bir çeşitli yaztanımlayın.

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

Kaynaklar ve İzler

Birleştirici veya kesiştirici 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} & {bar: number}

local numString1: numberOrString = true  -- Hata yazıyı
local numString2: type1and2 = {foo = "hello", bar = 1}

İstemciliği Tanımlama

Açık tipler için typeof işlevini bir tip definasyonunda kullanabilirsiniz:

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

Type kullanmanın bir yolu, setmetatable içindeki typeof タイプını tanımlamak olacaktır:

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

-- Vector + Vector would return a Vector type

Genel

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

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

Geniksiz olarak, bu nesnenin türü aşağıdaki gibi olurdu:

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

Bununla birlikte, Value tipinin çiftan gelen değer üzerine dayanmasını isteyebilirsiniz, burada nesiller gelir:

type GenericType<T> = T

Bu, herhangi bir şeye ayarlanabilen bir türü temsil eder. Bunu görselleştirmek için en iyi yol, bunu bir yazolarak görmektir.

type List<T> = {T}

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

Jenerikler ayrıca parantezlerin içinde çoklu değiştirme olabilir.

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

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

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

İşlev Genikleri

Fonksiyonlar ayrıca genikleri kullanabilir. State örneği, iç argumentlerin T değerini işlevin gelen argümanlarından tahmin eder.

Genel bir işlev tanımlamak için, işlev adına bir <> 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>

Çıkışları Yaz

Bir türün bir ModuleScript dışında kullanılabilmesi için, şu anahtar kelimeyi kullanın: export

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

Tip Modülü'nü Kullanan Kod
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()