NodeAsp
v0.1.14
NodeAsp es un conjunto de marcos ASP clásicos, que se basa en la idea modular de NodeJS, lo que le permite escribir felizmente programas ASP utilizando nuevos conceptos.
Los usos NodeAsp requieren que siga la especificación CommonJS y sea totalmente compatible con el método de carga de módulos NodeJS, lo que le permite utilizar directamente más del 50% de los módulos NodeJS. Todos los módulos que no tienen nada que ver con el entorno de ejecución de NodeJS y los objetos específicos de ES5-ES6 se pueden utilizar directamente. Una biblioteca de recursos de módulos tan grande no ha estado disponible en ningún marco ASP en el pasado.
NodeAsp es un marco único e innovador en el campo ASP. Su aparición ha cambiado el modelo de escritura ASP tradicional, lo que le permite completar el desarrollo front-end y back-end al mismo tiempo con solo conocer js y eliminar el tedioso proceso de implementación. Servidores NodeJS.
NodeAsp está aquí como terminador en el campo ASP.
NodoAsp: http://nodeasp.com
Descarga del módulo: http://nap.webkits.cn
Este marco solo se ejecuta en la plataforma WIN IIS. Por lo general, un host virtual ASP normal puede ejecutar este marco.
predeterminado.asp
<!-- #include file="NodeAsp.asp" -->
<%
require( ' ./index.js');
%>index.js
var http = require ( 'http' ) ;
http . createServer ( function ( req , res ) {
res . writeHead ( 200 , { 'Content-Type' : 'text/plain' } ) ;
res . end ( 'Hello Worldn' ) ;
} ) ; Paso 1: descargue NodeAsp.
Paso 2: Haga referencia a NodeAsp.
<!--#include file="NodeAsp.min.asp" -->Paso 3: utilice NodeAsp.
< %
var version = process.version;
Response.Write(version);
% > Estos objetos están disponibles en todos los módulos. Algunos objetos no están realmente en el alcance global, sino solo en el alcance del módulo; esta situación se señala específicamente en la siguiente documentación.
En los navegadores, el alcance de nivel superior es el alcance global. Esto significa que en el navegador, var algo declarará una variable global si se encuentra actualmente en el ámbito global. Es diferente en NodeAsp. El alcance de nivel superior no es el alcance global, var algo en el módulo NodeAsp solo pertenece a ese módulo.
Genere información sobre el entorno de ejecución.
En NodeAsp, el objetivo principal de la existencia del proceso es ser compatible con ciertos módulos de NodeJS, que normalmente no se utilizan.
Se utiliza para imprimir salida estándar y error estándar.
Consulte la sección控制台a continuación para obtener más detalles.
Hemos introducido el módulo de búfer para que sea compatible con Buffer de NodeJS. Tenga en cuenta que el módulo de búfer debe incluirse en node_modules para usar Buffer.
Si olvida colocar el módulo de búfer en node_modules, esto no afectará el funcionamiento normal del programa. Solo se generará un error cuando use Buffer.
Importar módulos. Una pequeña diferencia con NodeJS es que debido a que IIS solo puede ejecutar directamente archivos ASP en lugar de archivos JS, require también se puede usar para requerir un módulo en código ASP. Similar a ejecutar node test.js en la línea de comando.
Si desea conocer la ruta real del archivo al llamar al método require() para cargar el módulo, puede utilizar el método require.resolve() para obtenerla.
Consulte模块a continuación para obtener más detalles.
La ruta del archivo del archivo de código que se está ejecutando actualmente. Esta es la ruta absoluta analizada al archivo de código.
Por ejemplo: ejecute C:websitesnodeaspindex.asp
// module.js
Response . Write ( __filename ) ;
// C:websitesnodeaspmodule.js
// index.asp
require ( './module' ) ;
Response . Write ( __filename ) ;
// C:websitesnodeaspindex.aspEl nombre del directorio donde se ejecuta actualmente el script.
Una referencia al módulo actual. En particular, module.exports y exports apuntan al mismo objeto. En realidad, el módulo no es global sino local para cada módulo.
Consulte模块a continuación para obtener más detalles.
Una referencia al objeto module.exports, que es compartido por todas las instancias del módulo actual y al que se puede acceder a través de require(). Los detalles sobre cuándo usar exportaciones y cuándo usar module.exports se pueden encontrar en la documentación del sistema del módulo. En realidad, las exportaciones no son globales sino locales para cada módulo.
Consulte模块a continuación para obtener más detalles.
La función de temporizador incluye las siguientes cuatro funciones. Dado que ASP tiene un solo subproceso, las siguientes funciones son en realidad incompatibles.
setTimeout(cb, ms)
clearTimeout(t)
setInterval(cb, ms)
clearInterval(t)
Para depurar mejor los programas ASP, implementamos una herramienta de depuración de línea de comandos similar al navegador NodeJS/Chrome. Dirección de descarga: https://github.com/Spikef/NodeAsp-Console
NOTA: Se requiere IIS7.5 y .NET4 para ejecutarse y no se han probado otros entornos.
Abra CMD con derechos de administrador y use el comando REGASM para registrar componenteTerminal.dll, donde REGASM se encuentra en C:WindowsMicrosoft.NETFrameworkv4.0.30319 (la ubicación específica está relacionada con el número de versión).
C:WindowsMicrosoft.NETFrameworkv4.0.30319REGASM D:componentTerminal.dll /codebase
Para sistemas de 32 bits, busque la siguiente ubicación de registro:
HKEY_LOCAL_MACHINESOFTWAREMicrosoftInternet ExplorerMAINFeatureControlFEATURE_IGNORE_ZONES_INITIALIZATION_FAILURE_KB945701
Para sistemas de 64 bits, busque la siguiente ubicación de registro:
HKEY_LOCAL_MACHINESOFTWAREWow6432NodeMicrosoftInternet ExplorerMAINFeatureControlFEATURE_IGNORE_ZONES_INITIALIZATION_FAILURE_KB945701
Seleccione o cree un nuevo elemento FEATURE_IGNORE_ZONES_INITIALIZATION_FAILURE_KB945701 y luego cree un nuevo valor DWORD:
Nombre: w3wp.exe Valor: 1
Haga doble clic en Console.exe para abrir la línea de comando de depuración de NodeAsp.
Ingrese el siguiente código en default.asp y luego acceda a default.asp a través del navegador. A continuación, puedes ver los resultados en Console.exe .
var a = { name : "nodeasp" , value : true }
// 在console中将输出
//{
// name: "nodeasp",
// value: true
//}Salida a la consola, usando colores predeterminados.
var a = { name : "NodeAsp" , version : "0.0.1" } ;
console . log ( a ) ; Para la salida a la consola, use verde.
Para salida a la consola, use rojo. En particular, si la salida es un objeto de Error, se mostrará el mensaje de error completo.
Para salida a la consola, use amarillo.
Utilice la etiqueta para especificar el nombre e inicie un temporizador para calcular el tiempo necesario para la operación.
Muestra el tiempo requerido para una operación.
Ejemplo:
console . time ( '100-elements' ) ;
for ( var i = 0 ; i < 100 ; i ++ ) {
;
}
console . timeEnd ( '100-elements' ) ;
// prints 100-elements: 262msPuede ingresar los siguientes comandos en la consola.
cls/clear: borra la información de depuración y no se puede restaurar.
about: muestra información sobre.
copylast: copia el mensaje de salida anterior.
copyall: copia toda la información de salida.
NodeAsp tiene un sistema de carga de módulos que es casi idéntico a NodeJS, lo que garantiza que NodeAsp pueda utilizar directamente una gran cantidad de módulos NodeJS.
El núcleo de NodeAsp casi no contiene funciones necesarias para el desarrollo de sitios web y todas las funciones se amplían a través de módulos. Puede encontrar los módulos de funciones que necesita a través del centro de módulos de NodeAsp o NPM.
En NodeAsp, los archivos y módulos tienen una correspondencia uno a uno. A continuación se muestra un ejemplo de foo.js cargando Circle.js en el mismo directorio.
El contenido de foo.js
var circle = require ( './circle.js' ) ;
console . log ( 'The area of a circle of radius 4 is '
+ circle . area ( 4 ) ) ;Contenido de círculo.js:
var PI = Math . PI ;
exports . area = function ( r ) {
return PI * r * r ;
} ;
exports . circumference = function ( r ) {
return 2 * PI * r ;
} ;El módulo Circle.js genera dos funciones, área() y circunferencia(). Para exportar un objeto, simplemente agréguelo a las exportaciones de objetos especiales.
Tenga en cuenta que exports es una referencia a module.exports, solo por conveniencia. Cuando desee exportar un solo elemento, como un constructor, deberá utilizar module.exports.
// 正确输出构造函数
module . exports = MyConstructor ;Las variables locales dentro de un módulo son privadas. En este ejemplo, la variable PI es privada para Circle.js.
Considere esta situación:
a.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' ) ;b.js
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' ) ;principal.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 ) ;Primero, main.js carga a.js y luego a.js carga b.js. En este momento, b.js intentará cargar a.js. Para evitar bucles infinitos, a.js devolverá una copia sin terminar a b.js. Luego, b.js dejará de cargarse y devolverá su objeto de exportación al módulo a.js.
De esta forma, main.js ha cargado ambos módulos. El resultado de este programa es el siguiente:
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 = trueAl igual que NodeJS, los módulos que dependen cíclicamente no conducirán a un bucle infinito. Sin embargo, si ejecuta directamente los métodos de otros módulos cuando el módulo está cargado, se le indicará que no se puede encontrar el método correspondiente, por lo que debe evitar esta situación. .
// 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方法 Si no se encuentra el nombre del archivo, NodeAsp agregará los sufijos .js y .json e intentará cargarlo nuevamente.
.js se analizará como un archivo de texto sin formato Javascript y .json se analizará como un archivo de texto sin formato en formato JSON.
Si el módulo tiene el prefijo '/', representa una ruta absoluta. Por ejemplo, require('/home/marco/foo.js') carga el archivo /home/marco/foo.js.
Si el módulo tiene el prefijo './', la ruta es relativa al archivo que llama a require(). En otras palabras, círculo.js debe estar en el mismo directorio que foo.js para que require('./circle') lo encuentre.
Cuando un archivo no está señalado con '/' o './', el módulo se carga desde la carpeta node_modules.
Si la ruta especificada no existe, require() arrojará un error.
NOTA: Teniendo en cuenta que en el host IIS, se puede acceder a los archivos
.jsdirectamente a través del navegador, por lo que si no desea filtrar el código fuente, también puede utilizar cualquier sufijo de archivo.
Si el nombre del módulo en require() no es un módulo local y no comienza con '/', '../' o './', entonces el nodo comenzará desde el directorio principal del módulo actual e intentará agregar a / Cargue el módulo correspondiente en la carpeta node_modules.
Si no lo encuentra, suba al directorio principal hasta llegar a la ubicación del directorio superior.
Por ejemplo, si el archivo ubicado en '/home/ry/projects/foo.js' llama a require('bar.js'), entonces las ubicaciones que busca el nodo son:
/home/ry/projects/node_modules/bar.js
/home/ry/node_modules/bar.js
/home/node_modules/bar.js
/node_modules/bar.js
Puede colocar programas y bibliotecas en una carpeta separada y proporcionarles un único punto de entrada. Hay tres formas de permitir que una carpeta se cargue como parámetro para requerir().
El primer paso es crear un archivo llamado paquete.json en el directorio raíz de la carpeta, en el que se debe especificar un módulo principal. A continuación se muestra un ejemplo de un archivo package.json.
{
"name" : "some-library" ,
"main" : "./lib/some-library.js"
}Si este archivo en el ejemplo se coloca en el directorio ./some-library, entonces require('./some-library') cargará ./some-library/lib/some-library.js.
Si no hay ningún archivo package.json en el directorio, el nodo intentará cargar index.js en esta ruta.
Los módulos se almacenan en caché después de cargarse por primera vez. Esto significa que (al igual que otros cachés) se devolverá el mismo objeto cada vez que se llame a require('foo') y, por supuesto, se debe analizar el mismo archivo cada vez.
Llamar a require(foo) varias veces no necesariamente hace que el código del módulo se ejecute varias veces. Esta es una característica importante. Con esta característica, es posible devolver objetos parcialmente completados, y también se pueden cargar dependencias transitivas. , incluso si pueden causar bucles.
Si desea que un módulo se ejecute varias veces, exporte una función y luego llame a esa función.
El almacenamiento en caché del módulo se basa en nombres de archivos analizados. Dado que se pueden analizar diferentes archivos dependiendo de la ubicación de la llamada (por ejemplo, cuando se carga desde la carpeta node_modules), no hay garantía de que require('foo') siempre devuelva el archivo exacto si se analiza en otros archivos. mismo objeto.
En cada módulo, la variable módulo es una referencia a un objeto que representa el módulo actual. En particular, module.exports se puede obtener a través de las exportaciones de objetos del módulo global. El módulo no es en realidad un objeto global, sino más bien interno a cada módulo.
El objeto module.exports se genera a través del sistema de módulos. Por lo tanto, solo necesita asignar el objeto a exportar a module.exports . Por ejemplo, también podemos usar el siguiente método para escribir Circle.js, que es completamente equivalente.
// 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 ; Identificador utilizado para distinguir módulos. Generalmente, el nombre del archivo completamente analizado.
El nombre de archivo completamente resuelto del módulo.
El módulo que importa este módulo.
Cuando se usa require() para hacer referencia a un módulo, se sigue el siguiente proceso para encontrar el módulo de destino según la expresión.
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 Los módulos integrados, como NodeJS, deben ser necesarios antes de poder utilizarlos.
Este módulo se utiliza para escribir casos de prueba unitaria para el programa y se llama mediante require('assert'). Portado directamente desde NodeJS.
Módulo de procesamiento de eventos, trasplantado directamente desde NodeJS.
El módulo de operación de archivos es compatible con los métodos API de operación síncrona de la mayoría de los módulos de operación de archivos de NodeJS.
Módulo de procesamiento y solicitud HTTP. Portados y modificados desde NodeJS, la mayoría de ellos son compatibles.
Este módulo contiene un conjunto de herramientas para procesar y convertir rutas de archivos. Casi todos los métodos solo realizan transformación de cadenas y no llaman al sistema de archivos para verificar si la ruta es válida.
Portado y modificado desde NodeJS, casi totalmente compatible.
Codifica y decodifica URL, totalmente compatible con NodeJS.
Maneja cadenas de consulta de URL, totalmente compatible con NodeJS.
Este módulo contiene funciones de utilidad para el análisis de URL. Utilice require('url') para llamar a este módulo.
Totalmente compatible con NodeJS.
Módulo de método auxiliar, compatible con versiones de NodeJS inferiores a 4.0.
Para compilar el código fuente de NodeAsp es necesario instalar el entorno del nodo e instalar uglifyJS globalmente.
Simplemente ejecute node build en la línea de comando. Los archivos compilados se encuentran en el directorio del paquete.
C:DiskprojectsNodeAsp>node build
-----------------------
# build nodeAsp success
+ build/NodeAsp.min.asp
@ 2016-03-01 13:46:04
-----------------------
MIT
