Lua Academy · บทเรียน

การประกอบฟังก์ชัน

เชื่อมการแปลงข้อมูลเป็นลำดับ

บทเรียน 4 จาก 413 ขั้นตอน

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

การประกอบฟังก์ชันคืออะไร

การประกอบฟังก์ชันรวมฟังก์ชันสองตัวให้เป็นหนึ่งตัว ฟังก์ชันที่ประกอบแล้วจะส่งข้อมูลเข้าผ่านฟังก์ชันแรก แล้วส่งผลลัพธ์นั้นให้ฟังก์ชันที่สอง

ในคณิตศาสตร์เขียนเป็น f(g(x)) การประกอบฟังก์ชันช่วยให้สร้างการแปลงขนาดใหญ่จากฟังก์ชันขนาดเล็กที่ทำหน้าที่เฉพาะได้

การประกอบฟังก์ชันสองตัว

ฟังก์ชันช่วย compose รับฟังก์ชันสองตัวแล้วคืนฟังก์ชันใหม่ เมื่อเรียกใช้ ฟังก์ชัน g จะทำงานก่อน จากนั้นจึงส่งผลลัพธ์ให้ฟังก์ชัน f

ลำดับมีความสำคัญ ฟังก์ชันด้านในทำงานก่อน ส่วนฟังก์ชันด้านนอกจะทำงานกับผลลัพธ์ของมัน

local function compose(f, g)
  return function(x)
    return f(g(x))
  end
end

local function inc(n) return n + 1 end
local function dbl(n) return n * 2 end

local incThenDouble = compose(dbl, inc)
print(incThenDouble(3))

ลำดับมีความสำคัญ

การสลับอาร์กิวเมนต์ทำให้ผลลัพธ์เปลี่ยน compose(f, g) หมายถึงใช้ g ก่อน แล้วจึงใช้ f

ตัวอย่างด้านล่างแสดงว่าการคูณสองแล้วเพิ่มหนึ่งให้คำตอบต่างจากการเพิ่มหนึ่งแล้วคูณสอง

local function compose(f, g) return function(x) return f(g(x)) end end
local function inc(n) return n + 1 end
local function dbl(n) return n * 2 end

print(compose(dbl, inc)(3))
print(compose(inc, dbl)(3))

การประกอบฟังก์ชันข้อความ

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

ในที่นี้การกลับลำดับจะทำงานก่อน แล้วจึงเปลี่ยนเป็นตัวพิมพ์ใหญ่ ทำให้ได้ข้อความที่กลับลำดับและเป็นตัวพิมพ์ใหญ่

local function compose(f, g) return function(x) return f(g(x)) end end

local shout = compose(string.upper, string.reverse)
print(shout("lua"))

การประกอบฟังก์ชันหลายตัว

หากต้องการต่อฟังก์ชันมากกว่าสองตัว ให้เขียน composeAll ที่รับอาร์กิวเมนต์จำนวนไม่แน่นอน ฟังก์ชันนี้จะนำฟังก์ชันมาประยุกต์จากขวาไปซ้าย เช่นเดียวกับการเรียกซ้อนกัน

ลูปจะเดินย้อนกลับผ่านรายการฟังก์ชัน แล้วส่งค่าต่อผ่านฟังก์ชันแต่ละตัว

local function composeAll(...)
  local fns = {...}
  return function(x)
    for i = #fns, 1, -1 do
      x = fns[i](x)
    end
    return x
  end
end

local f = composeAll(function(n) return n + 1 end,
  function(n) return n * 2 end,
  function(n) return n - 3 end)
print(f(10))

จากขวาไปซ้าย

ใน composeAll(a, b, c) ฟังก์ชันขวาสุด c จะทำงานก่อน ตามด้วย b แล้วจึงเป็น a ซึ่งตรงกับรูปแบบการเรียกซ้อน a(b(c(x)))

การอ่านลำดับแบบนี้อาจทำได้ยาก จึงมีผู้พัฒนาบางส่วนชอบการส่งต่อจากซ้ายไปขวามากกว่า

การส่งต่อจากซ้ายไปขวา

