Bonnes pratiques

Cette page présente différentes bonnes pratiques pour le développement avec des scripts Google Ads.

Sélecteurs

Filtrer avec des sélecteurs

Dans la mesure du possible, utilisez des filtres pour ne demander que les entités dont vous avez besoin. Application en cours l'utilisation 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 deuxième approche n'est pas recommandée, car elle tente de récupérer la liste de tous les mots clés de votre compte uniquement pour 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 collection à ce niveau au lieu de parcourir toute la hiérarchie de la campagne. En plus d'être plus simple, cette approche offre de bien meilleures performances : le système n'a pas besoin de lire toutes les campagnes et tous les groupes d'annonces inutilement.

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();
Parcourir 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 requises.

Utiliser des méthodes d'accesseur parent spécifiques

Vous devez parfois 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.
}
Parcourir 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 deuxième approche 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és à votre ensemble d'annonces. La première approche se limite à extraire uniquement la collection d'annonces pertinentes 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 dans le sélecteur au lieu d'extraire, puis de parcourir une hiérarchie.

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

Approche de codage Extrait de code
Utiliser des 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.
}
Parcourir 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 deuxième approche n'est pas recommandée, car elle itère sur la hiérarchie des campagnes et des groupes d'annonces dans 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 à la liste des annonces en appliquant un filtre spécifique pour les entités parentes sur le sélecteur.

Utiliser des ID pour le filtrage lorsque cela est possible

Lorsque vous filtrez des entités, il est préférable de le faire par ID plutôt que par d'autres champs.

Prenons les extraits de code suivants qui sélectionnent une campagne.

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

La deuxième méthode est moins optimale, car le filtrage se base sur un champ autre que l'ID.

Filtrer par ID parental si possible

Lorsque vous sélectionnez une entité, filtrez-la par ID parent dans la mesure du 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 de l'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 uniquement par ID de groupe d'annonces (moins optimal) 
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 de 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.

Utilisez des étiquettes lorsque le nombre de conditions de filtrage est trop élevé

Lorsque vous avez trop de conditions de filtrage, il est judicieux de créer une des entités que vous traitez, et utilisez-le pour filtrer 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 offrent un niveau de performances similaire, la deuxième approche a tendance à générer du 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é.

Limiter le nombre de conditions dans votre clause IN

Lors de l'exécution de scripts, il est courant d'exécuter un rapport pour obtenir une liste entités. Pour ce faire, les développeurs créent généralement Requête AWQL qui filtre les ID d'entité à l'aide d'une clause IN Cette approche fonctionne très bien lorsque le nombre d'entités est limité. Cependant, comme la longueur de votre requête augmente, les performances de votre script se dégradent pour la raison suivante : raisons:

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

Dans ce cas, 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 de la 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 du 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 essaie de combiner plusieurs modifications dans par lot, afin d'émettre une requête unique effectuant plusieurs modifications. Cette approche accélère vos scripts et réduit la charge sur les serveurs Google Ads. Toutefois, certains modèles de code obligent les scripts Google Ads à vider fréquemment leur lot d'opérations, ce qui ralentit l'exécution de votre script.

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
Suivre les é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 seconde méthode n'est pas recommandée, car l'appel de la méthode keyword.bidding().getCpc() force les scripts Google Ads à vider setCpc() opération et n'exécute qu'une seule opération à la fois. La première approche, bien que semblable à la seconde, présente l'avantage supplémentaire 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 permettent de créer des objets de deux manières : avec des outils de création et des méthodes de création. Les générateurs 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 recommandée en raison de l'opération de sélection supplémentaire impliquée dans la récupération du mot clé. De plus, les méthodes de création sont également obsolètes.

Toutefois, gardez à l'esprit que lorsqu'ils sont mal utilisés, les compilateurs peuvent empêcher d'effectuer des opérations par lot à l'aide des scripts d'annonces.

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

Approche de codage Extrait de code
Suivre les é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 méthode est déconseillée, car elle appelle operation.getResult(). dans la boucle qui crée l'opération, forçant ainsi les scripts Google Ads à exécuter pour exécuter une opération à la fois. Bien que similaire, la première approche permet par lot, puisque nous appelons la méthode operation.getResult() dans une boucle différente de celle où où il a été créé.

Pensez à effectuer des importations groupées pour les mises à jour volumineuses

