Detaillierte Erklärung von JavaScript Promise und Async/Await

neues Versprechen (Funktion (auflösen, ablehnen) {
    if (/* asynchroner Vorgang erfolgreich*/) {
        resolve(value); //Ändern Sie den Status von Promise von padding auf guaranteed.
    } anders {
        reject(error); //Ändern Sie den Status von Promise von padding auf rejected
    }
})
Es gibt drei Prototypmethoden in der Implementierung: then, catch und finally
versprechen
.then((Ergebnis) => {
    //das Versprechen wird angenommen oder abgelehnt, um die Ausführung fortzusetzen})
.catch((Fehler) => {
    //Versprechen wird abgelehnt})
.schließlich (() => {
    //Wenn das Versprechen erfüllt ist, wird es trotzdem ausgeführt})

const anMeinGeburtstag = (isKayoSick) => {
  returniere neues Promise((lösen, ablehnen) => {
    setzeTimeout(() => {
      wenn (!istKayoSick) {
        Entschlossenheit (2);
      } anders {
        reject(new Error("Ich bin traurig"));
      }
    }, 2000);
  });
};

anMeinGeburtstag(falsch)
  .then((Ergebnis) => {
    console.log(`Ich habe ${result} Kuchen`); // Konsole druckt „Ich habe 2 Kuchen“ 
  })
  .catch((Fehler) => {
    console.log(Fehler); // nicht ausgeführt})
  .finally(() => {
    console.log("Party"); // Die Konsole druckt "Party"
  });

anMeinGeburtstag(true)
  .then((Ergebnis) => {
    console.log(`Ich habe ${result} Kuchen`); // nicht ausgeführt})
  .catch((Fehler) => {
    console.log(error); // Die Konsole druckt „Ich bin traurig“
  })
  .finally(() => {
    console.log("Party"); // Die Konsole druckt "Party"
  });

const Eingabenummer = () => {
  returniere neues Promise((lösen, ablehnen) => {
    // Beginnen Sie hier mit der Codierung });
};

const Eingabenummer = () => {
  returniere neues Promise((lösen, ablehnen) => {
    const userNumber = Number(window.prompt("Geben Sie eine Zahl ein (1 - 6):")); // Fragen Sie den Benutzer nach einer Zahl const randomNumber = Math.floor(Math.random() * 6 + 1); // Wählen Sie eine Zufallszahl zwischen 1 und 6 });
};

const Eingabenummer = () => {
  returniere neues Promise((lösen, ablehnen) => {
    const userNumber = Number(window.prompt("Geben Sie eine Zahl ein (1 - 6):")); // Fragen Sie den Benutzer nach einer Zahl const randomNumber = Math.floor(Math.random() * 6 + 1); // Wählen Sie eine Zufallszahl zwischen 1 und 6 if (isNaN(userNumber)) {
      reject(new Error("Falscher Eingabetyp")); // Wenn der vom Benutzer eingegebene Wert keine Zahl ist, wird eine Ausnahme ausgelöst und die Ablehnungsfunktion aufgerufen}
  });
};

returniere neues Promise((lösen, ablehnen) => {
  const userNumber = Number(window.prompt("Geben Sie eine Zahl ein (1 - 6):")); // Fragen Sie den Benutzer nach einer Zahl const randomNumber = Math.floor(Math.random() * 6 + 1); // Wählen Sie eine Zufallszahl zwischen 1 und 6 if (isNaN(userNumber)) {
    reject(new Error("Falscher Eingabetyp")); // Wenn der vom Benutzer eingegebene Wert keine Zahl ist, wird eine Ausnahme ausgelöst und die Ablehnungsfunktion aufgerufen}
 
  if (Benutzernummer === Zufallszahl) {
    // Wenn sie gleich sind, geben wir dem Benutzer 2 Punkte resolve({
      Punkte: 2,
      Zufallszahl,
    });
  } sonst wenn (
    Benutzernummer === Zufallszahl - 1 ||
    Benutzernummer === Zufallszahl + 1
  ) {
    // Wenn die Differenz zwischen userNumber und randomNumber 1 ist, dann geben wir dem Benutzer 1 Punkt resolve({
      Punkte: 1,
      Zufallszahl,
    });
  } anders {
    // Andernfalls erhält der Benutzer 0 Punkte resolve({
      Punkte: 0,
      Zufallszahl,
    });
  }
});

const continueGame = () => {
  returniere neues Promise((auflösen) => {
    if (window.confirm("Möchten Sie fortfahren?")) { // Den Benutzer fragen, ob er das Spiel fortsetzen möchte resolve(true);
    } anders {
      Lösung (falsch);
    }
  });
};

const handleGuess = () => {
  enterNumber() // Gibt ein Promise-Objekt zurück.then((result) => {
      alert(`Dice: ${result.randomNumber}: du hast ${result.points} Punkte`); // Wenn „Resolve“ ausgeführt wird, erhalten wir die Punktzahl des Benutzers und die Zufallszahl // Fragen Sie den Benutzer, ob er das Spiel fortsetzen möchte continueGame().then((result) => {
        wenn (Ergebnis) {
          handleGuess(); // Wenn ja, wird das Spiel fortgesetzt } else {
          alert("Spiel endet"); // Wenn nicht, öffne das Feld zum Spielende}
      });
    })
    .catch((Fehler) => Warnung(Fehler));
};
 
handleGuess(); // HandleGuess-Funktion ausführen

const handleGuess = async () => {
  versuchen {
    const result = await enterNumber(); // Statt der then-Methode müssen wir nur await vor promise setzen, um das Ergebnis direkt zu erhalten alert(`Dice: ${result.randomNumber}: you got ${result.points} points`);
 
    const isContinuing = warte auf continueGame();
 
    wenn (wird fortgesetzt) ​​{
      handleGuess();
    } anders {
      alert("Spiel endet");
    }
  } catch (error) { // Die Catch-Methode kann durch try, catch function alert(error); ersetzt werden.
  }
};

const Eingabenummer = () => {
  returniere neues Promise((lösen, ablehnen) => {
    const userNumber = Number(window.prompt("Geben Sie eine Zahl ein (1 - 6):")); // Fragen Sie den Benutzer nach einer Zahl const randomNumber = Math.floor(Math.random() * 6 + 1); // Das System wählt zufällig eine Zahl zwischen 1 und 6 aus if (isNaN(userNumber)) {
      reject(new Error("Falscher Eingabetyp")); // Gibt einen Fehler aus, wenn der Benutzer eine Zahl eingibt, die keine Ziffer ist}
 
    if (userNumber === randomNumber) { // Wenn der Benutzer die Zahl richtig errät, erhält er 2 Punkte resolve({
        Punkte: 2,
        Zufallszahl,
      });
    } sonst wenn (
      Benutzernummer === Zufallszahl - 1 ||
      Benutzernummer === Zufallszahl + 1
    ) { // Wenn sich userNumber von randomNumber um 1 unterscheidet, geben wir dem Benutzer 1 Punkt resolve({
        Punkte: 1,
        Zufallszahl,
      });
    } sonst { // Falsch, Punktzahl 0 resolve({
        Punkte: 0,
        Zufallszahl,
      });
    }
  });
};
 
