Installation und Betrieb der Nodejs-Tutorialumgebung_node.js

NodeJS laufen lassen

Der erste Schritt besteht natürlich darin, die NodeJS-Umgebung zu installieren. Jetzt ist es schneller, NodeJS unter Windows zu installieren:

http://www.nodejs.org/download/

Nachdem der Download abgeschlossen ist, fahren Sie einfach mit dem nächsten Schritt fort. Danach haben wir eine nodeJS-Umgebung

Im zweiten Schritt haben wir zur Erleichterung unserer nachfolgenden Vorgänge direkt einen Blog-Ordner auf dem Laufwerk D erstellt

Öffnen Sie dann das Windows-Befehlszeilentool, geben Sie das Laufwerk d ein und geben Sie Folgendes ein:

Code kopieren Der Code lautet wie folgt:

express -e blog

Dann sind möglicherweise abhängige Pakete enthalten, um sie zu installieren (die Installationskonfiguration wird von package.json bereitgestellt):

Code kopieren Der Code lautet wie folgt:

npm install

Auf diese Weise wurde unser Abhängigkeitspaket heruntergeladen. Das Abhängigkeitspaket, die Java-Paketdatei und die .net-BLL-Datei sollten dasselbe Konzept haben

Zu diesem Zeitpunkt ist unser Programm betriebsbereit:

Code kopieren Der Code lautet wie folgt:

Knoten-App

Code kopieren Der Code lautet wie folgt:

D:blog>node appExpress-Server überwacht Port 3000

Wenn Sie zu diesem Zeitpunkt den Browser öffnen, erfolgt eine Reaktion:

Hier verwenden wir Express (ein beliebtes NodeJS-Webentwicklungs-Framework) und die EJS-Template-Engine

Dateistruktur

Die Verzeichnisstruktur der Initialisierungsdatei ist wie folgt:

app.js ist die Eintragsdatei

package.json ist eine Modulabhängigkeitsdatei. Wenn wir npm install verwenden, lädt es basierend auf seiner Konfiguration verwandte Pakete aus dem Internet herunter

node_modules ist die heruntergeladene Moduldatei (package.json)

öffentliche speichert statische Ressourcendateien

routes speichert Routing-Dateien

Ansichten speichern zugehörige Ansichtsvorlagendateien

Auf diese Weise entsteht unsere grundlegende Verzeichnisstruktur. Lassen Sie uns kurz über das Verzeichnis node_modules sprechen

node_modules/ejs

Wie wir gerade gesagt haben, werden heruntergeladene Module hier gespeichert. Um es ganz klar auszudrücken: Es handelt sich um eine Sammlung von JS-Dateien

Code kopieren Der Code lautet wie folgt:

var parse = exports.parse = function(str, options){
  var Optionen = Optionen || {}
    , open = Optionen.open || exports.open || '<%'
    , close = options.close || exports.close || '%>'
    , Dateiname = Optionen.Dateiname
    , compileDebug = options.compileDebug !== false
    , buf = "";

  buf = 'var buf = [];';
  if (false !== options._with) buf = 'nwith (locals || {}) { (function(){ ';
  buf = 'n buf.push('';

  var lineno = 1;

  var verbrauchenEOL = false;
  for (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]) {
        case '=':
          prefix = "', escape((" line ', ';
          postfix = ")), '";
          ich;
          Pause;
        Fall '-':
          prefix = "', (" line ', ';
          postfix = "), '";
          ich;
          Pause;
        Standard:
          Präfix = "');" Zeile ';';
          postfix = "; buf.push('";
      }

      var end = str.indexOf(close, i)
        , js = str.substring(i, end)
        , start = i
        , include = null
        , n = 0;

      if ('-' == js[js.length-1]){
        js = js.substring(0, js.length - 2);
        verbrauchenEOL = true;
      }

      if (0 == js.trim().indexOf('include')) {
        var name = js.trim().slice(7).trim();
        if (!filename) throw new Error('filename option is needed for Includes');
        var path = discoverInclude(name, filename);
        include = read(path, 'utf8');
        include = exports.parse(include, { Dateiname: Pfad, _with: false, Öffnen: Öffnen, Schließen: Schließen, CompileDebug: CompileDebug });
        buf = "' (function(){" include "})() '";
        js = '';
      }

      while (~(n = js.indexOf("n", n))) n , lineno ;
      if (js.substr(0, 1) == ':') js = filtered(js);
      if (js) {
        if (js.lastIndexOf('//') > js.lastIndexOf('n')) js = 'n';
        buf = Präfix;
        buf = js;
        buf = postfix;
      }
      i = end - start close.length - 1;

} else if (stri == "\") {
buf = "\\";
} else if (stri == "'") {
buf = "\'";
} else if (stri == "r") {
// ignorieren
} else if (stri == "n") {
If (consumeEOL) {
         ConsumerEOL = false;
} sonst {
buf = "\n";
         lineno ;
}
} sonst {
       buf = stri;
}
}

