ฟังก์ชันโรงงาน
สร้างออบเจ็กต์ที่มีสถานะส่วนตัวผ่านคลอเชอร์
ฟังก์ชันโรงงาน เป็นบทเรียน JavaScript Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน JavaScript Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส JavaScript Academy มีบทเรียนทั้งหมด 4 บทเรียน
ฟังก์ชันโรงงานคืออะไร
ฟังก์ชันโรงงานคือฟังก์ชันใดก็ตามที่ส่งคืนวัตถุใหม่ ต่างจากตัวสร้างตรงที่คุณเรียกใช้ตามปกติ (ไม่ใช้ new) และฟังก์ชันนั้นสามารถใช้คลอเชอร์เพื่อเก็บสถานะส่วนตัวได้
function createUser(name) {
return {
name,
greet: () => "Hi, I am " + name
};
}
const u = createUser("Ada");
console.log(u.greet()); // "Hi, I am Ada"ไม่ต้องใช้คีย์เวิร์ดสำหรับสร้างวัตถุ
ฟังก์ชันโรงงานหลีกเลี่ยงข้อผิดพลาดที่อาจเกิดจาก new และ this คุณเพียงเรียกใช้ฟังก์ชัน แล้วรับวัตถุกลับมา
function point(x, y) {
return { x, y };
}
const p = point(3, 4);
console.log(p.x, p.y); // 3 4สถานะส่วนตัวผ่านคลอเชอร์
ตัวแปรที่ประกาศในโรงงานจะเป็นส่วนตัว เมธอดของวัตถุที่ส่งคืนมาจะครอบคลุมตัวแปรเหล่านั้นไว้ เช่นเดียวกับรูปแบบโมดูล แต่สามารถสร้างได้หลายอินสแตนซ์
function createCounter() {
let count = 0; // private
return {
inc: () => ++count,
get: () => count
};
}
const c = createCounter();
c.inc();
console.log(c.get()); // 1อินสแตนซ์อิสระหลายรายการ
การเรียกใช้โรงงานแต่ละครั้งจะสร้างวัตถุใหม่ที่มีสถานะส่วนตัวของตัวเอง นี่คือความแตกต่างสำคัญจากโมดูลแบบซิงเกิลตัน
function createCounter() {
let n = 0;
return { inc: () => ++n };
}
const a = createCounter();
const b = createCounter();
console.log(a.inc(), a.inc()); // 1 2
console.log(b.inc()); // 1คุณสมบัติที่คำนวณ
ฟังก์ชันโรงงานสามารถคำนวณค่าต่าง ๆ ตอนสร้าง และเปิดเผยเมธอดที่คำนวณค่าได้ โดยเก็บข้อมูลป้อนเข้าไว้เป็นส่วนตัว
function rectangle(w, h) {
return {
area: () => w * h,
perimeter: () => 2 * (w + h)
};
}
const r = rectangle(3, 4);
console.log(r.area()); // 12
console.log(r.perimeter()); // 14การตั้งค่าเริ่มต้นและการตั้งค่าเสริม
เนื่องจากเป็นฟังก์ชันธรรมดา ฟังก์ชันโรงงานจึงจัดการค่าเริ่มต้นและตัวเลือกต่าง ๆ ได้อย่างเป็นระเบียบด้วยการแยกโครงสร้าง
function createButton({ label = "OK", disabled = false } = {}) {
return { label, disabled };
}
console.log(createButton()); // { label: "OK", disabled: false }
console.log(createButton({ label: "Go" })); // { label: "Go", disabled: false }องค์ประกอบแทนการสืบทอด
ฟังก์ชันโรงงานเน้น composition โดยสร้างวัตถุจากการผสมพฤติกรรมต่าง ๆ แทนการต่อยอดสายโซ่คลาส
const canFly = (s) => ({ fly: () => s.name + " flies" });
function createBird(name) {
const self = { name };
return Object.assign(self, canFly(self));
}
console.log(createBird("Robin").fly()); // "Robin flies"พฤติกรรมที่ใช้ร่วมกัน
หากต้องการแชร์เมธอดระหว่างอินสแตนซ์โดยไม่สร้างสำเนาสำหรับแต่ละอินสแตนซ์ ให้กำหนดเมธอดเพียงครั้งเดียวแล้วใช้ assign หรือยอมรับต้นทุนเล็กน้อยเพื่อแลกกับประโยชน์ด้านความเป็นส่วนตัวที่คลอเชอร์มอบให้
const behavior = {
describe() { return "id " + this.id; }
};
function createItem(id) {
return Object.assign({ id }, behavior);
}
console.log(createItem(7).describe()); // "id 7"ส่งคืนฟังก์ชันด้วย
ฟังก์ชันโรงงานสามารถส่งคืนฟังก์ชันแทนวัตถุได้ หากนั่นทำให้ส่วนติดต่อเรียบง่ายกว่า และยังคงจับสถานะส่วนตัวไว้ได้
function multiplier(factor) {
return (n) => n * factor;
}
const triple = multiplier(3);
console.log(triple(5)); // 15โรงงานกับตัวสร้าง
ตัวสร้างใช้ new, this และสายโซ่ต้นแบบ ฟังก์ชันโรงงานเรียบง่ายกว่า หลีกเลี่ยงข้อผิดพลาดของ this และมอบความเป็นส่วนตัวที่แท้จริงผ่านคลอเชอร์ แต่ต้องแลกกับการไม่แชร์เมธอดผ่านต้นแบบ
การตรวจสอบเมื่อตอนสร้าง
ฟังก์ชันโรงงานสามารถตรวจสอบข้อมูลป้อนเข้า แล้วโยนข้อผิดพลาดหรือปรับข้อมูลให้อยู่ในรูปแบบมาตรฐานก่อนส่งคืน เพื่อรับประกันว่าวัตถุทุกชิ้นที่สร้างขึ้นถูกต้อง
function createAge(value) {
if (value < 0) throw new Error("age must be >= 0");
return { value };
}
console.log(createAge(30).value); // 30ตรวจสอบความเข้าใจอย่างรวดเร็ว
ฟังก์ชันโรงงาน
ทบทวน
ฟังก์ชันโรงงานส่งคืนวัตถุโดยไม่ใช้ new หรือ this และใช้คลอเชอร์เพื่อเก็บสถานะส่วนตัว การเรียกใช้แต่ละครั้งจะสร้างอินสแตนซ์ที่เป็นอิสระต่อกัน พร้อมรองรับคุณสมบัติที่คำนวณ การตั้งค่าเริ่มต้น composition และการตรวจสอบ ฟังก์ชันโรงงานแลกการแชร์เมธอดผ่านต้นแบบกับความเรียบง่ายและความเป็นส่วนตัวที่แท้จริง จึงเป็นทางเลือกแทนตัวสร้างที่สะอาดและขับเคลื่อนด้วยคลอเชอร์
คำถามที่พบบ่อย
บทเรียน “ฟังก์ชันโรงงาน” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ฟังก์ชันโรงงาน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส JavaScript Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส JavaScript Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ฟังก์ชันโรงงาน”
สร้างออบเจ็กต์ที่มีสถานะส่วนตัวผ่านคลอเชอร์ คุณปฏิบัติ JavaScript Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน JavaScript Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน JavaScript Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน
บทเรียน “ฟังก์ชันโรงงาน” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน JavaScript Academy นี้ได้ไหม
ได้ บทเรียน JavaScript Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