הצגת המקור של הדף "לואה (שפת תכנות)"

{{שפת תכנות
| שם = לואה
| שם בשפת המקור = Lua
| תמונה = [[קובץ:Programming in Lua, 4th Edition.jpg|150px]]
| כיתוב = מדריך השפה מאת רוברטו ירוסלמשי
| סמל = [[קובץ:Lua-Logo.svg|100px|סמליל שפת התכנות לואה]]
| כיתוב סמל = הסמליל של לואה החל משנת 1998
| פרדיגמות = [[תכנות מונחה דגמי אב]], [[תכנות אימפרטיבי]], [[תכנות פרוצדורלי]], [[תכנות פונקציונלי]]
| מתכנן = רוברטו ירוסלמשי, לואיז הנריק דה פיגרדו, ו־ולדמר סלס
| מפתח = [[האוניברסיטה הקתולית (ריו דה ז'ניירו)|אוניברסיטה הקתולית]] (PUC Rio) שב[[ריו דה ז'ניירו]]
| טיפוסיות = דינמית
| מימושים = [https://www.lua.org Lua], [http://luajit.org/ LuaJIT]
| ניבים = [http://metalua.luaforge.net/ Metalua<!--{{dead link |date=July 2018}}-->], [http://idle.thomaslauer.com Idle], [https://www.nongnu.org/gsl-shell/ GSL Shell]
| הושפעה על ידי = [[C++]], [[CLU (שפת תכנות)|CLU]], [[Modula-2]], [[Scheme]], [[SNOBOL]]
| השפיעה על = [[GameMonkey]], [[Io (שפת תכנות)|Io]], [[JavaScript]], [[Julia (שפת תכנות)|Julia]], [[MiniD (שפת תכנות)|MiniD]], [[Red (שפת תכנות)|Red]], [[Ring (שפת תכנות)|Ring]], [[Ruby]], [[Squirrel (שפת תכנות)|Squirrel]], [[MoonScript (שפת תכנות)|MoonScript]]
| רישיון = [[רישיון MIT]]
| סיומת = .lua
| אתר אינטרנט = https://www.lua.org
}}
'''לוּאה''' ('''Lua''', מ[[פורטוגזית]]: [[ירח]]) היא [[שפת תכנות דינמית]] שפותחה על ידי {{מונחון|רוברטו ירוסלמשי|Roberto Ierusalimschy}}, {{מונחון|לואיז הנריק דה פיגרדו|Luiz Henrique de Figueiredo}}, ו־{{מונחון|ולדמר סלס|Waldemar Celes}} בשנת 1993 ב[[האוניברסיטה הקתולית (ריו דה ז'ניירו)|אוניברסיטה הקתולית]] (PUC Rio) שב[[ריו דה ז'ניירו]].<ref name=":1" group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], About the Book, pp. xiii–xviii</ref><ref name=":2" /> הגרסה הציבורית הראשונה של לואה פורסמה בשנת 1994.<ref name=":2" /><ref name=":0" /><ref name=":1" /><ref name=":3" /> לואה משמשת בעיקר כשפת תכנות מוטמעת בתוכניות אחרות.<ref name=":1" group="א" /><ref name=":2" /> ה[[מפרש (תוכנה)|מפרש]] הסטנדרטי של השפה כתוב בשפת [[C (שפת תכנות)|C]] ומופץ כ[[תוכנה חופשית]] ב[[רישיון MIT]] בקשת רחבה של פלטפורמות.<ref name=":1" group="א" /><ref name=":2" />

==היסטוריה==
=== TECGRAF ===
'''TECGRAF''' היא ה[[מעבדה]] ל[[גרפיקה ממוחשבת]] של האוניברסיטה הקתולית שב[[ריו דה ז'ניירו]].<ref name=":2" /> המעבדה נוסדה בשנת 1987.<ref name=":2" /> המעבדה פיתחה [[ספרייה (תכנות)|ספריות]] [[GUI|ממשק גרפיות]] ו[[מנהל התקן|מנהלי התקנים]] גרפיים כדי לספק ללקוחות שלה תוכנות עם ממשקים ידידותיים למשתמש.<ref name=":2" />

בין השנים 1977–1992 ל[[ברזיל]] הייתה מדיניות [[מסחר]] שהקשתה מאוד על ייבוא מוצרי [[חומרה]] ו[[תוכנה]] מתוך מחשבה [[לאומנות|לאומנית]] שברזיל יכולה וחייבת לפתח חומרה ותוכנה משלה.<ref name=":2" /> על רקע מצב זה המעבדה TECGRAF נאלצה לפתח את הספריות והשפות המקוריות שלה במקום להישען על מוצרים [[טכנולוגיה|טכנולוגיים]] קיימים.<ref name=":2" />

אחת מהלקוחות הכי חשובים של TECGRAF היה חברת ה[[נפט]] הברזילאית [[פטרוברז]].<ref name=":2" /> TECGRAF פיתחה סך הכול שלוש [[שפת תכנות|שפות תכנות]] עבור הצרכים של פטרוברז.<ref name=":2" /> שתי שפות התכנות הראשונות, DEL ו־SOL, הובילו לפיתוחה של לואה.<ref name=":2" />

=== DEL ===
'''Data-entry Language''' (ב[[ראשי תיבות]]: '''DEL''', ב[[עברית]]: '''שפה לקליטת נתונים''') הייתה [[תכנות הצהרתי|שפת תכנות הצהרתית]] קטנה שפותחה על ידי TECGRAF עבור [[פטרוברז]].<ref name=":2" /> בשנת 1992 פטרוברז פנתה ל־TECGRAF בבקשה לפתח לה [[ממשק משתמש]] ידידותי עבור המהנדסים בחברה שנאלצו עד כה להשתמש ב[[כרטיס מנוקב|כרטיסים מנוקבים]] כדי להזין נתונים מספריים למחשבים.<ref name=":2" /> DEL הייתה שפה מוצלחת מאוד אך די מוגבלת; בעקבות זאת, נדרשו עוד ועוד יכולות חדשות לשפה כגון [[בקרת זרימה]], מה שהוביל את המעבדה למסקנה שנדרש פיתוח של שפת תכנות חדשה.<ref name=":2" />

=== SOL ===
'''Simple Object Language''' (בראשי תיבות '''SOL''', בעברית: '''שפת עצמים פשוטה''') הייתה שפת תכנות הצהרתית עם [[טיפוסיות]] חזקה שפותחה על ידי TECGRAF עבור פטרוברז.<ref name=":2" /> SOL הושפעה רבות מ־[[BibTeX]] ו־UIL, שפה ששימשה לעיצוב ממשקים גרפיים במערכות [[יוניקס]].<ref name=":2" /> הפיתוח של SOL הושלם בשנת 1993, אך השפה מעולם לא הושקה בפועל.<ref name=":2" /> בפטרוברז כבר דרשו תמיכה ב[[תכנות פרוצדורלי]]; בעקבות כך, TECGRAF החליטו להחליף את שתי השפות באחת שתתן מענה מקיף לכל הדרישות של פטרוברז, וכך נולדה לואה.<ref name=":2" />

=== PUC Rio Lua ===
הפיתוח של לואה החל בשנת 1993 על ידי [[מדען מחשב|מדען המחשב]] {{מונחון|רוברטו ירוסלמשי|Roberto Ierusalimschy}}, ה[[מתמטיקאי]] {{מונחון|לואיז הנריק דה פיגרדו|Luiz Henrique de Figueiredo}}, ו[[מהנדס תוכנה|מהנדס התוכנה]] {{מונחון|ולדמר סלס|Waldemar Celes}}; השלושה עבדו יחד ב־TECGRAF.{{כ}}<ref name=":2" /> משמעות השם "Lua" בפורטוגזית היא [[ירח]]; השם נבחר בעקבות שמה של שפת התכנות SOL שקדמה ללואה, מכיוון שמשמעות המילה "Sol" בפורטוגזית היא [[השמש|שמש]].<ref name=":2" /> לואה ירשה מ־SOL את יעודה כשפה לתיאור נתונים, ומ־DEL את יעודה כ{{מונחון|שפה משובצת|embedded language}}.<ref name=":2" /> בנוסף ל־SOL ו־DEL, לואה הושפעה גם מ[[מודולה-2|מודולה־2]], [[CLU (שפת תכנות)|CLU]], [[Scheme]], {{משמאל לימין|C++}}, ו־[[SNOBOL]].<ref name=":2" /> מודולה־2 תרמה את רוב התחביר וה[[מילים שמורות|מילים השמורות]] בשפה.<ref name=":2" /> Scheme הייתה מקור להשראה עבור הסמנטיקה בשפה; לדוגמה, התייחסות לפונקציות כערכים והמעבר ההדרגתי ל{{מונחון|[[תחום הכרזה]] לקסיקלי|lexical scope}}.<ref name=":2" /> CLU נתנה השראה לריבוי החזרות והקצאות מפונקציות.<ref name=":2" /> [[++C]] נתנה השראה ל{{מונחון|משתנים מקומיים|locals}}.<ref name=":2" /> SNOBOL נתנה השראה לטבלאות בשפה.<ref name=":2" />

==== Lua 1.0–1.1 ====
בשנת 1993 הסתיים הפיתוח של Lua 1.0, אבל גרסה זו לא שוחררה לציבור באותו הזמן.<ref name=":2" /><ref name=":0">{{קישור כללי|כתובת=https://www.lua.org/news.html|כותרת=News|אתר=www.lua.org|תאריך_וידוא=2022-09-01}}</ref><ref name=":1">{{קישור כללי|כתובת=https://www.lua.org/versions.html|כותרת=Version history|אתר=www.lua.org|תאריך_וידוא=2022-09-01}}</ref> ה[[ניתוח לקסיקלי|מנתח הלקסיקלי]] הראשון של השפה פותח באמצעות [[Lex]] ו־[[Yacc]].<ref name=":2" />

בשנת 1994 שוחררה Lua 1.1 וזמן קצר לאחר מכן פורסם המאמר שהציג לראשונה את השפה לקהל הרחב.<ref name=":2" /><ref name=":0" /><ref name=":1" /><ref name=":3">{{קישור כללי|כתובת=https://www.lua.org/semish94.html|הכותב=Luiz Henrique de Figueiredo, Roberto Ierusalimschy, Waldemar Celes Filho|כותרת=The design and implementation of a language for extending applications|אתר=www.lua.org|תאריך_וידוא=2022-09-01}}</ref> גרסה זאת הייתה חופשית לשימוש אקדמי אך לא לשימוש מסחרי.<ref name=":2" /><ref name=":0" /> בגרסה זו פותח מנתח לקסיקלי חדש לשפה שהכפיל את מהירות הניתוח התחבירי.<ref name=":2" />

==== Lua 2.1–2.5 ====
בשנת 1995 פורסמה Lua 2.1.<ref name=":2" /><ref name=":0" /><ref name=":1" /> בגרסה זו הופיע לראשונה התחביר שאפשר חיקוי של [[תכנות מונחה-עצמים|תכנות מונחה עצמים]] בשפה, ונוסף מנגנון ל{{מונחון|מצבי נסיגה|fallback}}.<ref name=":2" /><ref name=":1" /><ref>{{קישור כללי|כתובת=https://www.lua.org/spe.html|הכותב=Luiz Henrique de Figueiredo, Roberto Ierusalimschy, Waldemar Celes Filho|כותרת=Lua: An extensible extension language|אתר=www.lua.org|תאריך_וידוא=2022-09-01}}</ref> החל מגרסה זאת היישום המרכזי של לואה הפך להיות חופשי גם לשימוש מסחרי.<ref name=":2" /><ref name=":1" /> בגרסה הקודמת, לואה הציעה שלוש דרכים ליצירת טבלאות: בסוגריים עגולים <code>()</code> לטבלה ריקה, בסוגריים מרובעים <code>[]</code> למערך מספרים, ובסוגריים מסולסלים <code>{}</code> ל[[רשומה (אחסון נתונים)|רשומה]].<ref name=":2" /> בגרסה זו התחביר ליצירת טבלאות אוחד לסוגריים מסולסלים ופעולת ההשוואה שונתה מ־<code>=</code> ל־<code>==</code> כדי לאפשר את האיחוד בתחביר הטבלאות.<ref name=":2" /> באותה שנה פורסמה Lua 2.2, בגרסה זו התחביר לפונקציות הורחב ונוסף ממשק חדש ל[[ניפוי שגיאות]].<ref name=":2" /><ref name=":1" />

בשנת 1996 פורסמה Lua 2.5.<ref name=":2" /><ref name=":0" /><ref name=":1" /> בגרסה זו נוספו ממשק בשפה לחיפוש [[ביטויים רגולריים|ביטויים]] ב[[מחרוזת (מדעי המחשב)|מחרוזות]], ואפשרות ל{{מונחון|ריבוי פרמטרים בפונקציות|vararg functions}} באמצעות <code>...</code>.<ref name=":2" /><ref name=":1" />

==== Lua 3.0–3.2 ====
בשנת 1997 פורסמה Lua 3.0.<ref name=":2" /><ref name=":0" /><ref name=":1" /> בגרסה זו הטיפוסיות של פונקציות שהוגדרו בלואה ופונקציות שהוגדרו ב[[שפת C]] אוחדה לטיפוסיות אחת עבור שני סוגי הפונקציות.<ref name=":2" /> בגרסה זו המנגנון ל{{מונחון|מצבי נסיגה|fallback}} בשפה התחיל לקבל פרמטר נוסף לסוג ה[[תכנות מונחה-אירועים|אירוע]]: {{מונחון|תג|tag}}.<ref name=":2" />

בשנת 1998 פורסמה Lua 3.1.<ref name=":2" /><ref name=":0" /><ref name=":1" /> בגרסה זו לואה אימצה {{מונחון|[[תחום הכרזה]] לקסיקלי|lexical scope}} חלקי, [[פונקציות למדא|פונקציות אנונימיות]], וייצוג מספרים בשפה באמצעות [[נקודה צפה]] {{מונחון|באורך כפול|double-precision floating-point format}}.<ref name=":2" /><ref name=":1" /> לאור המחסור בלולאת <code>for</code>, חוסר שביעות רצון מלולאות <code>while</code>, ומחלוקת על התחביר האפשרי עבור לולאת <code>for</code>, הוחלט בסוף לספק פונקציה כללית מסדר גבוה מהצורה <code>foreach(t, print)</code> שתבצע עבודה בלולאה מתוך פרמטר של פונקציה.<ref name=":2" /> החל מגרסה זו, ניתן להגדיר מפתח בטבלה באמצעות סוגריים מרובעים כך: <code>t={["key"]=value}</code>.<ref name=":2" /> באותה שנה הושק ה[[סמליל]] הנוכחי של השפה.<ref name=":0" /><ref>{{קישור כללי|כתובת=https://www.lua.org/images/|כותרת=Logos|אתר=www.lua.org|תאריך_וידוא=2022-09-01}}</ref>

בשנת 1999 פורסמה Lua 3.2.<ref name=":2" /><ref name=":0" /><ref name=":1" /> בגרסה זו נוספה ספרייה חדשה בשפה לניפוי שגיאות,<ref name=":2" /> ו{{מונחון|מטא פונקציות|metafunctions}} חדשות עבור טבלאות.<ref name=":1" /> גרסה זו נחשבה לאחת הגרסאות היציבות של לואה, רבים דילגו כליל על Lua 4.0 ועברו מ־Lua 3.2 הישר אל Lua 5.0.<ref name=":2" />

==== Lua 4.0–4.1 ====
בשנת 2000 פורסמה Lua 4.0.<ref name=":2" /><ref name=":0" /><ref name=":1" /> מגרסה זו ניפוי השגיאות בשפה הפך להיות זמין בכל רגע נתון בזמן ריצה ונוספו לולאות מסוג <code>for</code>.<ref name=":2" /><ref name=":1" /> כמו כן, נוספה בשפה ספרייה לאינטראקציה עם [[מערכת הפעלה|מערכות הפעלה]] וממשק ה־C של השפה ידע להתמודד עם ריבוי [[מצב (מדעי המחשב)|מצבים]].<ref name=":2" />

בשנת 2001 פורסמה גרסת אלפא של Lua 4.1.<ref name=":2" /> גרסה זאת הייתה בפועל Lua 5.0 תוך כדי הליך הפיתוח שלה; הקפיצה במספר ל־5.0 התרחשה בשנת 2002 לאחר פיתוח מנגנון חדש לניהול [[מודולריות (תכנות)|מודולריות]] בשפה.<ref name=":2" />

==== Lua 5.0–5.4 ====
בשנת 2003 פורסמה Lua 5.0.<ref name=":2" /><ref name=":0" /><ref name=":1" /> בגרסה זו לואה אימצה {{מונחון|[[תחום הכרזה]] לקסיקלי|lexical scope}} מלא וזנחה את מנגנון היקף המשתנים הקודם, נוספו {{מונחון|שגרות המשך|coroutine}}, [[תהליכון|תהליכונים]], {{מונחון|מטא טבלאות|metatables}}, משתנים בוליאניים, [[מיטוב אלגוריתמים|מיטוב]] ל[[רקורסיית זנב]], טבלאות עם ייחוס משתנים חלש (ייחוס מתירני ל[[איסוף זבל (מדעי המחשב)|איסוף זבל]]), והרחבות נוספות.<ref name=":2" /><ref name=":1" /> החל מגרסה זו לואה שוחררה תחת [[רישיון MIT]].<ref name=":2" /><ref name=":1" /> החל מגרסה זו, ניתן לערבב בטבלאות באופן חופשי בין רשומות ופריטים.<ref name=":2" /> באותה שנה פורסמה המהדורה הראשונה של מדריך השפה.<ref name=":2" /><ref name=":0" /> בחודש יולי באותה שנה Lua 1.0 שוחררה לציבור לרגל חגיגת עשור לשפה.<ref name=":2" />

בשנת 2005 פורסמה הגרסה הראשונה של המהדר LuaJIT.<ref>{{קישור כללי|כתובת=https://luajit.org/download.html|כותרת=Download|אתר=luajit.org|תאריך_וידוא=2022-09-01}}</ref>

בשנת 2006 פורסמה Lua 5.1.<ref name=":2" /><ref name=":0" /><ref name=":1" /> בגרסה זו הופיע מנגנון חדש ל[[איסוף זבל (מדעי המחשב)|איסוף זבל]], תחביר חדש ל[[מודולריות (תכנות)|מודולריות]], מנגנון חדש ל{{מונחון|ריבוי פרמטרים בפונקציות|varargs}}, קינון הערות ומחרוזות בעזרת <code>[==[...]==]</code>, שתי [[אופרטור (תכנות)|פעולות]] חדשות: אורך ו[[מודולו]], {{מונחון|מטא טבלאות|metatable}} לכל ה[[טיפוס נתונים|טיפוסים]], והרחבות נוספות.<ref name=":2" /><ref name=":1" /> באותה שנה פורסמה המהדורה השנייה של מדריך השפה.<ref name=":0" />

בשנת 2011 פורסמה Lua 5.2.<ref name=":0" /><ref name=":1" /> בגרסה זו נוספה ספרייה ל[[פעולות על סיביות]] (פעולות ביטים), יכולת קידוד [[UTF-8]] במחרוזות, [[פקודת goto|פעולת <code>goto</code>]], והרחבות נוספות.<ref name=":1" />

בשנת 2012 [[ויקיפדיה]] אימצה את לואה כ[[שפת תסריט]] ל[[ויקיפדיה:תבנית|תבניות]].<ref name=":0" /><ref name=":8">{{צ-מאמר|שם=Why "Lua" is on everybody's lips, and when to expect MediaWiki 1.19|קישור=https://en.wikipedia.org/w/index.php?title=Wikipedia:Wikipedia_Signpost/2012-01-30/Technology_report&oldid=655406890|כתב עת=Wikipedia Signpost|שנת הוצאה=2015-04-07|מחבר=Jarry1250}}</ref>

בשנת 2013 פורסמה המהדורה השלישית של מדריך השפה.<ref name=":0" />

בשנת 2015 פורסמה Lua 5.3.<ref name=":0" /><ref name=":1" /> בגרסה זו נוסף טיפוס חדש ל[[מספר שלם|מספרים שלמים]], נוספו סימנים חדשים לשפה ל[[פעולה על סיביות|פעולות על ביטים]],<ref group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], Bits and Bytes, pp. 115–123</ref> ספרייה חדשה למחרוזות בקידוד UTF-8,<ref name=":2" group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], Strings, pp. 29–38</ref> ותמיכה במערכות מסוג [[32 ביט]]ים ו־[[64 ביט]]ים.<ref name=":1" />

בשנת 2016 פורסמה המהדורה הרביעית של מדריך השפה.<ref name=":0" />

בשנת 2020 פורסמה Lua 5.4.<ref name=":0" /><ref name=":1" /> בגרסה זו מנגנון חדש לאיסוף זבל, תמיכה במשתנים קבועים באמצעות <code><const></code> ותחביר חדש לסגירת משתנים.<ref name=":1" />

== דוגמאות ==
=== שלום עולם! ===
<syntaxhighlight lang="lua" line="1">
print("Hello world!")
</syntaxhighlight>

=== [[מחלק משותף מקסימלי]] ===
<syntaxhighlight lang="lua" line="1">
local function GCD(a, b)
    while a ~= b do
        if a > b then
            a = a - b
        else
            b = b - a
        end
    end
    return a
end
</syntaxhighlight>

=== עצרת ===
[[שגרה (תכנות)|שגרה]] [[רקורסיה|רקורסיבית]] נאיבית לחישוב [[עצרת (מתמטיקה)|עצרת]] בלי [[מיטוב אלגוריתמים|אופטימיזציה]]:<syntaxhighlight lang="lua" line="1">
local function factorial(n)
    if n == 0 then
        return 1
    end
    return n * factorial(n - 1)
end
</syntaxhighlight>שגרה רקורסיבית לחישוב עצרת עם אופטימיזציה:<syntaxhighlight lang="lua" line="1">
local cache = {
    [0] = 0,
    [1] = 1
}
local function factorial(n)
    if not cache[n] then
        cache[n] = n * factorial(n - 1)
    end
    return cache[n]
end
</syntaxhighlight>

== עיצוב ==
עקרונותיה המעצבים של לואה הם בהירות תחבירית, הצעת מנגנונים בסיסיים במקום מבני שפה מורכבים למקרים ייחודיים, והשימוש בטבלה כ[[מבנה נתונים]] אוניברסלי.<ref name=":2">{{צ-מאמר|שם=The Evolution of Lua|קישור=https://doi.org/10.1145/1238844.1238846|מו"ל=Association for Computing Machinery|כתב עת=Proceedings of the third ACM SIGPLAN conference on History of programming languages|שנת הוצאה=2007-06-09|עמ=2–1–2–26|סדרה=HOPL III|doi=10.1145/1238844.1238846|מחבר=Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes}}</ref> מאפיינים בולטים נוספים של השפה הם ניידות בין [[מערכת הפעלה|מערכות הפעלה]] ו[[ארכיטקטורת מחשב|סוגי מעבדים]] שונים (מפרש השפה כתוב ב[[שפת C]] והוא שוקל פחות מ[[מגה בייט]] אחד), [[תכנות פונקציונלי]], ויעילות ביצועית בזמן ובזיכרון.<ref name=":1" group="א" /><ref name=":2" /> היסטורית, לואה עוצבה להיות שפה מוטמעת לתיאור נתונים.<ref group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], Data Files and Serialization, pp. 137–146</ref><ref name=":2" /> לואה מצוידת במנגנון אוטומטי לאיסוף זבל.<ref name=":1" group="א" /><ref name=":2" /> בלואה, משתנים שלא יוגדרו במפורש כמשתנים מקומיים באמצעות <code>local</code> יוגדרו להיות משתנים גלובליים.<ref name=":0" group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], Getting Started, pp. 3–12</ref><ref name=":6" group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], Filling Some Gaps, pp. 67–76</ref> גישה למשתנים לא קיימים אינה נחשבת לשגיאה בשפה, אלא משתנה לא קיים תמיד יחזיר ערך <code>nil</code>.<ref name=":0" group="א" />

=== סמנטיקה ===
מבחינה סמנטית, לואה שואבת השראה משפת התכנות [[Scheme]].<ref name=":2" /> ההשפעה של Scheme על לואה הייתה ניכרת באופן הדרגתי עם ההתפחות של לואה, במיוחד עם הופעתן של [[פונקציות למדא|פונקציות אנונימיות]] ו{{מונחון|[[תחום הכרזה]] לקסיקלי|lexical scope}} ב־Lua 3.1.<ref name=":2" /> באופן דומה ל־Scheme, ל[[משתנה (תכנות)|משתנים]] אין [[טיפוסיות]], אלא רק ל[[ערך (מדעי המחשב)|ערכים]] יש טיפוסיות; משתנים לעולם לא מעתיקים מבנה נתונים בהקצאה, אלא רק מעתיקים את ה[[מצביע]] לאותו מבנה נתונים; ל[[שגרה (תכנות)|פונקציה]] אין מעמד מיוחד בשפה, היא ככל שאר טיפוסי הנתונים וניתן להקצות אותה למשתנה כלשהו; למעשה לכל המבנים בשפה יש מעמד שווה, ואת כולם ניתן להקצות לתוך משתנים.<ref name=":2" /> עם זאת, קיים הבדל סמנטי מרכזי בין לואה ל־Scheme, בכך שטבלאות הן מבנה הנתונים היחידי בלואה, ומהן המתכנת מרכיב מבני נתונים מורכבים יותר כגון [[מחסנית (מבנה נתונים)|מחסניות]], [[קבוצה (מבנה נתונים)|קבוצות]], ו[[רשימה (מבנה נתונים)|רשימות]].<ref name=":2" />

=== טיפוסי נתונים ===

בלואה, ל[[משתנה (תכנות)|משתנים]] אין [[טיפוסיות]], אלא רק ל[[ערך (מדעי המחשב)|ערכים]] יש טיפוסיות.<ref name=":0" group="א" /> ניתן לבדוק את הטיפוסיות של הערכים באמצעות הפונקציה הגלובלית <code>type</code> כך:<ref name=":0" group="א" /><syntaxhighlight lang="lua">
type(print) -- function
</syntaxhighlight>
{| class="wikitable mw-collapsible"
|+טיפוסי הנתונים הבסיסיים של לואה<ref name=":0" group="א" /><ref group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], Numbers, pp. 17–27</ref><ref name=":2" group="א" />
! colspan="2" |סוג
! colspan="2" |שם
! colspan="3" |דוגמה
!פעולות{{ביאור|לא כולל פונקציות מובנות בשפה}}
!טווח ערכים
|-
| colspan="2" |ערך ריק
| colspan="2" |<code>nil</code>
| colspan="3" |<code>nil</code>
| rowspan="2" |[[שלילה]] <code>not</code>, [[וגם (לוגיקה)|וגם]] <code>and</code>, [[או (לוגיקה)|או]] <code>or</code>
|<code>nil</code>
|-
| colspan="2" |בוליאני
| colspan="2" |<code>boolean</code>
| colspan="3" |<code>true</code>
|<code>true</code> או <code>false</code>{{ביאור|בלואה, כל ערך שאינו nil או false נחשב ל־true, כולל 0 או מחרוזת ריקה.}}
|-
| colspan="2" |טבלה
| colspan="2" |<code>table</code>
| colspan="3" |<code>{}</code>
|גישה והקצאה עם <code>t["key"]</code> או <code>t.key</code>, אורך <code>#</code>
|טבלה
|-
| colspan="2" rowspan="2" |[[שגרה (תכנות)|פונקציה]]
| colspan="2" rowspan="2" |<code>function</code>
| colspan="3" |<code>f = function(x) end</code>
| rowspan="2" |קריאה
| rowspan="2" |פונקציה
|-
| colspan="3" |<code>function f(x) end</code>
|-
| rowspan="3" |[[מספר]]{{ביאור|הפונקציה type לא מבדילה בין מספרים ממשים ומספרים שלמים, אבל הפונקציה math.type מחזירה float עבור מספרים ממשים ו־integer עבור מספרים שלמים.}}
| rowspan="2" |[[מספר ממשי|ממשי]]
| rowspan="3" |<code>number</code>
| rowspan="2" |<code>float</code>{{ביאור|בפועל מדובר בנקודה צפה באורך כפול (double).}}
| colspan="3" rowspan="3" |<code>1.0-</code>
| rowspan="3" |[[ארבע פעולות החשבון|ארבע פעולות חשבון]]: <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code> [[פעולות השוואה]]:{{ביאור|1=פעולות ההשוואה == ו־~= זמינות לכל סוגי הערכים.}} <code>==</code>, <code>~=</code>, <code><</code>, <code>></code>, <code><=</code>, <code>>=</code>, [[מודולו]] <code>%</code>, [[העלאה בחזקה]] <code>^</code>
|<math>-10^{308} \leq x \in \mathbb{R} \leq 10^{308}</math>
|-
|<math>-2^{53} \leq x \in \mathbb{R} \leq 2^{53}</math>{{ביאור|טווח שמאפשר הצגה מדויקת של מספרים שלמים}}
|-
| [[מספר שלם|שלם]]{{ביאור|נוסף בלואה 5.3}}
|<code>integer</code>
|<math>-2^{63} \leq x \in \mathbb{Z} \leq 2^{63} - 1</math>
|-
| colspan="2" |[[מחרוזת (מדעי המחשב)|מחרוזת]]
| colspan="2" |<code>string</code>
|<code>"..."</code>
|<code>'...'</code>
|<code><nowiki>[[...]]</nowiki></code>
|חיבור מחרוזות <code>..</code>, אורך <code>#</code>
|מחרוזת
|-
| colspan="2" |[[תהליכון]]
| colspan="2" |<code>thread</code>
| colspan="3" |
|
|תהליכון
|-
| colspan="2" |ערך ב[[שפת C]]
| colspan="2" |<code>userdata</code>
| colspan="5" |(ערכים בשפת C)
|}
{{ביאורים}}

=== מחרוזות ===
בלואה, מחרוזות הן רצף תווים עם [[קידוד תווים|קידוד]] לא מוגדר.<ref name=":2" group="א" /> לדוגמה, פעולת אורך של מחרוזת לא מתחשבת בסוג הקידוד, אלא בסכום ה[[בית (מחשב)|בתים]] בלבד.<ref name=":2" group="א" /> עם זאת, נהוג להשתמש בקידוד [[UTF-8]], והחל מגרסה 5.3 קיימת ספרייה קטנה בשפה שיודעת להתמודד עם מחרוזות בקידוד UTF-8.<ref name=":2" group="א" /> מחרוזות בלואה לא ניתנות לשינוי, במקום זאת, יוצרים כל פעם מחרוזת חדשה עם השינויים רצויים.<ref name=":2" group="א" /> כשנעשית פעולה מספרית על מחרוזת (כגון חיבור מספרים <code>+</code>), או פעולת מחרוזת על מספר (כגון שרשור <code>..</code>) לואה מנסה לבצע המרה בין מחרוזות ומספרים באופן אוטומטי.<ref name=":2" group="א" /> בשפה זמינה ספרייה נרחבת ל{{מונחון|התאמת דפוסים|pattern matching}}, חיפוש, והחלפה בתוך מחרוזות באמצעות ביטויים דומים ל[[ביטויים רגולריים]].<ref name=":8" group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], Pattern Matching, pp. 89–104</ref>

=== טבלאות ===
בלואה, טבלאות פשוטות מתנהגות כ[[מילון (מבנה נתונים)|מילונים]] והן משמשות להרכבת מבני נתונים מכל הסוגים, כולל [[מערך (מבנה נתונים)|מערכים]], [[מטריצה|מטריצות]], [[רשימה מקושרת|רשימות מקושרות]], [[קבוצה (מבנה נתונים)|קבוצות]], ועוד.<ref name=":3" group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], Tables, pp. 39–48</ref><ref name=":9" group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], Data Structures, pp. 125–136</ref> בניגוד לשפות רבות אחרות, הספירה בלואה תמיד מתחילה ב־<code>1</code> ולא ב־<code>0</code>; כלומר, הפריט הראשון בטבלה מקומו הוא <code>1</code> ולא <code>0</code>.<ref name=":3" group="א" /> ניתן להקצות ערך מכל סוג של [[טיפוס נתונים]] (למעט <code>nil</code> המציין פריט חסר) הן למפתח בטבלה והן לערך אליו המפתח מוביל.<ref name=":3" group="א" /><ref name=":2" /> בנוסף, לא קיימת אכיפה של אחידות ב[[טיפוסיות]] בטבלה, לא במפתחות ולא בערכים.<ref name=":2" /> הפעולה לבדיקת אורך טבלה (<code>#</code>) מתאימה אך ורק לטבלאות רצופות היטב (ללא מקומות ריקים); ומכיוון שאין כל אכיפה בשפה על מיקום פריט בטבלה, ספירת הפריטים בטבלאות היא בדרך כלל באחריות המתכנת.<ref name=":3" group="א" /><ref name=":9" group="א" /> מיקומם של הפריטים בטבלה לא משפיע כלל על גודל הטבלה, מכיוון שטבלאות בשפה הן מילונים ולא מערכים.<ref name=":9" group="א" />

=== פונקציות ===
למרות היותה שפה [[תכנות אימפרטיבי|אימפרטיבית]], ללואה תמיכה מלאה ב[[תכנות פונקציונלי]].<ref name=":7" group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], Closures, pp. 79–88</ref> בלואה, פונקציות הן ערכים לכל דבר ועניין וניתן להקצות אותן לתוך משתנים וטבלאות או להגדיר אותן בתוך ביטויים כ[[תחשיב למדא]].<ref name=":2" /><ref name=":4" group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], Functions, pp. 49–58</ref><ref name=":7" group="א" /> כמו כן, פונקציות בשפה מתנהגות כ־{{מונחון|סגור (שפות תכנות)|סְגוֹר|closure}}; לדוגמה, פונקציות יודעות להחזיר פונקציות חדשות ולהנחיל להן גישה למשתנים מקומיים שהוגדרו מחוצה להן.<ref name=":7" group="א" /> כשאר הערכים בשפה, פונקציות הן אנונימיות בהגדרה, ורק למשתנים שמחזיקים אותן יש שמות.<ref name=":7" group="א" /> בקריאה לפונקציה, פרמטרים חסרים ייחשבו כ־<code>nil</code> ופרמטרים עודפים יושלכו.<ref name=":2" /><ref name=":4" group="א" /> בלואה, פונקציות יכולות להחזיר ריבוי של ערכים.<ref name=":4" group="א" /> כמו כן, לפונקציות אין אכיפה של טיפוסיות לפרמטרים או לערכים שהיא מחזירה; על המתכנת לדאוג לכך באמצעות בדיקות ידניות.<ref name=":4" group="א" /> במקרים מתאימים, לואה מבצעת אופטימיזציית [[רקורסיית זנב]].<ref name=":4" group="א" />

=== קלט ופלט ===
מהיותה שפה ניידת עם תלות מינימלית במערכות הפעלה או חומרה, ללואה ישנן יכולות מעטות ב[[מערכת קבצים|ניהול קבצים]] וקלט נתונים.<ref name=":5" group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], The External World, pp. 59–66</ref> השפה מציעה אך ורק מה שתקן [[C (שפת תכנות)|ISO C]] מציע עבור צורכי [[קלט]] ו[[פלט]] (IO), וניהול קבצים מתקדם יותר בדרך כלל כרוך בשימוש בספריות [[צד שלישי]] או בשיבוץ השפה עם שפה אחרת.<ref name=":5" group="א" /> בין היכולות של לואה הן לכתוב ולקרוא בקבצים, ליצור ולמחוק קבצים, לגשת למשתני <code>ENV</code>, להריץ תוכנה, ולבדוק זמן ותאריך.<ref name=":5" group="א" /><ref group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], Date and Time, pp. 109–114</ref>

=== ניפוי שגיאות ===
לואה מצוידת בספרייה ל[[ניפוי שגיאות]] ו[[טיפול בחריגות]] בזמן ריצה.<ref name=":10" group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], Compilation, Execution, and Errors, pp. 147–157</ref> הפונקציות <code>assert</code> ו־<code>error</code> משמשות לזריקת שגיאות.<ref name=":10" group="א" /> טיפול בחריגות בשפה נעשה באמצעות הפונקציה <code>pcall</code>, הפונקציה מאפשרת להריץ קוד אקראי, לתפוס שגיאות בתוכו, ולמנוע קריסה של התוכנית באירוע שגיאה.<ref name=":10" group="א" /> הספרייה <code>debug</code> נותנת למתכנת כלים כדי לבדוק את {{מונחון|סדר קריאת השגרות|traceback}} ומצב התוכנית בכל נקודת זמן בקוד לבירור הנסיבות של שגיאה כלשהי.<ref name=":10" group="א" />

=== מודולים ===
לואה היא שפה [[מודולריות (תכנות)|מודולרית]]. [[מודול (תוכנה)|מודול]] ניטען באמצעות הפונקציה <code>require</code> אך ורק פעם אחת בזמן ריצה של תוכנית.<ref name=":11" group="א">[[לואה (שפת תכנות)#Programming in Lua|Programming in Lua]], Modules and Packages, pp. 159–168</ref> ניתן לשנות את האופן בו לואה מחפשת או טוענת מודולים באמצעות הספרייה <code>package</code>.<ref name=":11" group="א" /> כמו בשפות דינמיות אחרות, לואה מאפשרת לטעון ולפרש קוד חדש בזמן ריצה לא רק מתוך מודולים, אלא גם מתוך מחרוזת.<ref name=":10" group="א" /> קוד מקור בלואה תמיד עובר הידור למצב ביניים בזמן ריצה, ניתן להדר קובץ קוד מקור בלואה ולשמור אותו באמצעות הפקודה <code>luac</code> במסוף.<ref name=":10" group="א" /> כל יחידת קוד שעוברת פירוש, כגון קובץ [[קוד מקור]] או פקודה תקנית במסוף, נקראת {{מונחון|חתיכה|chunk}}.<ref name=":0" group="א" />

== תחביר ==
מבחינה תחבירית, לואה שואבת השראה משפת התכנות [[מודולה-2|מודולה־2]].<ref name=":2" /> בניגוד למודולה־2, לואה מבדילה בין אותיות גדולות ואותיות קטנות.<ref name=":0" group="א" /> הסימן [[נקודה ופסיק]] (<code>;</code>) מפריד בין [[פקודה (מחשב)|פקודות]], אך אין חובה להשתמש בו, אפילו בין שתי פקודות צמודות.<ref name=":0" group="א" />

=== אסימוני השפה ===
{| class="wikitable mw-collapsible"
|+אסימונים בלואה<ref>{{קישור כללי|כתובת=https://www.lua.org/manual/5.3/manual.html#3.1|כותרת=Lua 5.3 Reference Manual: Lexical Conventions|אתר=www.lua.org|תאריך_וידוא=2022-10-16}}</ref>
! colspan="3" |סיווג
!הגדרה
!דוגמה
|-
|מזהה
| colspan="2" |'''שם [[משתנה (תכנות)|משתנה]]'''
|רצף [[תו (מחשב)|תווי]] אותיות [[אלפבית לטיני]]ות, [[ספרה|ספרות]] [[השיטה העשרונית|עשרוניות]], והתו <code>_</code>, כשהתו הראשון מוכרח להיות אות
|<code>x</code>
|-
| rowspan="7" |[[ערך (מדעי המחשב)|ערך]]
| rowspan="2" |'''[[מספר שלם]]'''
|[[עשרוני]]
|רצף ספרות עשרוניות
|<code>42</code>
|-
|[[הקסדצימלי]]
|רצף תווים שנפתח ב־<code>0X</code> וממשיך בספרות עשרוניות או באותיות מ־<code>A</code> עד <code>F</code>
|<code>0XFFFFFF</code>
|-
| rowspan="3" |'''[[מספר ממשי]]'''
|[[שבר עשרוני]]
|רצף ספרות עשרוניות עם [[נקודה עשרונית]]
|<code>1.25</code>
|-
|[[כתיב מדעי]]
|רצף ספרות עשרוניות עם נקודה עשרונית, התו <code>E</code>, סימן שלילה <code>-</code> ורצף ספרות עשרוניות נוסף.
|<code>4.0E-10</code>
|-
|[[הקסדצימלי]]
|רצף תווים שנפתח במספר הקסדצימלי (ראו במספר שלם), נקודה <code>.</code>, ומספר הקסדצמלי עוקב
|<code>0x0.1E</code>
|-
| rowspan="2" |'''[[מחרוזת (מדעי המחשב)|מחרוזת]]'''
|שורה
|רצף תווים מוקף בתו <code>"</code>, או בתו <code>'</code>
|<code>"ABC"</code>
|-
|קטע
|רצף תווים מוקף ב־<code>[[</code> ו־<code>]]</code>
|<code><nowiki>[[ABC]]</nowiki></code>
|-
| rowspan="4" |תחביר
| colspan="2" |'''[[אופרטור (תכנות)|פעולה]]'''
|כל הופעה של תו המייצג פעולה בשפה
|<code>+</code>
|-
| colspan="2" |'''[[מילה שמורה]]'''
|כל רצף תווים שיוצר מילה מרשימת המילים השמורות
|<code>local</code>
|-
| rowspan="2" |'''הערה'''
|שורה
|רצף תווים שנפתח בזוג מקפים <code>--</code> ונגמר בסוף השורה
|<code>--</code>
|-
|קטע
|רצף תווים בנפתח בזוג מקפים <code>--</code> ובזוג סוגריים מרובעים ונגמר בזוג סוגריים מרובעים כמו במחרוזת; ניתן לקונן קטעים באמצעות מספר מאוזן של התו <code>=</code> בין הסוגריים המרובעים בכל צד.
|דוגמה בהמשך
|}

=== מילים שמורות ===
בלואה 5.3 קיימות 22 [[מילים שמורות]], ולא ניתן להשתמש בהן כמזהים.<ref name=":0" group="א" /> המילים השמורות שהופיעו עם הגרסה הציבורית הראשונה של לואה:<ref name=":4">{{צ-ספר|שם=Reference Manual of the Programming Language Lua|מו"ל=Lua.org|מחבר=Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes|פרק=Lexical Conventions|קישור=https://www.lua.org/ftp/refman-1.1.ps.gz|שנת הוצאה=1994}}</ref>

{{טורים
| רוחב = 26em
| תוכן =
# <code>'''local'''</code> – יצירת משתנה מקומי חדש
# <code>'''nil'''</code> – ערך ריק
# <code>'''function'''</code> – הגדרת [[פונקציה (תכנות)|פונקציה]] חדשה
# <code>'''do'''</code> – פתיחת קטע פקודות בלולאה או [[תחום הכרזה]]
# <code>'''else'''</code> – נסיגת תנאי
# <code>'''elseif'''</code> – שרשור תנאי
# <code>'''end'''</code> – סגירת קטע פקודות או תחום הכרזה
# <code>'''if'''</code> – פתיחת תנאי
# <code>'''repeat'''</code> – פתיחת לולאה מסוג <code>repeat</code>
# <code>'''return'''</code> – להחזיר ערך ולצאת מפונקציה. בלואה הפקודה <code>return</code> חייבת להיות הפקודה האחרונה בתוך קטע של פקודות (קטע פקודות מסתיים במילה <code>end</code>).<ref name=":6" group="א" />
# <code>'''until'''</code> – תנאי למחזור בלולאה מסוג <code>repeat</code>
# <code>'''then'''</code> – פתיחת קטע פקודות לביצוע בתנאי חיובי
# <code>'''while'''</code> – פתיחת לולאה מסוג <code>while</code> והגדרת תנאי למחזור
# <code>'''and'''</code> – [[קשר לוגי]]: [[וגם (לוגיקה)|וגם]]
# <code>'''not'''</code> – קשר לוגי: [[לא (לוגיקה)|לא]]
# <code>'''or'''</code> – קשר לוגי: [[או (לוגיקה)|או]]
}}

מילים שמורות שנוספו בגרסה 4.0:<ref name=":5">{{קישור כללי|כתובת=https://www.lua.org/manual/4.0/manual.html#4.1|כותרת=Lua: 4.0 Reference Manual: Lexical Conventions|אתר=www.lua.org|תאריך_וידוא=2022-09-16}}</ref>

# <code>'''break'''</code> – עצירת לולאה ויציאה ממנה
# <code>'''for'''</code> – פתיחת לולאה מסוג <code>for</code>
# <code>'''in'''</code> – קריאה לפונקציית [[איטרציה]] בתחילת מחזור של לולאה מסוג <code>for</code>

מילים שמורות שנוספו בגרסה 5.0:<ref name=":6">{{קישור כללי|כתובת=https://www.lua.org/manual/5.0/manual.html#2.1|כותרת=Lua 5.0 Reference Manual: Lexical Conventions|אתר=www.lua.org|תאריך_וידוא=2022-09-16}}</ref>

# <code>'''true'''</code> – ערך [[ערך אמת|אמת]]
# <code>'''false'''</code> – ערך [[שקר (לוגיקה)|שקר]]

מילים שמורות שנוספו בגרסה 5.2:<ref name=":7">{{קישור כללי|כתובת=https://www.lua.org/manual/5.2/manual.html#3.1|כותרת=Lua 5.2 Reference Manual: Lexical Conventions|אתר=www.lua.org|תאריך_וידוא=2022-09-16}}</ref>

# <code>'''goto'''</code> – [[פקודת goto|קפיצה]] לתווית בקוד. תוויות מסומנות באמצעות זוג נקודתיים לפני ואחרי התווית כך: <code>::label::</code> בנוסף, לא ניתן לקפוץ מחוץ לפונקציה, וכללי הנראות של משתנים חלים גם על תוויות.<ref name=":6" group="א" />
=== טבלאות ===
טבלה מוגדרת באמצעות זוג סוגריים מסולסלים <code>{}</code>.<ref name=":3" group="א" /><syntaxhighlight lang="lua">
local point = {}
</syntaxhighlight>ניתן להכניס פריטים חדשים לטבלה בשתי דרכים: בתוך הסוגריים המסולסלים בפקודה אחת, או מחוץ לסוגריים המסולסלים באמצעות פקודה נפרדת לכל פריט.<ref name=":3" group="א" /> שתי הדרכים הן שקולות, אך הדרך הראשונה היא מהירה יותר מהיבט ביצועי של המפרש.<ref name=":3" group="א" /><syntaxhighlight lang="lua">
local point = {x = 0, y = 0}
</syntaxhighlight><syntaxhighlight lang="lua">
local point = {}
point.x = 0
point.y = 0
</syntaxhighlight>בנוסף, ניתן לגשת לפריט בטבלה בשתי דרכים: באמצעות נקודה ומזהה או באמצעות זוג סוגריים מרובעים וערך.<ref name=":3" group="א" /> מפתחות שהוגדרו עם מזהים הם בפועל מיוצגים באמצעות ערך של מחרוזת, וכן ההפך.<ref name=":3" group="א" /> בניגוד למזהים (שהם תמיד מיוצגים באמצעות מחרוזת), סוגריים מרובעים יודעים לקבל ערך מכל טיפוס נתונים ולא רק מחרוזות.<syntaxhighlight lang="lua">
local point = {}
point["x"] = 0
point["y"] = 0
print(point.x, point.y) -- 0    0
</syntaxhighlight>ניתן לבטא מבני נתונים מורכבים יותר באמצעות קינון טבלאות.<ref name=":3" group="א" /><syntaxhighlight lang="lua">
local style = {
    font = {
        size = 12,
        family = "sans-serif",
        bold = false,
        italic = false
    },
    foreground_color = {R = 0, G = 0, B = 0},
    background_color = {R = 255, G = 255, B = 255}
}
print(style.font.family) -- sans-serif
</syntaxhighlight>ניתן גם ליצור מבנה שקול אך ללא כל מזהים. במקרה הזה, ניתן לגשת לנתונים בטבלה באמצעות תחביר המערך.<ref name=":3" group="א" /><syntaxhighlight lang="lua">
local style = {
    {12, "sans-serif", false, false},
    {0, 0, 0},
    {255, 255, 255}
}
print(style[1][2]) -- sans-serif
</syntaxhighlight>הסרת פריט מהטבלה תתבצע באמצעות הקצאת הערך <code>nil</code> לפריט.<ref name=":3" group="א" /><syntaxhighlight lang="lua">
local point = {x = 0, y = 0, z = 0}
point.z = nil
</syntaxhighlight>בפועל, גם ספריות הליבה של לואה מורכבות מטבלאות.<ref name=":3" group="א" /> לדוגמה, הפונקציה <code>math.sin</code> נמצאת בתוך הפריט <code>sin</code> בטבלה <code>math</code> שנמצאת בהיקף המשתנים הגלובלי כך:<syntaxhighlight lang="lua">
print(math.sin(math.pi/2))                      -- 1
print(_G["math"]["sin"](_G["math"]["pi"]/2))    -- 1
</syntaxhighlight>לואה מאפשרת לסימן פסיק <code>,</code> אחד מיותר להופיע אחרי הפריט האחרון בהגדרת טבלה.<ref name=":3" group="א" /> מצורכי [[תאימות לאחור]] עם גרסאות קודמות של השפה, לואה מאפשרת גם שימוש בסימן [[נקודה ופסיק]] <code>;</code> במקום פסיק <code>,</code> על מנת להפריד בין פריטים בטבלה.<ref name=":3" group="א" />

=== פונקציות ===
==== הגדרה ====
בלואה פונקציה מוגדרת באמצעות שם מזהה וזוג סוגריים עגולים <code>()</code>, כשה[[פרמטר]]ים מוגדרים בתוך הסוגריים העגולים.<ref name=":4" group="א" /> קיימים שני תחבירים להגדרת פונקציה, שני התחבירים שקולים.<ref name=":4" group="א" /> לדוגמה, נגדיר את ה[[פרבולה]] <math>f(x) = x^2</math> על ידי הקצאת [[פונקציות למדא|פונקציה אנונימית]] לתוך המשתנה <code>f</code>:<syntaxhighlight lang="lua">
local f = function(x)
    return x^2
end
</syntaxhighlight>או על ידי הכרזת משתנה <code>f</code> מסוג פונקציה:<syntaxhighlight lang="lua">
local function f(x)
    return x^2
end
</syntaxhighlight>

==== קריאה ====
ניתן להשמיט את הסוגריים העגולים בקריאה לפונקציה אך ורק אם יש פרמטר בודד שמגדיר טבלה חדשה (בתוך זוג סוגריים מסולסלים <code>{}</code>) או מחרוזת חדשה (בתוך זוג מירכאות <code>""</code>).<ref name=":4" group="א" /> לדוגמה, הפונקציה <code>require</code> לטעינת [[מודול (תוכנה)|מודולים]] יכולה לקבל פרמטר מסוג מחרוזת של שם מודול ללא זוג סוגריים עגולים: <syntaxhighlight lang="lua">
local lfs = require "lfs" -- LuaFleSystem
</syntaxhighlight>

==== תכנות מונחה עצמים ====
בלואה קיים תחביר נוסף להגדרת וקריאת פונקציות באמצעות נקודתיים <code>:</code> שמאפשר חיקוי של [[תכנות מונחה-עצמים|תכנות מונחה עצמים]].<ref name=":4" group="א" /> במקרים כאלה, הפרמטר הראשון יהיה אוטומטית הטבלה שמכילה את הפונקציה, והייצוג שלה בתוך הפונקציה יהיה באמצעות המשתנה המקומי <code>self</code>.<ref name=":4" group="א" /> לדוגמה:<syntaxhighlight lang="lua">
local vector = {x = 1, y = 2, z = 3}
function vector:scale(scalar)
    self.x = self.x * scalar
    self.y = self.y * scalar
    self.z = self.z * scalar
end
function vector:print()
    print(self.x, self.y, self.z)
end
vector:print()      --  1       2       3
vector:scale(1.5)
vector:print()      --  1.5     3       4.5
</syntaxhighlight>

==== ריבוי פרמטרים ====
ניתן להגדיר פונקציה עם הסימן המיוחד <code>...</code> שקולט מספר שרירותי של פרמטרים אנונימיים.<ref name=":4" group="א" /> ניתן להעביר את אותם ערכים הלאה באמצעות <code>...</code> בגוף הפונקציה.<ref name=":4" group="א" /> לדגמה, פונקציית שתחשב [[סכום]] של מספר לא מוגדר של פרמטרים תכתב כך:<syntaxhighlight lang="lua">
local function sum(...)
    local result = 0
    for _, value in ipairs{...} do
        result = result + value
    end
    return result
end
print(sum(1, 2, 3)) -- 6
</syntaxhighlight>
=== הערות ===
הערה בת שורה אחת מתחילה בזוג מקפים. הערה בת שורות אחדות מתחילה בזוג מקפים ואחריהם זוג סוגריים מרובעים, ומסתיימת בזוג סוגריים מרובעים (כך נכתבת הערה גם ב־[[SQL]]). לואה מאפשרת גם קינון הערות מרובות שורות בעזרת הכלת התו <code>=</code> באופן מאוזן בין הסוגריים המרובעים בכל אגף.<syntaxhighlight lang="lua">
-- A comment in Lua starts with a double-hyphen and runs until the end of the line.
--[[ Multi-line strings & comments
     are adorned with double square brackets.]]
--[=[ Level 1 comment
    --[==[ Level 2 comment
        --[===[ Level 3 comment
            ...
        --]===]
    --]==]
--]=]
</syntaxhighlight>

=== בקרת זרימה ===
==== תחום הכרזה ====
בלואה ניתן ליצור [[תחום הכרזה]] חדש עבור משתנים מקומיים באמצעות <code>do</code> כך:<ref name=":7" group="א" /><syntaxhighlight lang="lua">
do
    local print = nil
    -- print("Hello world!") --> Error
end
print("Hello world!") --> Hello world!
</syntaxhighlight>

==== לולאות ====
[[לולאה (תכנות)|לולאות]] <code>for</code> נומרית כמו בדוגמה למטה תבצע מחזור מ־<code>1</code> עד <code>10</code> עבור האינדקס <code>i</code> ותוסיף לו <code>2</code> בכל מחזור.<ref name=":6" group="א" /><syntaxhighlight lang="lua">
for i = 1, 10, 2 do
    print(i) -- 1 3 5 7 9
end
</syntaxhighlight>לולאת <code>for</code> על טבלה לפי מפתח בסדר אקראי:<ref name=":3" group="א" /><syntaxhighlight lang="lua">
local weekdays = {
    ["Sunday"] = 1,
    ["Monday"] = 2,
    ["Tuesday"] = 3,
    ["Wednesday"] = 4,
    ["Thursday"] = 5,
    ["Friday"] = 6,
    ["Saturday"] = 7,
}
for key, value in pairs(weekdays) do
    print(key, value)
end
</syntaxhighlight>לולאת <code>for</code> על טבלה לפי אינדקס בסדר קבוע:<ref name=":3" group="א" /><syntaxhighlight lang="lua">
local weekdays = {
    "Sunday",
    "Monday",
    "Tuesday",
    "Wednesday",
    "Thursday",
    "Friday",
    "Saturday",
}
for index, value in ipairs(weekdays) do
    print(index, value)
end
</syntaxhighlight>לולאת <code>while</code> בודקת את התנאי בתחילת כל מחזור:<ref name=":6" group="א" /><syntaxhighlight lang="lua">
local i = 1
while weekdays[i] do
    print(weekdays[i])
    i = i + 1
end
</syntaxhighlight>לעומת זאת, לולאת <code>repeat</code> בודקת את התנאי בסוף כל מחזור; לפיכך, בלולאה מסוג זה המחזור הראשון מתקיים תמיד.<ref name=":6" group="א" /> בניגוד לשפות רבות, משתנים מקומיים שנוצרו בתוך הלולאה הם עדיין זמינים גם בתנאי למחזור אחרי המילה <code>repeat</code>.<ref name=":6" group="א" /><syntaxhighlight lang="lua">
local i = 1
repeat
    print(weekdays[i])
    i = i + 1
until not weekdays[i]
</syntaxhighlight>כמו בהרבה שפות אחרות, בלואה ניתן לבצע עצירה ויציאה ידנית מכל לולאה באמצעות הפקודה <code>break</code>.<ref name=":6" group="א" />

=== פעולות ===
{| class="wikitable mw-collapsible"
|+סימני פעולות בלואה<ref>{{קישור כללי|כתובת=https://www.lua.org/manual/5.3/manual.html#3.4|כותרת=Lua 5.3 Reference Manual: Expressions|אתר=www.lua.org|שפה=en|תאריך_וידוא=2022-10-01}}</ref>
! colspan="2" |סיווג
!אופרנדים
!פעולה
! colspan="2" |סימן
|-
| rowspan="21" |[[פעולה בינארית|בינארי]]
|[[הקצאה (תורת המשחקים)|הקצאה]]
| colspan="2" |קליטת [[ערך (מדעי המחשב)|ערך]] ל[[משתנה (תכנות)|משתנה]]
| dir="ltr" | <code>'''='''</code>
| rowspan="2" |<math>=</math>
|-
| rowspan="6" |יוחסה
| rowspan="6" |[[מספר]]ים
|שווה ל־
| dir="ltr" | '''<code>==</code>'''
|-
|לא שווה ל־
| dir="ltr" | <code>'''~='''</code>
|<math>\neq</math>
|-
|גדול מ־
| dir="ltr" | '''<code>></code>'''
|<math>></math>
|-
|קטן מ־
| dir="ltr" | '''<code><</code>'''
|<math><</math>
|-
|גדול או שווה ל־
| dir="ltr" | '''<code>>=</code>'''
|<math>\geq</math>
|-
|קטן או שווה ל־
| dir="ltr" | '''<code><=</code>'''
|<math>\leq</math>
|-
| rowspan="2" |[[לוגיקה]]
| rowspan="2" |[[אמת ושקר (פילוסופיה)|אמת או שקר]]
|[[וגם (לוגיקה)|וגם]]
| dir="ltr" | <code>'''and'''</code>
|<math>\and</math>
|-
|[[או (לוגיקה)|או]]
| dir="ltr" | <code>'''or'''</code>
|<math>\or</math>
|-
| rowspan="7" |[[פעולות החשבון|חשבון]]
| rowspan="7" |מספרים
|חיבור
| dir="ltr" | '''<code>+</code>'''
|<math>+</math>
|-
|חיסור
| dir="ltr" | '''<code>-</code>'''
|<math>-</math>
|-
|כפל
| dir="ltr" | '''<code>*</code>'''
|<math>\times</math>
|-
|חילוק
| dir="ltr" | '''<code>/</code>'''
|<math>\div</math>
|-
|חילוק ללא שארית
| dir="ltr" | '''<code>//</code>'''
| rowspan="2" |
|-
|מודולו
| dir="ltr" | '''<code>%</code>'''
|-
|[[העלאה בחזקה]]
| dir="ltr" | <code>'''^'''</code>
|<math>x^n</math>
|-
| colspan="2" rowspan="6" |[[פעולה על סיביות|סיביות]]{{ביאור|פעולות אלו נוספו בגרסה 5.3}}
|וגם
| dir="ltr" | <code>'''&'''</code>
| rowspan="6" |
|-
|או
| dir="ltr" | <code>'''<nowiki>|</nowiki>'''</code>
|-
|[[או מוציא]]
| dir="ltr" | <code>'''~'''</code>
|-
|הזזה ימינה
| dir="ltr" | <code>'''<<'''</code>
|-
|הזזה שמאלה
| dir="ltr" | <code>'''>>'''</code>
|-
| rowspan="3" |[[פעולה אונארית|אונארי]]
|לא
| dir="ltr" | <code>'''~'''</code>
|-
|[[לוגיקה]]
|[[אמת ושקר (פילוסופיה)|אמת או שקר]]
|[[לא (לוגיקה)|לא]]
| dir="ltr" | <code>'''~'''</code> או '''<code>not</code>'''
|<math>\neg</math>
|-
|[[פעולות החשבון|חשבון]]
|מספר
|סימן שלילי
| dir="ltr" | '''<code>-</code>'''
|<math>-</math>
|}
{{ביאורים}}

=== מחרוזות ===
השפה מצוידת בספרייה לחיפוש, החלפה, ו{{מונחון|התאמת דפוסים|pattern matching}} במחרוזות באמצעות ביטויים דומים ל[[ביטויים רגולריים]].<ref name=":8" group="א" />
{| class="mw-collapsible"
|+'''אסימונים בביטויי מחרוזות בלואה'''<ref name=":8" group="א" />
|-
| dir="ltr" | <code>.</code>
| colspan="3" |כל תו
|-
| dir="ltr" | <code>'''%a'''</code>
|אותיות
| dir="ltr" | <code>'''%A'''</code>
|לא אותיות
|-
| dir="ltr" | <code>'''%c'''</code>
|[[תווי בקרה]]
| dir="ltr" | <code>'''%C'''</code>
|לא תווי בקרה
|-
| dir="ltr" | <code>'''%d'''</code>
|מספרים
| dir="ltr" | <code>'''%D'''</code>
|לא מספרים
|-
| dir="ltr" | <code>'''%g'''</code>
|תווים נראים לא כולל רווחים.
| dir="ltr" | <code>'''%G'''</code>
|תווים בלתי נראים כולל רווחים
|-
| dir="ltr" | <code>'''%l'''</code>
|אותיות קטנות
| dir="ltr" | <code>'''%L'''</code>
|לא אותיות קטנות
|-
| dir="ltr" | <code>'''%p'''</code>
|סימני פיסוק
| dir="ltr" | <code>'''%P'''</code>
|לא סימני פיסוק
|-
| dir="ltr" | <code>'''%s'''</code>
|תווי ריווח
| dir="ltr" | <code>'''%S'''</code>
|לא תווי ריווח
|-
| dir="ltr" | <code>'''%u'''</code>
|[[אותיות רישיות ואותיות קטנות|אותיות רישיות]] (אותיות גדולות)
| dir="ltr" | <code>'''%U'''</code>
|לא אותיות רישיות (אותיות גדולות)
|-
| dir="ltr" | <code>'''%w'''</code>
|אותיות ומספרים
| dir="ltr" | <code>'''%W'''</code>
|לא אותיות ולא מספרים
|-
| dir="ltr" | <code>'''%x'''</code>
|תווים של מספרים [[הקסדצימלי]]ים
| dir="ltr" | <code>'''%X'''</code>
|לא תווים של מספרים הקסדצמיליים
|-
| dir="ltr" | <code>'''+'''</code>
| colspan="3" |לפחות פעם אחת או יותר
|-
| dir="ltr" | <code>'''*'''</code>
| colspan="3" |לפחות אפס פעמים או יותר (הרצף הארוך ביותר)
|-
| dir="ltr" | <code>'''-'''</code>
| colspan="3" |לפחות אפס פעמים או יותר (הרצף הקצר ביותר)
|-
| dir="ltr" | <code>'''?'''</code>
| colspan="3" |אפס פעמים או הופעה אחת לכל היותר
|-
| dir="ltr" | '''<code>(...)</code>'''
| colspan="3" |לכידת תווים להחזרה. ניתן ללכוד כמה רצפים, הם מוחזרים בסדר הופעתם. בלכידה ריקה <code>()</code>, לואה מחזירה את המיקום שלה במחרוזת.
|-
| dir="ltr" | '''<code>[^...]</code>'''
| colspan="3" |מבחר אפשריות של תווים, בזמן שהסימן ^ בתחילת הרשימה הופך את כל האפשרויות לשלילה (כלומר, אף אחד מהתווים ברשימה).
|-
| dir="ltr" | '''<code>%</code>'''
| colspan="3" |סימון תווים מיוחדים או שימוש בתווי דקדוק כתווים רגילים; לדוגמה, <code>%%</code> יחשב כהופעה רגילה של התו <code>%</code> במחרוזת.
|-
| dir="ltr" | '''<code>$</code>'''
| colspan="3" |סוף מחרוזת
|-
| dir="ltr" | '''<code>^</code>'''
| colspan="3" |תחילת מחרוזת
|}
דוגמה ללכידת שנה, חודש, ויום מתאריך תפוגה במחרוזת באמצעות הפונקציה <code>string.match</code>:<syntaxhighlight lang="lua">
local text = "EXP:2010-01-01"
local year, month, day = string.match(text, "(%d+)%-(%d%d)%-(%d%d)")
</syntaxhighlight>
== שימושים ==
לואה זכתה לשימוש נרחב בין היתר ב[[משחק מחשב|משחקי מחשב]], [[רובוטיקה]], [[עיבוד תמונה]], [[עורך טקסט|עורכי טקסט]], [[אוטומציה של בניית תוכנה|אוטומציה]], [[ביואינפורמטיקה]], וב[[מערכת משובצת מחשב|מערכות משובצות מחשב]].<ref name=":2" /> למרות יעודה כשפה מוטמעת, ללואה קיימת קהילה עצמאית, [[מערכת ניהול חבילות|מנהל חבילות]], ו[[ספרייה (תכנות)|ספריות]] המאפשרים בה פיתוח נוח ורב תחומי ללא תלות ב־C או בשפות אחרות. מבין השימושים המפורסמים בלואה ניתן למנות את ה[[ויקיפדיה:תבנית|תבניות]] במיזם [[ויקיפדיה]].<ref name=":8" />

== מנהל חבילות ==
'''LuaRocks''' היא [[מערכת ניהול חבילות|מערכת ניהול החבילות]] של לואה, היא פותחה בשפה עצמה והושקה בשנת 2007. המערכת יוצרת סביבה נוחה לפיתוח יציב ושיתופי בלואה ויודעת לטפל ביחסי תלות בין החבילות עצמן, בגרסאותיהן, ובגרסאות של המפרש הזמין במחשב. החבילות מסודרות במקום מרוכז בכל מחשב וכך חוסכות הכלה מיותרת של אותם רכיבים בכל פרויקט לואה חדש.

== מימושים ==
מהיותה שפה [[קוד פתוח|חופשית]] שנועדה להטמעה, ללואה קיימים [[מימוש]]ים רבים שפותחו למגוון מטרות על ידי מפתחים וצוותים עצמאים, ואין בניהם בהכרח תאימות. כמו כן, גם המפרש הסטנדרטי של האוניברסיטה הקתולית עבר שינויים ללא תאימות לאחור לאורך הפיתוח של השפה.<ref name=":1" />

=== PUC Rio Lua ===
'''PUC Rio Lua''' הוא המימוש המרכזי והנפוץ ביותר של לואה, נהוג לכנות אותו גם '''PUC Lua'''. המימוש מפותח ב[[האוניברסיטה הקתולית (ריו דה ז'ניירו)|אוניברסיטה הקתולית]] (PUC Rio) שב[[ריו דה ז'ניירו]] משנת 1993 ומופץ תחת [[רישיון MIT]].<ref>{{קישור כללי|כתובת=https://www.lua.org/license.html|כותרת=License|אתר=www.lua.org|תאריך_וידוא=2022-10-16}}</ref> ה[[מפרש (תוכנה)|מפרש]] כתוב ב[[C (שפת תכנות)|שפת C]] והוא מתאפיין בצריכה חסכונית של [[זיכרון גישה אקראית|זיכרון]] וכוח [[מעבד|עיבוד]] למרות ביצועיו המהירים ביחס לשפות מפורשות אחרות. PUC Lua ממיר קוד מקור של Lua ל־[[bytecode]] לפני שלב הריצה לאחר שהקוד עובר בדיקות ראשוניות כגון חוקיות התחביר.<ref name=":10" group="א" />

=== LuaJIT ===
'''LuaJIT''' הוא מימוש המכוון לביצועים גבוהים מאוד עם לואה בעזרת [[מהדר|הידור]] תוך כדי [[זמן ריצה (תוכנה)|זמן ריצה]] (Just In Time compilation). חלקים מהמפרש כתובים ב[[שפת סף]]. למימוש קיים ממשק {{מונחון|FFI|Foreign Function Interface}} שמאפשר תיווך בין לואה ו[[C (שפת תכנות)|שפת C]] מבלי לגרוע בביצועים של המפרש ובלי צורך להיעזר ב־Lua C API כפי שדרוש במימוש הסטנדרטי של PUC Lua. בנוסף למהדר, גם המפרש של LuaJIT הוא מהיר בכפולות מהמפרש הסטנדרטי של PUC Lua, אפילו אם המהדר אינו מופעל כלל.<ref name=":9">{{קישור כללי|כתובת=https://luajit.org/performance_x86.html|כותרת=Performance: x86/x64|אתר=luajit.org|תאריך_וידוא=2022-10-16}}</ref> הביצועים של LuaJIT מהירים עשרות מונים משל PUC Lua 5.1.<ref name=":9" /> עובדה זו הפכה את המימוש לאטרקטיבי בתעשייה.<ref>{{קישור כללי|כתובת=https://luajit.org/sponsors.html|כותרת=LuaJIT Sponsorship Program|אתר=luajit.org|תאריך_וידוא=2022-10-16}}</ref>

=== eLua ===
'''eLua''' (קיצור של '''Embedded Lua''') היא מימוש מלא של השפה המיועד ל[[מערכת משובצת מחשב|מערכות משובצות מחשב]] ומציע [[מיטוב אלגוריתמים|אופטימיזציות]] והרחבות חדשות לשפה שהן רלוונטיות ל[[חומרה]] האופיינית למערכות משובצות. התכונות המרכזיות:<ref>{{קישור כללי|כתובת=http://www.eluaproject.net/overview|כותרת=Overview|אתר=www.eluaproject.net|תאריך_וידוא=2022-10-16}}</ref>
* שליטה מלאה וישירה בחומרה בהיעדר [[מערכת הפעלה]]. עם זאת, המימוש נמנע מלהפוך לתחליף עבור מערכת הפעלה.
* תאימות על מערכות עם [[ארכיטקטורות מחשבים|ארכיטקטורת מחשבים]] שונות. המימוש דואג למגר כל הבדל אפשרי בהתנהגות השפה על גבי מעבדים עם [[סט פקודות]] שונה.
* המימוש מתוכנן כדי לאפשר החלפה ושדרוג מזדמן של החומרה מבלי לגרום לאי תאימויות בקוד שנכתב עד כה.
* [[מעטפת (מחשבים)|מעטפת]] המאפשרת אינטראקציה נוחה בתהליך הפיתוח בין הקוד המוטמע לקוד שנערך על ידי המשתמש. לדוגמה, הטמעת הקוד וקבלת משוב על [[שגיאה#תכנות מחשבים|שגיאות]] תוך כדי הריצה בלי צורך ב[[סימולציה|סימולציות]] לפני ההטמעה.

== ראו גם ==
* [[מודולה-2|מודולה־2]] – שפת תכנות מערכות שנתנה את ההשראה לתחביר של לואה.
* [[Scheme]] – ניב של שפת התכנות [[Lisp]] שנתן השראה סמנטית לשפת התכנות לואה.

== לקריאה נוספת ==
{{Ltr|
* {{עוגן|Programming in Lua|{{צ-ספר|שם=Programming in Lua|קישור=https://www.lua.org/pil/|מו"ל=Lua.org|שנת הוצאה=2016|מקום הוצאה=|ISBN=8590379868|מהדורה=4th Edition|מחבר=Roberto Ierusalimschy|שפה=en}}}}
* {{צ-מאמר|שם=The Evolution of Lua|קישור=https://doi.org/10.1145/1238844.1238846|מו"ל=Association for Computing Machinery|כתב עת=Proceedings of the third ACM SIGPLAN conference on History of programming languages|שנת הוצאה=2007-06-09|עמ=2–1–2–26|סדרה=HOPL III|doi=10.1145/1238844.1238846|מחבר=Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes}}
}}
==קישורים חיצוניים==
{{ויקישיתוף בשורה}}
* {{אתר רשמי}}
*[http://www.lua.org/manual/ התיעוד הרשמי]
* [http://lua-users.org/wiki/LuaImplementations רשימת המימושים הידועים של Lua]
* [http://luajit.org/ דף הבית של LuaJIT]
* [http://www.eluaproject.net/ דף הבית של eLua]
* [https://github.com/lua/lua קוד המקור הרשמי של Lua]
* [https://www.lua.org/cgi-bin/demo התנסות בהרצת לואה]

== הערות שוליים ==
=== מדריך השפה מהדורה רביעית ===
{{הערות שוליים|יישור=שמאל|קבוצה=א}}

=== מקורות נוספים ===
{{הערות שוליים|יישור=שמאל}}

{{בקרת זהויות}}

[[קטגוריה:שפות תכנות]]
[[קטגוריה:שפות תכנות פונקציונליות]]