เรียนรู้เกี่ยวกับโมดูลไฟล์และโมดูลหลักใน Node ในบทความเดียว

เมื่อเราใช้ Nodejs เพื่อการพัฒนารายวัน เรามักจะใช้ need เพื่อนำเข้าโมดูลสองประเภท หนึ่งคือโมดูลที่เราเขียนเองหรือ文件模块บุคคลที่สามที่ติดตั้งโดยใช้ npm คือ เป็นโมดูลในตัวของ Node ที่เตรียมไว้ให้เราใช้งาน เช่น os , fs และโมดูลอื่นๆ เรียกว่า核心模块

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

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

เริ่มจากโมดูลไฟล์กันก่อน

โมดูลไฟล์

โมดูลไฟล์คืออะไร?

ในโหนด โมดูลที่จำเป็นต้องใช้ตัวระบุโมดูลที่ขึ้นต้นด้วย .、.. 或/ (นั่นคือ การใช้เส้นทางสัมพัทธ์หรือเส้นทางสัมบูรณ์) จะถือเป็นโมดูลไฟล์ นอกจากนี้ยังมีโมดูลประเภทพิเศษ แม้ว่าจะไม่มีพาธสัมพัทธ์หรือพาธสัมบูรณ์ และไม่ใช่โมดูลหลัก แต่จะชี้ไปที่แพ็กเกจ เมื่อโหนดระบุตำแหน่งโมดูลประเภทนี้ ก็จะ模块路径เพื่อค้นหาโมดูลทีละโมดูล เรียกว่าโมดูลแบบกำหนดเอง

ดังนั้น โมดูลไฟล์จึงมีสองประเภท ประเภทหนึ่งคือโมดูลไฟล์ธรรมดาที่มีเส้นทาง และอีกประเภทหนึ่งคือโมดูลแบบกำหนดเองที่ไม่มีเส้นทาง

โมดูลไฟล์ถูกโหลดแบบไดนามิก ณ รันไทม์ ซึ่งต้องการตำแหน่งไฟล์ที่สมบูรณ์ กระบวนการคอมไพล์และดำเนินการ และช้ากว่าโมดูลหลัก

สำหรับการวางตำแหน่งไฟล์ Node จะจัดการโมดูลไฟล์ทั้งสองประเภทนี้แตกต่างกัน มาดูกระบวนการค้นหาโมดูลไฟล์ทั้งสองประเภทนี้กันดีกว่า

การค้นหาโมดูลไฟล์ธรรมดา

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

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

const math = need("math");

เนื่องจากไม่ได้ระบุนามสกุล โหนดจึงไม่สามารถระบุไฟล์สุดท้ายได้ ในกรณีนี้ โหนดจะดำเนินการขยายให้เสร็จสิ้นตามลำดับ .js、.json、.node และลองทำทีละรายการ กระบวนการนี้เรียกว่า文件扩展名分析

ควรสังเกตด้วยว่าในการพัฒนาจริง นอกเหนือจากความต้องการไฟล์เฉพาะแล้ว เรายังระบุไดเร็กทอรีด้วย เช่น:

const axios = need("../network");

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

โดยเฉพาะอย่างยิ่ง Node จะส่งคืนไฟล์ที่ชี้ไปที่ฟิลด์ main ของ package.json ในไดเร็กทอรีเป็นผลการค้นหา หากไฟล์ที่ชี้ไปโดย main นั้นผิด หรือไฟล์ package.json ไม่มีอยู่เลย Node จะใช้ index เป็นชื่อไฟล์เริ่มต้น จากนั้นใช้ .js และ .node เพื่อทำการวิเคราะห์ส่วนขยายและค้นหาไฟล์เป้าหมาย ทีละรายการหากไม่พบก็จะเกิดข้อผิดพลาด

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

เพิ่งกล่าวถึง

การค้นหาโมดูลแบบกำหนดเอง

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

