เรียนรู้เพิ่มเติมเกี่ยวกับกลไกโมดูลของ Node และพูดคุยเกี่ยวกับกระบวนการใช้งานโมดูล

ก่อนที่จะเสนอข้อกำหนด CommonJs Javascript ไม่มีระบบโมดูล ซึ่งหมายความว่าเป็นเรื่องยากสำหรับเราในการพัฒนาแอปพลิเคชันขนาดใหญ่เนื่องจากการจัดระเบียบโค้ดจะยากขึ้น

ข้อกำหนด CommonJs คืออะไร

ก่อนอื่น CommonJS ไม่ได้มีลักษณะเฉพาะสำหรับ Node CommonJS เป็นข้อกำหนดของโมดูลที่กำหนดวิธีการอ้างอิงและส่งออกโมดูล Nodejs ใช้เฉพาะข้อกำหนดนี้เท่านั้น โดยส่วนใหญ่แบ่งออกเป็นสามส่วน: การอ้างอิงโมดูล คำจำกัดความของโมดูล และการระบุโมดูล .

การอ้างอิงโมดูล

การอ้างอิงโมดูลหมายความว่าเราสามารถแนะนำโมดูลอื่นๆ ผ่านทาง require ได้

const { เพิ่ม } = ต้องการ('./add');
const result = add(1,2);

Module กำหนด

ไฟล์เป็นโมดูลและโมดูลจะมีตัวแปรสองตัวคือโมดูลและการส่งออก module คือโมดูลปัจจุบัน การส่งออกคือเนื้อหาที่จะส่งออก และการส่งออกเป็นคุณลักษณะของโมดูล นั่นคือ การส่งออกคือ module.exports เนื้อหาที่นำเข้าโดยโมดูลอื่นผ่าน need คือเนื้อหาของ module.exports

// add.js
ส่งออกเพิ่ม = (ก, ข) => {
    กลับ + b;
}

การระบุโมดูล

การระบุโมดูลคือเนื้อหาที่ต้องการ ตัวอย่างเช่น require('./add') ดังนั้นการระบุโมดูลคือ ./add add

กลไกการนำเข้าและส่งออกโมดูลที่สร้างผ่าน CommonJS ช่วยให้ผู้ใช้สามารถสร้างแอปพลิเคชันขนาดใหญ่ได้อย่างง่ายดายโดยไม่ต้องคำนึงถึงมลภาวะที่แปรผัน

การใช้งานโมดูลโหนด

โหนดใช้ข้อกำหนด CommonJs และเพิ่มคุณสมบัติบางอย่างที่ต้องการ โหนดส่วนใหญ่ทำสามสิ่งต่อไปนี้เพื่อใช้ข้อกำหนด CommonJs:

• การวางตำแหน่งไฟล์

• การวิเคราะห์พาธ

• การคอมไพล์ และการดำเนินการของ

การวิเคราะห์พาธ

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

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

// แผนภาพโมดูลแคช:
const cachedModule = {
    '/Usr/file/src/add.js': 'เนื้อหาที่คอมไพล์ของ add.js',
    'http': 'เนื้อหาที่คอมไพล์ของโมดูล http ที่มาพร้อมกับโหนด',
    'express': 'เนื้อหาที่คอมไพล์ของโมดูลไฟล์ที่กำหนดเองที่ไม่ใช่เส้นทางด่วน'
    -
}

เมื่อคุณต้องการค้นหาโมดูลที่นำเข้าโดย need ลำดับการค้นหาโมดูลคือการตรวจสอบก่อนว่าโมดูลนั้นอยู่ในแคชหรือไม่ หากไม่อยู่ในแคช ให้ตรวจสอบโมดูลหลักแล้วค้นหา โมดูลไฟล์ ในหมู่พวกเขาโมดูลไฟล์ในรูปแบบของเส้นทางจะค้นหาได้ง่ายกว่า เส้นทางไฟล์ที่สมบูรณ์สามารถรับได้ตามเส้นทางสัมพัทธ์หรือเส้นทางสัมบูรณ์ การค้นหาโมดูลไฟล์แบบกำหนดเองในรูปแบบที่ไม่ใช่เส้นทางค่อนข้างลำบาก

ไดเร็กทอรี node_modules อยู่ที่ไหน ตัวอย่างเช่น ไฟล์ที่เรากำลังดำเนินการอยู่คือ /Usr/file/index.js

; 
* /Usr/file/index.js;
-

const { เพิ่ม } = ต้องการ ('เพิ่ม');
const result = add(1, 2);

ในโมดูลนี้ เราได้แนะนำโมดูลเพิ่มแล้ว การเพิ่มนี้ไม่ใช่โมดูลหลักหรือโมดูลไฟล์ในรูปแบบของเส้นทาง ดังนั้นวิธีการค้นหาโมดูลเพิ่มในขณะนี้

โมดูลมีแอตทริบิวต์ path เส้นทางในการค้นหาโมดูลเพิ่มอยู่ในแอตทริบิวต์ paths เราสามารถพิมพ์แอตทริบิวต์นี้เพื่อดู:

