i18n: new crowdin translations

src/content/docs/de/4x/guide/behind-proxies.mdx

@@ -91,8 +91,8 @@ Das Aktivieren von `trust proxy` hat folgende Auswirkungen:
   </li>
   <li markdown="1">
     `X-Forwarded-Proto` kann vom Reverse Proxy gesetzt werden, um der App mitzuteilen, ob es `https`
-    oder `http` oder sogar ein ungültiger Name ist. Dieser Wert wird von [req.protocol]reflektiert
-    (/en/api#req.protocol).
+    oder `http` oder sogar ein ungültiger Name ist. This value is reflected by
+    [req.protocol](/api/request/#reqprotocol).
   </li>
   <li markdown="1">
     Die Werte [req.ip](/api#req.ip) und [req.ips](/api#req.ips) werden auf der Basis der

src/content/docs/de/4x/guide/error-handling.mdx

@@ -207,7 +207,7 @@ app.use((err, req, res, next) => {
 
 Du definierst die Middleware zuletzt nach anderen `app.use()` und Routet Anrufe; zum Beispiel:
 
-```js
+```cjs title="index.cjs"
 const bodyParser = require('body-parser');
 const methodOverride = require('method-override');
 
@@ -223,14 +223,30 @@ app.use((err, req, res, next) => {
 });
 ```
 
+```mjs title="index.mjs"
+import bodyParser from 'body-parser';
+import methodOverride from 'method-override';
+
+app.use(
+  bodyParser.urlencoded({
+    extended: true,
+  })
+);
+app.use(bodyParser.json());
+app.use(methodOverride());
+app.use((err, req, res, next) => {
+  // logic
+});
+```
+
 Antworten innerhalb einer Middleware-Funktion können in jedem Format sein, wie z.B. in einer HTML-Fehlerseite, einer einfachen Nachricht oder einem JSON-String.
 
 Für organisatorische (und höherstufige Framework) Zwecke können Sie
 verschiedene Middleware-Funktionen definieren, so wie Sie es mit den regulären Middleware-Funktionen
 würden. Zum Beispiel, um einen Fehlerhandler
 für Anfragen mit `XHR` und denen ohne folgende zu definieren:
 
-```js
+```cjs title="index.cjs"
 const bodyParser = require('body-parser');
 const methodOverride = require('method-override');
 
@@ -246,6 +262,22 @@ app.use(clientErrorHandler);
 app.use(errorHandler);
 ```
 
+```mjs title="index.mjs"
+import bodyParser from 'body-parser';
+import methodOverride from 'method-override';
+
+app.use(
+  bodyParser.urlencoded({
+    extended: true,
+  })
+);
+app.use(bodyParser.json());
+app.use(methodOverride());
+app.use(logErrors);
+app.use(clientErrorHandler);
+app.use(errorHandler);
+```
+
 In diesem Beispiel könnten die generischen `logErrors` Anfrage und
 Fehlerinformationen in `stderr` schreiben, zum Beispiel:
 

src/content/docs/de/4x/guide/overriding-express-api.md

@@ -14,7 +14,7 @@ Das Ändern der globalen Prototypen wirkt sich auf alle geladenen Express-Apps i
 
 Sie können die Signatur und das Verhalten bestehender Methoden mit eigenen überschreiben, indem Sie eine benutzerdefinierte Funktion zuweisen.
 
-Folgendes ist ein Beispiel für das Überschreiben des Verhaltens von [res.sendStatus](/api#res.sendStatus).
+Following is an example of overriding the behavior of [res.sendStatus](/api/response/#ressendstatus).
 
 ```js
 app.response.sendStatus = function (statusCode, type, message) {

src/content/docs/de/4x/guide/routing.mdx

@@ -9,19 +9,19 @@ _Routing_ bezieht sich darauf, wie die Endpunkte einer Anwendung (URIs) auf Kund
 Für eine Einführung in das Routing siehe [Basic routing](/starter/basic-routing).
 
 Du definierst Routing, indem du Methoden des Express `app` Objekts verwendest, die den HTTP-Methoden entsprechen;
-zum Beispiel, `app. et()` um GET-Anfragen und `app.post` zu behandeln, um POST-Anfragen zu bearbeiten. Für eine vollständige Liste
-siehe [app.METHOD](/api/application#appmethodpath-callback--callback-). Du kannst auch [app.all()](/api/application#appallpath-callback--callback-) verwenden, um alle HTTP-Methoden und [app. se()](/api/application#appusepath-callback--callback) bis
-Middleware als Callback-Funktion angeben (siehe [Middleware](/guide/using-middleware) für Details).
+zum Beispiel, `app. et()` um GET-Anfragen und `app.post` zu behandeln, um POST-Anfragen zu bearbeiten. For a full list,
+see [app.METHOD](/api/application#appmethod). You can also use [app.all()](/api/application#appall) to handle all HTTP methods and [app.use()](/api/application#appuse) to
+specify middleware as the callback function (See [Using middleware](/guide/using-middleware) for details).
 
-Diese Routing-Methoden geben eine Callback-Funktion (manchmal auch "handler functions") an, die aufgerufen wird, wenn die Anwendung eine Anfrage an die angegebene Route (Endpunkt) und die HTTP-Methode erhält. Mit anderen Worten, die Anwendung "lauscht" für Anforderungen, die mit der angegebenen Route(s) und Methode(n) übereinstimmen und wenn es ein Spiel erkennt, ruft es die angegebene Callback-Funktion auf.
+These routing methods specify a callback function (sometimes called a "handler function") that Express automatically runs when the application receives a request matching the specified route (endpoint) and HTTP method. Mit anderen Worten, die Anwendung "lauscht" für Anforderungen, die mit der angegebenen Route(s) und Methode(n) übereinstimmen und wenn es ein Spiel erkennt, ruft es die angegebene Callback-Funktion auf.
 
 In der Tat können die Routing-Methoden mehr als eine Callback-Funktion als Argumente haben.
 Mit mehreren Callback-Funktionen, es ist wichtig, `next` als Argument für die Callback-Funktion zur Verfügung zu stellen und dann `next()` im Körper der Funktion aufzurufen, um die Steuerung
 an den nächsten Callback zu übergeben.
 
 Der folgende Code ist ein Beispiel für eine sehr einfache Route.
 
-```js
+```cjs title="index.cjs"
 const express = require('express');
 const app = express();
 
@@ -31,6 +31,17 @@ app.get('/', (req, res) => {
 });
 ```
 
+```mjs title="index.mjs"
+import express from 'express';
+
+const app = express();
+
+// respond with "hello world" when a GET request is made to the homepage
+app.get('/', (req, res) => {
+  res.send('hello world');
+});
+```
+
 ## Routenmethoden
 
 Eine Route-Methode wird von einer der HTTP-Methoden abgeleitet und an eine Instanz der Klasse \`express angehängt.
@@ -50,7 +61,7 @@ app.post('/', (req, res) => {
 ```
 
 Express unterstützt Methoden, die allen HTTP-Anfragemethoden entsprechen: `get`, `post` und so weiter.
-Für eine vollständige Liste siehe [app.METHOD](/api/application#appmethodpath-callback--callback-).
+For a full list, see [app.METHOD](/api/application#appmethod).
 
 Es gibt eine spezielle Routing-Methode, `app.all()`, die benutzt wird, um Middleware-Funktionen an einem Pfad für _all_ HTTP-Requestmethoden zu laden. Zum Beispiel wird der folgende Handler für Anfragen an die Route `"/secret"` ausgeführt, ob `GET` verwendet wird, `POST`, `PUT`, `DELETE`, oder jede andere HTTP-Anfragemethode, die im [http module]unterstützt wird (https://nodejs.org/api/http.html#http_http_methods).
 
@@ -212,7 +223,7 @@ Zeichen mit einem zusätzlichen Backslash maskieren, zum Beispiel `\d+`.
 </Alert>
 
 <Alert type="warnung">
-Das Zeichen <a href="https://github.com/expressjs/express/issues/2495">`*` in regulären Ausdrücken wird nicht auf die übliche Weise</a> interpretiert. Benutze `{0,}` anstelle von `*`.
+The [`*`](https://github.com/expressjs/express/issues/2495) character in regular expressions is not interpreted in the usual way. Benutze `{0,}` anstelle von `*`.
 </Alert>
 
 ## Routenhandler
@@ -312,17 +323,17 @@ app.get(
 
 Die Methoden auf dem Antwortobjekt (`res`) in der folgenden Tabelle können eine Antwort an den Client senden und den Request-Antwort-Zyklus beenden. Wenn keine dieser Methoden von einem Routenhandler aufgerufen wird, bleibt die Client-Anfrage hängen.
 
-| Methode                                                                | Beschreibung                                                                                              |
-| ---------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
-| [res.download()](/api/response#resdownloadpath--filename--options--fn) | Fordern Sie eine Datei zum Download an.                                                                   |
-| [res.end()](/api/response#resenddata-encoding-callback)                | Beenden Sie den Antwort-Prozess.                                                                          |
-| [res.json()](/api/response#resjsonbody)                                | Sende eine JSON-Antwort.                                                                                  |
-| [res.jsonp()](/api/response#resjsonpbody)                              | Senden Sie eine JSON-Antwort mit JSONP-Unterstützung.                                                     |
-| [res.redirect()](/api/response#resredirectstatus-path)                 | Anfrage umleiten.                                                                                         |
-| [res.render()](/api/response#resrenderview--locals--callback)          | Ansichtsvorlage ausblenden.                                                                               |
-| [res.send()](/api/response#ressendbody)                                | Senden Sie eine Antwort von verschiedenen Typen.                                                          |
-| [res.sendFile()](/api/response#ressendfilepath--options--fn)           | Senden Sie eine Datei als octet-Stream.                                                                   |
-| [res.sendStatus()](/api/response#ressendstatusstatuscode)              | Legen Sie den Antwort-Statuscode fest und senden Sie seine Zeichenfolge Repräsentation als Antwortkörper. |
+| Methode                                         | Beschreibung                                                                                              |
+| ----------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| [res.download()](/api/response#resdownload)     | Fordern Sie eine Datei zum Download an.                                                                   |
+| [res.end()](/api/response#resend)               | Beenden Sie den Antwort-Prozess.                                                                          |
+| [res.json()](/api/response#resjson)             | Sende eine JSON-Antwort.                                                                                  |
+| [res.jsonp()](/api/response#resjsonp)           | Senden Sie eine JSON-Antwort mit JSONP-Unterstützung.                                                     |
+| [res.redirect()](/api/response#resredirect)     | Anfrage umleiten.                                                                                         |
+| [res.render()](/api/response#resrender)         | Render a view template.                                                                                   |
+| [res.send()](/api/response#ressend)             | Senden Sie eine Antwort von verschiedenen Typen.                                                          |
+| [res.sendFile()](/api/response#ressendfile)     | Senden Sie eine Datei als octet-Stream.                                                                   |
+| [res.sendStatus()](/api/response#ressendstatus) | Legen Sie den Antwort-Statuscode fest und senden Sie seine Zeichenfolge Repräsentation als Antwortkörper. |
 
 ## app.route()
 
@@ -353,7 +364,7 @@ Das folgende Beispiel erzeugt einen Router als Modul, lädt eine Middleware-Funk
 
 Erstelle eine Router-Datei namens `birds.js` im App-Verzeichnis, mit folgendem Inhalt:
 
-```js
+```cjs title="birds.cjs"
 const express = require('express');
 const router = express.Router();
 
@@ -376,19 +387,51 @@ router.get('/about', (req, res) => {
 module.exports = router;
 ```
 
+```mjs title="birds.mjs"
+import express from 'express';
+
+const router = express.Router();
+
+// middleware that is specific to this router
+const timeLog = (req, res, next) => {
+  console.log('Time: ', Date.now());
+  next();
+};
+router.use(timeLog);
+
+// define the home page route
+router.get('/', (req, res) => {
+  res.send('Birds home page');
+});
+// define the about route
+router.get('/about', (req, res) => {
+  res.send('About birds');
+});
+
+export default router;
+```
+
 Laden Sie dann das Router-Modul in der App:
 
-```js
+```cjs title="index.cjs"
 const birds = require('./birds');
 
 // ...
 
 app.use('/birds', birds);
 ```
 
+```mjs title="index.mjs"
+import birds from './birds';
+
+// ...
+
+app.use('/birds', birds);
+```
+
 Die App wird nun in der Lage sein, Anfragen an `/birds` und `/birds/about` zu bearbeiten, aufrufen sowie die Middleware-Funktion `timeLog` aufrufen, die spezifisch für die Route ist.
 
-Aber wenn die übergeordnete Route `/birds` Pfadparameter hat, wird sie standardmäßig nicht von den Unterrouten aus erreichbar sein. Um es zugänglich zu machen, müssen Sie die Option "mergeParams" an den Router-Konstruktor [reference](/api/application#appusepath-callback--callback) übergeben.
+Aber wenn die übergeordnete Route `/birds` Pfadparameter hat, wird sie standardmäßig nicht von den Unterrouten aus erreichbar sein. To make it accessible, you will need to pass the `mergeParams` option to the Router constructor [reference](/api/application#appuse).
 
 ```js
 const router = express.Router({ mergeParams: true });