คีย์เวิร์ดใหม่

การเรียกฟังก์ชันด้วย new จะสร้างออบเจ็กต์ใหม่โดยใช้ฟังก์ชันที่เรียกว่า "เครื่องมือสร้าง" สำหรับออบเจ็กต์นั้น

function MyFunction() {}
const myObject = new MyFunction();

typeof myObject;
> "object"`

วิธีนี้ช่วยให้ "ฟังก์ชันเครื่องมือสร้าง" สร้างเทมเพลตสำหรับการสร้างออบเจ็กต์ที่มีรูปแบบโครงสร้างเดียวกัน ดังนี้

function MyFunction() {
  this.myProperty = true;
}
const myObject = new MyFunction();

myObject.myProperty;
> true

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

function MyFunction( myArgument ) {
    this.myValue = myArgument;
    this.doubleMyValue = () => myArgument * 2;
}
const myObject = new MyFunction( 10 );

myObject.myValue;
> 10

myObject.doubleMyValue();
> 20

this หมายถึงบริบทการดำเนินการปัจจุบันของฟังก์ชัน ซึ่งหมายความว่าฟังก์ชันตัวสร้างจะเป็นไปตามกฎเดียวกันสำหรับค่าของ this เช่นเดียวกับฟังก์ชันอื่นๆ ตัวอย่างเช่น ฟังก์ชันที่กำหนดให้เป็นตัวสร้างจะใช้การเชื่อมโยงส่วนกลางสำหรับค่า this เมื่อเรียกใช้โดยอิสระ ดังนี้

function MyFunction() {
    console.log( this  );
}
const myObject = new MyFunction();
> MyFunction { }

MyFunction(); // Global `this` binding outside of strict mode is `globalThis`
> Window { … }

(function() {
    "use strict";
    function MyFunction() {
            console.log( this );
    }
    MyFunction();  // Global `this` binding inside of strict mode is `undefined`
}());
> undefined

เป็นเรื่องปกติที่จะใช้อักขระตัวแรกของตัวระบุของฟังก์ชันตัวสร้างตามรูปแบบการตั้งชื่อที่กำหนดโดยฟังก์ชันจากโรงงานของ JavaScript แม้ว่าบางครั้งคุณอาจเห็นการใช้คำที่ใช้สลับกัน แต่เป็นฟังก์ชันของตัวสร้าง ซึ่งเป็นฟังก์ชันที่มีจุดประสงค์ในการดำเนินการกับออบเจ็กต์ที่สร้างขึ้นใหม่เมื่อเรียกใช้ด้วยคีย์เวิร์ด new จะแตกต่างจาก "ฟังก์ชันโรงงาน" ซึ่งชัดแจ้ง return ออบเจ็กต์เมื่อมีการเรียกใช้ตามปกติ

function myFunction( myArgument = false ) {
  return { "myProperty" : myArgument };
}
const myObject = myFunction( true );

myObject;
> Object { myProperty: true }

แม้ว่าหลักการพื้นฐานจะเหมือนกัน แต่ Use Case สำหรับฟังก์ชันตัวสร้างที่กำหนดเองจะแสดงผลได้ดีกว่าด้วยไวยากรณ์คลาสที่มีฟีเจอร์ครบถ้วนมากกว่าใน ES6