NodeAsp

NodeAsp

NodeAsp คือชุดของเฟรมเวิร์ก Classic ASP ซึ่งใช้แนวคิดแบบโมดูลาร์ของ NodeJS ช่วยให้คุณสามารถเขียนโปรแกรม ASP โดยใช้แนวคิดใหม่ได้อย่างมีความสุข

การใช้งาน NodeAsp จำเป็นต้องเป็นไปตามข้อกำหนด CommonJS และเข้ากันได้อย่างสมบูรณ์กับวิธีการโหลดโมดูล NodeJS ซึ่งทำให้คุณสามารถใช้โมดูล NodeJS มากกว่า 50% ได้โดยตรง โมดูลทั้งหมดที่ไม่เกี่ยวข้องกับสภาพแวดล้อมการทำงาน NodeJS และอ็อบเจ็กต์เฉพาะ ES5-ES6 สามารถใช้ได้โดยตรง ไลบรารีทรัพยากรโมดูลขนาดใหญ่ดังกล่าวไม่มีอยู่ในกรอบงาน ASP ใด ๆ ในอดีต

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

NodeAsp อยู่ที่นี่ในฐานะจุดสิ้นสุดในฟิลด์ ASP

หน้าแรก

NodeAsp: http://nodeasp.com

ดาวน์โหลดโมดูล: http://nap.webkits.cn

สภาพแวดล้อมการทำงาน

เฟรมเวิร์กนี้ทำงานบนแพลตฟอร์ม WIN IIS เท่านั้น โดยปกติแล้วโฮสต์เสมือน ASP ธรรมดาสามารถเรียกใช้เฟรมเวิร์กนี้ได้

ตัวอย่างง่ายๆ

ค่าเริ่มต้น.asp

 <!-- #include file="NodeAsp.asp" -->

<%
    require( ' ./index.js');
%>

ดัชนี js

 var http = require ( 'http' ) ;

http . createServer ( function ( req , res ) {
  res . writeHead ( 200 , { 'Content-Type' : 'text/plain' } ) ;
  res . end ( 'Hello Worldn' ) ;
} ) ; 

วิธีใช้

ขั้นตอนที่ 1: ดาวน์โหลด NodeAsp.

ขั้นตอนที่ 2: อ้างอิง NodeAsp

 <!--#include file="NodeAsp.min.asp" -->

ขั้นตอนที่ 3: ใช้ NodeAsp

 < %
var version = process.version;
Response.Write(version);
% > 

วัตถุระดับโลก

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

ทั่วโลก

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

กระบวนการ

ส่งออกข้อมูลบางอย่างเกี่ยวกับสภาพแวดล้อมการทำงาน

ใน NodeAsp วัตถุประสงค์หลักของการดำรงอยู่ของกระบวนการคือการเข้ากันได้กับโมดูล NodeJS บางตัวซึ่งโดยปกติจะไม่ได้ใช้

คอนโซล

ใช้เพื่อพิมพ์เอาต์พุตมาตรฐานและข้อผิดพลาดมาตรฐาน

ดูส่วน控制台ด้านล่างสำหรับรายละเอียด

บัฟเฟอร์

เราได้แนะนำโมดูลบัฟเฟอร์เพื่อให้เข้ากันได้กับบัฟเฟอร์ของ NodeJS โปรดทราบว่าจะต้องรวมโมดูลบัฟเฟอร์ไว้ใต้ node_modules เพื่อใช้บัฟเฟอร์

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

จำเป็นต้อง

นำเข้าโมดูล ความแตกต่างเล็กน้อยจาก NodeJS คือเนื่องจาก IIS สามารถเรียกใช้ไฟล์ ASP ได้โดยตรงแทนไฟล์ JS เท่านั้น ดังนั้น need จึงสามารถใช้เพื่อขอโมดูลในโค้ด ASP คล้ายกับการรันโหนด test.js บนบรรทัดคำสั่ง

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

ดูส่วน模块ด้านล่างสำหรับรายละเอียด

__ชื่อไฟล์

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

ตัวอย่างเช่น: ดำเนินการ C:websitesnodeaspindex.asp

 // module.js
Response . Write ( __filename ) ;
// C:websitesnodeaspmodule.js

// index.asp
require ( './module' ) ;
Response . Write ( __filename ) ;
// C:websitesnodeaspindex.asp

__ชื่อ