// example.js
console.log(module.paths)

;

อย่างที่คุณเห็น โมดูลใน Node มีอาร์เรย์เส้นทางโมดูล ซึ่งถูกเก็บไว้ใน module.paths และใช้เพื่อระบุวิธีที่ Node ค้นหาโมดูลแบบกำหนดเองที่อ้างอิงโดยโมดูลปัจจุบัน

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

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

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

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

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

โมดูลไฟล์ถูกคอมไพล์และดำเนินการ

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

• ไฟล์ JavaScript ไฟล์จะถูกอ่านพร้อมกันผ่านโมดูล fs จากนั้นคอมไพล์และดำเนินการ ยกเว้นไฟล์ .node และ .json ไฟล์อื่นๆ จะถูกโหลดเป็นไฟล์ .js

• ไฟล์ .node ซึ่งเป็นไฟล์นามสกุลที่คอมไพล์และสร้างหลังจากเขียนด้วยภาษา C/C++ โหนดโหลดไฟล์ผ่านเมธอด process.dlopen()

• json หลังจากอ่านไฟล์พร้อมกันผ่านโมดูล fs แล้ว ให้ใช้ JSON.parse() เพื่อแยกวิเคราะห์และส่งกลับผลลัพธ์

ก่อนที่จะคอมไพล์และรันโมดูลไฟล์ Node จะล้อมมันโดยใช้โมดูล wrapper ดังที่แสดงด้านล่าง:

