Bonnes pratiques

Cette page couvre différentes bonnes pratiques de développement avec les scripts Google Ads.

Sélecteurs

Filtrer avec des sélecteurs

Lorsque cela est possible, utilisez des filtres pour ne demander que les entités dont vous avez besoin. L'application de filtres appropriés présente les avantages suivants:

  • Le code est plus simple et plus facile à comprendre.
  • Le script s'exécutera bien plus rapidement.

Comparez les extraits de code suivants:

Approche de codage Extrait de code
Filtrer à l'aide de sélecteurs (recommandé) 
var keywords = AdsApp.keywords()
    .withCondition('Clicks > 10')
    .forDateRange('LAST_MONTH')
    .get();
while (keywords.hasNext()) {
  var keyword = keywords.next();
  // Do work here.
}
Filtrer dans le code (non recommandé) 
var keywords = AdsApp.keywords().get();

while (keywords.hasNext()) {
  var keyword = keywords.next();
  var stats = keyword.getStatsFor(
      'LAST_MONTH');
  if (stats.getClicks() > 10) {
    // Do work here.
  }
}

La seconde méthode est déconseillée, car elle tente de récupérer la liste de tous les mots clés de votre compte dans le seul but d'appliquer un filtre à la liste.

Éviter de parcourir la hiérarchie de la campagne

Lorsque vous souhaitez récupérer des entités à un niveau particulier, utilisez une méthode de collecte à ce niveau au lieu de parcourir toute la hiérarchie de la campagne. En plus d'être plus simple, cette méthode offre également de bien meilleures performances: le système n'aura pas à lire inutilement l'ensemble des campagnes et des groupes d'annonces.

Comparez les extraits de code suivants qui récupèrent toutes les annonces de votre compte:

Approche de codage Extrait de code
Utiliser la méthode de collecte appropriée (recommandé) 

var ads = AdsApp.ads();
Traverser la hiérarchie (non recommandé) 
var campaigns = AdsApp.campaigns().get();
while (campaigns.hasNext()) {
  var adGroups = campaigns.next().
      adGroups().get();
  while (adGroups.hasNext()) {
    var ads = adGroups.next().ads().get();
    // Do your work here.
  }
}

La deuxième approche n'est pas recommandée, car elle tente d'extraire des hiérarchies d'objets entières (campagnes, groupes d'annonces), alors que seules les annonces sont nécessaires.

Utiliser des méthodes accesseur parent spécifiques

Parfois, vous devez obtenir l'entité parente d'un objet récupéré. Dans ce cas, vous devez utiliser une méthode d'accesseur fournie au lieu d'extraire des hiérarchies entières.

Comparez les extraits de code suivants, qui récupèrent les groupes d'annonces contenant des annonces textuelles ayant enregistré plus de 50 clics le mois dernier:

Approche de codage Extrait de code
Utiliser la méthode d'accesseur parent appropriée (recommandé) 
var ads = AdsApp.ads()
    .withCondition('Clicks > 50')
    .forDateRange('LAST_MONTH')
    .get();

while (ads.hasNext()) {
  var ad = ads.next();
  var adGroup = ad.getAdGroup();
  var campaign = ad.getCampaign();
  // Store (campaign, adGroup) to an array.
}
Traverser la hiérarchie (non recommandé) 
var campaigns = AdsApp.campaigns().get();
while (campaigns.hasNext()) {
  var adGroups = campaigns.next()
      .adGroups()
      .get();
  while (adGroups.hasNext()) {
    var ads = adGroups.ads()
       .withCondition('Clicks > 50')
       .forDateRange('LAST_MONTH')
       .get();
    if (ads.totalNumEntities() > 0) {
      // Store (campaign, adGroup) to an array.
    }
  }
}

La seconde méthode n'est pas recommandée, car elle extrait l'ensemble des hiérarchies de campagnes et de groupes d'annonces de votre compte, alors que vous n'avez besoin que d'un sous-ensemble de campagnes et de groupes d'annonces associé à votre ensemble d'annonces. La première approche se limite à extraire uniquement la collection d'annonces pertinente et utilise une méthode appropriée pour accéder à ses objets parents.

Utiliser des filtres parents spécifiques

Pour accéder aux entités d'une campagne ou d'un groupe d'annonces spécifique, utilisez un filtre spécifique dans le sélecteur au lieu de récupérer puis de parcourir une hiérarchie.

Comparez les extraits de code suivants qui récupèrent la liste des annonces textuelles d'une campagne et d'un groupe d'annonces spécifiés ayant enregistré plus de 50 clics le mois dernier.

