# Express examples and more

# Express examples

> Explore a collection of Express.js application examples covering various use cases, integrations, and advanced configurations to help you learn and build your projects.

# Express examples

This page contains list of examples using Express.

- [auth](https://github.com/expressjs/express/tree/master/examples/auth) - Authentication with login and password
- [content-negotiation](https://github.com/expressjs/express/tree/master/examples/content-negotiation) - HTTP content negotiation
- [cookie-sessions](https://github.com/expressjs/express/tree/master/examples/cookie-sessions) - Working with cookie-based sessions
- [cookies](https://github.com/expressjs/express/tree/master/examples/cookies) - Working with cookies
- [downloads](https://github.com/expressjs/express/tree/master/examples/downloads) - Transferring files to client
- [ejs](https://github.com/expressjs/express/tree/master/examples/ejs) - Working with Embedded JavaScript templating (ejs)
- [error-pages](https://github.com/expressjs/express/tree/master/examples/error-pages) - Creating error pages
- [error](https://github.com/expressjs/express/tree/master/examples/error) - Working with error middleware
- [hello-world](https://github.com/expressjs/express/tree/master/examples/hello-world) - Simple request handler
- [markdown](https://github.com/expressjs/express/tree/master/examples/markdown) - Markdown as template engine
- [multi-router](https://github.com/expressjs/express/tree/master/examples/multi-router) - Working with multiple Express routers
- [mvc](https://github.com/expressjs/express/tree/master/examples/mvc) - MVC-style controllers
- [online](https://github.com/expressjs/express/tree/master/examples/online) - Tracking online user activity with `online` and `redis` packages
- [params](https://github.com/expressjs/express/tree/master/examples/params) - Working with route parameters
- [resource](https://github.com/expressjs/express/tree/master/examples/resource) - Multiple HTTP operations on the same resource
- [route-map](https://github.com/expressjs/express/tree/master/examples/route-map) - Organizing routes using a map
- [route-middleware](https://github.com/expressjs/express/tree/master/examples/route-middleware) - Working with route middleware
- [route-separation](https://github.com/expressjs/express/tree/master/examples/route-separation) - Organizing routes per each resource
- [search](https://github.com/expressjs/express/tree/master/examples/search) - Search API
- [session](https://github.com/expressjs/express/tree/master/examples/session) - User sessions
- [static-files](https://github.com/expressjs/express/tree/master/examples/static-files) - Serving static files
- [vhost](https://github.com/expressjs/express/tree/master/examples/vhost) - Working with virtual hosts
- [view-constructor](https://github.com/expressjs/express/tree/master/examples/view-constructor) - Rendering views dynamically
- [view-locals](https://github.com/expressjs/express/tree/master/examples/view-locals) - Saving data in request object between middleware calls
- [web-service](https://github.com/expressjs/express/tree/master/examples/web-service) - Simple API service

## Additional examples

These are some additional examples with more extensive integrations.

Warning

This information refers to third-party sites, products, or modules that are not maintained by the Expressjs team. Listing here does not constitute an endorsement or recommendation from the Expressjs project team.

- [prisma-fullstack](https://github.com/prisma/prisma-examples/tree/latest/pulse/fullstack-simple-chat) - Fullstack app with Express and Next.js using [Prisma](https://www.npmjs.com/package/prisma) as an ORM
- [prisma-rest-api-ts](https://github.com/prisma/prisma-examples/tree/latest/orm/express) - REST API with Express in TypeScript using [Prisma](https://www.npmjs.com/package/prisma) as an ORM

  [Edit this page](https://github.com/expressjs/expressjs.com/edit/gh-pages/fr/starter/examples.md          )

---

# FAQ

> Find answers to frequently asked questions about Express.js, including topics on application structure, models, authentication, template engines, error handling, and more.

# FAQ

## Comment puis-je structurer mon application ?

Il n’existe pas de réponse définitive à cette question. La réponse dépend
de l’échelle de votre application et de l’équipe qui est impliquée. Pour être aussi
flexible que possible, Express ne fait aucune supposition en terme de structure.

Les routes et la logique propre à l’application peuvent être opérationnelles dans autant de fichiers
que vous le souhaitez, et dans les structures de répertoire que vous préférez. Pour plus d’inspiration,
consultez les exemples suivants :

- [Listes de routes](https://github.com/expressjs/express/blob/4.13.1/examples/route-separation/index.js#L32-47)
- [Feuille de route](https://github.com/expressjs/express/blob/4.13.1/examples/route-map/index.js#L52-L66)
- [Contrôleurs de style MVC](https://github.com/expressjs/express/tree/master/examples/mvc)

Il existe aussi des extensions tiers pour Express, permettant de simplifier certains de ces modèles :

- [Routage ingénieux](https://github.com/expressjs/express-resource)

## Comment puis-je définir des modèles ?

Express ne connaît pas les bases de données. Ce concept est
laissé aux modules Node tiers, vous permettant ainsi
d’interagir avec quasiment toutes les bases de données.

Voir [LoopBack](http://loopback.io) pour obtenir une infrastructure basée sur Express et centrée autour de modèles.

## Comment puis-je authentifier des utilisateurs ?

L’authentification est une autre partie complexe dans laquelle Express
ne s’aventure pas. Vous pouvez utiliser tous les schémas d’authentification que vous voulez.
Pour un schéma simple de type nom d’utilisateur/mot de passe, voir [cet exemple](https://github.com/expressjs/express/tree/master/examples/auth).

## Quels moteurs de modèles Express prend-il en charge ?

Express prend en charge tous les moteurs de modèles conformes à la signature `(path, locals, callback)`.
Pour normaliser les interfaces de moteur de modèles et la mise en cache, voir le
projet [consolidate.js](https://github.com/visionmedia/consolidate.js)
pour la prise en charge. Des moteurs de modèles non répertoriés peuvent encore prendre en charge la signature Express.

For more information, see [Using template engines with Express](https://expressjs.com/fr/guide/using-template-engines.html).

## Comment puis-je gérer des réponses 404 ?

Dans Express, étant donné que les réponses 404 ne sont pas le résultat d’une erreur,
le middleware de traitement d’erreurs ne les traite pas. Ce comportement est
dû au fait qu’une réponse 404 indique simplement l’absence d’un travail supplémentaire à effectuer. En d’autres termes, Express a exécuté toutes les routes et fonctions middleware,
et aucune n’a répondu. Tout ce que vous avez à faire est
d’ajouter une fonction middleware à la toute fin de la pile (en-dessous de toutes les autres fonctions)
pour gérer une réponse 404 :

```
app.use((req, res, next) => {
  res.status(404).send("Sorry can't find that!")
})
```

Add routes dynamically at runtime on an instance of `express.Router()`
so the routes are not superseded by a middleware function.

## Comment puis-je configurer un gestionnaire d’erreurs ?

Vous pouvez définir un middleware de traitement d’erreurs de la même façon qu’un autre middleware,
à l’exception qu’il faudra 4 arguments au lieu de 3 ; et plus particulièrement avec la signature `(err, req, res, next)` :

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

Pour plus d’informations, voir [Traitement d’erreurs](https://expressjs.com/fr/guide/error-handling.html).

## Comment puis-je générer un fichier HTML simple ?

Vous ne pouvez pas ! Il n’est pas nécessaire de “générer” un fichier HTML avec la fonction `res.render()`.
Si vous avez un fichier spécifique, utilisez la fonction `res.sendFile()`.
Si vous utilisez plusieurs actifs d’un répertoire, utilisez la fonction middleware `express.static()`.

## What version of Node.js does Express require?

- [Express 4.x](https://expressjs.com/fr/4x/api.html) requires Node.js 0.10 or higher.
- [Express 5.x](https://expressjs.com/fr/5x/api.html) requires Node.js 18 or higher.

  [Edit this page](https://github.com/expressjs/expressjs.com/edit/gh-pages/fr/starter/faq.md          )

---

# Générateur d’applications Express

> Learn how to use the Express application generator tool to quickly create a skeleton for your Express.js applications, streamlining setup and configuration.

# Générateur d’applications Express

Utilisez l’outil de générateur d’applications, `express`, pour créer rapidement un squelette d’application.

You can run the application generator with the `npx` command (available in Node.js 8.2.0).

```
$ npx express-generator
```

For earlier Node versions, install the application generator as a global npm package and then launch it:

```
$ npm install -g express-generator
$ express
```

Affichez les options de commande à l’aide de l’option `-h` :

```
$ express -h

  Usage: express [options] [dir]

  Options:

    -h, --help          output usage information
        --version       output the version number
    -e, --ejs           add ejs engine support
        --hbs           add handlebars engine support
        --pug           add pug engine support
    -H, --hogan         add hogan.js engine support
        --no-view       generate without view engine
    -v, --view <engine> add view <engine> support (ejs|hbs|hjs|jade|pug|twig|vash) (defaults to jade)
    -c, --css <engine>  add stylesheet <engine> support (less|stylus|compass|sass) (defaults to plain css)
        --git           add .gitignore
    -f, --force         force on non-empty directory
```

Par exemple, ce code crée une application Express nomée *myapp*. L’application sera crée dans le dossier *myapp*, lui meme placé dans le repertoir de travail courant. Le moteur de vue sera configuré avec [Pug](https://expressjs.com/fr/starter/pugjs.org):

```
$ express --view=pug myapp

   create : myapp
   create : myapp/package.json
   create : myapp/app.js
   create : myapp/public
   create : myapp/public/javascripts
   create : myapp/public/images
   create : myapp/routes
   create : myapp/routes/index.js
   create : myapp/routes/users.js
   create : myapp/public/stylesheets
   create : myapp/public/stylesheets/style.css
   create : myapp/views
   create : myapp/views/index.pug
   create : myapp/views/layout.pug
   create : myapp/views/error.pug
   create : myapp/bin
   create : myapp/bin/www
```

Ensuite, installez les dépendances :

```
$ cd myapp
$ npm install
```

Sous MacOS ou Linux, exécutez l’application à l’aide de la commande suivante :

```
$ DEBUG=myapp:* npm start
```

Sous Windows, utilisez la commande suivante :

```
> set DEBUG=myapp:* & npm start
```

Installez `express` à l’aide de la commande suivante :

```
PS> $env:DEBUG='myapp:*'; npm start
```

Ensuite, chargez ‘http://hôte_local:3000/’ dans votre navigateur pour accéder à l’application.

L’application générée possède la structure de répertoire suivante :

```
.
├── app.js
├── bin
│   └── www
├── package.json
├── public
│   ├── images
│   ├── javascripts
│   └── stylesheets
│       └── style.css
├── routes
│   ├── index.js
│   └── users.js
└── views
    ├── error.pug
    ├── index.pug
    └── layout.pug

7 directories, 9 files
```

La structure d’application créée par le générateur est l’une des nombreuses manières possibles de structurer les applications Express. Vous avez toute latitude pour l’utiliser ou la modifier en fonction de vos besoins.

   [Edit this page](https://github.com/expressjs/expressjs.com/edit/gh-pages/fr/starter/generator.md          )

---

# Exemple Hello world

> Get started with Express.js by building a simple 'Hello World' application, demonstrating the basic setup and server creation for beginners.

# Exemple Hello world

Il s’agit de l’application Express la plus simple que vous puissiez créer. Cette application ne contient qu’un seul fichier, c’est-à-dire *tout l’inverse* de ce que vous obtiendriez avec le
[générateur Express](https://expressjs.com/fr/starter/generator.html), qui crée l’échafaudage d’une application entière, avec des fichiers JavaScript, des modèles [Pug](https://expressjs.com/fr/starter/pugjs.org) et des sous-répertoires pour divers motifs.

```
const express = require('express')
const app = express()
const port = 3000

app.get('/', (req, res) => {
  res.send('Hello World!')
})

app.listen(port, () => {
  console.log(`Example app listening on port ${port}`)
})
```

L’application démarre un serveur et écoute le port 3000 à la recherche de connexions. L’application répond “Hello World!” aux demandes adressées
à l’URL racine (`/`) ou à la *route* racine. Pour tous les autres chemins d’accès, elle répondra par **404 Not Found**.

### Running Locally

Premièrement, créez un répertoire appelé `myapp`, rendez-vous dedans et exécutez la commande `npm init`. Ensuite, installez `express` en tant que dépendance en suivant les instructions du [guide d’installation](https://expressjs.com/fr/starter/installing.html).

Dans le répertoire `myapp`, créez un fichier appelé `app.js` et ajoutez le code suivant :

Les objets `req` (demande) et `res` (réponse) sont exactement les mêmes que ceux que Node fournit, vous pouvez donc appeler
`req.pipe()`, `req.on('data', callback)` et tout autre objet sans recourir à Express.

Exécutez l’application avec la commande suivante :

```
$ node app.js
```

Puis chargez [http://localhost:3000/](http://localhost:3000/) dans un navigateur pour consulter le résultat.

  [Edit this page](https://github.com/expressjs/expressjs.com/edit/gh-pages/fr/starter/hello-world.md          )

---

# Installation

> Learn how to install Express.js in your Node.js environment, including setting up your project directory and managing dependencies with npm.

# Installation

En supposant que [Node.js](https://nodejs.org/) est déjà installé, créez un répertoire pour héberger votre application et faites-en votre répertoire de travail.

- [Express 4.x](https://expressjs.com/fr/4x/api.html) requires Node.js 0.10 or higher.
- [Express 5.x](https://expressjs.com/fr/5x/api.html) requires Node.js 18 or higher.

```
$ mkdir myapp
$ cd myapp
```

Utilisez la commande `npm init` afin de créer un fichier `package.json` pour votre application.
Pour plus d’informations sur le fonctionnement du fichier `package.json`, voir [Specifics of npm’s package.json handling](https://docs.npmjs.com/files/package.json).

```
$ npm init
```

Cette commande vous invite à fournir un certain nombre d’informations, telles que le nom et la version de votre application.
Pour le moment, vous pouvez simplement appuyer sur la touche RETURN pour accepter les valeurs par défaut, à l’exception de ce qui suit :

```
entry point: (index.js)
```

Entrez `app.js` ou un nom de votre choix pour le fichier principal. Si vous souhaitez que le nom soit `index.js`, appuyez sur la touche RETURN pour accepter le nom de fichier par défaut suggéré.

Installez ensuite Express dans le répertoire `myapp`, puis sauvegardez-le dans la liste des dépendances. Par exemple :

```
$ npm install express
```

Pour installer Express de façon temporaire et ne pas l’ajouter à la liste des dépendances, omettez l’option `--save` :

```
$ npm install express --no-save
```

` ajoute automatiquement le module Node.js à la liste des dépendances. Par la suite, l’exécution de `npm install` dans le répertoire de l’application installera automatiquement les modules présents dans la liste des dépendances.

   [Edit this page](https://github.com/expressjs/expressjs.com/edit/gh-pages/fr/starter/installing.md          )

---

# Servir des fichiers statiques dans Express

> Understand how to serve static files like images, CSS, and JavaScript in Express.js applications using the built-in 'static' middleware.

# Servir des fichiers statiques dans Express

Pour servir des fichiers statiques tels que les images, les
fichiers CSS et les fichiers JavaScript, utilisez la fonction de
logiciel intermédiaire intégré `express.static` dans Express.

The function signature is:

```
express.static(root, [options])
```

The `root` argument specifies the root directory from which to serve static assets.
For more information on the `options` argument, see [express.static](https://expressjs.com/fr/5x/api.html#express.static).

Par exemple, utilisez le code suivant pour
servir des images, des fichiers CSS et des fichiers JavaScript dans
un répertoire nommé `public` :

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

Maintenant, vous pouvez charger les fichiers qui sont dans le
répertoire `public` :

```
http://localhost:3000/images/kitten.jpg
http://localhost:3000/css/style.css
http://localhost:3000/js/app.js
http://localhost:3000/images/bg.png
http://localhost:3000/hello.html
```

Express recherche les fichiers relatifs au répertoire statique, donc
le nom du répertoire statique ne fait pas partie de l'URL.

Pour utiliser plusieurs répertoires statiques actifs,
utilisez la fonction middleware
`express.static` plusieurs fois :

```
app.use(express.static('public'))
app.use(express.static('files'))
```

Express recherche les fichiers dans l’ordre dans lequel vous
avez établi les répertoires statiques avec la fonction middleware `express.static`.

Note

For best results, [use a reverse proxy](https://expressjs.com/fr/advanced/best-practice-performance.html#use-a-reverse-proxy) cache to improve performance of serving static assets.

To create a virtual path prefix (where the path does not actually exist in the file system) for files that are served by the `express.static` function, [specify a mount path](https://expressjs.com/fr/5x/api.html#app.use) for the static directory, as shown below:

```
app.use('/static', express.static('public'))
```

Maintenant, vous pouvez charger les fichiers qui sont dans le
répertoire `public` à partir du préfixe de chemin
d’accès `/static`.

```
http://localhost:3000/static/images/kitten.jpg
http://localhost:3000/static/css/style.css
http://localhost:3000/static/js/app.js
http://localhost:3000/static/images/bg.png
http://localhost:3000/static/hello.html
```

Cependant, le chemin d’accès que vous fournissez à la
fonction `express.static` est en rapport avec
le répertoire à partir duquel vous lancez votre processus `node`. Si
vous exécutez l’application express à partir d’un autre répertoire, il
est plus sûr d’utiliser le chemin d’accès absolu que vous voulez
servir :

```
const path = require('path')
app.use('/static', express.static(path.join(__dirname, 'public')))
```

For more details about the `serve-static` function and its options, see  [serve-static](https://expressjs.com/resources/middleware/serve-static.html).

  [Edit this page](https://github.com/expressjs/expressjs.com/edit/gh-pages/fr/starter/static-files.md          )

---

# Version Support

> Find information about the support schedule for different Express.js versions, including which versions are currently maintained and end-of-life policies.

# Version Support

Only the latest version of any given major release line is supported.

Versions that are EOL (end-of-life) *may* receive updates for critical security vulnerabilities, but the Express team offers no guarantee and does not plan to address or release fixes for any issues found.

| Major Version | Minimum Node.js Version | Support Start Date | Support End Date |
| --- | --- | --- | --- |
| v5.x | 18 | September 2024 | ongoing |
| v4.x | 0.10.0 | April 2014 | ongoing |
| v3.x | 0.8.0 | October 2012 | July 2015 |
| v2.x | 0.4.1 | March 2011 | July 2012 |
| v1.x | 0.2.0 | December 2010 | March 2011 |
| v0.14.x | 0.1.98 | December 2010 | December 2010 |

## Commercial Support Options

If you are unable to update to a supported version of Express, please contact one of our partners to receive security updates:

- [HeroDevs Never-Ending Support](http://www.herodevs.com/support/express-nes?utm_source=expressjs&utm_medium=link&utm_campaign=express_eol_page)

 [Edit this page](https://github.com/expressjs/expressjs.com/edit/gh-pages/fr/support/index.md          )