ชื่อไดเร็กทอรีของไดเร็กทอรีที่สคริปต์ถูกเรียกใช้งานอยู่ในปัจจุบัน

โมดูล

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

ดูส่วน模块ด้านล่างสำหรับรายละเอียด

การส่งออก

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

ดูส่วน模块ด้านล่างสำหรับรายละเอียด

จับเวลา

ฟังก์ชั่นจับเวลาประกอบด้วยสี่ฟังก์ชั่นต่อไปนี้ เนื่องจาก ASP เป็นแบบเธรดเดียว ฟังก์ชันต่อไปนี้จึงเข้ากันไม่ได้จริง ๆ

 setTimeout(cb, ms)

clearTimeout(t)

setInterval(cb, ms)

clearInterval(t)

คอนโซล

เพื่อที่จะดีบักโปรแกรม ASP ได้ดีขึ้น เราได้ใช้เครื่องมือดีบักบรรทัดคำสั่งที่คล้ายกับเบราว์เซอร์ NodeJS/Chrome ที่อยู่การดาวน์โหลด: https://github.com/Spikef/NodeAsp-Console

หมายเหตุ: จำเป็นต้องใช้ IIS7.5 และ .NET4 เพื่อรัน และสภาพแวดล้อมอื่นๆ ยังไม่ได้รับการทดสอบ

คู่มือการใช้งาน

ขั้นตอนที่ 1: ลงทะเบียนคอมโพเนนต์ COM

เปิด CMD ด้วยสิทธิ์ของผู้ดูแลระบบ และใช้คำสั่ง REGASM เพื่อลงทะเบียนส่วนประกอบTerminal.dll โดยที่ REGASM อยู่ที่ C:WindowsMicrosoft.NETFrameworkv4.0.30319 (ตำแหน่งเฉพาะเกี่ยวข้องกับหมายเลขเวอร์ชัน)

 C:WindowsMicrosoft.NETFrameworkv4.0.30319REGASM D:componentTerminal.dll /codebase

ขั้นตอนที่ 2: แก้ไขรีจิสทรีเพื่อแก้ไขข้อผิดพลาด ASP 0177: 8000ffff

สำหรับระบบ 32 บิต ให้ค้นหาตำแหน่งรีจิสทรีต่อไปนี้:

HKEY_LOCAL_MACHINESOFTWAREMicrosoftInternet ExplorerMAINFeatureControlFEATURE_IGNORE_ZONES_INITIALIZATION_FAILURE_KB945701

สำหรับระบบ 64 บิต ให้ค้นหาตำแหน่งรีจิสทรีต่อไปนี้:

HKEY_LOCAL_MACHINESOFTWAREWow6432NodeMicrosoftInternet ExplorerMAINFeatureControlFEATURE_IGNORE_ZONES_INITIALIZATION_FAILURE_KB945701

เลือกหรือสร้างรายการใหม่ FEATURE_IGNORE_ZONES_INITIALIZATION_FAILURE_KB945701 จากนั้นสร้างค่า DWORD ใหม่:

ชื่อ: w3wp.exe ค่า: 1

ขั้นตอนที่ 3: เริ่มคอนโซล

คลิกสองครั้งที่ Console.exe เพื่อเปิดบรรทัดคำสั่งการดีบัก NodeAsp

ขั้นตอนที่ 4: การดีบัก

ป้อนรหัสต่อไปนี้ใน default.asp จากนั้นเข้าถึง default.asp ผ่านทางเบราว์เซอร์ จากนั้นคุณจะเห็นผลลัพธ์ใน Console.exe

 var a = { name : "nodeasp" , value : true }
// 在console中将输出
//{
//    name: "nodeasp",
//    value: true
//}

วิธีการโมดูล

console.log()

ส่งออกไปยังคอนโซลโดยใช้สีเริ่มต้น

 var a = { name : "NodeAsp" , version : "0.0.1" } ;
console . log ( a ) ; 

console.info()

สำหรับเอาต์พุตไปยังคอนโซล ให้ใช้สีเขียว

คอนโซล.ข้อผิดพลาด()

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

คอนโซล.คำเตือน()

สำหรับเอาต์พุตไปยังคอนโซล ให้ใช้สีเหลือง

console.time (ฉลาก)

ใช้ป้ายกำกับเพื่อระบุชื่อและเริ่มจับเวลาเพื่อคำนวณเวลาที่ต้องใช้ในการดำเนินการ

