Lassen Sie Nodejs laufen
Der erste Schritt besteht natürlich darin, die NodeJS -Umgebung zu installieren. Nachdem Windows eine schnellere Installation von NodeJs hat, können Sie es direkt herunterladen:
http://www.nodejs.org/download/
Laden Sie es nach Bedarf herunter. Nach Abschluss des Downloads gehen Sie einfach zum nächsten Schritt. Danach werden wir die NodeJS -Umgebung haben.
Der zweite Schritt besteht darin, unsere nachfolgenden Operationen zu erleichtern, wir haben direkt einen Ordner -Blog auf der Festplatte D. gesehen.
Öffnen Sie dann das Windows -Befehlszeilen -Tool, geben Sie D Disk ein und geben Sie ein:
Kopieren Sie den Code wie folgt: Express -e -Blog
Anschließend gibt es möglicherweise Abhängigkeitspakete im Inneren. Wir müssen das Blog -Verzeichnis für die Installation eingeben (die Installationskonfiguration wird von package.json bereitgestellt):
Kopieren Sie den Code wie folgt: NPM Installation
Auf diese Weise laden wir das Abhängigkeitspaket herunter, das vom Paket- und Java -Paketdateien abhängt, und die .NET BLL -Datei sollte ein Konzept sein
Zu diesem Zeitpunkt ist unser Programm bereit zu laufen:
Kopieren Sie den Code wie folgt: Knoten -App
Kopieren Sie den Code wie folgt: D:/blog> Knoten Appexpress Server auf Port 3000 Hören
Zu diesem Zeitpunkt haben Sie eine Antwort, wenn Sie den Browser öffnen:
Hier verwenden wir Express (ein beliebtes Nodejsweb -Entwicklungsrahmen) und verwenden die EJS -Template -Engine
Dateistruktur
Die Initialisierungsdatei -Verzeichnisstruktur lautet wie folgt:
App.js ist die Eintragsdatei
Package.json ist eine Modulabhängigkeitsdatei. Wenn wir die NPM -Installation verwenden, werden verwandte Pakete entsprechend der Konfiguration online heruntergeladen.
node_modules ist die heruntergeladene Moduldatei (package.json)
öffentliche Geschäfte statische Ressourcendateien
Routen speichern Routing -Dateien
Ansichten speichern verwandte Ansichtsvorlagendateien
Auf diese Weise erscheint unsere grundlegende Verzeichnisstruktur. Lassen Sie uns hier kurz über das Verzeichnis node_modules sprechen.
node_modules/ejs
Wir haben gerade gesagt, dass das heruntergeladene Modul hier gespeichert ist. Um es unverblümt auszudrücken, handelt es sich um eine Sammlung von JS -Dateien
Die Codekopie lautet wie folgt:
var parse = exports.parse = function (str, option) {
var options = Optionen || {}
, open = options.open || exports.open || "<%"
, close = options.close || exports.close || "%>"
, Dateiname = options.filename
, compiledebug = options.comPileDebug! == Falsch
, buf = "";
buf += 'var buf = [];';
if (false!
buf += '/n buf.push (/' ';
var lineno = 1;
var Consumpteol = false;
für (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]) {
Fall '=':
Präfix = "', Escape ((" + line +', ';
postfix = ")), '";
++ i;
brechen;
Fall '-':
Präfix = "', (" + line +', ';
postfix = "), '";
++ i;
brechen;
Standard:
Präfix = "');" + Linie + ';';
postfix = "; buf.push ('";
}
var end = Str.Indexof (nah, i)
, JS = Str.Substring (i, Ende)
, starten = ich
, einschließen = null
, n = 0;
if ('-' == js [jsgth-1]) {
JS = JSUBstring (0, Js.Length - 2);
Verbraucher = wahr;
}
if (0 == js.trim (). indexof ('include')) {
var name = js.trim (). Slice (7) .Trim ();
if (! Dateiname) Werfen Sie einen neuen Fehler ('Dateiname -Option für include');
var path = ResolVeInclude (Name, Dateiname);
include = read (Pfad, 'utf8');
include = exports.parse (include, {Dateiname: Pfad, _with: false, offen: offen, schließen: compiledebug: compiledebug});
buf + = "' + (function () {" + include + "}) () +'";
JS = '';
}
while (~ (n = js.indexof ("/n", n))) n ++, lineno ++;
if (Js.Substr (0, 1) == ':') JS = gefiltert (JS);
if (js) {
if (js.lastIndexof ('//')> js.lastindexof ('/n')) js += '/n';
buf += Präfix;
buf += js;
buf += postfix;
}
i + = Ende - Start + Close.Length - 1;
} else if (stri == "//") {
buf += "////";
} else if (stri == "'") {
buf += "// '";
} else if (stri == "/r") {
// ignorieren
} else if (stri == "/n") {
if (Consumeeol) {
Verbraucher = falsch;
} anders {
buf += "// n";
Leineno ++;
}
} anders {
Buf += STRI;
}
}
if (false!
sonst buf += "');/nreturn buf.join (' ');";
BUF zurückgeben;
};
Genau wie die hier verwendete EJS -Vorlage und das Express -Modul gingen wir dann neugierig in das EJS -Programm, um zu sehen, was der Unterschied ist.
Nach dem Öffnen, ejs.js, zeichnen wir einen Code zum Lesen: Wir kennen diesen Code besser. Es steht im Einklang mit dem Vorlagenmotorencode des Unterstrichs und beide analysieren die Vorlage in eine Zeichenfolge.
Konvertieren Sie sie dann in eine Funktion über die EV -Funktion oder neue Funktionsmethode und geben Sie sie zum Parsen in Ihr eigenes Datenobjekt ein.
Was den spezifischen Workflow betrifft, wissen wir noch nicht, sodass wir ihn nur in den späteren Punkt einsetzen können. Okay, gehen wir jetzt zu anderen Modulen.
app.js
Als Eintragsdatei spielt App.js eine wichtige Rolle:
Die Codekopie lautet wie folgt:
/**
* Modulabhängigkeiten.
*/
var express = require ('express');
var routes = fordert ('./ Routen');
var user = required ('./ Routes/user');
var http = required ('http');
var path = require ('path');
var app = express ();
// alle Umgebungen
app.set ('port', process.env.port || 3000);
app.set ('Ansichten', Path.Join (__ DirName, 'Ansichten');
app.set ('Ansicht Engine', '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')));
// nur Entwicklung
if ('Development' == app.get ('env')) {
app.use (express.ErrorHandler ());
}
app.get ('/', Routes.Index);
app.get ('/user', user.list);
http.createServer (App) .Listen (app.get ('port'), function () {
console.log ('Express Server -Anhören auf Port' + app.get ('port'));
});
Wir laden die Express- und Http
app.set ('port', process.env.port || 3000) ist der Port beim Start
app.set ('Ansichten', __dirname + '/Ansichten') ist der Pfad zum Speichern der Vorlagendatei. Wo __Dirname eine globale Variable ist, die das Verzeichnis speichert, in dem sich das aktuelle Skript befindet. Wir können es auf diese Weise anzeigen:
Die Codekopie lautet wie folgt:
console.log (__ DirName); // index.js den folgenden Code hinzufügen
/**
D:/Blog> Knoten -App
Express Server li
D:/Blog/Routen
*/
Wie dieser __DIRName erhalten wurde, müssen wir vorerst nicht darauf achten
App.set ('Ansicht Engine', 'EJS') Legt die Vorlagenmotor auf EJS fest
App.use (Express.Favicon ()) soll das Symbol so festlegen, dass es die folgende Bilderdatei öffentlich erstellen kann.
app.use (express.logger ('dev')); Express hängt von Connect ab, und die integrierte Middleware gibt einige Protokolle aus.
app.use (express.json ()); wird verwendet, um den Anforderungskörper zu analysieren, wobei die Zeichenfolge dynamisch in ein JSON -Objekt umgewandelt wird
app.use (Express.Methodoverride ()); Schließen Sie integrierte Middleware an, um Postanfragen zu bearbeiten, und kann Put und andere HTTP-Methoden verkleiden
app.use (App.router); Rufen Sie die Regeln für die Auflösung von Router an
app.use (express.static (Path.Join (__ DirName, 'public'))); Schließen Sie integrierte Middleware an, die im Root-Verzeichnis öffentlich festgelegt werden, um statische Dateien zu speichern
Die Codekopie lautet wie folgt:
if ('Development' == app.get ('env')) {
app.use (express.ErrorHandler ());
}
Dieser Satz bedeutet, dass Fehlerinformationen unter Entwicklungsbedingungen ausgegeben werden sollten
Die Codekopie lautet wie folgt:
app.get ('/', Routes.Index);
app.get ('/user', user.list);
Diese beiden Sätze sind zum Zugriffszeit spezifische Verarbeitungsdateien. Wenn Sie beispielsweise hier direkt zugreifen, ist der Standardzugriff Routen.Index.
Dann analysiert es tatsächlich die Vorlagendaten innerhalb:
Die Codekopie lautet wie folgt:
exports.index = function (req, res) {
console.log (__ DirName);
res.render ('index', {title: 'express'});
};
Schließlich wird der obige Code aufgerufen, um einen HTTP -Server zu erstellen und Port 3000 anzuhören. Nach dem Erfolg können Sie auf der Webseite darauf zugreifen.
Routing
Wir haben diese Methode verwendet, um die Route zu erstellen
Die Codekopie lautet wie folgt: app.get ('/', Routes.Index);
Der obige Code kann durch diesen Code ersetzt werden (geschrieben in der App)
Die Codekopie lautet wie folgt:
app.get ('/', Funktion (req, res) {
res.render ('index', {title: 'express'});
});
Dieser Code bedeutet, dass beim Zugriff auf die Startseite die EJS -Vorlagen -Engine aufgerufen wird, um die Index.ejs -Vorlagendatei zu rendern
Nehmen Sie jetzt einige Änderungen vor. Der obige Code implementiert die Routing-Funktion, aber wir können den Routing-Code nicht in die App einfügen. Wenn es zu viele Routen gibt, wird die App aufgebläht, sodass wir die entsprechende Konfiguration in den Index einfügen
Löschen Sie daher die relevanten Routing -Funktionen in der App und fügen Sie den Code zum Ende der App hinzu:
Die Codekopie lautet wie folgt: Routen (App);
Dann modifizieren Sie index.js
Die Codekopie lautet wie folgt:
module.exports = function (App) {
app.get ('/', Funktion (req, res) {
res.render ('index', {title: 'express'});
});
};
Wie dieser Code organisiert ist, ist noch nicht klar, daher werde ich nicht mehr darauf achten. Schauen wir es uns später an
Routing -Regeln
Express umfasst mehrere HTTP -Anforderungen, wir verwenden im Allgemeinen GET/post zwei
Die Codekopie lautet wie folgt:
app.get ();
app.post ();
Der erste Parameter ist der Anforderungspfad, der zweite Parameter ist die Rückruffunktion oder die beiden Parameter sind Anforderung und Antwort
Für REQ (Anfrage) gibt es dann die folgenden Regeln
Req.Query behandelt die Get -Anfrage und erhalten Sie die Get -Request -Parameter
Req.Params Handles /: XXX -Formular erhalten oder nach Anfrage
Req.body kümmert sich um Postanfrage und erhält die Postanfrage
Req.params Handles Get und Post-Anfragen
Path -Regeln unterstützen auch die Regelmäßigkeit, wir werden später über die Details sprechen ...
Routing -Regeln hinzufügen
Wenn wir auf einen Link zugreifen, der nicht existiert:
Da es keine Routing -Regel für /y gibt, sagt er die Akte unter der Öffentlichkeit nicht, also ist es 404
Jetzt fügen wir die entsprechende Route in index.js hinzu:
Die Codekopie lautet wie folgt:
module.exports = function (App) {
app.get ('/', Funktion (req, res) {
res.render ('index', {title: 'express'});
});
app.get ('/y', Funktion (req, res) {
res.send ('ye xiaochai');
});
};
Hier habe ich die verstümmelte Seite:
Der Grund dafür ist, dass meine Datei nach dem Herunterladen GBK -Codierung ist. Wir müssen es nur in UTF-8 ändern. Die Template Engine interessieren uns nicht. Gehen wir zum nächsten Abschnitt.
Registrierungsfunktion
Hier folgen wir dem ursprünglichen Blogger, um eine einfache Registrierungsfunktion auszuführen, die Mongo DB als Datenbank zu verwenden, und dann werden wir die Funktionen wiederum verbessern
Erstellen Sie eine neue Registerroute und erstellen Sie eine neue Registervorlage dafür. Beginnen wir also beginnen wir
① Erstellen Sie eine neue Route im Index
Die Codekopie lautet wie folgt:
app.get ('/register', function (req, res) {
res.render ('index', {title: 'register page'});
});
Die Codekopie lautet wie folgt:
module.exports = function (App) {
app.get ('/', Funktion (req, res) {
res.render ('index', {title: 'express'});
});
app.get ('/y', Funktion (req, res) {
res.send ('ye xiaochai');
});
app.get ('/register', function (req, res) {
res.render ('Register', {title: 'register page'});
});
Die Codekopie lautet wie folgt:
<! DocType html>
<html>
<kopf>
<title> < %= title %> </title>
<link rel = 'stylesheet' href = '/stylesheets/style.css'/>
</head>
<body>
<H1> < %= title %> </h1>
<form method = "post">
<Div> Benutzername: <Eingabe type = "text" name = "name"/> </div>
<Div> Passwort: <Eingabe type = "Passwort" name = "Passwort"/> </div>
<Div> <Eingabe type = "surug" value = "login"/> </div>
</form>
</body>
</html>
Auf diese Weise wird unsere Seite gebildet:
Mit dem grundlegenden Programm benötigen wir jetzt Datenbankunterstützung, daher müssen wir die MongoDB -Umgebung installieren
MongoDb
MongoDB ist ein NoSQL, der auf verteiltem Dateispeicher basiert. Es ist in C ++ geschrieben. Die von MongoDB unterstützte Datenstruktur ist locker, ähnlich wie JSON. Wir wissen, dass JSON jeden Typ unterstützen kann, damit wir eine sehr komplexe Struktur erstellen können.
Die Codekopie lautet wie folgt:
{
ID: 1,
Name: 'ye xiaochai',
Frinds: [
{ID: 2, Name: 'Su Huanzhen'},
{ID: 3, Name: 'einseitiges Buch'}
]
}
MongoDB installieren
Gehen Sie zuerst zu http://www.mongodb.org/downloads, um die Installationsdatei herunterzuladen. Kopieren Sie die Datei in D -Datei und benennen Sie sie MongoDB um und erstellen Sie dann einen neuen Blog -Ordner innerhalb
Öffnen Sie dann das Befehlszeilenwerkzeug, um das Verzeichnis auf Bin zu wechseln und eingeben:
Kopieren Sie den Code wie folgt: Mongod -dbPath d:/mongoDB/Blog
Legen Sie den Blogordner auf das Projektverzeichnis ein und starten Sie die Datenbank. Aus Gründen der Bequemlichkeit schreiben wir einen Befehl und klicken direkt, um die Datenbank zu starten:
Kopieren Sie den Code wie folgt: d: /mongodb/bin/mongod.exe -dbpath d:/mongodb/blog
Link zu MongoDB
Nachdem die Datenbank erfolgreich installiert wurde, benötigt unser Programm auch das relevante "Treiber" -Programm, um die Datenbank zu verknüpfen. Natürlich muss das Paket heruntergeladen werden ...
Öffnen Sie Paket.json, um eine neue Zeile in Abhängigkeiten hinzuzufügen
Die Codekopie lautet wie folgt:
{
"Name": "Anwendungsname",
"Version": "0.0.1",
"privat": wahr,
"Skripte": {{
"Start": "Node App.js"
},
"Abhängigkeiten": {{
"Express": "3.4.8",
"EJS": "*",
"MongoDB": "*"
}
}
Führen Sie dann die NPM -Installation aus, um das neue Abhängigkeitspaket herunterzuladen. Auf diese Weise sind Fahrer, die mit MongoDB zusammenhängen, verfügbar. Um MySQL und andere Datenbanken zu verknüpfen, sind andere Abhängigkeitspakete erforderlich.
Erstellen Sie zu diesem Zeitpunkt die Datei "Einstellung.JS" im Stammverzeichnis, um die Datenbankverbindungsinformationen zu speichern
Die Codekopie lautet wie folgt:
module.exports = {
Cookiesecret: 'Myblog',
DB: 'Blog',
Gastgeber: 'Localhost'
};
DB ist der Datenbankname, Host ist die Datenbankadresse, Cookiesecret wird für die Cookie -Verschlüsselung verwendet und hat nichts mit der Datenbank zu tun
Erstellen Sie als Nächstes einen neuen Modellordner im Stammverzeichnis und erstellen
Die Codekopie lautet wie folgt:
var Settings = Request ('../ Einstellungen'),
Db = erfordern ('mongoDb'). Db,
Connection = fordert ('mongoDB'). Verbindung,
Server = Request ('mongoDB'). Server;
module.exports = new db (setting.db, neuer server (setting.host, connection.default_port), {sicher: true});
Die Codekopie lautet wie folgt: neuer dB (setting.db, neuer Server (Setting.host, Connection.Default_port), {sicher: true});
Legen Sie den Datenbanknamen, die Datenbankadresse und den Datenbankport fest, um eine Datenbankinstanz zu erstellen und die Instanz über modul.exports zu exportieren, damit die Datenbank gelesen und verfasst werden kann
Wir müssen erfolgreich in die Datenbank schreiben, und das serverseitige Programm muss die Postinformationen verarbeiten
Die Codekopie lautet wie folgt:
var mongoDB = required ('./ db');
Funktion Benutzer (Benutzer) {
this.name = user.name;
this.Password = user.Password;
};
module.exports = user;
// Benutzerinformationen speichern
User.prototype.save = function (radback) {
// Benutzerdokument, die in der Datenbank gespeichert werden soll
var user = {
Name: this.name,
Passwort: this.Password
};
// Öffnen Sie die Datenbank
mongodb.open (Funktion (err, db) {
if (err) {
Rückruf zurückgeben (arr); // Fehler, ERR -Informationen zurückgeben
}
// Lesen Sie die Benutzersammlung
DB.Collection ('Benutzer', Funktion (Err, Sammlung) {
if (err) {
mongoDB.close ();
Rückruf zurückgeben (arr); // Fehler, ERR -Informationen zurückgeben
}
// Benutzerdaten in die Benutzersammlung einfügen
Collection.insert (Benutzer, {
sicher: wahr
}, function (err, user) {
mongoDB.close ();
if (err) {
Rückruf zurückgeben (arr); // Fehler, ERR -Informationen zurückgeben
}
Callback (NULL, Benutzer [0]); //Erfolg! ERR IST NULL und gibt das gespeicherte Benutzerdokument zurück
});
});
});
};
Die Codekopie lautet wie folgt:
// Benutzerinformationen lesen
User.get = function (Name, Rückruf) {
// Öffnen Sie die Datenbank
mongodb.open (Funktion (err, db) {
if (err) {
Rückruf zurück Rückruf (err); // Fehler, ERR -Informationen zurückgeben
}
// Lesen Sie die Benutzersammlung
DB.Collection ('Benutzer', Funktion (Err, Sammlung) {
if (err) {
mongoDB.close ();
Rückruf zurück Rückruf (err); // Fehler, ERR -Informationen zurückgeben
}
// Suchen Sie ein Dokument mit einem Benutzernamen (Namensschlüssel) Wertname
Collection.Findone ({{
Name: Name
}, function (err, user) {
mongoDB.close ();
if (err) {
Rückruf zurückgeben (Err); // fehlgeschlagen! Kehren Sie zu Erressinformationen zurück
}
Rückruf (Null, Benutzer); // Erfolg! Geben Sie die Informationen zur Abfrage -Benutzerinformationen zurück
});
});
});
};
Hier schreibt einer Daten und der andere liest Daten. Es gibt einen Prozessor. Jetzt müssen Sie das folgende Programm vor Index.js hinzufügen.
Die Codekopie lautet wie folgt: var user = fordert ('../ models/user.js');
Ändern Sie die App.post ('/Register').
Die Codekopie lautet wie folgt:
app.post ('/register', function (req, res) {
var name = req.body.name;
var pwd = req.body.Password;
var Newuser = neuer Benutzer ({{{
Name: Name,
Passwort: PWD
});
Newuser.save (Funktion (Err, Benutzer) {
// Verwandte Operationen, Schreibsitzung
Res.Send (Benutzer);
});
});
Klicken Sie dann, um sich zu registrieren, und Sie haben eine Reaktion
Wenn Sie zu diesem Zeitpunkt nicht feststellen können, ob Sie in die Datenbank schreiben möchten, können Sie die Datenbank zum Abfragen eingeben und zunächst zum Datenbankverzeichnis wechseln
Kopieren Sie den Code wie folgt: d:/mongoDB/bin>
eingeben:
Kopieren Sie den Code wie folgt: Mongo
Wechseln Sie dann die Datenbank, um eine Verbindung zum Blog herzustellen
Kopieren Sie den Code wie folgt: Verwenden Sie das Blog
Letzte Eingabe
Kopieren Sie den Code wie folgt: db.users.find ()
Wir alle haben glücklich gesehen, dass die Daten geschrieben wurden, sodass das heutige Lernen vorerst zu Ende gegangen ist
Abschluss
Heute haben wir einem Blog gefolgt, um den Vorgang von der Installation bis zum Schreiben in die Datenbank abzuschließen. Lassen Sie uns morgen andere Aspekte hinzufügen und das Erlernen von NodeJS nach und nach vertiefen.