Best practice

In questa pagina vengono illustrate varie best practice per lo sviluppo con gli script Google Ads.

Selettori

Filtrare con i selettori

Se possibile, utilizza i filtri per richiedere solo le entità di cui hai bisogno. Applicazione in corso filtri corretti presentano i seguenti vantaggi:

  • Il codice è più semplice e facile da comprendere.
  • Lo script verrà eseguito molto più rapidamente.

Confronta i seguenti snippet di codice:

Approccio alla programmazione Snippet di codice
Filtrare i dati utilizzando i selettori (opzione consigliata) 
var keywords = AdsApp.keywords()
    .withCondition('Clicks > 10')
    .forDateRange('LAST_MONTH')
    .get();
while (keywords.hasNext()) {
  var keyword = keywords.next();
  // Do work here.
}
Filtro nel codice (non consigliato) 
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.
  }
}

Il secondo approccio non è consigliato perché tenta di recuperare l'elenco a tutte le parole chiave dell'account per applicare un filtro all'elenco.

Evita di attraversare la gerarchia delle campagne

Quando vuoi recuperare entità a un determinato livello, utilizza una raccolta a quel livello, invece di attraversare l'intera gerarchia della campagna. Oltre a essere più semplice, avrà anche un rendimento molto migliore: il sistema non dovrà leggere inutilmente tutte le campagne e tutti i gruppi di annunci.

Confronta i seguenti snippet di codice che recuperano tutti gli annunci nel tuo account:

Approccio alla programmazione Snippet di codice
Utilizzare il metodo di raccolta appropriato (consigliato) 
var ads = AdsApp.ads();
Attraversa la gerarchia (opzione sconsigliata) 
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.
  }
}

Il secondo approccio non è consigliato perché tenta di recuperare intere gerarchie di oggetti (campagne, gruppi di annunci), mentre sono richiesti solo gli annunci.

Utilizzare metodi specifici della funzione di accesso padre

A volte è necessario ottenere l'entità principale di un oggetto recuperato. In questo caso, devi utilizzare un metodo di accesso fornito anziché recuperare intere gerarchie.

Confronta i seguenti snippet di codice che recuperano i gruppi di annunci con annunci di testo con più di 50 clic il mese scorso:

Approccio alla programmazione Snippet di codice
Utilizzare il metodo appropriato della funzione di accesso genitore (consigliato) 
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.
}
Attraversa la gerarchia (opzione non consigliata) 
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.
    }
  }
}

Il secondo approccio non è consigliato in quanto consente di recuperare l'intera campagna di gruppi di annunci e gerarchie di gruppi di annunci nel tuo account, mentre campagne e gruppi di annunci associati all'insieme di annunci. Il primo si limita a recuperare solo la raccolta di annunci pertinente, e usa un metodo appropriato per accedere agli oggetti principali.

Utilizzare filtri principali specifici

Per accedere alle entità all'interno di una campagna o di un gruppo di annunci specifico, utilizza una specifica nel selettore invece di recuperare e poi attraversare una gerarchia.

Confronta i seguenti snippet di codice che recuperano l'elenco degli annunci di testo all'interno di una campagna e di un gruppo di annunci specificati con più di 50 clic nell'ultimo mese.

Approccio alla programmazione Snippet di codice
Utilizzare filtri a livello di entità principale appropriati (consigliato) 
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.
}
Eseguire la scansione della gerarchia (opzione non consigliata) 
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.
    }
  }
}

Il secondo approccio non è consigliato perché esegue l'iterazione sulla gerarchia delle campagne e dei gruppi di annunci nel tuo account, mentre ti serve solo un insieme selezionato di annunci e le relative campagne e gruppi di annunci principali. Il primo approccio limita iterazione all'elenco di annunci applicando un filtro specifico per le entità principali sul selettore.

Se possibile, utilizza gli ID per l'applicazione di filtri

Quando filtri per entità, è preferibile filtrare per ID anziché per altri campi.

Prendi in considerazione i seguenti snippet di codice che selezionano una campagna.

Approccio alla programmazione Snippet di codice
Filtrare in base all'ID (opzione consigliata) 
var campaign = AdsApp.campaigns()
    .withIds([12345])
    .get()
    .next();
