Anforderung abrufen – bereichsbezogen, global

  • Freigeben Version: Yokohama
  • Aktualisiert 30. Januar 2025
  • 14 Minuten Lesedauer

    • Die API zum Abrufen von Anforderungen enthält Methoden zum Erstellen oder Abrufen eines Anforderungsobjekts, damit Anwendungen Ressourcen wie JSON-, Text- oder Binärdaten asynchron von einem Server anfordern und die Antwort verarbeiten können. Diese API unterstützt verschiedene HTTP-Methoden wie GET, POST, PUT, DELETE usw.

    Diese API ist Teil einer Reihe von Abruf -APIs, die verschiedene Aktionen zum Abrufen von Ressourcen von externen Websites bereitstellen. Die vollständige API-Sammlung zum Abrufen enthält:

    Zur Unterstützung von Abrufaktionen ermöglicht die Systemeigenschaft glide.hosts.allowlistdie Steuerung, auf welche Hosts eine Abrufmethode zugreifen kann. Sie gilt für HTTP-APIs wie RestMessageV2 und die oben genannten. Weitere Informationen zu glide.hosts.allowlistfinden Sie unter Available system properties.

    Anforderungseigenschaften

    Die Abrufanforderungs -API unterstützt mehrere schreibgeschützte Eigenschaften, die detaillierte Informationen zu einer HTTP-Anforderung enthalten. Einige davon sind URL (die URL der Anforderung), Methode (die HTTP-Methode), Header (die zugehörigen Header) und Text (der Anforderungstext als Stream). Andere Eigenschaften umfassen Einstellungen für Caching, Anmeldeinformationen und Referrer. Diese Eigenschaften sind schreibgeschützt. Das heißt, sie können aufgerufen, aber nicht geändert werden, nachdem die Anforderung erstellt wurde. Weitere Informationen zu den einzelnen Eigenschaften finden Sie unter https://developer.mozilla.org/en-US/docs/Web/API/Request.

    Tabelle : 1. Anforderungseigenschaften
    Eigenschaftsname Beschreibung Beispiel
    body Schreibgeschützte Eigenschaft. Enthält einen lesbaren Stream von Bytedaten mit dem Textinhalt, der der Anforderung hinzugefügt wurde.

    Datentyp/-wert: ReadableStream oder NULL

    		 
    const request = new Request("/myEndpoint", {
  method: "POST",
  body: "Hello world",
});

request.body; // ReadableStream
    „bodyUsed“ Schreibgeschützte Eigenschaft. Kennzeichnung, die angibt, ob der Anforderungstext bereits gelesen wurde.
    Akzeptierter Wert:
    • wahr: Der Anforderungstext wurde gelesen.
    • „falsch“: Der Anforderungstext wurde nicht gelesen.

    Datentyp: Boolesch

    		 
    const request = new Request("/myEndpoint", {
  method: "POST",
  body: "Hello world",
});

request.bodyUsed; // false

