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

ฟังก์ชันโรงงาน

สร้างออบเจ็กต์ที่มีสถานะส่วนตัวผ่านคลอเชอร์

ฟังก์ชันโรงงาน เป็นบทเรียน 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

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

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