Partager via

Effectuer une boucle et paginer des données renvoyées par le kit de développement logiciel (SDK) Azure pour JavaScript

Lorsque vous utilisez des services Azure, vous devez souvent traiter de grands ensembles de données. Le Kit de développement logiciel (SDK) Azure pour JavaScript fournit des itérateurs asynchrones pour aider à gérer cette tâche efficacement. Cet article explique quels itérateurs asynchrones sont, comment les utiliser et fournit des exemples pour les services Azure clés.

Qu’est-ce que les itérateurs asynchrones ?

Les itérateurs asynchrones sont une fonctionnalité de JavaScript moderne qui vous permet d’utiliser des données de manière asynchrone. Ils sont utiles pour gérer les données paginées à partir d’API. Les itérateurs asynchrones utilisent la for-await-of boucle pour itérer sur les données, en les récupérant selon les besoins.

L’utilisation d’itérateurs asynchrones offre plusieurs avantages :

  • Syntaxe simplifiée : La for-await-of boucle simplifie l’utilisation d’itérateurs asynchrones.
  • Récupération de données à la demande : Récupérez uniquement les données dont vous avez besoin, ce qui réduit l’utilisation de la mémoire et la charge sur le serveur principal.
  • Compatibilité future : Les itérateurs asynchrones sont une fonctionnalité standard en JavaScript, ce qui garantit la compatibilité avec les futures mises à jour et bibliothèques.

Si vous débutez avec des itérateurs asynchrones, les concepts suivants vous aident à comprendre le fonctionnement de la pagination dans les kits sdk Azure pour JavaScript.

  • Fonctions asynchrones : Fonctions qui retournent un Promise.
  • Générateurs: Fonctions qui peuvent être suspendues et reprises, produisant plusieurs valeurs.
  • Générateurs asynchrones : Combinez les fonctionnalités des fonctions asynchrones et des générateurs pour produire des itérateurs asynchrones.

Les bibliothèques clientes Azure utilisent des itérateurs asynchrones pour gérer des collections potentiellement volumineuses de données. Voici des exemples d’utilisation d’itérateurs asynchrones avec différents services Azure.

Itérer sur un petit nombre d’éléments

Si votre ensemble de résultats ne contient que quelques éléments, vous pouvez itérer sur cette petite liste. Le code suivant effectue une boucle dans un petit ensemble de conteneurs dans Stockage Azure :

for await (const container of blobServiceClient.listContainers()) {
  console.log(`Container: ${container.name}`);
}

Itérer sur les données par page

Si votre jeu de données est plus grand, vous pouvez retourner les données dans les pages, puis effectuer une itération sur les éléments de chaque page. Le code suivant effectue une boucle dans une page de données, puis chaque élément.

const firstPage = await blobServiceClient.listContainers().byPage().next();

const continuationToken = firstPage.value.continuationToken;

// The iterator also supports iteration by page.
for await (const page of blobServiceClient
  .listContainers()
  .byPage({ continuationToken })) {
  if (page.containerItems) {
    for (const container of page.containerItems) {
      console.log(`Container: ${container.name}`);
    }
  }
}

Poursuivre la boucle

Si vous devez avoir plus de contrôle sur la boucle, y compris la reprise de la boucle, utilisez un jeton de continuation. L’itérateur paginé prend également en charge la reprise à partir d’un jeton de continuation. Dans l’exemple suivant, nous utilisons le jeton de continuation de la première itération pour reprendre l’itération à la deuxième page.

console.log('Starting to process pages...');

let processingComplete = false;
let pageNumber = 1;

try {
  let page = undefined;
  let continuationToken = undefined;

  do {
    // Get a page of results
    page = await blobServiceClient.listContainers().byPage().next();

    // Get the continuation token from the current page
    continuationToken = page?.value?.continuationToken;

    console.log(
      `Processing page ${pageNumber}, items ${page.value.containerItems?.length || 0} with continuation token: ${continuationToken || 'none'}`
    );
    console.log(page.value);

    // Scenario to continue paging:
    // Perform an operation on the current page results
    // if the operation returns true, stop processing
    processingComplete = await fakeProcessor(page.value);
    if (processingComplete) {
      console.log('Stopping processing.');
      break;
    }
    console.log(
      `Processing complete for page ${pageNumber++}: get next page if a continuation token exists`
    );
  } while (continuationToken && !processingComplete);

  console.log(
    `Finished processing. Total pages processed: ${pageNumber - 1}`
  );

Ressources supplémentaires

  • Last updated on