Les développeurs effectuent souvent des tâches telles que générer des rapports et mettre à jour les propriétés des entités (par exemple, les enchères sur les 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 MaxCpc des mots clés dont le TopImpressionPercentage > 0.4 du mois dernier est le suivant :

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 modifier des mots clés par ID (moins optimal) 
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);
  }
}

Alors que la deuxième méthode permet d'obtenir de très bons résultats, la première est à privilégier dans ce cas,

  • Le nombre d'objets pouvant être récupérés dans les scripts Google Ads est limité ou mis à jour en une seule exécution, et les opérations de sélection et de mise à jour dans une seconde approche est comptabilisé dans cette limite.

  • Les importations groupées sont soumises à des limites plus élevées, tant en termes de nombre d'entités pouvant être mises à jour que de durée d'exécution globale.

Regrouper vos importations groupées par campagnes

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

Imaginons deux tâches d'importation groupée exécutées en parallèle. L'un met en veille les annonces d'une annonce. group; l'autre ajuste les enchères de mot clé. Même si les opérations ne sont pas liées, les opérations peuvent s'appliquer à des entités appartenant au même groupe d'annonces (ou à deux groupes d'annonces de la même campagne). Dans ce cas, le système verrouille l'entité parente (campagne ou groupe d'annonces partagés), entraînant ainsi l'importation groupée. des tâches à bloquer les unes sur les autres.

Les scripts Google Ads permettent d'optimiser l'exécution d'une même tâche d'importation groupée. la plus simple consiste à exécuter une seule tâche d'importation groupée par compte à la fois. Si vous décidez d'effectuer plusieurs importations groupées par compte, garantir que les importations groupées fonctionnent sur la base d'une liste de campagnes mutuellement exclusive ; (et leurs entités enfants) pour des performances optimales.

Rapports

Utiliser des rapports pour extraire des 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. Nous vous recommandons d'utiliser des rapports pour les raisons suivantes :

  • Les rapports offrent de meilleures performances pour les requêtes volumineuses.
  • Les rapports n'atteindront pas les quotas de récupération normaux.

Comparez les extraits de code suivants qui récupèrent les métriques "Clics", "Impressions" Coût et texte de tous les mots clés ayant enregistré plus de 50 clics le mois dernier:

Approche de codage Extrait de code
Utiliser des 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 seconde méthode est déconseillée, car elle effectue une itération sur les mots clés. et récupère les statistiques une entité à la fois. Les rapports sont plus rapides car il récupère toutes les données en un seul appel et les diffuse obligatoire. De plus, les mots clés récupérés dans la deuxième 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 de création de rapports a été conçue pour l'ancienne infrastructure et génère des résultats au 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 suggérons d'utiliser la recherche pour profiter de toutes les fonctionnalités des nouveaux rapports de l'API Google Ads.

Préférer GAQL à AWQL

Bien qu'AWQL soit toujours accepté dans les requêtes de rapport et les appels withCondition, il est exécuté via une couche de traduction qui n'est pas entièrement compatible en exploitant pleinement le langage AWQL. Pour avoir un contrôle total sur vos requêtes, assurez-vous à l'aide de GAQL.

Si vous souhaitez traduire des requêtes AWQL, vous pouvez consulter le l'outil de migration.

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 susceptibles d'être renvoyées par le rapport, que vous modifiiez ou non et de les parcourir. Vous devez donc toujours utiliser des filtres spécifiques pour réduire au maximum l'ensemble de résultats selon votre cas d'utilisation.

Par exemple, imaginons que vous souhaitiez trouver des groupes d'annonces dont les enchères ne se situent pas dans une plage spécifique. Il serait plus rapide d'effectuer deux requêtes distinctes, une pour les enchères. sous le seuil inférieur et un autre pour les enchères supérieures au seuil supérieur, il peut extraire tous les groupes d'annonces et ignorer ceux que vous n'utilisez pas. qui vous intéressent.

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 à 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 Ads Manager (CM)

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

Lorsque vous écrivez des scripts pour des comptes administrateur, utilisez plutôt executeInParallel() d'exécution en série lorsque cela est possible. executeInParallel() améliore votre script (jusqu'à une heure) et jusqu'à 30 minutes par compte. (au lieu de 30 minutes combinées pour les exécutions en série). Consultez nos limites pour en savoir plus.

Feuilles de calcul

Utiliser des 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ération groupée. (par exemple, getRange()) par rapport aux méthodes qui mettent à jour une cellule à la fois.

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

Approche de codage Extrait de code
Modifier 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, il offre toujours de mauvaises performances par rapport au premier extrait, en raison du nombre d'appels d'API effectués.