request.text().then((bodyAsText) => {
  console.log(request.bodyUsed); // true
});
    Cache Schreibgeschützte Eigenschaft. Enthält den Cache-Modus der Anforderung, der steuert, wie die Anforderung mit dem HTTP-Cache des Browsers interagiert.
    Akzeptierte Werte:
    • Standard: Der Browser sucht in seinem HTTP-Cache nach einer übereinstimmenden Anforderung.
      • Wenn eine Übereinstimmung vorhanden ist und diese neu ist, wird sie aus dem Cache zurückgegeben.
      • Wenn es eine Übereinstimmung gibt, diese jedoch veraltet ist, sendet der Browser eine bedingte Anforderung an den Remote-Server. Wenn der Server angibt, dass sich die Ressource nicht geändert hat, wird sie aus dem Cache zurückgegeben. Andernfalls wird die Ressource vom Server heruntergeladen und der Cache aktualisiert.
      • Wenn es keine Übereinstimmung gibt, sendet der Browser eine normale Anforderung und aktualisiert den Cache mit der heruntergeladenen Ressource.
    • erzwingen-cache: Der Browser sucht in seinem HTTP-Cache nach einer übereinstimmenden Anforderung.
      • Wenn eine Übereinstimmung vorhanden ist, ob sie aktuell oder veraltet ist, wird sie aus dem Cache zurückgegeben.
      • Wenn es keine Übereinstimmung gibt, führt der Browser eine normale Anforderung durch und aktualisiert den Cache mit der heruntergeladenen Ressource.
    • no-cache: Der Browser sucht in seinem HTTP-Cache nach einer übereinstimmenden Anforderung.
      • Wenn eine Übereinstimmung vorhanden ist, aktuell oder veraltet, sendet der Browser eine bedingte Anforderung an den Remote-Server. Wenn der Server angibt, dass sich die Ressource nicht geändert hat, wird sie aus dem Cache zurückgegeben. Andernfalls wird die Ressource vom Server heruntergeladen und der Cache aktualisiert.
      • Wenn es keine Übereinstimmung gibt, sendet der Browser eine normale Anforderung und aktualisiert den Cache mit der heruntergeladenen Ressource.
    • no-store: Der Browser ruft die Ressource vom Remote-Server ab, ohne zuerst im Cache zu suchen, und aktualisiert den Cache nicht mit der heruntergeladenen Ressource.
    • only-if-cached: Der Browser sucht in seinem HTTP-Cache nach einer übereinstimmenden Anforderung.
      • Wenn eine Übereinstimmung vorhanden ist, ob sie aktuell oder veraltet ist, wird sie aus dem Cache zurückgegeben.
      • Wenn es keine Übereinstimmung gibt, antwortet der Browser mit 504 Gateway-Zeitüberschreitungsstatus.

      Der Modus „Nur-bei-Zwischenspeicherung“ kann nur verwendet werden, wenn der Modus der Anforderung „same-origin“ist. Zwischengespeicherte Umleitungen werden befolgt, wenn die Umleitungseigenschaft der Anforderung auf „follow“ festgelegt ist und die Umleitungen den „Same-Ursprungs -Modus“ nicht verletzen.

    • reload: Der Browser ruft die Ressource vom Remote-Server ab, ohne zuerst im Cache zu suchen, aktualisiert dann aber den Cache mit der heruntergeladenen Ressource.

    Datentyp: Zeichenfolge

    		 
    // Download a resource with cache busting, to bypass the cache
// completely.
fetch("some.json", { cache: "no-store" }).then((response) => {
  /* consume the response */
});

// Download a resource with cache busting, but update the HTTP
// cache with the downloaded resource.
fetch("some.json", { cache: "reload" }).then((response) => {
  /* consume the response */
});

// Download a resource with cache busting when dealing with a
// properly configured server that will send the correct ETag
// and Date headers and properly handle If-Modified-Since and
// If-None-Match request headers, therefore we can rely on the
// validation to guarantee a fresh response.
fetch("some.json", { cache: "no-cache" }).then((response) => {
  /* consume the response */
});

// Download a resource with economics in mind! Prefer a cached
// albeit stale response to conserve as much bandwidth as possible.
fetch("some.json", { cache: "force-cache" }).then((response) => {
  /* consume the response */
});

