ในฐานะที่เป็นรูปแบบการพัฒนาซอฟต์แวร์รูปแบบเสาหินถูกนำมาใช้อย่างกว้างขวางในภาษาที่มุ่งเน้นวัตถุมากมาย ในจาวาสคริปต์รูปแบบเสาหินยังใช้กันอย่างแพร่หลาย อย่างไรก็ตามเนื่องจากภาษา JavaScript มีวิธีการเชิงวัตถุที่เป็นเอกลักษณ์จึงสอดคล้องกับภาษาที่มุ่งเน้นวัตถุแบบดั้งเดิม แต่ก็ยังแตกต่างกันในการใช้งาน
ก่อนอื่นมาดูคำจำกัดความของรูปแบบโมโนเมอร์ในภาษาที่มุ่งเน้นวัตถุแบบดั้งเดิม: รูปแบบโมโนเมอร์เป็นคลาสที่สามารถสร้างอินสแตนซ์ได้เพียงครั้งเดียวและสามารถเข้าถึงได้ผ่านจุดเชื่อมต่อที่รู้จักกันดี มีสองจุดในคำจำกัดความนี้ที่เน้นลักษณะของภาษาที่มุ่งเน้นวัตถุแบบดั้งเดิมคือคลาสและการสร้างอินสแตนซ์ ดังนั้นสำหรับภาษาที่มุ่งเน้นวัตถุแบบดั้งเดิมรูปแบบเสาหินจึงขึ้นอยู่กับลักษณะตามธรรมชาติของชั้นเรียนและอินสแตนซ์ นั่นคือใช้คลาสคีย์เวิร์ดเพื่อกำหนดคลาสซึ่งสามารถสร้างอินสแตนซ์ผ่านคำหลักใหม่ แต่จะต้องมั่นใจว่าทุกครั้งที่มีการสร้างอินสแตนซ์โดยใหม่อินสแตนซ์เดียวกันจะได้รับหรือว่าตัวสร้างสามารถเรียกได้เพียงครั้งเดียว
ลองมาดูคำจำกัดความของรูปแบบโมโนเมอร์ใน JavaScript: Monomer เป็นวัตถุที่ใช้ในการแบ่งเนมสเปซและจัดระเบียบชุดของวิธีการและคุณลักษณะที่เกี่ยวข้องเข้าด้วยกัน หากสามารถสร้างอินสแตนซ์ได้จะสามารถสร้างอินสแตนซ์ได้เพียงครั้งเดียว เมื่อเปรียบเทียบคำจำกัดความข้างต้นคุณจะพบว่าคำจำกัดความของโมโนเมอร์ที่นี่กำหนดสาระสำคัญของมันเป็นวัตถุแทนที่จะเป็นคลาสในภาษาที่มุ่งเน้นวัตถุแบบดั้งเดิมซึ่งแสดงให้เห็นว่าภาษาของ JavaScript นั้นใช้วัตถุ ในเวลาเดียวกันมันก็ชี้ให้เห็นในภายหลังว่าหากสามารถสร้างอินสแตนซ์ได้นี่แสดงให้เห็นว่าควรมีหลายวิธีในการกำหนดโมโนเมอร์ใน JavaScript มีวิธีหนึ่งหรือมากกว่าหนึ่งวิธีในการสร้างอินสแตนซ์ที่สามารถสร้างอินสแตนซ์นั่นคือใช้คำหลักใหม่เพื่อสร้างวัตถุโมโนเมอร์ อย่างไรก็ตามวิธีนี้ไม่ใช่คุณสมบัติตามธรรมชาติของ JavaScript เองเนื่องจากวัตถุที่สร้างขึ้นโดยใช้คำหลักใหม่นั้นถูกจำลองและกำหนดผ่านฟังก์ชั่น (แม้ว่า ES6 จะเริ่มสนับสนุนคำหลักของคลาส แต่ยังไม่ได้รับการสนับสนุนอย่างกว้างขวางจากเบราว์เซอร์) ดังนั้นจะใช้คุณสมบัติตามธรรมชาติของ JavaScript เพื่อใช้รูปแบบโมโนเมอร์ได้อย่างไร?
var singleton = {attribute1: true, attribute2: 10, method1: function () {}, method2: function (arg) {}}นี่คือวัตถุซิงเกิลตันซึ่งมีคุณสมบัติและวิธีการหลายอย่าง มันรวมอยู่ในหน้า วัตถุนี้ถูกสร้างขึ้นเมื่อโหลด JS มันถูกเรียกว่าใช้ singleton.method1 เมื่อโทร การสร้างอินสแตนซ์ของมันจะเสร็จสมบูรณ์ในระหว่างการดำเนินการของการโหลดการแยกวิเคราะห์ JS เราไม่ได้ใช้คำหลักใหม่เพื่อสร้างอินสแตนซ์วัตถุนี้ นี่คือความแตกต่างอย่างมากระหว่างการใช้รูปแบบเสาหินใน JavaScript และภาษาที่มุ่งเน้นวัตถุแบบดั้งเดิม วิธีนี้ง่ายกว่าและเข้าใจง่ายกว่า อย่างไรก็ตามวิธีนี้มีข้อเสียหลายประการ ข้อเสียที่ชัดเจนอย่างหนึ่งคือมันไม่ได้ให้เนมสเปซ หากโปรแกรมเมอร์อื่น ๆ กำหนดตัวแปรซิงเกิลในหน้ามันเป็นเรื่องง่ายที่จะเขียนทับและสร้างความสับสนให้กับวัตถุเสาหิน ดังนั้นสำหรับปัญหานี้จะถูกเขียนใหม่ดังนี้:
var myspace = {}; myspace.singleton = {attribute1: true, attribute2: 10, method1: function () {}, method2: function (arg) {}}ที่นี่เนมสเปซ myspace ถูกกำหนดไว้ก่อนจากนั้นวัตถุเดี่ยวเดี่ยวจะถูกติดตั้งใต้วัตถุนี้ซึ่งจะช่วยลดความเป็นไปได้ของความขัดแย้งกับโปรแกรมเมอร์และการไม่เห็นแก่ตัวอย่างมาก แม้ว่าคนอื่นจะกำหนดตัวแปรซิงเกิลในขอบเขตทั่วโลก แต่ก็จะไม่ก่อให้เกิดมลพิษวัตถุซิงเกิลตัน สิ่งนี้ใช้ฟังก์ชั่นของการหารเนมสเปซและจัดระเบียบคุณลักษณะและวิธีการที่เกี่ยวข้องบางอย่างตามที่กล่าวไว้ในคำจำกัดความก่อนหน้า
วิธีนี้ยังคงมีข้อเสีย คุณสมบัติและวิธีการทั้งหมดของวัตถุเสาหินนี้จะถูกแชร์และสามารถเข้าถึงและแก้ไขได้ตลอดเวลาจากภายนอก ดังนั้นจึงใช้การปิดเพื่อจำลองคุณสมบัติและวิธีการส่วนตัวดังนี้:
myspace.singleton = (function () {var privateattribute1 = false; var privateattribute1 = [1,2,3]; ฟังก์ชั่น PrivateMethod1 () {} ฟังก์ชั่น PrivateMethod2 () {} return {publicattribute1: จริง PublicMethod2: ฟังก์ชั่น (Arg) {Privateattribute1 = [4,5,6];ที่นี่เรากำหนดฟังก์ชั่นการดำเนินการตนเองที่ไม่ระบุชื่อโดยตรงให้กับวัตถุ monolith ในฟังก์ชั่นนี้คำหลัก VAR และฟังก์ชั่นใช้เพื่อกำหนดคุณสมบัติส่วนตัวและวิธีการตามลำดับ สิ่งเหล่านี้ไม่สามารถเข้าถึงได้โดยตรงนอกฟังก์ชั่น (ด้านนอกวัตถุเสาหิน) เนื่องจากเมื่อฟังก์ชั่นถูกเรียกใช้งานพื้นที่ของขอบเขตภายในจะถูกรีไซเคิลซึ่งเป็นเหตุผลว่าทำไมการปิดสามารถใช้ในการจำลองคุณสมบัติและวิธีการส่วนตัว ในฟังก์ชั่นนี้ (ปิด) วัตถุจะถูกส่งคืนในที่สุดซึ่งมีวิธีการสาธารณะและคุณสมบัติบางอย่างซึ่งสามารถเรียกได้โดยตรงภายนอก ในเวลาเดียวกันเนื่องจากวิธีการสาธารณะเหล่านี้ถูกกำหนดไว้ในฟังก์ชั่นพวกเขาสามารถเรียกคุณสมบัติและวิธีการส่วนตัวของพวกเขา อย่างไรก็ตามโลกภายนอกสามารถดำเนินการบางอย่างผ่านวิธีการและคุณสมบัติสาธารณะที่ส่งคืนและไม่สามารถเรียกคุณสมบัติโดยตรงเช่น Singleton.PrivateMethod1 สิ่งนี้ทำให้วัตถุเสาหินไม่เพียง แต่แยกโลกภายนอกเพื่อเข้าถึงคุณสมบัติและวิธีการส่วนตัวโดยตรง แต่ยังมีคุณสมบัติและวิธีการทั่วไปบางอย่างไปยังโลกภายนอกเพื่อดำเนินการบางอย่างให้เสร็จสมบูรณ์
รูปแบบเสาหินนี้สร้างขึ้นโดยการตรวจสอบด้วยตนเองของฟังก์ชั่นที่ไม่ระบุชื่อถูกนำมาใช้กันอย่างแพร่หลายในห้องสมุด JS หลายแห่ง แต่ก็ยังมีปัญหาอยู่ หากเราไม่จำเป็นต้องใช้วัตถุเมื่อโหลดหน้าเว็บและการสร้างวัตถุมีราคาแพงกว่า (เช่นการคำนวณจำนวนมากหรือการเข้าถึงต้นไม้ DOM และคุณสมบัติหลายอย่าง ฯลฯ ) มันมีเหตุผลที่จะสร้างมันเมื่อจำเป็นแทนที่จะสร้างโดยตรงกับการแยกวิเคราะห์และการดำเนินการของ JS แนวคิดนี้เรียกว่า Lazy Loading ดังนั้นแก้ไขรหัสด้านบนดังนี้:
myspace.singleton = (function () {var impleinstance; function constructor () {var privateattribute1 = false; var privateattribute1 = [1,2,3]; ฟังก์ชั่น privateemethod1 () {} ฟังก์ชั่น PrivateMethod2 () {} {} {publicattribute1 Privateattribute1 = true;ที่นี่ตัวแปรส่วนตัวที่ไม่ซ้ำกัน enciendinstance ถูกกำหนดไว้ในฟังก์ชันที่ไม่ระบุชื่อเป็นที่จับเพื่อตรวจสอบว่ามีการสร้างวัตถุเสาหินหรือไม่ จากนั้นคุณลักษณะและวิธีการทั้งหมดที่กำหนดไว้สำหรับวัตถุเสาหินได้ถูกวางไว้ในฟังก์ชันที่เรียกว่าตัวสร้าง เฉพาะเมื่อฟังก์ชั่นเรียกว่าวัตถุเสาหินสามารถสร้างขึ้นได้มิฉะนั้นจะไม่ถูกสร้างขึ้นโดยตรง จากนั้นส่งคืนวัตถุซึ่งมีวิธี getInstance ซึ่งใช้สำหรับการโทรภายนอก เมื่อเรียกวิธีการก่อนอื่นให้พิจารณาว่าวัตถุเสาหินมีอยู่หรือไม่ ถ้ามีอยู่ให้ส่งคืนโดยตรง มิฉะนั้นเรียกใช้ฟังก์ชันตัวสร้างเพื่อสร้างวัตถุเสาหินและส่งคืน ในที่สุดถ้าเราเรียกวิธีการของวัตถุเสาหินเราจำเป็นต้องใช้ myspace.singleton.getInstance (). PublicMethod1 () ที่นี่เราจะสร้างวัตถุเสาหินนี้เท่านั้นเมื่อเราเรียกวิธีนี้มิฉะนั้นวัตถุเสาหินจะไม่ถูกสร้างขึ้นโดยอัตโนมัติซึ่งใช้จริงในการโหลดตามความต้องการหรือการโหลดขี้เกียจ