amirho/expressjs.com
1
0
Fork 0
mirror of https://github.com/expressjs/expressjs.com.git synced 2026-02-22 03:51:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove prism (#1746)

Browse Source
This commit is contained in:
Sebastian Beltran
2025-02-05 18:23:03 -05:00
committed by GitHub
parent fabc75a85a
commit 68b4840949
298 changed files with 7757 additions and 9326 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
_config.yml
View File

@@ -11,16 +11,19 @@ defaults:
lang: en
# Build settings
markdown: kramdown
plugins:
- jekyll-redirect-from
highlighter: rouge
# library used for syntax highlighting
markdown: kramdown
kramdown:
math_engine: mathjax
input: GFM
hard_wrap: false
syntax_highlighter_opts:
disable : true
syntax_highlighter: rouge
exclude:
- [uk/CHANGELOG.md]

4
_includes/head.html
View File

@@ -7,7 +7,8 @@
<script data-cfasync="false" src="/js/theme.js"></script>
<link rel="stylesheet" href="/css/dark-theme.css?_={{ site.time | date: '%s' }}">
<link rel="stylesheet" href="/css/style.css?_={{ site.time | date: '%s' }}">
<link rel="stylesheet" href="/css/prism.css">
<link rel="stylesheet" href="/css/sintax.css?_={{ site.time | date: '%s' }}">
<link rel="stylesheet" href="/css/font-awesome.min.css">
<link rel="stylesheet" href="//fonts.googleapis.com/css?family=Open+Sans:300,400,600,700&amp;amp;subset=latin,latin-ext">
<link rel="stylesheet" href="/css/{{ page.lang }}.css">
@@ -44,7 +45,6 @@
<script data-cfasync="false" src="//ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<script data-cfasync="false" src="/js/app.js"></script>
<script data-cfasync="false" defer src="/js/menu.js"></script>
<script data-cfasync="false" src="/js/prism.js"></script>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/docsearch.js@2/dist/cdn/docsearch.min.css" />
</head>

10
css/dark-theme.css
View File

@@ -151,9 +151,6 @@ html.dark-mode div#overlay {
opacity: 0.5;
}
html.dark-mode .doc-box.doc-info pre.language-javascript {
background: var(--main_dark_bg);
}
html.dark-mode h1,
html.dark-mode h2,
@@ -163,9 +160,6 @@ html.dark-mode em,
html.dark-mode strong {
color: var(--dark_main_text);
}
html.dark-mode pre {
background: var(--second_dark_bg);
}
/* index.html */
html.dark-mode #description .express > a {
color: var(--dark_main_text);
@@ -284,7 +278,3 @@ html.dark-mode #blog-side-menu-container h3 a{
html.dark-mode #blog-side-menu > li > a{
color: var(--dark_inner_text);
}
html.dark-mode pre code {
background-color: inherit;
}

142
css/prism.css
View File

@@ -1,142 +0,0 @@
/* http://prismjs.com/download.html?themes=prism&languages=markup+css+clike+javascript+bash */
/**
* prism.js default theme for JavaScript, CSS and HTML
* Based on dabblet (http://dabblet.com)
* @author Lea Verou
*/
code[class*="language-"],
pre[class*="language-"] {
color: black;
text-shadow: 0 1px white;
font-family: Consolas, Monaco, 'Andale Mono', monospace;
direction: ltr;
text-align: left;
white-space: pre;
word-spacing: normal;
word-break: normal;
line-height: 1.5;
-moz-tab-size: 4;
-o-tab-size: 4;
tab-size: 4;
-webkit-hyphens: none;
-moz-hyphens: none;
-ms-hyphens: none;
hyphens: none;
}
pre[class*="language-"]::-moz-selection, pre[class*="language-"] ::-moz-selection,
code[class*="language-"]::-moz-selection, code[class*="language-"] ::-moz-selection {
text-shadow: none;
background: #b3d4fc;
}
pre[class*="language-"]::selection, pre[class*="language-"] ::selection,
code[class*="language-"]::selection, code[class*="language-"] ::selection {
text-shadow: none;
background: #b3d4fc;
}
@media print {
code[class*="language-"],
pre[class*="language-"] {
text-shadow: none;
}
}
/* Code blocks */
pre[class*="language-"] {
padding: 1em;
margin: .5em 0;
overflow: auto;
}
:not(pre) > code[class*="language-"],
pre[class*="language-"] {
background: #F7F7F7;
}
pre.language-sh {
background-color: #272727;
}
code.language-sh {
color: #4fbf40;
text-shadow: none;
}
/* Inline code */
:not(pre) > code[class*="language-"] {
padding: .1em;
border-radius: .3em;
}
.token.comment,
.token.prolog,
.token.doctype,
.token.cdata {
color: slategray;
}
.token.punctuation {
color: #999;
}
.namespace {
opacity: .7;
}
.token.property,
.token.tag,
.token.boolean,
.token.number,
.token.constant,
.token.symbol,
.token.deleted {
color: #905;
}
.token.selector,
.token.attr-name,
.token.string,
.token.char,
.token.builtin,
.token.inserted {
color: #690;
}
.token.operator,
.token.entity,
.token.url,
.language-css .token.string,
.style .token.string {
color: #a67f59;
background: hsla(0, 0%, 100%, .5);
}
.token.atrule,
.token.attr-value,
.token.keyword {
color: #07a;
}
.token.function {
color: #DD4A68;
}
.token.regex,
.token.important,
.token.variable {
color: #e90;
}
.token.important {
font-weight: bold;
}
.token.entity {
cursor: help;
}

137
css/sintax.css Normal file
View File

@@ -0,0 +1,137 @@
:root {
--orange: #953800;
--green: #116329;
--blue-light: #0550ae;
--blue-darker: #0a3069;
--pupple: #8250df;
--gray: #6e7781;
--red: #cf222e;
--red-darker: #82071e;
}
.dark-mode:root {
--orange: #ffa657;
--green: #79c0ff;
--blue-light: #a5d6ff;
--blue-darker: #1f6feb;
--pupple: #d2a8ff;
--gray: #8b949e;
--red: #ff7b72;
--red-darker: #8e1519;
}
.highlight table td { padding: 5px; }
.highlight table pre { margin: 0; }
.highlight, .highlight .w {
color: #24292f;
background-color: var(--code-bg);
}
.highlight .k, .highlight .kd, .highlight .kn, .highlight .kp, .highlight .kr, .highlight .kt, .highlight .kv {
color: var(--red);
}
.highlight .gr {
color: #f6f8fa;
}
.highlight .gd {
color: var(--red-darker);
background-color: #ffebe9;
}
.highlight .nb,
.highlight .nc,
.highlight .no,
.highlight .nn {
color: var(--orange);
}
.highlight .sr,.highlight .na, .highlight .nt, .highlight .gi {
color: var(--green);
}
.highlight .gi {
background-color: #dafbe1;
}
.highlight .ges {
font-weight: bold;
font-style: italic;
}
.highlight .l,
.highlight .ld,
.highlight .m,
.highlight .mb,
.highlight .mf,
.highlight .mh,
.highlight .mi,
.highlight .il,
.highlight .mo,
.highlight .mx,
.highlight .kc,
.highlight .sb,
.highlight .bp,
.highlight .ne,
.highlight .nl,
.highlight .py
.highlight .nv,
.highlight .vc,
.highlight .vg,
.highlight .vi,
.highlight .vm,
.highlight .s1,
.highlight .o,
.highlight .ow,
.highlight .gh,
.highlight .gu,
.highlight .dl {
color: var(--blue-light);
}
.highlight .gh {
font-weight: bold;
}
.highlight .gu {
font-weight: bold;
}
.highlight .s, .highlight .sa, .highlight .sc, .highlight .sd, .highlight .s2, .highlight .se, .highlight .sh, .highlight .sx, .highlight .ss {
color: var(--blue-darker);
}
.highlight .nd, .highlight .nf, .highlight .fm {
color: var(--pupple);
}
.highlight .err {
color: #f6f8fa;
background-color: #82071e;
}
.highlight .c,
.highlight .gl
.highlight .ch,
.highlight .cd,
.highlight .cm,
.highlight .cp,
.highlight .cpf,
.highlight .c1,
.highlight .cs,
.highlight .gt {
color: var(--gray);
}
.highlight .ni,
.highlight .ge,
.highlight .si,
.highlight .gs {
color: #24292f;
}
.highlight .ge {
font-style: italic;
}
.highlight .gs {
font-weight: bold;
}

57
css/style.css
View File