Filtro per nome (meno ottimale) 
var campaign = AdsApp.campaigns()
    .withCondition('Name="foo"')
    .get()
    .next();

Il secondo approccio è meno ottimale perché filtriamo in base a un campo diverso dall'ID.

Filtra per ID genitori, se possibile

Quando selezioni un'entità, filtra in base agli ID principali, se possibile. In questo modo, le query verranno eseguite più rapidamente perché l'elenco delle entità recuperate dai server viene limitato durante il filtraggio dei risultati.

Considera il seguente snippet di codice che recupera un gruppo di annunci in base al suo ID. Supponiamo che l'ID campagna principale sia noto.

Approccio alla programmazione Snippet di codice
Filtrare per ID campagna e gruppo di annunci (consigliato) 
var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .withCondition('CampaignId="54678"')
    .get()
    .next();
Filtrare solo in base all'ID gruppo di annunci (meno ottimale) 
var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .get()
    .next();

Anche se entrambi gli snippet di codice forniscono risultati identici, se applichi il filtro nello snippet di codice 1 utilizzando un ID principale (CampaignId="54678"), codice più efficiente limitando l'elenco di entità di cui il server da ripetere durante il filtraggio dei risultati.

Utilizzare le etichette quando sono presenti troppe condizioni di filtro

Quando ci sono troppe condizioni di filtro, è una buona idea creare un'immagine per le entità elaborate e utilizzala per filtrare le entità.

Prendi in considerazione il seguente snippet di codice che recupera un elenco di campagne per nome.

Approccio alla programmazione Snippet di codice
Utilizzare un'etichetta (opzione consigliata) 
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
}
Crea selettori complessi (sconsigliato) 
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.
}

Sebbene entrambi gli snippet di codice offrano un livello di prestazioni simile, il secondo approccio tende a generare codice più complesso con l'aumento del numero di condizioni nel selettore. Inoltre, è più facile applicare l'etichetta a una nuova entità rispetto alla modifica dello script per includere una nuova entità.

Limita il numero di condizioni nella clausola IN

Quando esegui gli script, un caso d'uso comune è eseguire un report per un elenco di entità. Di solito gli sviluppatori realizzano questo risultato costruendo una Query AWQL che filtra in base agli ID entità utilizzando una clausola IN. Questo approccio funziona bene se il numero di entità è limitato. Tuttavia, con l'aumento della lunghezza della query, il rendimento dello script peggiora per due motivi:

  • L'analisi di una query più lunga richiede più tempo.
  • Ogni ID aggiunto a una clausola IN è una condizione aggiuntiva da valutare e quindi richiede più tempo.

In queste condizioni, è preferibile applicare un'etichetta alle entità e poi filtrare in base a LabelId.

Approccio alla programmazione Snippet di codice
Applicare un'etichetta e filtrare per labelID (opzione consigliata) 
// 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() + '"');
Creare una query lunga utilizzando la clausola IN (opzione non consigliata) 
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…)');

Aggiornamenti sull'account

Modifiche collettive

Quando apporti modifiche a un'entità Google Ads, gli script Google Ads non eseguono immediatamente la modifica. Prova invece a combinare più modifiche i batch, in modo da poter emettere una singola richiesta che fa più modifiche. Questo approccio velocizza gli script e riduce il carico su Google Ads server web. Tuttavia, esistono alcuni pattern di codice che obbligano gli script Google Ads a far svuotare frequentemente il suo batch di operazioni, causando così l'esecuzione dello script lentamente.

Considera lo script riportato di seguito che aggiorna le offerte di un elenco di parole chiave.

Approccio alla programmazione Snippet di codice
Tenere traccia degli elementi aggiornati (opzione consigliata) 
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());
}
Recupero degli elementi aggiornati in un ciclo stretto (opzione non consigliata) 
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());
}

Il secondo approccio non è consigliato poiché la chiamata keyword.bidding().getCpc() obbliga gli script Google Ads a svuotare setCpc() operativa ed eseguire una sola operazione alla volta. Il primo approccio, sebbene simile al secondo, ha il vantaggio aggiuntivo di supportare il raggruppamento poiché la chiamata getCpc() viene eseguita in un loop separato da quello in cui viene chiamata setCpc().

