การตรวจสอบประเภท

Luau สนับสนุนระบบชนิดของเรื่องที่เป็นระเบียบาลผ่านการใช้งานของลักษณะการใช้งานและลักษณะทางคำอธิบาย เหล่านี้ใช้เพื่อให้คำเตือนที่ดีขึ้น ข้อผิดพลาด และคำแนะนำใน เว็บไซต์เรื่องการเขียนสคริป

การกำหนดประเภท

ใช้คำว่า type เพื่ออธิบายประเภทของคุณเอง:

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

โหมดการใด้สมอง

มีสามโหมดการใช้งานประเภท Luau ที่สามารถตั้งค่าได้ในบรรทัดแรกของ Script :

• --!nocheck - อย่าตรวจสอบประเภท
• --!nonstrict - โหมดปกติสำหรับสคริปทั้งหมดเท่านั้น ยืนยันประเภทแปรเท่านั้นหากพวกเขาถูกแสดงอย่างชัดเจน
• --!strict - พิมพ์

โหมดปกติสำหรับตัวตรวจสอบชนิดนี้คือ --!nonstrict โหมดอื่น ๆ ควบคุมว่าตัวตรวจสอบชนิดนี้เคยเข้มงวดเกี่ยวกับการใช้งานและการตรวจสอบประเภทสำหรับตัวแปร

รูปแบบ

การกำหนดค่าคำอธิบายชนิดสามารถใช้ตัวประกาศนียภาพ : หลังตัวแปรท้องถิ่นหลังจากการกำหนดค่าคำอธิบาย โดยปกติในโหมด nonstrict ทุกตัวแปรได้รับการกำหนดค่าประเภท any

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

มีสี่ประเภทพื้นฐานที่สามารถใช้ในการอธิบาย:

• nil - มีค่า
• boolean - true หรือ false
• number - มูลค่าตัวเลข
• string - ข้อความ

ภายใน Roblox คลาสทุกคลาส ข้อมูลชนิด และ enums มีข้อมูลชนิดของตัวเองที่คุณสามารถตรวจสอบได้:

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

เพื่อให้ใช้ประเภทได้ออปชัน ใช้ ? ที่ด้านหลังของการแก้ไข:

local foo: string? = nil

นี่จะช่วยให้แปรนี้เป็นประเภทที่กำหนดหรือ string ในกรณีนี้หรือ nil

รูปแบบตัวอักษร

คุณยังสามารถใช้ตัวแปรสตริงและ booleans ในรูปแบบตัวอักษรได้แทนที่จะใช้ string และ boolean :

local alwaysHelloWorld: "Hello world!" = "Hello world!"
alwaysHelloWorld = "Just hello!"  -- ประเภทข้อผิดพลาด: ไม่สามารถแปลงได้เป็น "สวัสดีโลก!"

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

ประเภท Casts

ในบางครั้งคุณอาจต้องช่วยผู้ตรวจสอบชนิดด้วยการโยนค่าให้เป็นชนิดอื่นด้วย :: ตัวประกอบ:

local myNumber = 1
local myString: string

myString = myNumber  -- ไม่เป็นไปตามที่คุณต้องการ; พิมพ์ข้อผิดพลาดการแปลง
myString = myNumber :: any  -- ตกลง; คุณสามารถใช้คำแบบใดก็ได้
local myFlag = myNumber :: boolean  -- Not OK; types are unrelated

พิมพ์ระเบียบเรียง

พิจารณาฟังก์ชันต่อไปนี้:

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

คุณสมบัตินี้เพิ่ม x ไปยัง y แต่ข้อผิดพลาดถ้าหนึ่งหรือทั้งสองของพวกเขาเป็นสตริง Luau ไม่รู้ว่าคุณสมบัตินี้สามารถใช้ตัวเลขเท่านั้น เพื่อป้องกันประเภทของปัญ

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

Luau ตอนนี้รู้ว่าฟังก์ชันใช้ตัวเลขสองตัวและแสดงคำเตือนถ้าคุณพยายามผ่านอะไรที่ไม่ใช่ตัวเลขในฟังก์ชัน:

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

พิมพ์: ที่จุดสิ้นสุดของการตั้งค่าฟังก์ชัน:

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

เพื่อส่งค่าหลายชนิด ให้วางค่าในกุญแจ:

local function FindSource(script: BaseScript, pattern: string): (string, number)
	return 42, true  -- ประเภทข้อผิดพลาด
end

การกำหนดประเภทการใช้งาน

รูปแบบที่มีประสิทธิภาพสามารถกำหนดได้โดยการใช้คำสั่ง (in) -> out โดยใช้ฟังก์ชันจากตัวอย่างก่อนหน้านี้ ประเภทของฟังก์ชันคือ:

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

