Esta tradução está incompleta. Por favor, ajude a traduzir este artigo.

Neste primeiro artigo sobre Express responderemos as questões, " O que é Node ?" e "O que é Express ?", e dar a você uma visão geral  sobre o que torna o Express um framework web tão especial. Vamos descrever as principais características, e mostrar alguns dos principaís blocos de códigos de construção de um aplicativo Express  (embora neste momento você ainda não tenha um ambiente de desenvolvimento para testá-lo).

Pré-requisitos: Conhecimentos básicos em informática. Uma compreensão geral de programação web lado servidor (backend),e em particular as mecanicas de interação cliente-servidor em websites.
Objetivos: Familiarizar-se com Express e como ele se encaixa com o Node, quais as funcionalidades que ele fornece e os principais blocos de construção de um aplicativo Express.

O que é Express e Node ?

Node (ou formalmente Node.js) é um ambiente em tempo de execução open-source (código aberto) e multiplataforma que permite que os desenvolvedores criem todo tipo de aplicativos e ferramentas do lado servidor em JavaScript.  Node destina-se a ser usado fora do contexto de um navegador (ou seja executando diretamente no computador ou no servidor). Como tal, o ambiente omite APIs JavaScript específicas do navegador e adiciona suporte para APIs de sistema operacional mais tradicionais, incluindo bibliotecas de sistemas HTTP e arquivos.

Do ponto de vista do desenvolvimento de um servidor web, o Node possui vários benefícios:

  • Performance excelente. Node foi projetado para otimizar a taxa de transferência e a escalabilidade em aplicações web e é uma ótima combinação para muitos problemas comuns de desenvolvimento da web (por exemplo, aplicações web em tempo real).
  • O código é escrito em "JavaScript simples e antigo", o que significa menos tempo é gasto para lidar com mudanças de código entre navegador e servidor web, não sendo necessário uma mudança na linguagem.
  • JavaScript é uma linguagem de programação relativamente nova e  beneficia de melhorias no design da linguagem quando comparadas a outras linguagens tradicionais de servidor web (Por exemplo Python, PHP, etc.)  Muito outras linguagens novos e populares compilam / convertem em JavaScript que você também pode usar como o CoffeeScript, ClosureScript, Scala, LiveScript, etc.
  • O gerenciador de pacotes do Node (NPM) prove acesso a centena de milhares de pacotes reutiliváveis. Ele também possui a melhor resolução de dependência da classe e também pode ser usado para automatizar a maior parte da cadeia de ferramentas de compilação.
  • É portátil, com versões em sistemas operacionais Microsoft Windows, OS X, Linux, Solaris, FreeBSD, OpenBSD, WebOS e NonStop. Além disso, é bem suportado por muitos provedores de hospedagem na web, que muitas vezes fornecem infra-estrutura específica e documentação para hospedar sites do Node.
  • It has a very active third party ecosystem and developer community, with lots of people who are willing to help. Possui uma comunidade de desenvolvedores e um ecossistema muito ativo, com muitas pessoas que estão dispostas a ajudar.

Trivialmente você pode criar um simples servidor web para responder qualquer requisição usando apenas o pacote HTTP padrão do Node, conforme mostrado abaixo. Isto criará um servidor e escutará qualquer tipo de requisição HTTP na URL http://127.0.0.1:8000/; Quando um é recebido, enviará uma resposta em texto simples escrita "Olá Mundo".

// Carrega o modulo HTTP do Node
var http = require("http");

// Cria um servidor HTTP e uma escuta de requisições para a porta 8000
http.createServer(function(request, response) {

  // Configura o cabeçalho da resposta com um status HTTP e um Tipo de Conteúdo
   response.writeHead(200, {'Content-Type': 'text/plain'});
   
   // Manda o corpo da resposta "Olá Mundo"
   response.end('Olá Mundo\n');
}).listen(8000);

// Imprime no console a URL de acesso ao servidor
console.log('Servidor executando em http://127.0.0.1:8000/');