@@ -337,27 +337,6 @@ header {
/* code */
p code, td code {
color: #333;
}
pre {
color: #555;
font-size: 14px;
line-height: 1.4;
padding: 16px;
border-radius: 3px;
overflow: auto;
border: 1px solid #ddd;
}
pre code {
padding: 0;
overflow: scroll;
word-break: break-all;
background-color: inherit;
}
code {
background-color: var(--code-bg);
margin-block: -.125rem;
@@ -367,6 +346,13 @@ code {
border-radius: 6px;
}
pre {
padding: 16px;
border-radius: 3px;
border: 1px solid #ddd;
background-color: var(--code-bg);
}
/* top button */
.scroll #top {
@@ -487,13 +473,6 @@ html[xmlns] .clearfix {
margin-top: 1rem;
}
.doc-box pre {
font-size: 12px;
line-height: 14px;
padding: 0;
margin: 0;
}
.doc-box p {
margin: 0 0 8px 0;
}
@@ -502,28 +481,6 @@ html[xmlns] .clearfix {
margin: 0;
}
.doc-box pre[class*="language-"] {
background: none repeat scroll 0 0 #fff;
}
/* English pages use backticks for code blocks */
.en-doc .page pre[class*="language-"] {
padding-top: 10px !important;
}
/* Non-English pages use pre and code tags for code blocks */
.non-en-doc .page pre[class*="language-"] {
padding-top: 0 !important;
padding-bottom: 0 !important;
}
.page pre.plain-text, .page code.plain-text {
padding-top: 0 !important;
color: #000;
}
.doc-notice {
background: var(--notice-bg);
border-left: 3px solid var(--notice-accent);

34
de/advanced/best-practice-performance.md
View File

@@ -196,23 +196,19 @@ In einer Entwicklungsumgebung wird die Umgebungsvariable in der Regel in Ihrer i
Verwenden Sie bei Upstart das Schlüsselwort `env` in Ihrer Jobdatei. Beispiel:
<pre>
<code class="language-sh" translate="no">
```sh
# /etc/init/env.conf
env NODE_ENV=production
</code>
</pre>
```
Weitere Informationen hierzu siehe [Upstart Intro, Cookbook and Best Practices](http://upstart.ubuntu.com/cookbook/#environment-variables).
Verwenden Sie bei systemd die Anweisung `Environment` in Ihrer Einheitendatei. Beispiel:
<pre>
<code class="language-sh" translate="no">
```sh
# /etc/systemd/system/myservice.service
Environment=NODE_ENV=production
</code>
</pre>
```
Weitere Informationen siehe [Umgebungsvariablen in systemd-Einheiten verwenden](https://coreos.com/os/docs/latest/using-environment-variables-in-systemd-units.html).
@@ -273,8 +269,7 @@ Es gibt zwei Möglichkeiten, Init-Systeme mit Ihrer Express-Anwendung zu verwend
Eine "systemd"-Servicekonfigurationsdatei wird als *Einheitendatei* bezeichnet, die die Endung ".service" hat. Dies ist ein Beispiel für eine Einheitendatei zur direkten Verwaltung einer Node-Anwendung (ersetzen Sie den Text in Fettdruck durch Werte für Ihr System und Ihre Anwendung):
<pre>
<code class="language-sh" translate="no">
```sh
[Unit]
Description=Awesome Express App
@@ -302,8 +297,7 @@ Restart=always
[Install]
WantedBy=multi-user.target
</code>
</pre>
```
Weitere Informationen zu "systemd" siehe [systemd-Referenz (Man-Page)](http://www.freedesktop.org/software/systemd/man/systemd.unit.html).
##### StrongLoop Process Manager als "systemd"-Service
@@ -311,13 +305,13 @@ Sie können StrongLoop Process Manager problemlos als "systemd"-Service installi
So installieren Sie StrongLoop Process Manager als "systemd"-Service:
```console
```bash
$ sudo sl-pm-install --systemd
```
Starten Sie dann den Service mit:
```console
```bash
$ sudo /usr/bin/systemctl start strong-pm
```
@@ -331,8 +325,7 @@ Ein "Upstart"-Service wird als Jobkonfigurationsdatei (auch als "Job" bezeichnet
Erstellen Sie eine Datei namens `myapp.conf` unter `/etc/init/` mit dem folgenden Inhalt (ersetzen Sie den Text in Fettdruck durch Werte für Ihr System und Ihre Anwendung):
<pre>
<code class="language-sh" translate="no">
```sh
# When to start the process
start on runlevel [2345]
@@ -360,8 +353,7 @@ respawn
# Limit restart attempt to 10 times within 10 seconds
respawn limit 10 10
</code>
</pre>
```
Hinweis: Dieses Script erfordert Upstart 1.4 oder höher mit Unterstützung auf Ubuntu 12.04-14.10.
@@ -381,13 +373,13 @@ Sie können StrongLoop Process Manager problemlos als "Upstart"-Service installi
So installieren Sie StrongLoop Process Manager als "Upstart 1.4"-Service:
```console
```bash
$ sudo sl-pm-install
```
Fühen Sie dann den Service aus mit:
```console
```bash
$ sudo /sbin/initctl start strong-pm
```
@@ -416,7 +408,7 @@ Wenn StrongLoop Process Manager (PM) eine Anwendung ausführt, wird diese automa
Beispiel: Angenommen, Sie haben Ihre Anwendung auf prod.foo.com bereitgestellt, und StrongLoop PM ist auf Port 8701 (Standardport) empfangsbereit. Dann müssen Sie die Clustergröße mithilfe von "slc" auf "8" einstellen.
```console
```bash
$ slc ctl -C http://prod.foo.com:8701 set-size my-app 8
```

57
de/advanced/best-practice-security.md
View File

@@ -47,20 +47,20 @@ Ein handliches Tool zum Abrufen eines kostenloses TLS-Zertifikats ist außerdem
Installieren Sie "Helmet" wie alle anderen Module:
```console
```bash
$ npm install --save helmet
```
So verwenden Sie "Helmet" in Ihrem Code:
<pre>
<code class="language-javascript" translate="no">
...
var helmet = require('helmet');
app.use(helmet());
...
</code>
</pre>
```js
/// ...
const helmet = require('helmet')
app.use(helmet())
/// ...
```
### Deaktivieren Sie mindestens den X-Powered-By-Header
@@ -68,11 +68,9 @@ Wenn Sie "Helmet" nicht verwenden wollen, sollten Sie mindestens den `X-Powered-
Ein bewährtes Verfahren ist also, diesen Header mit der Methode `app.disable()` zu deaktivieren:
<pre>
<code class="language-javascript" translate="no">
app.disable('x-powered-by');
</code>
</pre>
```js
app.disable('x-powered-by')
```
Wenn Sie `helmet.js` verwenden, kümmert sich das Tool darum.
@@ -95,17 +93,15 @@ Die Verwendung des standardmäßigen Namens des Sitzungscookies kann Ihre Anwend
Dieses Problem lässt sich vermeiden, wenn Sie allgemeine Cookienamen verwenden; z. B. durch Verwendung der [express-session](https://www.npmjs.com/package/express-session)-Middleware:
<pre>
<code class="language-javascript" translate="no">
var session = require('express-session');
```js
const session = require('express-session')
app.set('trust proxy', 1) // trust first proxy
app.use(session({
secret: 's3Cur3',
name : 'sessionId',
name: 'sessionId'
})
);
</code>
</pre>
)
```
### Cookie-Sicherheitsoptionen festlegen
@@ -119,26 +115,25 @@ Legen Sie die folgenden Cookieoptionen fest, um die Sicherheit zu erhöhen:
Dies ist ein Beispiel zur Verwendung der [cookie-session](https://www.npmjs.com/package/cookie-session)-Middleware:
<pre>
<code class="language-javascript" translate="no">
var session = require('cookie-session');
var express = require('express');
var app = express();
```js
const session = require('cookie-session')
const express = require('express')
const app = express()
var expiryDate = new Date( Date.now() + 60 * 60 * 1000 ); // 1 hour
const expiryDate = new Date(Date.now() + 60 * 60 * 1000) // 1 hour
app.use(session({
name: 'session',
keys: ['key1', 'key2'],
cookie: { secure: true,
cookie: {
secure: true,
httpOnly: true,
domain: 'example.com',
path: 'foo/bar',
expires: expiryDate
}
})
);
</code>
</pre>
)
```
## Weitere Überlegungen

46
de/advanced/developing-template-engines.md
View File

@@ -12,37 +12,31 @@ Verwenden Sie die Methode `app.engine(ext, callback)`, um Ihre eigene Template-E
Der folgende Code ist ein Beispiel für die Implementierung einer sehr einfachen Template-Engine für die Ausgabe von `.ntl`-Dateien.
<pre>
<code class="language-javascript" translate="no">
var fs = require('fs'); // this engine requires the fs module
app.engine('ntl', function (filePath, options, callback) { // define the template engine
fs.readFile(filePath, function (err, content) {
if (err) return callback(new Error(err));
```js
const fs = require('fs') // this engine requires the fs module
app.engine('ntl', (filePath, options, callback) => { // define the template engine
fs.readFile(filePath, (err, content) => {
if (err) return callback(new Error(err))
// this is an extremely simple template engine
var rendered = content.toString().replace('#title#', '<title>'+ options.title +'</title>')
.replace('#message#', '<h1>'+ options.message +'</h1>');
return callback(null, rendered);
});
});
app.set('views', './views'); // specify the views directory
app.set('view engine', 'ntl'); // register the template engine
</code>
</pre>
const rendered = content.toString().replace('#title#', `<title>${options.title}</title>`)
.replace('#message#', `<h1>${options.message}</h1>`)
return callback(null, rendered)
})
})
app.set('views', './views') // specify the views directory
app.set('view engine', 'ntl') // register the template engine
```
Ihre Anwendung ist jetzt in der Lage, `.ntl`-Dateien auszugeben. Erstellen Sie im Verzeichnis `views` eine Datei namens `index.ntl` mit dem folgenden Inhalt.
<pre>
<code class="language-javascript" translate="no">
```pug
#title#
#message#
</code>
</pre>
```
Erstellen Sie dann in Ihrer Anwendung die folgende Route.
<pre>
<code class="language-javascript" translate="no">
app.get('/', function (req, res) {
res.render('index', { title: 'Hey', message: 'Hello there!'});
});
</code>
</pre>
```js
app.get('/', (req, res) => {
res.render('index', { title: 'Hey', message: 'Hello there!' })
})
```
Wenn Sie eine Anforderung zur Homepage einleiten, wird `index.ntl` im HTML-Format ausgegeben.

22
de/guide/behind-proxies.md
View File

@@ -34,12 +34,12 @@ Eine einzelne IP-Adresse, ein Teilnetz oder ein Array von IP-Adressen und Teilne
Sie können IP-Adressen wie folgt festlegen:
<pre>
<code class="language-js" translate="no">app.set('trust proxy', 'loopback') // specify a single subnet
```js
app.set('trust proxy', 'loopback') // specify a single subnet
app.set('trust proxy', 'loopback, 123.123.123.123') // specify a subnet and an address
app.set('trust proxy', 'loopback, linklocal, uniquelocal') // specify multiple subnets as CSV
app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal']) // specify multiple subnets as an array</code>
</pre>
app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal']) // specify multiple subnets as an array
```
Sobald die Werte angegeben wurden, werden die betreffenden IP-Adressen und Teilnetze aus dem Adressfeststellungsprozess ausgeschlossen. Die nicht vertrauenswürdige IP-Adresse, die am nächsten zum Anwendungsserver liegt, wird als IP-Adresse des Clients festgelegt.
</td>
@@ -53,12 +53,14 @@ Dem `n`-ten Hop vom Proxy-Server soll als Client vertraut werden.
<tr>
<td>Funktion</td>
<td markdown="1">
Individuell angepasste, vertrauenswürdige Implementierung. Dies sollten Sie nur verwenden, wenn Sie genau wissen, was Sie tun. <pre>
<code class="language-js" translate="no">app.set('trust proxy', function (ip) {
if (ip === '127.0.0.1' || ip === '123.123.123.123') return true; // trusted IPs
else return false;
});</code>
</pre>
Individuell angepasste, vertrauenswürdige Implementierung. Dies sollten Sie nur verwenden, wenn Sie genau wissen, was Sie tun.
```js
app.set('trust proxy', (ip) => {
if (ip === '127.0.0.1' || ip === '123.123.123.123') return true // trusted IPs
else return false
})
```
</td>
</tr>
</tbody>

22
de/guide/database-integration.md
View File

@@ -33,7 +33,7 @@ Diese Datenbanktreiber sind neben zahlreichen anderen Treibern verfügbar. Weite
**Modul**: [cassandra-driver](https://github.com/datastax/nodejs-driver)
**Installation**
```console
```bash
$ npm install cassandra-driver
```
@@ -58,7 +58,7 @@ client.execute('select key from system.local', function(err, result) {
**Modul**: [nano](https://github.com/dscape/nano)
**Installation**
```console
```bash
$ npm install nano
```
@@ -91,7 +91,7 @@ books.list(function(err, body){
**Modul**: [levelup](https://github.com/rvagg/node-levelup)
**Installation**
```console
```bash
$ npm install level levelup leveldown
```
@@ -121,7 +121,7 @@ db.put('name', 'LevelUP', function (err) {
**Modul**: [mysql](https://github.com/felixge/node-mysql/)
**Installation**
```console
```bash
$ npm install mysql
```
@@ -154,7 +154,7 @@ connection.end();
**Modul**: [mongodb](https://github.com/mongodb/node-mongodb-native)
**Installation**
```console
```bash
$ npm install mongodb
```
@@ -187,7 +187,7 @@ Wenn Sie nach einem Objektmodelltreiber für MongoDB suchen, schauen Sie unter [
**Modul**: [apoc](https://github.com/hacksparrow/apoc)
**Installation**
```console
```bash
$ npm install apoc
```
@@ -218,7 +218,7 @@ apoc.query('match (n) return n').exec().then(
Anmerkung: [Siehe Installations-Voraussetzungen](https://github.com/oracle/node-oracledb#-installation).
```console
```bash
$ npm install oracledb
```
@@ -263,7 +263,7 @@ getEmployee(101)
**Modul**: [pg-promise](https://github.com/vitaly-t/pg-promise)
**Installation**
```console
```bash
$ npm install pg-promise
```
@@ -291,7 +291,7 @@ db.one("SELECT $1 AS value", 123)
**Modul**: [redis](https://github.com/mranney/node_redis)
**Installation**
```console
```bash
$ npm install redis
```
@@ -329,7 +329,7 @@ client.hkeys('hash key', function (err, replies) {
**Modul**: [sqlite3](https://github.com/mapbox/node-sqlite3)
**Installation**
```console
```bash
$ npm install sqlite3
```
@@ -367,7 +367,7 @@ db.close();
**Modul**: [elasticsearch](https://github.com/elastic/elasticsearch-js)
**Installation**
```console
```bash
$ npm install elasticsearch
```

12
de/guide/debugging.md
View File

@@ -10,19 +10,19 @@ lang: de
Wenn Sie alle in Express verwendeten internen Protokolle anzeigen wollen, legen Sie beim Starten Ihrer Anwendung die Umgebungsvariable `DEBUG` auf `express:*` fest.
```console
```bash
$ DEBUG=express:* node index.js
```
Verwenden Sie unter Windows den entsprechenden Befehl.
```console
```bash
> set DEBUG=express:* & node index.js
```
Die Ausführung dieses Befehls für die durch [express generator](/{{ page.lang }}/starter/generator.html) generierte Standardanwendung resultiert in folgender Ausgabe:
```console
```bash
$ DEBUG=express:* node ./bin/www
express:router:route new / +0ms
express:router:layer new / +1ms
@@ -68,7 +68,7 @@ $ DEBUG=express:* node ./bin/www
Bei einer Anforderung an die Anwendung sind die Protokolle im Express-Code angegeben:
```console
```bash
express:router dispatching GET / +4h
express:router query : / +2ms
express:router expressInit : / +0ms
@@ -92,12 +92,12 @@ Wenn Sie nur die Protokolle von der Routerimplementierung sehen wollen, legen Si
Beispiel: Wenn Sie die Anwendung mit `$ express sample-app` generiert haben, können Sie die Debuganweisungen mit dem folgenden Befehl aktivieren:
```console
```bash
$ DEBUG=sample-app:* node ./bin/www
```
Sie können mehrere Debug-Namespaces in einer durch Kommas getrennten Namensliste angeben:
```console
```bash
$ DEBUG=http,mail,express:* node index.js
```

118
de/guide/error-handling.md
View File

@@ -11,105 +11,89 @@ lang: de
Middlewarefunktionen für die Fehlerbehandlung werden in derselben Weise definiert wie andere Middlewarefunktionen, nur, dass Fehlerbehandlungsfunktionen vier anstatt drei Argumente aufweisen:
`(err, req, res, next)`. Beispiel:
<pre>
<code class="language-javascript" translate="no">
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Something broke!');
});
</code>
</pre>
```js
app.use((err, req, res, next) => {
console.error(err.stack)
res.status(500).send('Something broke!')
})
```
Middleware für die Fehlerbehandlung wird ganz zuletzt nach allen anderen `app.use()`- und Weiterleitungsaufrufen definiert. Beispiel:
<pre>
<code class="language-javascript" translate="no">
var bodyParser = require('body-parser');
var methodOverride = require('method-override');
```js
const bodyParser = require('body-parser')
const methodOverride = require('method-override')
app.use(bodyParser());
app.use(methodOverride());
app.use(function(err, req, res, next) {
app.use(bodyParser())
app.use(methodOverride())
app.use((err, req, res, next) => {
// logic
});
</code>
</pre>
})
```
Antworten von der Middlewarefunktion können das von Ihnen gewünschte Format aufweisen wie beispielsweise eine Fehlerseite im HTML-Format, eine einfache Nachricht oder eine JSON-Zeichenfolge.
Für organisatorische Zwecke (und Frameworks der höheren Ebene) können Sie mehrere Middlewarefunktionen für die Fehlerbehandlung definieren, wie Sie dies bei regulären Middlewarefunktionen auch tun würden. Wenn Sie beispielsweise eine Fehlerbehandlungsroutine (Error-Handler) für Anforderungen über `XHR` und andere Anforderungen definieren wollen, können Sie die folgenden Befehle verwenden:
<pre>
<code class="language-javascript" translate="no">
var bodyParser = require('body-parser');
var methodOverride = require('method-override');
```js
const bodyParser = require('body-parser')
const methodOverride = require('method-override')
app.use(bodyParser());
app.use(methodOverride());
app.use(logErrors);
app.use(clientErrorHandler);
app.use(errorHandler);
</code>
</pre>
app.use(bodyParser())
app.use(methodOverride())
app.use(logErrors)
app.use(clientErrorHandler)
app.use(errorHandler)
```
In diesem Beispiel kann die generische `logErrors`-Funktion Anforderungs- und Fehlerinformationen in `stderr` schreiben:
<pre>
<code class="language-javascript" translate="no">
```js
function logErrors (err, req, res, next) {
console.error(err.stack);
next(err);
console.error(err.stack)
next(err)
}
</code>
</pre>
```
In diesem Beispiel wird `clientErrorHandler` wie folgt definiert. In diesem Fall wird der Fehler explizit an den nächsten Error-Handler übergeben:
<pre>
<code class="language-javascript" translate="no">
```js
function clientErrorHandler (err, req, res, next) {
if (req.xhr) {
res.status(500).send({ error: 'Something failed!' });
res.status(500).send({ error: 'Something failed!' })
} else {
next(err);
next(err)
}
}
</code>
</pre>
```
Die `errorHandler`-Funktion "catch-all" kann wie folgt implementiert werden:
<pre>
<code class="language-javascript" translate="no">
```js
function errorHandler (err, req, res, next) {
res.status(500);
res.render('error', { error: err });
res.status(500)
res.render('error', { error: err })
}
</code>
</pre>
```
Wenn Sie Übergaben an die Funktion `next()` vornehmen (außer die Zeichenfolge `'route'`), sieht Express die aktuelle Anforderung als Fehler an und überspringt alle verbleibenden fehlerfreien Behandlungsroutinen und Middlewarefunktionen. Wenn Sie den Fehler bearbeiten wollen, müssen Sie (wie im nächsten Abschnitt beschrieben) eine Fehlerbehandlungsweiterleitung erstellen.
Bei einem Routenhandler mit mehreren Callback-Funktionen können Sie den Parameter `route` verwenden, um den nächsten Routenhandler zu überspringen. Beispiel:
<pre>
<code class="language-javascript" translate="no">
```js
app.get('/a_route_behind_paywall',
function checkIfPaidSubscriber(req, res, next) {
(req, res, next) => {
if (!req.user.hasPaid) {
// continue handling this request
next('route');
next('route')
}
}, function getPaidContent(req, res, next) {
PaidContent.find(function(err, doc) {
if(err) return next(err);
res.json(doc);
});
});
</code>
</pre>
}, (req, res, next) => {
PaidContent.find((err, doc) => {
if (err) return next(err)
res.json(doc)
})
})
```
In diesem Beispiel wird der Handler `getPaidContent` übersprungen. Alle verbleibenden Handler in `app` für `/a_route_behind_paywall` werden jedoch weiter ausgeführt.
<div class="doc-box doc-info" markdown="1">
@@ -130,14 +114,12 @@ Wenn `next()` mit einem Fehler aufgerufen wird, nachdem Sie mit dem Schreiben de
Wenn Sie also einen angepassten Error-Handler hinzufügen, empfiehlt es sich, eine Delegierung zur Standardfehlerbehandlungsroutine in Express vorzunehmen, wenn die Header bereits an den Client gesendet wurden:
<pre>
<code class="language-javascript" translate="no">
```js
function errorHandler (err, req, res, next) {
if (res.headersSent) {
return next(err);
return next(err)
}
res.status(500);
res.render('error', { error: err });
res.status(500)
res.render('error', { error: err })
}
</code>
</pre>
```

247
de/guide/migrating-4.md
View File

@@ -91,14 +91,12 @@ In den meisten Fällen können Sie einfach nur die Middleware der alten Version
In Version 4 können Sie über einen Variablenparameter den Pfad definieren, in den Middlewarefunktionen geladen werden. Dann können Sie den Wert des Parameters aus dem Routenhandler laden. Beispiel:
<pre>
<code class="language-javascript" translate="no">
```js
app.use('/book/:id', function (req, res, next) {
console.log('ID:', req.params.id);
next();
});
</code>
</pre>
console.log('ID:', req.params.id)
next()
})
```
<h3 id="routing">
Das Routingsystem
</h3>
@@ -117,20 +115,18 @@ Die neue Methode `app.route()` hilft beim Erstellen verkettbarer Routenhandler f
Dies ist ein Beispiel für verkettete Routenhandler, die mit der Funktion `app.route()` definiert werden.
<pre>
<code class="language-javascript" translate="no">
```js
app.route('/book')
.get(function (req, res) {
res.send('Get a random book');
res.send('Get a random book')
})
.post(function (req, res) {
res.send('Add a book');
res.send('Add a book')
})
.put(function (req, res) {
res.send('Update the book');
});
</code>
</pre>
res.send('Update the book')
})
```
<h4 id="express-router">Die Klasse <code>express.Router</code></h4>
@@ -140,38 +136,36 @@ Im folgenden Beispiel wird ein Router als Modul erstellt, Middleware in das Modu
Beispiel: Erstellen Sie eine Routerdatei namens `birds.js` mit dem folgenden Inhalt im Anwendungsverzeichnis:
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var router = express.Router();
```js
var express = require('express')
var router = express.Router()
// middleware specific to this router
router.use(function timeLog (req, res, next) {
console.log('Time: ', Date.now());
next();
});
console.log('Time: ', Date.now())
next()
})
// define the home page route
router.get('/', function (req, res) {
res.send('Birds home page');
});
res.send('Birds home page')
})
// define the about route
router.get('/about', function (req, res) {
res.send('About birds');
});
res.send('About birds')
})
module.exports = router;
</code>
</pre>
module.exports = router
```
Laden Sie dann das Routermodul in die Anwendung:
<pre>
<code class="language-javascript" translate="no">
var birds = require('./birds');
...
app.use('/birds', birds);
</code>
</pre>
```js
var birds = require('./birds')
/// ...
app.use('/birds', birds)
```
Die Anwendung kann nun Anforderungen an die Pfade `/birds` und `/birds/about` bearbeiten und ruft die Middleware `timeLog` auf, die speziell für diese Weiterleitung bestimmt ist.
@@ -301,48 +295,45 @@ Anwendung der Version 3
Es wird eine Express v.3-Anwendung mit der folgenden Datei `app.js` angenommen:
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var routes = require('./routes');
var user = require('./routes/user');
var http = require('http');
var path = require('path');
```js
var express = require('express')
var routes = require('./routes')
var user = require('./routes/user')
var http = require('http')
var path = require('path')
var app = express();
var app = express()
// all environments
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'pug');
app.use(express.favicon());
app.use(express.logger('dev'));
app.use(express.methodOverride());
app.use(express.session({ secret: 'your secret here' }));
app.use(express.bodyParser());
app.use(app.router);
app.use(express.static(path.join(__dirname, 'public')));
app.set('port', process.env.PORT || 3000)
app.set('views', path.join(__dirname, 'views'))
app.set('view engine', 'pug')
app.use(express.favicon())
app.use(express.logger('dev'))
app.use(express.methodOverride())
app.use(express.session({ secret: 'your secret here' }))
app.use(express.bodyParser())
app.use(app.router)
app.use(express.static(path.join(__dirname, 'public')))
// development only
if ('development' == app.get('env')) {
app.use(express.errorHandler());
if (app.get('env') === 'development') {
app.use(express.errorHandler())
}
app.get('/', routes.index);
app.get('/users', user.list);
app.get('/', routes.index)
app.get('/users', user.list)
http.createServer(app).listen(app.get('port'), function () {
console.log('Express server listening on port ' + app.get('port'));
});
</code>
</pre>
console.log('Express server listening on port ' + app.get('port'))
})
```
<h4 id=""><code>package.json</code></h4>
Die zugehörige `package.json`-Datei der Version 3 sieht in etwa wie folgt aus:
<pre>
<code class="language-javascript" translate="no">
```json
{
"name": "application-name",
"version": "0.0.1",
@@ -355,8 +346,7 @@ Die zugehörige `package.json`-Datei der Version 3 sieht in etwa wie folgt aus:
"pug": "*"
}
}
</code>
</pre>
```
<h3 id="">
Prozess
@@ -364,7 +354,7 @@ Prozess
Beginnen Sie den Migrationsprozess mit der Installation der erforderlichen Middleware für die Express 4-Anwendung und der Aktualisierung von Express und Pug auf die aktuellen Versionen. Verwenden Sie hierzu den folgenden Befehl:
```console
```bash
$ npm install serve-favicon morgan method-override express-session body-parser multer errorhandler express@latest pug@latest --save
```
@@ -385,8 +375,7 @@ Nehmen Sie an `app.js` die folgenden Änderungen vor:
Durch Ausführung des Befehls `npm` wird `package.json` wie folgt aktualisiert:
<pre>
<code class="language-javascript" translate="no">
```json
{
"name": "application-name",
"version": "0.0.1",
@@ -406,76 +395,76 @@ Durch Ausführung des Befehls `npm` wird `package.json` wie folgt aktualisiert:
"serve-favicon": "^2.0.1"
}
}
</code>
</pre>
```
<h4 id=""><code>app.js</code></h4>
Entfernen Sie dann ungültigen Code, laden Sie die erforderliche Middleware und nehmen Sie andere Änderungen nach Bedarf vor. Die Datei `app.js` sieht dann wie folgt aus:
<pre>
<code class="language-javascript" translate="no">
var http = require('http');
var express = require('express');
var routes = require('./routes');
var user = require('./routes/user');
var path = require('path');
```js
var http = require('http')
var express = require('express')
var routes = require('./routes')
var user = require('./routes/user')
var path = require('path')
var favicon = require('serve-favicon');
var logger = require('morgan');
var methodOverride = require('method-override');
var session = require('express-session');
var bodyParser = require('body-parser');
var multer = require('multer');
var errorHandler = require('errorhandler');
var favicon = require('serve-favicon')
var logger = require('morgan')
var methodOverride = require('method-override')
var session = require('express-session')
var bodyParser = require('body-parser')
var multer = require('multer')
var errorHandler = require('errorhandler')
var app = express();
var app = express()
// all environments
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'pug');
app.use(favicon(__dirname + '/public/favicon.ico'));
app.use(logger('dev'));
app.use(methodOverride());
app.use(session({ resave: true,
app.set('port', process.env.PORT || 3000)
app.set('views', path.join(__dirname, 'views'))
app.set('view engine', 'pug')
app.use(favicon(path.join(__dirname, '/public/favicon.ico')))
app.use(logger('dev'))
app.use(methodOverride())
app.use(session({
resave: true,
saveUninitialized: true,
secret: 'uwotm8' }));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(multer());
app.use(express.static(path.join(__dirname, 'public')));
secret: 'uwotm8'
}))
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({ extended: true }))
app.use(multer())
app.use(express.static(path.join(__dirname, 'public')))
app.get('/', routes.index);
app.get('/users', user.list);
app.get('/', routes.index)
app.get('/users', user.list)
// error handling middleware should be loaded after the loading the routes
if ('development' == app.get('env')) {
app.use(errorHandler());
if (app.get('env') === 'development') {
app.use(errorHandler())
}
var server = http.createServer(app);
server.listen(app.get('port'), function(){
console.log('Express server listening on port ' + app.get('port'));
});
</code>
</pre>
var server = http.createServer(app)
server.listen(app.get('port'), () => {
console.log('Express server listening on port ' + app.get('port'))
})
```
<div class="doc-box doc-info" markdown="1">
Wenn Sie nicht direkt mit dem Modul `http` arbeiten müssen (socket.io/SPDY/HTTPS), ist das Laden des Moduls nicht erforderlich. Die Anwendung kann dann einfach wie folgt gestartet werden:
<pre>
<code class="language-js" translate="no">app.listen(app.get('port'), function(){
console.log('Express server listening on port ' + app.get('port'));
});
</code>
</pre>
```js
app.listen(app.get('port'), function () {
console.log('Express server listening on port ' + app.get('port'))
})
```
</div>
<h3 id="">Anwendung ausführen</h3>
Der Migrationsprozess ist abgeschlossen und die Anwendung ist nun eine Express 4-Anwendung. Zum Bestätigen starten Sie die Anwendung mit dem folgenden Befehl:
```console
```bash
$ node .
```
@@ -489,14 +478,14 @@ Das Befehlszeilentool zum Generieren einer Express-Anwendung ist nach wie vor `e
Wenn der Express 3 App Generator bereits auf Ihrem System installiert ist, müssen Sie diesen deinstallieren:
```console
```bash
$ npm uninstall -g express
```
Abhängig davon, wie Ihre Datei- und Verzeichnissberechtigungen konfiguriert sind, müssen Sie diesen Befehl möglicherweise mit `sudo` ausführen.
Installieren Sie nun den neuen Generator:
```console
```bash
$ npm install -g express-generator
```
@@ -518,7 +507,7 @@ Befehlsoptionen und -nutzung bleiben größtenteils unverändert. Es gelten jedo
Führen Sie den folgenden Befehl aus, um eine Express 4-Anwendung zu erstellen:
```console
```bash
$ express app4
```
@@ -528,7 +517,7 @@ Sie werden auch feststellen, dass die Datei `app.js` nun ein Node.js-Modul ist
Starten Sie nach der Installation der Abhängigkeiten die Anwendung mit dem folgenden Befehl:
```console
```bash
$ npm start
```
@@ -540,23 +529,19 @@ Weder das Verzeichnis `bin` noch die erweiterungslose Datei `www` ist für das E
Um das Verzeichnis `www` zu löschen und alles im "Express 3-Stil" zu belassen, löschen Sie die Zeile mit dem Eintrag `module.exports = app;` am Ende der Datei `app.js`. Fügen Sie dann stattdessen den folgenden Code an derselben Position ein:
<pre>
<code class="language-javascript" translate="no">
app.set('port', process.env.PORT || 3000);
```js
app.set('port', process.env.PORT || 3000)
var server = app.listen(app.get('port'), function () {
debug('Express server listening on port ' + server.address().port);
});
</code>
</pre>
debug('Express server listening on port ' + server.address().port)
})
```
Stellen Sie sicher, dass Sie das Modul `debug` am Anfang der Datei `app.js` laden. Verwenden Sie dazu den folgenden Code:
<pre>
<code class="language-javascript" translate="no">
var debug = require('debug')('app4');
</code>
</pre>
```js
var debug = require('debug')('app4')
```
Ändern Sie als Nächstes `"start": "node ./bin/www"` in der Datei `package.json` in `"start": "node app.js"`.

2
de/guide/migrating-5.md
View File

@@ -16,7 +16,7 @@ Express 5 unterscheidet sich nicht allzu sehr von Express 4: Die Änderungen an
Zum Installieren der aktuellen Alpha-Version und zur Vorschau von Express 5 geben Sie den folgenden Befehl im Stammverzeichnis Ihrer Anwendung ein:
```console
```bash
$ npm install "express@^{{ site.data.express.next_version }}" --save
```

307
de/guide/routing.md
View File

@@ -12,17 +12,15 @@ Der Begriff *Weiterleitung* (Routing) bezieht sich auf die Definition von Anwend
Der folgende Code ist ein Beispiel für ein sehr einfaches Basisrouting.
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
```js
const express = require('express')
const app = express()
// respond with "hello world" when a GET request is made to the homepage
app.get('/', function(req, res) {
res.send('hello world');
});
</code>
</pre>
app.get('/', (req, res) => {
res.send('hello world')
})
```
<h2 id="route-methods">Weiterleitungsmethoden</h2>
@@ -30,19 +28,17 @@ Eine Weiterleitungsmethode wird von einer HTTP-Methode abgeleitet und an eine In
Der folgende Code ist ein Beispiel für Weiterleitungen, die für die Methoden GET und POST zum Stamm (Root) der Anwendung definiert werden.
<pre>
<code class="language-javascript" translate="no">
```js
// GET method route
app.get('/', function (req, res) {
res.send('GET request to the homepage');
});
app.get('/', (req, res) => {
res.send('GET request to the homepage')
})
// POST method route
app.post('/', function (req, res) {
res.send('POST request to the homepage');
});
</code>
</pre>
app.post('/', (req, res) => {
res.send('POST request to the homepage')
})
```
Express unterstützt die folgenden Weiterleitungsmethoden, die den HTTP-Methoden entsprechen: `get`, `post`, `put`, `head`, `delete`, `options`, `trace`, `copy`, `lock`, `mkcol`, `move`, `purge`, `propfind`, `proppatch`, `unlock`, `report`, `mkactivity`, `checkout`, `merge`, `m-search`, `notify`, `subscribe`, `unsubscribe`, `patch`, `search` und `connect`.
@@ -54,14 +50,12 @@ Es gibt eine spezielle Weiterleitungsmethode, `app.all()`, die nicht von einer H
Im folgenden Beispiel wird der Handler für Anforderungen zur Weiterleitung "/secret" ausgeführt, um herauszufinden, ob Sie GET-, POST-, PUT-, DELETE- oder andere HTTP-Anforderungsmethoden verwenden, die im [HTTP-Modul](https://nodejs.org/api/http.html#http_http_methods) unterstützt werden.
<pre>
<code class="language-javascript" translate="no">
app.all('/secret', function (req, res, next) {
console.log('Accessing the secret section ...');
next(); // pass control to the next handler
});
</code>
</pre>
```js
app.all('/secret', (req, res, next) => {
console.log('Accessing the secret section ...')
next() // pass control to the next handler
})
```
<h2 id="route-paths">Weiterleitungspfade</h2>
@@ -79,75 +73,61 @@ Dies sind einige Beispiele für Weiterleitungspfade auf Basis von Zeichenfolgen.
Dieser Weiterleitungspfad gleicht Weiterleitungsanforderungen zum Stammverzeichnis (`/`) ab.
<pre>
<code class="language-javascript" translate="no">
app.get('/', function (req, res) {
res.send('root');
});
</code>
</pre>
```js
app.get('/', (req, res) => {
res.send('root')
})
```
Dieser Weiterleitungspfad gleicht Anforderungen mit `/about` ab.
<pre>
<code class="language-javascript" translate="no">
app.get('/about', function (req, res) {
res.send('about');
});
</code>
</pre>
```js
app.get('/about', (req, res) => {
res.send('about')
})
```
Dieser Weiterleitungspfad gleicht Anforderungen mit `/random.text` ab.
<pre>
<code class="language-javascript" translate="no">
app.get('/random.text', function (req, res) {
res.send('random.text');
});
</code>
</pre>
```js
app.get('/random.text', (req, res) => {
res.send('random.text')
})
```
Dies sind einige Beispiele für Weiterleitungspfade auf Basis von Zeichenfolgemustern.
Dieser Weiterleitungspfad gleicht `acd` und `abcd` ab.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab?cd', function(req, res) {
res.send('ab?cd');
});
</code>
</pre>
```js
app.get('/ab?cd', (req, res) => {
res.send('ab?cd')
})
```
Dieser Weiterleitungspfad gleicht `abcd`, `abbcd`, `abbbcd` usw. ab.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab+cd', function(req, res) {
res.send('ab+cd');
});
</code>
</pre>
```js
app.get('/ab+cd', (req, res) => {
res.send('ab+cd')
})
```
Dieser Weiterleitungspfad gleicht `abcd`, `abxcd`, `abRABDOMcd`, `ab123cd` usw. ab.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab*cd', function(req, res) {
res.send('ab*cd');
});
</code>
</pre>
```js
app.get('/ab*cd', (req, res) => {
res.send('ab*cd')
})
```
Dieser Weiterleitungspfad gleicht `/abe` und `/abcde` ab.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab(cd)?e', function(req, res) {
res.send('ab(cd)?e');
});
</code>
</pre>
```js
app.get('/ab(cd)?e', (req, res) => {
res.send('ab(cd)?e')
})
```
<div class="doc-box doc-info" markdown="1">
Die Zeichen ?, +, * und () sind Subsets ihrer Entsprechungen in regulären Ausdrücken. Der Bindestrich (-) und der Punkt (.) werden von zeichenfolgebasierten Pfaden förmlich interpretiert.
@@ -157,23 +137,19 @@ Beispiele für Weiterleitungspfade auf Basis regulärer Ausdrücke:
Dieser Weiterleitungspfad gleicht alle Weiterleitungsnamen ab, die den Buchstaben "a" enthalten.
<pre>
<code class="language-javascript" translate="no">
app.get(/a/, function(req, res) {
res.send('/a/');
});
</code>
</pre>
```js
app.get(/a/, (req, res) => {
res.send('/a/')
})
```
Dieser Weiterleitungspfad gleicht `butterfly` und `dragonfly`, jedoch nicht `butterflyman`, `dragonfly man` usw. ab.
<pre>
<code class="language-javascript" translate="no">
app.get(/.*fly$/, function(req, res) {
res.send('/.*fly$/');
});
</code>
</pre>
```js
app.get(/.*fly$/, (req, res) => {
res.send('/.*fly$/')
})
```
<h2 id="route-handlers">Routenhandler (Weiterleitungsroutinen)</h2>
@@ -183,71 +159,62 @@ Routenhandler können eine Funktion und/oder ein Funktionsarray sein, wie in den
Eine einzelne Callback-Funktion kann eine Weiterleitung verarbeiten. Beispiel:
<pre>
<code class="language-javascript" translate="no">
app.get('/example/a', function (req, res) {
res.send('Hello from A!');
});
</code>
</pre>
```js
app.get('/example/a', (req, res) => {
res.send('Hello from A!')
})
```
Mehrere Callback-Funktionen können eine Weiterleitung verarbeiten (achten Sie darauf, dass Sie das Objekt `next` angeben). Beispiel:
<pre>
<code class="language-javascript" translate="no">
app.get('/example/b', function (req, res, next) {
console.log('the response will be sent by the next function ...');
next();
}, function (req, res) {
res.send('Hello from B!');
});
</code>
</pre>
```js
app.get('/example/b', (req, res, next) => {
console.log('the response will be sent by the next function ...')
next()
}, (req, res) => {
res.send('Hello from B!')
})
```
Ein Array von Callback-Funktionen kann eine Weiterleitung verarbeiten. Beispiel:
<pre>
<code class="language-javascript" translate="no">
var cb0 = function (req, res, next) {
console.log('CB0');
next();
```js
const cb0 = function (req, res, next) {
console.log('CB0')
next()
}
var cb1 = function (req, res, next) {
console.log('CB1');
next();
const cb1 = function (req, res, next) {
console.log('CB1')
next()
}
var cb2 = function (req, res) {
res.send('Hello from C!');
const cb2 = function (req, res) {
res.send('Hello from C!')
}
app.get('/example/c', [cb0, cb1, cb2]);
</code>
</pre>
app.get('/example/c', [cb0, cb1, cb2])
```
Eine Kombination aus unabhängigen Funktionen und Funktionsarrays kann eine Weiterleitung verarbeiten. Beispiel:
<pre>
<code class="language-javascript" translate="no">
var cb0 = function (req, res, next) {
console.log('CB0');
next();
```js
const cb0 = function (req, res, next) {
console.log('CB0')
next()
}
var cb1 = function (req, res, next) {
console.log('CB1');
next();
const cb1 = function (req, res, next) {
console.log('CB1')
next()
}
app.get('/example/d', [cb0, cb1], function (req, res, next) {
console.log('the response will be sent by the next function ...');
next();
}, function (req, res) {
res.send('Hello from D!');
});
</code>
</pre>
app.get('/example/d', [cb0, cb1], (req, res, next) => {
console.log('the response will be sent by the next function ...')
next()
}, (req, res) => {
res.send('Hello from D!')
})
```
<h2 id="response-methods">Antwortmethoden</h2>
@@ -271,20 +238,18 @@ Sie können mithilfe von `app.route()` verkettbare Routenhandler für einen Weit
Dies ist ein Beispiel für verkettete Routenhandler, die mit der Funktion `app.route()` definiert werden.
<pre>
<code class="language-javascript" translate="no">
```js
app.route('/book')
.get(function(req, res) {
res.send('Get a random book');
.get((req, res) => {
res.send('Get a random book')
})
.post(function(req, res) {
res.send('Add a book');
.post((req, res) => {
res.send('Add a book')
})
.put(function(req, res) {
res.send('Update the book');
});
</code>
</pre>
.put((req, res) => {
res.send('Update the book')
})
```
<h2 id="express-router">express.Router</h2>
@@ -294,37 +259,35 @@ Im folgenden Beispiel wird ein Router als Modul erstellt, eine Middlewarefunktio
Erstellen Sie eine Routerdatei namens `birds.js` mit dem folgenden Inhalt im Anwendungsverzeichnis:
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var router = express.Router();
```js
const express = require('express')
const router = express.Router()
// middleware that is specific to this router
router.use(function timeLog(req, res, next) {
console.log('Time: ', Date.now());
next();
});
router.use((req, res, next) => {
console.log('Time: ', Date.now())
next()
})
// define the home page route
router.get('/', function(req, res) {
res.send('Birds home page');
});
router.get('/', (req, res) => {
res.send('Birds home page')
})
// define the about route
router.get('/about', function(req, res) {
res.send('About birds');
});
router.get('/about', (req, res) => {
res.send('About birds')
})
module.exports = router;
</code>
</pre>
module.exports = router
```
Laden Sie dann das Routermodul in die Anwendung:
<pre>
<code class="language-javascript" translate="no">
var birds = require('./birds');
...
app.use('/birds', birds);
</code>
</pre>
```js
const birds = require('./birds')
/// ...
app.use('/birds', birds)
```
Die Anwendung kann nun Anforderungen an die Pfade `/birds` und `/birds/about` bearbeiten und ruft die Middlewarefunktion `timeLog` auf, die speziell für diese Weiterleitung bestimmt ist.

227
de/guide/using-middleware.md
View File

@@ -37,149 +37,132 @@ Binden Sie Middleware auf Anwendungsebene zu einer Instanz des [Anwendungsobjekt
Dieses Beispiel zeigt eine Middlewarefunktion ohne Mountpfad. Die Funktion wird immer dann ausgeführt, wenn die Anwendung eine Anforderung erhält.
<pre>
<code class="language-javascript" translate="no">
var app = express();
```js
const app = express()
app.use(function (req, res, next) {
console.log('Time:', Date.now());
next();
});
</code>
</pre>
app.use((req, res, next) => {
console.log('Time:', Date.now())
next()
})
```
Dieses Beispiel zeigt eine Middlewarefunktion mit dem Mountpfad `/user/:id`. Die Funktion wird für jede Art von HTTP-Anforderung auf dem Pfad `/user/:id` ausgeführt.
<pre>
<code class="language-javascript" translate="no">
app.use('/user/:id', function (req, res, next) {
console.log('Request Type:', req.method);
next();
});
</code>
</pre>
```js
app.use('/user/:id', (req, res, next) => {
console.log('Request Type:', req.method)
next()
})
```
Dieses Beispiel zeigt eine Weiterleitung und deren Handlerfunktion (Middlewaresystem). Die Funktion verarbeitet GET-Anforderungen zum Pfad `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.get('/user/:id', function (req, res, next) {
res.send('USER');
});
</code>
</pre>
```js
app.get('/user/:id', (req, res, next) => {
res.send('USER')
})
```
Dies ist ein Beispiel zum Laden einer Reihe von Middlewarefunktionen an einem Mountpunkt mit einem Mountpfad. Das Beispiel veranschaulicht einen Middleware-Stack, über den Anforderungsinformationen zu einer HTTP-Anforderung zum Pfad `/user/:id` ausgegeben werden.
<pre>
<code class="language-javascript" translate="no">
app.use('/user/:id', function(req, res, next) {
console.log('Request URL:', req.originalUrl);
next();
}, function (req, res, next) {
console.log('Request Type:', req.method);
next();
});
</code>
</pre>
```js
app.use('/user/:id', (req, res, next) => {
console.log('Request URL:', req.originalUrl)
next()
}, (req, res, next) => {
console.log('Request Type:', req.method)
next()
})
```
Mit einem Routenhandler können Sie mehrere Weiterleitungen für einen Pfad definieren. Im folgenden Beispiel werden zwei Weiterleitungen für GET-Anforderungen zum Pfad `/user/:id` definiert. Die zweite Weiterleitung verursacht zwar keine Probleme, wird jedoch nie aufgerufen, da durch die erste Weiterleitung der Anforderung/Antwort-Zyklus beendet wird.
Dieses Beispiel zeigt einen Middleware-Sub-Stack, über den GET-Anforderungen zum Pfad `/user/:id` verarbeitet werden.
<pre>
<code class="language-javascript" translate="no">
app.get('/user/:id', function (req, res, next) {
console.log('ID:', req.params.id);
next();
}, function (req, res, next) {
res.send('User Info');
});
```js
app.get('/user/:id', (req, res, next) => {
console.log('ID:', req.params.id)
next()
}, (req, res, next) => {
res.send('User Info')
})
// handler for the /user/:id path, which prints the user ID
app.get('/user/:id', function (req, res, next) {
res.end(req.params.id);
});
</code>
</pre>
app.get('/user/:id', (req, res, next) => {
res.end(req.params.id)
})
```
Wenn Sie den Rest der Middlewarefunktionen eines Weiterleitungs-Middleware-Stack überspringen wollen, rufen Sie `next('route')` auf, um die Steuerung an die nächste Weiterleitung zu übergeben. **HINWEIS**: `next('route')` funktioniert nur in Middlewarefunktionen, die über die Funktionen `app.METHOD()` oder `router.METHOD()` geladen wurden.
Dieses Beispiel zeigt einen Middleware-Sub-Stack, über den GET-Anforderungen zum Pfad `/user/:id` verarbeitet werden.
<pre>
<code class="language-javascript" translate="no">
app.get('/user/:id', function (req, res, next) {
```js
app.get('/user/:id', (req, res, next) => {
// if the user ID is 0, skip to the next route
if (req.params.id == 0) next('route');
if (req.params.id === '0') next('route')
// otherwise pass the control to the next middleware function in this stack
else next(); //
}, function (req, res, next) {
else next() //
}, (req, res, next) => {
// render a regular page
res.render('regular');
});
res.render('regular')
})
// handler for the /user/:id path, which renders a special page
app.get('/user/:id', function (req, res, next) {
res.render('special');
});
</code>
</pre>
app.get('/user/:id', (req, res, next) => {
res.render('special')
})
```
<h2 id='middleware.router'>Middleware auf Routerebene</h2>
Middleware auf Routerebene funktioniert in der gleichen Weise wie Middleware auf Anwendungsebene, mit dem einzigen Unterschied, dass sie an eine Instanz von `express.Router()` gebunden ist.
<pre>
<code class="language-javascript" translate="no">
var router = express.Router();
</code>
</pre>
```js
const router = express.Router()
```
Laden Sie Middleware auf Routerebene über die Funktionen `router.use()` und `router.METHOD()`.
Der folgende Beispielcode repliziert das Middlewaresystem, das oben für die Middleware auf Anwendungsebene gezeigt wird, durch Verwendung von Middleware auf Routerebene.
<pre>
<code class="language-javascript" translate="no">
var app = express();
var router = express.Router();
```js
const app = express()
const router = express.Router()
// a middleware function with no mount path. This code is executed for every request to the router
router.use(function (req, res, next) {
console.log('Time:', Date.now());
next();
});
router.use((req, res, next) => {
console.log('Time:', Date.now())
next()
})
// a middleware sub-stack shows request info for any type of HTTP request to the /user/:id path
router.use('/user/:id', function(req, res, next) {
console.log('Request URL:', req.originalUrl);
next();
}, function (req, res, next) {
console.log('Request Type:', req.method);
next();
});
router.use('/user/:id', (req, res, next) => {
console.log('Request URL:', req.originalUrl)
next()
}, (req, res, next) => {
console.log('Request Type:', req.method)
next()
})
// a middleware sub-stack that handles GET requests to the /user/:id path
router.get('/user/:id', function (req, res, next) {
router.get('/user/:id', (req, res, next) => {
// if the user ID is 0, skip to the next router
if (req.params.id == 0) next('route');
if (req.params.id === '0') next('route')
// otherwise pass control to the next middleware function in this stack
else next(); //
}, function (req, res, next) {
else next() //
}, (req, res, next) => {
// render a regular page
res.render('regular');
});
res.render('regular')
})
// handler for the /user/:id path, which renders a special page
router.get('/user/:id', function (req, res, next) {
console.log(req.params.id);
res.render('special');
});
router.get('/user/:id', (req, res, next) => {
console.log(req.params.id)
res.render('special')
})
// mount the router on the app
app.use('/', router);
</code>
</pre>
app.use('/', router)
```
<h2 id='middleware.error-handling'>Middleware für die Fehlerbehandlung</h2>
<div class="doc-box doc-notice" markdown="1">
@@ -188,14 +171,12 @@ Middleware für die Fehlerbehandlung benötigt immer *vier* Argumente. Sie müss
Middlewarefunktionen für die Fehlerbehandlung werden in derselben Weise definiert wie andere Middlewarefunktionen, außer dass Fehlerbehandlungsfunktionen speziell bei Signaturen vier anstatt drei Argumente aufweisen `(err, req, res, next)`:
<pre>
<code class="language-javascript" translate="no">
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Something broke!');
});
</code>
</pre>
```js
app.use((err, req, res, next) => {
console.error(err.stack)
res.status(500).send('Something broke!')
})
```
Details zu Middleware für die Fehlerbehandlung siehe [Fehlerbehandlung](/{{ page.lang }}/guide/error-handling.html).
@@ -224,9 +205,8 @@ Das optionale Objekt `options` kann folgende Eigenschaften aufweisen:
Dies ist ein Beispiel zur Verwendung der Middlewarefunktion `express.static` mit einem ausführlich dargestellten Optionsobjekt:
<pre>
<code class="language-javascript" translate="no">
var options = {
```js
const options = {
dotfiles: 'ignore',
etag: false,
extensions: ['htm', 'html'],
@@ -234,23 +214,20 @@ var options = {
maxAge: '1d',
redirect: false,
setHeaders: function (res, path, stat) {
res.set('x-timestamp', Date.now());
res.set('x-timestamp', Date.now())
}
}
app.use(express.static('public', options));
</code>
</pre>
app.use(express.static('public', options))
```
Es sind mehrere statische Verzeichnisse pro Anwendung möglich:
<pre>
<code class="language-javascript" translate="no">
app.use(express.static('public'));
app.use(express.static('uploads'));
app.use(express.static('files'));
</code>
</pre>
```js
app.use(express.static('public'))
app.use(express.static('uploads'))
app.use(express.static('files'))
```
Details zur Funktion `serve-static` und deren Optionen finden Sie in der Dokumentation zu [serve-static](https://github.com/expressjs/serve-static).
@@ -262,19 +239,17 @@ Installieren Sie das Modul Node.js für die erforderliche Funktionalität. Laden
Das folgende Beispiel veranschaulicht das Installieren und Laden der Middlewarefunktion `cookie-parser` für das Cookie-Parsing.
```console
```bash
$ npm install cookie-parser
```
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
var cookieParser = require('cookie-parser');
```js
const express = require('express')
const app = express()
const cookieParser = require('cookie-parser')
// load the cookie-parsing middleware
app.use(cookieParser());
</code>
</pre>
app.use(cookieParser())
```
Eine nicht vollständige Liste zu den Middlewarefunktionen anderer Anbieter, die im Allgemeinen mit Express verwendet werden, finden Sie unter [Middleware anderer Anbieter](../resources/middleware.html).

28
de/guide/using-template-engines.md
View File

@@ -15,7 +15,7 @@ Bevor über Express Vorlagendateien ausgegeben werden können, müssen die folge
Installieren Sie dann das entsprechende npm-Paket für die Template-Engine:
```console
```bash
$ npm install pug --save
```
@@ -25,33 +25,27 @@ Express-konforme Template-Engines wie Pug exportieren eine Funktion namens `__ex
Nach der Festlegung der View-Engine muss die Engine nicht angegeben oder das Template-Engine-Modul nicht in Ihre Anwendung geladen werden. Express lädt das Modul intern (wie unten für das obige Beispiel gezeigt).
<pre>
<code class="language-javascript" translate="no">
app.set('view engine', 'pug');
</code>
</pre>
```js
app.set('view engine', 'pug')
```
Erstellen Sie eine Pug-Vorlagendatei namens `index.pug` im Verzeichnis `views` mit dem folgenden Inhalt:
<pre>
<code class="language-javascript" translate="no">
```pug
html
head
title= title
body
h1= message
</code>
</pre>
```
Dann erstellen Sie eine Weiterleitung, um die Datei `index.pug` auszugeben. Wenn die Eigenschaft `view engine` nicht festgelegt wurde, müssen Sie die Erweiterung der Datei `view` angeben. Andernfalls müssen Sie diese Erweiterung nicht angeben.
<pre>
<code class="language-javascript" translate="no">
app.get('/', function (req, res) {
res.render('index', { title: 'Hey', message: 'Hello there!'});
});
</code>
</pre>
```js
app.get('/', (req, res) => {
res.render('index', { title: 'Hey', message: 'Hello there!' })
})
```
Wenn Sie eine Anforderung zur Homepage ausführen, wird die Datei `index.pug` im HTML-Format ausgegeben.

105
de/guide/writing-middleware.md
View File

@@ -44,29 +44,27 @@ Das folgende Beispiel zeigt die Elemente eines Middlewarefunktionsaufrufs:
Dies ist ein Beispiel einer einfachen Express-Anwendung namens "Hello World", für die Sie zwei Middlewarefunktionen definieren:
<pre><code class="language-javascript" translate="no">
var express = require('express');
var app = express();
```js
const express = require('express')
const app = express()
app.get('/', function (req, res) {
res.send('Hello World!');
});
app.get('/', (req, res) => {
res.send('Hello World!')
})
app.listen(3000);
</code></pre>
app.listen(3000)
```
<h2>Entwicklung</h2>
Dies ist ein einfaches Beispiel einer Middlewarefunktion namens "myLogger". Diese Funktion gibt lediglich "LOGGED" aus, wenn eine Anforderung zur Anwendung über diese Funktion läuft. Die Middlewarefunktion ist der Variablen `myLogger` zugeordnet.
<pre>
<code class="language-javascript" translate="no">
var myLogger = function (req, res, next) {
console.log('LOGGED');
next();
};
</code>
</pre>
```js
const myLogger = function (req, res, next) {
console.log('LOGGED')
next()
}
```
<div class="doc-box doc-notice" markdown="1">
Beachten Sie den Aufruf oben zu `next()`. Durch den Aufruf dieser Funktion wird die nächste Middlewarefunktion in der Anwendung aufgerufen. Die Funktion `next()` ist nicht Teil der Node.js- oder Express-API, sondern das dritte Argument, das an die Middlewarefunktion übergeben wird. Die Funktion `next()` kann jeden beliebigen Namen haben, per Konvention erhält sie jedoch immer den Namen "next". Um Unklarheiten zu vermeiden, sollten Sie immer diese Konvention verwenden.
@@ -75,25 +73,23 @@ Beachten Sie den Aufruf oben zu `next()`. Durch den Aufruf dieser Funktion wird
Zum Laden der Middlewarefunktion rufen Sie `app.use()` auf und geben die Middlewarefunktion an. Beispiel: Durch den folgenden Code wird die Middlewarefunktion `myLogger` vor der Weiterleitung zum Stammverzeichnispfad (/) geladen.
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
```js
const express = require('express')
const app = express()
var myLogger = function (req, res, next) {
console.log('LOGGED');
next();
};
const myLogger = function (req, res, next) {
console.log('LOGGED')
next()
}
app.use(myLogger);
app.use(myLogger)
app.get('/', function (req, res) {
res.send('Hello World!');
});
app.get('/', (req, res) => {
res.send('Hello World!')
})
app.listen(3000);
</code>
</pre>
app.listen(3000)
```
Sobald die Anwendung eine Anforderung erhält, gibt sie die Nachricht "LOGGED" an das Terminal aus.
@@ -105,39 +101,34 @@ Die Middlewarefunktion `myLogger` gibt einfach eine Nachricht aus und übergibt
Im nächsten Beispiel wird die Eigenschaft `requestTime` zum Anforderungsobjekt hinzugefügt. Diese Middlewarefunktion erhält den Namen "requestTime".
<pre>
<code class="language-javascript" translate="no">
var requestTime = function (req, res, next) {
req.requestTime = Date.now();
next();
};
</code>
</pre>
```js
const requestTime = function (req, res, next) {
req.requestTime = Date.now()
next()
}
```
Die Anwendung verwendet nun die Middlewarefunktion `requestTime`. Außerdem verwendet die Callback-Funktion der Weiterleitung zum Stammverzeichnispfad die Eigenschaft, die die Middlewarefunktion zu `req` (dem Anforderungsobjekt) hinzufügt.
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
```js
const express = require('express')
const app = express()
var requestTime = function (req, res, next) {
req.requestTime = Date.now();
next();
};
const requestTime = function (req, res, next) {
req.requestTime = Date.now()
next()
}
app.use(requestTime);
app.use(requestTime)
app.get('/', function (req, res) {
var responseText = 'Hello World!<br>';
responseText += '<small>Requested at: ' + req.requestTime + '</small>';
res.send(responseText);
});
app.listen(3000);
</code>
</pre>
app.get('/', (req, res) => {
let responseText = 'Hello World!<br>'
responseText += `<small>Requested at: ${req.requestTime}</small>`
res.send(responseText)
})
app.listen(3000)
```
Wenn Sie eine Anforderung zum Stammverzeichnis der Anwendung einleiten, zeigt die Anwendung nun die Zeitmarke Ihrer Anforderung im Browser an.
Da Sie Zugriff auf das Anforderungsobjekt, das Antwortobjekt, die nächste Middlewarefunktion im Stack und die gesamte Node.js-API haben, sind die Möglichkeiten, die Sie mit Middlewarefunktionen haben, nahezu unendlich.

54
de/starter/basic-routing.md
View File

@@ -13,11 +13,9 @@ Per *Routing* wird bestimmt, wie eine Antwort auf eine Clientanforderung an eine
Jede Weiterleitung (Route) kann eine oder mehrere Handlerfunktionen haben, die ausgeführt werden, wenn die Weiterleitung abgeglichen wird.
Weiterleitungsdefinitionen haben die folgende Struktur:
<pre>
<code class="language-javascript" translate="no">
```js
app.METHOD(PATH, HANDLER)
</code>
</pre>
```
Bedeutung:
@@ -34,42 +32,34 @@ Die folgenden Beispiele veranschaulichen das Definieren einfacher Weiterleitunge
Antworten Sie mit `Hello World!` auf der Homepage:
<pre>
<code class="language-javascript" translate="no">
app.get('/', function (req, res) {
res.send('Hello World!');
});
</code>
</pre>
```js
app.get('/', (req, res) => {
res.send('Hello World!')
})
```
Antworten Sie auf POST-Anforderungen auf die Weiterleitung zum Stammverzeichnis (`/`), der Homepage der Anwendung:
<pre>
<code class="language-javascript" translate="no">
app.post('/', function (req, res) {
res.send('Got a POST request');
});
</code>
</pre>
```js
app.post('/', (req, res) => {
res.send('Got a POST request')
})
```
Antworten Sie auf eine PUT-Anforderung zur Weiterleitung `/user`:
<pre>
<code class="language-javascript" translate="no">
app.put('/user', function (req, res) {
res.send('Got a PUT request at /user');
});
</code>
</pre>
```js
app.put('/user', (req, res) => {
res.send('Got a PUT request at /user')
})
```
Antworten Sie auf eine DELETE-Anforderung zur Weiterleitung `/user`:
<pre>
<code class="language-javascript" translate="no">
app.delete('/user', function (req, res) {
res.send('Got a DELETE request at /user');
});
</code>
</pre>
```js
app.delete('/user', (req, res) => {
res.send('Got a DELETE request at /user')
})
```
Details zum Thema Routing finden Sie in der entsprechenden [Routinganleitung](/{{ page.lang }}/guide/routing.html).

26
de/starter/faq.md
View File

@@ -42,26 +42,22 @@ Express unterstützt jede Template-Engine, die der `(path, locals, callback)`-Si
In Express sind 404-Antworten nicht das Ergebnis eines Fehlers, sodass diese Antworten von der Fehlerbehandlungsroutine nicht erfasst werden. Dieses Verhalten ist damit zu erklären, dass eine 404-Antwort einfach angibt, dass keine weiteren Arbeiten auszuführen sind. In anderen Worten: Express hat alle Middlewarefunktionen und Weiterleitungen ausgeführt und festgestellt, dass keine Funktion eine Antwort zurückgegeben hat. Sie müssen also bei der Handhabung der 404-Antwort nur eine Middlewarefunktion am Ende des Stacks (unterhalb von allen anderen Funktionen) hinzufügen:
<pre>
<code class="language-javascript" translate="no">
app.use(function(req, res, next) {
res.status(404).send('Sorry cant find that!');
});
</code>
</pre>
```js
app.use((req, res, next) => {
res.status(404).send('Sorry cant find that!')
})
```
## Wie richte ich eine Fehlerbehandlungsroutine ein?
Middleware für die Fehlerbehandlung wird in derselben Weise definiert wie andere Middleware; außer dass sie vier anstatt drei Argumente aufweist. Dies gilt speziell bei der Signatur `(err, req, res, next)`:
<pre>
<code class="language-javascript" translate="no">
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Something broke!');
});
</code>
</pre>
```js
app.use((err, req, res, next) => {
console.error(err.stack)
res.status(500).send('Something broke!')
})
```
Weitere Informationen siehe [Fehlerbehandlung](/{{ page.lang }}/guide/error-handling.html).

14
de/starter/generator.md
View File

@@ -12,13 +12,13 @@ Mit dem Application Generator Tool `express` können Sie innerhalb kürzester Ze
Installieren Sie `express` mit dem folgenden Befehl:
```console
```bash
$ npm install express-generator -g
```
Zeigen Sie die Befehlsoptionen mit der Option `-h` an:
```console
```bash
$ express -h
Usage: express [options][dir]
@@ -40,7 +40,7 @@ $ express -h
Im folgenden Beispiel wird eine Express-Anwendung mit dem Namen _myapp_ im aktuellen Arbeitsverzeichnis erstellt:
```console
```bash
$ express --view=pug myapp
create : myapp
@@ -64,20 +64,20 @@ $ express --view=pug myapp
Installieren Sie dann Abhängigkeiten:
```console
```bash
$ cd myapp
$ npm install
```
Führen Sie unter MacOS oder Linux die Anwendung mit diesem Befehl aus:
```console
```bash
$ DEBUG=myapp:* npm start
```
Verwenden Sie unter Windows diesen Befehl:
```console
```bash
> set DEBUG=myapp:* & npm start
```
@@ -85,7 +85,7 @@ Laden Sie dann `http://localhost:3000/` in Ihren Browser, um auf die Anwendung z
Die erstellte Anwendung hat die folgende Verzeichnisstruktur:
```console
```bash
.
├── app.js
├── bin

8
de/starter/hello-world.md
View File

@@ -16,8 +16,7 @@ Erstellen Sie zunächst ein Verzeichnis namens `myapp`, wechseln Sie in das Verz
Erstellen Sie im Verzeichnis `myapp` eine Datei namens `app.js` und fügen Sie den folgenden Code hinzu:
<pre>
<code class="language-javascript" translate="no">
```js
const express = require('express')
const app = express()
const port = 3000
@@ -29,8 +28,7 @@ app.get('/', (req, res) => {
app.listen(port, () => {
console.log(`Example app listening on port ${port}`)
})
</code>
</pre>
```
Die Anwendung startet einen Server und ist an Port 3000 empfangsbereit für Verbindungen. Die Anwendung antwortet mit "Hello World!" auf Anforderungen zur Stamm-URL (`/`) oder zu *route*. Bei jedem anderen Pfad lautet die Antwort **404 Not Found**.
@@ -40,7 +38,7 @@ Die Anwendung startet einen Server und ist an Port 3000 empfangsbereit für Verb
Führen Sie die Anwendung mit dem folgenden Befehl aus:
```console
```bash
$ node app.js
```

10
de/starter/installing.md
View File

@@ -10,20 +10,20 @@ lang: de
Angenommen, Sie haben [Node.js](https://nodejs.org/) bereits installiert. Erstellen Sie ein Verzeichnis für Ihre Anwendung und definieren Sie dieses Verzeichnis als Ihr Arbeitsverzeichnis.
```console
```bash
$ mkdir myapp
$ cd myapp
```
Erstellen Sie mit dem Befehl `npm init` eine Datei namens `package.json` für Ihre Anwendung. Weitere Informationen zur Funktionsweise von `package.json` finden Sie in den [Angaben zur Handhabung der npm-Datei package.json](https://docs.npmjs.com/files/package.json).
```console
```bash
$ npm init
```
Dieser Befehl fordert Sie zur Eingabe verschiedener Angaben wie Name und Version Ihrer Anwendung auf. Für den Moment reicht es, die Eingabetaste zu drücken und die Standardwerte für die meisten Angaben zu akzeptieren. Es gilt jedoch folgende Ausnahme:
```console
```bash
entry point: (index.js)
```
@@ -31,13 +31,13 @@ Geben Sie `app.js` oder einen Namen Ihrer Vorstellung als Namen für die Hauptda
Installieren Sie jetzt Express im Verzeichnis `myapp` und speichern Sie es in der Abhängigkeitsliste. Beispiel:
```console
```bash
$ npm install express --save
```
Wenn Sie Express vorübergehend installieren und nicht zur Abhängigkeitsliste hinzufügen wollen, geben Sie die Option `--save` nicht an:
```console
```bash
$ npm install express
```

47
de/starter/static-files.md
View File

@@ -12,62 +12,51 @@ Wenn Sie statische Dateien wie Bilder, CSS-Dateien und JavaScript-Dateien bereit
Übergeben Sie den Namen des Verzeichnisses mit den statischen Assets an die Middlewarefunktion `express.static`, um direkt mit dem Bereitstellen der Dateien zu beginnen. Beispiel: Verwenden Sie den folgenden Code, um Bilder, CSS-Dateien und JavaScript-Dateien in einem Verzeichnis namens `public` bereitzustellen:
<pre>
<code class="language-javascript" translate="no">
app.use(express.static('public'));
</code>
</pre>
```js
app.use(express.static('public'))
```
Jetzt können Sie die Dateien laden, die sich im Verzeichnis `public` befinden:
<pre>
<code class="language-javascript" translate="no">
```text
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
</code>
</pre>
```
<div class="doc-box doc-info">
Express sucht nach den Dateien, die sich auf das Verzeichnis mit den statischen Assets beziehen. Der Name dieses Verzeichnisses ist also nicht Teil der URL. </div>
Wenn Sie mehrere Verzeichnisse mit statischen Assets verwenden wollen, rufen Sie die Middlewarefunktion `express.static` mehrmals auf:
<pre>
<code class="language-javascript" translate="no">
app.use(express.static('public'));
app.use(express.static('files'));
</code>
</pre>
```js
app.use(express.static('public'))
app.use(express.static('files'))
```
Express sucht in der Reihenfolge nach den Dateien, in der sie die Verzeichnisse mit den statischen Assets über die Middlewarefunktion `express.static` festgelegt haben.
Wenn Sie ein Präfix für einen virtuellen Pfad (in dem der Pfad nicht wirklich im Dateisystem existiert) für Dateien festlegen wollen, die über die Funktion `express.static` bereitgestellt werden, [müssen Sie einen Mountpfad](/{{ page.lang }}/4x/api.html#app.use) für das Verzeichnis mit den statischen Assets wie unten gezeigt angeben:
<pre>
<code class="language-javascript" translate="no">
app.use('/static', express.static('public'));
</code>
</pre>
```js
app.use('/static', express.static('public'))
```
Jetzt können Sie die Dateien, die sich im Verzeichnis `public` befinden, aus dem Pfadpräfix `/static` laden.
<pre>
<code class="language-javascript" translate="no">
```text
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
</code>
</pre>
```
Der Pfad, den Sie für die Funktion `express.static` angeben, ist jedoch relativ zum Verzeichnis, aus dem Sie Ihren Prozess `node` starten. Wenn Sie die Express-Anwendung aus einem anderen Verzeichnis ausführen, ist es sicherer, den absoluten Pfad des Verzeichnisses zu verwenden, das Sie bereitstellen wollen:
<pre>
<code class="language-javascript" translate="no">
app.use('/static', express.static(__dirname + '/public'));
</code>
</pre>
```js
const path = require('path')
app.use('/static', express.static(path.join(__dirname, 'public')))
```

14
en/advanced/best-practice-performance.md
View File

@@ -298,13 +298,13 @@ You can easily install StrongLoop Process Manager as a systemd service. After yo
To install StrongLoop PM as a systemd service:
```console
```bash
$ sudo sl-pm-install --systemd
```
Then start the service with:
```console
```bash
$ sudo /usr/bin/systemctl start strong-pm
```
@@ -366,13 +366,13 @@ You can easily install StrongLoop Process Manager as an Upstart service. After y
To install StrongLoop PM as an Upstart 1.4 service:
```console
```bash
$ sudo sl-pm-install
```
Then run the service with:
```console
```bash
$ sudo /sbin/initctl start strong-pm
```
@@ -402,7 +402,7 @@ When StrongLoop Process Manager (PM) runs an application, it automatically runs
For example, assuming you've deployed your app to prod.foo.com and StrongLoop PM is listening on port 8701 (the default), then to set the cluster size to eight using slc:
```console
```bash
$ slc ctl -C http://prod.foo.com:8701 set-size my-app 8
```
@@ -416,7 +416,7 @@ When running an application with PM2, you can enable **cluster mode** to run it
To enable cluster mode, start your application like so:
```console
```bash
# Start 4 worker processes
$ pm2 start npm --name my-app -i 4 -- start
# Auto-detect number of available CPUs and start that many worker processes
@@ -427,7 +427,7 @@ This can also be configured within a PM2 process file (`ecosystem.config.js` or
Once running, the application can be scaled like so:
```console
```bash
# Add 3 more workers
$ pm2 scale my-app +3
# Scale to a specific number of workers

8
en/advanced/best-practice-security.md
View File

@@ -90,7 +90,7 @@ Helmet includes several other middleware functions which you can read about [at
Install Helmet like any other module:
```console
```bash
$ npm install --save helmet
```
@@ -221,7 +221,7 @@ Using npm to manage your application's dependencies is powerful and convenient.
Since npm@6, npm automatically reviews every install request. Also, you can use `npm audit` to analyze your dependency tree.
```console
```bash
$ npm audit
```
@@ -229,14 +229,14 @@ If you want to stay more secure, consider [Snyk](https://snyk.io/).
Snyk offers both a [command-line tool](https://www.npmjs.com/package/snyk) and a [Github integration](https://snyk.io/docs/github) that checks your application against [Snyk's open source vulnerability database](https://snyk.io/vuln/) for any known vulnerabilities in your dependencies. Install the CLI as follows:
```console
```bash
$ npm install -g snyk
$ cd your-app
```
Use this command to test your application for vulnerabilities:
```console
```bash
$ snyk test
```

2
en/advanced/developing-template-engines.md
View File

@@ -31,7 +31,7 @@ app.set('view engine', 'ntl') // register the template engine
Your app will now be able to render `.ntl` files. Create a file named `index.ntl` in the `views` directory with the following content.
```text
```pug
#title#
#message#
```

26
en/guide/database-integration.md
View File

@@ -35,7 +35,7 @@ search on the [npm](https://www.npmjs.com/) site.
### Installation
```console
```bash
$ npm install cassandra-driver
```
@@ -57,7 +57,7 @@ client.execute('select key from system.local', (err, result) => {
### Installation
```console
```bash
$ npm install couchbase
```
@@ -94,7 +94,7 @@ bucket.query(query, [13], (err, result) => {
### Installation
```console
```bash
$ npm install nano
```
@@ -130,7 +130,7 @@ books.list((err, body) => {
### Installation
```console
```bash
$ npm install level levelup leveldown
```
@@ -157,7 +157,7 @@ db.put('name', 'LevelUP', (err) => {
### Installation
```console
```bash
$ npm install mysql
```
@@ -189,7 +189,7 @@ connection.end()
### Installation
```console
```bash
$ npm install mongodb
```
@@ -236,7 +236,7 @@ If you want an object model driver for MongoDB, look at [Mongoose](https://githu
### Installation
```console
```bash
$ npm install neo4j-driver
```
@@ -267,7 +267,7 @@ session.readTransaction((tx) => {
NOTE: [See installation prerequisites](https://github.com/oracle/node-oracledb#-installation).
```console
```bash
$ npm install oracledb
```
@@ -311,7 +311,7 @@ getEmployee(101)
### Installation
```console
```bash
$ npm install pg-promise
```
@@ -336,7 +336,7 @@ db.one('SELECT $1 AS value', 123)
### Installation
```console
```bash
$ npm install redis
```
@@ -371,7 +371,7 @@ client.hkeys('hash key', (err, replies) => {
### Installation
```console
```bash
$ npm install tedious
```
@@ -432,7 +432,7 @@ function executeStatement () {
### Installation
```console
```bash
$ npm install sqlite3
```
@@ -466,7 +466,7 @@ db.close()
### Installation
```console
```bash
$ npm install elasticsearch
```

12
en/guide/debugging.md
View File

@@ -11,19 +11,19 @@ redirect_from: "/guide/debugging.html"
To see all the internal logs used in Express, set the `DEBUG` environment variable to
`express:*` when launching your app.
```console
```bash
$ DEBUG=express:* node index.js
```
On Windows, use the corresponding command.
```console
```bash
> set DEBUG=express:* & node index.js
```
Running this command on the default app generated by the [express generator](/{{ page.lang }}/starter/generator.html) prints the following output:
```console
```bash
$ DEBUG=express:* node ./bin/www
express:router:route new / +0ms
express:router:layer new / +1ms
@@ -69,7 +69,7 @@ $ DEBUG=express:* node ./bin/www
When a request is then made to the app, you will see the logs specified in the Express code:
```console
```bash
express:router dispatching GET / +4h
express:router query : / +2ms
express:router expressInit : / +0ms
@@ -95,13 +95,13 @@ An application generated by the `express` command uses the `debug` module and it
For example, if you generated the app with `$ express sample-app`, you can enable the debug statements with the following command:
```console
```bash
$ DEBUG=sample-app:* node ./bin/www
```
You can specify more than one debug namespace by assigning a comma-separated list of names:
```console
```bash
$ DEBUG=http,mail,express:* node index.js
```

12
en/guide/migrating-4.md
View File

@@ -384,7 +384,7 @@ Begin the migration process by installing the required middleware for the
Express 4 app and updating Express and Pug to their respective latest
version with the following command:
```console
```bash
$ npm install serve-favicon morgan method-override express-session body-parser multer errorhandler express@latest pug@latest --save
```
@@ -499,7 +499,7 @@ app.listen(app.get('port'), () => {
The migration process is complete, and the app is now an
Express 4 app. To confirm, start the app by using the following command:
```console
```bash
$ node .
```
@@ -518,7 +518,7 @@ The command-line tool to generate an Express app is still
If you already have the Express 3 app generator installed on your system,
you must uninstall it:
```console
```bash
$ npm uninstall -g express
```
Depending on how your file and directory privileges are configured,
@@ -526,7 +526,7 @@ you might need to run this command with `sudo`.
Now install the new generator:
```console
```bash
$ npm install -g express-generator
```
@@ -549,7 +549,7 @@ Command options and use largely remain the same, with the following exceptions:
Execute the following command to create an Express 4 app:
```console
```bash
$ express app4
```
@@ -562,7 +562,7 @@ You will also notice that the `app.js` file is now a Node.js module, in contrast
After installing the dependencies, start the app by using the following command:
```console
```bash
$ npm start
```

2
en/guide/using-middleware.md
View File

@@ -255,7 +255,7 @@ Install the Node.js module for the required functionality, then load it in your
The following example illustrates installing and loading the cookie-parsing middleware function `cookie-parser`.
```console
```bash
$ npm install cookie-parser
```

2
en/guide/using-template-engines.md
View File

@@ -22,7 +22,7 @@ This defaults to the `views` directory in the application root directory.
Then install the corresponding template engine npm package; for example to install Pug:
```console
```bash
$ npm install pug --save
```

18
en/starter/generator.md
View File

@@ -13,20 +13,20 @@ Use the application generator tool, `express-generator`, to quickly create an ap
You can run the application generator with the `npx` command (available in Node.js 8.2.0).
```console
```bash
$ npx express-generator
```
For earlier Node versions, install the application generator as a global npm package and then launch it:
```console
```bash
$ npm install -g express-generator
$ express
```
Display the command options with the `-h` option:
```console
```bash
$ express -h
Usage: express [options] [dir]
@@ -48,7 +48,7 @@ $ express -h
For example, the following creates an Express app named _myapp_. The app will be created in a folder named _myapp_ in the current working directory and the view engine will be set to <a href="https://pugjs.org/" target="_blank" title="Pug documentation">Pug</a>:
```console
```bash
$ express --view=pug myapp
create : myapp
@@ -72,26 +72,26 @@ $ express --view=pug myapp
Then install dependencies:
```console
```bash
$ cd myapp
$ npm install
```
On MacOS or Linux, run the app with this command:
```console
```bash
$ DEBUG=myapp:* npm start
```
On Windows Command Prompt, use this command:
```console
```bash
> set DEBUG=myapp:* & npm start
```
On Windows PowerShell, use this command:
```console
```bash
PS> $env:DEBUG='myapp:*'; npm start
```
@@ -100,7 +100,7 @@ Then, load `http://localhost:3000/` in your browser to access the app.
The generated app has the following directory structure:
```console
```bash
.
├── app.js
├── bin

2
en/starter/hello-world.md
View File

@@ -43,7 +43,7 @@ The `req` (request) and `res` (response) are the exact same objects that Node pr
Run the app with the following command:
```console
```bash
$ node app.js
```

8
en/starter/installing.md
View File

@@ -14,7 +14,7 @@ Assuming you've already installed [Node.js](https://nodejs.org/), create a direc
* [Express 4.x](/{{ page.lang }}/4x/api.html) requires Node.js 0.10 or higher.
* [Express 5.x](/{{ page.lang }}/5x/api.html) requires Node.js 18 or higher.
```console
```bash
$ mkdir myapp
$ cd myapp
```
@@ -22,7 +22,7 @@ $ cd myapp
Use the `npm init` command to create a `package.json` file for your application.
For more information on how `package.json` works, see [Specifics of npm's package.json handling](https://docs.npmjs.com/files/package.json).
```console
```bash
$ npm init
```
@@ -37,13 +37,13 @@ Enter `app.js`, or whatever you want the name of the main file to be. If you wan
Now, install Express in the `myapp` directory and save it in the dependencies list. For example:
```console
```bash
$ npm install express
```
To install Express temporarily and not add it to the dependencies list:
```console
```bash
$ npm install express --no-save
```

4
en/starter/static-files.md
View File

@@ -28,7 +28,7 @@ app.use(express.static('public'))
Now, you can load the files that are in the `public` directory:
```plain-text
```text
http://localhost:3000/images/kitten.jpg
http://localhost:3000/css/style.css
http://localhost:3000/js/app.js
@@ -62,7 +62,7 @@ app.use('/static', express.static('public'))
Now, you can load the files that are in the `public` directory from the `/static` path prefix.
```plain-text
```text
http://localhost:3000/static/images/kitten.jpg
http://localhost:3000/static/css/style.css
http://localhost:3000/static/js/app.js

34
es/advanced/best-practice-performance.md
View File

@@ -197,23 +197,19 @@ En el desarrollo, normalmente establece las variables de entorno en el shell int
Con Upstart, utilice la palabra clave `env` en el archivo de trabajo. Por ejemplo:
<pre>
<code class="language-sh" translate="no">
```sh
# /etc/init/env.conf
env NODE_ENV=production
</code>
</pre>
```
Para obtener más información, consulte [Upstart Intro, Cookbook and Best Practices](http://upstart.ubuntu.com/cookbook/#environment-variables).
Con systemd, utilice la directiva `Environment` en el archivo unit. Por ejemplo:
<pre>
<code class="language-sh" translate="no">
```sh
# /etc/systemd/system/myservice.service
Environment=NODE_ENV=production
</code>
</pre>
```
Para obtener más información, consulte [Using Environment Variables In systemd Units](https://coreos.com/os/docs/latest/using-environment-variables-in-systemd-units.html).
@@ -274,8 +270,7 @@ Systemd es un administrador de servicios y sistemas Linux. La mayoría de las pr
Un archivo de configuración de servicio de systemd se denomina un _archivo unit_, con un nombre de archivo terminado en .service. A continuación, se muestra un archivo unit de ejemplo para gestionar directamente una aplicación Node (sustituya el texto en negrita por los valores de su sistema y su aplicación):
<pre>
<code class="language-sh" translate="no">
```sh
[Unit]
Description=Awesome Express App
@@ -303,8 +298,7 @@ Restart=always
[Install]
WantedBy=multi-user.target
</code>
</pre>
```
Para obtener más información sobre systemd, consulte [systemd reference (man page)](http://www.freedesktop.org/software/systemd/man/systemd.unit.html).
@@ -314,13 +308,13 @@ Puede instalar fácilmente StrongLoop Process Manager como un servicio systemd.
Para instalar StrongLoop PM como un servicio systemd:
```console
```bash
$ sudo sl-pm-install --systemd
```
A continuación, inicie el servicio con:
```console
```bash
$ sudo /usr/bin/systemctl start strong-pm
```
@@ -334,8 +328,7 @@ Un servicio de Upstart se define en un archivo de configuración de trabajo (tam
Cree un archivo denominado `myapp.conf` en `/etc/init/` con el siguiente contenido (sustituya el texto en negrita por los valores de su sistema y su aplicación):
<pre>
<code class="language-sh" translate="no">
```sh
# When to start the process
start on runlevel [2345]
@@ -363,8 +356,7 @@ respawn
# Limit restart attempt to 10 times within 10 seconds
respawn limit 10 10
</code>
</pre>
```
NOTA: este script requiere Upstart 1.4 o posterior, soportado en Ubuntu 12.04-14.10.
@@ -384,13 +376,13 @@ Puede instalar fácilmente StrongLoop Process Manager como un servicio Upstart.
Para instalar StrongLoop PM como un servicio Upstart 1.4:
```console
```bash
$ sudo sl-pm-install
```
A continuación, ejecute el servicio con:
```console
```bash
$ sudo /sbin/initctl start strong-pm
```
@@ -418,7 +410,7 @@ Cuando StrongLoop Process Manager (PM) ejecuta una aplicación, la ejecuta autom
Por ejemplo, suponiendo que ha desplegado la aplicación en prod.foo.com y que StrongLoop PM escucha en el puerto 8701 (el valor predeterminado), para establecer el tamaño de clúster en ocho utilizando slc:
```console
```bash
$ slc ctl -C http://prod.foo.com:8701 set-size my-app 8
```

63
es/advanced/best-practice-security.md
View File

@@ -60,20 +60,20 @@ Helmet es realmente una colección de nueve funciones de middleware más paquete
Instale Helmet como cualquier otro módulo:
```console
```bash
$ npm install --save helmet
```
A continuación, utilícelo en el código:
<pre>
<code class="language-javascript" translate="no">
...
var helmet = require('helmet');
app.use(helmet());
...
</code>
</pre>
```js
/// ...
const helmet = require('helmet')
app.use(helmet())
/// ...
```
### Como mínimo, inhabilitar la cabecera X-Powered-By
@@ -81,11 +81,9 @@ Si no desea utilizar Helmet, como mínimo, inhabilite la cabecera `X-Powered-By`
Por lo tanto, se recomienda desactivar la cabecera con el método `app.disable()`:
<pre>
<code class="language-javascript" translate="no">
app.disable('x-powered-by');
</code>
</pre>
```js
app.disable('x-powered-by')
```
Si utiliza `helmet.js`, lo hace automáticamente.
@@ -108,17 +106,15 @@ Si utiliza el nombre de cookie de sesión predeterminado, la aplicación puede q
Para evitar este problema, utilice nombres de cookie genéricos, por ejemplo, con el middleware [express-session](https://www.npmjs.com/package/express-session):
<pre>
<code class="language-javascript" translate="no">
var session = require('express-session');
```js
const session = require('express-session')
app.set('trust proxy', 1) // trust first proxy
app.use(session({
secret: 's3Cur3',
name : 'sessionId',
name: 'sessionId'
})
);
</code>
</pre>
)
```
### Establecer las opciones de seguridad de las cookies
@@ -132,26 +128,25 @@ Establezca las siguientes opciones de cookies para mejorar la seguridad:
A continuación, se muestra un ejemplo de uso del middleware [cookie-session](https://www.npmjs.com/package/cookie-session):
<pre>
<code class="language-javascript" translate="no">
var session = require('cookie-session');
var express = require('express');
var app = express();
```js
const session = require('cookie-session')
const express = require('express')
const app = express()
var expiryDate = new Date( Date.now() + 60 * 60 * 1000 ); // 1 hour
const expiryDate = new Date(Date.now() + 60 * 60 * 1000) // 1 hour
app.use(session({
name: 'session',
keys: ['key1', 'key2'],
cookie: { secure: true,
cookie: {
secure: true,
httpOnly: true,
domain: 'example.com',
path: 'foo/bar',
expires: expiryDate
}
})
);
</code>
</pre>
)
```
## Prevenir ataques de fuerza bruta a la autenticación
@@ -170,7 +165,7 @@ El uso de npm para gestionar las dependencias de la aplicación es muy útil y c
Desde npm@6, npm revisa automáticamente cada solicitud de instalación. También puedes utilizar 'npm audit' para analizar tu árbol de dependencias.
```console
```bash
$ npm audit
```
@@ -178,14 +173,14 @@ Si quieres mantener más seguro, considera [Snyk](https://snyk.io/).
Snyk ofrece tanto [herramienta de línea de comandos](https://www.npmjs.com/package/snyk) como una [integración de Github](https://snyk.io/docs/github) que comprueba tu aplicación contra [la base de datos de código abierto sobre vulnerabilidades de Snyk](https://snyk.io/vuln/) por cualquier vulnerabilidad conocida en tus dependencias. Instala la interfaz de línea de comandos:
```console
```bash
$ npm install -g snyk
$ cd your-app
```
Usa este comando para comprobar tu aplicación contra vulnerabilidades:
```console
```bash
$ snyk test
```

46
es/advanced/developing-template-engines.md
View File

@@ -13,38 +13,32 @@ Utilice el método `app.engine(ext, callback)` para crear su propio motor de pla
El siguiente código es un ejemplo de implementación de un motor de plantilla muy simple para la representación de archivos `.ntl`.
<pre>
<code class="language-javascript" translate="no">
var fs = require('fs'); // this engine requires the fs module
app.engine('ntl', function (filePath, options, callback) { // define the template engine
fs.readFile(filePath, function (err, content) {
if (err) return callback(new Error(err));
```js
const fs = require('fs') // this engine requires the fs module
app.engine('ntl', (filePath, options, callback) => { // define the template engine
fs.readFile(filePath, (err, content) => {
if (err) return callback(new Error(err))
// this is an extremely simple template engine
var rendered = content.toString().replace('#title#', '<title>'+ options.title +'</title>')
.replace('#message#', '<h1>'+ options.message +'</h1>');
return callback(null, rendered);
});
});
app.set('views', './views'); // specify the views directory
app.set('view engine', 'ntl'); // register the template engine
</code>
</pre>
const rendered = content.toString().replace('#title#', `<title>${options.title}</title>`)
.replace('#message#', `<h1>${options.message}</h1>`)
return callback(null, rendered)
})
})
app.set('views', './views') // specify the views directory
app.set('view engine', 'ntl') // register the template engine
```
La aplicación ahora podrá representar archivos `.ntl`. Cree un archivo denominado `index.ntl` en el directorio `views` con el siguiente contenido.
<pre>
<code class="language-javascript" translate="no">
```pug
#title#
#message#
</code>
</pre>
```
A continuación, cree la ruta siguiente en la aplicación.
<pre>
<code class="language-javascript" translate="no">
app.get('/', function (req, res) {
res.render('index', { title: 'Hey', message: 'Hello there!'});
});
</code>
</pre>
```js
app.get('/', (req, res) => {
res.render('index', { title: 'Hey', message: 'Hello there!' })
})
```
Cuando realice una solicitud a la página de inicio, `index.ntl` se representará como HTML.

22
es/guide/behind-proxies.md
View File

@@ -37,12 +37,12 @@ Una dirección IP, una subred o una matriz de direcciones IP y subredes de confi
Puede establecer direcciones IP de varias formas:
<pre>
<code class="language-js" translate="no">app.set('trust proxy', 'loopback') // specify a single subnet
```js
app.set('trust proxy', 'loopback') // specify a single subnet
app.set('trust proxy', 'loopback, 123.123.123.123') // specify a subnet and an address
app.set('trust proxy', 'loopback, linklocal, uniquelocal') // specify multiple subnets as CSV
app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal']) // specify multiple subnets as an array</code>
</pre>
app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal']) // specify multiple subnets as an array
```
Cuando se especifican, las direcciones IP o las subredes se excluyen del proceso de determinación de direcciones, y la dirección IP no de confianza más próxima al servidor de aplicaciones se establece como la dirección IP del cliente.
</td>
@@ -57,12 +57,14 @@ Confíe en la porción `n` entre el origen y el destino del servidor proxy acces
<td>Función</td>
<td markdown="1">
Implementación de confianza personalizada. Utilícela sólo si sabe lo que está haciendo.
<pre>
<code class="language-js" translate="no">app.set('trust proxy', function (ip) {
if (ip === '127.0.0.1' || ip === '123.123.123.123') return true; // trusted IPs
else return false;
});</code>
</pre>
```js
app.set('trust proxy', (ip) => {
if (ip === '127.0.0.1' || ip === '123.123.123.123') return true // trusted IPs
else return false
})
```
</td>
</tr>
</tbody>

22
es/guide/database-integration.md
View File

@@ -34,7 +34,7 @@ Estos son algunos de los muchos controladores de base de datos que hay disponibl
**Módulo**: [cassandra-driver](https://github.com/datastax/nodejs-driver)
**Instalación**
```console
```bash
$ npm install cassandra-driver
```
@@ -59,7 +59,7 @@ client.execute('select key from system.local', function(err, result) {
**Módulo**: [nano](https://github.com/dscape/nano)
**Instalación**
```console
```bash
$ npm install nano
```
@@ -92,7 +92,7 @@ books.list(function(err, body){
**Módulo**: [levelup](https://github.com/rvagg/node-levelup)
**Instalación**
```console
```bash
$ npm install level levelup leveldown
```
@@ -122,7 +122,7 @@ db.put('name', 'LevelUP', function (err) {
**Módulo**: [mysql](https://github.com/felixge/node-mysql/)
**Instalación**
```console
```bash
$ npm install mysql
```
@@ -155,7 +155,7 @@ connection.end();
**Módulo**: [mongodb](https://github.com/mongodb/node-mongodb-native)
**Instalación**
```console
```bash
$ npm install mongodb
```
@@ -188,7 +188,7 @@ Si desea un controlador de modelo de objeto para MongoDB, consulte [Mongoose](ht
**Módulo**: [apoc](https://github.com/hacksparrow/apoc)
**Instalación**
```console
```bash
$ npm install apoc
```
@@ -219,7 +219,7 @@ apoc.query('match (n) return n').exec().then(
NOTA: [Vea los requisitos previos de instalación](https://github.com/oracle/node-oracledb#-installation).
```console
```bash
$ npm install oracledb
```
@@ -265,7 +265,7 @@ getEmployee(101)
**Módulo**: [pg-promise](https://github.com/vitaly-t/pg-promise)
**Instalación**
```console
```bash
$ npm install pg-promise
```
@@ -293,7 +293,7 @@ db.one("SELECT $1 AS value", 123)
**Módulo**: [redis](https://github.com/mranney/node_redis)
**Instalación**
```console
```bash
$ npm install redis
```
@@ -331,7 +331,7 @@ client.hkeys('hash key', function (err, replies) {
**Módulo**: [sqlite3](https://github.com/mapbox/node-sqlite3)
**Instalación**
```console
```bash
$ npm install sqlite3
```
@@ -369,7 +369,7 @@ db.close();
**Módulo**: [elasticsearch](https://github.com/elastic/elasticsearch-js)
**Instalación**
```console
```bash
$ npm install elasticsearch
```

12
es/guide/debugging.md
View File

@@ -11,19 +11,19 @@ description: Learn how to enable and use debugging logs in Express.js applicatio
Para ver todos los registros internos utilizados en Express, establezca la variable de entorno `DEBUG` en `express:*` cuando inicie la aplicación.
```console
```bash
$ DEBUG=express:* node index.js
```
En Windows, utilice el mandato correspondiente.
```console
```bash
> set DEBUG=express:* & node index.js
```
La ejecución de este mandato en la aplicación predeterminada generada por el [generador de Express](/{{ page.lang }}/starter/generator.html) imprime la siguiente salida:
```console
```bash
$ DEBUG=express:* node ./bin/www
express:router:route new / +0ms
express:router:layer new / +1ms
@@ -69,7 +69,7 @@ $ DEBUG=express:* node ./bin/www
Cuando se realiza una solicitud a la aplicación, verá los registros especificados en el código de Express:
```console
```bash
express:router dispatching GET / +4h
express:router query : / +2ms
express:router expressInit : / +0ms
@@ -95,12 +95,12 @@ Una aplicación generada por el mandato `express` utiliza el módulo `debug`, y
Por ejemplo, si ha generado la aplicación con `$ express sample-app`, puede habilitar las sentencias de depuración con el siguiente mandato:
```console
```bash
$ DEBUG=sample-app:* node ./bin/www
```
Puede especificar más de un espacio de nombres de depuración asignando una lista separada por comas de nombres:
```console
```bash
$ DEBUG=http,mail,express:* node index.js
```

118
es/guide/error-handling.md
View File

@@ -11,105 +11,89 @@ description: Understand how Express.js handles errors in synchronous and asynchr
Defina las funciones de middleware de manejo de errores de la misma forma que otras funciones de middleware, excepto que las funciones de manejo de errores tienen cuatro argumentos en lugar de tres: `(err, req, res, next)`. Por ejemplo:
<pre>
<code class="language-javascript" translate="no">
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Something broke!');
});
</code>
</pre>
```js
app.use((err, req, res, next) => {
console.error(err.stack)
res.status(500).send('Something broke!')
})
```
El middleware de manejo de errores se define al final, después de otras llamadas de rutas y `app.use()`; por ejemplo:
<pre>
<code class="language-javascript" translate="no">
var bodyParser = require('body-parser');
var methodOverride = require('method-override');
```js
const bodyParser = require('body-parser')
const methodOverride = require('method-override')
app.use(bodyParser());
app.use(methodOverride());
app.use(function(err, req, res, next) {
app.use(bodyParser())
app.use(methodOverride())
app.use((err, req, res, next) => {
// logic
});
</code>
</pre>
})
```
Las respuestas desde una función de middleware pueden estar en el formato que prefiera, por ejemplo, una página de errores HTML, un mensaje simple o una serie JSON.
A efectos de la organización (y de infraestructura de nivel superior), puede definir varias funciones de middleware de manejo de errores, de la misma forma que con las funciones de middleware normales. Por ejemplo, si desea definir un manejador de errores para las solicitudes realizadas utilizando `XHR`, y las que no lo tienen, puede utilizar los siguientes mandatos:
<pre>
<code class="language-javascript" translate="no">
var bodyParser = require('body-parser');
var methodOverride = require('method-override');
```js
const bodyParser = require('body-parser')
const methodOverride = require('method-override')
app.use(bodyParser());
app.use(methodOverride());
app.use(logErrors);
app.use(clientErrorHandler);
app.use(errorHandler);
</code>
</pre>
app.use(bodyParser())
app.use(methodOverride())
app.use(logErrors)
app.use(clientErrorHandler)
app.use(errorHandler)
```
En este ejemplo, los `logErrors` genéricos pueden escribir información de solicitudes y errores en `stderr`, por ejemplo:
<pre>
<code class="language-javascript" translate="no">
```js
function logErrors (err, req, res, next) {
console.error(err.stack);
next(err);
console.error(err.stack)
next(err)
}
</code>
</pre>
```
También en este ejemplo, `clientErrorHandler` se define de la siguiente manera; en este caso, el error se pasa de forma explícita al siguiente:
<pre>
<code class="language-javascript" translate="no">
```js
function clientErrorHandler (err, req, res, next) {
if (req.xhr) {
res.status(500).send({ error: 'Something failed!' });
res.status(500).send({ error: 'Something failed!' })
} else {
next(err);
next(err)
}
}
</code>
</pre>
```
La función que detecta todos los errores de `errorHandler` puede implementarse de la siguiente manera:
<pre>
<code class="language-javascript" translate="no">
```js
function errorHandler (err, req, res, next) {
res.status(500);
res.render('error', { error: err });
res.status(500)
res.render('error', { error: err })
}
</code>
</pre>
```
Si pasa cualquier valor a la función `next()` (excepto la serie `'route'`), Express considera que la solicitud actual tiene un error y omitirá las restantes funciones de middleware y direccionamiento que no son de manejo de errores. Si desea manejar ese error de alguna manera, deberá crear una ruta de manejo de errores como se describe en la siguiente sección.
Si tiene un manejador de rutas con varias funciones de devolución de llamada, puede utilizar el parámetro `route` para omitir el siguiente manejador de rutas. Por ejemplo:
<pre>
<code class="language-javascript" translate="no">
```js
app.get('/a_route_behind_paywall',
function checkIfPaidSubscriber(req, res, next) {
(req, res, next) => {
if (!req.user.hasPaid) {
// continue handling this request
next('route');
next('route')
}
}, function getPaidContent(req, res, next) {
PaidContent.find(function(err, doc) {
if(err) return next(err);
res.json(doc);
});
});
</code>
</pre>
}, (req, res, next) => {
PaidContent.find((err, doc) => {
if (err) return next(err)
res.json(doc)
})
})
```
En este ejemplo, se omitirá el manejador `getPaidContent`, pero los restantes manejadores en `app` para `/a_route_behind_paywall` continuarán ejecutándose.
<div class="doc-box doc-info" markdown="1">
@@ -130,14 +114,12 @@ Si invoca `next()` con un error después de haber empezado a escribir la respues
Por lo tanto, cuando añade un manejador de errores personalizado, se recomienda delegar en los mecanismos de manejo de errores predeterminados de Express, cuando las cabeceras ya se han enviado al cliente:
<pre>
<code class="language-javascript" translate="no">
```js
function errorHandler (err, req, res, next) {
if (res.headersSent) {
return next(err);
return next(err)
}
res.status(500);
res.render('error', { error: err });
res.status(500)
res.render('error', { error: err })
}
</code>
</pre>
```

246
es/guide/migrating-4.md
View File

@@ -96,14 +96,12 @@ En la mayoría de los casos, sólo tiene que sustituir el middleware de la versi
En la versión 4, puede utilizar un parámetro de variable para definir la vía de acceso donde se cargan las funciones de middleware y, a continuación, leer el valor del parámetro en el manejador de rutas.
Por ejemplo:
<pre>
<code class="language-javascript" translate="no">
```js
app.use('/book/:id', function (req, res, next) {
console.log('ID:', req.params.id);
next();
});
</code>
</pre>
console.log('ID:', req.params.id)
next()
})
```
<h3 id="routing">
El sistema de direccionamiento
</h3>
@@ -122,20 +120,18 @@ El nuevo método `app.route()` permite crear manejadores de rutas encadenables p
A continuación, se muestra un ejemplo de manejadores de rutas encadenados que se definen utilizando la función `app.route()`.
<pre>
<code class="language-javascript" translate="no">
```js
app.route('/book')
.get(function (req, res) {
res.send('Get a random book');
res.send('Get a random book')
})
.post(function (req, res) {
res.send('Add a book');
res.send('Add a book')
})
.put(function (req, res) {
res.send('Update the book');
});
</code>
</pre>
res.send('Update the book')
})
```
<h4 id="express-router">Clase <code>express.Router</code></h4>
@@ -145,38 +141,36 @@ El siguiente ejemplo crea un direccionador como un módulo, carga el middleware
Por ejemplo, cree un archivo de direccionador denominado `birds.js` en el directorio de la aplicación, con el siguiente contenido:
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var router = express.Router();
```js
var express = require('express')
var router = express.Router()
// middleware specific to this router
router.use(function timeLog (req, res, next) {
console.log('Time: ', Date.now());
next();
});
console.log('Time: ', Date.now())
next()
})
// define the home page route
router.get('/', function (req, res) {
res.send('Birds home page');
});
res.send('Birds home page')
})
// define the about route
router.get('/about', function (req, res) {
res.send('About birds');
});
res.send('About birds')
})
module.exports = router;
</code>
</pre>
module.exports = router
```
A continuación, cargue el módulo de direccionador en la aplicación:
<pre>
<code class="language-javascript" translate="no">
var birds = require('./birds');
...
app.use('/birds', birds);
</code>
</pre>
```js
var birds = require('./birds')
/// ...
app.use('/birds', birds)
```
La aplicación ahora podrá manejar solicitudes a las vías de acceso `/birds` y `/birds/about`, e invocará el middleware `timeLog` que es específico de la ruta.
@@ -309,48 +303,45 @@ Aplicación versión 3
Considere una aplicación Express v.3 con el siguiente archivo `app.js`:
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var routes = require('./routes');
var user = require('./routes/user');
var http = require('http');
var path = require('path');
```js
var express = require('express')
var routes = require('./routes')
var user = require('./routes/user')
var http = require('http')
var path = require('path')
var app = express();
var app = express()
// all environments
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'pug');
app.use(express.favicon());
app.use(express.logger('dev'));
app.use(express.methodOverride());
app.use(express.session({ secret: 'your secret here' }));
app.use(express.bodyParser());
app.use(app.router);
app.use(express.static(path.join(__dirname, 'public')));
app.set('port', process.env.PORT || 3000)
app.set('views', path.join(__dirname, 'views'))
app.set('view engine', 'pug')
app.use(express.favicon())
app.use(express.logger('dev'))
app.use(express.methodOverride())
app.use(express.session({ secret: 'your secret here' }))
app.use(express.bodyParser())
app.use(app.router)
app.use(express.static(path.join(__dirname, 'public')))
// development only
if ('development' == app.get('env')) {
app.use(express.errorHandler());
if (app.get('env') === 'development') {
app.use(express.errorHandler())
}
app.get('/', routes.index);
app.get('/users', user.list);
app.get('/', routes.index)
app.get('/users', user.list)
http.createServer(app).listen(app.get('port'), function () {
console.log('Express server listening on port ' + app.get('port'));
});
</code>
</pre>
console.log('Express server listening on port ' + app.get('port'))
})
```
<h4 id=""><code>package.json</code></h4>
El archivo `package.json` de la versión 3 correspondiente será similar al siguiente:
<pre>
<code class="language-javascript" translate="no">
```json
{
"name": "application-name",
"version": "0.0.1",
@@ -363,8 +354,7 @@ El archivo `package.json` de la versión 3 correspondiente será similar al sigu
"pug": "*"
}
}
</code>
</pre>
```
<h3 id="">
Proceso
@@ -372,7 +362,7 @@ Proceso
Para empezar el proceso de migración, instale el middleware necesario para la aplicación Express 4 y actualice Express y Pug a su versión respectiva más reciente con el siguiente mandato:
```console
```bash
$ npm install serve-favicon morgan method-override express-session body-parser multer errorhandler express@latest pug@latest --save
```
@@ -394,8 +384,7 @@ Realice los cambios siguientes en `app.js`:
La ejecución del mandato `npm` anterior actualizará `package.json` de la siguiente manera:
<pre>
<code class="language-javascript" translate="no">
```json
{
"name": "application-name",
"version": "0.0.1",
@@ -415,68 +404,69 @@ La ejecución del mandato `npm` anterior actualizará `package.json` de la sigui
"serve-favicon": "^2.0.1"
}
}
</code>
</pre>
```
<h4 id=""><code>app.js</code></h4>
A continuación, elimine el código no válido, cargue el middleware necesario y realice otros cambios según sea necesario. El archivo `app.js` será parecido al siguiente:
<pre>
<code class="language-javascript" translate="no">
var http = require('http');
var express = require('express');
var routes = require('./routes');
var user = require('./routes/user');
var path = require('path');
```js
var http = require('http')
var express = require('express')
var routes = require('./routes')
var user = require('./routes/user')
var path = require('path')
var favicon = require('serve-favicon');
var logger = require('morgan');
var methodOverride = require('method-override');
var session = require('express-session');
var bodyParser = require('body-parser');
var multer = require('multer');
var errorHandler = require('errorhandler');
var favicon = require('serve-favicon')
var logger = require('morgan')
var methodOverride = require('method-override')
var session = require('express-session')
var bodyParser = require('body-parser')
var multer = require('multer')
var errorHandler = require('errorhandler')
var app = express();
var app = express()
// all environments
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'pug');
app.use(favicon(__dirname + '/public/favicon.ico'));
app.use(logger('dev'));
app.use(methodOverride());
app.use(session({ resave: true,
app.set('port', process.env.PORT || 3000)
app.set('views', path.join(__dirname, 'views'))
app.set('view engine', 'pug')
app.use(favicon(path.join(__dirname, '/public/favicon.ico')))
app.use(logger('dev'))
app.use(methodOverride())
app.use(session({
resave: true,
saveUninitialized: true,
secret: 'uwotm8' }));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(multer());
app.use(express.static(path.join(__dirname, 'public')));
secret: 'uwotm8'
}))
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({ extended: true }))
app.use(multer())
app.use(express.static(path.join(__dirname, 'public')))
app.get('/', routes.index);
app.get('/users', user.list);
app.get('/', routes.index)
app.get('/users', user.list)
// error handling middleware should be loaded after the loading the routes
if ('development' == app.get('env')) {
app.use(errorHandler());
if (app.get('env') === 'development') {
app.use(errorHandler())
}
var server = http.createServer(app);
server.listen(app.get('port'), function(){
console.log('Express server listening on port ' + app.get('port'));
});
</code>
</pre>
var server = http.createServer(app)
server.listen(app.get('port'), () => {
console.log('Express server listening on port ' + app.get('port'))
})
```
<div class="doc-box doc-info" markdown="1">
A menos que necesite trabajar directamente con el módulo `http` (socket.io/SPDY/HTTPS), no es necesario cargarlo y la aplicación puede iniciarse simplemente de la siguiente manera:
<pre>
<code class="language-js" translate="no">app.listen(app.get('port'), function(){
console.log('Express server listening on port ' + app.get('port'));
});</code>
</pre>
```js
app.listen(app.get('port'), function () {
console.log('Express server listening on port ' + app.get('port'))
})
```
</div>
<h3 id="">Ejecutar la aplicación</h3>
@@ -484,7 +474,7 @@ A menos que necesite trabajar directamente con el módulo `http` (socket.io/SPDY
El proceso de migración está completo y la aplicación es ahora una aplicación
Express 4. Para confirmarlo, inicie la aplicación utilizando el siguiente mandato:
```console
```bash
$ node .
```
@@ -498,7 +488,7 @@ La herramienta de línea de mandatos para generar una aplicación Express contin
Si ya ha instalado el generador de aplicaciones Express 3 en el sistema, debe desinstalarlo:
```console
```bash
$ npm uninstall -g express
```
@@ -506,7 +496,7 @@ Dependiendo de cómo se configuren los privilegios de archivos y directorios, de
A continuación, instale el nuevo generador:
```console
```bash
$ npm install -g express-generator
```
@@ -527,7 +517,7 @@ Las opciones de mandato y el uso continúan prácticamente iguales, con las sigu
Ejecute el siguiente mandato para crear una aplicación Express 4:
```console
```bash
$ express app4
```
@@ -537,7 +527,7 @@ También observará que el archivo `app.js` es ahora un módulo Node.js, a difer
Después de instalar las dependencias, inicie la aplicación utilizando el siguiente mandato:
```console
```bash
$ npm start
```
@@ -551,23 +541,19 @@ sin extensión son obligatorios para crear una aplicación Express o iniciar la
Para eliminar el directorio `www` y dejarlo todo como en "Express 3",
suprima la línea `module.exports = app;` al final del archivo `app.js` y pegue el siguiente código en su lugar:
<pre>
<code class="language-javascript" translate="no">
app.set('port', process.env.PORT || 3000);
```js
app.set('port', process.env.PORT || 3000)
var server = app.listen(app.get('port'), function () {
debug('Express server listening on port ' + server.address().port);
});
</code>
</pre>
debug('Express server listening on port ' + server.address().port)
})
```
Asegúrese de cargar el módulo `debug` encima del archivo `app.js` utilizando el código siguiente:
<pre>
<code class="language-javascript" translate="no">
var debug = require('debug')('app4');
</code>
</pre>
```js
var debug = require('debug')('app4')
```
A continuación, cambie `"start": "node ./bin/www"` en el archivo `package.json` por `"start": "node app.js"`.

2
es/guide/migrating-5.md
View File

@@ -17,7 +17,7 @@ Express 5 no es muy diferente de Express 4: los cambios en la API no son tan sig
Para instalar el release alpha más reciente y obtener una vista previa de Express 5, especifique el siguiente mandato en el directorio raíz de la aplicación:
```console
```bash
$ npm install "express@^{{ site.data.express.next_version }}" --save
```

307
es/guide/routing.md
View File

@@ -14,17 +14,15 @@ Para ver una introducción al direccionamiento, consulte [Direccionamiento bási
El siguiente código es un ejemplo de una ruta muy básica.
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
```js
const express = require('express')
const app = express()
// respond with "hello world" when a GET request is made to the homepage
app.get('/', function(req, res) {
res.send('hello world');
});
</code>
</pre>
app.get('/', (req, res) => {
res.send('hello world')
})
```
<h2 id="route-methods">Métodos de ruta</h2>
@@ -32,19 +30,17 @@ Un método de ruta se deriva de uno de los métodos HTTP y se adjunta a una inst
El siguiente código es un ejemplo de las rutas que se definen para los métodos GET y POST a la raíz de la aplicación.
<pre>
<code class="language-javascript" translate="no">
```js
// GET method route
app.get('/', function (req, res) {
res.send('GET request to the homepage');
});
app.get('/', (req, res) => {
res.send('GET request to the homepage')
})
// POST method route
app.post('/', function (req, res) {
res.send('POST request to the homepage');
});
</code>
</pre>
app.post('/', (req, res) => {
res.send('POST request to the homepage')
})
```
Express da soporte a los siguientes métodos de direccionamiento que se corresponden con los métodos HTTP: `get`, `post`, `put`, `head`, `delete`, `options`, `trace`, `copy`, `lock`, `mkcol`, `move`, `purge`, `propfind`, `proppatch`, `unlock`, `report`, `mkactivity`, `checkout`, `merge`, `m-search`, `notify`, `subscribe`, `unsubscribe`, `patch`, `search` y `connect`.
@@ -56,14 +52,12 @@ Hay un método de direccionamiento especial, `app.all()`, que no se deriva de ni
En el siguiente ejemplo, el manejador se ejecutará para las solicitudes a "/secret", tanto si utiliza GET, POST, PUT, DELETE, como cualquier otro método de solicitud HTTP soportado en el [módulo http](https://nodejs.org/api/http.html#http_http_methods).
<pre>
<code class="language-javascript" translate="no">
app.all('/secret', function (req, res, next) {
console.log('Accessing the secret section ...');
next(); // pass control to the next handler
});
</code>
</pre>
```js
app.all('/secret', (req, res, next) => {
console.log('Accessing the secret section ...')
next() // pass control to the next handler
})
```
<h2 id="route-paths">Vías de acceso de ruta</h2>
@@ -81,75 +75,61 @@ Estos son algunos ejemplos de vías de acceso de ruta basadas en series.
Esta vía de acceso de ruta coincidirá con las solicitudes a la ruta raíz, `/`.
<pre>
<code class="language-javascript" translate="no">
app.get('/', function (req, res) {
res.send('root');
});
</code>
</pre>
```js
app.get('/', (req, res) => {
res.send('root')
})
```
Esta vía de acceso de ruta coincidirá con las solicitudes a `/about`.
<pre>
<code class="language-javascript" translate="no">
app.get('/about', function (req, res) {
res.send('about');
});
</code>
</pre>
```js
app.get('/about', (req, res) => {
res.send('about')
})
```
Esta vía de acceso de ruta coincidirá con las solicitudes a `/random.text`.
<pre>
<code class="language-javascript" translate="no">
app.get('/random.text', function (req, res) {
res.send('random.text');
});
</code>
</pre>
```js
app.get('/random.text', (req, res) => {
res.send('random.text')
})
```
Estos son algunos ejemplos de vías de acceso de ruta basadas en patrones de serie.
Esta vía de acceso de ruta coincidirá con `acd` y `abcd`.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab?cd', function(req, res) {
res.send('ab?cd');
});
</code>
</pre>
```js
app.get('/ab?cd', (req, res) => {
res.send('ab?cd')
})
```
Esta vía de acceso de ruta coincidirá con `abcd`, `abbcd`, `abbbcd`, etc.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab+cd', function(req, res) {
res.send('ab+cd');
});
</code>
</pre>
```js
app.get('/ab+cd', (req, res) => {
res.send('ab+cd')
})
```
Esta vía de acceso de ruta coincidirá con `abcd`, `abxcd`, `abRABDOMcd`, `ab123cd`, etc.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab*cd', function(req, res) {
res.send('ab*cd');
});
</code>
</pre>
```js
app.get('/ab*cd', (req, res) => {
res.send('ab*cd')
})
```
Esta vía de acceso de ruta coincidirá con `/abe` y `/abcde`.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab(cd)?e', function(req, res) {
res.send('ab(cd)?e');
});
</code>
</pre>
```js
app.get('/ab(cd)?e', (req, res) => {
res.send('ab(cd)?e')
})
```
<div class="doc-box doc-info" markdown="1">
Los caracteres ?, +, * y () son subconjuntos de sus contrapartidas de expresiones regulares. El guión (-) y el punto (.) se interpretan literalmente en las vías de acceso basadas en series.
@@ -159,23 +139,19 @@ Ejemplos de vías de acceso de ruta basadas en expresiones regulares:
Esta vía de acceso de ruta coincidirá con cualquier valor con una "a" en el nombre de la ruta.
<pre>
<code class="language-javascript" translate="no">
app.get(/a/, function(req, res) {
res.send('/a/');
});
</code>
</pre>
```js
app.get(/a/, (req, res) => {
res.send('/a/')
})
```
Esta vía de acceso de ruta coincidirá con `butterfly` y `dragonfly`, pero no con `butterflyman`, `dragonfly man`, etc.
<pre>
<code class="language-javascript" translate="no">
app.get(/.*fly$/, function(req, res) {
res.send('/.*fly$/');
});
</code>
</pre>
```js
app.get(/.*fly$/, (req, res) => {
res.send('/.*fly$/')
})
```
<h2 id="route-handlers">Manejadores de rutas</h2>
@@ -185,71 +161,62 @@ Los manejadores de rutas pueden tener la forma de una función, una matriz de fu
Una función de devolución de llamada individual puede manejar una ruta. Por ejemplo:
<pre>
<code class="language-javascript" translate="no">
app.get('/example/a', function (req, res) {
res.send('Hello from A!');
});
</code>
</pre>
```js
app.get('/example/a', (req, res) => {
res.send('Hello from A!')
})
```
Más de una función de devolución de llamada puede manejar una ruta (asegúrese de especificar el objeto `next`). Por ejemplo:
<pre>
<code class="language-javascript" translate="no">
app.get('/example/b', function (req, res, next) {
console.log('the response will be sent by the next function ...');
next();
}, function (req, res) {
res.send('Hello from B!');
});
</code>
</pre>
```js
app.get('/example/b', (req, res, next) => {
console.log('the response will be sent by the next function ...')
next()
}, (req, res) => {
res.send('Hello from B!')
})
```
Una matriz de funciones de devolución de llamada puede manejar una ruta. Por ejemplo:
<pre>
<code class="language-javascript" translate="no">
var cb0 = function (req, res, next) {
console.log('CB0');
next();
```js
const cb0 = function (req, res, next) {
console.log('CB0')
next()
}
var cb1 = function (req, res, next) {
console.log('CB1');
next();
const cb1 = function (req, res, next) {
console.log('CB1')
next()
}
var cb2 = function (req, res) {
res.send('Hello from C!');
const cb2 = function (req, res) {
res.send('Hello from C!')
}
app.get('/example/c', [cb0, cb1, cb2]);
</code>
</pre>
app.get('/example/c', [cb0, cb1, cb2])
```
Una combinación de funciones independientes y matrices de funciones puede manejar una ruta. Por ejemplo:
<pre>
<code class="language-javascript" translate="no">
var cb0 = function (req, res, next) {
console.log('CB0');
next();
```js
const cb0 = function (req, res, next) {
console.log('CB0')
next()
}
var cb1 = function (req, res, next) {
console.log('CB1');
next();
const cb1 = function (req, res, next) {
console.log('CB1')
next()
}
app.get('/example/d', [cb0, cb1], function (req, res, next) {
console.log('the response will be sent by the next function ...');
next();
}, function (req, res) {
res.send('Hello from D!');
});
</code>
</pre>
app.get('/example/d', [cb0, cb1], (req, res, next) => {
console.log('the response will be sent by the next function ...')
next()
}, (req, res) => {
res.send('Hello from D!')
})
```
<h2 id="response-methods">Métodos de respuesta</h2>
@@ -274,20 +241,18 @@ Como la vía de acceso se especifica en una única ubicación, la creación de r
A continuación, se muestra un ejemplo de manejadores de rutas encadenados que se definen utilizando `app.route()`.
<pre>
<code class="language-javascript" translate="no">
```js
app.route('/book')
.get(function(req, res) {
res.send('Get a random book');
.get((req, res) => {
res.send('Get a random book')
})
.post(function(req, res) {
res.send('Add a book');
.post((req, res) => {
res.send('Add a book')
})
.put(function(req, res) {
res.send('Update the book');
});
</code>
</pre>
.put((req, res) => {
res.send('Update the book')
})
```
<h2 id="express-router">express.Router</h2>
@@ -297,37 +262,35 @@ El siguiente ejemplo crea un direccionador como un módulo, carga una función d
Cree un archivo de direccionador denominado `birds.js` en el directorio de la aplicación, con el siguiente contenido:
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var router = express.Router();
```js
const express = require('express')
const router = express.Router()
// middleware that is specific to this router
router.use(function timeLog(req, res, next) {
console.log('Time: ', Date.now());
next();
});
router.use((req, res, next) => {
console.log('Time: ', Date.now())
next()
})
// define the home page route
router.get('/', function(req, res) {
res.send('Birds home page');
});
router.get('/', (req, res) => {
res.send('Birds home page')
})
// define the about route
router.get('/about', function(req, res) {
res.send('About birds');
});
router.get('/about', (req, res) => {
res.send('About birds')
})
module.exports = router;
</code>
</pre>
module.exports = router
```
A continuación, cargue el módulo de direccionador en la aplicación:
<pre>
<code class="language-javascript" translate="no">
var birds = require('./birds');
...
app.use('/birds', birds);
</code>
</pre>
```js
const birds = require('./birds')
/// ...
app.use('/birds', birds)
```
La aplicación ahora podrá manejar solicitudes a `/birds` y `/birds/about`, así como invocar la función de middleware `timeLog` que es específica de la ruta.

227
es/guide/using-middleware.md
View File

@@ -39,152 +39,135 @@ Enlace el middleware de nivel de aplicación a una instancia del [objeto de apli
Este ejemplo muestra una función de middleware sin ninguna vía de acceso de montaje. La función se ejecuta cada vez que la aplicación recibe una solicitud.
<pre>
<code class="language-javascript" translate="no">
var app = express();
```js
const app = express()
app.use(function (req, res, next) {
console.log('Time:', Date.now());
next();
});
</code>
</pre>
app.use((req, res, next) => {
console.log('Time:', Date.now())
next()
})
```
Este ejemplo muestra una función de middleware montada en la vía de acceso `/user/:id`. La función se ejecuta para cualquier tipo de solicitud HTTP en la vía de acceso `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.use('/user/:id', function (req, res, next) {
console.log('Request Type:', req.method);
next();
});
</code>
</pre>
```js
app.use('/user/:id', (req, res, next) => {
console.log('Request Type:', req.method)
next()
})
```
Este ejemplo muestra una ruta y su función de manejador (sistema de middleware). La función maneja las solicitudes GET a la vía de acceso `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.get('/user/:id', function (req, res, next) {
res.send('USER');
});
</code>
</pre>
```js
app.get('/user/:id', (req, res, next) => {
res.send('USER')
})
```
A continuación, se muestra un ejemplo de carga de una serie de funciones de middleware en un punto de montaje, con una vía de acceso de montaje.
Ilustra una subpila de middleware que imprime información de solicitud para cualquier tipo de solicitud HTTP en la vía de acceso `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.use('/user/:id', function(req, res, next) {
console.log('Request URL:', req.originalUrl);
next();
}, function (req, res, next) {
console.log('Request Type:', req.method);
next();
});
</code>
</pre>
```js
app.use('/user/:id', (req, res, next) => {
console.log('Request URL:', req.originalUrl)
next()
}, (req, res, next) => {
console.log('Request Type:', req.method)
next()
})
```
Los manejadores de rutas permiten definir varias rutas para una vía de acceso. El ejemplo siguiente define dos rutas para las solicitudes GET a la vía de acceso `/user/:id`. La segunda ruta no dará ningún problema, pero nunca se invocará, ya que la primera ruta finaliza el ciclo de solicitud/respuestas.
Este ejemplo muestra una subpila de middleware que maneja solicitudes GET a la vía de acceso `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.get('/user/:id', function (req, res, next) {
console.log('ID:', req.params.id);
next();
}, function (req, res, next) {
res.send('User Info');
});
```js
app.get('/user/:id', (req, res, next) => {
console.log('ID:', req.params.id)
next()
}, (req, res, next) => {
res.send('User Info')
})
// handler for the /user/:id path, which prints the user ID
app.get('/user/:id', function (req, res, next) {
res.end(req.params.id);
});
</code>
</pre>
app.get('/user/:id', (req, res, next) => {
res.end(req.params.id)
})
```
Para omitir el resto de las funciones de middleware de una pila de middleware de direccionador, invoque `next('route')` para pasar el control a la siguiente ruta.
**NOTA**: `next('route')` sólo funcionará en las funciones de middleware que se hayan cargado utilizando las funciones `app.METHOD()` o `router.METHOD()`.
Este ejemplo muestra una subpila de middleware que maneja solicitudes GET a la vía de acceso `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.get('/user/:id', function (req, res, next) {
```js
app.get('/user/:id', (req, res, next) => {
// if the user ID is 0, skip to the next route
if (req.params.id == 0) next('route');
if (req.params.id === '0') next('route')
// otherwise pass the control to the next middleware function in this stack
else next(); //
}, function (req, res, next) {
else next() //
}, (req, res, next) => {
// render a regular page
res.render('regular');
});
res.render('regular')
})
// handler for the /user/:id path, which renders a special page
app.get('/user/:id', function (req, res, next) {
res.render('special');
});
</code>
</pre>
app.get('/user/:id', (req, res, next) => {
res.render('special')
})
```
<h2 id='middleware.router'>Middleware de nivel de direccionador</h2>
El middleware de nivel de direccionador funciona de la misma manera que el middleware de nivel de aplicación, excepto que está enlazado a una instancia de `express.Router()`.
<pre>
<code class="language-javascript" translate="no">
var router = express.Router();
</code>
</pre>
```js
const router = express.Router()
```
Cargue el middleware de nivel de direccionador utilizando las funciones `router.use()` y `router.METHOD()`.
El siguiente código de ejemplo replica el sistema de middleware que se ha mostrado anteriormente para el middleware de nivel de aplicación, utilizando el middleware de nivel de direccionador:
<pre>
<code class="language-javascript" translate="no">
var app = express();
var router = express.Router();
```js
const app = express()
const router = express.Router()
// a middleware function with no mount path. This code is executed for every request to the router
router.use(function (req, res, next) {
console.log('Time:', Date.now());
next();
});
router.use((req, res, next) => {
console.log('Time:', Date.now())
next()
})
// a middleware sub-stack shows request info for any type of HTTP request to the /user/:id path
router.use('/user/:id', function(req, res, next) {
console.log('Request URL:', req.originalUrl);
next();
}, function (req, res, next) {
console.log('Request Type:', req.method);
next();
});
router.use('/user/:id', (req, res, next) => {
console.log('Request URL:', req.originalUrl)
next()
}, (req, res, next) => {
console.log('Request Type:', req.method)
next()
})
// a middleware sub-stack that handles GET requests to the /user/:id path
router.get('/user/:id', function (req, res, next) {
router.get('/user/:id', (req, res, next) => {
// if the user ID is 0, skip to the next router
if (req.params.id == 0) next('route');
if (req.params.id === '0') next('route')
// otherwise pass control to the next middleware function in this stack
else next(); //
}, function (req, res, next) {
else next() //
}, (req, res, next) => {
// render a regular page
res.render('regular');
});
res.render('regular')
})
// handler for the /user/:id path, which renders a special page
router.get('/user/:id', function (req, res, next) {
console.log(req.params.id);
res.render('special');
});
router.get('/user/:id', (req, res, next) => {
console.log(req.params.id)
res.render('special')
})
// mount the router on the app
app.use('/', router);
</code>
</pre>
app.use('/', router)
```
<h2 id='middleware.error-handling'>Middleware de manejo de errores</h2>
<div class="doc-box doc-notice" markdown="1">
@@ -193,14 +176,12 @@ El middleware de manejo de errores siempre utiliza *cuatro* argumentos. Debe pr
Defina las funciones de middleware de manejo de errores de la misma forma que otras funciones de middleware, excepto con cuatro argumentos en lugar de tres, específicamente con la firma `(err, req, res, next)`:
<pre>
<code class="language-javascript" translate="no">
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Something broke!');
});
</code>
</pre>
```js
app.use((err, req, res, next) => {
console.error(err.stack)
res.status(500).send('Something broke!')
})
```
Para obtener detalles sobre el middleware de manejo de errores, consulte: [Manejo de errores](/{{ page.lang }}/guide/error-handling.html).
@@ -229,9 +210,8 @@ El objeto `options` opcional puede tener las siguientes propiedades:
A continuación, se muestra un ejemplo de uso de la función de middleware `express.static` con un objeto de opciones elaboradas:
<pre>
<code class="language-javascript" translate="no">
var options = {
```js
const options = {
dotfiles: 'ignore',
etag: false,
extensions: ['htm', 'html'],
@@ -239,23 +219,20 @@ var options = {
maxAge: '1d',
redirect: false,
setHeaders: function (res, path, stat) {
res.set('x-timestamp', Date.now());
res.set('x-timestamp', Date.now())
}
}
app.use(express.static('public', options));
</code>
</pre>
app.use(express.static('public', options))
```
Puede tener más de un directorio estático para cada aplicación:
<pre>
<code class="language-javascript" translate="no">
app.use(express.static('public'));
app.use(express.static('uploads'));
app.use(express.static('files'));
</code>
</pre>
```js
app.use(express.static('public'))
app.use(express.static('uploads'))
app.use(express.static('files'))
```
Para obtener más detalles sobre la función `serve-static` y sus opciones, consulte la documentación de [serve-static](https://github.com/expressjs/serve-static).
@@ -267,19 +244,17 @@ Instale el módulo Node.js para la funcionalidad necesaria y cárguelo en la apl
El siguiente ejemplo ilustra la instalación y carga de la función de middleware de análisis de cookies `cookie-parser`.
```console
```bash
$ npm install cookie-parser
```
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
var cookieParser = require('cookie-parser');
```js
const express = require('express')
const app = express()
const cookieParser = require('cookie-parser')
// load the cookie-parsing middleware
app.use(cookieParser());
</code>
</pre>
app.use(cookieParser())
```
Para ver una lista parcial de las funciones de middleware de terceros que más se utilizan con Express, consulte: [Middleware de terceros](../resources/middleware.html).

28
es/guide/using-template-engines.md
View File

@@ -16,9 +16,9 @@ Para que Express pueda representar archivos de plantilla, deben establecerse los
A continuación, instale el paquete npm de motor de plantilla correspondiente:
```console
```bash
$ npm install pug --save
```console
```bash
<div class="doc-box doc-notice" markdown="1">
Los motores de plantilla compatibles con Express como, por ejemplo, Pug exportan una función denominada `__express(filePath, options, callback)`, que es invocada por la función `res.render()` para representar el código de plantilla.
@@ -28,33 +28,27 @@ Algunos motores de plantilla no siguen esta convención. La biblioteca [Consolid
Una vez establecida la propiedad view engine, no tiene que especificar el motor ni cargar el módulo de motor de plantilla en la aplicación; Express carga el módulo internamente, como se muestra a continuación (para el ejemplo anterior).
<pre>
<code class="language-javascript" translate="no">
```js
app.set('view engine', 'pug');
</code>
</pre>
```
Cree un archivo de plantilla Pug denominado `index.pug` en el directorio `views`, con el siguiente contenido:
<pre>
<code class="language-javascript" translate="no">
```pug
html
head
title= title
body
h1= message
</code>
</pre>
```
A continuación, cree una ruta para representar el archivo `index.pug`. Si la propiedad `view engine` no se establece, debe especificar la extensión del archivo `view`. De lo contrario, puede omitirla.
<pre>
<code class="language-javascript" translate="no">
app.get('/', function (req, res) {
res.render('index', { title: 'Hey', message: 'Hello there!'});
});
</code>
</pre>
```js
app.get('/', (req, res) => {
res.render('index', { title: 'Hey', message: 'Hello there!' })
})
```
Cuando realice una solicitud a la página de inicio, el archivo `index.pug` se representará como HTML.

107
es/guide/writing-middleware.md
View File

@@ -45,31 +45,27 @@ El siguiente ejemplo muestra los elementos de una llamada a función de middlewa
A continuación, se muestra un ejemplo de una aplicación Express simple, "Hello World", para la que definirá dos funciones de middleware:
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
```js
const express = require('express')
const app = express()
app.get('/', function (req, res) {
res.send('Hello World!');
});
app.get('/', (req, res) => {
res.send('Hello World!')
})
app.listen(3000);
</code>
</pre>
app.listen(3000)
```
<h2>Desarrollo</h2>
Este es un ejemplo simple de una función de middleware denominada "myLogger". Esta función simplemente imprime "LOGGED" cuando una solicitud de la aplicación pasa por ella. La función de middleware se asigna a una variable denominada `myLogger`.
<pre>
<code class="language-javascript" translate="no">
var myLogger = function (req, res, next) {
console.log('LOGGED');
next();
};
</code>
</pre>
```js
const myLogger = function (req, res, next) {
console.log('LOGGED')
next()
}
```
<div class="doc-box doc-notice" markdown="1">
Observe la llamada anterior a `next()`. La llamada a esta función invoca la siguiente función de middleware en la aplicación.
@@ -79,25 +75,23 @@ La función `next()` no forma parte de la API de Express o Node.js, pero es el t
Para cargar la función de middleware, llame a `app.use()`, especificando la función de middleware.
Por ejemplo, el siguiente código carga la función de middleware `myLogger` antes de la ruta a la vía de acceso raíz (/).
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
```js
const express = require('express')
const app = express()
var myLogger = function (req, res, next) {
console.log('LOGGED');
next();
};
const myLogger = function (req, res, next) {
console.log('LOGGED')
next()
}
app.use(myLogger);
app.use(myLogger)
app.get('/', function (req, res) {
res.send('Hello World!');
});
app.get('/', (req, res) => {
res.send('Hello World!')
})
app.listen(3000);
</code>
</pre>
app.listen(3000)
```
Cada vez que la aplicación recibe una solicitud, imprime el mensaje "LOGGED" en el terminal.
@@ -109,39 +103,34 @@ La función de middleware `myLogger` simplemente imprime un mensaje y, a continu
El siguiente ejemplo añade una propiedad denominada `requestTime` al objeto de solicitud. Llamaremos a esta función de middleware "requestTime".
<pre>
<code class="language-javascript" translate="no">
var requestTime = function (req, res, next) {
req.requestTime = Date.now();
next();
};
</code>
</pre>
```js
const requestTime = function (req, res, next) {
req.requestTime = Date.now()
next()
}
```
La aplicación ahora utiliza la función de middleware `requestTime`. Asimismo, la función de devolución de llamada de la ruta de vía de acceso raíz utiliza la propiedad que la función de middleware añade a `req` (el objeto de solicitud).
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
```js
const express = require('express')
const app = express()
var requestTime = function (req, res, next) {
req.requestTime = Date.now();
next();
};
const requestTime = function (req, res, next) {
req.requestTime = Date.now()
next()
}
app.use(requestTime);
app.use(requestTime)
app.get('/', function (req, res) {
var responseText = 'Hello World!<br>';
responseText += '<small>Requested at: ' + req.requestTime + '</small>';
res.send(responseText);
});
app.listen(3000);
</code>
</pre>
app.get('/', (req, res) => {
let responseText = 'Hello World!<br>'
responseText += `<small>Requested at: ${req.requestTime}</small>`
res.send(responseText)
})
app.listen(3000)
```
Cuando realiza una solicitud a la raíz de la aplicación, la aplicación ahora muestra la indicación de fecha y hora de la solicitud en el navegador.
Como tiene acceso al objeto de solicitud, el objeto de respuesta, la siguiente función de middleware de la pila y toda la API de Node.js, las posibilidades con las funciones de middleware son ilimitadas.

54
es/starter/basic-routing.md
View File

@@ -15,11 +15,9 @@ El *direccionamiento* hace referencia a la determinación de cómo responde una
Cada ruta puede tener una o varias funciones de manejador, que se excluyen cuando se correlaciona la ruta.
La definición de ruta tiene la siguiente estructura:
<pre>
<code class="language-javascript" translate="no">
```js
app.METHOD(PATH, HANDLER)
</code>
</pre>
```
Donde:
@@ -36,42 +34,34 @@ El siguiente ejemplo ilustra la definición de rutas simples.
Responda con `Hello World!` en la página inicial:
<pre>
<code class="language-javascript" translate="no">
app.get('/', function (req, res) {
res.send('Hello World!');
});
</code>
</pre>
```js
app.get('/', (req, res) => {
res.send('Hello World!')
})
```
Responda a la solicitud POST en la ruta raíz (`/`), la página de inicio de la aplicación:
<pre>
<code class="language-javascript" translate="no">
app.post('/', function (req, res) {
res.send('Got a POST request');
});
</code>
</pre>
```js
app.post('/', (req, res) => {
res.send('Got a POST request')
})
```
Responda a una solicitud PUT en la ruta `/user`:
<pre>
<code class="language-javascript" translate="no">
app.put('/user', function (req, res) {
res.send('Got a PUT request at /user');
});
</code>
</pre>
```js
app.put('/user', (req, res) => {
res.send('Got a PUT request at /user')
})
```
Responda a una solicitud DELETE en la ruta `/user`:
<pre>
<code class="language-javascript" translate="no">
app.delete('/user', function (req, res) {
res.send('Got a DELETE request at /user');
});
</code>
</pre>
```js
app.delete('/user', (req, res) => {
res.send('Got a DELETE request at /user')
})
```
Para obtener más detalles sobre el direccionamiento, consulte la [guía de direccionamiento](/{{ page.lang }}/guide/routing.html).

26
es/starter/faq.md
View File

@@ -45,26 +45,22 @@ Para normalizar las interfaces de motor de plantilla y el almacenamiento en memo
En Express, las respuestas 404 no son el resultado de un error, por lo que el middleware de manejador de errores no las capturará. Este comportamiento se debe a que una respuesta 404 simplemente indica la ausencia de trabajo adicional pendiente; es decir, Express ha ejecutado todas las rutas y funciones de middleware, y ha comprobado que ninguna de ellas responde. Lo único que debe hacer es añadir una función de middleware al final de la pila (debajo de las demás funciones) para manejar una respuesta 404:
<pre>
<code class="language-javascript" translate="no">
app.use(function(req, res, next) {
res.status(404).send('Sorry cant find that!');
});
</code>
</pre>
```js
app.use((req, res, next) => {
res.status(404).send('Sorry cant find that!')
})
```
## ¿Cómo configuro un manejador de errores?
El middleware de manejo de errores se define de la misma forma que otro middleware, excepto con cuatro argumentos en lugar de tres; específicamente con la firma `(err, req, res, next)`:
<pre>
<code class="language-javascript" translate="no">
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Something broke!');
});
</code>
</pre>
```js
app.use((err, req, res, next) => {
console.error(err.stack)
res.status(500).send('Something broke!')
})
```
Para obtener más información, consulte [Manejo de errores](/{{ page.lang }}/guide/error-handling.html).

14
es/starter/generator.md
View File

@@ -13,13 +13,13 @@ Utilice la herramienta de generador de aplicaciones, `express`, para crear rápi
Instale `express` con el siguiente mandato:
```console
```bash
$ npm install express-generator -g
```
Muestre las opciones de mandato con la opción `-h`:
```console
```bash
$ express -h
Usage: express [options][dir]
@@ -41,7 +41,7 @@ $ express -h
Por ejemplo, el código siguiente crea una aplicación Express denominada _myapp_. La aplicación será creada en una carpeta llamada _myapp_ en el directorio de trabajo actual y el motor de vistas será asignado a <a href="https://pugjs.org/" target="_blank" title="Documentación de Pug">Pug</a>:
```console
```bash
$ express --view=pug myapp
create : myapp
@@ -65,20 +65,20 @@ $ express --view=pug myapp
A continuación, instale las dependencias:
```console
```bash
$ cd myapp
$ npm install
```
En MacOS o Linux, ejecute la aplicación con este mandato:
```console
```bash
$ DEBUG=myapp:* npm start
```
En Windows, utilice este mandato:
```console
```bash
> set DEBUG=myapp:* & npm start
```
@@ -86,7 +86,7 @@ A continuación, cargue `http://localhost:3000/` en el navegador para acceder a
La aplicación generada tiene la siguiente estructura de directorios:
```console
```bash
.
├── app.js
├── bin

8
es/starter/hello-world.md
View File

@@ -17,8 +17,7 @@ En primer lugar, cree un directorio denominado `myapp`, cámbielo y ejecute `npm
En el directorio `myapp`, cree un archivo denominado `app.js` y añada el código siguiente:
<pre>
<code class="language-javascript" translate="no">
```js
const express = require('express')
const app = express()
const port = 3000
@@ -30,8 +29,7 @@ app.get('/', (req, res) => {
app.listen(port, () => {
console.log(`Example app listening on port ${port}`)
})
</code>
</pre>
```
La aplicación inicia un servidor y escucha las conexiones en el puerto 3000. La aplicación responde con "Hello World!" para las solicitudes al URL raíz (`/`) o a la *ruta* raíz. Para cada vía de acceso diferente, responderá con un error **404 Not Found**.
@@ -41,7 +39,7 @@ La aplicación inicia un servidor y escucha las conexiones en el puerto 3000. La
Ejecute la aplicación con el siguiente mandato:
```console
```bash
$ node app.js
```

10
es/starter/installing.md
View File

@@ -11,7 +11,7 @@ description: Learn how to install Express.js in your Node.js environment, includ
Suponiendo que ya ha instalado [Node.js](https://nodejs.org/), cree un directorio para que contenga la aplicación y conviértalo en el directorio de trabajo.
```console
```bash
$ mkdir myapp
$ cd myapp
```
@@ -19,14 +19,14 @@ $ cd myapp
Utilice el mandato `npm init` para crear un archivo `package.json` para la aplicación.
Para obtener más información sobre cómo funciona `package.json`, consulte [Specifics of npm's package.json handling](https://docs.npmjs.com/files/package.json).
```console
```bash
$ npm init
```
Este mandato solicita varios elementos como, por ejemplo, el nombre y la versión de la aplicación.
Por ahora, sólo tiene que pulsar INTRO para aceptar los valores predeterminados para la mayoría de ellos, con la siguiente excepción:
```console
```bash
entry point: (index.js)
```
@@ -34,13 +34,13 @@ Especifique `app.js` o el nombre que desee para el archivo principal. Si desea q
A continuación, instale Express en el directorio `myapp` y guárdelo en la lista de dependencias. Por ejemplo:
```console
```bash
$ npm install express --save
```
Para instalar Express temporalmente y no añadirlo a la lista de dependencias, omita la opción `--save`:
```console
```bash
$ npm install express
```

47
es/starter/static-files.md
View File

@@ -13,23 +13,19 @@ Para el servicio de archivos estáticos como, por ejemplo, imágenes, archivos C
Pase el nombre del directorio que contiene los activos estáticos a la función de middleware `express.static` para empezar directamente el servicio de los archivos. Por ejemplo, utilice el siguiente código para el servicio de imágenes, archivos CSS y archivos JavaScript en un directorio denominado `public`:
<pre>
<code class="language-javascript" translate="no">
app.use(express.static('public'));
</code>
</pre>
```js
app.use(express.static('public'))
```
Ahora, puede cargar los archivos que hay en el directorio `public`:
<pre>
<code class="language-javascript" translate="no">
```text
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
</code>
</pre>
```
<div class="doc-box doc-info">
Express busca los archivos relativos al directorio estático, por lo que el nombre del directorio estático no forma parte del URL.
@@ -37,39 +33,32 @@ Express busca los archivos relativos al directorio estático, por lo que el nomb
Para utilizar varios directorios de activos estáticos, invoque la función de middleware `express.static` varias veces:
<pre>
<code class="language-javascript" translate="no">
app.use(express.static('public'));
app.use(express.static('files'));
</code>
</pre>
```js
app.use(express.static('public'))
app.use(express.static('files'))
```
Express busca los archivos en el orden en el que se definen los directorios estáticos con la función de middleware `express.static`.
Para crear un prefijo de vía de acceso virtual (donde la vía de acceso no existe realmente en el sistema de archivos) para los archivos a los que da servicio la función `express.static`, [especifique una vía de acceso de montaje](/{{ page.lang }}/4x/api.html#app.use) para el directorio estático, como se muestra a continuación:
<pre>
<code class="language-javascript" translate="no">
app.use('/static', express.static('public'));
</code>
</pre>
```js
app.use('/static', express.static('public'))
```
Ahora, puede cargar los archivos que hay en el directorio `public` desde el prefijo de vía de acceso `/static`.
<pre>
<code class="language-javascript" translate="no">
```text
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
</code>
</pre>
```
No obstante, la vía de acceso que proporciona a la función `express.static` es relativa al directorio desde donde inicia el proceso `node`. Si ejecuta la aplicación Express desde cualquier otro directorio, es más seguro utilizar la vía de acceso absoluta del directorio al que desea dar servicio:
<pre>
<code class="language-javascript" translate="no">
app.use('/static', express.static(__dirname + '/public'));
</code>
</pre>
```js
const path = require('path')
app.use('/static', express.static(path.join(__dirname, 'public')))
```

34
fr/advanced/best-practice-performance.md
View File

@@ -199,23 +199,19 @@ En développement, vous définissez généralement les variables d'environnement
Avec Upstart, utilisez le mot clé `env` dans votre fichier de travail. Par exemple :
<pre>
<code class="language-sh" translate="no">
```sh
# /etc/init/env.conf
env NODE_ENV=production
</code>
</pre>
```
Pour plus d'informations, voir [Upstart Intro, Cookbook and Best Practices](http://upstart.ubuntu.com/cookbook/#environment-variables).
Avec systemd, utilisez la directive `Environment` dans votre fichier d'unité. Par exemple :
<pre>
<code class="language-sh" translate="no">
```sh
# /etc/systemd/system/myservice.service
Environment=NODE_ENV=production
</code>
</pre>
```
Pour plus d'informations, voir [Using Environment Variables In systemd Units](https://coreos.com/os/docs/latest/using-environment-variables-in-systemd-units.html).
@@ -276,8 +272,7 @@ Systemd est un système Linux et un gestionnaire de services. La plupart des dis
Un fichier de configuration de service systemd est appelé *fichier d'unité* et porte l'extension .service. Voici un exemple de fichier d'unité permettant de gérer une application Node directement (remplacez le texte en gras par les valeurs appropriées à votre système et votre application) :
<pre>
<code class="language-sh" translate="no">
```sh
[Unit]
Description=Awesome Express App
@@ -305,8 +300,7 @@ Restart=always
[Install]
WantedBy=multi-user.target
</code>
</pre>
```
Pour plus d'informations sur systemd, voir la [page d'aide de systemd](http://www.freedesktop.org/software/systemd/man/systemd.unit.html).
##### StrongLoop PM en tant que service systemd
@@ -315,13 +309,13 @@ Vous pouvez facilement installer StrongLoop Process Manager en tant que service
Pour installer StrongLoop PM en tant que service systemd :
```console
```bash
$ sudo sl-pm-install --systemd
```
Démarrez ensuite le service comme suit :
```console
```bash
$ sudo /usr/bin/systemctl start strong-pm
```
@@ -335,8 +329,7 @@ Un service Upstart est défini dans un fichier de configuration de travail (éga
Créez un fichier nommé `myapp.conf` dans `/etc/init/` avec le contenu suivant (remplacez le texte en gras par les valeurs appropriées à votre système et votre application) :
<pre>
<code class="language-sh" translate="no">
```sh
# When to start the process
start on runlevel [2345]
@@ -364,8 +357,7 @@ respawn
# Limit restart attempt to 10 times within 10 seconds
respawn limit 10 10
</code>
</pre>
```
REMARQUE : ce script nécessite Upstart 1.4 ou ultérieur, pris en charge sur Ubuntu 12.04-14.10.
@@ -385,13 +377,13 @@ Vous pouvez facilement installer StrongLoop Process Manager en tant que service
Pour installer StrongLoop PM en tant que service Upstart 1.4 :
```console
```bash
$ sudo sl-pm-install
```
Exécutez ensuite le service comme suit :
```console
```bash
$ sudo /sbin/initctl start strong-pm
```
@@ -419,7 +411,7 @@ Lorsque StrongLoop Process Manager (PM) exécute une application, il l'exécute
Par exemple, en supposant que vous avez déployé votre application sur prod.foo.com et que StrongLoop PM est en mode écoute sur le port 8701 (par défaut), pour définir la taille du cluster sur 8 à l'aide de slc :
```console
```bash
$ slc ctl -C http://prod.foo.com:8701 set-size my-app 8
```

57
fr/advanced/best-practice-security.md
View File

@@ -48,20 +48,20 @@ Helmet n'est actuellement qu'une collection de neuf fonctions middleware plus pe
Installez Helmet comme n'importe quel autre module :
```console
```bash
$ npm install --save helmet
```
Puis, pour l'utiliser dans votre code :
<pre>
<code class="language-javascript" translate="no">
...
var helmet = require('helmet');
app.use(helmet());
...
</code>
</pre>
```js
/// ...
const helmet = require('helmet')
app.use(helmet())
/// ...
```
### Désactivez au minimum l'en-tête X-Powered-By
@@ -69,11 +69,9 @@ Si vous ne voulez pas utiliser Helmet, désactivez au minimum l'en-tête `X-Powe
Il est donc conseillé de neutraliser l'en-tête à l'aide de la méthode `app.disable()` comme suit :
<pre>
<code class="language-javascript" translate="no">
app.disable('x-powered-by');
</code>
</pre>
```js
app.disable('x-powered-by')
```
Si vous utilisez `helmet.js`, cette opération s'effectue automatiquement.
@@ -96,17 +94,15 @@ L'utilisation d'un nom de cookie de session par défaut risque d'ouvrir votre ap
Pour éviter ce problème, utilisez des noms de cookie génériques, par exemple à l'aide du middleware [express-session](https://www.npmjs.com/package/express-session) :
<pre>
<code class="language-javascript" translate="no">
var session = require('express-session');
```js
const session = require('express-session')
app.set('trust proxy', 1) // trust first proxy
app.use(session({
secret: 's3Cur3',
name : 'sessionId',
name: 'sessionId'
})
);
</code>
</pre>
)
```
### Définissez des options de sécurité de cookie
@@ -120,26 +116,25 @@ Définissez les options de cookie suivantes pour accroître la sécurité :
Exemple d'utilisation du middleware [cookie-session](https://www.npmjs.com/package/cookie-session) :
<pre>
<code class="language-javascript" translate="no">
var session = require('cookie-session');
var express = require('express');
var app = express();
```js
const session = require('cookie-session')
const express = require('express')
const app = express()
var expiryDate = new Date( Date.now() + 60 * 60 * 1000 ); // 1 hour
const expiryDate = new Date(Date.now() + 60 * 60 * 1000) // 1 hour
app.use(session({
name: 'session',
keys: ['key1', 'key2'],
cookie: { secure: true,
cookie: {
secure: true,
httpOnly: true,
domain: 'example.com',
path: 'foo/bar',
expires: expiryDate
}
})
);
</code>
</pre>
)
```
## Autres considérations

46
fr/advanced/developing-template-engines.md
View File

@@ -13,38 +13,32 @@ Utilisez la méthode `app.engine(ext, callback)` pour créer votre propre moteur
Le code suivant est un exemple d'implémentation d'un moteur de modèle très simple qui permet d'afficher le rendu des fichiers `.ntl`.
<pre>
<code class="language-javascript" translate="no">
var fs = require('fs'); // this engine requires the fs module
app.engine('ntl', function (filePath, options, callback) { // define the template engine
fs.readFile(filePath, function (err, content) {
if (err) return callback(new Error(err));
```js
const fs = require('fs') // this engine requires the fs module
app.engine('ntl', (filePath, options, callback) => { // define the template engine
fs.readFile(filePath, (err, content) => {
if (err) return callback(new Error(err))
// this is an extremely simple template engine
var rendered = content.toString().replace('#title#', '<title>'+ options.title +'</title>')
.replace('#message#', '<h1>'+ options.message +'</h1>');
return callback(null, rendered);
});
});
app.set('views', './views'); // specify the views directory
app.set('view engine', 'ntl'); // register the template engine
</code>
</pre>
const rendered = content.toString().replace('#title#', `<title>${options.title}</title>`)
.replace('#message#', `<h1>${options.message}</h1>`)
return callback(null, rendered)
})
})
app.set('views', './views') // specify the views directory
app.set('view engine', 'ntl') // register the template engine
```
Votre application est désormais en mesure d'afficher le rendu des fichiers `.ntl`. Créez un fichier nommé `index.ntl` dans le répertoire `views` avec le contenu suivant.
<pre>
<code class="language-javascript" translate="no">
```pug
#title#
#message#
</code>
</pre>
```
ENsuite, créez la route suivante dans votre application.
<pre>
<code class="language-javascript" translate="no">
app.get('/', function (req, res) {
res.render('index', { title: 'Hey', message: 'Hello there!'});
});
</code>
</pre>
```js
app.get('/', (req, res) => {
res.render('index', { title: 'Hey', message: 'Hello there!' })
})
```
Lorsque vous effectuerez une demande à la page d'accueil, `index.ntl` sera rendu au format HTML.

22
fr/guide/behind-proxies.md
View File

@@ -35,12 +35,12 @@ Adresse IP, sous-réseau ou tableau d'adresses IP et de sous-réseaux auxquels f
Vous pouvez définir les adresses IP de l'une des manières suivantes :
<pre>
<code class="language-js" translate="no">app.set('trust proxy', 'loopback') // specify a single subnet
```js
app.set('trust proxy', 'loopback') // specify a single subnet
app.set('trust proxy', 'loopback, 123.123.123.123') // specify a subnet and an address
app.set('trust proxy', 'loopback, linklocal, uniquelocal') // specify multiple subnets as CSV
app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal']) // specify multiple subnets as an array</code>
</pre>
app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal']) // specify multiple subnets as an array
```
S'ils sont spécifiés, les sous-réseaux ou les adresses IP sont exclus du processus d'identification d'adresse, et l'adresse IP sans confiance la plus proche du serveur d'applications est identifiée comme étant l'adresse IP du client.
</td>
@@ -55,12 +55,14 @@ Approuve le `n`ème tronçon à partir proxy de face comme étant le client.
<td>Fonction</td>
<td markdown="1">
Implémentation de confiance personnalisée. N'utilisez cette option que si vous êtes sûr de vous.
<pre>
<code class="language-js" translate="no">app.set('trust proxy', function (ip) {
if (ip === '127.0.0.1' || ip === '123.123.123.123') return true; // trusted IPs
else return false;
});</code>
</pre>
```js
app.set('trust proxy', (ip) => {
if (ip === '127.0.0.1' || ip === '123.123.123.123') return true // trusted IPs
else return false
})
```
</td>
</tr>
</tbody>

22
fr/guide/database-integration.md
View File

@@ -35,7 +35,7 @@ consultez le site [npm](https://www.npmjs.com/).
**Module** : [cassandra-driver](https://github.com/datastax/nodejs-driver)
**Installation**
```console
```bash
$ npm install cassandra-driver
```
@@ -60,7 +60,7 @@ client.execute('select key from system.local', function(err, result) {
**Module** : [nano](https://github.com/dscape/nano)
**Installation**
```console
```bash
$ npm install nano
```
@@ -93,7 +93,7 @@ books.list(function(err, body){
**Module** : [levelup](https://github.com/rvagg/node-levelup)
**Installation**
```console
```bash
$ npm install level levelup leveldown
```
@@ -123,7 +123,7 @@ db.put('name', 'LevelUP', function (err) {
**Module** : [mysql](https://github.com/felixge/node-mysql/)
**Installation**
```console
```bash
$ npm install mysql
```
@@ -156,7 +156,7 @@ connection.end();
**Module** : [mongodb](https://github.com/mongodb/node-mongodb-native)
**Installation**
```console
```bash
$ npm install mongodb
```
@@ -189,7 +189,7 @@ Si vous voulez un pilote de modèle d'objet pour MongoDB, recherchez [Mongoose](
**Module** : [apoc](https://github.com/hacksparrow/apoc)
**Installation**
```console
```bash
$ npm install apoc
```
@@ -220,7 +220,7 @@ apoc.query('match (n) return n').exec().then(
Remarque: [Voir les conditions préalables à l'installation](https://github.com/oracle/node-oracledb#-installation).
```console
```bash
$ npm install oracledb
```
@@ -265,7 +265,7 @@ getEmployee(101)
**Module** : [pg-promise](https://github.com/vitaly-t/pg-promise)
**Installation**
```console
```bash
$ npm install pg-promise
```
@@ -293,7 +293,7 @@ db.one("SELECT $1 AS value", 123)
**Module** : [redis](https://github.com/mranney/node_redis)
**Installation**
```console
```bash
$ npm install redis
```
@@ -331,7 +331,7 @@ client.hkeys('hash key', function (err, replies) {
**Module** : [sqlite3](https://github.com/mapbox/node-sqlite3)
**Installation**
```console
```bash
$ npm install sqlite3
```
@@ -369,7 +369,7 @@ db.close();
**Module** : [elasticsearch](https://github.com/elastic/elasticsearch-js)
**Installation**
```console
```bash
$ npm install elasticsearch
```

12
fr/guide/debugging.md
View File

@@ -11,19 +11,19 @@ description: Learn how to enable and use debugging logs in Express.js applicatio
Pour afficher tous les journaux internes utilisés dans Express, affectez à la variable d'environnement `DEBUG` la valeur `express:*` lors du lancement de votre application.
```console
```bash
$ DEBUG=express:* node index.js
```
Sous Windows, utilisez la commande correspondante.
```console
```bash
> set DEBUG=express:* & node index.js
```
L'exécution de cette commande sur l'application par défaut générée par le [générateur express](/{{ page.lang }}/starter/generator.html) imprime le résultat suivant :
```console
```bash
$ DEBUG=express:* node ./bin/www
express:router:route new / +0ms
express:router:layer new / +1ms
@@ -69,7 +69,7 @@ $ DEBUG=express:* node ./bin/www
Si une demande est par la suite effectuée à l'application, vous verrez les journaux spécifiés dans le code Express :
```console
```bash
express:router dispatching GET / +4h
express:router query : / +2ms
express:router expressInit : / +0ms
@@ -95,12 +95,12 @@ Une application générée par la commande `express` également appel au module
Ainsi, si vous avez généré l'application à l'aide de `$ express sample-app`, vous pouvez activer les instructions de débogage en exécutant la commande suivante :
```console
```bash
$ DEBUG=sample-app:* node ./bin/www
```
Vous pouvez spécifier plusieurs espaces de noms de débogage en affectant une liste de noms séparés par des virgules :
```console
```bash
$ DEBUG=http,mail,express:* node index.js
```

118
fr/guide/error-handling.md
View File

@@ -13,83 +13,70 @@ Définissez les fonctions middleware de traitement d'erreurs de la même manièr
à l'exception près que les fonctions de traitement d'erreurs se composent de quatre arguments et non de trois :
`(err, req, res, next)`. Par exemple :
<pre>
<code class="language-javascript" translate="no">
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Something broke!');
});
</code>
</pre>
```js
app.use((err, req, res, next) => {
console.error(err.stack)
res.status(500).send('Something broke!')
})
```
Définissez le middleware de traitement d'erreurs en dernier, après les autres appels `app.use()` et de routes ; par exemple :
<pre>
<code class="language-javascript" translate="no">
var bodyParser = require('body-parser');
var methodOverride = require('method-override');
```js
const bodyParser = require('body-parser')
const methodOverride = require('method-override')
app.use(bodyParser());
app.use(methodOverride());
app.use(function(err, req, res, next) {
app.use(bodyParser())
app.use(methodOverride())
app.use((err, req, res, next) => {
// logic
});
</code>
</pre>
})
```
Les réponses issues d'une fonction middleware peuvent être au format de votre choix, par exemple une page d'erreur HTML, un simple message ou une chaîne JSON.
A des fins organisationnelles (et d'infrastructure de niveau supérieur), vous pouvez définir plusieurs fonctions middleware de traitement d'erreurs, tout comme vous le feriez avec d'autres fonctions middleware ordinaires.
Par exemple, si vous vouliez définir un gestionnaire d'erreurs pour les demandes réalisées avec `XHR` et pour celles réalisées sans, vous pourriez utiliser les commandes suivantes :
<pre>
<code class="language-javascript" translate="no">
var bodyParser = require('body-parser');
var methodOverride = require('method-override');
```js
const bodyParser = require('body-parser')
const methodOverride = require('method-override')
app.use(bodyParser());
app.use(methodOverride());
app.use(logErrors);
app.use(clientErrorHandler);
app.use(errorHandler);
</code>
</pre>
app.use(bodyParser())
app.use(methodOverride())
app.use(logErrors)
app.use(clientErrorHandler)
app.use(errorHandler)
```
Dans cet exemple, les erreurs `logErrors` génériques pourraient écrire des informations de demande et d'erreur dans `stderr`, par exemple :
<pre>
<code class="language-javascript" translate="no">
```js
function logErrors (err, req, res, next) {
console.error(err.stack);
next(err);
console.error(err.stack)
next(err)
}
</code>
</pre>
```
Egalement dans cet exemple, `clientErrorHandler` est défini comme suit ; dans ce cas, l'erreur est explicitement transmise à la fonction suivante :
<pre>
<code class="language-javascript" translate="no">
```js
function clientErrorHandler (err, req, res, next) {
if (req.xhr) {
res.status(500).send({ error: 'Something failed!' });
res.status(500).send({ error: 'Something failed!' })
} else {
next(err);
next(err)
}
}
</code>
</pre>
```
La fonction "catch-all" `errorHandler` peut être mise en oeuvre comme suit :
<pre>
<code class="language-javascript" translate="no">
```js
function errorHandler (err, req, res, next) {
res.status(500);
res.render('error', { error: err });
res.status(500)
res.render('error', { error: err })
}
</code>
</pre>
```
Si vous transmettez tout à la fonction `next()` (sauf la chaîne `'route'`), Express considère la demande en cours
comme étant erronée et ignorera tout routage de gestion non lié à une erreur et toute fonction middleware restants. Si vous voulez gérer cette erreur de quelque façon que ce soit, vous devrez créer
@@ -97,24 +84,21 @@ une route de gestion d'erreur tel que décrit dans la section suivante.
Si vous disposez d'un gestionnaire de routage avec plusieurs fonctions callback, vour pouvez utiliser le paramètre `route` pour passer au gestionnaire de routage suivant. Par exemple :
<pre>
<code class="language-javascript" translate="no">
```js
app.get('/a_route_behind_paywall',
function checkIfPaidSubscriber(req, res, next) {
(req, res, next) => {
if (!req.user.hasPaid) {
// continue handling this request
next('route');
next('route')
}
}, function getPaidContent(req, res, next) {
PaidContent.find(function(err, doc) {
if(err) return next(err);
res.json(doc);
});
});
</code>
</pre>
}, (req, res, next) => {
PaidContent.find((err, doc) => {
if (err) return next(err)
res.json(doc)
})
})
```
Dans cet exemple, le gestionnaire `getPaidContent` sera ignoré, mais tous les gestionnaires restants dans `app` pour `/a_route_behind_paywall` continueront d'être exécutés.
<div class="doc-box doc-info" markdown="1">
@@ -143,14 +127,12 @@ De ce fait, lorsque vous ajoutez un gestionnaire d'erreurs personnalisé, vous d
les mécanismes de gestion d'erreur par défaut à Express, lorsque les en-têtes
ont déjà été envoyés au client :
<pre>
<code class="language-javascript" translate="no">
```js
function errorHandler (err, req, res, next) {
if (res.headersSent) {
return next(err);
return next(err)
}
res.status(500);
res.render('error', { error: err });
res.status(500)
res.render('error', { error: err })
}
</code>
</pre>
```

246
fr/guide/migrating-4.md
View File

@@ -100,14 +100,12 @@ GitHub.
Dans la version 4 vous pouvez utilisez un paramètre variable pour définir le chemin vers lequel les fonctions middleware sont chargées, puis lire la valeur de ce paramètre dans le gestionnaire de routage.
Par exemple :
<pre>
<code class="language-javascript" translate="no">
```js
app.use('/book/:id', function (req, res, next) {
console.log('ID:', req.params.id);
next();
});
</code>
</pre>
console.log('ID:', req.params.id)
next()
})
```
<h3 id="routing">
Le système de routage
</h3>
@@ -128,20 +126,18 @@ La nouvelle méthode `app.route()` vous permet de créer des gestionnaires de ro
Voici quelques exemples de gestionnaires de chemin de chaînage définis à l'aide de la fonction `app.route()`.
<pre>
<code class="language-javascript" translate="no">
```js
app.route('/book')
.get(function (req, res) {
res.send('Get a random book');
res.send('Get a random book')
})
.post(function (req, res) {
res.send('Add a book');
res.send('Add a book')
})
.put(function (req, res) {
res.send('Update the book');
});
</code>
</pre>
res.send('Update the book')
})
```
<h4 id="express-router">classe <code>express.Router</code> </h4>
@@ -153,38 +149,36 @@ L'exemple suivant créé une routeur en tant que module, charge un middleware da
Par exemple, créez un fichier de routage nommé `birds.js` dans le répertoire app, avec le contenu suivant :
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var router = express.Router();
```js
var express = require('express')
var router = express.Router()
// middleware specific to this router
router.use(function timeLog (req, res, next) {
console.log('Time: ', Date.now());
next();
});
console.log('Time: ', Date.now())
next()
})
// define the home page route
router.get('/', function (req, res) {
res.send('Birds home page');
});
res.send('Birds home page')
})
// define the about route
router.get('/about', function (req, res) {
res.send('About birds');
});
res.send('About birds')
})
module.exports = router;
</code>
</pre>
module.exports = router
```
Puis, chargez le module de routage dans l'application :
<pre>
<code class="language-javascript" translate="no">
var birds = require('./birds');
...
app.use('/birds', birds);
</code>
</pre>
```js
var birds = require('./birds')
/// ...
app.use('/birds', birds)
```
L'application pourra gérer des demandes dans les chemins `/birds` et
`/birds/about`, et appellera le middleware `timeLog` spécifique à la route.
@@ -321,48 +315,45 @@ Application de la version 3
Examinons une application Express v.3 avec le fichier `app.js` suivant :
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var routes = require('./routes');
var user = require('./routes/user');
var http = require('http');
var path = require('path');
```js
var express = require('express')
var routes = require('./routes')
var user = require('./routes/user')
var http = require('http')
var path = require('path')
var app = express();
var app = express()
// all environments
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'pug');
app.use(express.favicon());
app.use(express.logger('dev'));
app.use(express.methodOverride());
app.use(express.session({ secret: 'your secret here' }));
app.use(express.bodyParser());
app.use(app.router);
app.use(express.static(path.join(__dirname, 'public')));
app.set('port', process.env.PORT || 3000)
app.set('views', path.join(__dirname, 'views'))
app.set('view engine', 'pug')
app.use(express.favicon())
app.use(express.logger('dev'))
app.use(express.methodOverride())
app.use(express.session({ secret: 'your secret here' }))
app.use(express.bodyParser())
app.use(app.router)
app.use(express.static(path.join(__dirname, 'public')))
// development only
if ('development' == app.get('env')) {
app.use(express.errorHandler());
if (app.get('env') === 'development') {
app.use(express.errorHandler())
}
app.get('/', routes.index);
app.get('/users', user.list);
app.get('/', routes.index)
app.get('/users', user.list)
http.createServer(app).listen(app.get('port'), function () {
console.log('Express server listening on port ' + app.get('port'));
});
</code>
</pre>
console.log('Express server listening on port ' + app.get('port'))
})
```
<h4 id=""><code>package.json</code></h4>
Voici à quoi ressemble le fichier `package.json` qui accompagne la version 3 :
<pre>
<code class="language-javascript" translate="no">
```json
{
"name": "application-name",
"version": "0.0.1",
@@ -375,8 +366,7 @@ Voici à quoi ressemble le fichier `package.json` qui accompagne la version 3 :
"pug": "*"
}
}
</code>
</pre>
```
<h3 id="">
Processus
@@ -385,7 +375,7 @@ Processus
Commencez le processus de migration en installant le middleware requis pour l'application
Express 4 et en mettant à jour Express et Pug vers leur version la plus récente respective à l'aide de la commande suivante :
```console
```bash
$ npm install serve-favicon morgan method-override express-session body-parser multer errorhandler express@latest pug@latest --save
```
@@ -410,8 +400,7 @@ Apportez les modifications suivantes à `app.js` :
Le fait d'exécuter la commande `npm` ci-dessus mettra à jour `package.json` comme suit :
<pre>
<code class="language-javascript" translate="no">
```json
{
"name": "application-name",
"version": "0.0.1",
@@ -431,69 +420,70 @@ Le fait d'exécuter la commande `npm` ci-dessus mettra à jour `package.json` co
"serve-favicon": "^2.0.1"
}
}
</code>
</pre>
```
<h4 id=""><code>app.js</code></h4>
Puis, supprimez le code non valide, chargez les middleware requis et procédez aux autres changements,
le cas échéant. Voici à quoi ressemble le fichier `app.js` :
<pre>
<code class="language-javascript" translate="no">
var http = require('http');
var express = require('express');
var routes = require('./routes');
var user = require('./routes/user');
var path = require('path');
```js
var http = require('http')
var express = require('express')
var routes = require('./routes')
var user = require('./routes/user')
var path = require('path')
var favicon = require('serve-favicon');
var logger = require('morgan');
var methodOverride = require('method-override');
var session = require('express-session');
var bodyParser = require('body-parser');
var multer = require('multer');
var errorHandler = require('errorhandler');
var favicon = require('serve-favicon')
var logger = require('morgan')
var methodOverride = require('method-override')
var session = require('express-session')
var bodyParser = require('body-parser')
var multer = require('multer')
var errorHandler = require('errorhandler')
var app = express();
var app = express()
// all environments
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'pug');
app.use(favicon(__dirname + '/public/favicon.ico'));
app.use(logger('dev'));
app.use(methodOverride());
app.use(session({ resave: true,
app.set('port', process.env.PORT || 3000)
app.set('views', path.join(__dirname, 'views'))
app.set('view engine', 'pug')
app.use(favicon(path.join(__dirname, '/public/favicon.ico')))
app.use(logger('dev'))
app.use(methodOverride())
app.use(session({
resave: true,
saveUninitialized: true,
secret: 'uwotm8' }));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(multer());
app.use(express.static(path.join(__dirname, 'public')));
secret: 'uwotm8'
}))
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({ extended: true }))
app.use(multer())
app.use(express.static(path.join(__dirname, 'public')))
app.get('/', routes.index);
app.get('/users', user.list);
app.get('/', routes.index)
app.get('/users', user.list)
// error handling middleware should be loaded after the loading the routes
if ('development' == app.get('env')) {
app.use(errorHandler());
if (app.get('env') === 'development') {
app.use(errorHandler())
}
var server = http.createServer(app);
server.listen(app.get('port'), function(){
console.log('Express server listening on port ' + app.get('port'));
});
</code>
</pre>
var server = http.createServer(app)
server.listen(app.get('port'), () => {
console.log('Express server listening on port ' + app.get('port'))
})
```
<div class="doc-box doc-info" markdown="1">
A mois que vous deviez utiliser le module `http` (socket.io/SPDY/HTTPS) directement, vous n'avez pas à le charger et l'application peut être démarrée comme suit :
<pre>
<code class="language-js" translate="no">app.listen(app.get('port'), function(){
console.log('Express server listening on port ' + app.get('port'));
});</code>
</pre>
```js
app.listen(app.get('port'), function () {
console.log('Express server listening on port ' + app.get('port'))
})
```
</div>
<h3 id="">Exécutez l'application</h3>
@@ -501,7 +491,7 @@ A mois que vous deviez utiliser le module `http` (socket.io/SPDY/HTTPS) directem
Le processus de migration est terminé et l'application est désormais une application
Express 4. Pour confirmer, démarrez l'application en utilisant la commande suivante :
```console
```bash
$ node .
```
@@ -518,14 +508,14 @@ L'outil de ligne de commande qui permet de générer une application Express est
Si le générateur d'applications Express 3 est installé sur votre système, vous devez le désinstaller :
```console
```bash
$ npm uninstall -g express
```
En fonction de la configuration de vos privilèges de fichier et de répertoire,
vous devrez exécuter cette commande avec `sudo`.A présent, installez le nouveau générateur :
```console
```bash
$ npm install -g express-generator
```
@@ -547,7 +537,7 @@ Les options et les syntaxe de commande restent généralement identiques, avec l
Exécutez la commande suivante pour créer une application Express 4 :
```console
```bash
$ express app4
```
@@ -560,7 +550,7 @@ Vous noterez également que le fichier `app.js` est désormais un module Node.js
Après avoir installé les dépendances, démarrez l'application en utilisant la commande suivante :
```console
```bash
$ npm start
```
@@ -581,23 +571,19 @@ Pour se débarrasser du répertoire `www` et garder la présentation d'Express 3
supprimez la ligne `module.exports = app;` à la fin du fichier
`app.js`, puis collez le code suivant à la place :
<pre>
<code class="language-javascript" translate="no">
app.set('port', process.env.PORT || 3000);
```js
app.set('port', process.env.PORT || 3000)
var server = app.listen(app.get('port'), function () {
debug('Express server listening on port ' + server.address().port);
});
</code>
</pre>
debug('Express server listening on port ' + server.address().port)
})
```
Assurez-vous d'avoir chargé le module `debug` en haut du fichier `app.js` à l'aide du code suivant :
<pre>
<code class="language-javascript" translate="no">
var debug = require('debug')('app4');
</code>
</pre>
```js
var debug = require('debug')('app4')
```
Ensuite, modifiez `"start": "node ./bin/www"` dans le fichier `package.json` en `"start": "node app.js"`.

2
fr/guide/migrating-5.md
View File

@@ -25,7 +25,7 @@ Pour installer la dernière version alpha et pour
prévisualiser Express 5, entrez la commande suivante dans le
répertoire principal de l'application :
```console
```bash
$ npm install "express@^{{ site.data.express.next_version }}" --save
```

307
fr/guide/routing.md
View File

@@ -14,17 +14,15 @@ Pour une introduction au routage, voir [Basic routing](/{{ page.lang }}/starter/
Le code suivant est un exemple de routage très basique.
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
```js
const express = require('express')
const app = express()
// respond with "hello world" when a GET request is made to the homepage
app.get('/', function(req, res) {
res.send('hello world');
});
</code>
</pre>
app.get('/', (req, res) => {
res.send('hello world')
})
```
<h2 id="route-methods">Méthodes de routage</h2>
@@ -32,19 +30,17 @@ Une méthode de routage est dérivée de l'une des méthodes HTTP, et est liée
Le code suivant est un exemple de routes qui sont définies pour les méthodes GET et POST jusqu'à la route de l'application.
<pre>
<code class="language-javascript" translate="no">
```js
// GET method route
app.get('/', function (req, res) {
res.send('GET request to the homepage');
});
app.get('/', (req, res) => {
res.send('GET request to the homepage')
})
// POST method route
app.post('/', function (req, res) {
res.send('POST request to the homepage');
});
</code>
</pre>
app.post('/', (req, res) => {
res.send('POST request to the homepage')
})
```
Express prend en charge les méthodes de routage suivantes qui correspondent aux méthodes HTTP : `get`, `post`, `put`, `head`, `delete`, `options`, `trace`, `copy`, `lock`, `mkcol`, `move`, `purge`, `propfind`, `proppatch`, `unlock`, `report`, `mkactivity`, `checkout`, `merge`, `m-search`, `notify`, `subscribe`, `unsubscribe`, `patch`, `search`, and `connect`.
@@ -57,14 +53,12 @@ Il existe une méthode de routage spéciale, `app.all()`, qui n'est pas dérivé
Dans l'exemple suivant, le gestionnaire sera exécuté pour les demandes de "/secret", que vous utilisiez GET, POST, PUT, DELETE ou toute autre méthode de demande HTTP prise en charge dans le [module http](https://nodejs.org/api/http.html#http_http_methods).
<pre>
<code class="language-javascript" translate="no">
app.all('/secret', function (req, res, next) {
console.log('Accessing the secret section ...');
next(); // pass control to the next handler
});
</code>
</pre>
```js
app.all('/secret', (req, res, next) => {
console.log('Accessing the secret section ...')
next() // pass control to the next handler
})
```
<h2 id="route-paths">Chemins de routage</h2>
@@ -82,75 +76,61 @@ Il s'agit d'exemples de chemins de routage basés sur des chaînes.
Ce chemin de routage fera correspondre des demandes à la route racine, `/`.
<pre>
<code class="language-javascript" translate="no">
app.get('/', function (req, res) {
res.send('root');
});
</code>
</pre>
```js
app.get('/', (req, res) => {
res.send('root')
})
```
Ce chemin de routage fera correspondre des demandes à `/about`.
<pre>
<code class="language-javascript" translate="no">
app.get('/about', function (req, res) {
res.send('about');
});
</code>
</pre>
```js
app.get('/about', (req, res) => {
res.send('about')
})
```
Ce chemin de routage fera correspondre des demandes à `/random.text`.
<pre>
<code class="language-javascript" translate="no">
app.get('/random.text', function (req, res) {
res.send('random.text');
});
</code>
</pre>
```js
app.get('/random.text', (req, res) => {
res.send('random.text')
})
```
Il s'agit d'exemples de chemins de routage basés sur des masques de chaîne.
Ce chemin de routage fait correspondre `acd` et `abcd`.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab?cd', function(req, res) {
res.send('ab?cd');
});
</code>
</pre>
```js
app.get('/ab?cd', (req, res) => {
res.send('ab?cd')
})
```
Ce chemin de routage fait correspondre `abcd`, `abbcd`, `abbbcd`, etc.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab+cd', function(req, res) {
res.send('ab+cd');
});
</code>
</pre>
```js
app.get('/ab+cd', (req, res) => {
res.send('ab+cd')
})
```
Ce chemin de routage fait correspondre `abcd`, `abxcd`, `abRABDOMcd`, `ab123cd`, etc.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab*cd', function(req, res) {
res.send('ab*cd');
});
</code>
</pre>
```js
app.get('/ab*cd', (req, res) => {
res.send('ab*cd')
})
```
Ce chemin de routage fait correspondre `/abe` et `/abcde`.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab(cd)?e', function(req, res) {
res.send('ab(cd)?e');
});
</code>
</pre>
```js
app.get('/ab(cd)?e', (req, res) => {
res.send('ab(cd)?e')
})
```
<div class="doc-box doc-info" markdown="1">
Les caractères ?, +, * et () sont des sous-ensembles de leur expression régulière équivalente. Le trait d'union (-) et le point (.) sont interprétés littéralement par des chemins d'accès basés sur des chaînes.
@@ -160,23 +140,19 @@ Exemples de chemins de routage basés sur des expressions régulières :
Ce chemin de routage fera correspondre tout élément dont le nom de chemin comprend la lettre "a".
<pre>
<code class="language-javascript" translate="no">
app.get(/a/, function(req, res) {
res.send('/a/');
});
</code>
</pre>
```js
app.get(/a/, (req, res) => {
res.send('/a/')
})
```
Ce chemin de routage fera correspondre `butterfly` et `dragonfly`, mais pas `butterflyman`, `dragonfly man`, etc.
<pre>
<code class="language-javascript" translate="no">
app.get(/.*fly$/, function(req, res) {
res.send('/.*fly$/');
});
</code>
</pre>
```js
app.get(/.*fly$/, (req, res) => {
res.send('/.*fly$/')
})
```
<h2 id="route-handlers">Gestionnaires de routage</h2>
@@ -186,71 +162,62 @@ Les gestionnaires de route se trouvent sous la forme d'une fonction, d'un tablea
Une fonction de rappel unique peut traiter une route. Par exemple :
<pre>
<code class="language-javascript" translate="no">
app.get('/example/a', function (req, res) {
res.send('Hello from A!');
});
</code>
</pre>
```js
app.get('/example/a', (req, res) => {
res.send('Hello from A!')
})
```
Plusieurs fonctions de rappel peuvent traiter une route (n'oubliez pas de spécifier l'objet `next`). Par exemple :
<pre>
<code class="language-javascript" translate="no">
app.get('/example/b', function (req, res, next) {
console.log('the response will be sent by the next function ...');
next();
}, function (req, res) {
res.send('Hello from B!');
});
</code>
</pre>
```js
app.get('/example/b', (req, res, next) => {
console.log('the response will be sent by the next function ...')
next()
}, (req, res) => {
res.send('Hello from B!')
})
```
Un tableau de fonctions de rappel peut traiter une route. Par exemple :
<pre>
<code class="language-javascript" translate="no">
var cb0 = function (req, res, next) {
console.log('CB0');
next();
```js
const cb0 = function (req, res, next) {
console.log('CB0')
next()
}
var cb1 = function (req, res, next) {
console.log('CB1');
next();
const cb1 = function (req, res, next) {
console.log('CB1')
next()
}
var cb2 = function (req, res) {
res.send('Hello from C!');
const cb2 = function (req, res) {
res.send('Hello from C!')
}
app.get('/example/c', [cb0, cb1, cb2]);
</code>
</pre>
app.get('/example/c', [cb0, cb1, cb2])
```
Une combinaison de fonctions indépendantes et des tableaux de fonctions peuvent gérer une route. Par exemple :
<pre>
<code class="language-javascript" translate="no">
var cb0 = function (req, res, next) {
console.log('CB0');
next();
```js
const cb0 = function (req, res, next) {
console.log('CB0')
next()
}
var cb1 = function (req, res, next) {
console.log('CB1');
next();
const cb1 = function (req, res, next) {
console.log('CB1')
next()
}
app.get('/example/d', [cb0, cb1], function (req, res, next) {
console.log('the response will be sent by the next function ...');
next();
}, function (req, res) {
res.send('Hello from D!');
});
</code>
</pre>
app.get('/example/d', [cb0, cb1], (req, res, next) => {
console.log('the response will be sent by the next function ...')
next()
}, (req, res) => {
res.send('Hello from D!')
})
```
<h2 id="response-methods">Méthodes de réponse</h2>
@@ -275,20 +242,18 @@ Etant donné que le chemin est spécifié à une seul emplacement, la création
Voici quelques exemples de gestionnaires de chemin de chaînage définis à l'aide de `app.route()`.
<pre>
<code class="language-javascript" translate="no">
```js
app.route('/book')
.get(function(req, res) {
res.send('Get a random book');
.get((req, res) => {
res.send('Get a random book')
})
.post(function(req, res) {
res.send('Add a book');
.post((req, res) => {
res.send('Add a book')
})
.put(function(req, res) {
res.send('Update the book');
});
</code>
</pre>
.put((req, res) => {
res.send('Update the book')
})
```
<h2 id="express-router">express.Router</h2>
@@ -298,37 +263,35 @@ L'exemple suivant créé une routeur en tant que module, charge une fonction mid
Créez un fichier de routage nommé `birds.js` dans le répertoire app, avec le contenu suivant :
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var router = express.Router();
```js
const express = require('express')
const router = express.Router()
// middleware that is specific to this router
router.use(function timeLog(req, res, next) {
console.log('Time: ', Date.now());
next();
});
router.use((req, res, next) => {
console.log('Time: ', Date.now())
next()
})
// define the home page route
router.get('/', function(req, res) {
res.send('Birds home page');
});
router.get('/', (req, res) => {
res.send('Birds home page')
})
// define the about route
router.get('/about', function(req, res) {
res.send('About birds');
});
router.get('/about', (req, res) => {
res.send('About birds')
})
module.exports = router;
</code>
</pre>
module.exports = router
```
Puis, chargez le module de routage dans l'application :
<pre>
<code class="language-javascript" translate="no">
var birds = require('./birds');
...
app.use('/birds', birds);
</code>
</pre>
```js
const birds = require('./birds')
/// ...
app.use('/birds', birds)
```
L'application pourra dorénavant gérer des demandes dans `/birds` et `/birds/about`, et appeler la fonction middleware `timeLog` spécifique à la route.

227
fr/guide/using-middleware.md
View File

@@ -39,153 +39,136 @@ Liez le middleware niveau application à une instance de l'objet [app object](/{
Cet exemple illustre une fonction middleware sans chemin de montage. La fonction est exécutée à chaque fois que l'application reçoit une demande.
<pre>
<code class="language-javascript" translate="no">
var app = express();
```js
const app = express()
app.use(function (req, res, next) {
console.log('Time:', Date.now());
next();
});
</code>
</pre>
app.use((req, res, next) => {
console.log('Time:', Date.now())
next()
})
```
Cet exemple illustre une fonction middleware montée sur le chemin `/user/:id`. La fonction est exécutée pour tout type de
demande HTTP sur le chemin`/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.use('/user/:id', function (req, res, next) {
console.log('Request Type:', req.method);
next();
});
</code>
</pre>
```js
app.use('/user/:id', (req, res, next) => {
console.log('Request Type:', req.method)
next()
})
```
Cet exemple illustre une route et sa fonction de gestionnaire (système de middleware). La fonction gère les demandes GET adressées au chemin `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.get('/user/:id', function (req, res, next) {
res.send('USER');
});
</code>
</pre>
```js
app.get('/user/:id', (req, res, next) => {
res.send('USER')
})
```
Voici un exemple de chargement d'une série de fonctions middleware sur un point de montage, avec un chemin de montage.
Il illustre une sous-pile de middleware qui imprime les infos de demande pour tout type de demande HTTP adressée au chemin `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.use('/user/:id', function(req, res, next) {
console.log('Request URL:', req.originalUrl);
next();
}, function (req, res, next) {
console.log('Request Type:', req.method);
next();
});
</code>
</pre>
```js
app.use('/user/:id', (req, res, next) => {
console.log('Request URL:', req.originalUrl)
next()
}, (req, res, next) => {
console.log('Request Type:', req.method)
next()
})
```
Les gestionnaires de routage vous permettent de définir plusieurs routes pour un chemin. L'exemple ci-dessous définit deux routes pour les demandes GET adressées au chemin `/user/:id`. La deuxième route ne causera aucun problème, mais ne sera jamais appelée puisque la première route boucle le cycle demande-réponse.
Cet exemple illustre une sous-pile de middleware qui gère les demandes GET adressées au chemin `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.get('/user/:id', function (req, res, next) {
console.log('ID:', req.params.id);
next();
}, function (req, res, next) {
res.send('User Info');
});
```js
app.get('/user/:id', (req, res, next) => {
console.log('ID:', req.params.id)
next()
}, (req, res, next) => {
res.send('User Info')
})
// handler for the /user/:id path, which prints the user ID
app.get('/user/:id', function (req, res, next) {
res.end(req.params.id);
});
</code>
</pre>
app.get('/user/:id', (req, res, next) => {
res.end(req.params.id)
})
```
Pour ignorer les fonctions middleware issues d'une pile de middleware de routeur, appelez `next('route')` pour passer le contrôle à la prochaine route.
**REMARQUE **: `next('route')` ne fonctionnera qu'avec les fonctions middleware qui ont été chargées via les fonctions `app.METHOD()` ou `router.METHOD()`.
Cet exemple illustre une sous-pile de middleware qui gère les demandes GET adressées au chemin `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.get('/user/:id', function (req, res, next) {
```js
app.get('/user/:id', (req, res, next) => {
// if the user ID is 0, skip to the next route
if (req.params.id == 0) next('route');
if (req.params.id === '0') next('route')
// otherwise pass the control to the next middleware function in this stack
else next(); //
}, function (req, res, next) {
else next() //
}, (req, res, next) => {
// render a regular page
res.render('regular');
});
res.render('regular')
})
// handler for the /user/:id path, which renders a special page
app.get('/user/:id', function (req, res, next) {
res.render('special');
});
</code>
</pre>
app.get('/user/:id', (req, res, next) => {
res.render('special')
})
```
<h2 id='middleware.router'>Middleware niveau routeur</h2>
Le middleware niveau routeur fonctionne de la même manière que le middleware niveau application, à l'exception près qu'il est lié à une instance de `express.Router()`.
<pre>
<code class="language-javascript" translate="no">
var router = express.Router();
</code>
</pre>
```js
const router = express.Router()
```
Chargez le middleware niveau routeur par le biais des fonctions `router.use()` et `router.METHOD()`.
Le code d'exemple suivant réplique le système de middleware illustré ci-dessus pour le middleware niveau application, en utilisant un middleware niveau routeur :
<pre>
<code class="language-javascript" translate="no">
var app = express();
var router = express.Router();
```js
const app = express()
const router = express.Router()
// a middleware function with no mount path. This code is executed for every request to the router
router.use(function (req, res, next) {
console.log('Time:', Date.now());
next();
});
router.use((req, res, next) => {
console.log('Time:', Date.now())
next()
})
// a middleware sub-stack shows request info for any type of HTTP request to the /user/:id path
router.use('/user/:id', function(req, res, next) {
console.log('Request URL:', req.originalUrl);
next();
}, function (req, res, next) {
console.log('Request Type:', req.method);
next();
});
router.use('/user/:id', (req, res, next) => {
console.log('Request URL:', req.originalUrl)
next()
}, (req, res, next) => {
console.log('Request Type:', req.method)
next()
})
// a middleware sub-stack that handles GET requests to the /user/:id path
router.get('/user/:id', function (req, res, next) {
router.get('/user/:id', (req, res, next) => {
// if the user ID is 0, skip to the next router
if (req.params.id == 0) next('route');
if (req.params.id === '0') next('route')
// otherwise pass control to the next middleware function in this stack
else next(); //
}, function (req, res, next) {
else next() //
}, (req, res, next) => {
// render a regular page
res.render('regular');
});
res.render('regular')
})
// handler for the /user/:id path, which renders a special page
router.get('/user/:id', function (req, res, next) {
console.log(req.params.id);
res.render('special');
});
router.get('/user/:id', (req, res, next) => {
console.log(req.params.id)
res.render('special')
})
// mount the router on the app
app.use('/', router);
</code>
</pre>
app.use('/', router)
```
<h2 id='middleware.error-handling'>Middleware de traitement d'erreurs</h2>
<div class="doc-box doc-notice" markdown="1">
@@ -194,14 +177,12 @@ Le middleware de traitement d'erreurs comporte toujours *quatre* arguments. Vou
Définissez les fonctions middleware de traitement d'erreurs de la même façon que d'autres fonctions middleware, à l'exception près qu'il faudra 4 arguments au lieu de 3, et plus particulièrement avec la signature `(err, req, res, next)`) :
<pre>
<code class="language-javascript" translate="no">
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Something broke!');
});
</code>
</pre>
```js
app.use((err, req, res, next) => {
console.error(err.stack)
res.status(500).send('Something broke!')
})
```
Pour obtenir des détails sur le middleware de traitement d'erreurs, reportez-vous à : [Traitement d'erreurs](/{{ page.lang }}/guide/error-handling.html).
@@ -231,9 +212,8 @@ L'objet `options` facultatif peut avoir les propriétés suivantes :
Voici un exemple d'utilisation de la fonction middleware `express.static` avec un objet options élaboré :
<pre>
<code class="language-javascript" translate="no">
var options = {
```js
const options = {
dotfiles: 'ignore',
etag: false,
extensions: ['htm', 'html'],
@@ -241,23 +221,20 @@ var options = {
maxAge: '1d',
redirect: false,
setHeaders: function (res, path, stat) {
res.set('x-timestamp', Date.now());
res.set('x-timestamp', Date.now())
}
}
app.use(express.static('public', options));
</code>
</pre>
app.use(express.static('public', options))
```
Vous pouvez avoir plusieurs répertoires statiques par application :
<pre>
<code class="language-javascript" translate="no">
app.use(express.static('public'));
app.use(express.static('uploads'));
app.use(express.static('files'));
</code>
</pre>
```js
app.use(express.static('public'))
app.use(express.static('uploads'))
app.use(express.static('files'))
```
Pour obtenir plus de détails sur la fonction `serve-static` et ses options, reportez-vous à la documentation [serve-static](https://github.com/expressjs/serve-static).
@@ -269,19 +246,17 @@ Installez le module Node.js pour la fonctionnalité requise, puis chargez-le dan
L'exemple suivant illustre l'installation et le chargement de la fonction middleware d'analyse de cookie `cookie-parser`.
```console
```bash
$ npm install cookie-parser
```
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
var cookieParser = require('cookie-parser');
```js
const express = require('express')
const app = express()
const cookieParser = require('cookie-parser')
// load the cookie-parsing middleware
app.use(cookieParser());
</code>
</pre>
app.use(cookieParser())
```
Pour obtenir une liste non exhaustive des fonctions middleware tiers utilisées couramment avec Express, reportez-vous à : [Middleware tiers](../resources/middleware.html).

28
fr/guide/using-template-engines.md
View File

@@ -16,7 +16,7 @@ Pour qu'Express puisse afficher le rendu des fichiers modèles, vous devez défi
Ensuite, installez le package npm du moteur de modèle correspondant :
```console
```bash
$ npm install pug --save
```
@@ -28,33 +28,27 @@ Certaines moteurs de modèles ne suivent pas cette convention. La bibliothèque
Une fois le moteur de vue défini, vous n'avez pas à spécifier le moteur ou à charger le module de moteur de modèles dans votre application ; Express charge le module en interne, comme indiqué ci-dessous (pour l'exemple ci-dessus).
<pre>
<code class="language-javascript" translate="no">
app.set('view engine', 'pug');
</code>
</pre>
```js
app.set('view engine', 'pug')
```
Créez un fichier de modèle Pug nommé `index.pug` dans le répertoire `views`, avec le contenu suivant :
<pre>
<code class="language-javascript" translate="no">
```pug
html
head
title= title
body
h1= message
</code>
</pre>
```
Puis, créez une route pour générer le fichier `index.pug`. Si la propriété `view engine` n'est pas définie, vous devez spécifier l'extension du fichier `view`. Sinon, vous pouvez l'omettre.
<pre>
<code class="language-javascript" translate="no">
app.get('/', function (req, res) {
res.render('index', { title: 'Hey', message: 'Hello there!'});
});
</code>
</pre>
```js
app.get('/', (req, res) => {
res.render('index', { title: 'Hey', message: 'Hello there!' })
})
```
Lorsque vous faites une demande vers la page d'accueil, le fichier `index.pug` est généré en HTML.

107
fr/guide/writing-middleware.md
View File

@@ -69,31 +69,27 @@ app.get('/', function(req, res, next) {
Voici un exemple d'une application Express "Hello World" simple, pour laquelle vous allez définir deux fonctions middleware :
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
```js
const express = require('express')
const app = express()
app.get('/', function (req, res) {
res.send('Hello World!');
});
app.get('/', (req, res) => {
res.send('Hello World!')
})
app.listen(3000);
</code>
</pre>
app.listen(3000)
```
<h2>Développement</h2>
Voici un exemple simple de fonction middleware appelée "myLogger". Cette fonction imprime simplement "LOGGED" lorsqu'une demande traverse l'application. La fonction middleware est affectée à une variable nommée `myLogger`.
<pre>
<code class="language-javascript" translate="no">
var myLogger = function (req, res, next) {
console.log('LOGGED');
next();
};
</code>
</pre>
```js
const myLogger = function (req, res, next) {
console.log('LOGGED')
next()
}
```
<div class="doc-box doc-notice" markdown="1">
Notez l'appel ci-dessus de la fonction `next()`, qui appelle la fonction middleware suivant dans l'application. La fonction `next()` ne fait pas partie du Node.js ou de l'API Express, mais c'est le troisième argument qui est transmis à la fonction middleware. La fonction `next()` peut porter n'importe quel nom, mais par convention elle est toujours appelée "next". Pour éviter toute confusion, il est préférable de respecter cette convention.
@@ -102,25 +98,23 @@ Notez l'appel ci-dessus de la fonction `next()`, qui appelle la fonction middle
Pour charger la fonction middleware, appelez `app.use()` en spécifiant la fonction middleware.
Par exemple, le code suivant charge la fonction middleware `myLogger` avant la route au chemin racine (/).
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
```js
const express = require('express')
const app = express()
var myLogger = function (req, res, next) {
console.log('LOGGED');
next();
};
const myLogger = function (req, res, next) {
console.log('LOGGED')
next()
}
app.use(myLogger);
app.use(myLogger)
app.get('/', function (req, res) {
res.send('Hello World!');
});
app.get('/', (req, res) => {
res.send('Hello World!')
})
app.listen(3000);
</code>
</pre>
app.listen(3000)
```
Chaque fois que l'application reçoit une demande, elle imprime le message "LOGGED" sur le terminal.
@@ -132,39 +126,34 @@ La fonction middleware `myLogger` imprime simplement un message, puis traite la
L'exemple suivant ajoute une propriété appelée `requestTime` à l'objet Request. Nous nommerons cette fonction middleware "requestTime".
<pre>
<code class="language-javascript" translate="no">
var requestTime = function (req, res, next) {
req.requestTime = Date.now();
next();
};
</code>
</pre>
```js
const requestTime = function (req, res, next) {
req.requestTime = Date.now()
next()
}
```
L'application utilise désormais la fonction middleware `requestTime`. De plus, la fonction callback de la route du chemin racine utilise la propriété que la fonction middleware ajoute à `req` (l'objet Request).
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
```js
const express = require('express')
const app = express()
var requestTime = function (req, res, next) {
req.requestTime = Date.now();
next();
};
const requestTime = function (req, res, next) {
req.requestTime = Date.now()
next()
}
app.use(requestTime);
app.use(requestTime)
app.get('/', function (req, res) {
var responseText = 'Hello World!<br>';
responseText += '<small>Requested at: ' + req.requestTime + '</small>';
res.send(responseText);
});
app.listen(3000);
</code>
</pre>
app.get('/', (req, res) => {
let responseText = 'Hello World!<br>'
responseText += `<small>Requested at: ${req.requestTime}</small>`
res.send(responseText)
})
app.listen(3000)
```
Si vous effectuez une demande à la racine de l'application, cette dernière affiche maintenant l'horodatage de la demande dans le navigateur.
Puisque vous avez accès à l'objet Request, à l'objet Response, à la fonction middleware suivant dans la pile et à l'API Node.js complète, le champ des possibles avec les fonctions middleware est infini.

54
fr/starter/basic-routing.md
View File

@@ -16,11 +16,9 @@ nœud final spécifique, c'est-à-dire un URI (ou chemin) et une méthode de req
Chaque route peut avoir une ou plusieurs fonctions de gestionnaire, qui sont exécutées lorsque la route est mise en correspondance.
La définition de la route utilise la structure suivante :
<pre>
<code class="language-javascript" translate="no">
```js
app.METHOD(PATH, HANDLER)
</code>
</pre>
```
Où :
@@ -38,42 +36,34 @@ Les exemples suivants illustrent la définition de routes simples.
Réponse `Hello World!` sur la page d'accueil :
<pre>
<code class="language-javascript" translate="no">
app.get('/', function (req, res) {
res.send('Hello World!');
});
</code>
</pre>
```js
app.get('/', (req, res) => {
res.send('Hello World!')
})
```
Réponse à une demande POST sur la route racine (`/`), sur la page d'accueil de l'application :
<pre>
<code class="language-javascript" translate="no">
app.post('/', function (req, res) {
res.send('Got a POST request');
});
</code>
</pre>
```js
app.post('/', (req, res) => {
res.send('Got a POST request')
})
```
Réponse à une demande PUT sur la route `/user` :
<pre>
<code class="language-javascript" translate="no">
app.put('/user', function (req, res) {
res.send('Got a PUT request at /user');
});
</code>
</pre>
```js
app.put('/user', (req, res) => {
res.send('Got a PUT request at /user')
})
```
Réponse à une demande DELETE sur la route `/user` :
<pre>
<code class="language-javascript" translate="no">
app.delete('/user', function (req, res) {
res.send('Got a DELETE request at /user');
});
</code>
</pre>
```js
app.delete('/user', (req, res) => {
res.send('Got a DELETE request at /user')
})
```
Pour plus de détails sur le routage, reportez-vous au [guide de routage](/{{ page.lang }}/guide/routing.html).

26
fr/starter/faq.md
View File

@@ -60,27 +60,23 @@ 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 :
<pre>
<code class="language-javascript" translate="no">
app.use(function(req, res, next) {
res.status(404).send('Sorry cant find that!');
});
</code>
</pre>
```js
app.use((req, res, next) => {
res.status(404).send('Sorry cant find that!')
})
```
## 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)` :
<pre>
<code class="language-javascript" translate="no">
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Something broke!');
});
</code>
</pre>
```js
app.use((err, req, res, next) => {
console.error(err.stack)
res.status(500).send('Something broke!')
})
```
Pour plus d'informations, voir [Traitement d'erreurs](/{{ page.lang }}/guide/error-handling.html).

