Deixe o NodeJS executar
É claro que o primeiro passo é instalar o ambiente NodeJS. Agora que o Windows tem uma instalação mais rápida do NodeJS, você pode baixá -lo diretamente:
http://www.nodejs.org/download/
Baixe -o conforme necessário. Após a conclusão do download, basta ir para a próxima etapa. Depois disso, teremos o ambiente NodeJS.
A segunda etapa é, para facilitar nossas operações subsequentes, vimos diretamente um blog de pasta no disco D.
Em seguida, abra a ferramenta de linha de comando do Windows, digite o disco D e digite:
Copie o código da seguinte forma: Express -e Blog
Depois, pode haver pacotes de dependência dentro, precisamos entrar no diretório do blog para instalar (a configuração de instalação é fornecida pelo package.json):
Copie o código da seguinte forma: instalação do npm
Dessa forma, baixamos o pacote de dependência, que depende do pacote e dos arquivos do pacote Java e do arquivo .NET BLL deve ser um conceito
Neste momento, nosso programa está pronto para ser executado:
Copie o código da seguinte forma: aplicativo de nó
Copie o código da seguinte
Neste momento, você terá uma resposta quando abrir o navegador:
Aqui estamos usando o Express (uma estrutura popular de desenvolvimento NodeJSWeb) e use o mecanismo de modelo EJS
Estrutura de arquivo
A estrutura do diretório de arquivos de inicialização é a seguinte:
App.js é o arquivo de entrada
package.json é um arquivo de dependência do módulo. Quando usamos a instalação do NPM, ele baixará pacotes relacionados on -line de acordo com sua configuração.
Node_modules é o arquivo do módulo baixado (package.json)
Arquivos de recursos estáticos de lojas públicas
rotas salvar arquivos de roteamento
Visualizações armazenam arquivos de modelo de visualização relacionados
Dessa forma, nossa estrutura básica de diretório sai. Vamos falar brevemente sobre o diretório Node_modules aqui.
Node_modules/EJS
Acabamos de dizer que o módulo baixado é armazenado aqui. Para ser franco, é uma coleção de arquivos JS
A cópia do código é a seguinte:
var parse = exports.parse = function (str, opções) {
var opções = opções || {}
, open = options.open || exports.open || '<%'
, close = options.close || exports.close || '%>'
, FILENAME = Options.Filename
, CompiledeBug = options.comPiledeBug! == FALS
, buf = "";
buf += 'var buf = [];';
if (false! == options._with) buf += '/nwith (habitantes locais || {}) {(function () {';
buf += '/n buf.push (/' ';
var lineno = 1;
var consumoEol = false;
for (var i = 0, len = str.length; i <len; ++ i) {
var stri = str [i];
if (str.slice (i, open.length + i) == aberto) {
i += open.length
VAR prefixo, postfix, linha = (CompiledeBug? '__stack.lineno =': '') + lineno;
Switch (str [i]) {
case '=':
prefix = "', escape ((" + linha +', ';
postfix = ")), '";
++ i;
quebrar;
caso '-':
prefix = "', (" + linha +', ';
postfix = "), '";
++ i;
quebrar;
padrão:
prefix = "');" + linha + ';';
postfix = "; buf.push ('";
}
var end = str.indexOf (feche, i)
, JS = str.substring (i, fim)
, start = eu
, inclua = nulo
, n = 0;
if ('-' == js [js.length-1]) {
js = js.substring (0, js.length - 2);
consumeOol = true;
}
if (0 == js.trim (). indexof ('incluir')) {
Var nome = js.trim (). Slice (7) .Trim ();
se (! nome do arquivo) lançar um novo erro ('o nome do arquivo é necessário para incluir');
var path = resolveinclude (nome, nome do arquivo);
incluir = ler (caminho, 'utf8');
incluir = exports.parse (incluir, {FileName: Path, _with: false, aberto: aberto, feche: feche, CompiledeBug: CompiledeBug});
buf + = "' + (function () {" + incluir + "}) () +'";
js = '';
}
while (~ (n = js.IndexOf ("/n", n))) n ++, lineno ++;
if (js.substr (0, 1) == ':') js = filtrado (js);
if (js) {
if (js.LastIndexOF ('//')> js.lastIndexOf ('/n') JS += '/n';
BUF += prefixo;
BUF += JS;
BUF += Postfix;
}
i + = end - start + close.length - 1;
} else if (stri == "//") {
buf += "////";
} else if (stri == "'") {
buf += "// '";
} else if (stri == "/r") {
// ignore
} else if (stri == "/n") {
if (consumeeol) {
consumeOol = false;
} outro {
buf += "// n";
Lineno ++;
}
} outro {
BUF += STRI;
}
}
if (false! == options._with) buf += "');}) (); /n} /nreturn buf.join (' ');";
else buf += "');/nreturn buf.join (' ');";
retornar buf;
};
Assim como o modelo EJS e o módulo expresso que usamos aqui, entramos no programa EJS com curiosidade para ver qual é a diferença.
Após a abertura, EJS.JS, desenhamos algum código para ler: Estamos mais familiarizados com esse código. É consistente com o código do motor do modelo do sublinhado e ambos analisam o modelo em uma string.
Em seguida, converta -o em uma função através do método de avaliação ou nova função e passe -o para seu próprio objeto de dados para análise.
Quanto ao fluxo de trabalho específico, ainda não sabemos, então só podemos colocá -lo no ponto posterior para estudar. Ok, vamos para outros módulos agora.
App.js
Como arquivo de entrada, o App.js desempenha um papel importante:
A cópia do código é a seguinte:
/**
* Dependências do módulo.
*/
var express = requer ('expresso');
var rotas = requer ('./ rotas');
var user = requer ('./ rotas/usuário');
var http = requer ('http');
var caminho = requer ('caminho');
var app = express ();
// Todos os ambientes
app.set ('porta', 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')));
// apenas desenvolvimento
if ('Development' == App.get ('Env')) {
App.Use (Express.errorHandler ());
}
app.get ('/', rotas.index);
app.get ('/usuários', user.list);
http.createServer (app) .listen (app.get ('porta'), function () {
console.log ('servidor expresso de escuta na porta' + app.get ('porta'));
});
Carregamos os módulos Express e HTTP através do comando requer () e carregaremos o usuário do índice e outros arquivos de modelo no diretório de rotas
App.set ('Port', process.env.port || 3000) é a porta na inicialização
App.set ('Views', __dirName + '/Views') é o caminho para armazenar o arquivo de modelo. Onde __dirName é uma variável global, armazenando o diretório em que o script atual está localizado. Podemos visualizá -lo desta maneira:
A cópia do código é a seguinte:
console.log (__ Dirname); // index.js Adicione o seguinte código
/**
D:/blog> aplicativo de nós
Servidor expresso li
D:/blog/rotas
*/
Quanto à forma como esse __dirname foi obtido, não precisamos prestar atenção por enquanto
App.Set ('View Engine', 'EJS') define o mecanismo de modelo para EJS
App.Use (Express.Favicon ()) é definir o ícone para modificá -lo e, em seguida, você pode criar o arquivo de imagens abaixo do público.
App.Use (Express.logger ('Dev')); O Express depende do Connect, e o middleware embutido produzirá alguns logs.
App.Use (Express.json ()); é usado para analisar o corpo da solicitação, onde a corda será convertida dinamicamente em um objeto JSON
App.Use (Express.MetHODoverRide ()); Conecte o middleware embutido para lidar com solicitações de postagem e pode disfarçar o put e outros métodos HTTP
App.Use (App.Router); Regras de resolução do roteador de chamada
App.Use (Express.static (Path.Join (__ Dirname, 'Public'))); Conecte o middleware embutido, defina o público no diretório raiz para armazenar arquivos estáticos
A cópia do código é a seguinte:
if ('Development' == App.get ('Env')) {
App.Use (Express.errorHandler ());
}
Esta frase significa que as informações de erro devem ser produzidas em condições de desenvolvimento
A cópia do código é a seguinte:
app.get ('/', rotas.index);
app.get ('/usuários', user.list);
Essas duas frases são arquivos de processamento específicos no horário de acesso. Por exemplo, ao acessar diretamente aqui, o acesso padrão é rotas.Index.
Em seguida, ele analisa os dados do modelo dentro:
A cópia do código é a seguinte:
exports.index = function (req, res) {
console.log (__ Dirname);
res.render ('index', {title: 'Express'});
};
Por fim, o código acima será chamado para criar um servidor HTTP e ouvir a porta 3000. Após o sucesso, você pode acessá -lo na página da web.
roteamento
Usamos este método para construir a rota
A cópia do código é a seguinte: app.get ('/', rotas.index);
O código acima pode ser substituído por este código (escrito no aplicativo)
A cópia do código é a seguinte:
App.get ('/', function (req, res) {
res.render ('index', {title: 'Express'});
});
Este código significa que, ao acessar a página inicial, o mecanismo de modelo EJS é chamado para renderizar o arquivo de modelo Index.ejs
Agora faça algumas modificações. O código acima implementa a função de roteamento, mas não podemos colocar o código relacionado ao roteamento no aplicativo. Se houver muitas rotas, o aplicativo ficará inchado, por isso colocamos a configuração relevante no índice
Portanto, exclua as funções de roteamento relevante no aplicativo e adicione código ao final do aplicativo:
A cópia do código é a seguinte: Rotas (App);
Em seguida, modifique o index.js
A cópia do código é a seguinte:
module.exports = function (app) {
App.get ('/', function (req, res) {
res.render ('index', {title: 'Express'});
});
};
Como esse código está organizado ainda não está claro, então não prestarei mais atenção. Vamos dar uma olhada mais tarde
Regras de roteamento
Express encapsula várias solicitações HTTP, geralmente usamos Get/Post dois
A cópia do código é a seguinte:
app.get ();
app.post ();
O primeiro parâmetro é o caminho da solicitação, o segundo parâmetro é a função de retorno de chamada, ou os dois parâmetros são solicitações e resposta
Então, para req (solicitação), existem as seguintes regras
REQ.QUERY MANELES RECEBE A SEPITOR E RECEBE OS PARAURQUIÇÕES DE SOLGULAÇÃO
REQ.PARAMS HONDELES /: XXX FORME GET ou POST SOITOR
Req.Body lida com a solicitação de postagem e recebe o órgão de solicitação de postagem
Req.params lida com solicitações de obtenção e postagem, mas a prioridade da pesquisa é req.params-> req.body-> req.Query
As regras do caminho também apóiam a regularidade, falaremos sobre os detalhes mais tarde ...
Adicione regras de roteamento
Quando acessamos um link que não existe:
Como não há regra de roteamento para /y, ele não diz o arquivo em público, então é 404
Agora adicionamos a rota relevante em index.js:
A cópia do código é a seguinte:
module.exports = function (app) {
App.get ('/', function (req, res) {
res.render ('index', {title: 'Express'});
});
App.get ('/y', function (req, res) {
Res.Send ('Ye Xiaochai');
});
};
Aqui eu tenho uma página ilegal:
O motivo é que, após o download, meu arquivo é a codificação GBK. Só precisamos alterá-lo para UTF-8. Não nos importamos com o mecanismo de modelo. Vamos para a próxima seção.
Função de registro
Aqui seguimos o blogueiro original para fazer uma função de registro simples, usar o Mongo DB como banco de dados e, em seguida, melhoraremos as funções, por sua vez
Crie uma nova rota de registro e crie um novo modelo de registro para ele, então vamos começar
① Crie uma nova rota no índice
A cópia do código é a seguinte:
App.get ('/registra', função (req, res) {
res.render ('index', {title: 'registra página'});
});
A cópia do código é a seguinte:
module.exports = function (app) {
App.get ('/', function (req, res) {
res.render ('index', {title: 'Express'});
});
App.get ('/y', function (req, res) {
Res.Send ('Ye Xiaochai');
});
App.get ('/registra', função (req, res) {
res.render ('registro', {title: 'registre página'});
});
A cópia do código é a seguinte:
<! Doctype html>
<html>
<head>
<title> < %= title %> </title>
<link rel = 'Stylesheet' href = '/stylesheets/style.css'/>
</head>
<Body>
<H1> < %= title %> </h1>
<form método = "post">
<div> nome de usuário: <input type = "text" name = "name"/> </div>
<div> Senha: <input type = "senha" name = "senha"/> </div>
<div> <input type = "submit" value = "login"/> </div>
</morm>
</body>
</html>
Dessa forma, nossa página é formada:
Com o programa básico, agora precisamos de suporte ao banco de dados, por isso precisamos instalar o ambiente do MongoDB
MongoDB
O MongoDB é um NOSQL com base no armazenamento de arquivos distribuído. Está escrito em C ++. A estrutura de dados suportada pelo MongoDB é solta, semelhante ao JSON. Sabemos que o JSON pode suportar qualquer tipo, para que possamos criar uma estrutura muito complexa.
A cópia do código é a seguinte:
{
ID: 1,
Nome: 'ye xiaochai',
Frinds: [
{id: 2, nome: 'su huanzhen'},
{id: 3, nome: 'livro de uma página'}
]
}
Instale o MongoDB
Primeiro, acesse http://www.mongodb.org/downloads para baixar o arquivo de instalação, copie o arquivo para D Disk e renomeie -o MongoDB e, em seguida, crie uma nova pasta de blog dentro
Em seguida, abra a ferramenta de linha de comando para alternar o diretório para Bin e inserir:
Copie o código da seguinte
Defina a pasta do blog no diretório do projeto e inicie o banco de dados. Por uma questão de conveniência, escreveremos um comando e clicaremos diretamente para iniciar o banco de dados:
Copie o código da seguinte
Link para MongoDB
Depois que o banco de dados é instalado com sucesso, nosso programa também precisa do programa "driver" relevante para vincular o banco de dados. Claro, o pacote precisa ser baixado ...
Open Package.json para adicionar uma nova linha nas dependências
A cópia do código é a seguinte:
{
"Nome": "Nome do aplicativo",
"versão": "0.0.1",
"privado": verdadeiro,
"Scripts": {
"Start": "Node App.js"
},
"Dependências": {
"Express": "3.4.8",
"EJS": "*",
"MongoDB": "*"
}
}
Em seguida, execute o NPM Instale para baixar o novo pacote de dependência. Dessa forma, os drivers relacionados ao MongoDB estão disponíveis. Para vincular o MySQL e outros bancos de dados, outros pacotes de dependência são necessários.
No momento, crie o arquivo Setting.js no diretório raiz para salvar as informações de conexão do banco de dados
A cópia do código é a seguinte:
module.exports = {
CookieSecret: 'myblog',
DB: 'Blog',
Anfitrião: 'Localhost'
};
DB é o nome do banco de dados, o host é o endereço do banco de dados, CookieSecret é usado para criptografia de cookies e não tem nada a ver com o banco de dados
Em seguida, crie uma nova pasta modelo no diretório raiz e crie um novo db.js na pasta Models
A cópia do código é a seguinte:
var configurações = requer ('../ Configurações'),
Db = requer ('mongodb'). Db,
Conexão = requer ('mongodb'). Conexão,
Servidor = requer ('mongodb'). Servidor;
Module.Exports = new DB (Settings.db, novo servidor (Settings.Host, Connection.Default_port), {Safe: true});
A cópia do código é a seguinte: novo db (settings.db, novo servidor (settings.host, conexão.default_port), {seguro: true});
Defina o nome do banco de dados, o endereço do banco de dados e a porta do banco de dados para criar uma instância do banco de dados e exportar a instância através do Module.Exports, para que o banco de dados possa ser lido e gravado
Precisamos escrever com êxito no banco de dados, e o programa do servidor precisa processar as informações da postagem, para criar um novo usuário.js na pasta Models
A cópia do código é a seguinte:
var monongodb = requer ('./ db');
função usuário (usuário) {
this.name = user.name;
this.password = user.password;
};
module.exports = usuário;
// armazenando informações do usuário
User.prototype.save = function (retorno de chamada) {
// Documento do usuário a ser armazenado no banco de dados
Var User = {
Nome: this.name,
Senha: this.password
};
// Abra o banco de dados
mongodb.open (função (err, db) {
if (err) {
retornar retorno de chamada (err); // Erro, retornar informações de err
}
// Leia a coleção de usuários
db.collection ('usuários', function (err, coleta) {
if (err) {
mongodb.close ();
retornar retorno de chamada (err); // Erro, retornar informações de err
}
// Insira dados do usuário na coleção de usuários
Coleção.Insert (Usuário, {
Seguro: verdadeiro
}, function (err, usuário) {
mongodb.close ();
if (err) {
retornar retorno de chamada (err); // Erro, retornar informações de err
}
retorno de chamada (nulo, usuário [0]); //Sucesso! err é nulo e retorna o documento do usuário armazenado
});
});
});
};
A cópia do código é a seguinte:
// Leia as informações do usuário
User.get = function (nome, retorno de chamada) {
// Abra o banco de dados
mongodb.open (função (err, db) {
if (err) {
Retornar o retorno de chamada (err); // erro, retornar informações de erro
}
// Leia a coleção de usuários
db.collection ('usuários', function (err, coleta) {
if (err) {
mongodb.close ();
Retornar o retorno de chamada (err); // erro, retornar informações de erro
}
// Encontre um documento com um nome de valor de nome de usuário (chave de nome)
Coleção.findone ({
Nome: Nome
}, function (err, usuário) {
mongodb.close ();
if (err) {
Retorne o retorno de chamada (err); // falhou! Retornar para errar informações
}
retorno de chamada (nulo, usuário); // Sucesso! Retorne as informações do usuário da consulta
});
});
});
};
Aqui um escreve dados e o outro lê dados. Existe um processador. Agora você precisa adicionar o seguinte programa na frente do index.js.
A cópia do código é a seguinte: var user = requer ('../ models/user.js');
Modifique o app.post ('/register')
A cópia do código é a seguinte:
App.Post ('/registra', função (req, res) {
var name = req.body.name;
var pwd = req.body.password;
var newUser = novo usuário ({
Nome: Nome,
Senha: PWD
});
newUser.Save (function (err, usuário) {
// operações relacionadas, sessão de gravação
res.send (usuário);
});
});
Em seguida, clique para se registrar e você terá uma reação
Se você não puder determinar se deve gravar no banco de dados no momento, poderá inserir o banco de dados para consultar e primeiro alternar para o diretório de banco de dados
Copie o código da seguinte forma: d:/mongodb/bin>
digitar:
Copie o código da seguinte forma: Mongo
Em seguida, mude seu banco de dados para conectar -se ao blog
Copie o código da seguinte forma: Use o blog
Última entrada
Copie o código da seguinte forma: db.users.find ()
Todos nós vimos felizmente os dados sendo escritos, então o aprendizado de hoje chegou ao fim por enquanto
Conclusão
Hoje seguimos um blog para concluir a operação da instalação à gravação e ao banco de dados. Vamos adicionar outros aspectos amanhã e aprofundar gradualmente o aprendizado de nodejs.