ตัวแปรส่วนตัวด้วยคลอเชอร์
ซ่อนสถานะไว้ภายในขอบเขตของฟังก์ชัน
ตัวแปรส่วนตัวด้วยคลอเชอร์ เป็นบทเรียน 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); // undefinedCounter ที่มีสถานะส่วนตัว
ตัวอย่างมาตรฐานคือ 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การที่คลอเชอร์เก็บสถานะ
- ตัวแปรส่วนตัวด้วยคลอเชอร์
- รูปแบบโมดูล (IIFE)
- ฟังก์ชันโรงงาน