การส่งต่อจะกลับลำดับการอ่าน ฟังก์ชันจะทำงานจากซ้ายไปขวาตามลำดับที่เขียนไว้ หลายคนพบว่าวิธีนี้ติดตามสายการประมวลผลข้อมูลได้ง่ายกว่า

ลูปจะเดินไปข้างหน้า โดยนำแต่ละฟังก์ชันไปใช้กับค่าที่กำลังส่งต่อ

local function pipe(...)
  local fns = {...}
  return function(x)
    for i = 1, #fns do
      x = fns[i](x)
    end
    return x
  end
end

local process = pipe(function(n) return n + 1 end,
  function(n) return n * 2 end)
print(process(5))

การส่งต่อเพื่อให้อ่านง่าย

เมื่อใช้ pipe ขั้นตอนต่าง ๆ จะอ่านจากบนลงล่างตามลำดับการทำงาน วิธีนี้ทำให้การแปลงหลายขั้นตอนอธิบายตัวเองได้

ในที่นี้สตริงจะถูกตัดคำนำหน้าออก เปลี่ยนเป็นตัวพิมพ์เล็ก แล้วกลับลำดับ โดยแสดงแต่ละขั้นตามลำดับที่เกิดขึ้น

local function pipe(...) local fns={...} return function(x) for i=1,#fns do x=fns[i](x) end return x end end

local transform = pipe(string.lower, string.reverse,
  function(s) return "[" .. s .. "]" end)
print(transform("LUA"))

การประกอบฟังก์ชันกับคลอสเชอร์

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

วิธีนี้ทำให้แต่ละส่วนทดสอบได้ ขณะที่การประกอบฟังก์ชันแสดงลำดับการทำงานโดยรวม

local function pipe(...) local fns={...} return function(x) for i=1,#fns do x=fns[i](x) end return x end end
local function adder(n) return function(x) return x + n end end
local function muller(n) return function(x) return x * n end end

local calc = pipe(adder(3), muller(10))
print(calc(2))

การประกอบฟังก์ชันและสายการประมวลผลข้อมูล

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

วิธีนี้ทำงานร่วมกับการแปลงได้ดีมาก โดยส่งฟังก์ชันที่ประกอบแล้วเป็นการแปลงสำหรับแต่ละรายการ

local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function compose(f, g) return function(x) return f(g(x)) end end

local step = compose(function(n) return n + 1 end, function(n) return n * n end)
local r = map({1, 2, 3, 4}, step)
print(table.concat(r, ", "))

ทำให้ฟังก์ชันมีขนาดเล็ก

การประกอบฟังก์ชันให้ประโยชน์จากฟังก์ชันขนาดเล็กที่มีหน้าที่เดียว แต่ละฟังก์ชันทำงานหนึ่งอย่าง แล้วนำมารวมกันเป็นพฤติกรรมที่ซับซ้อนได้โดยไม่ต้องเขียนตรรกะซ้ำ

นี่คือหัวใจของการออกแบบเชิงฟังก์ชัน สร้างคลังคำศัพท์จากฟังก์ชันขนาดเล็ก แล้วประกอบกันเพื่อสื่อแนวคิดที่ใหญ่ขึ้น

ตรวจสอบอย่างรวดเร็ว

ติดตามลำดับอย่างรอบคอบก่อนตอบ

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุปทบทวน

การประกอบฟังก์ชันเชื่อมฟังก์ชันเข้าด้วยกัน เพื่อให้ผลลัพธ์ของฟังก์ชันหนึ่งถูกส่งต่อไปยังฟังก์ชันถัดไป การประกอบฟังก์ชันด้วย f และ g จะเรียก g ก่อนแล้วจึงเรียก f จากขวาไปซ้าย ส่วนการส่งต่อจะทำงานจากซ้ายไปขวาเพื่อให้อ่านง่าย

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

เริ่มต้นได้ฟรี

เรียนรู้ Lua ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 40
บทเรียน: 159

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

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

บทเรียน “การประกอบฟังก์ชัน” ฟรีหรือไม่

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

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

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

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

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

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

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

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

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

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

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