# 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/it/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

## In che modo devo strutturare l’applicazione?

Non esiste una risposta definitiva a questa domanda. La risposta dipende
dalla scalabilità dell’applicazione e dal team coinvolto. Per essere molto flessibile,
Express non fornisce molte indicazioni in termini di struttura.

Le route e altre logiche specifiche dell’applicazione possono essere presenti in molti file,
in qualsiasi struttura di directory desiderata. Visualizzare i seguenti
esempi:

- [Elenchi route](https://github.com/expressjs/express/blob/4.13.1/examples/route-separation/index.js#L32-47)
- [Definizione route](https://github.com/expressjs/express/blob/4.13.1/examples/route-map/index.js#L52-L66)
- [Controllori stile MVC](https://github.com/expressjs/express/tree/master/examples/mvc)

Inoltre, ci sono delle estensioni di terze parti per Express, le quali semplificano alcuni di questi modelli:

- [Routing pieno di risorse](https://github.com/expressjs/express-resource)

## In che modo è possibile definire i modelli?

Express non ha nessuna nozione di database. Questo concetto viene lasciato a moduli
Node di terzi, consentendo di interfacciarsi
con quasi qualsiasi database.

Consultare [LoopBack](http://loopback.io) per un framework basato su Express incentrato sui modelli.

## In che modo è possibile autenticare gli utenti?

L’autenticazione è un’altra area categorica in cui non si
avventura Express. È possibile utilizzare qualsiasi schema di autenticazione desiderato.
Per uno schema nome utente / password semplice, consultare [questo esempio](https://github.com/expressjs/express/tree/master/examples/auth).

## Quale motore di template supporta Express?

Express supporta qualsiasi motore di template conforme alla sigla `(path, locals, callback)`.
Per normalizzare le interfacce del motore di template e la memorizzazione in cache, consultare il progetto
[consolidate.js](https://github.com/visionmedia/consolidate.js)
per il supporto. I motori di template potrebbero ancora non supportare Express.

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

## In che modo è possibile gestire le risposte 404?

In Express, le risposte 404 non sono il risultato di un errore, pertanto
il middleware di gestione degli errori non le individuerà. Questo accade perché
una risposta 404 indica semplicemente l’assenza di ulteriori operazioni da effettuare;
in altre parole, Express ha eseguito tutte le funzioni middleware e route
e non ha riscontrato nessuna risposta da parte di quest’ultimi. L’unica cosa da fare è aggiungere
una funzione middleware alla parte finale dello stack (sotto tutte le altre funzioni)
per gestire una risposta 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.

## In che modo è possibile impostare un gestore degli errori?

È possibile definire il middleware di gestione degli errori nello stesso modo in cui si definisce qualsiasi altro middleware,
ad eccezione delle funzioni di gestione degli errori che hanno quattro argomenti invece di tre; nello specifico la firma `(err, req, res, next)`:

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

Per ulteriori informazioni, consultare [Gestione degli errori](https://expressjs.com/it/guide/error-handling.html).

## In che modo è possibile eseguire il rendering dell’HTML normale?

Non è necessario farlo! Non è necessario “eseguire il rendering” dell’HTML con la funzione `res.render()`.
Se si dispone di un file specifico, utilizzare la funzione `res.sendFile()`.
Se si stanno gestendo molti asset da una directory, utilizzare la funzione middleware
`express.static()`.

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

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

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

---

# Programma di creazione applicazione Express

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

# Programma di creazione applicazione Express

Utilizzare lo strumento di creazione dell’applicazione, `express`, per creare velocemente una struttura dell’applicazione.

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
```

Visualizzare le opzioni del comando con l’opzione `-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
```

Ad esempio, quanto segue crea un’applicazione Express denominata *myapp* nella directory di lavoro corrente: The app will be created in a folder named *myapp* in the current working directory and the view engine will be set to [Pug](https://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
```

Successivamente, installare le dipendenze:

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

Su Windows, utilizzare questo comando:

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

Su MacOS o Linux, eseguire l’applicazione con il seguente comando:

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

On Windows PowerShell, use this command:

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

Quindi caricare `http://localhost:3000/` sul browser per accedere all’applicazione.

L’applicazione creata dispone della seguente struttura per la directory:

```
.
├── 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 struttura dell’applicazione creata dal programma di creazione è solo uno dei tanti modi disponibili per creare la struttura delle applicazioni Express. È possibile utilizzare questa struttura o modificarla a seconda delle proprie necessità.

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

---

# Esempio di Hello world

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

# Esempio di Hello world

In sostanza, questa sarà l’applicazione Express più semplice che è possibile creare. È un’applicazione a singolo file — e *non* quello che si ottiene se si utilizza il [Programma di creazione Express](https://expressjs.com/it/starter/generator.html), il quale crea le fondamenta per un’applicazione completa con molti file JavaScript, template Jade e sotto directory per diversi scopi.

```
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’applicazione avvia un server e resta in ascolto sulla porta 3000 per le connessioni. L’applicazione risponde con “Hello World!” per le richieste
all’URL root (`/`) o *route*. Per qualsiasi altro percorso, risponderà con il messaggio **404 Non trovato**.

### Running Locally

Per prima cosa creare una directory denominata `myapp`, passare a quest’ultima ed eseguire `npm init`. Quindi installare `express` come dipendenza, come descritto nella [Guida all’installazione](https://expressjs.com/it/starter/installing.html).

Nella directory `myapp`, creare un file denominato `app.js` e aggiungere il seguente codice:

I valori `req` (richiesta) e `res` (risposta) sono esattamente gli stessi oggetti forniti da Node, quindi è possibile richiamare
`req.pipe()`, `req.on('data', callback)` e qualsiasi cosa che si farebbe senza il coinvolgimento di Express.

Eseguire l’applicazione con il seguente comando:

```
$ node app.js
```

Successivamente, caricare [http://localhost:3000/](http://localhost:3000/) su un browser per visualizzare l’output.

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

---

# Installazione

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

# Installazione

Presumendo che sia stato già installato [Node.js](https://nodejs.org/), creare una directory in cui conservare l’applicazione e renderla la directory di lavoro.

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

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

Utilizzare il comando `npm init` per creare un file `package.json` per l’applicazione.
Per ulteriori informazioni sul funzionamento di `package.json`, consultare [Informazioni specifiche sulla gestione di package.json di npm](https://docs.npmjs.com/files/package.json).

```
$ npm init
```

Questo comando richiede di specificare alcune informazioni, ad esempio il nome e la versione dell’applicazione.
Per il momento, è possibile semplicemente premere il tasto INVIO per accettare i valori di default per molti di esse, ad eccezione di quanto segue:

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

Immettere `app.js` o qualsiasi altra cosa come nome del file principale. Se si desidera che sia `index.js`, premere il tasto INVIO per accettare il nome file predefinito consigliato.

Quindi installare Express nella directory `myapp` e salvarlo nell’elenco delle dipendenze. Ad esempio:

```
$ npm install express
```

Per installare momentaneamente Express e non aggiungerlo all’elenco di dipendenze, omettere l’opzione `--save`:

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

I moduli Node installati con l’opzione `--save` vengono aggiunti all’elenco `dependencies` nel file `package.json`. Successivamente, l’esecuzione di `npm install` nella directory `app` installerà automaticamente i moduli nell’elenco di dipendenze.

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

---

# Gestione dei file statici in Express

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

# Gestione dei file statici in Express

Per gestire i file statici, quali immagini, file CSS e file JavaScript, utilizzare la funzione middleware integrata `express.static` in 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/it/5x/api.html#express.static).

Ad esempio, utilizzare il seguente codice per gestire le immagini, i file CSS e i file JavaScript nella directory denominata `public`:

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

Ora, è possibile caricare i file che si trovano nella directory `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 ricerca i file relativi alla directory statica, pertanto il nome della directory statica non è parte dell'URL.

Per utilizzare più directory di asset statiche, richiamare la funzione middleware `express.static` più volte:

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

Express ricerca i file nell’ordine in cui sono state impostate le directory statiche con la funzione middleware `express.static`.

Note

For best results, [use a reverse proxy](https://expressjs.com/it/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/it/5x/api.html#app.use) for the static directory, as shown below:

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

Ora, è possibile caricare i file che si trovano nella directory `public` dal prefisso del percorso `/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
```

Tuttavia, il percorso fornito per la funzione `express.static` è relativo alla directory dalla quale è possibile avviare il processo `node`. Se si esegue l’applicazione express da un’altra directory, è preferibile utilizzare il percorso assoluto della directory che si desidera gestire:

```
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/it/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/it/support/index.md          )
