0Pricing
Lua Academy · บทเรียน

การจดจำผลลัพธ์ด้วยคลอเชอร์

แคชผลลัพธ์ของฟังก์ชันที่ใช้เวลานานไว้ในตารางที่คลอเชอร์ถืออยู่

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

การจำผลลัพธ์คืออะไร

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

ตัวห่อหุ้มการจำผลลัพธ์พื้นฐาน

คลอเชอร์เก็บตาราง cache ไว้ เมื่อเรียกครั้งแรก ให้คำนวณและจัดเก็บผลลัพธ์ เมื่อเรียกซ้ำ ให้ส่งคืนค่าที่จัดเก็บไว้

local function memoize(fn)
  local cache = {}
  return function(x)
    if cache[x] == nil then
      cache[x] = fn(x)
    end
    return cache[x]
  end
end

ฟีโบนัชชีที่จำผลลัพธ์

การจำผลลัพธ์ของฟังก์ชันฟีโบนัชชีแบบเรียกซ้ำช่วยลดความซับซ้อนด้านเวลาจากเลขชี้กำลังเป็นเชิงเส้น

local fib
fib = memoize(function(n)
  if n <= 1 then return n end
  return fib(n-1) + fib(n-2)
end)
print(fib(30))  -- 832040 (fast!)

การจำผลลัพธ์สำหรับหลายอาร์กิวเมนต์

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

local function memoize2(fn)
  local cache = {}
  return function(a, b)
    local key = a .. "," .. b
    if cache[key] == nil then cache[key] = fn(a, b) end
    return cache[key]
  end
end

ตารางแคชซ้อนกัน

สำหรับชนิดอาร์กิวเมนต์แบบผสม ให้ใช้ตารางซ้อนกันโดยใช้แต่ละอาร์กิวเมนต์เป็นคีย์ เพื่อค้นหาในเวลา O(1) โดยไม่ต้องแปลงเป็นสตริง

local function nestedMemo(fn)
  local cache = {}
  return function(a, b)
    cache[a] = cache[a] or {}
    if cache[a][b] == nil then cache[a][b] = fn(a, b) end
    return cache[a][b]
  end
end

การทำให้แคชไม่ถูกต้อง

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

การจำผลลัพธ์ตาม TTL

เพิ่มตรรกะอายุการใช้งานโดยใช้ os.time() เพื่อทำให้รายการในแคชหมดอายุ

local function memoizeTTL(fn, ttl)
  local cache = {}
  return function(x)
    local entry = cache[x]
    if entry and os.time() - entry.time < ttl then
      return entry.value
    end
    cache[x] = {value = fn(x), time = os.time()}
    return cache[x].value
  end
end

แคชค่าแบบอ่อน

ใช้ค่าแบบอ่อน เพื่อให้ระบบสามารถเก็บกวาดผลลัพธ์ที่แคชไว้ได้เมื่อหน่วยความจำเหลือน้อย

local function memoizeWeak(fn)
  local cache = setmetatable({}, {__mode = "v"})
  return function(x)
    if cache[x] == nil then cache[x] = fn(x) end
    return cache[x]
  end
end

รูปแบบการจำผลลัพธ์แบบเรียกซ้ำ

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

แคชมีขนาดจำกัด (โครงร่าง LRU)

เพื่อควบคุมหน่วยความจำ ให้สร้างแคช LRU ที่นำรายการซึ่งไม่ได้ใช้งานมานานที่สุดออกเมื่อแคชมีขนาดเกินค่าสูงสุด

การจำผลลัพธ์ในการใช้งานจริง

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

คำถามเกี่ยวกับการจำผลลัพธ์

เหตุใดจึงควรใช้การจำผลลัพธ์กับฟังก์ชันบริสุทธิ์เท่านั้น

สรุป: การจำผลลัพธ์

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

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

บทเรียน “การจดจำผลลัพธ์ด้วยคลอเชอร์” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การจดจำผลลัพธ์ด้วยคลอเชอร์” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

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

  1. Upvalue คืออะไร
  2. Upvalue ร่วมระหว่างคลอเชอร์
  3. ฟังก์ชันโรงงานและตัวสร้างลำดับ
  4. การจดจำผลลัพธ์ด้วยคลอเชอร์
← กลับไปที่ Lua Academy