Approche de codage Extrait de code
Utiliser les filtres au niveau parent appropriés (recommandé) 
var ads = AdsApp.ads()
    .withCondition('CampaignName = "Campaign 1"')
    .withCondition('AdGroupName = "AdGroup 1"')
    .withCondition('Clicks > 50')
    .forDateRange('LAST_MONTH')
    .get();

while (ads.hasNext()) {
  var ad = ads.next();
  var adGroup = ad.getAdGroup();
  var campaign = ad.getCampaign();
  // Store (campaign, adGroup, ad) to
  // an array.
}
Traverser la hiérarchie (non recommandé) 
var campaigns = AdsApp.campaigns()
    .withCondition('Name = "Campaign 1"')
    .get();

while (campaigns.hasNext()) {
  var adGroups = campaigns.next()
      .adGroups()
      .withCondition('Name = "AdGroup 1"')
      .get();
  while (adGroups.hasNext()) {
    var ads = adGroups.ads()
       .withCondition('Clicks > 50')
       .forDateRange('LAST_MONTH')
       .get();
    while (ads.hasNext()) {
      var ad = ads.next();
      // Store (campaign, adGroup, ad) to
      // an array.
    }
  }
}

La seconde méthode n'est pas recommandée, car elle itère la hiérarchie des campagnes et des groupes d'annonces de votre compte, alors que vous n'avez besoin que d'un ensemble sélectionné d'annonces, ainsi que de leurs campagnes et groupes d'annonces parents. La première approche limite l'itération de la liste d'annonces en appliquant au sélecteur un filtre spécifique pour les entités parentes.

Si possible, utilisez des ID pour le filtrage

Lorsque vous filtrez des entités, il est préférable de les filtrer en fonction de leur ID plutôt qu'en fonction d'autres champs.

Examinez les extraits de code suivants, qui permettent de sélectionner une campagne.

Approche de codage Extrait de code
Filtrer par ID (recommandé) 
var campaign = AdsApp.campaigns()
    .withIds([12345])
    .get()
    .next();
Filtrer par nom (moins adapté) 
var campaign = AdsApp.campaigns()
    .withCondition('Name="foo"')
    .get()
    .next();

La seconde méthode est moins optimale, car nous effectuons un filtrage en fonction d'un champ autre que l'ID.

Filtrez par ID parental si possible

Lorsque vous sélectionnez une entité, filtrez par ID parent autant que possible. Cela accélère vos requêtes en limitant la liste des entités récupérées par les serveurs lors du filtrage des résultats.

Prenons l'exemple d'extrait de code suivant, qui récupère un groupe d'annonces en fonction de son ID. Supposons que l'ID de la campagne parente soit connu.

Approche de codage Extrait de code
Filtrer par ID de campagne et de groupe d'annonces (recommandé) 
var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .withCondition('CampaignId="54678"')
    .get()
    .next();
Filtrer par ID de groupe d'annonces seul (moins adapté) 
var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .get()
    .next();

Même si les deux extraits de code donnent des résultats identiques, le filtrage supplémentaire dans l'extrait de code 1 à l'aide d'un ID parent (CampaignId="54678") rend le code plus efficace en limitant la liste des entités que le serveur doit itérer lors du filtrage des résultats.

Utiliser des étiquettes lorsqu'il y a trop de conditions de filtrage

Lorsque vous avez trop de conditions de filtrage, il est judicieux de créer un libellé pour les entités que vous traitez et d'utiliser ce libellé pour filtrer vos entités.

Prenons l'exemple de l'extrait de code suivant, qui récupère une liste de campagnes par leur nom.

Approche de codage Extrait de code
Utiliser un libellé (recommandé) 
var label = AdsApp.labels()
    .withCondition('Name = "My Label"')
    .get()
    .next();
var campaigns = label.campaigns.get();
while (campaigns.hasNext()) {
  var campaign = campaigns.next();
  // Do more work
}
Créer des sélecteurs complexes (non recommandé) 
var campaignNames = [‘foo’, ‘bar’, ‘baz’];

for (var i = 0; i < campaignNames.length; i++) {
  campaignNames[i] = '"' + campaignNames[i] + '"';
}

var campaigns = AdsApp.campaigns
    .withCondition('CampaignName in [' + campaignNames.join(',') + ']')
    .get();

while (campaigns.hasNext()) {
  var campaign = campaigns.next();
  // Do more work.
}

