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

ตัวแปรส่วนตัวด้วยคลอเชอร์

ซ่อนสถานะไว้ภายในขอบเขตของฟังก์ชัน

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

สร้างความเป็นส่วนตัวด้วยคลอเชอร์

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

function secretBox() {
  let secret = "hidden";
  return {
    reveal: () => secret
  };
}
const box = secretBox();
console.log(box.reveal()); // "hidden"
console.log(box.secret);   // undefined

Counter ที่มีสถานะส่วนตัว

ตัวอย่างมาตรฐานคือ counter ที่ไม่สามารถแก้ไขจำนวนโดยตรงได้ มีเพียงเมธอดที่ส่งคืนมาเท่านั้นที่เปลี่ยนค่าได้

function makeCounter() {
  let count = 0;
  return {
    increment: () => ++count,
    value: () => count
  };
}
const c = makeCounter();
c.increment();
c.increment();
console.log(c.value()); // 2

สถานะไม่อาจแตะต้องได้

ไม่มีวิธีเข้าถึง count จากภายนอก การพยายามอ่านค่าจะได้ undefined คุณต้องเข้าถึงผ่านเมธอดเท่านั้น

function makeCounter() {
  let count = 0;
  return { inc: () => ++count, get: () => count };
}
const c = makeCounter();
c.count = 100;        // creates an unrelated property
console.log(c.get()); // 0 - real count untouched

การบังคับใช้กฎ

เนื่องจากการเข้าถึงต้องผ่านเมธอด คุณจึงบังคับใช้เงื่อนไขคงที่ได้ เช่น ไม่ปล่อยให้ balance ติดลบ

function account(start) {
  let balance = start;
  return {
    withdraw: (n) => {
      if (n > balance) return "insufficient";
      balance -= n;
      return balance;
    },
    balance: () => balance
  };
}
const a = account(100);
console.log(a.withdraw(150)); // "insufficient"
console.log(a.withdraw(40));  // 60

ฟิลด์ส่วนตัวหลายรายการ

คลอเชอร์หนึ่งตัวสามารถปกป้องตัวแปรหลายตัวพร้อมกันได้ ตัวแปรทั้งหมดจะถูกซ่อนไว้และแชร์เฉพาะระหว่างเมธอดที่ส่งคืนมา

function user(name) {
  let logins = 0;
  let lastSeen = null;
  return {
    login: () => { logins++; lastSeen = "now"; },
    stats: () => ({ name, logins, lastSeen })
  };
}
const u = user("Ada");
u.login();
console.log(u.stats()); // { name: "Ada", logins: 1, lastSeen: "now" }

ฟังก์ชันตัวช่วยส่วนตัว

ไม่ใช่แค่ข้อมูลเท่านั้น คุณยังซ่อนฟังก์ชันภายในได้ด้วย สิ่งที่เป็นสาธารณะมีเพียงเมธอดที่คุณเปิดเผย

function temperature() {
  let celsius = 0;
  const toF = (c) => c * 9 / 5 + 32; // private
  return {
    set: (c) => { celsius = c; },
    fahrenheit: () => toF(celsius)
  };
}
const t = temperature();
t.set(100);
console.log(t.fahrenheit()); // 212

อินสแตนซ์ที่เป็นอิสระต่อกัน

การเรียกใช้ฟังก์ชันโรงงานแต่ละครั้งจะสร้างสถานะส่วนตัวแยกต่างหาก ดังนั้นอินสแตนซ์จึงไม่รบกวนกัน

function makeCounter() {
  let n = 0;
  return { inc: () => ++n };
}
const a = makeCounter();
const b = makeCounter();
console.log(a.inc(), a.inc()); // 1 2
console.log(b.inc());          // 1

การเปิดเผยแบบอ่านอย่างเดียว

เปิดเผยตัวอ่านค่าโดยไม่มีตัวตั้งค่า เพื่อทำให้ค่าหนึ่งอ่านได้อย่างเดียวจากภายนอก ขณะที่ยังเปลี่ยนแปลงได้จากภายใน

function timer() {
  let ticks = 0;
  setupInternally();
  function setupInternally() { ticks = 3; }
  return { ticks: () => ticks };
}
const t = timer();
console.log(t.ticks()); // 3 - no way to set it outside

เปรียบเทียบ: ฟิลด์ของคลาส

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

class Counter {
  #count = 0;
  inc() { return ++this.#count; }
}
const c = new Counter();
console.log(c.inc()); // 1

เหตุผลที่สิ่งนี้ทำงานได้

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

แคชสำหรับการจดจำผลลัพธ์

สถานะส่วนตัวเหมาะอย่างยิ่งสำหรับแคช วัตถุแคชจะถูกซ่อนไว้และคงอยู่ระหว่างการเรียกใช้แต่ละครั้ง

function memoSquare() {
  const cache = {};
  return (n) => {
    if (cache[n] === undefined) cache[n] = n * n;
    return cache[n];
  };
}
const sq = memoSquare();
console.log(sq(4)); // 16
console.log(sq(4)); // 16 (cached)

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ตัวแปรส่วนตัวด้วยคลอเชอร์

ทบทวน

คลอเชอร์สร้างความเป็นส่วนตัวได้ ตัวแปรภายในโรงงานจะไม่สามารถเข้าถึงจากภายนอก แต่จะแชร์กันระหว่างเมธอดที่ส่งคืนมา สิ่งนี้ช่วยสร้าง counter ที่ป้องกันการแก้ไขโดยไม่ได้รับอนุญาต, balance ที่มีเงื่อนไขคงที่, ฟังก์ชันตัวช่วยที่ซ่อนอยู่ และแคช การเรียกใช้โรงงานแต่ละครั้งจะสร้างสถานะที่เป็นอิสระต่อกัน ฟิลด์ส่วนตัวของคลาสสมัยใหม่อย่าง #private เป็นอีกทางเลือกหนึ่ง แต่คลอเชอร์เหมาะอย่างยิ่งกับโค้ดที่ใช้รูปแบบโรงงาน

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

บทเรียน “ตัวแปรส่วนตัวด้วยคลอเชอร์” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ตัวแปรส่วนตัวด้วยคลอเชอร์”

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

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

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

บทเรียน “ตัวแปรส่วนตัวด้วยคลอเชอร์” ใช้เวลานานแค่ไหน

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

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

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

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

  1. การที่คลอเชอร์เก็บสถานะ
  2. ตัวแปรส่วนตัวด้วยคลอเชอร์
  3. รูปแบบโมดูล (IIFE)
  4. ฟังก์ชันโรงงาน
← กลับไปที่ JavaScript Academy