Outras tarefas comuns de desenvolvimento web não são suportadas diretamente pelo próprio Node. Se você deseja adicionar manipulação específica para diferentes requisições HTTP (por exemplo GET, POST, DELETE, etc.), lidar separadamente com pedidos em diferentes caminhos de URL ("rotas"), servir arquivos estáticos ou usar modelos para criar dinamicamente a resposta, então você precisará escrever o código você mesmo, ou você pode evitar de "reinventar a roda" e usar um framework!

Express é o framework web mais popular, e é a biblioteca subjacente para uma série de outros frameworks populares de Nodes. Fornece mecanismos para:

  • Gerencia as requisições de diferentes requisições e rotas e URLs.
  • Combinar com mecanismos de renderização de "view" para gerar respostas inserindo dados em modelos.
  • Definir as configurações comuns da aplicação web, como a porta a ser usada para conexão e a localização dos modelos que são usados para renderizar a resposta.
  • Adicionar em qualquer ponto da requisição um "middleware" para interceptar processar ou pré-processar e tratamentar à mesma.

Equanto o Express é bastante minimalista, os desenvolvedores criam pacotes de middleware para resolver quase todos os problemas no desenvolvimento web. Há bibliotecas para trabalhar com cookies, sessões, login de usuários, parametros de URL, dados em requisições POST, cabeçalho de segurança e entre tantos outros. Você pode achar uma lista de pacote de middleware mantido pela equipe Express em Express Middleware (juntamente com uma lista de alguns pacotes populares de terceiros).

Nota: Essa flexibilidade é uma espada de dois gumes. Há pacotes de middleware para resolver quase qualquer problema ou requisito, mas trabalhar os pacotes certos para usar às vezes pode ser um desafio. Também não há "caminho correto" para estruturar um aplicativo, e muitos exemplos que você pode encontrar na Internet não são ótimos, ou apenas mostram uma pequena parte do que você precisa fazer para desenvolver uma aplicação web.

De onde veio?

Node foi inicialmente lançado, apenas para Linux, em 2009. O gerenciador de pacotes NPM foi lançado em 2010 e o suporte nativo do Windows foi adicionado em 2012. O lançamento LTS atual é o Node v8.9.3, enquanto a versão mais recente é o Node 9. Este é um pequeno trecho de uma rica história; aprofundar a Wikipédia se quiser saber mais).

O Express foi inicialmente lançado em novembro de 2010 e atualmente está na versão 4.16 da API. Você pode verificar o changelog para obter informações sobre as mudanças na versão atual e o GitHub para obter notas de versão histórica mais detalhadas.

A popularidade de um framework web é importante porque é um indicador de se ele continuará a ser mantida, e quais recursos provavelmente estarão disponíveis em termos de documentação, bibliotecas de complemento e suporte técnico.

Não há nenhuma medida pronta e definitiva da popularidade das estruturas do lado do servidor (embora sites como o Hot Frameworks tentam avaliar a popularidade usando mecanismos como contar o número de projetos do GitHub e as perguntas do StackOverflow para cada plataforma). Uma questão melhor é se o Node e o Express são "suficientemente populares" para evitar problemas de plataformas impopulares. Eles continuam a evoluir ? Você pode obter ajuda se precisar ? Existe uma oportunidade para você receber trabalho remunerado se você aprender Express ?

Baseado no numero de empresas de alto perfil que usam Express, o numero de pessoas contribuindo para o codigo base, e o numero de pessoas que proveem suporte tanto gratuito como pago, então sim, Express é um framework popular!

Express é opinativo ?

Os frameworks web costumam se referir a si mesmas como "opinativas" ou "não opinativas".

Os frameworks opinativos são aqueles com opiniões sobre o "caminho certo" para lidar com qualquer tarefa específica. Muitas vezes, eles apoiam o desenvolvimento rápido em um domínio particular (resolvendo problemas de um tipo específico) porque a maneira correta de fazer qualquer coisa geralmente é bem compreendida e bem documentada. No entanto, eles podem ser menos flexíveis na resolução de problemas fora de seu domínio principal e tendem a oferecer menos opções para quais componentes e abordagens eles podem usar.