14
fr/starter/generator.md
View File

@@ -13,13 +13,13 @@ Utilisez l'outil de générateur d'applications, `express`, pour créer rapideme
Installez `express` à l'aide de la commande suivante :
```console
```bash
$ npm install express-generator -g
```
Affichez les options de commande à l'aide de l'option `-h` :
```console
```bash
$ express -h
Usage: express [options][dir]
@@ -41,7 +41,7 @@ $ express -h
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 <a href="pugjs.org" target="_blank" title="Documentation Pug">Pug</a>:
```console
```bash
$ express --view=pug myapp
create : myapp
@@ -65,20 +65,20 @@ $ express --view=pug myapp
Ensuite, installez les dépendances :
```console
```bash
$ cd myapp
$ npm install
```
Sous MacOS ou Linux, exécutez l'application à l'aide de la commande suivante :
```console
```bash
$ DEBUG=myapp:* npm start
```
Sous Windows, utilisez la commande suivante :
```console
```bash
> set DEBUG=myapp:* & npm start
```
@@ -86,7 +86,7 @@ Ensuite, chargez 'http://hôte_local:3000/' dans votre navigateur pour accéder
L'application générée possède la structure de répertoire suivante :
```console
```bash
.
├── app.js
├── bin

8
fr/starter/hello-world.md
View File

