Deje que NodeJs se ejecute
El primer paso es, por supuesto, instalar el entorno NodeJS. Ahora que Windows tiene una instalación más rápida de NodeJS, puede descargarlo directamente:
http://www.nodejs.org/download/
Descargarlo según sea necesario. Después de completar la descarga, simplemente vaya al siguiente paso. Después de eso, tendremos el entorno NodeJS.
El segundo paso es que, para facilitar nuestras operaciones posteriores, vimos directamente un blog de carpetas en el disco D.
Luego abra la herramienta de línea de comando de Windows, ingrese el disco D e ingrese:
Copie el código de la siguiente manera: Express -e Blog
Entonces puede haber paquetes de dependencia en el interior, debemos ingresar el directorio de blog para instalar (la configuración de instalación es proporcionada por paquete.json):
Copie el código de la siguiente manera: NPM Install
De esta manera, descargamos el paquete de dependencia, que depende del paquete y los archivos del paquete Java y el archivo .NET BLL debería ser un concepto
En este momento, nuestro programa está listo para ejecutar:
Copie el código de la siguiente manera: aplicación de nodo
Copie el código de la siguiente manera: D:/Blog> Nodo AppExpress Server Listen en el puerto 3000
En este momento, tendrá una respuesta cuando abra el navegador:
Aquí estamos utilizando Express (un marco de desarrollo NodeJWeb popular) y usamos el motor de plantilla EJS
Estructura de archivo
La estructura del directorio de archivos de inicialización es la siguiente:
App.js es el archivo de entrada
paquete.json es un archivo de dependencia del módulo. Cuando usamos la instalación de NPM, descargará paquetes relacionados en línea de acuerdo con su configuración.
node_modules es el archivo del módulo descargado (paquete.json)
Tiendas públicas Archivos de recursos estáticos
Rutas Guardar archivos de enrutamiento
Vistas de la tienda Vista de plantilla de vista relacionada con la tienda Archivos
De esta manera, sale nuestra estructura de directorio básico. Hablemos brevemente sobre el directorio Node_Modules aquí.
node_modules/EJS
Acabamos de decir que el módulo descargado se almacena aquí. Para decirlo sin rodeos, es una colección de archivos JS
La copia del código es la siguiente:
var parse = exports.parse = function (str, opciones) {
Opciones var = opciones || {}
, Open = Options.open || Exports.open || '<%'
, cierre = options.close || Exports.Close || '%>'
, nombre de archivo = options.FileName
, compileBug = options.compiledebug! == falso
, buf = "";
buf += 'var buf = [];';
if (false! == options._with) buf += '/nwith (locales || {}) {(function () {';
buf += '/n buf.push (/' ';
VAR Lineno = 1;
VAR consuteeol = false;
para (var i = 0, len = str.length; i <len; ++ i) {
var stri = str [i];
if (str.slice (i, open.length + i) == open) {
i += abre.length
VAR Prefix, PostFix, Line = (ComiDEBug? '__stack.lineno =': '') + Lineno;
Switch (str [i]) {
caso '=':
prefix = "', escapar ((" + línea +', ';
postfix = ")), '";
++ i;
romper;
caso '-':
prefix = "', (" + línea +', ';
postfix = "), '";
++ i;
romper;
por defecto:
prefijo = "');" + línea + ';';
postfix = "; buf.push ('";
}
var end = str.indexof (Close, i)
, js = str.substring (i, final)
, inicio = i
, incluir = nulo
, n = 0;
if ('-' == js [js.length-1]) {
js = js.substring (0, js.length - 2);
consumeol = true;
}
if (0 == js.trim (). indexOf ('include')) {
var name = js.trim (). slice (7) .trim ();
if (! filename) tire nuevo error ('se requiere la opción de nombre de archivo para incluir');
var ruta = resolveInClude (nombre, nombre de archivo);
incluir = Read (ruta, 'UTF8');
include = exports.parse (include, {nombre de archivo: ruta, _with: falso, abierta: abrir, cerrar: cerrar, compiladoBug: compileBug});
buf + = "' + (function () {" + include + "}) () +'";
js = '';
}
while (~ (n = js.indexof ("/n", n))) n ++, lineno ++;
if (js.substr (0, 1) == ':') js = filtred (js);
if (js) {
if (js.lastindexof ('//')> js.lastindexof ('/n')) js += '/n';
buf += prefijo;
buf += js;
buf += postfix;
}
i + = final - inicio + cerrar.length - 1;
} else if (stri == "//") {
buf += "////";
} else if (stri == "'") {
buf += "// '";
} else if (stri == "/r") {
// ignorar
} else if (stri == "/n") {
if (consumo) {
consumeol = falso;
} demás {
buf += "// n";
Lino ++;
}
} demás {
buf += stri;
}
}
if (false! == options._with) buf += "');}) (); /n} /nreturn buf.join (' ');";
else buf += "');/nreturn buf.join (' ');";
devolver buf;
};
Al igual que la plantilla EJS y el módulo Express que usamos aquí, entramos con curiosidad para ver cuál es la diferencia.
Después de abrir, EJS.JS, dibujamos algún código para leer: estamos más familiarizados con este código. Es consistente con el código de motor de la plantilla del bajo, y ambos analizan la plantilla en una cadena.
Luego, conviértalo en una función a través del método Eval o NUEVO FUNCIÓN, y pálelo a su propio objeto de datos para análisis.
En cuanto al flujo de trabajo específico, aún no lo sabemos, por lo que solo podemos ponerlo en el punto posterior para estudiar. Bien, vamos a otros módulos ahora.
app.js
Como archivo de entrada, App.js juega un papel importante:
La copia del código es la siguiente:
/**
* Dependencias del módulo.
*/
var express = request ('express');
rutas var = requerir ('./ rutas');
VAR user = request ('./ rutas/user');
var http = require ('http');
ruta var = requerir ('ruta');
var app = express ();
// Todos los entornos
app.set ('puerto', process.env.port || 3000);
App.set ('Vistas', Path.Join (__ Dirname, 'Vistas'));
App.set ('Ver motor', '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')));
// solo desarrollo
if ('desarrollo' == app.get ('env')) {
app.use (express.errorHandler ());
}
app.get ('/', rutas.index);
app.get ('/users', user.list);
http.createServer (app) .listen (app.get ('puerto'), function () {
console.log ('Express Server Listening on Port' + App.get ('Port'));
});
Cargamos los módulos Express y HTTP a través del comando requerir (), y cargaremos el usuario índice y otros archivos de plantilla en el directorio de rutas
App.set ('Port', Process.env.port || 3000) es el puerto al inicio
App.set ('Vistas', __Dirname + '/Views') es la ruta para almacenar el archivo de plantilla. Donde __Dirname es una variable global, almacenando el directorio donde se encuentra el script actual. Podemos verlo de esta manera:
La copia del código es la siguiente:
console.log (__ dirname); // index.js Agregar el siguiente código
/**
D:/blog> aplicación de nodo
Servidor Express Li
D:/blog/rutas
*/
En cuanto a cómo se obtuvo este __Dirname, no necesitamos prestarle atención por el momento
App.set ('Ver motor', 'EJS') establece el motor de plantilla en EJS
App.use (express.favicon ()) es establecer el icono para modificarlo, y luego puede crear el archivo de imágenes a continuación.
app.use (express.logger ('dev')); Express depende de la conexión, y el middleware incorporado generará algunos registros.
app.use (express.json ()); se usa para analizar el cuerpo de solicitud, donde la cadena se convertirá dinámicamente a un objeto JSON
app.use (express.methodoverride ()); Conecte el middleware incorporado para manejar las solicitudes de publicación y puede disfrazar y otros métodos HTTP
App.use (App.router); Llame a las reglas de resolución del enrutador
app.use (express.static (path.join (__ dirname, 'public'))); Conecte el middleware incorporado, establezca público en el directorio raíz para almacenar archivos estáticos
La copia del código es la siguiente:
if ('desarrollo' == app.get ('env')) {
app.use (express.errorHandler ());
}
Esta oración significa que la información de error debe ser obtenido en condiciones de desarrollo
La copia del código es la siguiente:
app.get ('/', rutas.index);
app.get ('/users', user.list);
Estas dos oraciones son archivos de procesamiento específicos en la hora de acceso. Por ejemplo, al acceder directamente aquí, el acceso predeterminado es rutas.index.
Luego analiza los datos de la plantilla dentro:
La copia del código es la siguiente:
exports.index = function (req, res) {
console.log (__ dirname);
res.render ('índice', {título: 'express'});
};
Finalmente, se llamará al código anterior para crear un servidor HTTP y escuchar el puerto 3000. Después del éxito, puede acceder a él en la página web.
enrutamiento
Utilizamos este método para construir la ruta
La copia del código es la siguiente: App.get ('/', Routes.Index);
El código anterior puede ser reemplazado por este código (escrito en la aplicación)
La copia del código es la siguiente:
app.get ('/', function (req, res) {
res.render ('índice', {título: 'express'});
});
Este código significa que al acceder a la página de inicio, se llama al motor de plantilla EJS para representar el archivo de plantilla index.eJS
Ahora haga algunas modificaciones. El código anterior implementa la función de enrutamiento, pero no podemos poner el código relacionado con el enrutamiento en la aplicación. Si hay demasiadas rutas, la aplicación se hinchará, por lo que ponemos la configuración relevante en el índice
Elimine las funciones de enrutamiento relevantes en la aplicación y agregue código al final de la aplicación:
La copia del código es la siguiente: Rutas (APP);
Luego modificar index.js
La copia del código es la siguiente:
módulo.exports = function (app) {
app.get ('/', function (req, res) {
res.render ('índice', {título: 'express'});
});
};
La forma en que se organiza este código aún no está claro, por lo que ya no le prestaré atención. Echemos un vistazo más tarde
Reglas de enrutamiento
Express encapsula múltiples solicitudes HTTP, generalmente usamos Get/Post Two
La copia del código es la siguiente:
app.get ();
app.post ();
El primer parámetro es la ruta de solicitud, el segundo parámetro es la función de devolución de llamada, o los dos parámetros son solicitud y respuesta
Luego, para req (solicitud) existen las siguientes reglas
Req.Query maneja la solicitud y obtiene los parámetros de solicitud GET
Req.Params Handles /: XXX Form Get o Post Solicitud
req.body maneja la solicitud de publicación y obtiene el cuerpo de solicitud de post
Req.Params maneja las solicitudes Get and Post, pero la prioridad de búsqueda es req.params-> req.body-> req.Query
Las reglas de la ruta también respaldan la regularidad, hablaremos sobre los detalles más tarde ...
Agregar reglas de enrutamiento
Cuando accedemos a un enlace que no existe:
Debido a que no hay una regla de enrutamiento para /y, no dice el archivo bajo público, por lo que es 404
Ahora agregamos la ruta relevante en index.js:
La copia del código es la siguiente:
módulo.exports = function (app) {
app.get ('/', function (req, res) {
res.render ('índice', {título: 'express'});
});
app.get ('/y', function (req, res) {
res.send ('ye xiaochai');
});
};
Aquí tengo una página de confusión:
La razón es que después de descargar, mi archivo es la codificación GBK. Solo necesitamos cambiarlo a UTF-8. No nos importa el motor de plantilla. Vamos a la siguiente sección.
Función de registro
Aquí seguimos al blogger original para hacer una función de registro simple, usar Mongo DB como base de datos, y luego mejoraremos las funciones a su vez
Cree una nueva ruta de registro y cree una nueva plantilla de registro para ella, así que comencemos
① Crear una nueva ruta en el índice
La copia del código es la siguiente:
app.get ('/registro', function (req, res) {
res.render ('índice', {título: 'registrar página'});
});
La copia del código es la siguiente:
módulo.exports = function (app) {
app.get ('/', function (req, res) {
res.render ('índice', {título: 'express'});
});
app.get ('/y', function (req, res) {
res.send ('ye xiaochai');
});
app.get ('/registro', function (req, res) {
res.render ('Registro', {Título: 'Página de registro'});
});
La copia del código es la siguiente:
<! Doctype html>
<html>
<Evista>
<title> < %= title %> </title>
<link rel = 'stylesheet' href = '/stylesheets/style.css'/>
</ablo>
<Body>
<h1> < %= título %> </h1>
<Form Method = "Post">
<iv> UserName: <input type = "text" name = "name"/> </div>
<Div> Password: <input type = "contraseña" name = "contraseña"/> </div>
<Div> <input type = "Subt" value = "Login"/> </div>
</form>
</body>
</html>
De esta manera, nuestra página está formada:
Con el programa básico, ahora necesitamos soporte de base de datos, por lo que necesitamos instalar el entorno MongoDB
Mongodb
MongoDB es un NoSQL basado en el almacenamiento de archivos distribuido. Está escrito en C ++. La estructura de datos compatible con MongoDB es suelta, similar a JSON. Sabemos que JSON puede admitir cualquier tipo, para que podamos crear una estructura muy compleja.
La copia del código es la siguiente:
{
ID: 1,
Nombre: 'Ye Xiaochai',
Frinds: [
{id: 2, nombre: 'Su Huanzhen'},
{id: 3, nombre: 'Libro de una página'}
]
}
Instalar MongoDB
Primero, vaya a http://www.mongodb.org/downloads para descargar el archivo de instalación, luego copie el archivo en el disco D y cambie el nombre de MongoDB, y luego cree una nueva carpeta de blog dentro de
Luego abra la herramienta de línea de comando para cambiar el directorio a bin e ingresar:
Copie el código de la siguiente manera: MongoD -Dbpath D:/MongoDB/Blog
Establezca la carpeta de blog en el directorio del proyecto e inicie la base de datos. En aras de la conveniencia, escribiremos un comando y haremos clic directamente para iniciar la base de datos:
Copie el código de la siguiente manera: D: /Mongodb/bin/mongod.exe -dbpath D:/MongoDB/Blog
Enlace a MongoDB
Después de que la base de datos se instala correctamente, nuestro programa también necesita el programa de "controlador" relevante para vincular la base de datos. Por supuesto, el paquete debe descargarse ...
Abra paquete.json para agregar una nueva línea en dependencias
La copia del código es la siguiente:
{
"Nombre": "Nombre de la aplicación",
"Versión": "0.0.1",
"Privado": Verdadero,
"Scripts": {
"Inicio": "Node App.js"
},
"Dependencias": {
"Express": "3.4.8",
"EJS": "*",
"MongoDB": "*"
}
}
Luego ejecute la instalación de NPM para descargar el nuevo paquete de dependencia. De esta manera, los conductores relacionados con MongoDB están disponibles. Para vincular MySQL y otras bases de datos, se necesitan otros paquetes de dependencia.
En este momento, cree el archivo setting.js en el directorio raíz para guardar la información de conexión de la base de datos
La copia del código es la siguiente:
módulo.exports = {
CookiesECret: 'myBlog',
DB: 'Blog',
Anfitrión: 'Localhost'
};
DB es el nombre de la base de datos, host es la dirección de la base de datos, CookiesECret se usa para el cifrado de cookies y no tiene nada que ver con la base de datos
A continuación, cree una nueva carpeta de modelo en el directorio raíz y cree un nuevo db.js en la carpeta de modelos
La copia del código es la siguiente:
Configuración de var = requirir ('../ Configuración'),
Db = require ('MongoDB'). DB,
Conexión = requirir ('MongoDB'). Conexión,
Servidor = requirir ('MongoDB'). Server;
módulo.exports = new db (settings.db, nuevo servidor (settings.host, conexión.default_port), {safe: true});
La copia del código es la siguiente: nuevo DB (settings.db, nuevo servidor (settings.host, conexión.default_port), {safe: true});
Establezca el nombre de la base de datos, la dirección de la base de datos y el puerto de la base de datos para crear una instancia de la base de datos y exporten la instancia a través de módulo.exports, de modo que la base de datos pueda ser leída y escrita por requerir
Necesitamos escribir con éxito en la base de datos, y el programa del lado del servidor debe procesar la información de la publicación, por lo que creamos un nuevo usuario.js en la carpeta de modelos
La copia del código es la siguiente:
var mongodb = require ('./ db');
Usuario de funciones (usuario) {
this.name = user.name;
this.password = user.password;
};
módulo.exports = user;
// almacenar información del usuario
User.prototype.save = function (devolución de llamada) {
// Documento de usuario que se almacenará en la base de datos
user var = {
Nombre: this.name,
Contraseña: this.password
};
// Abra la base de datos
mongodb.open (function (err, db) {
if (err) {
devolver la devolución de llamada (err); // Error, devuelve la información de ERR
}
// Lee la colección de usuarios
db.collection ('usuarios', function (err, colección) {
if (err) {
mongodb.close ();
devolver la devolución de llamada (err); // Error, devuelve la información de ERR
}
// Insertar datos de usuario en la recopilación de usuarios
colección.insert (usuario, {
seguro: verdadero
}, función (err, usuario) {
mongodb.close ();
if (err) {
devolver la devolución de llamada (err); // Error, devuelve la información de ERR
}
devolución de llamada (nulo, usuario [0]); //¡Éxito! ERR es nulo y devuelve el documento de usuario almacenado
});
});
});
};
La copia del código es la siguiente:
// leer información del usuario
User.get = function (nombre, devolución de llamada) {
// Abra la base de datos
mongodb.open (function (err, db) {
if (err) {
devolver la devolución de llamada (err); // Error, devuelva la información de errores
}
// Lee la colección de usuarios
db.collection ('usuarios', function (err, colección) {
if (err) {
mongodb.close ();
devolver la devolución de llamada (err); // Error, devuelva la información de errores
}
// Encuentra un documento con nombre de usuario (clave de nombre) Nombre del valor
colección.findone ({
Nombre: Nombre
}, función (err, usuario) {
mongodb.close ();
if (err) {
devuelve la devolución de llamada (err); // falló! Volver a la información errante
}
devolución de llamada (nulo, usuario); // ¡éxito! Devolver la información del usuario de la consulta
});
});
});
};
Aquí uno escribe datos y el otro lee datos. Hay un procesador. Ahora necesita agregar el siguiente programa frente a index.js.
La copia del código es la siguiente: var user = request ('../ modelos/user.js');
Modificar la app.post ('/registrar')
La copia del código es la siguiente:
app.post ('/registro', function (req, res) {
var name = req.body.name;
var pwd = req.body.password;
var newuser = nuevo usuario ({
Nombre: Nombre,
Contraseña: PWD
});
Newuser.save (function (err, usuario) {
// Operaciones relacionadas, sesión de escritura
res.send (usuario);
});
});
Luego haga clic para registrarse y tendrá una reacción
Si no puede determinar si escribir en la base de datos en este momento, puede ingresar la base de datos para consultar y primero cambiar al directorio de la base de datos
Copie el código de la siguiente manera: D:/MongoDB/bin>
ingresar:
Copie el código de la siguiente manera: Mongo
Luego cambie su base de datos para conectarse al blog
Copie el código de la siguiente manera: use el blog
Última entrada
Copie el código de la siguiente manera: db.users.find ()
Todos felizmente vimos los datos que se escribían, por lo que el aprendizaje de hoy ha llegado a su fin por el momento
Conclusión
Hoy seguimos un blog para completar la operación desde la instalación hasta la escritura a la base de datos. Agregamos otros aspectos mañana y profundicemos gradualmente el aprendizaje de NodeJs.