Utilizza i generatori quando possibile

Gli script Google Ads supportano due modi per creare nuovi oggetti: builder e creazione di machine learning. I builder sono più flessibili dei metodi di creazione, in quanto all'oggetto creato dalla chiamata API.

Considera i seguenti snippet di codice:

Approccio alla programmazione Snippet di codice
Utilizzare i generatori (opzione consigliata) 
var operation = adGroup.newKeywordBuilder()
    .withText('shoes')
    .build();
var keyword = operation.getResult();
Utilizzare i metodi di creazione (non consigliato) 
adGroup.createKeyword('shoes');
var keyword = adGroup.keywords()
    .withCondition('KeywordText="shoes"')
    .get()
    .next();

L'operazione di selezione aggiuntiva non è consigliata per il secondo approccio che implica il recupero della parola chiave. Inoltre, i metodi di creazione ritirato.

Tuttavia, tieni presente che i builder, se utilizzati in modo errato, possono impedire a Google Gli script di annunci raggruppano le relative operazioni.

Considera i seguenti snippet di codice che creano un elenco di parole chiave e stampano l'ID delle parole chiave appena create:

Approccio alla programmazione Snippet di codice
Tenere traccia degli elementi aggiornati (opzione consigliata) 
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());
}
Recuperare gli elementi aggiornati in un loop stretto (sconsigliato) 
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());
}

Il secondo approccio non è preferito perché chiama operation.getResult() nello stesso loop che crea l'operazione, forzando così gli script Google Ads di eseguire un'operazione alla volta. Il primo approccio, pur essendo simile, consente il batching poiché chiamiamo operation.getResult() in un ciclo diverso da quello in cui è stato creato.

Valuta la possibilità di utilizzare i caricamenti collettivi per gli aggiornamenti di grandi dimensioni

Un'attività comune svolta dagli sviluppatori è eseguire report e aggiornare le proprietà delle entità (ad es. le offerte per parole chiave) in base ai valori di rendimento correnti. Quando devi aggiornare molte entità, i caricamenti collettivi tendono a fornire prestazioni migliori. Ad esempio, considera i seguenti script che aumentano il CPC max delle parole chiave per le quali TopImpressionPercentage > 0.4 per l'ultimo mese:

Approccio alla programmazione Snippet di codice
Utilizzare il caricamento collettivo (opzione consigliata) 
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();
Selezionare e aggiornare le parole chiave per ID (meno ottimale) 
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);
  }
}

Sebbene il secondo approccio offra prestazioni abbastanza buone, in questo caso è preferibile il primo approccio poiché

  • Gli script Google Ads hanno un limite al numero di oggetti che possono essere recuperati o aggiornati in una singola esecuzione e le operazioni di selezione e aggiornamento nel secondo approccio vengono conteggiate ai fini di questo limite.

  • I caricamenti collettivi hanno limiti più elevati sia in termini di numero di entità che possono essere aggiornate sia in termini di tempo di esecuzione complessivo.

Raggruppa i caricamenti collettivi per campagne

Quando crei i caricamenti collettivi, prova a raggruppare le operazioni in base all'istanza principale campagna. In questo modo aumenti l'efficienza e riduci le probabilità di modifiche/errori di concorrenza in conflitto.

Considera due attività di caricamento collettivo eseguite in parallelo. Uno mette in pausa gli annunci di un annuncio group; l'altra aggiusta le offerte per parola chiave. Anche se le operazioni non sono correlate, possono essere applicate a entità nello stesso gruppo di annunci (o a due gruppi di annunci diversi nella stessa campagna). In questo caso, il sistema bloccherà l'entità principale (la campagna o il gruppo di annunci condivisi) che genera il caricamento collettivo. bloccare a vicenda attività.

Gli script Google Ads possono ottimizzare l'esecuzione all'interno di una singola attività di caricamento collettivo, la cosa più semplice da fare è eseguire una sola attività di caricamento collettivo per account una volta. Se decidi di eseguire più di un caricamento collettivo per account, assicurati che i caricamenti collettivi funzionino su un elenco di campagne mutuamente esclusive (e delle relative entità secondarie) per un rendimento ottimale.

Rapporti

Utilizzare i report per recuperare le statistiche

