Lua Academy · บทเรียน

การกำหนดและเรียกใช้ฟังก์ชัน

เรียนรู้ไวยากรณ์การประกาศฟังก์ชัน รูปแบบการเรียกใช้ และความแตกต่างระหว่างฟังก์ชันเฉพาะที่กับฟังก์ชันส่วนกลาง

การกำหนดและเรียกใช้ฟังก์ชัน เป็นบทเรียน Lua Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Lua Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Lua Academy มีบทเรียนทั้งหมด 4 บทเรียน

ไวยากรณ์ฟังก์ชัน

ฟังก์ชันใน Lua กำหนดด้วยคีย์เวิร์ด function ส่วนเนื้อหาคือบล็อกที่สิ้นสุดด้วย end ฟังก์ชันอาจเป็นฟังก์ชันส่วนกลางหรือฟังก์ชันเฉพาะที่ การเรียกฟังก์ชันทำได้โดยเติมวงเล็บพร้อมอาร์กิวเมนต์ หากไม่ระบุอาร์กิวเมนต์ พารามิเตอร์ที่ขาดจะได้รับค่า nil

function sayHello(name)
  print("Hello, " .. (name or "World") .. "!")
end

sayHello("Lua")   -- Hello, Lua!
sayHello()        -- Hello, World!

local function add(a, b)
  return a + b
end
print(add(3, 4))  -- 7

ค่าที่ส่งกลับ

ฟังก์ชันส่งกลับค่าด้วย return ต่างจากภาษาส่วนใหญ่ ฟังก์ชัน Lua สามารถส่งกลับได้หลายค่า หากไม่ระบุคำสั่ง return อย่างชัดเจน ฟังก์ชันจะไม่ส่งกลับค่าใดเลย (ศูนย์ค่า) ค่าที่ส่งกลับเกินมาจะถูกทิ้งเมื่อการเรียกฟังก์ชันไม่ใช่นิพจน์สุดท้ายในรายการ

local function minMax(t)
  local lo, hi = t[1], t[1]
  for i = 2, #t do
    if t[i] < lo then lo = t[i] end
    if t[i] > hi then hi = t[i] end
  end
  return lo, hi
end

local lo, hi = minMax({5,2,8,1,9})
print(lo, hi)  -- 1  9

ฟังก์ชันในฐานะค่า

ฟังก์ชันเป็นค่าอันดับหนึ่งใน Lua คุณสามารถเก็บฟังก์ชันไว้ในตัวแปร ส่งฟังก์ชันเป็นอาร์กิวเมนต์ให้ฟังก์ชันอื่น และส่งฟังก์ชันกลับได้ ความสามารถนี้ทำให้เกิดการเรียกกลับ ฟังก์ชันระดับสูง และรูปแบบการเขียนโปรแกรมเชิงฟังก์ชัน

local ops = {
  add = function(a, b) return a + b end,
  sub = function(a, b) return a - b end,
  mul = function(a, b) return a * b end,
}

local function apply(op, a, b)
  return op(a, b)
end

print(apply(ops.add, 10, 3))  -- 13
print(apply(ops.mul, 4, 5))   -- 20

ฟังก์ชันเฉพาะที่กับฟังก์ชันส่วนกลาง

ใช้ local function สำหรับฟังก์ชันช่วยเหลือที่ใช้เฉพาะภายในมอดูล ฟังก์ชันส่วนกลางทำให้เนมสเปซส่วนกลางรกและเข้าถึงได้จากทุกที่ ซึ่งอาจทำให้ชื่อขัดแย้งกัน โดยส่วนใหญ่ควรเลือกใช้ฟังก์ชันเฉพาะที่ และเปิดเผยเฉพาะสิ่งที่จำเป็นผ่านตารางของมอดูล

-- Bad: pollutes global namespace
function helper() end

-- Good: module-local
local function helper()
  return "I am local"
end

-- Module export pattern
local M = {}
function M.publicFunc()
  return helper()  -- can call local
end
return M

เมธอดด้วยไวยากรณ์โคลอน

Lua มีรูปแบบไวยากรณ์ย่อสำหรับกำหนดและเรียกเมธอดบนตาราง obj:method(arg) เทียบเท่ากับ obj.method(obj, arg) รูปแบบโคลอนจะส่งตารางเป็นอาร์กิวเมนต์แรกโดยอัตโนมัติ ซึ่งตามธรรมเนียมจะตั้งชื่อว่า self

local Dog = {}
Dog.__index = Dog

function Dog.new(name)
  return setmetatable({name=name}, Dog)
end

function Dog:speak()
  print(self.name .. " says: Woof!")
end

local d = Dog.new("Rex")
d:speak()   -- Rex says: Woof!

รูปแบบพารามิเตอร์เสริม

Lua ไม่มีพารามิเตอร์เสริมในตัว แต่คุณสามารถจำลองได้ด้วยการตรวจสอบค่า nil สำหรับฟังก์ชันที่มีพารามิเตอร์เสริมจำนวนมาก ให้ส่งตารางตัวเลือกเพียงตารางเดียว วิธีนี้อ่านง่ายกว่ารายการอาร์กิวเมนต์ที่ยาว

local function createUser(name, opts)
  opts = opts or {}
  return {
    name = name,
    role = opts.role or "user",
    active = opts.active ~= false,
    score = opts.score or 0,
  }