// Naive stale-while-revalidate client-level implementation.
// Prefer a cached albeit stale response; but update if it's too old.
// AbortController and signal to allow better memory cleaning.
// In reality; this would be a function that takes a path and a
// reference to the controller since it would need to change the value
let controller = new AbortController();
fetch("some.json", {
  cache: "only-if-cached",
  mode: "same-origin",
  signal: controller.signal,
})
  .catch((e) =>
    e instanceof TypeError && e.message === "Failed to fetch"
      ? { status: 504 } // Workaround for chrome; which fails with a TypeError
      : Promise.reject(e),
  )
  .then((res) => {
    if (res.status === 504) {
      controller.abort();
      controller = new AbortController();
      return fetch("some.json", {
        cache: "force-cache",
        mode: "same-origin",
        signal: controller.signal,
      });
    }
    const date = res.headers.get("date"),
      dt = date ? new Date(date).getTime() : 0;
    if (dt < Date.now() - 86_400_000) {
      // if older than 24 hours
      controller.abort();
      controller = new AbortController();
      return fetch("some.json", {
        cache: "reload",
        mode: "same-origin",
        signal: controller.signal,
      });
    }

    // Other possible conditions
    if (dt < Date.now() - 300_000)
      // If it's older than 5 minutes
      fetch("some.json", { cache: "no-cache", mode: "same-origin" }); // no cancellation or return value.
    return res;
  })
  .then((response) => {
    /* consume the (possibly stale) response */
  })
  .catch((error) => {
    /* Can be an AbortError/DOMException or a TypeError */
  });
    Anmeldeinformationen Schreibgeschützt. Spiegelt den Wert wider, der dem Request()- Konstruktor in der Option für Anmeldeinformationen angegeben wurde. Anmeldeinformationen sind Cookies, TLS-Client-Zertifikate oder Authentifizierungsheader, die einen Anwendernamen und ein Passwort enthalten.
    Akzeptierte Werte:
    • Include: Fügt immer Anmeldeinformationen ein, auch für ursprungsübergreifende Anforderungen.
    • auslassen: Senden Sie niemals Anmeldeinformationen in der Anforderung, oder fügen Sie Anmeldeinformationen in die Antwort ein.
    • same-origin: Es werden nur Anmeldeinformationen für Anforderungen gleicher Herkunft gesendet und eingeschlossen.

    Datentyp: Zeichenfolge

    		 
    const request = new Request("flowers.jpg");
const request = request.request; // returns "same-origin" by default
    destination Schreibgeschützt. Gibt eine Zeichenfolge zurück, die den Typ des angeforderten Inhalts beschreibt.
    Akzeptierte Werte:
    • Audio: Das Ziel sind Audiodaten.
    • Audioworklet: Das Ziel sind Daten, die zur Verwendung durch ein Audio-Worklet abgerufen werden.
    • Dokument: Das Ziel ist ein HTML- oder XML-Dokument.
    • eingebettet: Das Tag ist eingebetteter Inhalt.
    • FencedFrame: Das Ziel ist ein eingezäunter Frame.
    • Schriftart: Das Ziel ist eine Schriftart.
    • Frame: Das Ziel ist ein Frame.
    • iframe: Das Ziel ist ein iframe.
    • Bild: Das Ziel ist ein Bild.
    • json: Das Ziel ist eine JSON-Datei
    • Manifest: Das Ziel ist ein Manifest.
    • Objekt: Das Ziel ist ein Objekt.
    • paintworklet: Das Ziel ist ein Mal-Worklet.
    • Bericht: Das Ziel ist ein Bericht.
    • Skript: Das Ziel ist ein Skript.
    • Sharedworker: Das Ziel ist ein freigegebener Mitarbeiter.
    • Stil: Das Ziel ist ein Stil.
    • verfolgen: Das Ziel ist ein HTML-Code <track>.
    • Video: Das Ziel sind Videodaten.
    • worker: Das Ziel ist ein Worker.
    • xslt: Das Ziel ist eine XSLT-Transformation.

    Datentyp: Zeichenfolge

    		 
    fetch('https://example.com/image.jpg', {
  destination: 'image'
})
  .then(response => response.blob())
  .then(blob => {
    console.log('Image fetched successfully', blob);
  })
  .catch(error => console.error('Error:', error));
    headers Schreibgeschützt. Das Header-Objekt, das der Anforderung zugeordnet ist.

    Datentyp: Headerobjekt

    		 
    const myRequest = new Request("flowers.jpg");
