NodeAsp
v0.1.14
NodeAsp est un ensemble de framework ASP classique, qui s'appuie sur l'idée modulaire de NodeJS, vous permettant d'écrire avec bonheur des programmes ASP en utilisant de nouveaux concepts.
NodeAsp utilise require qui suit la spécification CommonJS et est entièrement compatible avec la méthode de chargement des modules NodeJS, vous permettant d'utiliser directement plus de 50 % des modules NodeJS. Tous les modules qui n'ont rien à voir avec l'environnement d'exécution NodeJS et les objets spécifiques ES5-ES6 peuvent être utilisés directement. Une telle bibliothèque de ressources de modules n'était disponible dans aucun framework ASP dans le passé.
NodeAsp est un framework unique et innovant dans le domaine ASP. Son émergence a changé le modèle d'écriture ASP traditionnel, vous permettant de réaliser simultanément le développement front-end et back-end uniquement en connaissant js et en éliminant le processus fastidieux de déploiement. Serveurs NodeJS.
NodeAsp est ici comme terminateur dans le champ ASP.
NodeAsp : http://nodeasp.com
Téléchargement du module : http://nap.webkits.cn
Ce framework fonctionne uniquement sur la plateforme WIN IIS. Habituellement, un hôte virtuel ASP ordinaire peut exécuter ce framework.
par défaut.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' ) ;
} ) ; Étape 1 : Téléchargez NodeAsp.
Étape 2 : référencez NodeAsp.
<!--#include file="NodeAsp.min.asp" -->Étape 3 : utilisez NodeAsp.
< %
var version = process.version;
Response.Write(version);
% > Ces objets sont disponibles dans tous les modules. Certains objets ne sont pas réellement dans la portée globale, mais uniquement dans la portée du module - cette situation est spécifiquement soulignée dans la documentation suivante.
Dans les navigateurs, la portée de niveau supérieur est la portée globale. Cela signifie que dans le navigateur, var quelque chose déclarera une variable globale si elle se trouve actuellement dans la portée globale. C'est différent dans NodeAsp. La portée de niveau supérieur n'est pas la portée globale, var quelque chose dans le module NodeAsp n'appartient qu'à ce module.
Afficher des informations sur l'environnement d'exécution.
Dans NodeAsp, l'objectif principal de l'existence des processus est d'être compatible avec certains modules NodeJS, qui ne sont généralement pas utilisés.
Utilisé pour imprimer la sortie standard et l’erreur standard.
Voir la section控制台ci-dessous pour plus de détails.
Nous avons introduit le module buffer pour être compatible avec Buffer de NodeJS. Veuillez noter que le module buffer doit être inclus sous node_modules pour utiliser Buffer.
Si vous oubliez de placer le module buffer sous node_modules, cela n'affectera pas le fonctionnement normal du programme. Une erreur sera générée uniquement lorsque vous utiliserez Buffer.
Importer des modules. Un peu différent de NodeJS est que, comme IIS ne peut exécuter directement que des fichiers ASP au lieu de fichiers JS, require peut également être utilisé pour exiger un module dans le code ASP. Semblable à l’exécution de node test.js sur la ligne de commande.
Si vous souhaitez connaître le chemin réel du fichier lors de l'appel de la méthode require() pour charger le module, vous pouvez utiliser la méthode require.resolve() pour l'obtenir.
Voir模块ci-dessous pour plus de détails.
Le chemin du fichier de code en cours d'exécution. Il s'agit du chemin absolu analysé vers le fichier de code.
Par exemple : exécutez C:websitesnodeaspindex.asp
// module.js
Response . Write ( __filename ) ;
// C:websitesnodeaspmodule.js
// index.asp
require ( './module' ) ;
Response . Write ( __filename ) ;
// C:websitesnodeaspindex.aspLe nom du répertoire dans lequel le script est actuellement exécuté.
Une référence au module actuel. En particulier, module.exports et exports pointent vers le même objet. Le module n'est en fait pas global mais local à chaque module.
Voir模块ci-dessous pour plus de détails.
Une référence à l'objet module.exports, qui est partagé par toutes les instances du module actuel et accessible via require(). Des détails sur quand utiliser les exportations et quand utiliser module.exports peuvent être trouvés dans la documentation du système de module. Les exports ne sont en réalité pas globaux mais locaux à chaque module.
Voir模块ci-dessous pour plus de détails.
La fonction minuterie comprend les quatre fonctions suivantes. Comme ASP est monothread, les fonctions suivantes sont en réalité incompatibles.
setTimeout(cb, ms)
clearTimeout(t)
setInterval(cb, ms)
clearInterval(t)
Afin de mieux déboguer les programmes ASP, nous avons implémenté un outil de débogage en ligne de commande similaire au navigateur NodeJS/Chrome. Adresse de téléchargement : https://github.com/Spikef/NodeAsp-Console
REMARQUE : IIS7.5 et .NET4 sont requis pour fonctionner et les autres environnements n'ont pas été testés.
Ouvrez CMD avec les droits d'administrateur et utilisez la commande REGASM pour enregistrer composantTerminal.dll, où REGASM se trouve dans C:WindowsMicrosoft.NETFrameworkv4.0.30319 (l'emplacement spécifique est lié au numéro de version).
C:WindowsMicrosoft.NETFrameworkv4.0.30319REGASM D:componentTerminal.dll /codebase
Pour les systèmes 32 bits, recherchez l'emplacement de registre suivant :
HKEY_LOCAL_MACHINESOFTWAREMicrosoftInternet ExplorerMAINFeatureControlFEATURE_IGNORE_ZONES_INITIALIZATION_FAILURE_KB945701
Pour les systèmes 64 bits, recherchez l'emplacement de registre suivant :
HKEY_LOCAL_MACHINESOFTWAREWow6432NodeMicrosoftInternet ExplorerMAINFeatureControlFEATURE_IGNORE_ZONES_INITIALIZATION_FAILURE_KB945701
Sélectionnez ou créez un nouvel élément FEATURE_IGNORE_ZONES_INITIALIZATION_FAILURE_KB945701 , puis créez une nouvelle valeur DWORD :
Nom : w3wp.exe Valeur : 1
Double-cliquez sur Console.exe pour ouvrir la ligne de commande de débogage NodeAsp.
Entrez le code suivant dans default.asp, puis accédez à default.asp via le navigateur. Ensuite, vous pouvez voir les résultats dans Console.exe .
var a = { name : "nodeasp" , value : true }
// 在console中将输出
//{
// name: "nodeasp",
// value: true
//}Sortie vers la console, en utilisant les couleurs par défaut.
var a = { name : "NodeAsp" , version : "0.0.1" } ;
console . log ( a ) ; Pour la sortie vers la console, utilisez le vert.
Pour la sortie vers la console, utilisez le rouge. En particulier, si la sortie est un objet Error, le message d'erreur complet sera affiché.
Pour la sortie vers la console, utilisez le jaune.
Utilisez l'étiquette pour spécifier le nom et démarrer une minuterie pour calculer le temps requis pour l'opération.
Afficher le temps requis pour une opération.
Exemple:
console . time ( '100-elements' ) ;
for ( var i = 0 ; i < 100 ; i ++ ) {
;
}
console . timeEnd ( '100-elements' ) ;
// prints 100-elements: 262msVous pouvez saisir les commandes suivantes dans la console.
cls/clear : efface les informations de débogage et ne peut pas être restauré.
à propos : Afficher des informations à propos.
copylast : copie le message de sortie précédent.
copyall : copie toutes les informations de sortie.
NodeAsp dispose d'un système de chargement de modules presque identique à NodeJS, ce qui garantit que NodeAsp peut utiliser directement un grand nombre de modules NodeJS.
Le noyau de NodeAsp ne contient presque aucune fonction requise pour le développement de sites Web, et toutes les fonctions sont étendues via des modules. Vous pouvez trouver les modules de fonction dont vous avez besoin via le centre de modules de NodeAsp ou NPM.
Dans NodeAsp, les fichiers et les modules ont une correspondance biunivoque. Vous trouverez ci-dessous un exemple de foo.js chargeant circle.js dans le même répertoire.
Le contenu de foo.js
var circle = require ( './circle.js' ) ;
console . log ( 'The area of a circle of radius 4 is '
+ circle . area ( 4 ) ) ;Contenu de circle.js :
var PI = Math . PI ;
exports . area = function ( r ) {
return PI * r * r ;
} ;
exports . circumference = function ( r ) {
return 2 * PI * r ;
} ;Le module circle.js génère deux fonctions, area() et circumference(). Pour exporter un objet, ajoutez-le simplement aux exportations d'objets spéciaux.
Notez que exports est une référence à module.exports, juste pour plus de commodité. Lorsque vous souhaitez exporter un seul élément tel qu'un constructeur, vous devez utiliser module.exports.
// 正确输出构造函数
module . exports = MyConstructor ;Les variables locales au sein d'un module sont privées. Dans cet exemple, la variable PI est privée pour circle.js.
Considérez cette situation :
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' ) ;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 ) ;Tout d’abord, main.js charge a.js, puis a.js charge b.js. À ce moment-là, b.js tentera de charger a.js. Afin d'éviter les boucles infinies, a.js renverra une copie inachevée à b.js. Ensuite, b.js arrêtera de se charger et renverra son objet d'exportation au module a.js.
De cette façon, main.js a chargé les deux modules. Le résultat de ce programme est le suivant :
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 = trueComme NodeJS, les modules généralement dépendants de manière cyclique ne mèneront pas à une boucle infinie. Cependant, si vous exécutez directement les méthodes d'autres modules lorsque le module est chargé, vous serez informé que la méthode correspondante est introuvable, vous devez donc éviter cette situation. .
// 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 le nom du fichier est introuvable, NodeAsp ajoutera les suffixes .js et .json et tentera de se charger à nouveau.
.js sera analysé comme un fichier texte brut Javascript et .json sera analysé comme un fichier texte brut au format JSON.
Si le module est préfixé par '/', il représente un chemin absolu. Par exemple, require('/home/marco/foo.js') charge le fichier /home/marco/foo.js.
Si le module est préfixé par './', le chemin est relatif au fichier appelant require(). En d'autres termes, circle.js doit être dans le même répertoire que foo.js pour que require('./circle') le trouve.
Lorsqu'un fichier n'est pas pointé avec '/' ou './', le module est chargé depuis le dossier node_modules.
Si le chemin spécifié n'existe pas, require() générera une erreur.
REMARQUE : étant donné que sur l'hôte IIS, les fichiers
.jssont accessibles directement via le navigateur, donc si vous ne souhaitez pas divulguer le code source, vous pouvez également utiliser n'importe quel suffixe de fichier.
Si le nom du module dans require() n'est pas un module local et ne commence pas par '/', '../' ou './', alors le nœud démarrera à partir du répertoire parent du module actuel et tentera d'ajouter /Chargez le module correspondant dans le dossier node_modules.
S'il n'est pas trouvé, déplacez-vous vers le répertoire parent jusqu'à ce que vous atteigniez l'emplacement du répertoire supérieur.
Par exemple, si le fichier situé dans '/home/ry/projects/foo.js' appelle require('bar.js'), alors les emplacements recherchés par le nœud sont :
/home/ry/projects/node_modules/bar.js
/home/ry/node_modules/bar.js
/home/node_modules/bar.js
/node_modules/bar.js
Vous pouvez placer les programmes et les bibliothèques dans un dossier séparé et y fournir un point d'entrée unique. Il existe trois façons d'activer le chargement d'un dossier en tant que paramètre pour require().
La première étape consiste à créer un fichier appelé package.json dans le répertoire racine du dossier, qui doit spécifier un module principal. Vous trouverez ci-dessous un exemple de fichier package.json.
{
"name" : "some-library" ,
"main" : "./lib/some-library.js"
}Si ce fichier dans l'exemple est placé dans le répertoire ./some-library, alors require('./some-library') chargera ./some-library/lib/some-library.js.
S'il n'y a pas de fichier package.json dans le répertoire, le nœud essaiera de charger index.js dans ce chemin.
Les modules sont mis en cache après leur premier chargement. Cela signifie que (comme les autres caches), le même objet sera renvoyé à chaque fois que require('foo') est appelé, et bien sûr, le même fichier doit être analysé à chaque fois.
Appeler require(foo) plusieurs fois n'entraîne pas nécessairement l'exécution répétée du code dans le module. Il s'agit d'une fonctionnalité importante. Avec cette fonctionnalité, il est possible de renvoyer des objets partiellement terminés de cette façon, les dépendances transitives peuvent également être chargées. , même s'ils peuvent provoquer des boucles.
Si vous souhaitez qu'un module s'exécute plusieurs fois, exportez une fonction, puis appelez cette fonction.
La mise en cache des modules repose sur les noms de fichiers analysés. Étant donné que différents fichiers peuvent être analysés en fonction de l'emplacement de l'appel (par exemple, lors du chargement à partir du dossier node_modules), il n'y a aucune garantie que require('foo') renverra toujours le fichier exact s'il est analysé dans d'autres fichiers. même objet.
Dans chaque module, la variable module est une référence à un objet représentant le module actuel. En particulier, module.exports peut être obtenu via les exportations globales d'objets de module. module n'est pas réellement un objet global, mais plutôt interne à chaque module.
L'objet module.exports est généré via le système de modules. Par conséquent, il vous suffit d'attribuer l'objet à exporter à module.exports . Par exemple, nous pouvons également utiliser la méthode suivante pour écrire circle.js, qui est tout à fait équivalente.
// 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 ; Identifiant permettant de distinguer les modules. Généralement le nom du fichier entièrement analysé.
Le nom de fichier entièrement résolu du module.
Le module qui importe ce module.
Lorsque vous utilisez require() pour référencer un module, le processus suivant est suivi pour trouver le module cible en fonction de l'expression.
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 Les modules intégrés, comme NodeJS, doivent être requis avant de pouvoir être utilisés.
Ce module est utilisé pour écrire des cas de tests unitaires pour le programme et est appelé via require('assert'). Porté directement depuis NodeJS.
Module de traitement d'événements, directement transplanté depuis NodeJS.
Le module d'opération de fichier est compatible avec les méthodes API d'opération synchrone de la plupart des modules d'opération de fichier NodeJS.
Module de requête et de traitement HTTP. Portés et modifiés depuis NodeJS, la plupart d'entre eux sont compatibles.
Ce module contient un ensemble d'outils pour traiter et convertir les chemins de fichiers. Presque toutes les méthodes effectuent uniquement une transformation de chaîne et n'appellent pas le système de fichiers pour vérifier si le chemin est valide.
Porté et modifié depuis NodeJS, presque entièrement compatible.
Encode et décode les URL, entièrement compatible avec NodeJS.
Gère les chaînes de requête URL, entièrement compatibles avec NodeJS.
Ce module contient des fonctions utilitaires pour l'analyse d'URL. Utilisez require('url') pour appeler ce module.
Entièrement compatible avec NodeJS.
Module de méthode auxiliaire, compatible avec les versions NodeJS inférieures à 4.0.
La compilation du code source NodeAsp nécessite l'installation de l'environnement de nœud et l'installation d'uglifyJS globalement.
Exécutez simplement node build sur la ligne de commande. Les fichiers compilés se trouvent dans le répertoire du bundle.
C:DiskprojectsNodeAsp>node build
-----------------------
# build nodeAsp success
+ build/NodeAsp.min.asp
@ 2016-03-01 13:46:04
-----------------------
MIT