const weiterSpiel = () => {
  returniere neues Promise((auflösen) => {
    if (window.confirm("Möchten Sie fortfahren?")) { // Den Benutzer fragen, ob er das Spiel fortsetzen möchte resolve(true);
    } anders {
      Lösung (falsch);
    }
  });
};
 
const handleGuess = async () => {
  versuchen {
    const result = await enterNumber(); // await ersetzt die then-Funktion alert(`Dice: ${result.randomNumber}: du hast ${result.points} Punkte`);
 
    const isContinuing = warte auf continueGame();
 
    wenn (wird fortgesetzt) ​​{
      handleGuess();
    } anders {
      alert("Spiel endet");
    }
  } catch (error) { // Die Catch-Methode kann durch try, catch function alert(error); ersetzt werden.
  }
};
 
handleGuess(); // HandleGuess-Funktion ausführen

const fetchData = async () => {
  const res = await fetch("https://restcountries.eu/rest/v2/alpha/cn"); // fetch() gibt ein Versprechen zurück, also müssen wir darauf warten
 
  const country = await res.json(); // res ist jetzt nur noch eine HTTP-Antwort, also müssen wir res.json() aufrufen
 
  console.log(Land); // Chinas Daten werden in der Entwicklerkonsole protokolliert
};
 
fetchData();

// Aufgabe 4: Informationen über die Nachbarländer Chinas einholen const fetchCountry = async (alpha3Code) => {
  versuchen {
    const res = warte auf Abruf(
      `https://restcountries.eu/rest/v2/alpha/${alpha3Code}`
    );
 
    const Daten = warte auf res.json();
 
    Daten zurückgeben;
  } Fehler abfangen {
    konsole.log(Fehler);
  }
};

const fetchCountryAndNeighbors = async () => {
  const china = warte auf fetchCountry("cn");
 
  Konsole.log (China);
};
 
fetchCountryAndNeighbors();

const Nachbarn = china.borders.map((Grenze) => fetchCountry(Grenze));

const fetchCountryAndNeigbors = async () => {
  const china = warte auf fetchCountry("cn");
 
  const Nachbarn = warte auf Promise.all(
    china.borders.map((Grenze) => fetchCountry(Grenze))
  );
 
  console.log(Nachbarn);
};
 
fetchCountryAndNeigbors();

const fetchCountry = async (alpha3Code) => {
  versuchen {
    const res = warte auf Abruf(
      `https://restcountries.eu/rest/v2/alpha/${alpha3Code}`
    );
    const Daten = warte auf res.json();
    Daten zurückgeben;
  } Fehler abfangen {
    konsole.log(Fehler);
  }
};
 
const fetchCountryAndNeigbors = async () => {
  const china = warte auf fetchCountry("cn");
  const Nachbarn = warte auf Promise.all(
    china.borders.map((Grenze) => fetchCountry(Grenze))
  );
  console.log(Nachbarn);
};
 
fetchCountryAndNeigbors();