(function(exports, need, module, __filename, __dirname) {
    //Module code});

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

หลังจากเข้าใจโมดูล wrapper แล้ว เรามาดูรายละเอียดขั้นตอนการคอมไพล์และการดำเนินการของไฟล์ json กันก่อน

การคอมไพล์และรันไฟล์ json

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

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

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

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

การคอมไพล์และการดำเนินการของโมดูลส่วนขยาย C/C++

ก่อนที่จะอธิบายการคอมไพล์และการดำเนินการของโมดูลส่วนขยาย C/C++ ให้เราแนะนำก่อนว่าโมดูลส่วนขยาย C/C++ คืออะไร

โมดูลส่วนขยาย C/C++ อยู่ในหมวดหมู่ของโมดูลไฟล์ ตามชื่อที่แนะนำ โมดูลเหล่านี้เขียนด้วยภาษา C/C++ ก็คือ ไม่จำเป็นต้องคอมไพล์หลังจากโหลดแล้ว หลังจากดำเนินการโดยตรงแล้ว ดังนั้นจึงโหลดได้เร็วกว่าโมดูล JavaScript เล็กน้อย เมื่อเปรียบเทียบกับโมดูลไฟล์ที่เขียนด้วย JS โมดูลส่วนขยาย C/C++ มีข้อดีด้านประสิทธิภาพที่ชัดเจน สำหรับฟังก์ชันที่ไม่ครอบคลุมโดยโมดูลหลักของโหนดหรือมีข้อกำหนดด้านประสิทธิภาพเฉพาะ ผู้ใช้สามารถเขียนโมดูลส่วนขยาย C/C++ เพื่อให้บรรลุเป้าหมายได้

ไฟล์ .node คืออะไร และเกี่ยวข้องกับโมดูลส่วนขยาย C/C++ อย่างไร

ในความเป็นจริง หลังจากคอมไพล์โมดูลส่วนขยาย C/C++ ที่เขียนแล้ว ไฟล์ .node จะถูกสร้างขึ้น กล่าวอีกนัยหนึ่ง ในฐานะผู้ใช้โมดูล เราไม่ได้แนะนำซอร์สโค้ดของโมดูลส่วนขยาย C/C++ โดยตรง แต่เป็นไฟล์ไบนารีที่คอมไพล์แล้วของโมดูลส่วนขยาย C/C++ ดังนั้นจึงไม่จำเป็นต้องคอมไพล์ไฟล์ .node หลังจากที่ Node พบไฟล์ .node แล้ว จะต้องโหลดและรันไฟล์เท่านั้น ในระหว่างการดำเนินการ ออบเจ็กต์การส่งออกของโมดูลจะถูกเติมและส่งกลับไปยังผู้เรียก

เป็นที่น่าสังเกตว่าไฟล์ .node ที่สร้างโดยการคอมไพล์โมดูลส่วนขยาย C/C++ มีรูปแบบที่แตกต่างกันภายใต้แพลตฟอร์มที่แตกต่างกัน: ภายใต้ระบบ *nix โมดูลส่วนขยาย C/C++ จะถูกคอมไพล์เป็นไฟล์อ็อบเจ็กต์ที่ใช้ร่วมกันของลิงก์แบบไดนามิกโดยคอมไพเลอร์ เช่น g++/gcc ส่วนขยายคือ .so ภายใต้ Windows จะถูกคอมไพล์เป็นไฟล์ไลบรารีลิงก์แบบไดนามิกโดยคอมไพเลอร์ Visual C++ และส่วนขยายคือ .dll แต่นามสกุลที่เราใช้ในการใช้งานจริงคือ .node จริงๆ แล้วนามสกุลของ .node นั้นดูเป็นธรรมชาติมากกว่า จริงๆ แล้วมันเป็นไฟล์ .dll ใน Windows และไฟล์ .dll ใต้ไฟล์ .so *nix .

หลังจากที่ Node ค้นหาไฟล์ .node ที่ต้องการแล้ว จะเรียกเมธอด process.dlopen() เพื่อโหลดและรันไฟล์ เนื่องจากไฟล์ .node มีรูปแบบไฟล์ที่แตกต่างกันภายใต้แพลตฟอร์มที่แตกต่างกัน เพื่อให้บรรลุการใช้งานข้ามแพลตฟอร์ม เมธอด dlopen() จึงมีการใช้งานที่แตกต่างกันภายใต้แพลตฟอร์ม Windows และ *nix จากนั้นจึงถูกห่อหุ้มผ่านเลเยอร์ความเข้ากันได้ libuv รูปต่อไปนี้แสดงกระบวนการคอมไพล์และการโหลดโมดูลส่วนขยาย C/C++ ภายใต้แพลตฟอร์มที่แตกต่างกัน:

โมดูลหลัก

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

จริงๆ แล้วโมดูลหลักแบ่งออกเป็นสองส่วนที่เขียนด้วยภาษา C/C++ และ JavaScript ไฟล์ C/C++ จะถูกจัดเก็บไว้ในไดเร็กทอรี src ของโปรเจ็กต์ Node และไฟล์ JavaScript จะถูกจัดเก็บไว้ในไดเร็กทอรี lib แน่นอนว่ากระบวนการคอมไพล์และการดำเนินการของโมดูลทั้งสองส่วนนี้แตกต่างกัน

การคอมไพล์และการทำงานของโมดูลหลัก JavaScript

สำหรับการคอมไพล์โมดูลหลัก JavaScript ในระหว่างกระบวนการคอมไพล์ซอร์สโค้ดของ Node นั้น Node จะใช้เครื่องมือ js2c.py ที่มาพร้อมกับ V8 เพื่อแปลงโค้ด JavaScript ในตัวทั้งหมด รวมถึงโมดูลหลัก JavaScript ลงในอาร์เรย์ C++ โค้ด JavaScript จะถูกจัดเก็บไว้ในเนมสเปซของโหนดเป็นสตริง เมื่อเริ่มต้นกระบวนการโหนด โค้ด JavaScript จะถูกโหลดลงในหน่วยความจำโดยตรง

เมื่อมีการแนะนำโมดูลหลัก JavaScript โหนดจะเรียก process.binding() เพื่อค้นหาตำแหน่งในหน่วยความจำผ่านการวิเคราะห์ตัวระบุโมดูลและดึงข้อมูลออกมา หลังจากที่ถูกนำออกไปแล้ว โมดูลหลักของ JavaScript จะถูกห่อด้วยโมดูล wrapper จากนั้นจึงดำเนินการ ออบเจ็กต์การส่งออกจะถูกส่งออก และส่งคืนไปยังผู้เรียก

โมดูลหลัก C/C++ ได้รับการคอมไพล์และดำเนินการ

ในโมดูลหลัก บางโมดูลเขียนด้วยภาษา C/C++ ทั้งหมด บางโมดูลมีส่วนหลักที่เสร็จสมบูรณ์โดย C/C++ และส่วนอื่นๆ ได้รับการจัดทำแพ็คเกจหรือส่งออกโดย JavaScript เพื่อให้ตรงตามข้อกำหนดด้านประสิทธิภาพ โมดูลเช่น buffer , fs , os ฯลฯ เขียนบางส่วนด้วยภาษา C/C++ แบบจำลองนี้ซึ่ง โมดูล C++ ใช้คอร์ภายในส่วนหลัก และโมดูล JavaScript ใช้การห่อหุ้มภายนอกส่วนหลัก เป็นวิธีทั่วไปสำหรับ Node ในการปรับปรุงประสิทธิภาพ

ส่วนของโมดูลหลักที่เขียนด้วย C/C++ ล้วนเรียกว่าโมดูลในตัว เช่น node_fs , node_os ฯลฯ โดยปกติผู้ใช้จะไม่เรียกส่วนเหล่านี้โดยตรง แต่จะขึ้นอยู่กับโมดูลหลักของ JavaScript โดยตรง ดังนั้นในกระบวนการแนะนำโมดูลหลักของโหนดจึงมีสายโซ่อ้างอิงดังนี้:

โมดูลหลัก JavaScript โหลดโมดูลในตัวอย่างไร

จำเมธอด process.binding() ได้ไหม Node จะลบโมดูลหลักของ JavaScript ออกจากหน่วยความจำโดยการเรียกเมธอดนี้ วิธีนี้ยังใช้กับโมดูลหลักของ JavaScript เพื่อช่วยในการโหลดโมดูลในตัว

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

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

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

สรุป

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

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

• โมดูลไฟล์สามารถแบ่งออกเป็นโมดูล JavaScript และโมดูลส่วนขยาย C/C++ ตามกระบวนการคอมไพล์และการดำเนินการที่แตกต่างกัน หลังจากที่โมดูล JavaScript ได้รับการจัดทำแพ็กเกจโดยโมดูล Wrapper แล้ว โมดูลดังกล่าวจะถูกดำเนินการผ่านเมธอด runInThisContext ของโมดูล vm เนื่องจากโมดูลส่วนขยาย C/C++ เป็นไฟล์ปฏิบัติการที่สร้างขึ้นหลังจากการคอมไพล์แล้ว จึงสามารถดำเนินการได้โดยตรงและส่งคืนอ็อบเจ็กต์ที่ส่งออก ถึงผู้โทร

• โมดูลหลักแบ่งออกเป็นโมดูลหลัก JavaScript และโมดูลในตัว โมดูลหลัก JavaScript จะถูกโหลดลงในหน่วยความจำเมื่อกระบวนการ Node เริ่มต้นขึ้น สามารถนำออกมาและดำเนินการผ่านเมธอด process.binding() ได้ การคอมไพล์และการดำเนินการของโมดูลในตัวจะต้องผ่าน process.binding() การประมวลผลฟังก์ชัน get_builtin_module() และ register_func()

นอกจากนี้เรายังพบห่วงโซ่อ้างอิงสำหรับโหนดเพื่อแนะนำโมดูลหลักนั่นคือโมดูลไฟล์-> JavaScript Core Module-> โมดูลใน ตัว โมดูลใช้วิธีการเขียนโมดูลภายนอก