1. Análisis de apertura
Hola a todos, el artículo de hoy se centra principalmente en una serie de análisis de código fuente para el middleware "Connect" y el middleware auxiliar relacionado. Creo que todos han leído el artículo anterior.
Este artículo presenta el método y el propósito de uso, y este artículo también está fuera de mi propio interés, para que los lectores puedan tener una comprensión más profunda. Si hay alguna incorrección en la etapa de análisis, dame algunos consejos.
¡está bien! Llegemos al punto de las viejas reglas. Echemos un vistazo a un ejemplo primero y usemos el análisis de introducción en combinación, de la siguiente manera:
La copia del código es la siguiente:
var conection = request ("./ lib/conection");
var App = Connect.CreateServer ();
App.use (Connect.static (__ dirname + "/public", {
Maxage: 0
}));
app.use (function (req, res, next) {
res.end ("¡Hola mundo!");
})
.listen (8888);
2. Análisis de línea por línea:
(1), la primera línea, introduzca el módulo "Connect", cree un servidor HTTP | HTTPS a través de Connect y proporcione todas las funciones del servidor HTTP.
El middleware "Connect" le permite crear "servidores" de varias maneras.
La copia del código es la siguiente:
var servidor = conecte.createServer (
Connect.logger ()
, Connect.static (__ dirname + '/public')
); // 1
var App = Connect ();
app.use (function (req, res) {
res.end ("Hola, Nobita!/N");
}). Escuchar (8888); // 2
Entonces, cómo hace eso, mira el código fuente:
La copia del código es la siguiente:
exports = módulo.exports = createServer;
exports.createServer = CreateServer;
Mount "CreateServer" en las "exportaciones" globales, luego expande un atributo "CreateServer" y lo monte nuevamente, el propósito es ser compatible con el formulario de escritura nativo.
Se ha logrado el propósito de crear diferentes maneras. Esta es también una idea de la que todos pueden aprender en su desarrollo diario.
(2), veamos la segunda línea "Connect.CreateServer". ¿Qué hizo? Mira el código fuente a continuación:
La copia del código es la siguiente:
var httpserver = require ('./ http'). servidor,
Httpsserver = require ('./ https'). Server;
función createServer () {
if ('objeto' == typeof argumentos [0]) {
devolver nuevo httpsserver (argumentos [0], array.prototype.slice.call (argumentos, 1));
} demás {
devolver nuevo httpserver (array.prototype.slice.call (argumentos));
}
};
"Httpsserver" y "httpserver" son básicamente los mismos, son solo el método https encapsulado por "httpsserver". Cuando "CreateServer", también se puede pasar una serie de middleware, que es la misma que la introducción posterior, pero solo puede estar unida al directorio raíz.
(3), continúe mirando la tercera línea "App.use ()", qué hizo, mira el código fuente de la siguiente manera:
La copia del código es la siguiente:
var server = exports.server = function httpserver (middleware) {
this.stack = [];
middleware.foreach (function (fn) {
this.use (fn);
}, este);
http.server.call (this, this.handle);
};
/**
* Heredar de `http.server.prototype`.
*/
Servidor.prototype .__ proto__ = http.server.prototype;
"Connect" es el prototipo heredado de "HTTP Server", que reemplazará el Solicador del servidor con el middleware que usa.
Use "conectar.use (ruta, manejo)" para agregar middleware a cada ruta. El "mango" de estos middleware estará vinculado a "ruta" y guardado en una "pila". Cada vez que hay una solicitud de "solicitud",
Atravesando este montón, encuentre el "mango" correspondiente a la "ruta" y ejecute "identificador". Si "Many" finalmente llama a "Next ()", continuará buscando y ejecutando el siguiente manejo de "coincidencia".
Al encapsular "mango", es fácil agregar más "middleware" a "conectar".
(4), finalmente, mira "Escuchar (8888)", ¿Qué tipo de trabajo hace?
Es muy simple. Al heredar el objeto del servidor subyacente, proporciona la función de "escuchar" escuchar puertos específicos.
Servidor.prototype .__ proto__ = http.server.prototype
El siguiente es todo el código fuente de "Connect.js". Para ahorrar espacio, se han eliminado todos los comentarios, como se muestra en la figura a continuación:
Para agregar:
La copia del código es la siguiente:
fs.ReadDirsync (__ dirname + '/middleware'). foreach (función (nombre de archivo) {
if (//.js$/.test(fileName)) {
var name = filename.substr (0, filename.lastindexof ('.'));
exports.middleware .__ defineGetter __ (nombre, function () {
return requit ('./ middleware/' + name);
});
}
});
El "objeto" middleware "exporta" y luego enojar al objeto "middleware" es un método que carga directamente el módulo de archivo .js en la carpeta "middleware".
Use: "Exports.utils.merge (Exports, Exports.Middleware)" para exportar directamente los métodos en el middleware.
Tres, resumamos:
(1) Comprender la intención de diseño del código fuente ayudará a maximizar las ganancias en la aplicación.
(2) Al observar el código fuente, comprenda el proceso y luego deduzca los detalles gramaticales.
(3) Aprenda de las inteligentes ideas de implementación en el código fuente, pero no el diseño de la transición, el diseño en aras del diseño.
(4) Continúe analizando el middleware relevante mañana y continúe actualizándose. . . . . .