@@ -19,8 +19,7 @@ Ensuite, installez `express` en tant que dépendance en suivant les instructions
Dans le répertoire `myapp`, créez un fichier appelé `app.js` et ajoutez le code suivant :
<pre>
<code class="language-javascript" translate="no">
```js
const express = require('express')
const app = express()
const port = 3000
@@ -32,8 +31,7 @@ app.get('/', (req, res) => {
app.listen(port, () => {
console.log(`Example app listening on port ${port}`)
})
</code>
</pre>
```
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**.
@@ -45,7 +43,7 @@ Les objets `req` (demande) et `res` (réponse) sont exactement les mêmes que ce
Exécutez l'application avec la commande suivante :
```console
```bash
$ node app.js
```

10
fr/starter/installing.md
View File

@@ -11,7 +11,7 @@ description: Learn how to install Express.js in your Node.js environment, includ
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.
```console
```bash
$ mkdir myapp
$ cd myapp
```
@@ -19,14 +19,14 @@ $ 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).
```console
```bash
$ 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 :
```console
```bash
entry point: (index.js)
```
@@ -34,13 +34,13 @@ Entrez `app.js` ou un nom de votre choix pour le fichier principal. Si vous souh
Installez ensuite Express dans le répertoire `myapp`, puis sauvegardez-le dans la liste des dépendances. Par exemple :
```console
```bash
$ npm install express --save
```
Pour installer Express de façon temporaire et ne pas l'ajouter à la liste des dépendances, omettez l'option `--save` :
```console
```bash
$ npm install express
```

47
fr/starter/static-files.md
View File

@@ -20,24 +20,20 @@ les fichiers directement. Par exemple, utilisez le code suivant pour
servir des images, des fichiers CSS et des fichiers JavaScript dans
un répertoire nommé `public` :
<pre>
<code class="language-javascript" translate="no">
app.use(express.static('public'));
</code>
</pre>
```js
app.use(express.static('public'))
```
Maintenant, vous pouvez charger les fichiers qui sont dans le
répertoire `public` :
<pre>
<code class="language-javascript" translate="no">
```text
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
</code>
</pre>
```
<div class="doc-box doc-info">
Express recherche les fichiers relatifs au répertoire statique, donc
@@ -48,12 +44,10 @@ Pour utiliser plusieurs répertoires statiques actifs,
utilisez la fonction middleware
`express.static` plusieurs fois :
<pre>
<code class="language-javascript" translate="no">
app.use(express.static('public'));
app.use(express.static('files'));
</code>
</pre>
```js
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`.
@@ -65,25 +59,21 @@ pour les fichiers qui sont servis par la fonction
chemin de montage](/{{ page.lang }}/4x/api.html#app.use) pour le répertoire statique, comme démontré
ci-dessous :
<pre>
<code class="language-javascript" translate="no">
app.use('/static', express.static('public'));
</code>
</pre>
```js
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`.
<pre>
<code class="language-javascript" translate="no">
```text
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
</code>
</pre>
```
Cependant, le chemin d'accès que vous fournissez à la
fonction `express.static` est en rapport avec
@@ -92,8 +82,7 @@ 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 :
<pre>
<code class="language-javascript" translate="no">
app.use('/static', express.static(__dirname + '/public'));
</code>
</pre>
```js
const path = require('path')
app.use('/static', express.static(path.join(__dirname, 'public')))
```

14
id/advanced/best-practice-performance.md
View File

@@ -298,13 +298,13 @@ You can easily install StrongLoop Process Manager as a systemd service. After yo
To install StrongLoop PM as a systemd service:
```console
```bash
$ sudo sl-pm-install --systemd
```
Then start the service with:
```console
```bash
$ sudo /usr/bin/systemctl start strong-pm
```
@@ -366,13 +366,13 @@ You can easily install StrongLoop Process Manager as an Upstart service. After y
To install StrongLoop PM as an Upstart 1.4 service:
```console
```bash
$ sudo sl-pm-install
```
Then run the service with:
```console
```bash
$ sudo /sbin/initctl start strong-pm
```
@@ -400,7 +400,7 @@ When StrongLoop Process Manager (PM) runs an application, it automatically runs
For example, assuming you've deployed your app to prod.foo.com and StrongLoop PM is listening on port 8701 (the default), then to set the cluster size to eight using slc:
```console
```bash
$ slc ctl -C http://prod.foo.com:8701 set-size my-app 8
```
@@ -414,7 +414,7 @@ When running an application with PM2, you can enable **cluster mode** to run it
To enable cluster mode, start your application like so:
```console
```bash
# Start 4 worker processes
$ pm2 start npm --name my-app -i 4 -- start
# Auto-detect number of available CPUs and start that many worker processes
@@ -425,7 +425,7 @@ This can also be configured within a PM2 process file (`ecosystem.config.js` or
Once running, the application can be scaled like so:
```console
```bash
# Add 3 more workers
$ pm2 scale my-app +3
# Scale to a specific number of workers

8
id/advanced/best-practice-security.md
View File

@@ -91,7 +91,7 @@ Helmet includes several other middleware functions which you can read about [at
Install Helmet like any other module:
```console
```bash
$ npm install --save helmet
```
@@ -222,7 +222,7 @@ Using npm to manage your application's dependencies is powerful and convenient.
Since npm@6, npm automatically reviews every install request. Also, you can use `npm audit` to analyze your dependency tree.
```console
```bash
$ npm audit
```
@@ -230,14 +230,14 @@ If you want to stay more secure, consider [Snyk](https://snyk.io/).
Snyk offers both a [command-line tool](https://www.npmjs.com/package/snyk) and a [Github integration](https://snyk.io/docs/github) that checks your application against [Snyk's open source vulnerability database](https://snyk.io/vuln/) for any known vulnerabilities in your dependencies. Install the CLI as follows:
```console
```bash
$ npm install -g snyk
$ cd your-app
```
Use this command to test your application for vulnerabilities:
```console
```bash
$ snyk test
```

2
id/advanced/developing-template-engines.md
View File

@@ -31,7 +31,7 @@ app.set('view engine', 'ntl') // register the template engine
Your app will now be able to render `.ntl` files. Create a file named `index.ntl` in the `views` directory with the following content.
```text
```pug
#title#
#message#
```

26
id/guide/database-integration.md
View File

@@ -35,7 +35,7 @@ search on the [npm](https://www.npmjs.com/) site.
### Installation
```console
```bash
$ npm install cassandra-driver
```
@@ -57,7 +57,7 @@ client.execute('select key from system.local', (err, result) => {
### Installation
```console
```bash
$ npm install couchbase
```
@@ -94,7 +94,7 @@ bucket.query(query, [13], (err, result) => {
### Installation
```console
```bash
$ npm install nano
```
@@ -130,7 +130,7 @@ books.list((err, body) => {
### Installation
```console
```bash
$ npm install level levelup leveldown
```
@@ -157,7 +157,7 @@ db.put('name', 'LevelUP', (err) => {
### Installation
```console
```bash
$ npm install mysql
```
@@ -189,7 +189,7 @@ connection.end()
### Installation
```console
```bash
$ npm install mongodb
```
@@ -236,7 +236,7 @@ If you want an object model driver for MongoDB, look at [Mongoose](https://githu
### Installation
```console
```bash
$ npm install neo4j-driver
```
@@ -267,7 +267,7 @@ session.readTransaction((tx) => {
NOTE: [See installation prerequisites](https://github.com/oracle/node-oracledb#-installation).
```console
```bash
$ npm install oracledb
```
@@ -311,7 +311,7 @@ getEmployee(101)
### Installation
```console
```bash
$ npm install pg-promise
```
@@ -336,7 +336,7 @@ db.one('SELECT $1 AS value', 123)
### Installation
```console
```bash
$ npm install redis
```
@@ -371,7 +371,7 @@ client.hkeys('hash key', (err, replies) => {
### Installation
```console
```bash
$ npm install tedious
```
@@ -432,7 +432,7 @@ function executeStatement () {
### Installation
```console
```bash
$ npm install sqlite3
```
@@ -466,7 +466,7 @@ db.close()
### Installation
```console
```bash
$ npm install elasticsearch
```

12
id/guide/debugging.md
View File

@@ -11,19 +11,19 @@ description: Learn how to enable and use debugging logs in Express.js applicatio
To see all the internal logs used in Express, set the `DEBUG` environment variable to
`express:*` when launching your app.
```console
```bash
$ DEBUG=express:* node index.js
```
On Windows, use the corresponding command.
```console
```bash
> set DEBUG=express:* & node index.js
```
Running this command on the default app generated by the [express generator](/{{ page.lang }}/starter/generator.html) prints the following output:
```console
```bash
$ DEBUG=express:* node ./bin/www
express:router:route new / +0ms
express:router:layer new / +1ms
@@ -69,7 +69,7 @@ $ DEBUG=express:* node ./bin/www
When a request is then made to the app, you will see the logs specified in the Express code:
```console
```bash
express:router dispatching GET / +4h
express:router query : / +2ms
express:router expressInit : / +0ms
@@ -95,13 +95,13 @@ An application generated by the `express` command uses the `debug` module and it
For example, if you generated the app with `$ express sample-app`, you can enable the debug statements with the following command:
```console
```bash
$ DEBUG=sample-app:* node ./bin/www
```
You can specify more than one debug namespace by assigning a comma-separated list of names:
```console
```bash
$ DEBUG=http,mail,express:* node index.js
```

12
id/guide/migrating-4.md
View File

@@ -384,7 +384,7 @@ Begin the migration process by installing the required middleware for the
Express 4 app and updating Express and Pug to their respective latest
version with the following command:
```console
```bash
$ npm install serve-favicon morgan method-override express-session body-parser multer errorhandler express@latest pug@latest --save
```
@@ -499,7 +499,7 @@ app.listen(app.get('port'), () => {
The migration process is complete, and the app is now an
Express 4 app. To confirm, start the app by using the following command:
```console
```bash
$ node .
```
@@ -518,7 +518,7 @@ The command-line tool to generate an Express app is still
If you already have the Express 3 app generator installed on your system,
you must uninstall it:
```console
```bash
$ npm uninstall -g express
```
Depending on how your file and directory privileges are configured,
@@ -526,7 +526,7 @@ you might need to run this command with `sudo`.
Now install the new generator:
```console
```bash
$ npm install -g express-generator
```
@@ -549,7 +549,7 @@ Command options and use largely remain the same, with the following exceptions:
Execute the following command to create an Express 4 app:
```console
```bash
$ express app4
```
@@ -562,7 +562,7 @@ You will also notice that the `app.js` file is now a Node.js module, in contrast
After installing the dependencies, start the app by using the following command:
```console
```bash
$ npm start
```

2
id/guide/migrating-5.md
View File

@@ -14,7 +14,7 @@ Express 5.0 is still in the beta release stage, but here is a preview of the cha
To install the latest beta and to preview Express 5, enter the following command in your application root directory:
```console
```bash
$ npm install "express@^{{ site.data.express.next_version }}" --save
```

2
id/guide/using-middleware.md
View File

@@ -254,7 +254,7 @@ Install the Node.js module for the required functionality, then load it in your
The following example illustrates installing and loading the cookie-parsing middleware function `cookie-parser`.
```console
```bash
$ npm install cookie-parser
```

2
id/guide/using-template-engines.md
View File

@@ -32,7 +32,7 @@ This defaults to the `views` directory in the application root directory.
Then install the corresponding template engine npm package; for example to install Pug:
```console
```bash
$ npm install pug --save
```

18
id/starter/generator.md
View File

@@ -13,20 +13,20 @@ Gunakan alat generator aplikasi, `express-generator`, untuk membuat kerangka apl
Anda dapat menjalankan generator aplikasi dengan perintah `npx` (tersedia di Node.js versi 8.2.0).
```console
```bash
$ npx express-generator
```
Untuk versi Node sebelumnya, instal generator aplikasi sebagai paket npm secara global lalu jalankan:
```console
```bash
$ npm install -g express-generator
$ express
```
Tampilkan daftar opsi perintah dengan opsi `-h`:
```console
```bash
$ express -h
Usage: express [options] [dir]
@@ -48,7 +48,7 @@ $ express -h
Misal, tutorial berikut ini kita akan membuat aplikasi Express bernama _myapp_. Aplikasi akan dibuat dalam folder bernama _myapp_ di direktori kerja saat ini dan _view engine_ yang akan digunakan adalah <a href="https://pugjs.org/" target="_blank" title="Pug documentation">Pug</a>:
```console
```bash
$ express --view=pug myapp
create : myapp
@@ -72,26 +72,26 @@ $ express --view=pug myapp
Kemudian instal semua dependensi project:
```console
```bash
$ cd myapp
$ npm install
```
Di MacOS atau Linux, jalankan aplikasi dengan perintah ini:
```console
```bash
$ DEBUG=myapp:* npm start
```
Di _Command Prompt_ Windows, gunakan perintah ini:
```console
```bash
> set DEBUG=myapp:* & npm start
```
Di _PowerShell_ Windows, gunakan perintah ini:
```console
```bash
PS> $env:DEBUG='myapp:*'; npm start
```
@@ -100,7 +100,7 @@ Kemudian, kunjungi `http://localhost:3000/` di browser Anda untuk mengakses apli
Aplikasi yang dihasilkan memiliki struktur direktori sebagai berikut:
```console
```bash
.
├── app.js
├── bin

2
id/starter/hello-world.md
View File

@@ -43,7 +43,7 @@ Di direktori `myapp`, buat file bernama `app.js` dan salin kode dari contoh di a
Jalankan aplikasi dengan perintah berikut:
```console
```bash
$ node app.js
```

8
id/starter/installing.md
View File

@@ -14,7 +14,7 @@ Kami asumsikan Anda telah menginstal [Node.js](https://nodejs.org/), buatlah dir
* [Express versi 4.x](/{{ page.lang }}/4x/api.html) memerlukan Node.js versi 0.10 atau yang lebih tinggi.
* [Express versi 5.x](/{{ page.lang }}/5x/api.html) memerlukan Node.js versi 18 atau yang lebih tinggi.
```console
```bash
$ mkdir myapp
$ cd myapp
```
@@ -22,7 +22,7 @@ $ cd myapp
Gunakan perintah `npm init` untuk membuat file `package.json` untuk aplikasi Anda.
Untuk informasi selengkapnya tentang cara kerja `package.json`, lihat [Spesifikasi penggunaan package.json dari npm](https://docs.npmjs.com/files/package.json).
```console
```bash
$ npm init
```
@@ -37,13 +37,13 @@ Masukan `app.js`, atau apa pun nama file utamanya yang Anda inginkan. Jika Anda
Sekarang, instal Express di direktori `myapp` dan simpan di daftar dependensi. Misalnya:
```console
```bash
$ npm install express
```
Untuk menginstal Express secara sementara dan tidak menambahkannya ke daftar dependensi, jalankan perintah berikut:
```console
```bash
$ npm install express --no-save
```

4
id/starter/static-files.md
View File

@@ -28,7 +28,7 @@ app.use(express.static('public'))
Sekarang, Anda dapat melihat file yang ada di direktori `public`:
```plain-text
```text
http://localhost:3000/images/kitten.jpg
http://localhost:3000/css/style.css
http://localhost:3000/js/app.js
@@ -60,7 +60,7 @@ app.use('/static', express.static('public'))
Sekarang, Anda dapat melihat file yang ada di direktori `public` menggunakan awalan jalur `/static`.
```plain-text
```text
http://localhost:3000/static/images/kitten.jpg
http://localhost:3000/static/css/style.css
http://localhost:3000/static/js/app.js

10
index.md
View File

@@ -17,9 +17,9 @@ redirect_from: "/en/index.html"
<div id="install-command">$ npm install express --save</div>
</div>
<div id="homepage-rightpane" class="pane">
<div id="quick-start">
<pre><code class="language-javascript">
<div id="homepage-rightpane" class="pane" markdown="1">
```javascript
const express = require('express')
const app = express()
const port = 3000
@@ -31,8 +31,8 @@ app.get('/', (req, res) => {
app.listen(port, () => {
console.log(`Example app listening on port ${port}`)
})
</code></pre>
</div>
```
</div>
</section>
<section id="announcements">

34
it/advanced/best-practice-performance.md
View File

@@ -198,23 +198,19 @@ Nello sviluppo, solitamente si impostano le variabili di ambiente nella shell in
Con Upstart, utilizzare la parola chiave `env` nel file job. Ad esempio:
<pre>
<code class="language-sh" translate="no">
```sh
# /etc/init/env.conf
env NODE_ENV=production
</code>
</pre>
```
Per ulteriori informazioni, consultare [Upstart Intro, Cookbook and Best Practices](http://upstart.ubuntu.com/cookbook/#environment-variables).
Con systemd, utilizzare la direttiva `Environment` nel file unit. Ad esempio:
<pre>
<code class="language-sh" translate="no">
```sh
# /etc/systemd/system/myservice.service
Environment=NODE_ENV=production
</code>
</pre>
```
Per ulteriori informazioni, consultare [Using Environment Variables In systemd Units](https://coreos.com/os/docs/latest/using-environment-variables-in-systemd-units.html).
@@ -275,8 +271,7 @@ Systemd è un sistema Linux e un service manager. Le più importanti distribuzio
Un file di configurazione del servizio systemd è denominato *unit file*, con un nome file che termina con .service. Segue un unit file di esempio per gestire un'applicazione Node direttamente (sostituire il testo in grassetto con i valori appropriati per il proprio sistema e applicazione):
<pre>
<code class="language-sh" translate="no">
```sh
[Unit]
Description=Awesome Express App
@@ -304,8 +299,7 @@ Restart=always
[Install]
WantedBy=multi-user.target
</code>
</pre>
```
Per ulteriori informazioni su systemd, consultare [systemd reference (man page)](http://www.freedesktop.org/software/systemd/man/systemd.unit.html).
##### StrongLoop PM in qualità di servizio systemd
@@ -314,13 +308,13 @@ Per ulteriori informazioni su systemd, consultare [systemd reference (man page)]
Per installare StrongLoop PM in qualità di servizio systemd:
```console
```bash
$ sudo sl-pm-install --systemd
```
Successivamente, avviare il servizio con:
```console
```bash
$ sudo /usr/bin/systemctl start strong-pm
```
@@ -334,8 +328,7 @@ Un servizio Upstart è definito in un file di configurazione del lavoro (anche n
Creare un file denominato `myapp.conf` in `/etc/init/` con il seguente contenuto (sostituire il testo in grassetto con i valori appropriati per il proprio sistema e applicazione):
<pre>
<code class="language-sh" translate="no">
```sh
# When to start the process
start on runlevel [2345]
@@ -363,8 +356,7 @@ respawn
# Limit restart attempt to 10 times within 10 seconds
respawn limit 10 10
</code>
</pre>
```
NOTA: questo script richiede Upstart 1.4 o versione successiva, supportato su Ubuntu 12.04-14.10.
@@ -384,13 +376,13 @@ Per ulteriori informazioni su Upstart, consultare [Upstart Intro, Cookbook and B
Per installare StrongLoop PM in qualità di servizio Upstart 1.4:
```console
```bash
$ sudo sl-pm-install
```
Successivamente, eseguire il servizio con:
```console
```bash
$ sudo /sbin/initctl start strong-pm
```
@@ -418,7 +410,7 @@ Quando StrongLoop Process Manager (PM) esegue un'applicazione, la esegue automat
Ad esempio, se l'applicazione è stata implementata su prod.foo.com e StrongLoop PM è in ascolto sulla porta 8701 (quella predefinita), per impostare la dimensione del cluster a otto utilizzando slc:
```console
```bash
$ slc ctl -C http://prod.foo.com:8701 set-size my-app 8
```

57
it/advanced/best-practice-security.md
View File

@@ -48,20 +48,20 @@ Attualmente, Helmet non è altro che una raccolta di nove funzioni middleware pi
Installare Helmet come qualsiasi altro modulo:
```console
```bash
$ npm install --save helmet
```
Successivamente, per utilizzarlo nel codice:
<pre>
<code class="language-javascript" translate="no">
...
var helmet = require('helmet');
app.use(helmet());
...
</code>
</pre>
```js
/// ...
const helmet = require('helmet')
app.use(helmet())
/// ...
```
### Disattivare almeno l'intestazione X-Powered-By
@@ -69,11 +69,9 @@ Se non si desidera Helmet, disattivare almeno l'intestazione `X-Powered-By`. Gl
Quindi, la miglior cosa da fare è disattivare l'intestazione con il metodo `app.disable()`:
<pre>
<code class="language-javascript" translate="no">
app.disable('x-powered-by');
</code>
</pre>
```js
app.disable('x-powered-by')
```
Se si utilizza `helmet.js`, questa operazione sarà effettuata per conto dell'utente.
@@ -96,17 +94,15 @@ L'utilizzo del nome del cookie della sessione predefinito potrebbe esporre l'app
Per evitare questo problema, utilizzare i nomi dei cookie predefiniti; ad esempio, utilizzando il middleware [express-session](https://www.npmjs.com/package/express-session):
<pre>
<code class="language-javascript" translate="no">
var session = require('express-session');
```js
const session = require('express-session')
app.set('trust proxy', 1) // trust first proxy
app.use(session({
secret: 's3Cur3',
name : 'sessionId',
name: 'sessionId'
})
);
</code>
</pre>
)
```
### Impostare le opzioni di sicurezza dei cookie
@@ -120,26 +116,25 @@ Impostare le seguenti opzioni per i cookie per aumentare la sicurezza:
Esempio di utilizzo del middleware [cookie-session](https://www.npmjs.com/package/cookie-session):
<pre>
<code class="language-javascript" translate="no">
var session = require('cookie-session');
var express = require('express');
var app = express();
```js
const session = require('cookie-session')
const express = require('express')
const app = express()
var expiryDate = new Date( Date.now() + 60 * 60 * 1000 ); // 1 hour
const expiryDate = new Date(Date.now() + 60 * 60 * 1000) // 1 hour
app.use(session({
name: 'session',
keys: ['key1', 'key2'],
cookie: { secure: true,
cookie: {
secure: true,
httpOnly: true,
domain: 'example.com',
path: 'foo/bar',
expires: expiryDate
}
})
);
</code>
</pre>
)
```
## Ulteriori informazioni

46
it/advanced/developing-template-engines.md
View File

@@ -13,38 +13,32 @@ Utilizzare il metodo `app.engine(ext, callback)` per creare il proprio motore di
Il seguente codice è un esempio di implementazione di un motore di template molto semplice per il rendering del file `.ntl`.
<pre>
<code class="language-javascript" translate="no">
var fs = require('fs'); // this engine requires the fs module
app.engine('ntl', function (filePath, options, callback) { // define the template engine
fs.readFile(filePath, function (err, content) {
if (err) return callback(new Error(err));
```js
const fs = require('fs') // this engine requires the fs module
app.engine('ntl', (filePath, options, callback) => { // define the template engine
fs.readFile(filePath, (err, content) => {
if (err) return callback(new Error(err))
// this is an extremely simple template engine
var rendered = content.toString().replace('#title#', '<title>'+ options.title +'</title>')
.replace('#message#', '<h1>'+ options.message +'</h1>');
return callback(null, rendered);
});
});
app.set('views', './views'); // specify the views directory
app.set('view engine', 'ntl'); // register the template engine
</code>
</pre>
const rendered = content.toString().replace('#title#', `<title>${options.title}</title>`)
.replace('#message#', `<h1>${options.message}</h1>`)
return callback(null, rendered)
})
})
app.set('views', './views') // specify the views directory
app.set('view engine', 'ntl') // register the template engine
```
L'applicazione sarà ora in grado di effettuare il rendering dei file `.ntl`. Creare un file denominato `index.ntl` nella directory `views` con il seguente contenuto.
<pre>
<code class="language-javascript" translate="no">
```pug
#title#
#message#
</code>
</pre>
```
Successivamente, creare il seguente percorso nell'applicazione.
<pre>
<code class="language-javascript" translate="no">
app.get('/', function (req, res) {
res.render('index', { title: 'Hey', message: 'Hello there!'});
});
</code>
</pre>
```js
app.get('/', (req, res) => {
res.render('index', { title: 'Hey', message: 'Hello there!' })
})
```
Quando si effettua una richiesta per la home page, `index.ntl` verrà visualizzato come HTML.

22
it/guide/behind-proxies.md
View File

@@ -37,12 +37,12 @@ Un indirizzo IP, una subnet o un array di indirizzi IP e subnet a cui fornire at
È possibile impostare gli indirizzi IP in uno dei seguenti modi:
<pre>
<code class="language-js" translate="no">app.set('trust proxy', 'loopback') // specify a single subnet
```js
app.set('trust proxy', 'loopback') // specify a single subnet
app.set('trust proxy', 'loopback, 123.123.123.123') // specify a subnet and an address
app.set('trust proxy', 'loopback, linklocal, uniquelocal') // specify multiple subnets as CSV
app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal']) // specify multiple subnets as an array</code>
</pre>
app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal']) // specify multiple subnets as an array
```
Quando specificati, gli indirizzi IP o le subnet vengono esclusi dal processo di determinazione dell'indirizzo e l'indirizzo IP non attendibile più vicino al server delle applicazioni viene considerato come indirizzo IP del client.
</td>
@@ -57,12 +57,14 @@ Considerare attendibile una parte del percorso `n`th dal server proxy principale
<td>Funzione</td>
<td markdown="1">
Implementazione attendibilità personalizzata. Questa funzione deve essere utilizzata solo da esperti.
<pre>
<code class="language-js" translate="no">app.set('trust proxy', function (ip) {
if (ip === '127.0.0.1' || ip === '123.123.123.123') return true; // trusted IPs
else return false;
});</code>
</pre>
```js
app.set('trust proxy', (ip) => {
if (ip === '127.0.0.1' || ip === '123.123.123.123') return true // trusted IPs
else return false
})
```
</td>
</tr>
</tbody>

22
it/guide/database-integration.md
View File

@@ -36,7 +36,7 @@ effettuare una ricerca nel sito [npm](https://www.npmjs.com/).
[cassandra-driver](https://github.com/datastax/nodejs-driver)
```console
```bash
$ npm install cassandra-driver
```
@@ -62,7 +62,7 @@ client.execute('select key from system.local', function(err, result) {
[nano](https://github.com/dscape/nano)
```console
```bash
$ npm install nano
```
@@ -96,7 +96,7 @@ books.list(function(err, body){
[levelup](https://github.com/rvagg/node-levelup)
```console
```bash
$ npm install level levelup leveldown
```
@@ -127,7 +127,7 @@ db.put('name', 'LevelUP', function (err) {
[mysql](https://github.com/felixge/node-mysql/)
```console
```bash
$ npm install mysql
```
@@ -161,7 +161,7 @@ connection.end();
[mongodb](https://github.com/mongodb/node-mongodb-native)
```console
```bash
$ npm install mongodb
```
@@ -195,7 +195,7 @@ Se si desidera un driver del modello oggetto per MongoDB, consultare [Mongoose](
[apoc](https://github.com/hacksparrow/apoc)
```console
```bash
$ npm install apoc
```
@@ -226,7 +226,7 @@ apoc.query('match (n) return n').exec().then(
NOTA: [Vedi i prerequisiti di installazione](https://github.com/oracle/node-oracledb#-installation).
```console
```bash
$ npm install oracledb
```
@@ -272,7 +272,7 @@ getEmployee(101)
[pg](https://github.com/brianc/node-postgres)
```console
```bash
$ npm install pg
```
@@ -308,7 +308,7 @@ pg.connect(conString, function(err, client, done) {
[redis](https://github.com/mranney/node_redis)
```console
```bash
$ npm install redis
```
@@ -347,7 +347,7 @@ client.hkeys('hash key', function (err, replies) {
[sqlite3](https://github.com/mapbox/node-sqlite3)
```console
```bash
$ npm install sqlite3
```
@@ -386,7 +386,7 @@ db.close();
[elasticsearch](https://github.com/elastic/elasticsearch-js)
```console
```bash
$ npm install elasticsearch
```

12
it/guide/debugging.md
View File

@@ -12,19 +12,19 @@ description: Learn how to enable and use debugging logs in Express.js applicatio
Per visualizzare tutti i log interni utilizzati in Express, impostare la variabile di ambiente `DEBUG` su
`express:*` quando si avvia l'applicazione.
```console
```bash
$ DEBUG=express:* node index.js
```
Su Windows, utilizzare il comando corrispondente.
```console
```bash
> set DEBUG=express:* & node index.js
```
L'esecuzione di questo comando sull'applicazione predefinita generata da [Programma di creazione express](/{{ page.lang }}/starter/generator.html) consentirà di stampare il seguente output:
```console
```bash
$ DEBUG=express:* node ./bin/www
express:router:route new / +0ms
express:router:layer new / +1ms
@@ -70,7 +70,7 @@ $ DEBUG=express:* node ./bin/www
Quando successivamente viene effettuata una richiesta all'applicazione, verranno visualizzati i log specificati nel codice Express:
```console
```bash
express:router dispatching GET / +4h
express:router query : / +2ms
express:router expressInit : / +0ms
@@ -96,12 +96,12 @@ Un'applicazione generata dal comando `express` utilizza inoltre il modulo `debug
Ad esempio, se l'applicazione è stata generata con `$ express sample-app`, è possibile abilitare le istruzioni di debug con il seguente comando:
```console
```bash
$ DEBUG=sample-app:* node ./bin/www
```
È possibile specificare più di uno spazio dei nomi di debug assegnando un elenco di nomi separati da virgola:
```console
```bash
$ DEBUG=http,mail,express:* node index.js
```

118
it/guide/error-handling.md
View File

@@ -13,29 +13,25 @@ Definire le funzioni middleware di gestione degli errori nello stesso modo in cu
ad eccezione delle funzioni di gestione degli errori che hanno quattro argomenti invece di tre:
`(err, req, res, next)`. Ad esempio:
<pre>
<code class="language-javascript" translate="no">
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Something broke!');
});
</code>
</pre>
```js
app.use((err, req, res, next) => {
console.error(err.stack)
res.status(500).send('Something broke!')
})
```
Si definisce il middleware di gestione degli errori per ultimo, successivamente `app.use()` e altre chiamate route; ad esempio:
<pre>
<code class="language-javascript" translate="no">
var bodyParser = require('body-parser');
var methodOverride = require('method-override');
```js
const bodyParser = require('body-parser')
const methodOverride = require('method-override')
app.use(bodyParser());
app.use(methodOverride());
app.use(function(err, req, res, next) {
app.use(bodyParser())
app.use(methodOverride())
app.use((err, req, res, next) => {
// logic
});
</code>
</pre>
})
```
Le risposte dall'interno delle funzione middleware possono essere in qualsiasi formato desiderato, ad esempio una pagina di errore HTML, un messaggio semplice o una stringa JSON.
@@ -44,78 +40,66 @@ diverse funzioni middleware di gestione degli errori, come solitamente si fa con
le funzioni middleware normali. Ad esempio, se si desidera definire un programma di gestione errori per le richieste
effettuate utilizzando `XHR` e quelle senza, è necessario utilizzare i seguenti comandi:
<pre>
<code class="language-javascript" translate="no">
var bodyParser = require('body-parser');
var methodOverride = require('method-override');
```js
const bodyParser = require('body-parser')
const methodOverride = require('method-override')
app.use(bodyParser());
app.use(methodOverride());
app.use(logErrors);
app.use(clientErrorHandler);
app.use(errorHandler);
</code>
</pre>
app.use(bodyParser())
app.use(methodOverride())
app.use(logErrors)
app.use(clientErrorHandler)
app.use(errorHandler)
```
In questo esempio, il `logErrors` generico potrebbe scrivere le richieste e le informazioni sull'errore
su `stderr`, ad esempio:
<pre>
<code class="language-javascript" translate="no">
```js
function logErrors (err, req, res, next) {
console.error(err.stack);
next(err);
console.error(err.stack)
next(err)
}
</code>
</pre>
```
Inoltre, in questo esempio, `clientErrorHandler` viene definito come segue; in questo caso, l'errore viene chiaramente tramandato al successivo:
<pre>
<code class="language-javascript" translate="no">
```js
function clientErrorHandler (err, req, res, next) {
if (req.xhr) {
res.status(500).send({ error: 'Something failed!' });
res.status(500).send({ error: 'Something failed!' })
} else {
next(err);
next(err)
}
}
</code>
</pre>
```
La funzione "catch-all" `errorHandler` potrebbe essere implementata come segue:
<pre>
<code class="language-javascript" translate="no">
```js
function errorHandler (err, req, res, next) {
res.status(500);
res.render('error', { error: err });
res.status(500)
res.render('error', { error: err })
}
</code>
</pre>
```
Se si trasmette qualsiasi cosa alla funzione `next()` (ad eccezione della stringa `'route'`), Express considera la richiesta corrente come se contenesse errori e ignorerà qualsiasi altra funzione middleware e routing di non gestione degli errori restante. Se si desidera gestire quell'errore in qualche modo, sarà necessario creare una route di gestione degli errori come descritto nella sezione successiva.
Se si dispone di un gestore route con più funzioni di callback, è possibile utilizzare il parametro `route` per passare al successivo gestore route. Ad esempio:
<pre>
<code class="language-javascript" translate="no">
```js
app.get('/a_route_behind_paywall',
function checkIfPaidSubscriber(req, res, next) {
(req, res, next) => {
if (!req.user.hasPaid) {
// continue handling this request
next('route');
next('route')
}
}, function getPaidContent(req, res, next) {
PaidContent.find(function(err, doc) {
if(err) return next(err);
res.json(doc);
});
});
</code>
</pre>
}, (req, res, next) => {
PaidContent.find((err, doc) => {
if (err) return next(err)
res.json(doc)
})
})
```
In questo esempio, il gestore `getPaidContent` verrà ignorato ma qualsiasi altro gestore rimanente in `app` per `/a_route_behind_paywall` verrà eseguito senza interruzione.
<div class="doc-box doc-info" markdown="1">
@@ -143,14 +127,12 @@ Pertanto, quando si aggiunge un gestore degli errori personalizzato, si consigli
di gestione degli errori predefinito in Express, quando le intestazioni
sono state già inviate al client:
<pre>
<code class="language-javascript" translate="no">
```js
function errorHandler (err, req, res, next) {
if (res.headersSent) {
return next(err);
return next(err)
}
res.status(500);
res.render('error', { error: err });
res.status(500)
res.render('error', { error: err })
}
</code>
</pre>
```

246
it/guide/migrating-4.md
View File

@@ -101,14 +101,12 @@ GitHub.
Nella versione 4 è possibile utilizzare un parametro di variabile per definire il percorso in cui vengono caricate le funzioni middleware, quindi leggere il valore del parametro dal programma di gestione route.
Ad esempio:
<pre>
<code class="language-javascript" translate="no">
```js
app.use('/book/:id', function (req, res, next) {
console.log('ID:', req.params.id);
next();
});
</code>
</pre>
console.log('ID:', req.params.id)
next()
})
```
<h3 id="routing">
Il sistema di routing
</h3>
@@ -132,20 +130,18 @@ sulle route, consultare la documentazione [`Router()`](/{{ page.lang }}/4x/api.h
Segue un esempio di handler di route a catena definiti utilizzando la funzione `app.route()`.
<pre>
<code class="language-javascript" translate="no">
```js
app.route('/book')
.get(function (req, res) {
res.send('Get a random book');
res.send('Get a random book')
})
.post(function (req, res) {
res.send('Add a book');
res.send('Add a book')
})
.put(function (req, res) {
res.send('Update the book');
});
</code>
</pre>
res.send('Update the book')
})
```
<h4 id="express-router">Classe <code>express.Router</code></h4>
@@ -159,38 +155,36 @@ si definiscono alcune route e si caricano su un percorso nell'applicazione princ
Ad esempio, creare un file router denominato `birds.js` nella directory dell'applicazione,
con i seguenti contenuti:
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var router = express.Router();
```js
var express = require('express')
var router = express.Router()
// middleware specific to this router
router.use(function timeLog (req, res, next) {
console.log('Time: ', Date.now());
next();
});
console.log('Time: ', Date.now())
next()
})
// define the home page route
router.get('/', function (req, res) {
res.send('Birds home page');
});
res.send('Birds home page')
})
// define the about route
router.get('/about', function (req, res) {
res.send('About birds');
});
res.send('About birds')
})
module.exports = router;
</code>
</pre>
module.exports = router
```
Successivamente, caricare il modulo router nell'applicazione:
<pre>
<code class="language-javascript" translate="no">
var birds = require('./birds');
...
app.use('/birds', birds);
</code>
</pre>
```js
var birds = require('./birds')
/// ...
app.use('/birds', birds)
```
L'applicazione sarà ora in grado di gestire le richieste per i percorsi `/birds` e
`/birds/about` e chiamerà il middleware `timeLog`
@@ -328,49 +322,46 @@ Applicazione con la versione 3
Prendere in considerazione l'applicazione Express v.3 con il seguente file `app.js`:
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var routes = require('./routes');
var user = require('./routes/user');
var http = require('http');
var path = require('path');
```js
var express = require('express')
var routes = require('./routes')
var user = require('./routes/user')
var http = require('http')
var path = require('path')
var app = express();
var app = express()
// all environments
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'pug');
app.use(express.favicon());
app.use(express.logger('dev'));
app.use(express.methodOverride());
app.use(express.session({ secret: 'your secret here' }));
app.use(express.bodyParser());
app.use(app.router);
app.use(express.static(path.join(__dirname, 'public')));
app.set('port', process.env.PORT || 3000)
app.set('views', path.join(__dirname, 'views'))
app.set('view engine', 'pug')
app.use(express.favicon())
app.use(express.logger('dev'))
app.use(express.methodOverride())
app.use(express.session({ secret: 'your secret here' }))
app.use(express.bodyParser())
app.use(app.router)
app.use(express.static(path.join(__dirname, 'public')))
// development only
if ('development' == app.get('env')) {
app.use(express.errorHandler());
if (app.get('env') === 'development') {
app.use(express.errorHandler())
}
app.get('/', routes.index);
app.get('/users', user.list);
app.get('/', routes.index)
app.get('/users', user.list)
http.createServer(app).listen(app.get('port'), function () {
console.log('Express server listening on port ' + app.get('port'));
});
</code>
</pre>
console.log('Express server listening on port ' + app.get('port'))
})
```
<h4 id=""><code>package.json</code></h4>
Il file `package.json` della versione 3 associata deve
apparire come segue:
<pre>
<code class="language-javascript" translate="no">
```json
{
"name": "application-name",
"version": "0.0.1",
@@ -383,8 +374,7 @@ apparire come segue:
"pug": "*"
}
}
</code>
</pre>
```
<h3 id="">
Processo
@@ -394,7 +384,7 @@ Iniziare il processo di migrazione installando il middleware richiesto per l'app
Express 4 e aggiornando Express e Pug alla versione aggiornata
con il seguente comando:
```console
```bash
$ npm install serve-favicon morgan method-override express-session body-parser multer errorhandler express@latest pug@latest --save
```
@@ -419,8 +409,7 @@ Apportare le seguenti modifiche a `app.js`:
L'esecuzione del comando `npm` aggiornerà `package.json` come segue:
<pre>
<code class="language-javascript" translate="no">
```json
{
"name": "application-name",
"version": "0.0.1",
@@ -440,69 +429,70 @@ L'esecuzione del comando `npm` aggiornerà `package.json` come segue:
"serve-favicon": "^2.0.1"
}
}
</code>
</pre>
```
<h4 id=""><code>app.js</code></h4>
Successivamente, rimuovere il codice non valido, caricare il middleware richiesto e apportare le modifiche
necessarie. Il file `app.js` apparirà come segue:
<pre>
<code class="language-javascript" translate="no">
var http = require('http');
var express = require('express');
var routes = require('./routes');
var user = require('./routes/user');
var path = require('path');
```js
var http = require('http')
var express = require('express')
var routes = require('./routes')
var user = require('./routes/user')
var path = require('path')
var favicon = require('serve-favicon');
var logger = require('morgan');
var methodOverride = require('method-override');
var session = require('express-session');
var bodyParser = require('body-parser');
var multer = require('multer');
var errorHandler = require('errorhandler');
var favicon = require('serve-favicon')
var logger = require('morgan')
var methodOverride = require('method-override')
var session = require('express-session')
var bodyParser = require('body-parser')
var multer = require('multer')
var errorHandler = require('errorhandler')
var app = express();
var app = express()
// all environments
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'pug');
app.use(favicon(__dirname + '/public/favicon.ico'));
app.use(logger('dev'));
app.use(methodOverride());
app.use(session({ resave: true,
app.set('port', process.env.PORT || 3000)
app.set('views', path.join(__dirname, 'views'))
app.set('view engine', 'pug')
app.use(favicon(path.join(__dirname, '/public/favicon.ico')))
app.use(logger('dev'))
app.use(methodOverride())
app.use(session({
resave: true,
saveUninitialized: true,
secret: 'uwotm8' }));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(multer());
app.use(express.static(path.join(__dirname, 'public')));
secret: 'uwotm8'
}))
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({ extended: true }))
app.use(multer())
app.use(express.static(path.join(__dirname, 'public')))
app.get('/', routes.index);
app.get('/users', user.list);
app.get('/', routes.index)
app.get('/users', user.list)
// error handling middleware should be loaded after the loading the routes
if ('development' == app.get('env')) {
app.use(errorHandler());
if (app.get('env') === 'development') {
app.use(errorHandler())
}
var server = http.createServer(app);
server.listen(app.get('port'), function(){
console.log('Express server listening on port ' + app.get('port'));
});
</code>
</pre>
var server = http.createServer(app)
server.listen(app.get('port'), () => {
console.log('Express server listening on port ' + app.get('port'))
})
```
<div class="doc-box doc-info" markdown="1">
A meno che non sia necessario gestire direttamente il modulo `http` (socket.io/SPDY/HTTPS), il relativo caricamento non è richiesto e l'applicazione può essere avviata semplicemente come segue:
<pre>
<code class="language-js" translate="no">app.listen(app.get('port'), function(){
console.log('Express server listening on port ' + app.get('port'));
});</code>
</pre>
```js
app.listen(app.get('port'), function () {
console.log('Express server listening on port ' + app.get('port'))
})
```
</div>
<h3 id="">Eseguire l'applicazione</h3>
@@ -510,7 +500,7 @@ A meno che non sia necessario gestire direttamente il modulo `http` (socket.io/S
Il processo di migrazione è stato completato e ora l'applicazione
è stata aggiornata a Express 4. Per confermare, avviare l'applicazione utilizzando il seguente comando:
```console
```bash
$ node .
```
@@ -529,7 +519,7 @@ Lo strumento della riga comandi per generare un'applicazione Express è sempre
Se il programma di creazione dell'applicazione di Express 3 è già installato sul sistema,
è necessario disinstallarlo:
```console
```bash
$ npm uninstall -g express
```
@@ -538,7 +528,7 @@ potrebbe essere necessario eseguire questo comando con `sudo`.
Ora, installare il nuovo programma di creazione:
```console
```bash
$ npm install -g express-generator
```
@@ -561,7 +551,7 @@ L'utilizzo e le opzioni del comando sono rimaste quasi gli stessi, con le seguen
Eseguire il seguente comando per creare un'applicazione Express 4:
```console
```bash
$ express app4
```
@@ -574,7 +564,7 @@ Si noterà inoltre che il file `app.js` è ora un modulo Node.js, diversamente d
Dopo aver installato le dipendenze, avviare l'applicazione utilizzando il seguente comando:
```console
```bash
$ npm start
```
@@ -598,23 +588,19 @@ Per rimuovere la directory `www` e conservare le cose "come farebbe Express 3",
cancellare la riga in cui viene riportata la dicitura `module.exports = app;` alla fine del file
`app.js`, quindi incollare il seguente codice al proprio posto:
<pre>
<code class="language-javascript" translate="no">
app.set('port', process.env.PORT || 3000);
```js
app.set('port', process.env.PORT || 3000)
var server = app.listen(app.get('port'), function () {
debug('Express server listening on port ' + server.address().port);
});
</code>
</pre>
debug('Express server listening on port ' + server.address().port)
})
```
Assicurarsi di caricare il modulo `debug` all'inizio del file `app.js` utilizzando il seguente codice:
<pre>
<code class="language-javascript" translate="no">
var debug = require('debug')('app4');
</code>
</pre>
```js
var debug = require('debug')('app4')
```
Successivamente, modificare `"start": "node ./bin/www"` nel file `package.json` in `"start": "node app.js"`.

2
it/guide/migrating-5.md
View File

@@ -17,7 +17,7 @@ Express 5 non è molto differente da Express 4: le modifiche all'API non sono co
Per installare l'ultima alfa e per vedere in anteprima Express 5, immettere il seguente comando nella directory root dell'applicazione:
```console
```bash
$ npm install "express@^{{ site.data.express.next_version }}" --save
```

307
it/guide/routing.md
View File

@@ -14,17 +14,15 @@ Per un'introduzione al concetto di routing, consultare la sezione [Routing di ba
Il codice seguente è un esempio di una route veramente di base.
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
```js
const express = require('express')
const app = express()
// respond with "hello world" when a GET request is made to the homepage
app.get('/', function(req, res) {
res.send('hello world');
});
</code>
</pre>
app.get('/', (req, res) => {
res.send('hello world')
})
```
<h2 id="route-methods">Metodi di route</h2>
@@ -32,19 +30,17 @@ Un metodo di route deriva da uno dei metodi HTTP ed è collegato ad un'istanza d
Il codice seguente è un esempio di route definite per i metodi GET e POST nella root dell'app.
<pre>
<code class="language-javascript" translate="no">
```js
// GET method route
app.get('/', function (req, res) {
res.send('GET request to the homepage');
});
app.get('/', (req, res) => {
res.send('GET request to the homepage')
})
// POST method route
app.post('/', function (req, res) {
res.send('POST request to the homepage');
});
</code>
</pre>
app.post('/', (req, res) => {
res.send('POST request to the homepage')
})
```
Express supporta i seguenti metodi di routing che corrispondono a metodi HTTP: `get`, `post`, `put`, `head`, `delete`, `options`, `trace`, `copy`, `lock`, `mkcol`, `move`, `purge`, `propfind`, `proppatch`, `unlock`, `report`, `mkactivity`, `checkout`, `merge`, `m-search`, `notify`, `subscribe`, `unsubscribe`, `patch`, `search` e `connect`.
@@ -57,14 +53,12 @@ Esiste un metodo di routing speciale, `app.all()`, che non deriva da alcun metod
Nell'esempio seguente, l'handler verrà eseguito per richieste a "/secret" se si stanno utilizzando GET, POST, PUT, DELETE, o qualsiasi altro metodo di richiesta HTTP supportato nel [modulo http](https://nodejs.org/api/http.html#http_http_methods).
<pre>
<code class="language-javascript" translate="no">
app.all('/secret', function (req, res, next) {
console.log('Accessing the secret section ...');
next(); // pass control to the next handler
});
</code>
</pre>
```js
app.all('/secret', (req, res, next) => {
console.log('Accessing the secret section ...')
next() // pass control to the next handler
})
```
<h2 id="route-paths">Percorsi di route</h2>
@@ -82,75 +76,61 @@ Ecco alcuni esempi di percorsi di route basati su stringhe.
Questo percorso di route corrisponderà a richieste nella route root, `/`.
<pre>
<code class="language-javascript" translate="no">
app.get('/', function (req, res) {
res.send('root');
});
</code>
</pre>
```js
app.get('/', (req, res) => {
res.send('root')
})
```
Questo percorso di route corrisponderà a richieste in `/about`.
<pre>
<code class="language-javascript" translate="no">
app.get('/about', function (req, res) {
res.send('about');
});
</code>
</pre>
```js
app.get('/about', (req, res) => {
res.send('about')
})
```
Questo percorso di route corrisponderà a richieste in `/random.text`.
<pre>
<code class="language-javascript" translate="no">
app.get('/random.text', function (req, res) {
res.send('random.text');
});
</code>
</pre>
```js
app.get('/random.text', (req, res) => {
res.send('random.text')
})
```
Ecco alcuni esempi di percorsi di route basati su modelli di stringa.
Questo percorso di route corrisponderà a `acd` e `abcd`.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab?cd', function(req, res) {
res.send('ab?cd');
});
</code>
</pre>
```js
app.get('/ab?cd', (req, res) => {
res.send('ab?cd')
})
```
Questo percorso di route corrisponderà a `abcd`, `abbcd`, `abbbcd` e così via.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab+cd', function(req, res) {
res.send('ab+cd');
});
</code>
</pre>
```js
app.get('/ab+cd', (req, res) => {
res.send('ab+cd')
})
```
Questo percorso di route corrisponderà a `abcd`, `abxcd`, `abRABDOMcd`, `ab123cd` e così via.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab*cd', function(req, res) {
res.send('ab*cd');
});
</code>
</pre>
```js
app.get('/ab*cd', (req, res) => {
res.send('ab*cd')
})
```
Questo percorso di route corrisponderà a `/abe` e `/abcde`.
<pre>
<code class="language-javascript" translate="no">
app.get('/ab(cd)?e', function(req, res) {
res.send('ab(cd)?e');
});
</code>
</pre>
```js
app.get('/ab(cd)?e', (req, res) => {
res.send('ab(cd)?e')
})
```
<div class="doc-box doc-info" markdown="1">
I caratteri ?, +, * e () sono sottoinsiemi delle rispettive controparti di espressioni regolari. Trattino (-) e punto (.) vengono interpretati letteralmente da percorsi basati su stringhe.
@@ -160,23 +140,19 @@ Esempi di percorsi di route basati su espressioni regolari:
Questo percorso di route corrisponderà a qualsiasi elemento con "a" nel nome route.
<pre>
<code class="language-javascript" translate="no">
app.get(/a/, function(req, res) {
res.send('/a/');
});
</code>
</pre>
```js
app.get(/a/, (req, res) => {
res.send('/a/')
})
```
Questo percorso di route corrisponderà a `butterfly` e `dragonfly`, ma non a `butterflyman`, `dragonfly man` e così via.
<pre>
<code class="language-javascript" translate="no">
app.get(/.*fly$/, function(req, res) {
res.send('/.*fly$/');
});
</code>
</pre>
```js
app.get(/.*fly$/, (req, res) => {
res.send('/.*fly$/')
})
```
<h2 id="route-handlers">Handler di route</h2>
@@ -186,71 +162,62 @@ Gli handler di route possono avere il formato di una funzione, di un array di fu
Una singola funzione di callback può gestire una route. Ad esempio:
<pre>
<code class="language-javascript" translate="no">
app.get('/example/a', function (req, res) {
res.send('Hello from A!');
});
</code>
</pre>
```js
app.get('/example/a', (req, res) => {
res.send('Hello from A!')
})
```
Più funzioni di callback possono gestire una route (assicurarsi di specificare l'oggetto `next`). Ad esempio:
<pre>
<code class="language-javascript" translate="no">
app.get('/example/b', function (req, res, next) {
console.log('the response will be sent by the next function ...');
next();
}, function (req, res) {
res.send('Hello from B!');
});
</code>
</pre>
```js
app.get('/example/b', (req, res, next) => {
console.log('the response will be sent by the next function ...')
next()
}, (req, res) => {
res.send('Hello from B!')
})
```
Un array di funzioni callback possono gestire una route. Ad esempio:
<pre>
<code class="language-javascript" translate="no">
var cb0 = function (req, res, next) {
console.log('CB0');
next();
```js
const cb0 = function (req, res, next) {
console.log('CB0')
next()
}
var cb1 = function (req, res, next) {
console.log('CB1');
next();
const cb1 = function (req, res, next) {
console.log('CB1')
next()
}
var cb2 = function (req, res) {
res.send('Hello from C!');
const cb2 = function (req, res) {
res.send('Hello from C!')
}
app.get('/example/c', [cb0, cb1, cb2]);
</code>
</pre>
app.get('/example/c', [cb0, cb1, cb2])
```
Una combinazione di funzioni indipendenti e array di funzioni può gestire una route. Ad esempio:
<pre>
<code class="language-javascript" translate="no">
var cb0 = function (req, res, next) {
console.log('CB0');
next();
```js
const cb0 = function (req, res, next) {
console.log('CB0')
next()
}
var cb1 = function (req, res, next) {
console.log('CB1');
next();
const cb1 = function (req, res, next) {
console.log('CB1')
next()
}
app.get('/example/d', [cb0, cb1], function (req, res, next) {
console.log('the response will be sent by the next function ...');
next();
}, function (req, res) {
res.send('Hello from D!');
});
</code>
</pre>
app.get('/example/d', [cb0, cb1], (req, res, next) => {
console.log('the response will be sent by the next function ...')
next()
}, (req, res) => {
res.send('Hello from D!')
})
```
<h2 id="response-methods">Metodi di risposta</h2>
@@ -275,20 +242,18 @@ Poiché il percorso è specificato in una singola ubicazione, la creazione di ro
Ecco un esempio di handler di route concatenati, definiti utilizzando `app.route()`.
<pre>
<code class="language-javascript" translate="no">
```js
app.route('/book')
.get(function(req, res) {
res.send('Get a random book');
.get((req, res) => {
res.send('Get a random book')
})
.post(function(req, res) {
res.send('Add a book');
.post((req, res) => {
res.send('Add a book')
})
.put(function(req, res) {
res.send('Update the book');
});
</code>
</pre>
.put((req, res) => {
res.send('Update the book')
})
```
<h2 id="express-router">express.Router</h2>
@@ -298,37 +263,35 @@ Nel seguente esempio si crea un router come modulo, si carica al suo interno una
Creare un file router denominato `birds.js` nella directory app, con il seguente contenuto:
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var router = express.Router();
```js
const express = require('express')
const router = express.Router()
// middleware that is specific to this router
router.use(function timeLog(req, res, next) {
console.log('Time: ', Date.now());
next();
});
router.use((req, res, next) => {
console.log('Time: ', Date.now())
next()
})
// define the home page route
router.get('/', function(req, res) {
res.send('Birds home page');
});
router.get('/', (req, res) => {
res.send('Birds home page')
})
// define the about route
router.get('/about', function(req, res) {
res.send('About birds');
});
router.get('/about', (req, res) => {
res.send('About birds')
})
module.exports = router;
</code>
</pre>
module.exports = router
```
Quindi, caricare il modulo router nell'app:
<pre>
<code class="language-javascript" translate="no">
var birds = require('./birds');
...
app.use('/birds', birds);
</code>
</pre>
```js
const birds = require('./birds')
/// ...
app.use('/birds', birds)
```
L'app ora sarà in grado di gestire richieste a `/birds` e `/birds/about`, oltre a richiamare la funzione middleware `timeLog`, specifica per la route.

227
it/guide/using-middleware.md
View File

@@ -39,153 +39,136 @@ Associare il middleware al livello dell'applicazione ad un'istanza dell'[oggetto
Questo esempio presenta una funzione middleware senza percorso di montaggio. La funzione viene eseguita ogni volta che l'app riceve una richiesta.
<pre>
<code class="language-javascript" translate="no">
var app = express();
```js
const app = express()
app.use(function (req, res, next) {
console.log('Time:', Date.now());
next();
});
</code>
</pre>
app.use((req, res, next) => {
console.log('Time:', Date.now())
next()
})
```
Questo esempio presenta una funzione middleware montata nel percorso `/user/:id`. La funzione viene eseguita per qualsiasi tipo di
richiesta HTTP nel percorso `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.use('/user/:id', function (req, res, next) {
console.log('Request Type:', req.method);
next();
});
</code>
</pre>
```js
app.use('/user/:id', (req, res, next) => {
console.log('Request Type:', req.method)
next()
})
```
Questo esempio presenta una route e la relativa funzione handler (sistema middleware). La funzione gestisce richieste GET nel percorso `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.get('/user/:id', function (req, res, next) {
res.send('USER');
});
</code>
</pre>
```js
app.get('/user/:id', (req, res, next) => {
res.send('USER')
})
```
Ecco un esempio di caricamento di una serie di funzioni middleware in un punto di montaggio, con un percorso di montaggio.
Illustra un sotto-stack middleware che stampa informazioni sulla richiesta per qualsiasi tipo di richiesta HTTP nel percorso `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.use('/user/:id', function(req, res, next) {
console.log('Request URL:', req.originalUrl);
next();
}, function (req, res, next) {
console.log('Request Type:', req.method);
next();
});
</code>
</pre>
```js
app.use('/user/:id', (req, res, next) => {
console.log('Request URL:', req.originalUrl)
next()
}, (req, res, next) => {
console.log('Request Type:', req.method)
next()
})
```
Gli handler di route consentono di definire molteplici route per un percorso. Nell'esempio sottostante sono definite due route per richieste GET nel percorso `/user/:id`. La seconda route non provocherà alcun problema, ma non verrà mai chiamata, poiché la prima route termina il ciclo di richiesta-risposta.
Questo esempio presenta un sotto-stack middleware che gestisce richieste GET nel percorso `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.get('/user/:id', function (req, res, next) {
console.log('ID:', req.params.id);
next();
}, function (req, res, next) {
res.send('User Info');
});
```js
app.get('/user/:id', (req, res, next) => {
console.log('ID:', req.params.id)
next()
}, (req, res, next) => {
res.send('User Info')
})
// handler for the /user/:id path, which prints the user ID
app.get('/user/:id', function (req, res, next) {
res.end(req.params.id);
});
</code>
</pre>
app.get('/user/:id', (req, res, next) => {
res.end(req.params.id)
})
```
Per ignorare le restanti funzioni middleware da uno stack di middleware del router, richiamare `next('route')` per passare il controllo alla route successiva.
**NOTA**: `next('route')` funzionerà solo in funzioni middleware che sono state caricate utilizzando le funzioni `app.METHOD()` o `router.METHOD()`.
Questo esempio presenta un sotto-stack middleware che gestisce richieste GET nel percorso `/user/:id`.
<pre>
<code class="language-javascript" translate="no">
app.get('/user/:id', function (req, res, next) {
```js
app.get('/user/:id', (req, res, next) => {
// if the user ID is 0, skip to the next route
if (req.params.id == 0) next('route');
if (req.params.id === '0') next('route')
// otherwise pass the control to the next middleware function in this stack
else next(); //
}, function (req, res, next) {
else next() //
}, (req, res, next) => {
// render a regular page
res.render('regular');
});
res.render('regular')
})
// handler for the /user/:id path, which renders a special page
app.get('/user/:id', function (req, res, next) {
res.render('special');
});
</code>
</pre>
app.get('/user/:id', (req, res, next) => {
res.render('special')
})
```
<h2 id='middleware.router'>Middleware a livello del router</h2>
Il middleware a livello del router funziona nello stesso modo di quello a livello dell'applicazione, fatta eccezione per il fatto di essere associato ad un'istanza di `express.Router()`.
<pre>
<code class="language-javascript" translate="no">
var router = express.Router();
</code>
</pre>
```js
const router = express.Router()
```
Caricare il middleware a livello del router utilizzando le funzioni `router.use()` e `router.METHOD()`.
Il seguente codice di esempio replica il sistema middleware mostrato sopra per il middleware a livello dell'applicazione, utilizzando il middleware a livello del router:
<pre>
<code class="language-javascript" translate="no">
var app = express();
var router = express.Router();
```js
const app = express()
const router = express.Router()
// a middleware function with no mount path. This code is executed for every request to the router
router.use(function (req, res, next) {
console.log('Time:', Date.now());
next();
});
router.use((req, res, next) => {
console.log('Time:', Date.now())
next()
})
// a middleware sub-stack shows request info for any type of HTTP request to the /user/:id path
router.use('/user/:id', function(req, res, next) {
console.log('Request URL:', req.originalUrl);
next();
}, function (req, res, next) {
console.log('Request Type:', req.method);
next();
});
router.use('/user/:id', (req, res, next) => {
console.log('Request URL:', req.originalUrl)
next()
}, (req, res, next) => {
console.log('Request Type:', req.method)
next()
})
// a middleware sub-stack that handles GET requests to the /user/:id path
router.get('/user/:id', function (req, res, next) {
router.get('/user/:id', (req, res, next) => {
// if the user ID is 0, skip to the next router
if (req.params.id == 0) next('route');
if (req.params.id === '0') next('route')
// otherwise pass control to the next middleware function in this stack
else next(); //
}, function (req, res, next) {
else next() //
}, (req, res, next) => {
// render a regular page
res.render('regular');
});
res.render('regular')
})
// handler for the /user/:id path, which renders a special page
router.get('/user/:id', function (req, res, next) {
console.log(req.params.id);
res.render('special');
});
router.get('/user/:id', (req, res, next) => {
console.log(req.params.id)
res.render('special')
})
// mount the router on the app
app.use('/', router);
</code>
</pre>
app.use('/', router)
```
<h2 id='middleware.error-handling'>Middleware di gestione degli errori</h2>
<div class="doc-box doc-notice" markdown="1">
@@ -194,14 +177,12 @@ Il middleware di gestione degli errori impiega sempre *quattro* argomenti. È n
Definire le funzioni middleware di gestione degli errori nello stesso modo delle altre funzioni middleware, ma con quattro argomenti invece di tre, nello specifico con la firma `(err, req, res, next)`):
<pre>
<code class="language-javascript" translate="no">
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Something broke!');
});
</code>
</pre>
```js
app.use((err, req, res, next) => {
console.error(err.stack)
res.status(500).send('Something broke!')
})
```
Per dettagli sul middleware di gestione degli errori, consultare la sezione: [Gestione degli errori](/{{ page.lang }}/guide/error-handling.html).
@@ -231,9 +212,8 @@ L'oggetto facoltativo `options` può avere le seguenti proprietà:
Ecco un esempio di utilizzo della funzione middleware `express.static` con un oggetto opzioni elaborato:
<pre>
<code class="language-javascript" translate="no">
var options = {
```js
const options = {
dotfiles: 'ignore',
etag: false,
extensions: ['htm', 'html'],
@@ -241,23 +221,20 @@ var options = {
maxAge: '1d',
redirect: false,
setHeaders: function (res, path, stat) {
res.set('x-timestamp', Date.now());
res.set('x-timestamp', Date.now())
}
}
app.use(express.static('public', options));
</code>
</pre>
app.use(express.static('public', options))
```
È possibile avere più di una directory statica per app:
<pre>
<code class="language-javascript" translate="no">
app.use(express.static('public'));
app.use(express.static('uploads'));
app.use(express.static('files'));
</code>
</pre>
```js
app.use(express.static('public'))
app.use(express.static('uploads'))
app.use(express.static('files'))
```
Per ulteriori dettagli sulla funzione `serve-static` e sulle relative opzioni, consultare: documentazione [serve-static](https://github.com/expressjs/serve-static).
@@ -269,19 +246,17 @@ Installare il modulo Node.js per la funzionalità richiesta, quindi, caricarlo n
Il seguente esempio illustra l'installazione e il caricamento della funzione middleware di analisi dei cookie `cookie-parser`.
```console
```bash
$ npm install cookie-parser
```
<pre>
<code class="language-javascript" translate="no">
var express = require('express');
var app = express();
var cookieParser = require('cookie-parser');
```js
const express = require('express')
const app = express()
const cookieParser = require('cookie-parser')
// load the cookie-parsing middleware
app.use(cookieParser());
</code>
</pre>
app.use(cookieParser())
```
Per un elenco parziale delle funzioni middleware di terzi comunemente utilizzate con Express, consultare la sezione: [Middleware di terzi](../resources/middleware.html).

Some files were not shown because too many files have changed in this diff Show More