Bien que les deux extraits de code vous offrent un niveau de performances similaire, la seconde approche a tendance à générer un code plus complexe à mesure que le nombre de conditions dans votre sélecteur augmente. Il est également plus facile d'appliquer le libellé à une nouvelle entité que de modifier le script pour inclure une nouvelle entité.

Limitez le nombre de conditions dans votre clause IN.

Lors de l'exécution de scripts, un cas d'utilisation courant consiste à générer un rapport pour une liste d'entités. Pour ce faire, les développeurs construisent généralement une requête AWQL très longue qui filtre les ID d'entité à l'aide d'une clause IN. Cette approche fonctionne bien lorsque le nombre d'entités est limité. Cependant, à mesure que la longueur de votre requête augmente, les performances de votre script diminuent pour deux raisons:

  • Une requête plus longue prend plus de temps à analyser.
  • Chaque ID que vous ajoutez à une clause IN est une condition supplémentaire à évaluer, et prend donc plus de temps.

Dans de telles conditions, il est préférable d'appliquer un libellé aux entités, puis de filtrer par LabelId.

Approche de codage Extrait de code
Appliquer un libellé et filtrer par labelID (recommandé) 
// The label applied to the entity is "Report Entities"
var label = AdsApp.labels()
    .withCondition('LabelName contains "Report Entities"')
    .get()
    .next();

var report = AdsApp.report('SELECT AdGroupId, Id, Clicks, ' +
    'Impressions, Cost FROM KEYWORDS_PERFORMANCE_REPORT ' +
    'WHERE LabelId = "' + label.getId() + '"');
Créer une requête longue à l'aide d'une clause IN (non recommandé) 
var report = AdsApp.report('SELECT AdGroupId, Id, Clicks, ' +
    'Impressions, Cost FROM KEYWORDS_PERFORMANCE_REPORT WHERE ' +
    'AdGroupId IN (123, 456) and Id in (123,345, 456…)');

Modifications apportées au compte

Regrouper les modifications

Lorsque vous modifiez une entité Google Ads, les scripts Google Ads n'exécutent pas immédiatement la modification. Au lieu de cela, il tente de combiner plusieurs modifications en lots afin de pouvoir émettre une seule requête effectuant plusieurs modifications. Cette approche accélère vos scripts et réduit la charge sur les serveurs Google Ads. Cependant, certains schémas de code obligent les scripts Google Ads à vider fréquemment ses lots d'opérations, ralentissant ainsi leur exécution.

Prenons l'exemple du script suivant, qui met à jour les enchères d'une liste de mots clés.

Approche de codage Extrait de code
Effectuer le suivi des éléments mis à jour (recommandé) 
var keywords = AdsApp.keywords()
    .withCondition('Clicks > 50')
    .withCondition('CampaignName = "Campaign 1"')
    .withCondition('AdGroupName = "AdGroup 1"')
    .forDateRange('LAST_MONTH')
    .get();

var list = [];
while (keywords.hasNext()) {
  var keyword = keywords.next();
  keyword.bidding().setCpc(1.5);
  list.push(keyword);
}

for (var i = 0; i < list.length; i++) {
  var keyword = list[i];
  Logger.log('%s, %s', keyword.getText(),
      keyword.bidding().getCpc());
}
Récupérer les éléments mis à jour dans une boucle étroite (non recommandé) 
var keywords = AdsApp.keywords()
    .withCondition('Clicks > 50')
    .withCondition('CampaignName = "Campaign 1"')
    .withCondition('AdGroupName = "AdGroup 1"')
    .forDateRange('LAST_MONTH')
    .get();

while (keywords.hasNext()) {
  var keyword = keywords.next();
  keyword.bidding().setCpc(1.5);
  Logger.log('%s, %s', keyword.getText(),
      keyword.bidding().getCpc());
}

La deuxième approche n'est pas recommandée, car l'appel de keyword.bidding().getCpc() oblige les scripts Google Ads à vider l'opération setCpc() et à n'exécuter qu'une seule opération à la fois. La première approche, bien que semblable à la seconde, présente l'avantage de prendre en charge le traitement par lot, car l'appel getCpc() est effectué dans une boucle distincte de celle où setCpc() est appelé.

Utiliser des compilateurs si possible

Les scripts Google Ads proposent deux méthodes pour créer des objets : les outils de création et les méthodes de création. Les compilateurs sont plus flexibles que les méthodes de création, car ils vous donnent accès à l'objet créé à partir de l'appel d'API.

Examinez les extraits de code suivants:

Approche de codage Extrait de code
Utiliser des compilateurs (recommandé) 
var operation = adGroup.newKeywordBuilder()
    .withText('shoes')
    .build();
var keyword = operation.getResult();
Utiliser des méthodes de création (non recommandé) 
adGroup.createKeyword('shoes');
var keyword = adGroup.keywords()
    .withCondition('KeywordText="shoes"')
    .get()
    .next();

La deuxième approche n'est pas à privilégier en raison de l'opération de sélection supplémentaire liée à la récupération du mot clé. Les méthodes de création sont également obsolètes.

Toutefois, gardez à l'esprit que les outils de création, lorsqu'ils sont mal utilisés, peuvent empêcher les scripts Google Ads de regrouper leurs opérations.

Examinez les extraits de code suivants, qui créent une liste de mots clés et affichent l'ID des mots clés nouvellement créés:

Approche de codage Extrait de code
Effectuer le suivi des éléments mis à jour (recommandé) 
var keywords = [‘foo’, ‘bar’, ‘baz’];

var list = [];
for (var i = 0; i < keywords.length; i++) {
  var operation = adGroup.newKeywordBuilder()
      .withText(keywords[i])
      .build();
  list.push(operation);
}

for (var i = 0; i < list.length; i++) {
  var operation = list[i];
  var result = operation.getResult();
  Logger.log('%s %s', result.getId(),
      result.getText());
}
Récupérer les éléments mis à jour dans une boucle étroite (non recommandé) 
var keywords = [‘foo’, ‘bar’, ‘baz’];

for (var i = 0; i < keywords.length; i++) {
  var operation = adGroup.newKeywordBuilder()
      .withText(keywords[i])
      .build();
  var result = operation.getResult();
  Logger.log('%s %s', result.getId(),
      result.getText());
}

La deuxième approche est déconseillée, car elle appelle operation.getResult() dans la même boucle qui crée l'opération, forçant ainsi les scripts Google Ads à exécuter une opération à la fois. La première approche, bien que similaire, permet le traitement par lot, car nous appelons operation.getResult() dans une boucle différente de celle où elle a été créée.

Envisagez d'utiliser des importations groupées pour les mises à jour importantes

Une tâche courante des développeurs consiste à générer des rapports et à mettre à jour les propriétés d'une entité (par exemple, les enchères de mots clés) en fonction des valeurs de performances actuelles. Lorsque vous devez mettre à jour un grand nombre d'entités, les importations groupées ont tendance à offrir de meilleures performances. Prenons l'exemple des scripts suivants, qui augmentent le CPC max. des mots clés dont le champ TopImpressionPercentage > 0.4 au cours du dernier mois:

Approche de codage Extrait de code
Utiliser l'importation groupée (recommandé) 

var report = AdsApp.report(
  'SELECT AdGroupId, Id, CpcBid FROM KEYWORDS_PERFORMANCE_REPORT ' +
  'WHERE TopImpressionPercentage > 0.4 DURING LAST_MONTH');

var upload = AdsApp.bulkUploads().newCsvUpload([
  report.getColumnHeader('AdGroupId').getBulkUploadColumnName(),
  report.getColumnHeader('Id').getBulkUploadColumnName(),
  report.getColumnHeader('CpcBid').getBulkUploadColumnName()]);
upload.forCampaignManagement();

var reportRows = report.rows();
while (reportRows.hasNext()) {
  var row = reportRows.next();
  row['CpcBid'] = row['CpcBid'] + 0.02;
  upload.append(row.formatForUpload());
}

upload.apply();
Sélectionner et mettre à jour les mots clés par ID (moins adapté) 
var reportRows = AdsApp.report('SELECT AdGroupId, Id, CpcBid FROM ' +
    'KEYWORDS_PERFORMANCE_REPORT WHERE TopImpressionPercentage > 0.4 ' +
    ' DURING LAST_MONTH')
    .rows();

var map = {
};

while (reportRows.hasNext()) {
  var row = reportRows.next();
  var adGroupId = row['AdGroupId'];
  var id = row['Id'];

  if (map[adGroupId] == null) {
    map[adGroupId] = [];
  }
  map[adGroupId].push([adGroupId, id]);
}

for (var key in map) {
  var keywords = AdsApp.keywords()
      .withCondition('AdGroupId="' + key + '"')
      .withIds(map[key])
      .get();

  while (keywords.hasNext()) {
    var keyword = keywords.next();
    keyword.bidding().setCpc(keyword.bidding().getCpc() + 0.02);
  }
}