const myHeaders = myRequest.headers; // Headers {}
    Integrität Schreibgeschützt. Der Integritätswert der Unterressourcen der Anforderung.

    Wert: Der Wert, der beim Erstellen der Anforderung als Argument options.integrity übergeben wurde. Wenn keine Integrität angegeben wurde, gibt die Eigenschaft „“zurück.

    		 
    const myRequest = new Request("flowers.jpg", {
  integrity: "sha256-abc123",
});
console.log(myRequest.integrity); // "sha256-abc123"
    isHistoryNavigation Schreibgeschützt. Boolescher Wert, der angibt, ob es sich bei der Anforderung um eine Verlaufsnavigation handelt.
    Akzeptierte Werte:
    • „wahr“: Die Anforderung ist eine Verlaufsnavigation.
    • „falsch“: Die Anforderung ist keine Verlaufsnavigation.

    Datentyp: Boolesch

    		 
    self.addEventListener("request", (event) => {
  // ...

  if (event.request.isHistoryNavigation) {
    event.respondWith(
      caches.match(event.request).then((response) => {
        if (response !== undefined) {
          return response;
        } else {
          return fetch(event.request).then((response) => {
            let responseClone = response.clone();

            caches.open("v1").then((cache) => {
              cache.put(event.request, responseClone);
            });

            return response;
          });
        }
      }),
    );
  }

  // ...
});
    Keepalive Schreibgeschützt. Die Keepalive-Einstellung der Anforderung (wahr oder falsch). Gibt eine leere Zeichenfolge zurück, wenn in der Anforderung kein Integritätswert übergeben wird.
    Akzeptierte Werte:
    • „wahr“: Der Browser hält die zugeordnete Anforderung aufrecht, wenn die Seite, von der sie initiiert wurde, entladen wird, bevor die Anforderung abgeschlossen ist.
    • „false“: Der Browser hält die zugeordnete Anforderung nicht aufrecht, wenn die Seite, von der sie initiiert wurde, entladen wird, bevor die Anforderung abgeschlossen ist.

    Datentyp: Boolesch

    		 
    const options = {
  keepalive: true,
};

const myRequest = new Request("flowers.jpg", options);
let myKeepAlive = myRequest.keepalive; // true
    method Schreibgeschützt. Die Methode der Anforderung (GET, POSTusw.)

    Datentyp: Zeichenfolge

    		 
    const myRequest = new Request("flowers.jpg");
const myMethod = myRequest.method; // GET
    Modus Schreibgeschützt. Modus der Anforderung. Wird verwendet, um zu bestimmen, ob ursprungsübergreifende Anforderungen zu gültigen Antworten führen und welche Eigenschaften der Antwort lesbar sind.
    Akzeptierte Werte:
    • cors: Wenn die Anforderung ursprungsübergreifend ist, wird der CORS-Mechanismus (Cross-Origin Resource Sharing) verwendet.
    • navigieren: Ein Modus zur Unterstützung der Navigation. Der Navigationswert soll nur für die HTML-Navigation verwendet werden. Eine Navigationsanforderung wird nur beim Navigieren zwischen Dokumenten erstellt.
    • no-cors: Deaktiviert CORS für ursprungsübergreifende Anforderungen. Die Antwort ist undurchsichtig, was bedeutet, dass Header und Text für JavaScript nicht verfügbar sind.
    • same-origin: Verbietet ursprungsübergreifende Anforderungen. Wenn eine Anforderung mit diesem Modus an einen anderen Ursprung gesendet wird, ist das Ergebnis ein Fehler.

    Anforderungen können auf verschiedene Arten initiiert werden. Der Modus für eine Anforderung hängt davon ab, auf welche Weise sie initiiert wurde. Wenn beispielsweise ein Request-Objekt mit dem Request()- Konstrukteur erstellt wird, wird der Wert der Eigenschaft „mode“ für diesen Request auf „cors“ festgelegt. Für Anforderungen, die nicht durch die Anforderung ()erstellt wurden Konstrukteur, wird normalerweise ohne Kors als Modus verwendet. Beispiel: Bei eingebetteten Ressourcen, bei denen die Anforderung über Markup initiiert wird, erfolgt die Anforderung, sofern das Crossorigin-Attribut nicht vorhanden ist, in den meisten Fällen im No-Cors-Modus, d. h. für <link> oder <script> elements (except when used with modules), or <img>, <audio>,<video>, <object>, <embed>, or <iframe> elements.

    Datentyp: Zeichenfolge

    		 
    const myRequest = new Request("flowers.jpg");