if (false !== options._with) buf = "'); })();n} nreturn buf.join('');";
else buf = "');nreturn buf.join('');";
Rückgabe buf;
};

Zum Beispiel haben wir hier die EJS-Vorlage und das Express-Modul verwendet und sind dann neugierig in das EJS-Programm gegangen, um zu sehen, was der Unterschied ist

Nachdem wir ejs.js geöffnet haben, werfen wir einen Blick auf den Code: Wir kennen diesen Code. Er hat die gleiche Idee wie der Template-Engine-Code von Underscore, der die Vorlage in einen String analysiert

Konvertieren Sie es dann über die Methode eval oder new Function in eine Funktion und übergeben Sie Ihr eigenes Datenobjekt zur einfachen Analyse

Was den konkreten Arbeitsablauf betrifft, wissen wir noch nicht. Okay, gehen wir jetzt zu anderen Modulen über.

app.js

App.js spielt als Eingabedatei eine zentrale Rolle:

Code kopieren Der Code lautet wie folgt:

/**
 * Modulabhängigkeiten.
 */

var express = require('express');
var Routen = require('./routes');
var user = require('./routes/user');
var http = require('http');
var path = require('path');

var app = express();

// alle Umgebungen
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.set('view 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('/users', user.list);

http.createServer(app).listen(app.get('port'), function(){
console.log('Express-Server überwacht Port ' app.get('port'));
});

Wir laden Express- und http-Module über den Befehl require() und laden Vorlagendateien wie Indexbenutzer im Routenverzeichnis

app.set('port', process.env.PORT || 3000) dient zum Festlegen des Ports beim Start

app.set('views', __dirname '/views') dient zum Festlegen des Pfads zum Speichern der Vorlagendatei, wobei __dirname eine globale Variable ist, die das Verzeichnis speichert, in dem sich das aktuelle Skript befindet. Wir können es anzeigen so:

Code kopieren Der Code lautet wie folgt:

console.log(__dirname);//Füge den folgenden Code zu index.js hinzu
/**
D:blog>node app
Express-Server-Li
D:blogroutes
*/

Wie dieser __dirname erhalten wurde, müssen wir vorerst nicht beachten

app.set('view engine', 'ejs') setzt die Template-Engine auf ejs

app.use(express.favicon()) dient zum Festlegen des Symbols. Wenn Sie es ändern möchten, gehen Sie einfach zur Bilddatei unter öffentlich

app.use(express.logger('dev')); express ist auf connect angewiesen, daher gibt die integrierte Middleware einige Protokolle aus

app.use(express.json()); wird zum Parsen des Anforderungstexts verwendet, wobei die Zeichenfolge dynamisch in ein JSON-Objekt konvertiert wird

app.use(express.methodOverride()); connect verfügt über integrierte Middleware zur Verarbeitung von Post-Anfragen und kann http-Methoden wie put verschleiern

app.use(app.router); Call-Router-Parsing-Regeln

app.use(express.static(path.join(__dirname, 'public'))); integrierte Middleware verbinden, public im Stammverzeichnis festlegen, um statische Dateien zu speichern

Code kopieren Der Code lautet wie folgt:

if ('development' == app.get('env')) {
app.use(express.errorHandler());
}

Dieser Satz bedeutet, dass während der Entwicklung Fehlermeldungen ausgegeben werden sollen

Code kopieren Der Code lautet wie folgt:

app.get('/',routes.index);
app.get('/users', user.list);

Bei diesen beiden Sätzen handelt es sich um spezifische Verarbeitungsdateien zum Zeitpunkt des Zugriffs. Wenn Sie hier direkt zugreifen, lautet der Standardzugriff beispielsweise „routes.index“

Dann werden die Vorlagendaten tatsächlich intern analysiert:

Code kopieren Der Code lautet wie folgt:

exports.index = Funktion (req, res) {
console.log(__dirname);
res.render('index', { title: 'Express' });
};

Abschließend wird der obige Code aufgerufen, um einen http-Server zu erstellen und Port 3000 abzuhören. Nach Erfolg kann auf der Webseite darauf zugegriffen werden

Routenführung

Wir haben diese Methode früher verwendet, um das Routing zu erstellen

Code kopieren Der Code lautet wie folgt:

app.get('/', Routes.index) ;

Der obige Code kann durch diesen Code (in der App geschrieben) ersetzt werden

Code kopieren Der Code lautet wie folgt:

app.get('/', Funktion (req, res) {
res.render('index', { title: 'Express' });
});

Dieser Code bedeutet, dass beim Zugriff auf die Homepage die EJS-Vorlagen-Engine aufgerufen wird, um die Vorlagendatei index.ejs zu rendern

Nehmen wir nun einige Änderungen vor, um die Routing-Funktion zu implementieren, aber wir können den Routing-bezogenen Code nicht in die App einfügen. Wenn es zu viele Routen gibt, wird die App überfüllt, also fügen wir die entsprechende Konfiguration ein der Index

Deshalb löschen Sie die relevanten Routing-Funktionen in der App und fügen den Code am Ende der App hinzu:

Code kopieren Der Code lautet wie folgt:

Routen(App);

Ändern Sie dann index.js

Code kopieren Der Code lautet wie folgt:

module.exports = function(app) {
app.get('/', Funktion (req, res) {
res.render('index', { title: 'Express' });
});
};

Es ist noch nicht klar, wie dieser Code organisiert ist, daher werde ich ihm keine Beachtung schenken. Wir werden ihn uns später ansehen

Routing-Regeln

Express kapselt eine Vielzahl von HTTP-Anfragen. Wir verwenden im Allgemeinen get/post.

Code kopieren Der Code 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

Dann gibt es die folgenden Regeln für req (Anfrage)

req.query verarbeitet Get-Anfragen und ruft Get-Anfrage-Parameter ab

req.params verarbeitet Get- oder Post-Anfragen im Format /:xxx

req.body verarbeitet Post-Anfragen und erhält Post-Anfrage-Bodys

req.params verarbeitet Get- und Post-Anfragen, aber die Suchpriorität ist req.params->req.body->req.query

Pfadregeln unterstützen auch reguläre Ausdrücke, wir werden später auf die Details eingehen...

Routing-Regeln hinzufügen

Wenn wir einen nicht existierenden Link besuchen:

Da es keine Routing-Regel für /y gibt und keine öffentlichen Dateien erwähnt werden, ist es 404

Jetzt fügen wir relevante Routen in index.js hinzu:

Code kopieren Der Code lautet wie folgt:

module.exports = Funktion (App) {
app.get('/', Funktion (req, res) {
res.render('index', { title: 'Express' });
});
app.get('/y', Funktion (req, res) {
res.send('Ye Xiaochai');
});
};

Meine Seite ist hier verstümmelt:

Der Grund dafür ist, dass meine Datei nach dem Herunterladen in gbk codiert ist. Wir kümmern uns nicht um die Template-Engine.

Anmeldefunktion

Hier folgen wir dem ursprünglichen Blogger, um eine einfache Registrierungsfunktion zu erstellen. Hier verwenden wir Mongo DB als Datenbank und werden die Funktionen später nacheinander verbessern

Erstellen Sie eine neue Registerroute und eine neue Registervorlage dafür, also fangen wir an

① Erstellen Sie eine neue Route im Index

Code kopieren Der Code lautet wie folgt:

app.get('/register', function (req, res) {
res.render('index', { title: 'Registrierungsseite' });
});

Code kopieren Der Code lautet wie folgt:

module.exports = Funktion (App) {
app.get('/', Funktion (req, res) {
res.render('index', { title: 'Express' });
});

app.get('/y', function (req, res) {
res.send('Ye Xiaochai');
});

app.get('/register', function (req, res) {
res.render('register', { title: 'Registrierungsseite' });

});

Code kopieren Der Code lautet wie folgt:

<%= title %>

                       

Benutzername:

          

Passwort:

                                                                                                                               

Auf diese Weise entsteht unsere Seite:

Das Basisprogramm ist jetzt verfügbar, wir benötigen jetzt Datenbankunterstützung, also müssen wir die MongoDB-Umgebung installieren

MongoDB

MongoDB ist eine Art von NoSQL, die auf verteilter Dateispeicherung basiert. Sie ist in C geschrieben. Die von MongoDB unterstützte Datenstruktur ist locker, ähnlich wie bei JSON. Wir wissen, dass JSON jeden Typ unterstützen kann, sodass sehr komplexe Strukturen erstellt werden können

Code kopieren Der Code lautet wie folgt:

{
ID: 1,
Name: 'Ye Xiaochai',
Freunde: [
{ id: 2, name: 'Su Huan Zhen' },
{ id: 3, name: 'Einseitiges Buch' }
]
}

MongoDB installieren

Gehen Sie zuerst zu http://www.mongodb.org/downloads, um die Installationsdatei herunterzuladen, kopieren Sie dann die Datei auf das Laufwerk D, benennen Sie sie in „mongodb“ um und erstellen Sie dann darin einen neuen Blog-Ordner

Öffnen Sie dann das Befehlszeilentool und wechseln Sie zum Verzeichnis „bin“, geben Sie Folgendes ein:

Code kopieren Der Code lautet wie folgt:

mongod -dbpath d:mongodbblog

Legen Sie den Blog-Ordner als Projektverzeichnis fest und starten Sie die Datenbank. Der Einfachheit halber können wir in Zukunft einen Befehl schreiben und klicken, um die Datenbank zu starten:

Code kopieren Der Code lautet wie folgt:

d:mongodbbinmongod.exe -dbpath d:mongodbblog

MongoDB verknüpfen

Nachdem die Datenbank erfolgreich installiert wurde, benötigt unser Programm noch das entsprechende „Treiber“-Programm, um eine Verbindung zur Datenbank herzustellen. Natürlich müssen wir zu diesem Zeitpunkt das Paket herunterladen...

Öffnen Sie package.json und fügen Sie eine neue Zeile in Abhängigkeiten hinzu

Code kopieren Der Code 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 npm install aus, um das neue Abhängigkeitspaket herunterzuladen. Jetzt haben Sie den Treiber für mongoDB. Um eine Verbindung zu Datenbanken wie MySQL herzustellen, benötigen Sie andere Abhängigkeitspakete

Erstellen Sie zu diesem Zeitpunkt die Datei „setting.js“ im Stammverzeichnis und speichern Sie die Datenbankverbindungsinformationen

Code kopieren Der Code lautet wie folgt:

module.exports = {
cookieSecret: 'myblog',
db: 'Blog',
Host: '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

Als nächstes erstellen Sie einen neuen Modellordner im Stammverzeichnis und eine neue db.js unter dem Modellordner

Code kopieren Der Code lautet wie folgt:

var Settings = require('../settings'),
Db = require('mongodb').Db,
Connection = require('mongodb').Connection,
Server = require('mongodb').Server;
module.exports = new Db(settings.db, new Server(settings.host, Connection.DEFAULT_PORT), {safe: true});

Code kopieren Der Code lautet wie folgt:

new Db(settings.db, new Server(settings. host, Verbindung .DEFAULT_PORT), {safe: true });

Legen Sie den Datenbanknamen, die Datenbankadresse und den Datenbankport fest, um eine Datenbankinstanz zu erstellen, und exportieren Sie die Instanz über module.exports, damit die Datenbank über require gelesen und geschrieben werden kann

Um erfolgreich in die Datenbank zu schreiben, muss das serverseitige Programm die Beitragsinformationen verarbeiten, daher erstellen wir eine neue user.js im Modellordner

Code kopieren Der Code lautet wie folgt:

var mongodb = require('./db');
Funktion Benutzer(Benutzer) {

this.name = user.name;
this.password = user.password;
};

module.exports = Benutzer;

//Speicherbenutzerinformationen

User.prototype.save = Funktion (Rückruf) {
//Benutzerdokumente, die in der Datenbank gespeichert werden sollen
var user = {
Name: this.name,
Passwort: this.password
};
//Datenbank öffnen
mongodb.open(function (err, db) {
Wenn (irrt) {
Return callback(err); //Fehler, Fehlerinformationen zurückgeben
}
//Benutzersammlung lesen
db.collection('users', function (err, Collection) {
Wenn (irrt) {
          mongodb.close();
           return callback(err); //Fehler, Fehlerinformationen zurückgeben
}
//Benutzerdaten in Benutzersammlung einfügen
     collection.insert(Benutzer, {
        sicher: wahr
}, Funktion (err, Benutzer) {
          mongodb.close();
Wenn (irrt) {
              return callback(err); //Fehler, Fehlerinformationen zurückgeben
}
​​​​ callback(null, user[0]); //Erfolg! err ist null und gibt das gespeicherte Benutzerdokument zurück
});
});
});
};

Code kopieren Der Code lautet wie folgt:

//Benutzerinformationen lesen
User.get = function(name, callback) {
//Datenbank öffnen
mongodb.open(function (err, db) {
Wenn (irrt) {
Return callback(err);//Fehler, Fehlerinformationen zurückgeben
}
//Benutzersammlung lesen
db.collection('users', function (err, Collection) {
Wenn (irrt) {
          mongodb.close();
          return callback(err);//Fehler, Fehlerinformationen zurückgeben
}
//Suchen Sie ein Dokument, dessen Wert für den Benutzernamen (Namensschlüssel) name
ist      collection.findOne({
Name: Name
}, Funktion (err, Benutzer) {
          mongodb.close();
Wenn (irrt) {
             Rückruf (err);//Fehlgeschlagen! Fehlerinformationen zurückgeben
}
​​​ callback(null, user);//Erfolg! Geben Sie die abgefragten Benutzerinformationen zurück
});
});
});
};

Hier ist eines zum Schreiben von Daten und eines zum Lesen von Daten. Jetzt müssen wir das folgende Programm vor index.js hinzufügen

Code kopieren Der Code lautet wie folgt:

var User = require('../models/user .js' );

App.post('/register') ändern

Code kopieren Der Code lautet wie folgt:

app.post('/register', Funktion (req, res) {
var name = req.body.name;
var pwd = req.body.password;
var newUser = neuer Benutzer({
Name: Name,
Passwort: pwd
});
newUser.save(function (err, user) {
//Verwandte Vorgänge, in Sitzung schreiben
res.send(user);
});
});

Dann klicken Sie auf „Registrieren“ und Sie erhalten eine Antwort

Wenn Sie zu diesem Zeitpunkt nicht sicher sind, ob Sie in die Datenbank schreiben sollen, können Sie die abzufragende Datenbank eingeben und zunächst in das Datenbankverzeichnis wechseln

Code kopieren Der Code lautet wie folgt:

D:mongodbbin>

Geben Sie ein:

Code kopieren Der Code lautet wie folgt:

mongo

Dann stellen Sie die Datenbankverbindung auf Blog um

Code kopieren Der Code lautet wie folgt:

Blog verwenden

Letzte Eingabe

Code kopieren Der Code lautet wie folgt:

db.users.find()

Wir waren alle froh, die Daten geschrieben zu sehen, daher ist die heutige Studie vorerst zu Ende

Fazit

Heute haben wir einen Blog verfolgt, um den Vorgang von der Installation bis zum Schreiben in die Datenbank abzuschließen. Lassen Sie uns morgen weitere Aspekte hinzufügen und das Lernen von nodeJS schrittweise vertiefen