Si la seconde approche offre de bonnes performances, la première est préférable dans ce cas,

  • Les scripts Google Ads limitent le nombre d'objets pouvant être récupérés ou mis à jour en une seule exécution. Les opérations de sélection et de mise à jour de la seconde approche sont comptabilisées dans cette limite.

  • Les importations groupées sont soumises à des limites plus élevées en termes de nombre d'entités qu'elles peuvent mettre à jour et de temps d'exécution global.

Regrouper vos importations groupées par campagne

Lorsque vous créez des importations groupées, essayez de regrouper vos opérations par campagne parente. Cela augmente l'efficacité et réduit le risque de modifications conflictuelles / d'erreurs de simultanéité.

Envisagez d'exécuter deux tâches d'importation groupée en parallèle. L'une met en veille les annonces d'un groupe, l'autre ajuste les enchères de mots clés. Même si les opérations ne sont pas liées, elles peuvent s'appliquer à des entités d'un même groupe d'annonces (ou à deux groupes d'annonces différents d'une même campagne). Dans ce cas, le système verrouille l'entité parente (le groupe d'annonces ou la campagne partagés), ce qui entraîne le blocage des tâches d'importation groupée.

Les scripts Google Ads peuvent optimiser l'exécution au sein d'une même tâche d'importation groupée. Le plus simple est donc de n'exécuter qu'une seule tâche d'importation groupée par compte à la fois. Si vous décidez d'effectuer plusieurs importations groupées par compte, assurez-vous que les importations groupées se basent sur une liste de campagnes mutuellement exclusives (et leurs entités enfants) pour des performances optimales.

Rapports

Utiliser les rapports pour extraire les statistiques

Lorsque vous souhaitez récupérer de grandes quantités d'entités et leurs statistiques, il est souvent préférable d'utiliser des rapports plutôt que les méthodes AdsApp standards. L'utilisation des rapports est préférable pour les raisons suivantes:

  • Les rapports offrent de meilleures performances pour les requêtes volumineuses.
  • Les rapports ne respecteront pas les quotas d'extraction normaux.

Comparez les extraits de code suivants, qui extraient les données relatives aux clics, aux impressions, au coût et au texte de tous les mots clés ayant enregistré plus de 50 clics le mois dernier:

Approche de codage Extrait de code
Utiliser les rapports (recommandé) 
  report = AdsApp.search(
      'SELECT ' +
      '   ad_group_criterion.keyword.text, ' +
      '   metrics.clicks, ' +
      '   metrics.cost_micros, ' +
      '   metrics.impressions ' +
      'FROM ' +
      '   keyword_view ' +
      'WHERE ' +
      '   segments.date DURING LAST_MONTH ' +
      '   AND metrics.clicks > 50');
  while (report.hasNext()) {
    var row = report.next();
    Logger.log('Keyword: %s Impressions: %s ' +
        'Clicks: %s Cost: %s',
        row.adGroupCriterion.keyword.text,
        row.metrics.impressions,
        row.metrics.clicks,
        row.metrics.cost);
  }
Utiliser des itérateurs AdsApp (non recommandé) 
var keywords = AdsApp.keywords()
    .withCondition('metrics.clicks > 50')
    .forDateRange('LAST_MONTH')
    .get();
while (keywords.hasNext()) {
  var keyword = keywords.next();
  var stats = keyword.getStatsFor('LAST_MONTH');
  Logger.log('Keyword: %s Impressions: %s ' +
      'Clicks: %s Cost: %s',
      keyword.getText(),
      stats.getImpressions(),
      stats.getClicks(),
      stats.getCost());
}

La deuxième approche est déconseillée, car elle itère les mots clés et récupère les statistiques une entité à la fois. Dans ce cas, les rapports sont plus rapides, car ils extraient toutes les données en un seul appel et les diffusent selon les besoins. En outre, les mots clés récupérés avec la seconde approche sont comptabilisés dans le quota de votre script pour le nombre d'entités récupérées à l'aide d'un appel get().

Utiliser la recherche plutôt que le rapport

La méthode du rapport a été conçue pour l'ancienne infrastructure et génère les résultats dans un format plat, même si vous utilisez GAQL. Cela signifie qu'il doit transformer les résultats de la requête pour qu'ils correspondent à l'ancien style, qui n'est pas compatible avec tous les champs et ajoute une surcharge à chaque appel.

Nous vous conseillons d'utiliser plutôt le Réseau de Recherche pour profiter de toutes les fonctionnalités des nouvelles fonctionnalités de création de rapports de l'API Google Ads.