const myMode = myRequest.mode; // returns "cors" by default
    umleiten Schreibgeschützt. Modus für die Behandlung von Umleitungen.
    Gültige Werte:
    • Fehler
    • folgen
    • Manuell

    Datentyp: Zeichenfolge

    Standard: Folgen

    		 
    const myRequest = new Request("flowers.jpg");
const myCred = myRequest.redirect;
    Referrer Schreibgeschützt. Der Referrer der Anforderung (z. B. Client, No-Referreroder eine URL). Der Wert „no-referrer“ gibt eine leere Zeichenfolge zurück.

    Datentyp: Zeichenfolge

    		 
    const myRequest = new Request("flowers.jpg");
const myReferrer = myRequest.referrer; // returns "about:client" by default
    ReferrerPolicy Schreibgeschützt. Die Referrer-Richtlinie, die steuert, welche Referrer-Informationen im Referrer-Header mit der Anforderung gesendet werden.

    Datentyp: Zeichenfolge

    		 
    const myRequest = new Request("flowers.jpg");
const myReferrer = myRequest.referrerPolicy; // returns "" by default
    signal Schreibgeschützt. AbortSignal, das der Anforderung zugeordnet ist.

    Datentyp: Zeichenfolge

    		 
    // Create a new abort controller
const controller = new AbortController();

// Create a request with this controller's AbortSignal object
const req = new Request("/", { signal: controller.signal });

// Add an event handler logging a message in case of abort
req.signal.addEventListener("abort", () => {
  console.log("abort");
});

// In case of abort, log the AbortSignal reason, if any
fetch(req).catch(() => {
  if (req.signal.aborted) {
    if (req.signal.reason) {
      console.log(`Request aborted with reason: ${req.signal.reason}`);
    } else {
      console.log("Request aborted but no reason was given.");
    }
  } else {
    console.log("Request not aborted, but terminated abnormally.");
  }
});

// Actually abort the request
controller.abort();
    URL Schreibgeschützt. URL der Anforderung.

    Datentyp: Zeichenfolge

    		 
    const myRequest = new Request("flowers.jpg");
const myURL = myRequest.url; // "https://github.com/mdn/dom-examples/tree/main/fetch/fetch-request/flowers.jpg"

    Anforderung abrufen – Request()

    Erstellt ein neues Anforderungsobjekt. Erstellen Sie das Anforderungsobjekt optional über eine URL oder eine Objektressource.

    Tabelle : 2. Parameter
    Name Typ Beschreibung
    Eingabe Zeichenfolge oder Objekt Optional. Die abzurufende Ressource.

    Gültige Werte:

    • Eine Zeichenfolge, die die URL der abzurufenden Ressource enthält. Die API akzeptiert keine URLs, die Anmeldeinformationen enthalten, z. B. http://user.password.example.com. Eine Ausnahme wird ausgelöst, wenn die URL nicht analysiert werden kann.
    • Ein Anforderungsobjekt, das effektiv eine Kopie eines vorhandenen Anforderungsobjekts erstellt. Die Objektstruktur wird von der Anforderungsklasse bestimmt.
      Hinweis:
      Beachten Sie die folgenden Verhaltensaktualisierungen, um die Sicherheit zu gewährleisten und gleichzeitig die Wahrscheinlichkeit zu verringern, dass der Konstruktor Ausnahmen auslöst:
      • Wenn dieses Objekt an einem anderen Ursprung als der Konstruktoraufruf vorhanden ist, wird die Eigenschaft Request.referrer entfernt.
      • Wenn dieses Objekt über die Request.mode-Eigenschaft „ navigieren“verfügt, wird der Moduswert in „same-origin“konvertiert.
    Optionen Objekt Optional. Ein RequestInit abrufen : Bereichsbezogen, global -Objekt mit anwenderdefinierten Einstellungen, die auf die Anforderung angewendet werden sollen. Wenn Sie eine neue Anforderung aus einer vorhandenen Anforderung erstellen, überschreiben die in der neuen Anforderung festgelegten Optionen die entsprechenden Optionen in der ursprünglichen Anforderung.

    Standard: Gibt Standardwerte für alle Eigenschaften zurück.

    Das folgende Beispiel zeigt, wie Sie mit dem Request()- Konstrukteur ein neues Request-Objekt erstellen.

    var myImage = document.querySelector("img");