/** 
* /Usr/file/index.js;
-

console.log(module.paths);

เราสามารถพิมพ์ค่าของพาธได้โดยการรัน node index.js ในไดเร็กทอรีไฟล์ ค่าในเส้นทางเป็นอาร์เรย์ดังนี้:

[
'/Usr/file/node_modules',
'/Usr/node_modules',
'/node_modules',
]

นั่นคือโหนดจะค้นหาตามลำดับจากไดเร็กทอรีด้านบนเพื่อดูว่ามีโมดูลเพิ่มหรือไม่ หลักการจะคล้ายกับห่วงโซ่ต้นแบบ ขั้นแรก ให้เริ่มการค้นหาในโฟลเดอร์ node_modules ในไดเร็กทอรีระดับเดียวกับไฟล์ที่ดำเนินการในปัจจุบัน หากไม่พบไดเร็กทอรี node_modules หรือไม่มีอยู่ ให้ค้นหาต่อไปยังระดับบนสุด

ตำแหน่งไฟล์

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

การวิเคราะห์นามสกุลไฟล์

const { add } = need('./add');

ตัวอย่างเช่น ในโค้ดด้านบน ตัวระบุไฟล์ไม่มีนามสกุล ในขณะนี้ โหนดจะค้นหาการมีอยู่ของ .js, .json และ .node ตามลำดับ

การวิเคราะห์ไดเร็กทอรีและแพ็กเกจ

เหมือนกับโค้ดด้านบน สิ่งที่พบผ่าน ./add อาจไม่ใช่ไฟล์ แต่อาจเป็นไดเร็กทอรีหรือแพ็กเกจ (ตัดสินว่าเป็นไดเร็กทอรีหรือแพ็กเกจโดยการตัดสินว่ามีแพ็กเกจหรือไม่ json ในโฟลเดอร์เพิ่ม) ในขณะนี้ ขั้นตอนสำหรับการวางตำแหน่งไฟล์มีดังนี้:

• ตรวจสอบว่ามีไฟล์ package.json
  • • หรือไม่ อ่านค่าของฟิลด์หลักใน package.json เป็นไฟล์
  • อย่า
    • ค้นหาดัชนีในไดเร็กทอรีเป็นไฟล์ (มองหา index.js, index.json, index.node)

หากไม่มีฟิลด์หลักใน package.json ดัชนีก็จะถูกใช้เป็นไฟล์ด้วย จากนั้นจะดำเนินการวิเคราะห์ส่วนขยายเพื่อค้นหาไฟล์ที่มีส่วนต่อท้ายที่เกี่ยวข้อง .

การคอมไพล์โมดูล

โมดูลหลักที่เราพบในการพัฒนาคือโมดูล json และโมดูล js

การคอมไพล์โมดูล json

เมื่อเราต้องการโมดูล json โหนดจะช่วยเราใช้ fs.readFilcSync เพื่ออ่านไฟล์ json ที่เกี่ยวข้อง รับสตริง json จากนั้นเรียก JSON.parse เพื่อแยกวิเคราะห์เพื่อรับวัตถุ json จากนั้นมอบหมายให้ ส่งออกโมดูลแล้วจึงกำหนดให้ต้องการ

การคอมไพล์โมดูล js

เมื่อเราต้องการโมดูล js เช่น

// index.js
const { เพิ่ม } = need('./add');

// add.js
ส่งออกเพิ่ม = (ก, ข) => {
    กลับ + b;
}

เกิดอะไรขึ้นในเวลานี้ เหตุใดเราจึงสามารถใช้โมดูลตัวแปร ส่งออก และต้องการโดยตรงในโมดูล เนื่องจาก Node จะล้อมเนื้อหาของโมดูลก่อนและหลังเมื่อรวบรวมโมดูล js

ตัวอย่างเช่น โมดูล add.js จะถูกรวมไว้ในโครงสร้างที่คล้ายกับสิ่งนี้เมื่อคอมไพล์จริง:

(function(require,exports, module) {
  ส่งออกเพิ่ม = (ก, ข) => {
    กลับ + b;
  -
  ส่งคืนโมดูลส่งออก;
})(require, module.exports, module)

นั่นคือไฟล์ js ที่เราเขียนจะถูกรวมไว้ในฟังก์ชัน สิ่งที่เราเขียนเป็นเพียงเนื้อหาในฟังก์ชันนี้เท่านั้น และกระบวนการบรรจุภัณฑ์ที่ตามมาของ Node จะถูกซ่อนจากเรา ฟังก์ชันนี้รองรับการส่งผ่านพารามิเตอร์บางตัว รวมถึงข้อกำหนด การส่งออก และโมดูล

หลังจากคอมไพล์ไฟล์ js แล้ว ไฟล์จะถูกดำเนินการ โหนดจะส่งพารามิเตอร์ที่เกี่ยวข้องไปยังฟังก์ชันนี้ จากนั้นจึงดำเนินการและส่งคืนค่า module.exports ไปยังฟังก์ชัน need

ข้างต้นเป็นกระบวนการพื้นฐานสำหรับโหนดในการใช้ข้อกำหนด CommonJs