Remplacer les rappels par Async/Await

Remplace les rappels par async/await pour améliorer la lisibilité et la gestion des erreurs en JavaScript.

Vous pouvez interroger un modèle directement et tester les résultats renvoyés lors de l'utilisation de différentes valeurs de paramètre en utilisant la console Cloud ou en appelant directement l'API Vertex AI.

Pour obtenir un exemple d'utilisation de l'API Vertex AI, consultez la page Démarrage rapide avec l'API Vertex AI.
Pour afficher cet exemple dans la console Cloud : accédez à la console Google Cloud.

Requête forme libre

Refactorisez ce code JavaScript pour utiliser la fonction async/await plutôt que des rappels pour gérer les opérations asynchrones. L'objectif est d'améliorer la lisibilité du code et la gestion des erreurs.

function fetchData(url, callback) {
  http.get(url, function(response) {
    let data = '';
    response.on('data', (chunk) => {
      data += chunk;
    });
    response.on('end', () => {
      callback(null, data);
    });
  }).on('error', (err) => {
    callback(err);
  });
}

Réponse


async function fetchData(url) {
try {
const response = await new Promise((resolve, reject) => {
http.get(url, (res) => {
let data = '';
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
resolve(data);
});
}).on('error', reject);
});
return response;
} catch (error) {
throw error; // Re-throw the error to be handled by the caller
}
}

Explication :

Fonction async : nous définissons la fonction fetchData comme async, ce qui nous permet d'y utiliser await.
Bloc try...catch : nous encapsulons l'opération asynchrone dans un bloc try...catch pour gérer les erreurs potentielles.
Promise et await :
Nous créons une Promise qui se résout avec les données lorsque la réponse est entièrement reçue.
Nous utilisons await pour mettre en pause l'exécution de la fonction jusqu'à ce que l'opération Promise soit résolue.
Traitement des erreurs :
Si une erreur se produit pendant la requête http.get, la fonction reject de Promise est appelée, ce qui entraîne l'exécution du bloc catch.
Nous générons à nouveau l'erreur en utilisant throw error pour la propager à l'appelant.
Valeur de renvoi : si la fonction fetchData aboutit, elle renvoie les données récupérées.

Utilisation :

async function main() {
try {
const data = await fetchData('https://example.com/data');
console.log(data);
} catch (error) {
console.error('Error fetching data:', error);
}
}

main();

Avantages de l'utilisation de la méthode async/await :

Meilleure lisibilité : le code est plus concis et plus facile à comprendre, car le flux asynchrone est plus explicite.
Traitement simplifié des erreurs : le bloc try...catch permet de gérer clairement les erreurs.
Pas de problèmes de rappel : nous évitons les rappels imbriqués, ce qui rend le code plus facile à gérer.
Amélioration du flux de contrôle : l'exécution du code est plus prévisible, car await met la fonction en pause jusqu'à la fin de l'opération asynchrone.

Modèle :	gemini-1.5-flash-001
Température :	1
Nombre maximal de jetons de sortie :	8 192
TopK :	40
TopP :	0,95