NodeAsp
v0.1.14
NodeAsp é um conjunto de estruturas ASP clássicas, que se baseia na ideia modular do NodeJS, permitindo que você escreva programas ASP com alegria usando novos conceitos.
NodeAsp usa require que segue a especificação CommonJS e é totalmente compatível com o método de carregamento de módulo NodeJS, permitindo usar diretamente mais de 50% dos módulos NodeJS. Todos os módulos que não têm nada a ver com o ambiente de execução do NodeJS e objetos específicos do ES5-ES6 podem ser usados diretamente. Uma biblioteca de recursos de módulos tão grande não estava disponível em nenhuma estrutura ASP no passado.
NodeAsp é uma estrutura única e inovadora no campo ASP. Seu surgimento mudou o modelo tradicional de escrita ASP, permitindo que você conclua o desenvolvimento front-end e back-end ao mesmo tempo apenas conhecendo js e eliminando o tedioso processo de implantação. Servidores NodeJS.
NodeAsp está aqui como terminador no campo ASP.
NodeAsp: http://nodeasp.com
Download do módulo: http://nap.webkits.cn
Esta estrutura funciona apenas na plataforma WIN IIS. Normalmente, um host virtual ASP comum pode executar esta estrutura.
padrão.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' ) ;
} ) ; Passo 1: Baixe o NodeAsp.
Etapa 2: Referência NodeAsp.
<!--#include file="NodeAsp.min.asp" -->Etapa 3: use o NodeAsp.
< %
var version = process.version;
Response.Write(version);
% > Esses objetos estão disponíveis em todos os módulos. Alguns objetos não estão realmente no escopo global, mas apenas no escopo do módulo - esta situação é apontada especificamente na documentação a seguir.
Nos navegadores, o escopo de nível superior é o escopo global. Isso significa que no navegador var alguma coisa declarará uma variável global se ela estiver atualmente no escopo global. É diferente no NodeAsp. O escopo de nível superior não é o escopo global, var algo no módulo NodeAsp pertence apenas a esse módulo.
Produza algumas informações sobre o ambiente em execução.
No NodeAsp, o principal objetivo da existência do processo é ser compatível com determinados módulos do NodeJS, que normalmente não são utilizados.
Usado para imprimir saída padrão e erro padrão.
Consulte a seção控制台abaixo para obter detalhes.
Introduzimos o módulo buffer para ser compatível com o Buffer do NodeJS. Observe que o módulo buffer deve ser incluído em node_modules para usar o Buffer.
Se você esquecer de colocar o módulo buffer em node_modules, isso não afetará a operação normal do programa. Um erro será gerado apenas quando você usar o Buffer.
Importe módulos. Um pouco diferente do NodeJS é que, como o IIS só pode executar diretamente arquivos ASP em vez de arquivos JS, require também pode ser usado para exigir um módulo no código ASP. Semelhante à execução do node test.js na linha de comando.
Se você quiser saber o caminho real do arquivo ao chamar o método require() para carregar o módulo, você pode usar o método require.resolve() para obtê-lo.
Consulte模块abaixo para obter detalhes.
O caminho do arquivo de código atualmente em execução. Este é o caminho absoluto analisado para o arquivo de código.
Por exemplo: execute C:websitesnodeaspindex.asp
// module.js
Response . Write ( __filename ) ;
// C:websitesnodeaspmodule.js
// index.asp
require ( './module' ) ;
Response . Write ( __filename ) ;
// C:websitesnodeaspindex.aspO nome do diretório onde o script é executado atualmente.
Uma referência ao módulo atual. Em particular, module.exports e exports apontam para o mesmo objeto. Na verdade, o módulo não é global, mas local para cada módulo.
Consulte模块abaixo para obter detalhes.
Uma referência ao objeto module.exports, que é compartilhado por todas as instâncias do módulo atual e pode ser acessado por meio de require(). Detalhes sobre quando usar exports e quando usar module.exports podem ser encontrados na documentação do sistema do módulo. Na verdade, as exportações não são globais, mas locais para cada módulo.
Consulte模块abaixo para obter detalhes.
A função de temporizador inclui as quatro funções a seguir. Como o ASP é de thread único, as funções a seguir são, na verdade, incompatíveis.
setTimeout(cb, ms)
clearTimeout(t)
setInterval(cb, ms)
clearInterval(t)
Para depurar melhor os programas ASP, implementamos uma ferramenta de depuração de linha de comando semelhante ao navegador NodeJS/Chrome. Endereço de download: https://github.com/Spikef/NodeAsp-Console
NOTA: IIS7.5 e .NET4 são necessários para execução e outros ambientes não foram testados.
Abra o CMD com direitos de administrador e use o comando REGASM para registrar o componenteTerminal.dll, onde REGASM está localizado em C:WindowsMicrosoft.NETFrameworkv4.0.30319 (o local específico está relacionado ao número da versão).
C:WindowsMicrosoft.NETFrameworkv4.0.30319REGASM D:componentTerminal.dll /codebase
Para sistemas de 32 bits, encontre o seguinte local de registro:
HKEY_LOCAL_MACHINESOFTWAREMicrosoftInternet ExplorerMAINFeatureControlFEATURE_IGNORE_ZONES_INITIALIZATION_FAILURE_KB945701
Para sistemas de 64 bits, encontre o seguinte local de registro:
HKEY_LOCAL_MACHINESOFTWAREWow6432NodeMicrosoftInternet ExplorerMAINFeatureControlFEATURE_IGNORE_ZONES_INITIALIZATION_FAILURE_KB945701
Selecione ou crie um novo item FEATURE_IGNORE_ZONES_INITIALIZATION_FAILURE_KB945701 e, em seguida, crie um novo valor DWORD:
Nome: w3wp.exe Valor: 1
Clique duas vezes em Console.exe para abrir a linha de comando de depuração do NodeAsp.
Insira o seguinte código em default.asp e acesse default.asp por meio do navegador. A seguir, você pode ver os resultados em Console.exe .
var a = { name : "nodeasp" , value : true }
// 在console中将输出
//{
// name: "nodeasp",
// value: true
//}Saída para Console, usando cores padrão.
var a = { name : "NodeAsp" , version : "0.0.1" } ;
console . log ( a ) ; Para saída para o Console, use verde.
Para saída para o Console, use vermelho. Em particular, se a saída for um objeto Error, a mensagem de erro completa será exibida.
Para saída para o Console, use amarelo.
Use rótulo para especificar o nome e iniciar um cronômetro para calcular o tempo necessário para a operação.
Produza o tempo necessário para uma operação.
Exemplo:
console . time ( '100-elements' ) ;
for ( var i = 0 ; i < 100 ; i ++ ) {
;
}
console . timeEnd ( '100-elements' ) ;
// prints 100-elements: 262msVocê pode inserir os seguintes comandos no console.
cls/clear: Limpa informações de depuração e não pode ser restaurado.
sobre: Exibe informações sobre.
copylast: Copia a mensagem de saída anterior.
copyall: Copie todas as informações de saída.
O NodeAsp possui um sistema de carregamento de módulos quase idêntico ao NodeJS, o que garante que o NodeAsp possa usar diretamente um grande número de módulos NodeJS.
O núcleo do NodeAsp quase não contém funções necessárias para o desenvolvimento de sites e todas as funções são estendidas por meio de módulos. Você pode encontrar os módulos de função necessários através do centro de módulos do NodeAsp ou NPM.
No NodeAsp, arquivos e módulos possuem uma correspondência um-para-um. Abaixo está um exemplo de foo.js carregando Circle.js no mesmo diretório.
O conteúdo de foo.js
var circle = require ( './circle.js' ) ;
console . log ( 'The area of a circle of radius 4 is '
+ circle . area ( 4 ) ) ;Conteúdo de círculo.js:
var PI = Math . PI ;
exports . area = function ( r ) {
return PI * r * r ;
} ;
exports . circumference = function ( r ) {
return 2 * PI * r ;
} ;O módulo Circle.js gera duas funções, area() e circunference(). Para exportar um objeto, basta adicioná-lo às exportações de objetos especiais.
Observe que exports é uma referência a module.exports, apenas por conveniência. Quando você deseja exportar um único item, como um construtor, você precisa usar module.exports.
// 正确输出构造函数
module . exports = MyConstructor ;Variáveis locais dentro de um módulo são privadas. Neste exemplo, a variável PI é privada para Circle.js.
Considere esta situação:
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 ) ;Primeiro, main.js carrega a.js e depois a.js carrega b.js. Neste momento, o b.js tentará carregar o a.js. Para evitar loops infinitos, a.js retornará uma cópia inacabada para b.js. Então b.js irá parar de carregar e retornar seu objeto de exportação para o módulo a.js.
Desta forma, main.js carregou ambos os módulos. A saída deste programa é a seguinte:
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 = trueComo o NodeJS, os módulos geralmente dependentes do ciclo não levarão a um loop infinito. No entanto, se você executar diretamente os métodos de outros módulos quando o módulo for carregado, você será avisado de que o método correspondente não pode ser encontrado, portanto, você deve evitar esta situação. .
// 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方法 Caso o nome do arquivo não seja encontrado, o NodeAsp adicionará os sufixos .js e .json e tentará carregar novamente.
.js será analisado como um arquivo de texto simples Javascript e .json será analisado como um arquivo de texto simples no formato JSON.
Se o módulo tiver o prefixo '/', ele representa um caminho absoluto. Por exemplo, require('/home/marco/foo.js') carrega o arquivo /home/marco/foo.js.
Se o módulo tiver o prefixo './', o caminho será relativo ao arquivo que chama require(). Em outras palavras, Circle.js deve estar no mesmo diretório que foo.js para require('./circle') encontrá-lo.
Quando um arquivo não é apontado com '/' ou './', o módulo é carregado da pasta node_modules.
Se o caminho especificado não existir, require() gerará um erro.
NOTA: Considerando que no host IIS, os arquivos
.jspodem ser acessados diretamente pelo navegador, portanto, se você não quiser vazar o código-fonte, também pode usar qualquer sufixo de arquivo.
Se o nome do módulo em require() não for um módulo local e não começar com '/', '../' ou './', então o nó iniciará no diretório pai do módulo atual e tentará adicionar para / Carregue o módulo correspondente na pasta node_modules.
Se não for encontrado, vá para o diretório pai até chegar ao local superior do diretório.
Por exemplo, se o arquivo localizado em '/home/ry/projects/foo.js' chama require('bar.js'), então os locais que o nó procura são:
/home/ry/projects/node_modules/bar.js
/home/ry/node_modules/bar.js
/home/node_modules/bar.js
/node_modules/bar.js
Você pode colocar programas e bibliotecas em uma pasta separada e fornecer um único ponto de entrada para eles. Existem três maneiras de permitir que uma pasta seja carregada como parâmetro para require().
O primeiro passo é criar um arquivo chamado package.json no diretório raiz da pasta, que precisa especificar um módulo principal. Abaixo está um exemplo de arquivo package.json.
{
"name" : "some-library" ,
"main" : "./lib/some-library.js"
}Se este arquivo no exemplo for colocado no diretório ./some-library, então require('./some-library') carregará ./some-library/lib/some-library.js.
Se não houver nenhum arquivo package.json no diretório, o nó tentará carregar index.js neste caminho.
Os módulos são armazenados em cache após serem carregados pela primeira vez. Isso significa que (como outros caches) o mesmo objeto será retornado toda vez que require('foo') for chamado e, claro, o mesmo arquivo deverá ser analisado todas as vezes.
Chamar require(foo) múltiplas vezes não faz necessariamente com que o código no módulo seja executado múltiplas vezes. Este é um recurso importante, é possível retornar objetos parcialmente concluídos, desta forma, dependências transitivas também podem ser carregadas. , mesmo que possam causar dependência de loops.
Se você deseja que um módulo seja executado várias vezes, exporte uma função e chame-a.
O cache do módulo depende de nomes de arquivos analisados. Como diferentes arquivos podem ser analisados dependendo do local da chamada (por exemplo, ao carregar da pasta node_modules), não há garantia de que require('foo') sempre retornará o arquivo exato se for analisado para outros arquivos. mesmo objeto.
Em cada módulo, a variável módulo é uma referência a um objeto que representa o módulo atual. Em particular, module.exports pode ser obtido por meio das exportações globais de objetos de módulo. module não é realmente um objeto global, mas mais interno a cada módulo.
O objeto module.exports é gerado por meio do sistema de módulos. Portanto, você só precisa atribuir o objeto a ser exportado para module.exports . Por exemplo, também podemos usar o seguinte método para escrever circle.js, que é 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 usado para distinguir módulos. Geralmente o nome do arquivo totalmente analisado.
O nome de arquivo totalmente resolvido do módulo.
O módulo que importa este módulo.
Ao usar require() para fazer referência a um módulo, o processo a seguir é seguido para encontrar o módulo de destino com base na expressão.
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 Módulos integrados, como NodeJS, devem ser necessários antes de serem usados.
Este módulo é usado para escrever casos de teste unitários para o programa e é chamado através de require('assert'). Portado diretamente do NodeJS.
Módulo de processamento de eventos, transplantado diretamente do NodeJS.
O módulo de operação de arquivo é compatível com os métodos API de operação síncrona da maioria dos módulos de operação de arquivo NodeJS.
Módulo de solicitação e processamento HTTP. Portados e modificados do NodeJS, a maioria deles são compatíveis.
Este módulo contém um conjunto de ferramentas para processar e converter caminhos de arquivos. Quase todos os métodos realizam apenas transformação de string e não chamam o sistema de arquivos para verificar se o caminho é válido.
Portado e modificado do NodeJS, quase totalmente compatível.
Codifica e decodifica URLs, totalmente compatível com NodeJS.
Lida com strings de consulta de URL, totalmente compatíveis com NodeJS.
Este módulo contém funções utilitárias para análise de URL. Use require('url') para chamar este módulo.
Totalmente compatível com NodeJS.
Módulo de método auxiliar, compatível com versões do NodeJS inferiores a 4.0.
A compilação do código-fonte do NodeAsp requer a instalação do ambiente do nó e a instalação do uglifyJS globalmente.
Basta executar node build na linha de comando. Os arquivos compilados estão localizados no diretório do pacote.
C:DiskprojectsNodeAsp>node build
-----------------------
# build nodeAsp success
+ build/NodeAsp.min.asp
@ 2016-03-01 13:46:04
-----------------------
MIT
