Laissez les nodejs courir
La première étape est bien sûr d'installer l'environnement NodeJS. Maintenant que Windows a une installation plus rapide de NodeJS, vous pouvez le télécharger directement:
http://www.nodejs.org/download/
Téléchargez-le au besoin. Une fois le téléchargement terminé, passez à l'étape suivante. Après cela, nous aurons l'environnement NodeJS.
La deuxième étape est que, afin de faciliter nos opérations ultérieures, nous avons directement vu un blog de dossier sur le disque D.
Ouvrez ensuite l'outil de ligne de commande Windows, entrez le disque D et entrez:
Copiez le code comme suit: Blog Express -e
Ensuite, il peut y avoir des packages de dépendance à l'intérieur, nous devons entrer dans le répertoire du blog pour installer (la configuration d'installation est fournie par package.json):
Copiez le code comme suit: Installer NPM
De cette façon, nous téléchargeons le package de dépendance, qui dépend du package et des fichiers de package Java et le fichier .net BLL devrait être un concept
Pour le moment, notre programme est prêt à fonctionner:
Copiez le code comme suit: Application Node
Copiez le code comme suit: d: / blog> Node AppExpress Server écoute sur le port 3000
Pour le moment, vous aurez une réponse lorsque vous ouvrez le navigateur:
Ici, nous utilisons Express (un framework de développement nodejsweb populaire) et utilisons le moteur de modèle EJS
Structure de fichiers
La structure du répertoire de fichiers d'initialisation est la suivante:
app.js est le fichier d'entrée
package.json est un fichier de dépendance du module. Lorsque nous utilisons NPM Installer, il téléchargera des packages connexes en ligne en fonction de sa configuration.
Node_modules est le fichier de module téléchargé (package.json)
Magasins publics Fichiers de ressources statiques
Les routes enregistrent les fichiers de routage
Vues Store Related View Modèle Fichiers
De cette façon, notre structure de répertoire de base sort. Parlons brièvement du répertoire Node_modules ici.
node_modules / ejs
Nous avons juste dit que le module téléchargé est stocké ici. Pour le dire franchement, c'est une collection de fichiers JS
La copie de code est la suivante:
var parse = exportS.Parse = function (str, options) {
Var Options = Options || {}
, open = options.open || export.open || '<%'
, close = options.close || export.close || '%>'
, fichier = options.FileName
, compiledebug = options.compiledebug! == false
, buf = "";
buf + = 'var buf = [];';
if (false! == options._with) buf + = '/ nwith (locaux || {}) {(function () {';
buf + = '/ n buf.push (/' ';
var lineno = 1;
var Consumerseol = false;
pour (var i = 0, len = str.length; i <len; ++ i) {
var stri = str [i];
if (str.slice (i, open.length + i) == open) {
i + = open.length
Var Prefix, PostFix, Line = (compiledebug? '__stack.lineno =': '') + lineno;
switch (str [i]) {
cas '=':
prefix = "', Escape ((" + line +', ';
postfix = ")), '";
++ i;
casser;
cas '-':
prefix = "', (" + line +', ';
postfix = "), '";
++ i;
casser;
défaut:
prefix = "');" + ligne + ';';
postfix = "; buf.push ('";
}
var end = str.indexof (clôture, i)
, js = str.substring (i, fin)
, start = i
, inclure = null
, n = 0;
if ('-' == JS [Js.Length-1]) {
JS = JS.SubString (0, Js.Length - 2);
ConsumentEol = true;
}
if (0 == js.trim (). indexof ('include')) {
var name = js.trim (). Slice (7) .trim ();
if (! FileName) lancer une nouvelle erreur («l'option de nom de fichier est requise pour inclure»);
var path = résoluinclude (nom, nom de fichier);
include = read (chemin, «utf8»);
include = exportS.Parse (include, {nom de fichier: chemin, _With: false, ouvrir: ouvert, fermer: close, compiledebug: compiledebug});
buf + = "'+ (function () {" + include + "}) () +'";
js = '';
}
while (~ (n = js.Indexof ("/ n", n))) n ++, lineno ++;
if (Js.substr (0, 1) == ':') js = filtor (js);
if (js) {
if (Js.LastIndexof ('//')> jslastIndexof ('/ n')) js + = '/ n';
buf + = préfixe;
buf + = js;
buf + = postfix;
}
i + = end - start + close.length - 1;
} else if (stri == "//") {
buf + = "////";
} else if (stri == "'") {
buf + = "// '";
} else if (stri == "/ r") {
// ignorer
} else if (stri == "/ n") {
if (Consumeeol) {
ConsumentEol = False;
} autre {
buf + = "// n";
lineno ++;
}
} autre {
buf + = stri;
}
}
if (false! == options._with) buf + = "');}) (); / n} / nreturn buf.join (' ');";
else buf + = "'); / nreturn buf.join (' ');";
retour Buf;
};
Tout comme le modèle EJS et le module Express que nous avons utilisé ici, nous sommes ensuite entrés dans le programme EJS curieusement pour voir quelle est la différence.
Après ouverture, EJS.JS, nous dessions du code pour lire: nous connaissons davantage ce code. Il est cohérent avec le code de moteur de modèle du soulignement, et les deux analysent le modèle dans une chaîne.
Convertissez-le ensuite en une fonction via l'évaluation ou la méthode de la nouvelle fonction, et passez-la dans votre propre objet de données pour l'analyse.
Quant au flux de travail spécifique, nous ne savons pas encore, nous ne pouvons donc le mettre au point ultérieur pour étudier. D'accord, allons à d'autres modules maintenant.
app.js
En tant que fichier d'entrée, App.js joue un rôle important:
La copie de code est la suivante:
/ **
* Dépendances du module.
* /
var express = require ('express');
var Routes = require ('./ routes');
var user = require ('./ routes / utilisateur');
var http = require ('http');
var path = require ('path');
var app = express ();
// tous les environnements
app.set ('port', process.env.port || 3000);
app.set ('vues', path.join (__ dirname, 'vues'));
app.set ('Voir le moteur', 'ejs');
app.use (express.favicon ());
app.use (express.logger ('dev'));
app.use (express.json ());
app.use (express.urlencoded ());
app.use (express.methodoverride ());
app.use (app.router);
app.use (express.static (path.join (__ dirname, 'public')));
// Développement uniquement
if ('Development' == app.get ('env')) {
app.use (express.errorHandler ());
}
app.get ('/', Routes.Index);
app.get ('/ utilisateurs', user.list);
http.createServer (app) .Listen (app.get ('port'), function () {
Console.log ('Express Server écoutant sur le port' + app.get ('port'));
});
Nous chargeons les modules Express et HTTP via la commande require (), et chargerons l'utilisateur d'index et d'autres fichiers de modèle dans le répertoire des routes
app.set ('port', process.env.port || 3000) est le port au démarrage
app.set ('vues', __dirname + '/ vues') est le chemin d'accès pour stocker le fichier de modèle. Où __dirname est une variable globale, stockant le répertoire où se trouve le script actuel. Nous pouvons le voir de cette manière:
La copie de code est la suivante:
console.log (__ dirname); // index.js ajouter le code suivant
/ **
D: / Blog> Application Node
Serveur express Li
D: / blog / itinéraires
* /
Quant à la façon dont ce __dirname a été obtenu, nous n'avons pas besoin de y prêter attention pour le moment
app.set ('Afficher le moteur', 'ejs') définit le moteur de modèle à EJS
App.use (express.favicon ()) doit définir l'icône pour le modifier, puis vous pouvez créer le fichier d'images ci-dessous public.
app.use (express.logger ('dev')); Express dépend de la connexion et le middleware intégré publiera certains journaux.
app.use (express.json ()); est utilisé pour analyser le corps de la demande, où la chaîne sera convertie dynamiquement en un objet JSON
app.use (express.methodoverride ()); Connectez le middleware intégré pour gérer les demandes de poste et peut masquer le put et d'autres méthodes HTTP
app.use (app.router); Appeler les règles de résolution du routeur
app.use (express.static (path.join (__ dirname, 'public'))); Connectez le middleware intégré, définissez le public dans le répertoire racine pour stocker des fichiers statiques
La copie de code est la suivante:
if ('Development' == app.get ('env')) {
app.use (express.errorHandler ());
}
Cette phrase signifie que les informations d'erreur doivent être sorties dans des conditions de développement
La copie de code est la suivante:
app.get ('/', Routes.Index);
app.get ('/ utilisateurs', user.list);
Ces deux phrases sont des fichiers de traitement spécifiques au moment de l'accès. Par exemple, lors de l'accès directement ici, l'accès par défaut est Routes.Index.
Ensuite, il analyse en fait les données du modèle à l'intérieur:
La copie de code est la suivante:
export.index = fonction (req, res) {
console.log (__ dirname);
res.render ('index', {title: 'express'});
};
Enfin, le code ci-dessus sera appelé pour créer un serveur HTTP et écouter le port 3000. Après le succès, vous pouvez y accéder sur la page Web.
routage
Nous avons utilisé cette méthode pour construire l'itinéraire
La copie de code est la suivante: app.get ('/', rotes.index);
Le code ci-dessus peut être remplacé par ce code (écrit dans l'application)
La copie de code est la suivante:
app.get ('/', fonction (req, res) {
res.render ('index', {title: 'express'});
});
Ce code signifie que lors de l'accès à la page d'accueil, le moteur de modèle EJS est appelé pour rendre le fichier de modèle index.ejs
Faites maintenant quelques modifications. Le code ci-dessus implémente la fonction de routage, mais nous ne pouvons pas mettre le code lié au routage dans l'application. S'il y a trop d'itinéraires, l'application deviendra gonflée, nous mettons donc la configuration pertinente dans l'index
Supprimez donc les fonctions de routage pertinentes dans l'application et ajoutez du code à la fin de l'application:
La copie de code est la suivante: itinéraires (app);
Puis modifiez index.js
La copie de code est la suivante:
module.exports = fonction (app) {
app.get ('/', fonction (req, res) {
res.render ('index', {title: 'express'});
});
};
La façon dont ce code est organisé n'est pas encore claire, donc je ne y prêterai plus attention. Jetons un coup d'œil plus tard
Règles de routage
Express résume plusieurs demandes HTTP, nous utilisons généralement Get / Post deux
La copie de code est la suivante:
app.get ();
app.post ();
Le premier paramètre est le chemin de demande, le deuxième paramètre est la fonction de rappel, ou les deux paramètres sont la demande et la réponse
Ensuite, pour req (demande), il y a les règles suivantes
req.Query Goodles Get Demande et obtient les paramètres de demande de get
REQ.PARAMS GRANDES /: XXX FORME GET OU POST DEMANDE
req.body gère la demande de poste et obtient le corps de la demande de poste
req.params gère les demandes d'obtention et de publication, mais la priorité de recherche est req.params-> req.body-> req.query
Les règles de chemin soutiennent également la régularité, nous parlerons des détails plus tard ...
Ajouter des règles de routage
Lorsque nous accédons à un lien qui n'existe pas:
Parce qu'il n'y a pas de règle de routage pour / y, il ne dit pas le dossier sous public, donc c'est 404
Maintenant, nous ajoutons la route pertinente dans index.js:
La copie de code est la suivante:
module.exports = fonction (app) {
app.get ('/', fonction (req, res) {
res.render ('index', {title: 'express'});
});
app.get ('/ y', fonction (req, res) {
res.send ('ye xiaochai');
});
};
Ici, j'ai brouillé la page:
La raison en est qu'après le téléchargement, mon fichier est le codage GBK. Nous avons juste besoin de le changer en UTF-8. Nous ne nous soucions pas du moteur de modèle. Allons à la section suivante.
Fonction d'enregistrement
Ici, nous suivons le blogueur d'origine pour faire une fonction d'enregistrement simple, utilisons Mongo DB comme base de données, puis nous améliorerons les fonctions à leur tour
Créez une nouvelle route de registre et créez un nouveau modèle de registre pour cela, alors commençons
① Créez un nouvel itinéraire dans l'index
La copie de code est la suivante:
app.get ('/ registre', fonction (req, res) {
res.render ('index', {Title: 'Register Page'});
});
La copie de code est la suivante:
module.exports = fonction (app) {
app.get ('/', fonction (req, res) {
res.render ('index', {title: 'express'});
});
app.get ('/ y', fonction (req, res) {
res.send ('ye xiaochai');
});
app.get ('/ registre', fonction (req, res) {
res.render ('registre', {title: 'registre page'});
});
La copie de code est la suivante:
<! Doctype html>
<html>
<adal>
<TiTLE> <% = Title%> </Title>
<link rel = 'stylesheet' href = '/ stylesheets / style.css' />
</ head>
<body>
<h1> <% = title%> </h1>
<formulaire méthode = "post">
<div> Nom d'utilisateur: <input type = "text" name = "name" /> </div>
<div> Mot de passe: <entrée type = "mot de passe" name = "mot de passe" /> </div>
<div> <input type = "soumi" value = "login" /> </div>
</ form>
</docy>
</html>
De cette façon, notre page est formée:
Avec le programme de base, nous avons maintenant besoin d'une prise en charge de la base de données, nous devons donc installer l'environnement MongoDB
Mongodb
MongoDB est un NOSQL basé sur le stockage de fichiers distribué. Il est écrit en C ++. La structure des données soutenue par MongoDB est lâche, similaire à JSON. Nous savons que JSON peut prendre en charge n'importe quel type, afin que nous puissions créer une structure très complexe.
La copie de code est la suivante:
{
ID: 1,
Nom: «Ye Xiaochai»,
Frinds: [
{id: 2, nom: 'su Huanzhen'},
{id: 3, nom: 'livre d'une page'}
]]
}
Installer MongoDB
Tout d'abord, accédez à http://www.mongodb.org/downloads pour télécharger le fichier d'installation, puis copier le fichier sur le disque D et le renommer MongoDB, puis créer un nouveau dossier de blog à l'intérieur
Ouvrez ensuite l'outil de ligne de commande pour basculer le répertoire en bac et entrez:
Copiez le code comme suit: Mongod -dbpath d: / mongodb / blog
Définissez le dossier du blog sur le répertoire du projet et démarrez la base de données. Par souci de commodité, nous rédigerons une commande et cliquerons directement pour démarrer la base de données:
Copiez le code comme suit: d: /mongodb/bin/mongod.exe -dbpath d: / mongodb / blog
Lien vers MongoDB
Une fois la base de données installée avec succès, notre programme a également besoin du programme "Driver" pertinent pour lier la base de données. Bien sûr, le package doit être téléchargé ...
Open Package.json pour ajouter une nouvelle ligne dans les dépendances
La copie de code est la suivante:
{
"nom": "nom d'application",
"Version": "0.0.1",
"Private": vrai,
"scripts": {
"start": "node app.js"
},
"dépendances": {
"Express": "3.4.8",
"ejs": "*",
"MongoDB": "*"
}
}
Ensuite, exécutez NPM Installer pour télécharger le nouveau package de dépendance. De cette façon, les conducteurs liés à MongoDB sont disponibles. Pour lier MySQL et d'autres bases de données, d'autres packages de dépendances sont nécessaires.
À l'heure
La copie de code est la suivante:
module.exports = {
cookiesecret: 'myblog',
DB: «blog»,
Hôte: «localhost»
};
DB est le nom de la base de données, l'hôte est l'adresse de la base de données, cookiesecret est utilisé pour le chiffrement des cookies et n'a rien à voir avec la base de données
Ensuite, créez un nouveau dossier de modèle dans le répertoire racine et créez un nouveau db.js dans le dossier des modèles
La copie de code est la suivante:
var paramètres = requis ('../ Paramètres'),
Db = require ('mongodb'). Db,
Connexion = require ('mongodb'). Connexion,
Server = require ('MongoDB'). Server;
module.exports = new DB (settings.db, nouveau serveur (settings.host, connection.default_port), {Safe: true});
La copie de code est la suivante: new DB (settings.db, nouveau serveur (settings.host, connexion.default_port), {Safe: true});
Définissez le nom de la base de données, l'adresse de la base de données et le port de base de données pour créer une instance de base de données et exporter l'instance via module.exports, afin que la base de données puisse être lue et écrite par exigence
Nous devons écrire avec succès dans la base de données, et le programme côté serveur doit traiter les informations de publication, nous créons donc un nouvel utilisateur.js dans le dossier des modèles
La copie de code est la suivante:
var mongodb = require ('./ db');
fonction utilisateur (utilisateur) {
this.name = user.name;
this.password = user.password;
};
module.exports = utilisateur;
// Stockage des informations utilisateur
User.prototype.save = fonction (rappel) {
// Document utilisateur à stocker dans la base de données
var user = {
Nom: this.name,
Mot de passe: this.password
};
// Ouvrez la base de données
mongodb.open (fonction (err, db) {
if (err) {
return rappel (err); // Erreur, renvoyez des informations d'erreur
}
// Lire la collection d'utilisateurs
db.collection ('utilisateurs', fonction (err, collection) {
if (err) {
MongoDB.Close ();
return rappel (err); // Erreur, renvoyez des informations d'erreur
}
// insérer les données des utilisateurs dans la collecte des utilisateurs
collection.insert (utilisateur, {
sûr: vrai
}, fonction (err, utilisateur) {
MongoDB.Close ();
if (err) {
return rappel (err); // Erreur, renvoyez des informations d'erreur
}
rappel (null, utilisateur [0]); //Succès! err est nul et renvoie le document utilisateur stocké
});
});
});
};
La copie de code est la suivante:
// Lire les informations de l'utilisateur
User.get = fonction (nom, rappel) {
// Ouvrez la base de données
mongodb.open (fonction (err, db) {
if (err) {
return rappel (err); // error, renvoie des informations d'erreur
}
// Lire la collection d'utilisateurs
db.collection ('utilisateurs', fonction (err, collection) {
if (err) {
MongoDB.Close ();
return rappel (err); // error, renvoie des informations d'erreur
}
// Trouver un document avec un nom d'utilisateur (clé de nom) Nom de la valeur
collection.findone ({
nom: nom
}, fonction (err, utilisateur) {
MongoDB.Close ();
if (err) {
return rappel (err); // a échoué! Retour aux informations ERR
}
rappel (null, utilisateur); // succès! Renvoie les informations de l'utilisateur de la requête
});
});
});
};
Ici, l'un écrit des données et l'autre lit les données. Il y a un processeur. Vous devez maintenant ajouter le programme suivant devant index.js.
La copie de code est la suivante: var user = require ('../ modèles / user.js');
Modifier l'application.post ('/ registre')
La copie de code est la suivante:
app.post ('/ registre', fonction (req, res) {
var name = req.body.name;
var pwd = req.body.password;
var newuser = nouvel utilisateur ({
Nom: Nom,
Mot de passe: Pwd
});
newuser.save (fonction (err, utilisateur) {
// Opérations connexes, session d'écriture
res.send (utilisateur);
});
});
Puis cliquez pour vous inscrire et vous aurez une réaction
Si vous ne pouvez pas déterminer s'il faut écrire dans la base de données pour le moment, vous pouvez saisir la base de données pour la requête et passer d'abord au répertoire de la base de données
Copiez le code comme suit: d: / mongodb / bin>
entrer:
Copiez le code comme suit: Mongo
Puis commutez sa base de données pour se connecter au blog
Copiez le code comme suit: Utilisez le blog
Dernière entrée
Copiez le code comme suit: db.users.find ()
Nous avons tous avec plaisir les données rédigées, donc l'apprentissage d'aujourd'hui a pris fin pour le moment
Conclusion
Aujourd'hui, nous avons suivi un blog pour terminer l'opération de l'installation à l'écriture à la base de données. Ajoutons d'autres aspects demain et approfondissons progressivement l'apprentissage des nodejs.