Quando vuoi recuperare grandi quantità di entità e le relative statistiche, spesso è meglio utilizzare i report anziché i metodi AdsApp standard. L'uso di report è preferibile per i seguenti motivi:

  • I report offrono un rendimento migliore per le query di grandi dimensioni.
  • I report non raggiungeranno le normali quote di recupero.

Confronta i seguenti snippet di codice che recuperano clic, impressioni Costo e testo di tutte le parole chiave che hanno ricevuto più di 50 clic il mese scorso:

Approccio alla programmazione Snippet di codice
Utilizzare i report (opzione consigliata) 
  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);
  }
Utilizzare gli iteratori AdsApp (non consigliato) 
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());
}

Il secondo approccio non è preferito perché esegue l'iterazione sulle parole chiave e recupera le statistiche una entità alla volta. In questo caso, i report hanno un rendimento migliore poiché recuperano tutti i dati in una singola chiamata e li trasmettono in streaming in base alle esigenze. Inoltre, le parole chiave recuperate nel secondo approccio vengono conteggiate ai fini della quota dello script per il numero di entità recuperate utilizzando una chiamata get().

Utilizza la ricerca al posto del report

Il metodo del report è stato creato per la vecchia infrastruttura e restituirà risultati in formato flat anche se utilizzi GAQL. Ciò significa che deve trasformare i risultati della query in modo che corrispondano al vecchio stile, che non è supportato per tutti i campi e aggiunge un overhead a ogni chiamata.

Ti consigliamo di utilizzare la ricerca per sfruttare tutte le funzionalità dei nuovi report dell'API Google Ads.

Preferire GAQL ad AWQL

Sebbene AWQL sia ancora supportato nelle query dei report e nelle chiamate withCondition, viene eseguito tramite un livello di traduzione che non è completamente compatibile con il vero AWQL. Per avere il controllo completo sulle query, assicurati di avere utilizzando GAQL.

Se hai query AWQL esistenti che vuoi tradurre, abbiamo uno strumento di migrazione delle query che può aiutarti.

Non selezionare più righe del necessario

La velocità di esecuzione dei report (e dei selettori) si basa sul numero totale di righe che verrebbero restituite dal report, indipendentemente dal fatto che le esamini o meno. Ciò significa che devi sempre utilizzare filtri specifici per ridurre al minimo il set di risultati in modo che corrisponda al tuo caso d'uso.

Ad esempio, supponiamo che tu voglia trovare gruppi di annunci con offerte al di fuori di un determinato intervallo. Sarebbe più veloce effettuare due query distinte, una per le offerte inferiore alla soglia inferiore e un'altra per le offerte superiori alla soglia superiore, rispetto recuperare tutti i gruppi di annunci e ignorare quelli che non che ti interessa.

Approccio alla programmazione Snippet di codice
Utilizzare due query (opzione consigliata) 
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);
}
Applicare un filtro da una query generica (opzione non consigliata) 
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);
  }
}

Script di Google Ads Manager (Centro clienti)

Preferisci executeInParallel all'esecuzione seriale

Quando scrivi script per gli account amministratore, utilizza executeInParallel() anziché l'esecuzione seriale, se possibile. executeInParallel() offre allo script più tempo di elaborazione (fino a un'ora) e fino a 30 minuti per account elaborato (anziché 30 minuti combinati per l'esecuzione seriale). Per ulteriori dettagli, consulta la nostra pagina relativa ai limiti.

Fogli di lavoro

Utilizzare le operazioni collettive per aggiornare i fogli di lavoro

Quando aggiorni i fogli di lavoro, prova a utilizzare i metodi delle operazioni collettive (ad esempio, getRange()) rispetto ai metodi che aggiornano una cella alla volta.

Considera il seguente snippet di codice che genera un pattern frattale in un foglio di lavoro.

Approccio alla programmazione Snippet di codice
Aggiornare un intervallo di celle in una singola chiamata (consigliato) 
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);
Aggiornare una cella alla volta (opzione non consigliata) 
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();
}

Mentre i fogli di lavoro Google cercano di ottimizzare il secondo snippet di codice memorizzando nella cache di conversione, ma offre comunque un rendimento scarso rispetto al primo snippet, al numero di chiamate API effettuate.