รูปแบบตาราง

Luau ไม่มีประเภท table แต่อย่างใดอย่างหนึ่ง ประเภทตารางได้รับการกำหนดโดยใช้ {} สังคม ประเภทตารางได้รับการกำหนดโดยใช้ {type} คําแนะนํา

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

กำหนดรูปแบบดัชนีโดยใช้ {[indexType]: valueType} :

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

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

ตารางยังสามารถมีดัชนีสตริงที่ชัดเจนในชนิด

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

local function drive(car)
	-- เสมอไปขีด จำกัด ความเร็ว
end

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

ตัวแปร

นี่คือคำสั่งที่คำนวณจำนวนเงินสุทธิของจำนวนเงินใด ๆ:

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

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

	return sum
end

ตามที่คาดไว้, ฟังก์ชันนี้สามารถรับค่าใด ๆ พิมพ์, เช่น string

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

แทนที่, กำหนดประเภทให้กับ ... พิมพ์:

local function addLotsOfNumbers(...: number)

และตอนนี้บรรทัดที่สองจะเกิดข้อผิดพลาดชนิดขึ้น

print(addLotsOfNumbers(1, 2, 3, 4, 5))
print(addLotsOfNumbers(1, 2, "car", 4, 5))  -- ข้อผิดพลาดประเภท: ค่าสตริงไม่สามารถแปลงเป็นตัวเลขได้

อย่างไรก็ตาม นี่ไม่ทำงานเมื่อเขียนคำอธิบายประเภทที่ใช้งานได้:

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

แทนที่นี้ใช้คําอธิบาย ...type พิมพ์

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

สหภาพและการเข้าสู่

คุณสามารถกำหนดประเภทได้หลายประเภทโดยใช้คําต่อหรือสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสามสาม

type numberOrString = number | string
type type1 = {foo: string}
type type2 = {bar: number}
type type1and2 = type1 & type2  -- {foo: สตริง} & {bar: number}

local numString1: numberOrString = true  -- ชนิดของข้อผิดพลาด
local numString2: type1and2 = {foo = "hello", bar = 1}

กำหนดประเภทที่แนะนำ

คุณสามารถใช้คุณสมบัติ typeof ในคำอธิบายประเภทสำหรับประเภทที่แนะนำ:

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

วิธีหนึ่งในการใช้ typeof คือการใช้ประเภทตารางในการใช้งาน setmetatable ภายในการใช้งาน typeof โดยใช้

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

-- Vector + Vector would return a Vector type

ทั่วไป

Generics อยู่ในระดับตัวแปรระดับพื้นฐานสำหรับประเภท พิจารณาวัตถุ State ต่อไปนี้:

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

โดยไม่ต้องใช้เครื่องมือกำหนดค่า ชุดตัวอย่างสำหรับตัวนี้จะเป็นด้านล่าง:

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

อย่างไรก็ตามคุณอาจต้องการให้ประเภท Value ที่จะอ้างอิงจากค่าที่เข้ามาซึ่งเป็นที่ที่สเน็ปเข้ามา:

type GenericType<T> = T

<T> หมายถึงสไตล์ที่สามารถตั้งได้ที่ใดก็ได้ พิมพ์

type List<T> = {T}

local Names: List<string> = {"Bob", "Dan", "Mary"}  -- ประเภทกลายเป็น {สตริง}
local Fibonacci: List<number> = {1, 1, 2, 3, 5, 8, 13}  -- Type becomes {number}

Generics ยังสามารถมีการแทนที่หลายรายการภายในช่องเก็บข้อมูล

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

เพื่อทำงานใหม่ State พิมพ์:

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

ระเบียบทั่วไป

ฟังก์ชันยังสามารถใช้ตัวอักษรเว้นวรรคได้ ตัวอย่าง State ให้เฉพาะค่า T จากตัวอักษรที่เข้ามาของฟังก์ชัน

เพื่อกำหนดคุณสมบัติทั่วไปให้เพิ่ม <> เข้าชื่อคุณสมบัติ

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

local Activated = State("Activated", false)  -- สถานะ<button>
local TimesClicked = State("TimesClicked", 0)  -- State<number>

ส่งออกชนิด

เพื่อให้สามารถใช้ประเภทนี้ได้นอก ModuleScript ใช้คำว่าดุลยภาค export คำ

ใส่โมดูลใน ReplicatedStorage
export type Cat = {
	Name: string,
	Meow: (Cat) -> ()
}

สคริปต์โดยใช้ Modules ชนิด
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()