Frameworks não opinativos, ao contrário, têm muito menos restrições sobre a melhor maneira de utilizar componentes juntos para atingir um objetivo, ou mesmo quais componentes devem ser usados. Eles tornam mais fácil para os desenvolvedores usar as ferramentas mais adequadas para completar uma tarefa específica, embora você precise encontrar esses componentes por si próprio.


Express é não opinativo. Voce pode inserir qualquer middleware que você goste no manuseio das solicitações em quase qualquer ordem que desejar. Pode estrutar o aplicativo em um arquivo ou em vários, usar qualquer estrutura de pastas dentro do diretório principal. As vezes você sente que você tem diversas opções.

Como a codificação em Express se parece ?

Em um site tradicional baseado em dados, um aplicativo da Web aguarda pedidos HTTP do navegador da Web (ou outro cliente). Quando um pedido é recebido, o aplicativo descreve quais ações são necessárias com base no padrão de URL e possivelmente informações associadas contidas em dados POST ou GET. Dependendo do que é necessário, pode ler ou escrever informações de um banco de dados ou executar outras tarefas necessárias para satisfazer a solicitação. O aplicativo retornará uma resposta ao navegador da Web, criando, de forma dinâmica, uma página HTML para o navegador, exibindo inserindo os dados recuperados em espaços reservados em um modelo HTML.

Express fornece métodos para especificar qual função é chamada quando chega requisição HTTP (GET, POST, SET, etc.) e de rotas e métodos para especificar o mecanismo de modelo ("view") usado, onde o modelo arquivos estão localizados e qual modelo usar para renderizar uma resposta. Você pode usar o middleware Express para adicionar suporte para cookies, sessões e usuários, obtendo parâmetros POST / GET, etc. Você pode usar qualquer mecanismo de banco de dados suportado por Node (o Express não define nenhum comportamento relacionado a banco de dados).

As seções a seguir explicam algumas das coisas comuns que você verá ao trabalhar com o código Express e Node.

Olá Mundo Express

Primeiro, considere o padrão do exemplo do Express Olá Mundo (discutimos cada parte deste abaixo, e nas seções a seguir).

