1. Instalação
Copie o código da seguinte forma: $ NPM Install Express
Ou use Express Express (1) em qualquer lugar para instalar:
Copie o código da seguinte
$ npm install -g express
2. Comece rapidamente
A maneira mais rápida de começar com o Express é usar o Express Express (1) para gerar um aplicativo, como mostrado abaixo:
Crie um aplicativo:
A cópia do código é a seguinte:
$ npm install -g express
$ expresso /tmp /foo && CD /tmp /foo
Instale o pacote de dependência:
A cópia do código é a seguinte:
$ npm install -d
Inicie o servidor:
A cópia do código é a seguinte:
$ Node App.js
3. Crie um servidor
Para criar uma instância express.httpServer, basta chamar o método CreateServer (). Para este exemplo de aplicativo, podemos definir uma rota com base em ações HTTP (verbos http), tendo app.get () como exemplo:
A cópia do código é a seguinte:
var app = requer ('express'). createServer ();
App.get ('/', function (req, res) {
Res.send ('Hello World');
});
App.Listen (3000);
4. Crie um servidor HTTPS
Inicialize uma instância express.httpSserver como acima. Em seguida, passamos por um objeto de configuração, aceitando a chave, o cert e outras (propriedades/métodos) mencionadas na documentação HTTPS.
A cópia do código é a seguinte:
var app = requer ('express'). CreateServer ({key: ...});
V. Configuração
O Express suporta qualquer ambiente, como estágio do produto e estágio de desenvolvimento. Os desenvolvedores podem usar o método Configur () para definir o ambiente atual necessário. Se a chamada para configurar () não contiver nenhum nome de ambiente, ele será executado no retorno de chamada especificado em todos os ambientes.
Nota do tradutor: Alias como produção/desenvolvimento/estágio podem ser tomados por si mesmos, conforme mostrado no app.configure no Application.js. Veja o exemplo a seguir para uso real.
O exemplo a seguir apenas dumpexceptions (arremessando erros) no estágio de desenvolvimento e retorna uma exceção de pilha. No entanto, em ambos os ambientes, usamos o método e o BodyParser. Preste atenção ao uso do App.Router, que pode (opcional) ser usado para carregar a rota do programa. Além disso, a rota também será carregada ligando para o app.get (), app.post () etc. pela primeira vez.
A cópia do código é a seguinte:
App.configure (function () {
App.Use (Express.MetHODoverRide ());
App.Use (Express.BodyParser ());
App.Use (App.Router);
});
app.configure ('desenvolvimento', function () {
App.Use (Express.static (__ Dirname + '/public'));
App.use (Express.errorHandler ({dumpexceptions: true, showstack: true}));
});
App.configure ('Produção', function () {
var o ano = 31557600000;
App.Use (Express.static (__ Dirname + '/public', {maxage: Oneyear}));
App.Use (Express.errorHandler ());
});
Para ambientes semelhantes, você pode passar várias seqüências de ambiente:
A cópia do código é a seguinte:
App.configure ('Stage', 'Prod', function () {
// config
});
Para quaisquer configurações internas (#), o Express fornece métodos definidos (key [, val]), ativar (chave) e desativar (chave):
Nota do tradutor: Para detalhes, consulte: Application.js App.Set.
A cópia do código é a seguinte:
App.configure (function () {
App.set ('Views', __dirName + '/Views');
App.set ('Views');
// => "/absoluto/path/to/views"
app.enable ('algum recurso');
// equivalente a: app.set ('algum recurso', true);
App.disable ('algum recurso');
// equivalente a: app.set ('algum recurso', false);
App.enabled ('algum recurso')
// => false
});
Para mudar o ambiente, podemos definir variáveis de ambiente Node_env, como:
A cópia do código é a seguinte:
$ Node_env = nó de produção app.js
Isso é muito importante porque a maioria dos mecanismos de cache é ativada apenas durante a fase do produto.
6. Configurações
O Express suporta as seguintes configurações de atalho (fora da caixa):
1.Basepath é usado para o caminho da base de aplicação de res.redirect (), que lida explicitamente aos aplicativos montados.
2. View View O diretório raiz padrão é CWD/Views
3. View Engine O processamento padrão do mecanismo de visualização (arquivos de visualização) não requer o uso de sufixos
4. View Cache Ativa o cache Exibir (ativado no estágio do produto)
5. Codificação de alterações do caretim, o padrão é UTF-8
6. Caso rotas sensíveis rotas sensíveis ao caso
7. Após o roteamento do strito ser ativado (na rota), o final/não será ignorado (Nota de tradução: ou seja, App.get ('/Sofish') e App.get ('/Sofish/') serão diferentes)
8.json retorno de chamada Ativar Res.send () / Res.json () Suporte JSONP explícito (suporte transparente ao JSONP)
7. roteamento
O Express usa ações HTTP para fornecer um conjunto de APIs de roteamento rápido e expressivo. Por exemplo, se você deseja lidar com uma conta com um caminho de /usuário /12, podemos definir a rota da seguinte maneira. O valor associado aos espaços reservados nomeados é acessível pelo Req.params.
A cópia do código é a seguinte:
App.get ('/user/: id', function (req, res) {
res.send ('usuário' + req.params.id);
});
Uma rota é uma string que é compilada internamente em regular. Por exemplo, quando /usuário /: ID é compilado, uma versão simplificada da expressão regular é aproximadamente a seguinte:
A cópia do código é a seguinte:
// modifica a sequência oficial
/// user // ([^//]+) //?/
Expressões regulares podem ser transmitidas e aplicadas a cenários complexos. Como os grupos de conteúdo capturados por expressões regulares literais são anônimas, podemos acessá -los diretamente através do Req.params. Portanto, o primeiro conjunto de conteúdo que capturamos será req.params [0], enquanto o segundo conjunto é imediatamente seguido por req.params [1].
A cópia do código é a seguinte:
App.get (/^// Usuários? (?: // (/d+) (?: /./. (/d+))?)?/, function (req, res) {
res.send (req.params);
});
Solicitações de Curl para a rota definida acima:
A cópia do código é a seguinte:
$ curl http: // dev: 3000/usuário
[NULL, NULL]
$ CURL http: // dev: 3000/usuários
[NULL, NULL]
$ curl http: // dev: 3000/usuários/1
["1", nulo]
$ curl http: // dev: 3000/usuários/1..15
["1", "15"]
Aqui estão alguns exemplos de rotas associadas aos caminhos que eles podem usar:
A cópia do código é a seguinte:
"/ID do usuário"
/Usuário/12
"/Usuários/: id?"
/Usuários/5
/Usuários
"/files/*"
/files/jquery.js
/files/javascripts/jquery.js
"/arquivo/*.*"
/files/jquery.js
/files/javascripts/jquery.js
"/Usuário/: Id/: Operação?"
/Usuário/1
/Usuário/1/Editar
"/products.:format"
/products.json
/products.xml
"/products.:format?"
/products.json
/products.xml
/produtos
"/user/:id.:format?"
/Usuário/12
/User/12.json
Por exemplo, podemos usar o POST para enviar dados JSON e usar o BodyParser, um middleware que pode analisar o conteúdo da solicitação JSON (ou outro conteúdo) para retornar os dados e armazenar o resultado de retorno em req.body:
A cópia do código é a seguinte:
var express = requer ('expresso')
, app = express.createServer ();
App.Use (Express.BodyParser ());
App.Post ('/', function (req, res) {
res.send (req.body);
});
App.Listen (3000);
Geralmente, podemos usar um espaço reservado para o estilo "tolo" como o usuário/: id, sem restrições (nome). No entanto, por exemplo, se quisermos limitar o ID do usuário a ser apenas um número, podemos usar /usuário /: id ([0-9]+), que só entrará em vigor se o espaço reservado contiver pelo menos um número (adaptação, correspondência).
8. Passando o controle da rota
Podemos controlar a próxima rota adaptada chamando o terceiro parâmetro, next () função. Se a adaptação não for encontrada, o controle será transmitido de volta para se conectar e o middleware será chamado em sequência na ordem adicionada em uso (). O princípio também se aplica a várias rotas definidas para o mesmo caminho, e elas serão chamadas por sua vez até que um deles não lige a seguir () e decide fazer uma resposta de solicitação.
A cópia do código é a seguinte:
App.get ('/users/: id?', function (req, res, próximo) {
var id = req.params.id;
if (id) {
// Faça algo
} outro {
próximo();
}
});
App.get ('/usuários', function (req, res) {
// Faça outra coisa
});
O método app.all () pode transferir facilmente a mesma lógica para todas as ações HTTP chamando -o uma vez. Em seguida, usamos-o para extrair um usuário do pseudo-dados e atribuí-lo a req.user.
A cópia do código é a seguinte:
var express = requer ('expresso')
, app = express.createServer ();
var users = [{nome: 'tj'}];
App.all ('/user/: id/: op?', function (req, res, o próximo) {
req.user = usuários [req.params.id];
if (req.user) {
próximo();
} outro {
Próximo (novo erro ('Não é possível encontrar o usuário' + req.params.id));
}
});
App.get ('/user/: id', function (req, res) {
res.send ('visualização' + req.user.name);
});
App.get ('/user/: id/edit', function (req, res) {
res.send ('edição' + req.user.name);
});
app.put ('/user/: id', function (req, res) {
res.send ('atualização' + req.user.name);
});
App.get ('*', function (req, res) {
res.send (404, 'o que ???');
});
App.Listen (3000);
9. Middleware
O middleware Connect (propriedades) usado geralmente é acompanhado por um servidor de conexão regular que é passado para express.createServer (). como:
A cópia do código é a seguinte:
var express = requer ('expresso');
var app = express.createServer (
Express.logger ()
, Express.BodyParser ()
);
Além disso, dentro do bloco Configur () - Este palácio progressivo (Nota do tradutor: risos ^^, de maneira progressiva), também podemos usar convenientemente o uso () para adicionar middleware.
A cópia do código é a seguinte:
App.Use (Express.logger ({format: ': Método: url'}));
Geralmente, usando o middleware de conexão que você pode usar exigir ('Connect'), como este:
A cópia do código é a seguinte:
var connect = requer ('Connect');
App.use (Connect.logger ());
App.use (Connect.BodyParser ());
Isso é um tanto desagradável até certo ponto; portanto, expresse reexporta essas propriedades de middleware, embora sejam iguais:
A cópia do código é a seguinte:
App.Use (Express.logger ());
App.Use (Express.BodyParser ());
A ordem do middleware é muito importante. Quando o Connect recebe uma solicitação, o primeiro middleware para o qual passamos CreateServer () ou Use () será acompanhado por três parâmetros, solicitação, resposta e uma função de retorno de chamada (geralmente a seguir). Quando o próximo () for chamado, será o segundo turno do middleware e assim por diante. Vale a pena notar, porque muitos meios de idade dependem um do outro. Por exemplo, o MethodOverRide () consulta o método req.body para detectar a sobrecarga do método HTTP. Por outro lado, o BodyParser () analisa o conteúdo solicitado e o armazena em req.body. Outro exemplo é a análise de biscoitos e o suporte à sessão. Devemos primeiro usar () cookieparser () e depois session ().
Muitas aplicações expressas incluem essa linha de app.use (app.router), o que pode parecer um pouco estranho. De fato, é apenas uma função de middleware que contém todas as regras de roteamento definidas e executa pesquisas de roteamento com base nas solicitações de URL existentes e nos métodos HTTP. O Express permite que você decida sua posição, mas, por padrão, ele é colocado na parte inferior. Ao alterar a localização da rota, podemos alterar a prioridade do middleware, por exemplo, queremos usar o relatório de erro como o último middleware para que qualquer exceção passada para a próxima () possa ser tratada por ele; Ou queremos que o serviço de arquivo estático seja mais baixo para permitir que nossa rota ouça downloads de uma única solicitação de arquivo estático, etc. Isso se parece com o seguinte:
A cópia do código é a seguinte:
App.Use (Express.logger (...));
App.Use (Express.BodyParser (...));
App.Use (Express.CookieParser (...));
App.Use (Express.Session (...));
App.Use (App.Router);
App.Use (Express.static (...));
App.Use (Express.errorHandler (...));
Primeiro, adicionamos logger (), que pode conter o método req.end () do nó, fornecendo dados em nosso tempo de resposta. O conteúdo da solicitação será analisado (se houver dados), seguido de resolução de cookies e suporte à sessão. Ao mesmo tempo, o req.session será definido quando a rota no app.outer for acionada. No momento, não chamamos a próxima (), para que o middleware estático () não saiba sobre essa solicitação. Se a rota a seguir foi definida, podemos gravar vários estados, recusar downloads e consumir pontos de download, etc.
A cópia do código é a seguinte:
var downloads = {};
App.Use (App.Router);
App.Use (Express.static (__ Dirname + '/public'));
App.get ('/*', function (req, res, próximo) {
var arquivo = req.params [0];
Downloads [arquivo] = downloads [arquivo] || 0;
Downloads [arquivo] ++;
próximo();
});
10. Middleware de roteamento
O roteamento pode usar o middleware do roteador para passar mais de uma função de retorno de chamada (ou matriz) em seus métodos. Esse recurso é muito benéfico para restringir o acesso, baixar dados por meio de roteamento e assim por diante.
Normalmente, a recuperação de dados assíncronos pode parecer o exemplo a seguir, usamos o parâmetro: ID e tentamos carregar um usuário:
A cópia do código é a seguinte:
App.get ('/user/: id', função (req, res, seguinte) {
loadUser (req.params.id, function (err, usuário) {
se (err) retornar a seguir (err);
res.send ('visualização do usuário' + user.name);
});
});
Para garantir princípios secos e melhorar a legibilidade, podemos aplicar essa lógica a um middleware. Como mostrado abaixo, abstrair essa lógica no middleware permitirá que você a reutilize, garantindo a simplicidade do nosso roteamento.
A cópia do código é a seguinte:
função loadUser (req, res, próximo) {
// você buscaria seu usuário no banco de dados
var user = usuários [req.params.id];
if (usuário) {
req.user = usuário;
próximo();
} outro {
próximo (novo erro ('falhou ao carregar o usuário' + req.params.id));
}
}
App.get ('/user/: id', loadUser, function (req, res) {
res.send ('visualização do usuário' + req.user.name);
});
O roteamento múltiplo pode ser aplicado a uma camada mais profunda da lógica em ordem, como restringir o acesso a uma conta de usuário. O exemplo a seguir permite apenas aos usuários que passaram a autenticação para editar suas contas (ela).
A cópia do código é a seguinte:
função andrestrictToSelf (req, res, próximo) {
req.authenticateduser.id == req.user.id
? próximo()
: próximo (novo erro ('não autorizado'));
}
App.get ('/user/: id/edit', loadUser, AndrestriTToSelf, function (req, res) {
res.send ('editing user' + req.user.name);
});
Lembre -se sempre de que o roteamento é apenas uma função simples, como mostrado abaixo, podemos definir funções que retornam o middleware para criar uma solução mais expressiva e flexível.
A cópia do código é a seguinte:
função andrestrictto (função) {
Função de retorno (req, res, próximo) {
req.authenticatedUser.Role == função
? próximo()
: próximo (novo erro ('não autorizado'));
}
}
App.del ('/user/: id', loadUser, AndrestrictTo ('admin'), function (req, res) {
res.send ('Usuário excluído' + req.user.name);
});
O middleware comumente usado "pilha" pode ser passado através de uma matriz (que será aplicada recursivamente), que pode ser misturada e combinada em qualquer grau.
A cópia do código é a seguinte:
var a = [middleware1, middleware2]
, b = [middleware3, middleware4]
, all = [a, b];
app.get ('/foo', a, function () {});
app.get ('/bar', a, function () {});
App.get ('/', a, middleware3, middleware4, function () {});
app.get ('/', a, b, function () {});
app.get ('/', tudo, function () {});
Para o código completo desta instância, consulte o repositório de exemplo de middleware da rota.
Podemos ter várias vezes para "pular" o middleware de roteamento restante e continuar a corresponder às rotas subsequentes. Para fazer isso, só precisamos ligar para o próximo () com a string 'Route' - Next ('Route'). Se nenhuma rotas restantes corresponder à URL solicitada, o Express retornará 404 não encontrado.
11. Método HTTP
Até agora, fui exposto ao app.get () várias vezes. Além disso, o Express também fornece outras ações HTTP comuns, como App.Post (), App.Del (), etc.
Um exemplo comum de uso de postagem está enviando um formulário. Em seguida, simplesmente definimos o atributo do método do formulário para publicar no HTML, e o controle será atribuído à rota definida abaixo.
A cópia do código é a seguinte:
<form método = "post" action = "/">
<input type = "text" name = "user [nome]" />
<input type = "text" name = "user [email]" />
<input type = "submit" value = "submit" />
</morm>
Por padrão, o Express não sabe como lidar com o conteúdo dessa solicitação; portanto, devemos adicionar o middleware do BodyParser, que analisará o conteúdo do aplicativo/x-www-forma-urlncoded e solicitações de aplicativo/json e armazenará as variáveis em req.body. Podemos usar este middleware como o seguinte exemplo:
A cópia do código é a seguinte:
App.Use (Express.BodyParser ());
Como segue, nossa rota terá acesso ao objeto req.body.user e, quando o nome e o email forem definidos, ela conterá essas duas propriedades (NOTA DE TRANSFORNAÇÃO: Se o conteúdo enviado pelo formulário não estiver vazio).
A cópia do código é a seguinte:
App.Post ('/', function (req, res) {
console.log (req.body.user);
res.redirect ('volta');
});
Quando você deseja usar um método como colocar em um formulário, podemos usar uma entrada oculta chamada _method, que pode ser usada para modificar os métodos HTTP. Para fazer isso, primeiro precisamos do MethodOverRide Middleware, que deve aparecer após o BodyParser para usar o valor do formulário contido em seu req.body.
A cópia do código é a seguinte:
App.Use (Express.BodyParser ());
App.Use (Express.MetHODoverRide ());
Por que esses métodos não são de propriedade de padrão? Simplificando, é apenas porque não é necessário para a funcionalidade completa exigida pelo Express. O uso de métodos depende do seu aplicativo, você pode não precisar deles e o cliente ainda pode usar métodos como Put e Excluir, e você pode usá -los diretamente porque o MethodOverRide fornece uma solução muito boa para o formulário. Aqui está uma demonstração de como usar o put, que pode parecer:
A cópia do código é a seguinte:
<form método = "post" action = "/">
<input type = "hidden" name = "_ método" value = "put" />
<input type = "text" name = "user [nome]" />
<input type = "text" name = "user [email]" />
<input type = "submit" value = "submit" />
</morm>
App.put ('/', function () {
console.log (req.body.user);
res.redirect ('volta');
});
12. Manuseio de erros
O Express fornece o método app.error () para que a exceção recebida seja lançada em uma rota ou passada para a próxima (err). O exemplo a seguir lidará com páginas diferentes com base em uma exceção não fundamental específica:
A cópia do código é a seguinte:
função notfound (msg) {
this.name = 'notfound';
Error.call (this, msg);
Error.CaptureStackTrace (this, argumentos.callee);
}
Notfound.prototype .__ proto__ = error.prototype;
App.get ('/404', função (req, res) {
jogue novo não -acumulado;
});
App.get ('/500', função (req, res) {
lançar um novo erro ('teclado gato!');
});
Conforme descrito abaixo, podemos ligar para o app.error () várias vezes. Aqui, detectamos a instância Notfound e exibimos uma página 404, ou passamos para o próximo manipulador de erros. Vale a pena notar que esses processadores podem ser definidos em qualquer lugar, porque serão colocados sob o processador de roteamento quando a escuta () for ouvida. Ele permite definições no bloco Configure () para que possamos usar diferentes métodos de manuseio de exceções com base no ambiente.
A cópia do código é a seguinte:
App.error (function (err, req, res, próximo) {
if (err instância de notfound) {
res.Render ('404.Jade');
} outro {
próximo (err);
}
});
Para a simplicidade, aqui assumimos que todos os erros desta demonstração são 500 e, é claro, você pode escolher o que gosta. Ao executar chamadas do sistema para um sistema de arquivos como o nó, você pode receber um erro.Code com o ENOENT, o que significa que "não existe esse arquivo ou diretório", que podemos usar no manipulador de erros ou exibir uma página especificada quando necessário.
A cópia do código é a seguinte:
App.error (function (err, req, res) {
res.render ('500.jade', {
Erro: err
});
});
Nosso aplicativo também pode usar o Middleware do ErrorHandler do Connect para relatar exceções. Por exemplo, quando queremos produzir uma exceção do Stderr no ambiente de "desenvolvimento", podemos usar:
A cópia do código é a seguinte:
App.Use (Express.errorHandler ({dumpexceptions: true}));
Ao mesmo tempo, durante a fase de desenvolvimento, podemos precisar exibir as exceções que passamos e lançamos a página HTML sofisticada, para a qual podemos definir o ShowStack como True.
A cópia do código é a seguinte:
App.Use (Express.errorHandler ({ShowStack: true, dumpexceptions: true}));
O middleware do ErrorHandler também pode retornar JSON quando aceita: Existe um aplicativo/JSON, o que é muito útil para o desenvolvimento de aplicativos que dependem muito do JavaScript do cliente.
13. PREVOCESSO DE PARAMETRO DE ROTRA
O pré -processamento de parâmetros de roteamento, por meio de carregamento implícito de dados e verificação de solicitação, pode melhorar bastante a legibilidade do seu programa. Por exemplo, você geralmente precisa obter continuamente dados básicos de várias rotas. Por exemplo, carregando um usuário com /usuário /: id, podemos fazer isso:
A cópia do código é a seguinte:
App.get ('/user/: userID', function (req, res, seguinte) {
User.get (req.params.userID, function (err, usuário) {
se (err) retornar a seguir (err);
res.send ('user' + user.name);
});
});
Através do pré -processamento, nossos parâmetros podem ser mapeados para retornos de chamada que executam validação, controle e até carregam dados do banco de dados. Como segue, chamamos o app.param () com nomes de parâmetros e esperamos mapeá -lo para algum middleware. Como você pode ver, aceitamos o parâmetro ID que representa o valor da área espaço reservada. Usando isso, carregamos o usuário como de costume e lidamos com o erro e simplesmente chamamos a próxima () para entregar o controle ao próximo pré -processador ou processador de roteamento.
A cópia do código é a seguinte:
App.param ('userID', função (req, res, seguinte, id) {
User.get (id, função (err, usuário) {
se (err) retornar a seguir (err);
se (! Usuário) retornar a seguir (novo erro ('falhou ao encontrar usuário'));
req.user = usuário;
próximo();
});
});
Uma vez feito isso, o exposto acima melhorará bastante a legibilidade da rota e nos permitirá compartilhar facilmente a lógica ao longo do programa:
A cópia do código é a seguinte:
App.get ('/user/: userID', function (req, res) {
res.send ('usuário' + req.user.name);
});
14. Ver Processamento
O arquivo de exibição usa o formato <Name>. Por exemplo, o layout.ejs dirá ao sistema de visualização requer ('ejs'), e o módulo carregado deve (exportar) o exports.compile (str, opções) e retornar uma função para se adaptar ao expressão. App.register () pode ser usado para alterar esse comportamento padrão para mapear extensões de arquivo para mecanismos específicos. Por exemplo, "foo.html" pode ser processado pelo EJS.
O exemplo a seguir usa jade para processar index.html. Como não usamos o layout: false, o conteúdo processado pelo index.jade será passado para uma variável local chamada Body in Layout.jade.
A cópia do código é a seguinte:
App.get ('/', function (req, res) {
res.render ('index.jade', {title: 'meu site'});
});
A nova configuração do View Engine nos permite especificar o mecanismo de modelo padrão, por exemplo, quando usamos o Jade, você pode defini -lo assim:
A cópia do código é a seguinte:
App.Set ('View Engine', 'Jade');
Permita -nos lidar com isso:
A cópia do código é a seguinte:
res.render ('índice');
Correspondente a:
A cópia do código é a seguinte:
res.render ('index.jade');
Quando o mecanismo de visualização é definido, a extensão é opcional, mas ainda podemos misturar o mecanismo de modelo correspondente:
A cópia do código é a seguinte:
res.render ('outra página.ejs');
O Express também fornece configurações de opções de visualização, que serão aplicadas a uma visão toda vez que for renderizada, por exemplo, se você não quiser usar layouts:
A cópia do código é a seguinte:
App.set ('View Options', {
Layout: false
});
Isso pode ser sobrecarregado dentro da chamada res.render () quando necessário:
A cópia do código é a seguinte:
res.render ('myview.ejs', {layout: true});
Quando há necessidade de alterar um layout, geralmente precisamos especificar outro caminho. Por exemplo, quando definimos o View Engine como Jade e o arquivo é nomeado ./Views/mylayout.jade, podemos simplesmente passar nos parâmetros:
A cópia do código é a seguinte:
res.render ('página', {layout: 'mylayout'});
Caso contrário (Nota do tradutor: Quando o View Engine não está definido como jade ou outro mecanismo), devemos especificar uma extensão:
A cópia do código é a seguinte:
res.render ('página', {layout: 'mylayout.jade'});
Eles também podem ser caminhos absolutos:
A cópia do código é a seguinte:
res.render ('página', {layout: __dirname + '/../../mylayout.jade'});
Há um bom exemplo disso - personalize as tags iniciantes e fechadas de EJs:
A cópia do código é a seguinte:
App.set ('View Options', {
abrir: '{{',
fechar: '}}'
})
15. Ver peças
O sistema de visão do Express possui suporte interno para peças e coleções, o que equivale a substituir um fragmento de documento por uma visão "mini". Exemplo, renderizando repetidamente, na verdade para exibir comentários, podemos usar o conjunto de peças:
A cópia do código é a seguinte:
Parcial ('Comentário', {Coleção: Comentários});
Se não forem necessárias outras opções ou variáveis locais, podemos omitir o objeto inteiro e simplesmente passá -lo para uma matriz, o que é equivalente ao acima: acima:
A cópia do código é a seguinte:
parcial ('comentário', comentários);
Em uso, o conjunto de componentes fornece algum suporte "mágico" para variáveis locais gratuitamente:
1. Firstincollection True, quando é o primeiro objeto
2. Indexincollection no objeto de coleta
3.Lastincollection True, quando é o último objeto
4. Comprimento do comprimento da coleta do objeto de coleção
A transferência (geração) de variáveis locais tem maior prioridade. Ao mesmo tempo, as variáveis locais passadas para a visão dos pais também são adequadas para crianças. Por exemplo, quando usamos parcial ('blog/post', postagem) para renderizar uma postagem no blog, ele gerará uma variável local. Existe uma variável local na visualização que chama essa função, que também será válida para o blog/post. (Nota do tradutor: aqui parcial é mais parecido com o método de inclusão no PHP).
Nota: Use a coleção de peças com cuidado, a renderização de uma variedade de coleções de peças de comprimento 100 é equivalente a 100 visualizações que precisamos processar. Para coleções simples, é melhor repetir o embutido em vez de usar um coletor de componentes para evitar a sobrecarga excessiva.
16. Veja a pesquisa
A pesquisa de visualização é executada em relação à visualização pai (caminho). Se tivermos uma página de visualização chamada Views/User/List.jade, e Parcial ('Edit') está escrito dentro dela, ele tentará carregar visualizações/usuário/edit.jade e parcial ('../ mensagens') carregará Views/Message.jade.
O sistema de visualização também suporta indexação de modelos, permitindo que você use um diretório com o mesmo nome que a visualização. Por exemplo, em uma rota, res.Render ('Usuários') obtém não visualizações/usuários.jade, ou seja, views/usuários/index.jade. (Nota do tradutor: primeiro lide com a situação de <ath>.
Ao usar o índice de exibição acima, usamos parcial ('usuários') para consultar as views/usuários/index.jade no mesmo diretório que a visualização. Ao mesmo tempo, o sistema de visualização tentará indexar ../ Usuários/Index sem nós chamarmos parcial ('usuários').
17. Motores de modelo
A seguir, são os seguintes motores de modelo mais usados para o Express:
1.haml: implementação HAML
2.Jade: Haml.js sucessor
3.EJS: JavaScript incorporado
4.Coffeekup: Modelo baseado em CoffeeScript
5. JQuery Modelos
18. Suporte de sessão
O suporte à sessão pode ser obtido usando o middleware da sessão do Connect. Por esse motivo, geralmente precisamos preceder -o com o middleware do CookieParser, que analisará e armazenam dados de cookies em req.cookies.
A cópia do código é a seguinte:
App.Use (Express.CookieParser ());
App.use (Express.Session ({Secret: "Keyboard Cat"}));
Por padrão, o middleware da sessão usa o armazenamento de memória interno da Connect, mas existem muitas outras implementações. Por exemplo, o Connect-Redis fornece um armazenamento de sessão Redis, que pode ser usado como o seguinte:
A cópia do código é a seguinte:
var redisstore = requer ('Connect-Redis') (expresso);
App.Use (Express.CookieParser ());
App.Use (Express.Session ({secret: "Keyboard Cat", Store: New Redisstore}));
Neste ponto, as propriedades Req.Session e Req.SessionStore serão usadas por todas as rotas e middleware subsequente. Todas as propriedades sobre req.Session serão salvas automaticamente em uma resposta, por exemplo, quando queremos adicionar dados ao carrinho de compras:
A cópia do código é a seguinte:
var redisstore = requer ('Connect-Redis') (expresso);
App.Use (Express.BodyParser ());
App.Use (Express.CookieParser ());
App.Use (Express.Session ({secret: "Keyboard Cat", Store: New Redisstore}));
App.post ('/add-to-cart', função (req, res) {
// Podemos postar vários itens através de um formulário
// (em alguns casos, o middleware do corpo () é usado)
var itens = req.body.items;
req.session.items = itens;
res.redirect ('volta');
});
App.get ('/add-to-cart', function (req, res) {
// Ao retornar, página Get /Add-to-Cart
// Podemos verificar req.session.items && req.session.items.length
// imprima o prompt
if (req.session.items && req.session.items.length) {
req.Notify ('info', 'você tem %s itens no seu carrinho', req.session.items.length);
}
res.Render ('Shopping-Cart');
});
Para req.session, ele também possui métodos como sessão#touch (), sessão#Destroy (), Sessão#Regenerate (), etc. para manter e operar sessões. Para mais detalhes, consulte a documentação da sessão Connect.
19. Guia de atualização
Para os alunos que usam o Express 1.x, se você tiver programas importantes que precisam ser atualizados para 2.x para melhor suporte, consulte o Guia oficial de migração muito detalhado: http://expressjs.com/guide.html#migration-guide