Luau Cheat Sheet: דף עזר מהיר
מצבי בדיקת טיפוסים
הערה בשורה הראשונה של הקובץ קובעת עד כמה Luau בודקת אותו בקפדנות.
| מצב | תחביר |
|---|---|
| בלי בדיקת טיפוסים | --!nocheck |
| ברירת מחדל: בדיקה של מה שמסומן | --!nonstrict |
| קפדני: הסקה ובדיקה של הכול | --!strict |
| הרצת קובץ | luau main.luau |
| בדיקת טיפוסים בלי הרצה | luau-analyze main.luau |
| כיבוי אזהרת lint אחת | --!nolint UnknownGlobal |
טיפוסים בסיסיים
טיפוסים פרימיטיביים ואיך מסמנים טיפוס של משתנה.
| פעולה | תחביר |
|---|---|
| מספר | local age: number = 25 |
| מחרוזת | local name: string = "Ada" |
| בוליאני | local ok: boolean = true |
| אופציונלי (יכול להיות nil) | local nick: string? = nil |
| Any (יציאה מהבדיקה) | local x: any = f() |
| Unknown (any בטוח יותר) | local x: unknown = f() |
| Never (תמיד זורק שגיאה) | function fail(): never error("boom") end |
| Nil | local n: nil = nil |
| Coroutine / buffer | local co: thread, local b: buffer |
| מוסק: אין צורך בסימון | local hp = 100 -- number |
טבלאות עם טיפוסים: מערכים ו-maps
טבלאות הן עדיין טבלאות של Lua: הטיפוס אומר מה יש בתוכן.
| פעולה | תחביר |
|---|---|
| מערך של מספרים | local xs: {number} = {1, 2, 3} |
| מערך של מחרוזות | local names: {string} = {} |
| Map (מפתחות מחרוזת) | local ages: {[string]: number} = {} |
| Map (כל טיפוס מפתח) | local seen: {[Player]: boolean} = {} |
| מערך מקונן | local grid: {{number}} = {} |
| מערך של מבנים | local items: {{id: number}} = {} |
| מערך לקריאה בלבד | local t = table.freeze({1, 2, 3}) |
| מעבר על האיברים (כללי, רק ב-Luau) | for i, v in xs do print(i, v) end |
| מעבר על מפתחות וערכים | for k, v in pairs(ages) do end |
פונקציות
סמנו את הפרמטרים ואת טיפוס ההחזרה; -> () פירושו שלא מוחזר כלום.
| פעולה | תחביר |
|---|---|
| פרמטרים עם טיפוס + החזרה | function add(a: number, b: number): number |
| לא מחזירה כלום | function log(msg: string): () end |
| כמה ערכי החזרה | function split(s: string): (string, string) |
| פרמטר אופציונלי | function greet(name: string?) end |
| ערך ברירת מחדל | function greet(name: string?) name = name or "friend" end |
| מספר משתנה של ארגומנטים | function sum(...: number): number end |
| פונקציה אנונימית | local f = function(x: number): number return x * 2 end |
| טיפוס של פונקציה | type Adder = (number, number) -> number |
| פרמטר callback | function each(f: (number) -> ()) end |
כינויי טיפוסים, unions וליטרלים
תנו שם לטיפוס פעם אחת, והשתמשו בו בכל מקום.
| פעולה | תחביר |
|---|---|
| כינוי לטיפוס פרימיטיבי | type Health = number |
| Union (איחוד) | type Id = number | string |
| אופציונלי הוא union עם nil | type Maybe = string | nil -- same as string? |
| טיפוס ליטרל (singleton) | type Dir = "up" | "down" |
| Intersection (חיתוך) | type Both = Named & Aged |
| כינוי גנרי | type List<T> = {T} |
| ייצוא ממודול | export type Point = { x: number, y: number } |
| הטיפוס של ערך קיים | type Config = typeof(config) |
| המפתחות של טיפוס טבלה | type K = keyof<Point> |
מבני טבלאות ומתודות
תיאור אובייקטים, וה-self שמגיע עם קריאות בנקודתיים.
| פעולה | תחביר |
|---|---|
| מבנה בתוך השורה | local p: { x: number, y: number } = { x = 0, y = 0 } |
| מבנה עם שם | type Point = { x: number, y: number } |
| מאפיין אופציונלי | type User = { name: string, age: number? } |
| מבנה + indexer | type Bag = { count: number, [string]: any } |
| הרחבת מבנה | type Admin = User & { level: number } |
| מתודה (קיצור בנקודתיים) | function Point.move(self: Point, dx: number) end |
| מתודה בתוך טיפוס | type Point = { move: (self: Point, dx: number) -> () } |
| דפוס בנאי | function Point.new(x: number): Point end |
| קבועים מוקפאים (בסגנון enum) | local Color = table.freeze({ Red = 1, Blue = 2 }) |
Generics
פונקציה או טיפוס אחד שעובדים עם הרבה טיפוסי ערכים.
| פעולה | תחביר |
|---|---|
| פונקציה גנרית | function id<T>(x: T): T return x end |
| שני פרמטרי טיפוס | function pair<A, B>(a: A, b: B): (A, B) end |
| גנרית על מערך | function first<T>(xs: {T}): T? return xs[1] end |
| כינוי טיפוס גנרי | type Stack<T> = { items: {T} } |
| שימוש בכינוי עם טיפוס | local s: Stack<string> = { items = {} } |
| פונקציית map גנרית | function map<T, U>(xs: {T}, f: (T) -> U): {U} end |
| Generic pack (מספר משתנה) | function call<T...>(f: () -> T...): T... end |
צמצום טיפוסים, assertions ו-guards
לשכנע את בודק הטיפוסים שערך הוא מה שאתם יודעים שהוא.
| פעולה | תחביר |
|---|---|
| Type assertion (המרה) | local n = value :: number |
| Assertion דרך any | local n = (value :: any) :: number |
| צמצום עם typeof | if typeof(x) == "string" then -- x הוא string end |
| צמצום של אופציונלי | if name then print(#name) end |
| יציאה מוקדמת על nil | if not name then return end |
| צמצום union של ליטרלים | if dir == "up" then end |
| בדיקה בזמן ריצה + שגיאת טיפוס | assert(typeof(id) == "number", "id must be a number") |
| וידוא שאינו nil ואז שימוש | local item = assert(find(id), "missing item") |
אופרטורים ותחביר שאין ב-Lua
התוספות היומיומיות שמקלות על החיים: כאן קוד Luau מפסיק להיראות כמו Lua.
| פעולה | תחביר |
|---|---|
| חיבור והשמה | hp += 10 |
| חיסור / כפל / חילוק | hp -= 5, dmg *= 2, dmg /= 2 |
| חילוק שלמים והשמה | n //= 2 |
| שארית / חזקה והשמה | n %= 3, n ^= 2 |
| שרשור והשמה | msg ..= "!" |
| חילוק שלמים | local half = 7 // 2 -- 3 |
| שילוב משתנים במחרוזת | Hello, {name}! You have {n} items. (עטפו ב-backticks) |
| שילוב ביטוי במחרוזת | Total: {price * qty} (עטפו ב-backticks) |
| המשך לאיטרציה הבאה | for _, v in xs do if v < 0 then continue end end |
| ביטוי if-then-else | local label = if hp > 0 then "alive" else "dead" |
| ביטוי else-if משורשר | local t = if n > 0 then "pos" elseif n < 0 then "neg" else "zero" |
| ליטרלים בינאריים / עם מפרידים | 0b1010, 1_000_000 |
תוספות בספריות והבדלים מ-Lua
פונקציות בספרייה הסטנדרטית ש-Luau מוסיפה, והיכולות של Lua שהיא מסירה.
| פריט | פירוט |
|---|---|
| חיפוש ערך במערך | table.find(xs, 42) -- אינדקס או nil |
| העתקה רדודה | local copy = table.clone(t) |
| הפיכה לבלתי ניתן לשינוי / בדיקה | table.freeze(t), table.isfrozen(t) |
| הקצאה מראש של מערך | table.create(10, 0) |
| הגבלה לטווח / עיגול / סימן | math.clamp(x, 0, 1), math.round(x), math.sign(x) |
| פעולות על ביטים | bit32.band(a, b), bit32.lshift(a, 1) |
| הוסרו לטובת sandboxing | io, package, loadstring, loadfile, dofile |
| הוצאו משימוש אבל עדיין קיימות | getfenv, setfenv (הן מבטלות אופטימיזציות) |
| לא קיים ב-Luau | goto / תוויות (Luau מבוססת על Lua 5.1) |
| קריאה מ-stdin ב-Coddy | io.read() עובד כאן: Coddy מחזירה אותו מעל Luau |
| סיומת קובץ | main.luau (גם .lua עובד) |
| רק ב-Roblox, לא חלק מליבת Luau | game, workspace, Instance.new, task.wait |
Luau היא Lua 5.1 בתוספת מערכת טיפוסים הדרגתית: השפה ש-Roblox יצרה ופתחה כקוד פתוח. ה-Luau cheat sheet הזה מכסה את החלקים ש*אינם* Lua רגילה: הערות טיפוס, טבלאות עם טיפוסים, unions וטיפוסי ליטרל, generics, type assertions, והקיצורים התחביריים ש-Luau מוסיפה (+=, שילוב משתנים במחרוזות, continue, ביטויי if-then-else). לכל מה ששתי השפות חולקות, טבלאות, metatables, coroutines וספריית string, השאירו את דף העזר של Lua פתוח לצד הדף הזה.
כל קטע קוד כאן הוא Luau סטנדרטי, שאפשר להריץ עם ה-CLI של luau ולבדוק את הטיפוסים שלו עם luau-analyze. העתיקו את מה שצריך, או נסו כל חלק בזמן אמת בעורך האונליין של Luau, בלי שום התקנה. לומדים את מערכת הטיפוסים מאפס? קורס Luau האינטראקטיבי והחינמי של Coddy בונה אותה שיעור אחר שיעור.
שאלות נפוצות על ה-Luau cheat sheet
האם ה-Luau cheat sheet הזה בחינם?
כן. ה-Luau cheat sheet הזה חינמי לגמרי ולא דורש הרשמה. שמרו אותו במועדפים לפעם הבאה שתצטרכו את התחביר של union, של generic או של טבלה עם טיפוסים.
האם יש ב-Luau אופרטור +=?
כן. בניגוד ל-Lua רגילה, Luau תומכת בהשמה מורכבת:
+=, -=, *=, /=, //=, %=, ^=, ו-..= לשרשור מחרוזות. לכן hp += 10 הוא Luau תקין (וגם קוד סקריפט תקין ב-Roblox), ואילו ב-Lua 5.1 צריך לכתוב hp = hp + 10. שימו לב שאין ב-Luau ++ או --.מה ההבדל בין Lua ל-Luau?
Luau היא הרחבה של Lua 5.1 עם מערכת טיפוסים הדרגתית. מעבר לטיפוסים היא מוסיפה שילוב משתנים במחרוזות עם backticks, אופרטורי השמה מורכבת,
continue, ביטויי if-then-else, חילוק שלמים //, מעבר כללי על אוספים (for i, v in t do), ופונקציות ספרייה כמו table.find, table.clone ו-table.freeze. לטובת sandboxing היא מסירה את loadstring, loadfile, dofile, ואת הספריות io ו-package, ואין בה goto כי היא מבוססת על 5.1. רוב קוד ה-Lua הרגיל רץ בלי שינוי כ-Luau.איך מפעילים בדיקת טיפוסים ב-Luau?
שימו הערת מצב בשורה הראשונה של הקובץ:
--!strict בודק הכול ומסיק טיפוסים באגרסיביות, --!nonstrict (ברירת המחדל) בודק רק את מה שסימנתם, ו---!nocheck מכבה את הבדיקה. מחוץ לעורך קוד, הריצו luau-analyze main.luau כדי לבדוק טיפוסים בלי להריץ, ו-luau main.luau כדי להריץ.האם כותבים interface ב-Luau כמו ב-TypeScript?
לא. אין ב-Luau מילת מפתח
interface. מבנים של אובייקטים נכתבים כטיפוסי טבלה ומקבלים שם עם type: type User = { name: string, age: number? }. משלבים מבנים עם & במקום extends, ומשתמשים ב-export type כדי להפוך מבנה לזמין למודולים אחרים.האם דף העזר הזה זהה לכתיבת סקריפטים ב-Roblox?
כל מה שכאן הוא ליבת Luau, כלומר השפה עצמה, ולכן הוא חל גם על סקריפטים ב-Roblox וגם על Luau עצמאית. מה ש*לא* נמצא כאן הוא ה-API של מנוע Roblox (
game, workspace, Instance.new, שירותים, אירועים), שהוא ספרייה מעל השפה ומתועד על ידי Roblox, לא על ידי Luau.איפה אפשר להריץ את קטעי ה-Luau האלה?
בעורך האונליין של Luau: הוא מריץ את מפרש
luau האמיתי בדפדפן, עם תמיכה ב-stdin, כך שאפשר להדביק כל שורה מהעמוד הזה וללחוץ Run. לתרגול מסודר, קורס Luau האינטראקטיבי מכסה את אותו חומר עם תרגילים, פרויקטים ותעודה.משאבים קשורים
עוד דפי עזר
