1. Analyse d'ouverture
Bonjour à tous, l'article d'aujourd'hui se concentre principalement sur une série d'analyse de code source pour le middleware "Connect" et le middleware auxiliaire associé. Je pense que tout le monde a lu l'article précédent.
Cet article présente la méthode et l'objectif d'utilisation, et cet article est également hors de mon propre intérêt, afin que les lecteurs puissent en avoir une compréhension plus approfondie. S'il y a une incorrecte dans l'étape d'analyse, veuillez me donner quelques conseils.
Très bien! Passons au point des anciennes règles. Jetons un coup d'œil à un exemple d'abord et utilisons l'analyse d'introduction en combinaison, comme suit:
La copie de code est la suivante:
var connect = require ("./ lib / connect");
var app = connect.createServer ();
app.use (connect.static (__ dirname + "/ public", {
Maxage: 0
}));
app.use (function (req, res, suivant) {
res.end ("Hello World!");
})
.Listen (8888);
2. Analyse ligne par ligne:
(1), la première ligne, introduisez le module "Connect", créez un serveur HTTP | HTTPS via Connect et fournissez toutes les fonctions du serveur HTTP.
Le middleware "Connect" vous permet de créer des "serveurs" de diverses manières.
La copie de code est la suivante:
var server = connect.createServer (
connect.logger ()
, connect.static (__ dirname + '/ public')
)); // 1
var app = connect ();
app.use (function (req, res) {
res.end ("Bonjour, Nobita! / N");
}). écouter (8888); // 2
Alors comment cela fait cela, regardez le code source:
La copie de code est la suivante:
exports = module.exports = CreateServer;
export.CreateServer = CreateServer;
Monter "CreateServer" sur les "exportations" globales, puis développer un attribut "CreateServer" et le monter à nouveau, le but est d'être compatible avec la forme d'écriture native.
Le but de créer différentes manières a été atteint. C'est aussi une idée dont tout le monde peut apprendre dans son développement quotidien.
(2), examinons la deuxième ligne "connect.createserver". Qu'est-ce que cela a fait, consultez le code source ci-dessous:
La copie de code est la suivante:
var httpServer = require ('./ http'). Server,
HttpsServer = require ('./ https'). Server;
Fonction CreateServer () {
if ('objet' == type de arguments [0]) {
renvoyer un nouveau httpsServer (arguments [0], array.prototype.slice.call (arguments, 1));
} autre {
Renvoie un nouveau httpSserver (array.prototype.slice.call (arguments));
}
};
"Httpsserver" et "httpserver" sont fondamentalement les mêmes, ce ne sont que la méthode HTTPS encapsulée par "httpsserver". Lorsque "CreateServer", une série de middleware peut également être transmise, ce qui est le même que l'introduction ultérieure, mais ne peut être lié au répertoire racine.
(3), continuez à regarder la troisième ligne "app.use ()", qu'est-ce qu'il a fait, consultez le code source comme suit:
La copie de code est la suivante:
var server = export.server = fonction httpServer (middleware) {
this.stack = [];
middleware.ForEach (fonction (fn) {
this.use (fn);
}, ce);
http.server.call (this, this.handle);
};
/ **
* Hériter de `http.server.prototype`.
* /
Server.prototype .__ proto__ = http.server.prototype;
"Connect" est le prototype hérité de "HTTP Server", qui remplacera le RequestListener du serveur par le middleware que vous utilisez.
Utilisez "Connect.User (route, manche)" pour ajouter du middleware à chaque itinéraire. La "poignée" de ces middleware sera liée à "router" et enregistrée dans une "pile". Chaque fois qu'il y a une demande "demande",
Traversant ce tas, trouvez la "poignée" correspondant à "Route" et exécutez "Handle". Si "manche" appelle enfin "next ()", il continuera de rechercher et d'exécuter le prochain "manche" correspondant.
En encapsulant "manche", il est facile d'ajouter plus de "middleware" pour "connecter".
(4), enfin, regardez "écouter (8888)", quel genre de travail fait-il?
C'est très simple. En héritant de l'objet serveur sous-jacent, il donne la fonction de "écouter" pour écouter des ports spécifiques.
Server.prototype .__ proto__ = http.server.prototype
Ce qui suit est l'ensemble du code source de "Connect.js". Afin d'économiser de l'espace, tous les commentaires ont été supprimés, comme le montre la figure ci-dessous:
Pour ajouter:
La copie de code est la suivante:
fs.readDiRSYNC (__ dirname + '/ middleware'). foreach (function (nom de fichier) {
if (//.js$/.test(FileName)) {
var name = filename.substr (0, filename.LastIndexof ('.'));
export.middleware .__ Definegetter __ (nom, fonction () {
retour requis ('./ middleware /' + name);
});
}
});
L'objet "middleware" exporte "puis boucle vers l'objet" middleware "est une méthode qui charge directement le module de fichier .js dans le dossier" middleware ".
Utilisation: "export.utils.merge (exportations, exports.middleware)" Pour exporter directement les méthodes de middleware.
Trois, résumons:
(1) La compréhension de l'intention de conception du code source aidera à maximiser les gains de l'application.
(2) Lorsque vous regardez le code source, comprenez le processus, puis déduisez les détails grammaticaux.
(3) Apprenez des idées de mise en œuvre intelligentes dans le code source, mais ne transitionnez pas la conception, la conception pour des raisons de conception.
(4) Continuez à analyser le middleware pertinent demain et continuez à être mis à jour. . . . . .