console.timeEnd (ฉลาก)

ส่งออกเวลาที่จำเป็นสำหรับการดำเนินการ

ตัวอย่าง:

    console . time ( '100-elements' ) ;
    for ( var i = 0 ; i < 100 ; i ++ ) {
      ;
    }
    console . timeEnd ( '100-elements' ) ;
    // prints 100-elements: 262ms

คำสั่ง

คุณสามารถป้อนคำสั่งต่อไปนี้ในคอนโซล

• cls/clear: ล้างข้อมูลการดีบักและไม่สามารถกู้คืนได้

• เกี่ยวกับ: แสดงเกี่ยวกับข้อมูล

• copylast: คัดลอกข้อความเอาต์พุตก่อนหน้า

• copyall: คัดลอกข้อมูลเอาต์พุตทั้งหมด

โมดูล

NodeAsp มีระบบการโหลดโมดูลที่เกือบจะเหมือนกับ NodeJS ซึ่งทำให้มั่นใจได้ว่า NodeAsp สามารถใช้โมดูล NodeJS จำนวนมากได้โดยตรง

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

ใน NodeAsp ไฟล์และโมดูลจะมีการโต้ตอบแบบหนึ่งต่อหนึ่ง ด้านล่างนี้เป็นตัวอย่างของ foo.js ที่โหลด Circle.js ในไดเร็กทอรีเดียวกัน

เนื้อหาของ foo.js

 var circle = require ( './circle.js' ) ;
console . log ( 'The area of a circle of radius 4 is '
+ circle . area ( 4 ) ) ;

เนื้อหาของ Circle.js:

 var PI = Math . PI ;
exports . area = function ( r ) {
    return PI * r * r ;
} ;
exports . circumference = function ( r ) {
    return 2 * PI * r ;
} ;

โมดูล Circle.js ส่งออกสองฟังก์ชันคือ area() และ circumference() หากต้องการส่งออกออบเจ็กต์ เพียงเพิ่มลงในการส่งออกออบเจ็กต์พิเศษ

โปรดทราบว่าการส่งออกเป็นการอ้างอิงถึง module.exports เพียงเพื่อความสะดวก เมื่อคุณต้องการส่งออกรายการเดียว เช่น ตัวสร้าง คุณต้องใช้ module.exports

 // 正确输出构造函数
module . exports = MyConstructor ;

ตัวแปรท้องถิ่นภายในโมดูลเป็นแบบส่วนตัว ในตัวอย่างนี้ ตัวแปร PI เป็นแบบส่วนตัวของ Circle.js

วงจร

พิจารณาสถานการณ์นี้:

อจ

 console . log ( 'a starting' ) ;
exports . done = false ;
var b = require ( './b.js' ) ;
console . log ( 'in a, b.done = %j' , b . done ) ;
exports . done = true ;
console . log ( 'a done' ) ;

บีเจส

 console . log ( 'b starting' ) ;
exports . done = false ;
var a = require ( './a.js' ) ;
console . log ( 'in b, a.done = %j' , a . done ) ;
exports . done = true ;
console . log ( 'b done' ) ;

main.js

 console . log ( 'main starting' ) ;
var a = require ( './a.js' ) ;
var b = require ( './b.js' ) ;
console . log ( 'in main, a.done=%j, b.done=%j' , a . done , b . done ) ;

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

ด้วยวิธีนี้ main.js จึงโหลดทั้งสองโมดูล ผลลัพธ์ของโปรแกรมนี้จะเป็นดังนี้:

 main starting
a starting
b starting
in b , a . done = false
b done
in a , b . done = true
a done
in main , a . done = true , b . done = true

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

 // a.js
var b = require ( './b.js' ) ;
    exports . add = function ( m , n ) {
    console . info ( m + n ) ;
} ;

// b.js
var a = require ( './a' ) ;
var m = 101 , n = 102 ;
exports . result = function ( ) {
    a . add ( m , n ) ;        // 此处没有问题
} ;
a . add ( m , n ) ;            // 此处会报错，找不到a.add方法

โมดูลไฟล์

หากไม่พบชื่อไฟล์ NodeAsp จะเพิ่มส่วนต่อท้าย .js และ .json แล้วลองโหลดอีกครั้ง

.js จะถูกแยกวิเคราะห์เป็นไฟล์ข้อความธรรมดา Javascript และ .json จะถูกแยกวิเคราะห์เป็นไฟล์ข้อความธรรมดาในรูปแบบ JSON