Préférer GAQL à AWQL

Bien que le langage AWQL soit toujours accepté dans les requêtes de rapport et les appels withCondition, il est exécuté par une couche de traduction qui n'a pas une compatibilité totale avec le véritable langage AWQL. Pour contrôler totalement vos requêtes, assurez-vous d'utiliser GAQL.

Si vous souhaitez traduire des requêtes AWQL existantes, l'outil de migration des requêtes est à votre disposition.

Ne sélectionnez pas plus de lignes que nécessaire

La vitesse d'exécution des rapports (et des sélecteurs) est basée sur le nombre total de lignes qui seraient renvoyées par le rapport, que vous les ayez itérées ou non. Vous devez donc toujours utiliser des filtres spécifiques pour minimiser l'ensemble de résultats en fonction de votre cas d'utilisation.

Par exemple, imaginons que vous souhaitiez trouver des groupes d'annonces dont les enchères sont situées en dehors d'une plage spécifique. Il serait plus rapide d'effectuer deux requêtes distinctes, l'une pour les enchères inférieures au seuil minimal et l'autre pour les enchères supérieures au seuil supérieur, plutôt que d'extraire tous les groupes d'annonces et d'ignorer ceux qui ne vous intéressent pas.

Approche de codage Extrait de code
Utiliser deux requêtes (recommandé) 
var adGroups = []
var report = AdsApp.search(
    'SELECT ad_group.name, ad_group.cpc_bid_micros' +
    ' FROM ad_group WHERE ad_group.cpc_bid_micros < 1000000');

while (report.hasNext()) {
  var row = report.next();
  adGroups.push(row.adGroup);
}
var report = AdsApp.search(
    'SELECT ad_group.name, ad_group.cpc_bid_micros' +
    ' FROM ad_group WHERE ad_group.cpc_bid_micros > 2000000');

while (report.hasNext()) {
  var row = report.next();
  adGroups.push(row.adGroup);
}
Filtrer les résultats à partir d'une requête générique (non recommandé) 
var adGroups = []
var report = AdsApp.search(
    'SELECT ad_group.name, ad_group.cpc_bid_micros' +
    ' FROM ad_group');

while (report.hasNext()) {
  var row = report.next();
  var cpcBidMicros = row.adGroup.cpcBidMicros;
  if (cpcBidMicros < 1000000 || cpcBidMicros > 2000000) {
    adGroups.push(row.adGroup);
  }
}

Scripts du Gestionnaire d'annonces (CM)

Privilégier executeInParallel plutôt qu'une exécution en série

Lorsque vous écrivez des scripts pour des comptes administrateur, utilisez si possible executeInParallel() au lieu de l'exécution en série. executeInParallel() augmente le temps de traitement de votre script (jusqu'à une heure) et jusqu'à 30 minutes par compte traité (au lieu de 30 minutes combinées pour l'exécution en série). Pour en savoir plus, consultez la page sur les limites.

Feuilles de calcul

Utiliser les opérations par lot lors de la mise à jour de feuilles de calcul

Lorsque vous mettez à jour des feuilles de calcul, essayez d'utiliser les méthodes d'opérations groupées (par exemple, getRange()) plutôt que celles qui mettent à jour une cellule à la fois.

Prenons l'exemple de l'extrait de code suivant, qui génère un schéma fractal sur une feuille de calcul.

Approche de codage Extrait de code
Mettre à jour une plage de cellules en un seul appel (recommandé) 
var colors = new Array(100);
for (var y = 0; y < 100; y++) {
  xcoord = xmin;
  colors[y] = new Array(100);
  for (var x = 0; x < 100; x++) {
    colors[y][x] = getColor_(xcoord, ycoord);
    xcoord += xincrement;
  }
  ycoord -= yincrement;
}
sheet.getRange(1, 1, 100, 100).setBackgroundColors(colors);
Mettre à jour une cellule à la fois (non recommandé) 
var cell = sheet.getRange('a1');
for (var y = 0; y < 100; y++) {
  xcoord = xmin;
  for (var x = 0; x < 100; x++) {
    var c = getColor_(xcoord, ycoord);
    cell.offset(y, x).setBackgroundColor(c);
    xcoord += xincrement;
  }
  ycoord -= yincrement;
  SpreadsheetApp.flush();
}

Bien que Google Sheets tente d'optimiser le deuxième extrait de code en mettant en cache les valeurs, ses performances sont médiocres par rapport au premier, en raison du nombre d'appels d'API effectués.