var myRequest = new Request("flowers.jpg");

    Das folgende Beispiel zeigt, wie Sie das neue Anforderungsobjekt mithilfe des Eingabeparameters erstellen, um eine URL oder ein Objekt abzurufen.

    var myImage = document.querySelector("img");
var myRequest = new Request("flowers.jpg");

fetch(myRequest)
  .then((response) => response.blob())
  .then((response) => {
    var objectURL = URL.createObjectURL(response);
    myImage.src = objectURL;
  });

    Das folgende Beispiel zeigt, wie das neue Request-Objekt mit Header-Optionen mithilfe eines Objektliterals erstellt wird.

    var myImage = document.querySelector("img");
var myRequest = new Request("flowers.jpg");

var options = {
  headers: {
    "Cache-Control": "max-age=60480",
  },
};

    Anforderung abrufen – arrayBuffer()

    Liest den Anforderungstext und gibt ihn als Zusage zurück, der mit einem Array-Puffer aufgelöst wird.

    Tabelle : 3. Parameter
    Name Typ Beschreibung
    Keine
    Tabelle : 4. Ergebnisse
    Typ Beschreibung
    Zusage Ein Prompt, das mit einem arrayBufferaufgelöst wird.

    Im Folgenden wird gezeigt, wie Sie mit der arrayBuffer()- Methode eine neue Anforderung erstellen.

    var myArray = new Uint8Array(10);

var request = new Request("/myEndpoint", {
  method: "POST",
  body: myArray,
});

request.arrayBuffer().then((buffer) => {
  // perform an action with the buffer sent in the request
});

    Anforderung abrufen – blob()

    Liest den Anforderungstext und gibt ihn als Zusage zurück, das mit einem Blob aufgelöst wird.

    Tabelle : 5. Parameter
    Name Typ Beschreibung
    Keine
    Tabelle : 6. Ergebnisse
    Typ Beschreibung
    Objekt Ein Prompt, das mit einem Blobaufgelöst wird.

    Das folgende Beispiel zeigt, wie eine Anforderung mit der Methode blob() erstellt wird.

    var obj = { hello: "world" };
var myBlob = new Blob([JSON.stringify(obj, null, 2)], {
  type: "application/json",
});

var request = new Request("/myEndpoint", {
  method: "POST",
  body: myBlob,
});

request.blob().then((myBlob) => {
  // do something with the blob sent in the request
});

    Anforderung abrufen – bytes()

    Liest den Anforderungstext und gibt ihn als Zusage zurück, das mit einem Uint8Array aufgelöst wird.

    Tabelle : 7. Parameter
    Name Typ Beschreibung
    Keine
    Tabelle : 8. Ergebnisse
    Typ Beschreibung
    Objekt Ein Promise, das mit einem Uint8Arrayaufgelöst wird.

    Im Folgenden wird gezeigt, wie Sie mit der bytes()- Methode eine neue Anforderung erstellen.

    var myArray = new Uint8Array(10);