หากโมดูลขึ้นต้นด้วย '/' แสดงว่าโมดูลนั้นแสดงถึงเส้นทางที่แน่นอน ตัวอย่างเช่น need('/home/marco/foo.js') โหลดไฟล์ /home/marco/foo.js

หากโมดูลนำหน้าด้วย './' เส้นทางจะสัมพันธ์กับการเรียกไฟล์ need() กล่าวอีกนัยหนึ่ง วงกลม.js ต้องอยู่ในไดเรกทอรีเดียวกันกับ foo.js เพื่อให้ need('./circle') เพื่อค้นหา

เมื่อไฟล์ไม่ได้ชี้ไปที่ '/' หรือ './' โมดูลจะถูกโหลดจากโฟลเดอร์ node_modules

หากไม่มีเส้นทางที่ระบุ need() จะทำให้เกิดข้อผิดพลาด

หมายเหตุ: เมื่อพิจารณาว่าบนโฮสต์ IIS ไฟล์ .js สามารถเข้าถึงได้โดยตรงผ่านเบราว์เซอร์ ดังนั้นหากคุณไม่ต้องการให้ซอร์สโค้ดรั่วไหล คุณยังสามารถใช้ส่วนต่อท้ายไฟล์ใดก็ได้

โหลดจากโฟลเดอร์ node_modules

หากชื่อโมดูลใน need() ไม่ใช่โมดูลในเครื่องและไม่ได้ขึ้นต้นด้วย '/', '../' หรือ './' โหนดจะเริ่มต้นจากไดเร็กทอรีหลักของโมดูลปัจจุบันและลองเพิ่ม ไปที่ / โหลดโมดูลที่เกี่ยวข้องในโฟลเดอร์ node_modules

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

ตัวอย่างเช่น หากไฟล์อยู่ที่การเรียก '/home/ry/projects/foo.js' ต้องการ ('bar.js') ดังนั้นโหนดตำแหน่งที่ค้นหาคือ:

• /home/ry/projects/node_modules/bar.js

• /home/ry/node_modules/bar.js

• /home/node_modules/bar.js

• /node_modules/bar.js

แพคเกจโมดูล

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

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

 {
    "name" : "some-library" ,
    "main" : "./lib/some-library.js"
}

หากไฟล์นี้ในตัวอย่างอยู่ภายใต้ไดเร็กทอรี ./some-library ดังนั้น need('./some-library') จะโหลด ./some-library/lib/some-library.js

หากไม่มีไฟล์ package.json ในไดเร็กทอรี โหนดจะพยายามโหลด index.js ในพาธนี้

แคช

โมดูลจะถูกแคชหลังจากโหลดครั้งแรก ซึ่งหมายความว่า (เช่นเดียวกับแคชอื่นๆ) ออบเจ็กต์เดียวกันจะถูกส่งคืนทุกครั้งที่ need('foo') ถูกเรียก และแน่นอนว่า ไฟล์เดียวกันจะต้องถูกแยกวิเคราะห์ในแต่ละครั้ง

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

หากคุณต้องการให้โมดูลดำเนินการหลายครั้ง ให้ส่งออกฟังก์ชันแล้วเรียกใช้ฟังก์ชันนั้น

การแคชโมดูลอาศัยชื่อไฟล์ที่แยกวิเคราะห์ เนื่องจากไฟล์ที่แตกต่างกันอาจถูกแยกวิเคราะห์ขึ้นอยู่กับตำแหน่งของการโทร (เช่น เมื่อโหลดจากโฟลเดอร์ node_modules) จึงไม่รับประกันว่า need('foo') จะส่งกลับไฟล์ที่แน่นอนเสมอหากแยกวิเคราะห์เป็นไฟล์อื่น วัตถุเดียวกัน

วัตถุโมดูล

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

โมดูล.ส่งออก

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

 // circle.js
var PI = Math . PI ;
var circle = { } ;
circle . area = function ( r ) {
    return PI * r * r ;
} ;
circle . circumference = function ( r ) {
    return 2 * PI * r ;
} ;
module . exports = circle ; 

โมดูล.id

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

โมดูล.ชื่อไฟล์

ชื่อไฟล์ที่ได้รับการแก้ปัญหาอย่างสมบูรณ์ของโมดูล

โมดูล.ผู้ปกครอง