Dica: Se você tiver o Node e o Express já instalados (ou se você os instalar como mostrado no próximo artigo, você pode salvar este código em um arquivo chamado app.js e executá-lo em um prompt de comando, executando node app.js.

var express = require('express');
var app = express();

app.get('/', function(req, res) {
  res.send('Olá Mundo!');
});

app.listen(3000, function() {
  console.log('App de Exemplo escutando na porta 3000!');
});

As duas primeiras linhas require() importam o modulo Express e cria uma aplicação Express. Este objeto que é tradicionalmente nomeado app, tem metodos de roteamento de requisições HTTP, configurações de middleware, renderização de views HTML, registro de engines de templates, e modificando as configurações do aplicativo que controlam como o aplicativo se comporta (por exemplo, o modo de ambiente, se as definições de rota são sensíveis a maiúsculas e minúsculas, etc).

A parte do meio do código (as três linhas que começam com app.get) mostra uma definição de rota. O método app.get() especifica uma função de retorno de chamada que será invocada sempre que exista uma solicitação HTTP GET com um caminho ('/') relativo à raiz do site. A função de retorno de chamada requer uma solicitação e um objeto de resposta como argumentos, e simplesmente chama send() na resposta para retornar a string "Olá Mundo!"

O bloco final inicia o servidor na porta '3000' e imprime um comentário de log no console. Com o servidor em execução, você pode acessar o localhost:3000 em seu navegador para ver o exemplo de resposta retornado.

Importando e criando modulos

Um módulo é uma biblioteca / arquivo de JavaScript que você pode importar para outro código usando a função require() do Node. Express por sí é um módulo, assim como as bibliotecas de middleware e banco de dados que usamos em nossos aplicativos Express.

O código abaixo mostra como importamos um módulo por nome, usando o quadro Express como um exemplo. Primeiro invocamos a função require(), especificando o nome do módulo como uma string ('express'), e chamando o objeto retornado para criar um aplicativo Express. Podemos então acessar as propriedades e funções do objeto da aplicação.

var express = require('express');
var app = express();

Você também pode criar seus próprios módulos que podem ser importados da mesma maneira.

Dica: Você poderá querer criar seus próprios módulos, porque isso permite que você organize seu código em peças gerenciáveis - um aplicativo monolítico de arquivo único é difícil de entender e manter. O uso de módulos também ajuda você a gerenciar seu namespace, pois somente as variáveis que você exporta explicitamente são importadas quando você usa um módulo.

Para tornar os objetos disponíveis fora do módulo, você precisa apenas atribuí-los ao objeto exports. Por Exemplo, o módulo square.js abaixo é um arquivo que exporta os métodos area() e perimeter():

exports.area = function(width) { return width * width; };
exports.perimeter = function(width) { return 4 * width; };

Nós podemos importar este módulo usando require(), e depois ligue para o(s) método(s) exportado(s) como mostrado:

var square = require('./square'); // Aqui nós require() o nome do arquivo sem .js
console.log('The area of a square with a width of 4 is ' + square.area(4));

Nota: Você também pode especificar um caminho absoluto para o módulo (ou um nome, como fizemos inicialmente).

Se você deseja exportar um objeto completo em uma atribuição, em vez de criar uma propriedade de cada vez, atribua-a a module.exports como mostrado abaixo (você também pode fazer isso para tornar a raiz do objeto exportar um construtor ou outra função):

module.exports = {
  area: function(width) {
    return width * width;
  },
       
  perimeter: function(width) {
    return 4 * width;
  }
};

Para muitas outras informações sobre módulos veja Módulos (Node API docs).

Usando APIs assíncronas

O codigo JavaScript frequentemente usa APIs assíncronas em vez de síncronas para operações que podem levar algum tempo para serem concluídas. Uma API síncrona é aquela em que cada operação deve ser concluída antes que a próxima operação possa ser iniciada. Por exemplo, as seguintes funções de log são síncronas e imprimirão o texto no console em ordem (Primeiro, Segundo).

console.log('Primeiro');
console.log('Segundo');
Em contrapartida, uma API assíncrona é aquela em que a API iniciará uma operação e retornará imediatamente (antes da conclusão da operação). Assim que a operação terminar, a API usará algum mecanismo para executar operações adicionais. Por exemplo, o código abaixo imprimirá "Segundo, Primeiro" porque, mesmo que o método setTimeout() seja chamado primeiro e retorna imediatamente, a operação não se completa por vários segundos.
setTimeout(function() {
   console.log('Primeiro');
   }, 3000);
console.log('Segundo');

O uso de APIs assíncronas não bloqueadoras é ainda mais importante no Node do que no navegador, pois o Node é um ambiente de execução orientado por evento único. "single threaded" significa que todos os pedidos para o servidor são executados no mesmo tópico (em vez de serem gerados em processos separados). Este modelo é extremamente eficiente em termos de velocidade e recursos do servidor, mas isso significa que, se qualquer uma das suas funções chamar métodos síncronos que demoram muito para completar, eles bloquearão não apenas a solicitação atual, mas todas as outras solicitações serão tratadas por sua aplicação web.

Há várias maneiras de uma API assíncrona notificar sua aplicação que completou. A maneira mais comum é registrar uma função de retorno de chamada quando você invoca a API assíncrona, que será chamada de volta quando a operação for concluída. Esta é a abordagem usada acima.

Dica: O uso de callbacks pode ser bastante "bagunçado" se você tiver uma sequência de operações assíncronas dependentes que devem ser executados em ordem, porque isto resulta em multiplo níveis de callbacks aninhados. Este problema é comumente conhecido como "inferno de callback" ou "código hadouken". Este problema póde ser reduzido por boas práticas de programação (veja http://callbackhell.com/), usando um módulo como async, ou mesmo se mudar para os recursos do ES6, como Promises.

Dica: Uma convenção comum para Node e Express é usar as devoluções de retorno de erro. Nesta convenção, o primeiro valor em suas funções de retorno de chamada é um valor de erro, enquanto os argumentos subseqüentes contêm dados de sucesso. Há uma boa explicação de por que essa abordagem é útil neste blog: The Node.js Way - Understanding Error-First Callbacks (fredkschott.com).

Criando manipuladores de rotas

No nosso Olá Mundo em Express (veja acima), nós definimos um (callback) função manipuladora de rota para requisição GET HTTP para a raiz do site ('/').

app.get('/', function(req, res) {
  res.send('Olá Mundo');
});

A função de retorno de chamada requer uma solicitação e um objeto de resposta como argumento. Neste caso, o método simplesmente chama send() na resposta para retornar a string "Olá Mundo!" Há uma série de outros métodos de resposta para encerrar o ciclo de solicitação / resposta, por exemplo, você poderia chamar res.json() para enviar uma resposta JSON ou res.sendFile() para enviar um arquivo.

Dica JavaScript: Você pode usar qualquer argumento que você gosta nas funções de retorno de chamada. Quando o retorno de chamada é invocado, o primeiro argumento sempre será o pedido e o segundo sempre será a resposta. Faz sentido nomeá-los de tal forma que você possa identificar o objeto que você está trabalhando no corpo do retorno de chamada.

O Express também fornece métodos para definir manipuladores de rotas para todos as outras requisições HTTP, que são usados principalmente exatamente da mesma maneira: post(), put(), delete(), options(), trace(), copy(), lock(), mkcol(), move(), purge(), propfind(), proppatch(), unlock(), report(), mkactivity(), checkout(), merge(), m-search(), notify(), subscribe(), unsubscribe(), patch(), search(), e connect().

Há um método de roteamento especial, app.all(), que será chamado em resposta a qualquer método HTTP. Isso é usado para carregar funções de middleware em um caminho específico para todos os métodos de solicitação. O exemplo a seguir (da documentação Express) mostra um manipulador que será executado para solicitações para /secret independentemente do verbo HTTP usado (desde que seja suportado pelo módulo http).

app.all('/secret', function(req, res, next) {
  console.log('Acessando a sessão secreta...');
  next(); // passa o controle para o próximo manipulador
});

As rotas permitem combinar padrões de caracteres específicos em um URL e extrair alguns valores do URL e passá-los como parâmetros para o manipulador de rotas (como atributos do objeto de solicitação passado como parâmetro).

Muitas vezes, é útil agrupar manipuladores de rotas para uma determinada parte de um site e acessá-los usando um prefixo de rota comum (por exemplo, um site com um Wiki pode ter todas as rotas relacionadas ao wiki em um arquivo e tê-los acessado com um prefixo de rota de / wiki /). Em Express, isso é alcançado usando o objeto express.Router. Por exemplo, podemos criar nossa rota wiki em um módulo chamado wiki.js e, em seguida, exportar o objeto Router, conforme mostrado abaixo:

// wiki.js - Rotas de Wiki

var express = require('express');
var router = express.Router();

// Home page route
router.get('/', function(req, res) {
  res.send('Wiki home page');
});

// About page route
router.get('/about', function(req, res) {
  res.send('About this wiki');
});

module.exports = router;

Nota: Adicionar rotas ao objeto Router é como adicionar rotas ao objeto app (como mostrado anteriormente).

Para usar o roteador em nosso arquivo de aplicativo principal, então, require() o módulo de rota (wiki.js) e depois use() no aplicativo Express para adicionar o Router ao caminho de gerenciamento de middleware. As duas rotas serão acessíveis a partir de /wiki/ e /wiki/about/.

var wiki = require('./wiki.js');
// ...
app.use('/wiki', wiki);

Vamos mostrar-lhe muito mais sobre trabalhar com rotas e, em particular, sobre o uso do Router, mais tarde, na seção vinculada Rotas e controladores.

Usando middleware

O Middleware é usado extensivamente em aplicativos Express, para que as tarefas ofereçam arquivos estáticos ao tratamento de erros, a compressão de respostas HTTP. Enquanto as funções de rota terminam o ciclo de solicitação-resposta HTTP, retornando alguma resposta ao cliente HTTP, as funções de middleware normalmente executam alguma operação na solicitação ou resposta e, em seguida, ligue para a próxima função na "pilha", que pode ser mais middleware ou uma rota manipulador. A ordem em que o middleware é chamado depende do desenvolvedor do aplicativo.

Nota: O middleware pode executar qualquer operação, executar qualquer código, fazer alterações no objeto de solicitação e resposta, e também pode encerrar o ciclo de solicitação-resposta. Se não terminar o ciclo, ele deve chamar o next() para passar o controle para a próxima função de middleware (ou a solicitação será deixada pendurada).

A maioria dos aplicativos usará middleware de terceiros para simplificar tarefas comuns de desenvolvimento web, como trabalhar com cookies, sessões, autenticação de usuários, acessar dados POST e JSON, log, etc. Você pode encontrar uma lista de pacotes de middleware mantidos pela equipe Express (que também inclui outros pacotes populares de terceiros). Outros pacotes Express estão disponíveis no gerenciador de pacotes do NPM.

Para usar middleware de terceiros, primeiro você precisa instalá-lo em seu aplicativo usando NPM. Por exemplo, para instalar o logger morgan HTTP, você faria isso:

$ npm install morgan

Você pode então chamar use() no objeto do aplicativo Express para adicionar o middleware à pilha:

var express = require('express');
var logger = require('morgan');
var app = express();
app.use(logger('dev'));
...

Nota: O middleware e as funções de roteamento são chamadas na ordem em que são declaradas. Para alguns middleware, a ordem é importante (por exemplo, se o middleware de sessão depende do middleware de cookies, então o manipulador de cookies deve ser adicionado primeiro). É quase sempre o caso em que o middleware é chamado antes de definir rotas, ou seus manipuladores de rotas não terão acesso à funcionalidade adicionada pelo seu middleware.

Você pode escrever suas próprias funções de middleware, e é provável que você tenha que fazê-lo (somente para criar código de manipulação de erro). A única diferença entre uma função de middleware e um retorno de chamada de manipulador de rotas é que as funções de middleware têm um terceiro argumento next, que as funções de middleware devem chamar se não completam o ciclo de solicitação (quando a função de middleware é chamada, isso contém a próxima função que deve ser chamado).

Você pode adicionar uma função de middleware à cadeia de processamento com app.use() ou app.add(), dependendo se você deseja aplicar o middleware a todas as respostas ou a respostas com um verbo HTTP específico (GET, POST, etc. ). Você especifica rotas o mesmo em ambos os casos, embora a rota seja opcional ao chamar app.use().

O exemplo abaixo mostra como você pode adicionar a função middleware usando ambos os métodos e com/sem rota.

var express = require('express');
var app = express();

// Um exemplo de função middleware
var a_middleware_function = function(req, res, next) {
  // ... Fáz alguma operação
  next(); // next() Chama o próximo middleware ou função de rotas
}

// Função adicionada com use() para todas rotas e requisições
app.use(a_middleware_function);

// Função adicionadacom use() para uma rota específica
app.use('/someroute', a_middleware_function);

// função middleware adicionado para uma rota e requisição específica
app.get('/', a_middleware_function);

app.listen(3000);

Dica JavaScript: Acima, declaramos a função de middleware separadamente e, em seguida, configura-a como retorno de chamada. Na nossa função anterior do operador de rotas, declaramos a função de retorno de chamada quando foi utilizada. Em JavaScript, qualquer abordagem é válida.

A documentação Express possui uma documentação muito mais excelente sobre como usar e escrever o middleware Express.

Servindo arquivos estáticos

Você pode usar o middleware express.static para servir arquivos estáticos, incluindo suas imagens, CSS e JavaScript (static() é a única função de middleware que é realmente parte do Express). Por exemplo, você usaria a linha abaixo para exibir imagens, arquivos CSS e arquivos JavaScript de um diretório chamado 'public' no mesmo nível onde você chama o nó:

app.use(express.static('public'));

Todos os arquivos no diretório público são atendidos adicionando o nome do arquivo (relativo ao diretório "público" base) ao URL base. Então, por exemplo:

http://localhost:3000/images/dog.jpg
http://localhost:3000/css/style.css
http://localhost:3000/js/app.js
http://localhost:3000/about.html

Você pode chamar static() várias vezes para atender vários diretórios. Se um arquivo não puder ser encontrado por uma função de middleware, ele simplesmente será transmitido ao middleware subsequente (a ordem em que o middleware é chamado é baseada em sua ordem de declaração).

app.use(express.static('public'));
app.use(express.static('media'));

Você também pode criar um prefixo virtual para seus URL estáticos, em vez de ter os arquivos adicionados ao URL base. Por exemplo, aqui especificamos um caminho de montagem para que os arquivos sejam carregados com o prefixo "/media":

app.use('/media', express.static('public'));

Agora, você pode carregar os arquivos que estão no diretório public a partir do prefixo de caminho /media.

http://localhost:3000/media/images/dog.jpg
http://localhost:3000/media/video/cat.mp4
http://localhost:3000/media/cry.mp3

Para obter mais informações, consulte Servindo arquivos estáticos no Express.

Erros de manipulação

Os erros são tratados por uma ou mais funções de middleware especiais que possuem quatro argumentos, em vez dos três habituais: (err, req, res, next). Por exemplo:

app.use(function(err, req, res, next) {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

Isso pode retornar qualquer conteúdo exigido, mas deve ser chamado depois de todas as outras chamadas app.use() e rotas para que sejam o último middleware no processo de solicitação de pedidos!

Express vem com um manipulador de erros embutido, que cuida de todos os erros que podem ser encontrados no aplicativo. Essa função de middleware de gerenciamento de erros padrão é adicionada no final da pilha de funções do middleware. Se você passar um erro para next() e você não lidar com isso em um manipulador de erro, ele será tratado pelo manipulador de erros incorporado; o erro será gravado no cliente com o rastreamento da pilha.

Nota: O rastreamento da pilha não está incluído no ambiente de produção. Para executá-lo no modo de produção, você precisa configurar a variável de ambiente NODE_ENV para 'production'.

Nota: HTTP404 e outros códigos de status de "erro" não são tratados como erros. Se você quiser lidar com isso, você pode adicionar uma função de middleware para fazê-lo. Para mais informações, consulte as FAQ.

Para obter mais informações, consulte Gerenciamento de erros (Express docs).

Usando Banco de Dados

Aplicativos Express podem usar qualquer mecanismo de banco de dados suportado pelo Node (o Expresso em si não define nenhum comportamento / requisitos adicionais específicos para gerenciamento de banco de dados). Existem muitas opções, incluindo PostgreSQL, MySQL, Redis, SQLite, MongoDB, etc.

Para usá-los, você deve primeiro instalar o driver do banco de dados usando NPM. Por exemplo, para instalar o driver para o popular NoSQL MongoDB você usaria o comando:

$ npm install mongodb

O próprio banco de dados pode ser instalado localmente ou em um servidor em nuvem. No seu código Express, você precisa do driver, conecte-se ao banco de dados e execute as operações criar, ler, atualizar e excluir (CRUD). O exemplo abaixo (da documentação Express) mostra como você pode encontrar registros de "mamíferos" usando MongoDB.

var MongoClient = require('mongodb').MongoClient;

MongoClient.connect('mongodb://localhost:27017/animals', function(err, db) {
  if (err) throw err;

  db.collection('mammals').find().toArray(function (err, result) {
    if (err) throw err;

    console.log(result);
  });
});

Outra abordagem popular é acessar seu banco de dados indiretamente, através de um Object Relational Mapper ("ORM"). Nesta abordagem, você define seus dados como "objetos" ou "modelos" e o ORM mapeia estes para o formato de banco de dados subjacente. Esta abordagem tem o benefício de que, como desenvolvedor, você pode continuar a pensar em termos de objetos JavaScript, em vez de semântica de banco de dados, e que existe um local óbvio para realizar a validação e verificação de dados recebidos. Falaremos mais sobre bancos de dados em um artigo posterior.

Para obter mais informações, consulte integração com banco de dados (documentos express).

Renderizando dados (views)

Os mecanismos de modelo (referidos como "view engines" por Express) permitem que você especifique a estrutura de um documento de saída em um modelo, usando marcadores de posição para os dados que serão preenchidos quando uma página for gerada. Os modelos geralmente são usados para criar HTML, mas também podem criar outros tipos de documentos. Express tem suporte para uma série de mecanismos de modelos, e há uma comparação útil dos motores mais populares aqui: Comparing JavaScript Templating Engines: Jade, Mustache, Dust and More.

No seu código de configurações do aplicativo você configurou o mecanismo do modelo para usar e o local onde Express deve procurar modelos usando as configurações 'visualizações' e 'visualizar mecanismos', conforme mostrado abaixo (você também terá que instalar o pacote que contém a biblioteca do modelo também !)

var express = require('express');
var app = express();

//  Definir o diretório para conter os modelos ('views') 
app.set('views', path.join(__dirname, 'views'));

// Definir o motor de visualização para usar, neste caso 'some_template_engine_name' 
app.set('view engine', 'some_template_engine_name');

A aparência do modelo dependerá do mecanismo que você usa. Supondo que você tenha um arquivo de modelo chamado "índice. <Template_extension>" que contenha espaços reservados para variáveis de dados denominadas 'título' e 'mensagem', você chamaria Response.render() em uma função de roteador de rotas para criar e enviar a resposta HTML :

app.get('/', function(req, res) {
  res.render('index', { title: 'About dogs', message: 'Dogs rock!' });
});

Para obter mais informações, consulte usando motores de modelo com Express (Express docs).

Estrutura de Arquivos

Express não faz suposições em termos de estrutura ou quais os componentes que você usa. Rotas, visualizações, arquivos estáticos e outra lógica específica da aplicação podem viver em qualquer número de arquivos com qualquer estrutura de diretório. Embora seja perfeitamente possível ter todo o aplicativo Express em um único arquivo, geralmente faz sentido dividir seu aplicativo em arquivos com base em função (por exemplo, gerenciamento de contas, blogs, fóruns de discussão) e domínio de problema arquitetônico (por exemplo, modelo, exibição ou controlador se você está usando uma arquitetura MVC).

Em um tópico posterior, usaremos o Express Application Generator, que cria um esqueleto de aplicativo modular que podemos estender facilmente para criar aplicativos da web.

Sumario

Parabéns, você completou o primeiro passo em sua viagem Express/Node! Agora você deve entender os principais benefícios do Express e Node, e aproximadamente o que as principais partes de um aplicativo Express podem parecer (rotas, middleware, tratamento de erros e código de modelo). Você também deve entender isso com o Express sendo um quadro não organizado, a maneira como você puxa essas partes e as bibliotecas que você usa são em grande parte com você!

Claro que Express é deliberadamente uma estrutura de aplicativos web muito leve, tanto seu benefício e potencial vem de bibliotecas e recursos de terceiros. Examinaremos aqueles com mais detalhes nos seguintes artigos. No nosso próximo artigo, vamos analisar a criação de um ambiente de desenvolvimento de Node, para que você possa começar a ver algum código Express em ação.

Veja também

Próximos módulos

Etiquetas do documento e colaboradores

 Colaboradores desta página: TecladistaProd
 Última atualização por: TecladistaProd,