var request = new Request("/myEndpoint", {
  method: "POST",
  body: myArray,
});

request.bytes().then((buffer) => {
  // do something with the buffer sent in the request
});

    Anforderung abrufen – Klon ()

    Erstellt eine Kopie des aktuellen Anforderungsobjekts.

    Tabelle : 9. Parameter
    Name Typ Beschreibung
    Keine
    Tabelle : 10. Ergebnisse
    Typ Beschreibung
    Anforderung Ein Anforderungsobjekt, das eine exakte Kopie der Anforderung ist, für die der Klon () aufgerufen wurde. clone() löst einen Fehler aus, wenn der Anforderungstext bereits verwendet wurde. Wenn Sie die Anforderung ändern möchten, verwenden Sie den -Konstrukteur Anforderung abrufen – Request().

    Das folgende Beispiel zeigt, wie Sie mit request() eine neue Anforderung erstellen und anschließend mit clone()kopieren.

    var myRequest = new Request("flowers.jpg");
var newRequest = myRequest.clone(); // a copy of the request is now stored in newRequest

    Anforderung abrufen – formData()

    Liest den Anforderungstext und gibt ihn als Zusage zurück, das mit einem FormData-Objekt aufgelöst wird.

    Tabelle : 11. Parameter
    Name Typ Beschreibung
    Keine
    Tabelle : 12. Ergebnisse
    Typ Beschreibung
    Keine Ein Promise, das mit einem FormData- Objekt aufgelöst wird.

    Das folgende Beispiel zeigt, wie Sie mit request() eine neue Anforderung erstellen und dann mit der formData()-Methode auflösen, um sie als FormData-Objekt aufzulösen.

    var formData = new FormData();
var fileField = document.querySelector('input[type="file"]');

formData.append("username", "abc123");
formData.append("avatar", fileField.files[0]);

var request = new Request("/myEndpoint", {
  method: "POST",
  body: formData,
});

request.formData().then((data) => {
  // do something with the formdata sent in the request
});

    Anforderung abrufen – json()

    Liest den Anforderungstext, analysiert den Inhalt als JSON und gibt ein Prompt zurück, das mit dem analysierten Ergebnis aufgelöst wird.

    Tabelle : 13. Parameter
    Name Typ Beschreibung
    Keine
    Tabelle : 14. Ergebnisse
    Typ Beschreibung
    Objekt Eine Zusage (der eventuelle Abschluss oder das Fehlschlagen eines asynchronen Vorgangs und der resultierende Wert), die in ein JavaScript-Objekt aufgelöst wird. Dieses Objekt kann alles sein, was von JSON dargestellt werden kann: ein Objekt, ein Array, eine Zeichenfolge, eine Zahl usw.

    Das folgende Beispiel zeigt, wie Sie mit request() und dann json() eine neue Anforderung erstellen, um die Anforderung zu analysieren und als JSON-Objekt zurückzugeben.

    var obj = { hello: "world" };

var request = new Request("/myEndpoint", {
  method: "POST",
  body: JSON.stringify(obj),
});

request.json().then((data) => {
  // process the data sent in the request
});

    Anforderung abrufen – text()

    Liest den Anforderungstext und gibt ihn als Zusage zurück, das mit einer in UTF-8 decodierten Zeichenfolge aufgelöst wird.

    Tabelle : 15. Parameter
    Name Typ Beschreibung
    Keine
    Tabelle : 16. Ergebnisse
    Typ Beschreibung
    Keine Ein Prompt, das mit einer Zeichenfolge im UTF-8-Format aufgelöst wird.

    Dieses Beispiel zeigt den Aufruf von text().

    var text = "Hello world";

var request = new Request("/myEndpoint", {
  method: "POST",
  body: text,
});

request.text().then((text) => {
  // process the data sent in the request
});