end

local u = createUser("Alice", {role="admin", score=100})
print(u.name, u.role, u.score)

การเรียกฟังก์ชันต่อท้าย

การเรียกฟังก์ชันต่อท้าย คือการเรียกฟังก์ชันในตำแหน่งท้ายสุด ซึ่งเป็นการทำงานสุดท้ายก่อนส่งกลับ Lua ใช้ การปรับให้การเรียกฟังก์ชันต่อท้ายเหมาะสมที่สุด ดังนั้นการเรียกฟังก์ชันต่อท้ายที่ถูกต้องจะไม่ใช้พื้นที่สแตกเพิ่ม วิธีนี้ทำให้การเรียกซ้ำลึก ๆ ทำได้โดยไม่ล้นสแตก เมื่อการเรียกซ้ำอยู่ในตำแหน่งท้ายสุด

local function factorial(n, acc)
  acc = acc or 1
  if n <= 1 then return acc end
  return factorial(n - 1, n * acc)  -- tail call!
end

print(factorial(10))  -- 3628800
-- Can handle very large n without stack overflow

ฟังก์ชันที่เรียกใช้งานทันที

คุณสามารถกำหนดและเรียกฟังก์ชันทันทีได้ด้วย (function() ... end)() วิธีนี้มีประโยชน์สำหรับสร้างขอบเขตเฉพาะที่ เรียกใช้โค้ดตั้งค่าเพียงครั้งเดียว หรือป้องกันไม่ให้ตัวแปรชั่วคราวรบกวนขอบเขตภายนอก

local result = (function()
  local temp = 100
  local adjusted = temp * 1.5
  return math.floor(adjusted)
end)()

print(result)   -- 150
-- temp and adjusted not visible here

เก็บฟังก์ชันไว้ในตาราง

การเก็บฟังก์ชันไว้ในตารางเป็นรูปแบบมาตรฐานของการออกแบบมอดูลใน Lua ตารางจะทำหน้าที่เป็นเนมสเปซ คุณกำหนดฟังก์ชันได้โดยกำหนดให้กับฟิลด์ของตาราง หรือใช้รูปแบบจุดและโคลอนร่วมกับชื่อตาราง

local math2 = {}

function math2.clamp(val, lo, hi)
  return math.max(lo, math.min(hi, val))
end

function math2.lerp(a, b, t)
  return a + (b - a) * t
end

print(math2.clamp(150, 0, 100))  -- 100
print(math2.lerp(0, 10, 0.5))   -- 5.0

โคลสเชอร์ในฐานะการเรียกกลับ

ฟังก์ชันระดับสูงรับการเรียกกลับ ใน Lua การเรียกกลับก็คือค่าฟังก์ชันทั่วไป โคลสเชอร์มีประโยชน์เป็นพิเศษในฐานะการเรียกกลับ เพราะสามารถเก็บบริบทของจุดที่เรียกไว้ได้โดยไม่ต้องส่งอาร์กิวเมนต์เพิ่มเติมผ่านฟังก์ชันระดับสูง

local function forEach(t, fn)
  for i, v in ipairs(t) do
    fn(v, i)
  end
end

local sum = 0
forEach({10, 20, 30}, function(v)
  sum = sum + v
end)
print(sum)   -- 60

forEach({"a","b","c"}, function(v, i)
  print(i, v)
end)

ตรวจสอบความเข้าใจ

ผลลัพธ์ของ local function f() return 1, 2, 3 end; local a, b = f() คืออะไร

ทบทวน: ฟังก์ชัน

ประเด็นสำคัญ:

ใช้ local function เพื่อหลีกเลี่ยงการทำให้ตัวแปรส่วนกลางปะปน
ฟังก์ชันเป็นค่าอันดับหนึ่ง: เก็บไว้ในตัวแปร ตาราง หรือส่งเป็นอาร์กิวเมนต์ได้
ไวยากรณ์โคลอนจะส่ง self โดยอัตโนมัติ
จำลองพารามิเตอร์เสริมด้วย opts or {}
การเรียกฟังก์ชันแบบหางช่วยป้องกันสแตกโอเวอร์โฟลว์ในการเรียกซ้ำเชิงลึก
ฟังก์ชันที่ถูกเรียกใช้ทันทีจะสร้างขอบเขตแยกออกมา

คำถามที่พบบ่อย

บทเรียน “การกำหนดและเรียกใช้ฟังก์ชัน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การกำหนดและเรียกใช้ฟังก์ชัน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Lua Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Lua Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การกำหนดและเรียกใช้ฟังก์ชัน”

เรียนรู้ไวยากรณ์การประกาศฟังก์ชัน รูปแบบการเรียกใช้ และความแตกต่างระหว่างฟังก์ชันเฉพาะที่กับฟังก์ชันส่วนกลาง คุณปฏิบัติ Lua Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Lua Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Lua Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “การกำหนดและเรียกใช้ฟังก์ชัน” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Lua Academy นี้ได้ไหม

ได้ บทเรียน Lua Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

การกำหนดและเรียกใช้ฟังก์ชัน
ค่าที่ส่งคืนหลายค่า
อาร์กิวเมนต์จำนวนแปรผันและตัวดำเนินการ ...
การเรียกซ้ำใน Lua

← กลับไปที่ Lua Academy