โมดูลที่นำเข้าโมดูลนี้

ค้นหากระบวนการ

เมื่อใช้ need() เพื่ออ้างอิงโมดูล จะต้องปฏิบัติตามกระบวนการต่อไปนี้เพื่อค้นหาโมดูลเป้าหมายตามนิพจน์

 require ( X ) from module at path Y
1. If X begins with './' or '/' or '../'
a . LOAD_AS_FILE ( Y + X )
b . LOAD_AS_DIRECTORY ( Y + X )
2. LOAD_NODE_MODULES ( X , dirname ( Y ) )
3. THROW "not found"

LOAD_AS_FILE ( X )
1. If X is a file , load X as JavaScript text .  STOP
2. If X . js is a file , load X . js as JavaScript text .  STOP
3. If X . json is a file , parse X . json to a JavaScript Object .  STOP

LOAD_AS_DIRECTORY ( X )
1. If X / package . json is a file ,
a . Parse X / package . json , and look for "main" field .
b . let M = X + ( json main field )
c . LOAD_AS_FILE ( M )
2. If X / index . js is a file , load X / index . js as JavaScript text .  STOP
3. If X / index . json is a file , parse X / index . json to a JavaScript object . STOP

LOAD_NODE_MODULES ( X , START )
1. let DIRS = NODE_MODULES_PATHS ( START )
2. for each DIR in DIRS :
a . LOAD_AS_FILE ( DIR / X )
b . LOAD_AS_DIRECTORY ( DIR / X )

NODE_MODULES_PATHS ( START )
1. let PARTS = path split ( START )
2. let I = count of PARTS - 1
3. let DIRS = [ ]
4. while I >= 0 ,
a . if PARTS [ I ] = "node_modules" CONTINUE
c . DIR = path join ( PARTS [ 0 . . I ] + "node_modules" )
b . DIRS = DIRS + DIR
c . let I = I - 1
5. return DIRS 

โมดูลในตัว

ต้องจำเป็นต้องมีโมดูลในตัว เช่น NodeJS ก่อนจึงจะสามารถใช้งานได้

ยืนยัน

โมดูลนี้ใช้เพื่อเขียนกรณีทดสอบหน่วยสำหรับโปรแกรมและถูกเรียกผ่าน need('assert') ย้ายโดยตรงจาก NodeJS

เหตุการณ์ต่างๆ

โมดูลการประมวลผลเหตุการณ์ ปลูกถ่ายโดยตรงจาก NodeJS

FS

โมดูลการดำเนินการไฟล์เข้ากันได้กับวิธี API การดำเนินการแบบซิงโครนัสของโมดูลการดำเนินการไฟล์ NodeJS ส่วนใหญ่

http

คำขอ HTTP และโมดูลการประมวลผล ย้ายและแก้ไขจาก NodeJS ส่วนใหญ่เข้ากันได้

เส้นทาง

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

ย้ายและแก้ไขจาก NodeJS ซึ่งเกือบจะเข้ากันได้อย่างสมบูรณ์

Punycode

เข้ารหัสและถอดรหัส URL เข้ากันได้กับ NodeJS อย่างสมบูรณ์

สายรัด

จัดการสตริงการสืบค้น URL เข้ากันได้กับ NodeJS อย่างสมบูรณ์

URL

โมดูลนี้มีฟังก์ชันอรรถประโยชน์สำหรับการแยกวิเคราะห์ URL ใช้ need('url') เพื่อเรียกโมดูลนี้

เข้ากันได้กับ NodeJS อย่างสมบูรณ์

ยูทิลิตี้

โมดูลวิธีการเสริม เข้ากันได้กับ NodeJS เวอร์ชันต่ำกว่า 4.0

คอมไพล์ซอร์สโค้ด NodeAsp

การคอมไพล์ซอร์สโค้ด NodeAsp จำเป็นต้องติดตั้งสภาพแวดล้อมของโหนดและติดตั้ง uglifyJS ทั่วโลก

เพียงดำเนินการ node build บนบรรทัดคำสั่ง ไฟล์ที่คอมไพล์จะอยู่ในไดเร็กทอรีบันเดิล

 C:DiskprojectsNodeAsp>node build
-----------------------
# build nodeAsp success
+ build/NodeAsp.min.asp
@ 2016-03-01 13:46:04
-----------------------

ใบอนุญาต

เอ็มไอที