1. Análise de abertura
Olá a todos, o artigo de hoje se concentra principalmente em uma série de análises de código -fonte para o middleware "Connect" e o middleware auxiliar relacionado. Acho que todo mundo leu o artigo anterior.
Este artigo apresenta o método e o objetivo de uso, e este artigo também está fora do meu interesse, para que os leitores possam ter um entendimento mais profundo. Se houver alguma incorreção no estágio de análise, dê -me alguns conselhos.
tudo bem! Vamos ao ponto das regras antigas. Vamos dar uma olhada em um exemplo primeiro e usar a análise de introdução em combinação, como segue:
A cópia do código é a seguinte:
var connect = requer ("./ lib/connect");
var app = Connect.CreateServer ();
App.use (Connect.static (__ Dirname + "/public", {
Maxage: 0
}));
App.use (function (req, res, próximo) {
res.nd ("Hello World!");
})
.Listen (8888);
2. Análise de linha por linha:
(1), a primeira linha, introduza o módulo "Connect", crie um servidor HTTP | HTTPS através do Connect e forneça todas as funções do servidor HTTP.
O middleware "Connect" permite criar "servidores" de várias maneiras.
A cópia do código é a seguinte:
var Server = Connect.CreateServer (
Connect.logger ()
, Connect.static (__ Dirname + '/public')
); // 1
var app = Connect ();
App.use (function (req, res) {
res.nd ("Olá, Nobita!/n");
}). Ouça (8888); // 2
Então, como isso acontece, veja o código -fonte:
A cópia do código é a seguinte:
exports = module.exports = createServer;
exports.createServer = createServer;
O Mount "CreateServer" nas "exportações" globais, em seguida, expanda um atributo "CreateServer" e monte -o novamente, o objetivo é ser compatível com a forma de escrita nativa.
O objetivo de criar maneiras diferentes foi alcançado. Esta também é uma ideia que todos podem aprender em seu desenvolvimento diário.
(2), vejamos a segunda linha "Connect.CreateServer". O que isso fez, veja o código -fonte abaixo:
A cópia do código é a seguinte:
var httpServer = requer ('./ http'). servidor, servidor,
HttpSServer = requer ('./ https'). Servidor;
função createServer () {
if ('object' == typeof argumentos [0]) {
Retornar novo httpSServer (argumentos [0], Array.prototype.slice.call (argumentos, 1));
} outro {
retornar novo httpServer (array.prototype.slice.call (argumentos));
}
};
"HttpSServer" e "HttpServer" são basicamente os mesmos, eles são apenas o método HTTPS encapsulado por "httpSServer". Quando "CreateServer", uma série de middleware também pode ser transmitida, que é a mesma que a introdução subsequente, mas só pode estar ligada ao diretório raiz.
(3), continue olhando para a terceira linha "app.use ()", o que ele fez, observe o código -fonte da seguinte forma:
A cópia do código é a seguinte:
var server = exports.Server = função httpServer (middleware) {
this.stack = [];
middleware.foreach (função (fn) {
this.use (fn);
}, esse);
http.server.call (this, this.handle);
};
/**
* Herdar de `http.server.prototype`.
*/
Server.prototype .__ proto__ = http.server.prototype;
"Connect" é o protótipo herdado do "HTTP Server", que substituirá o Listener RequestListener do servidor pelo middleware que você usa.
Use "Connect.Use (Route, Handle)" para adicionar middleware a cada rota. O "identificador" desses middleware será obrigado a "rota" e salvo em uma "pilha". Toda vez que há uma solicitação de "solicitação",
Atravessando essa pilha, encontre o "identificador" correspondente a "rota" e execute "identificador". Se "Handle" Finalmente chamar "Next ()", continuará pesquisando e executando a próxima correspondência "Handle".
Ao encapsular "Handle", é fácil adicionar mais "middleware" a "Connect".
(4), finalmente, veja "Listen (8888)", que tipo de trabalho isso faz?
É muito simples. Ao herdar o objeto do servidor subjacente, ele fornece a função de "ouvir" para ouvir portas específicas.
Server.prototype .__ Proto__ = http.server.prototype
A seguir, é apresentado todo o código -fonte de "Connect.js". Para economizar espaço, todos os comentários foram excluídos, como mostrado na figura abaixo:
Para adicionar:
A cópia do código é a seguinte:
fs.readdirsync (__ dirname + '/middleware'). foreach (função (nome do arquivo) {
if (//.js$/.test(filename)) {
var name = filename.substr (0, filename.lastIndexof ('.'));
exports.middleware .__ definegetter __ (nome, function () {
Retorno requer ('./ middleware/' + nome);
});
}
});
O objeto "middleware" exporta "e depois loop para o objeto" middleware "é um método que carrega diretamente o módulo de arquivo .js na pasta" middleware ".
Uso: "exports.utils.merge (exports, exports.middleware)" para exportar diretamente os métodos no middleware.
Três, vamos resumir:
(1) Compreender a intenção de design do código -fonte ajudará a maximizar os ganhos no aplicativo.
(2) Ao olhar para o código -fonte, entenda o processo e deduza detalhes gramaticais.
(3) Aprenda com as idéias inteligentes de implementação no código -fonte, mas não faça o design da transição, o design por uma questão de design.
(4) Continue analisando o middleware relevante amanhã e continue sendo atualizado. . . . . .