Best Practices

Auf dieser Seite finden Sie verschiedene Best Practices für die Entwicklung mit Google Ads-Skripts.

Selektoren

Filterung mit Selektoren

Verwenden Sie nach Möglichkeit Filter, um nur benötigte Entitäten anzufordern. Das Anwenden geeigneter Filter hat folgende Vorteile:

• Der Code ist einfacher und leichter zu verstehen.
• Das Skript wird viel schneller ausgeführt.

Vergleichen Sie die folgenden Code-Snippets:

var keywords = AdsApp.keywords()
    .withCondition('Clicks > 10')
    .forDateRange('LAST_MONTH')
    .get();
while (keywords.hasNext()) {
  var keyword = keywords.next();
  // Do work here.
}

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.
  }
}

Die zweite Methode ist nicht empfehlenswert, da versucht wird, die Liste aller Keywords in Ihrem Konto abzurufen, um dann einen Filter auf die Liste anzuwenden.

Kampagnenhierarchie nicht durchlaufen

Wenn Sie Entitäten auf einer bestimmten Ebene abrufen möchten, verwenden Sie eine Sammlungsmethode auf dieser Ebene, anstatt die gesamte Kampagnenstruktur zu durchlaufen. Das ist nicht nur einfacher, sondern auch viel leistungsfähiger, da das System nicht alle Kampagnen und Anzeigengruppen unnötig einlesen muss.

Vergleichen Sie die folgenden Code-Snippets, mit denen alle Anzeigen in Ihrem Konto abgerufen werden:

var ads = AdsApp.ads();

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.
  }
}

Der zweite Ansatz wird nicht empfohlen, da versucht wird, ganze Hierarchien von Objekten (Kampagnen, Anzeigengruppen) abzurufen, wenn nur Anzeigen erforderlich sind.

Spezifische übergeordnete Zugriffsmethoden verwenden

Manchmal benötigen Sie die übergeordnete Entität eines abgerufenen Objekts. In diesem Fall sollten Sie eine bereitgestellte Zugriffsmethode verwenden, anstatt ganze Hierarchien abzurufen.

Vergleichen Sie die folgenden Code-Snippets, mit denen die Anzeigengruppen abgerufen werden, die im letzten Monat Textanzeigen mit mehr als 50 Klicks hatten:

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.
}

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.
    }
  }
}

Der zweite Ansatz wird nicht empfohlen, da dabei die gesamten Kampagnen- und Anzeigengruppenhierarchien in Ihrem Konto abgerufen werden, obwohl Sie nur eine Teilmenge der Kampagnen und Anzeigengruppen benötigen, die mit Ihren Anzeigen verknüpft sind. Der erste Ansatz beschränkt sich darauf, nur die relevante Anzeigensammlung abzurufen, und verwendet eine geeignete Methode, um auf die übergeordneten Objekte zuzugreifen.

Filter für bestimmte übergeordnete Elemente

Wenn Sie auf Entitäten innerhalb einer bestimmten Kampagne oder Anzeigengruppe zugreifen möchten, verwenden Sie einen bestimmten Filter im Selektor, anstatt die Entitäten abzurufen und dann eine Hierarchie zu durchlaufen.

Vergleichen Sie die folgenden Code-Snippets, mit denen die Liste der Textanzeigen in einer bestimmten Kampagne und Anzeigengruppe abgerufen wird, die im letzten Monat mehr als 50 Klicks erzielt haben.

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.
}

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.
    }
  }
}

Die zweite Methode wird nicht empfohlen, da die Kampagnen- und Anzeigengruppenhierarchie in Ihrem Konto durchlaufen wird, obwohl Sie nur eine ausgewählte Gruppe von Anzeigen sowie die zugehörigen Kampagnen und Anzeigengruppen benötigen. Beim ersten Ansatz wird die Iteration auf die Liste der Anzeigen beschränkt, indem ein bestimmter Filter für übergeordnete Entitäten auf die Auswahl angewendet wird.

Nach Möglichkeit IDs zum Filtern verwenden

Wenn Sie nach Entitäten filtern, sollten Sie nach Entitäten anhand ihrer IDs statt nach anderen Feldern filtern.

Sehen Sie sich die folgenden Code-Snippets zur Auswahl einer Kampagne an:

var campaign = AdsApp.campaigns()
    .withIds([12345])
    .get()
    .next();

var campaign = AdsApp.campaigns()
    .withCondition('Name="foo"')
    .get()
    .next();

Die zweite Methode ist weniger geeignet, weil nach einem anderen Feld als der ID gefiltert wird.

Nach Möglichkeit nach übergeordneten IDs filtern

Filtern Sie zur Auswahl einer Entität nach Möglichkeit nach übergeordneten IDs. Dadurch werden Ihre Abfragen schneller, da die Liste der Entitäten, die von den Servern beim Filtern der Ergebnisse abgerufen werden, begrenzt wird.

Sehen Sie sich das folgende Code-Snippet an, mit dem eine AdGroup anhand ihrer ID abgerufen wird. Angenommen, die ID der übergeordneten Kampagne ist bekannt.

var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .withCondition('CampaignId="54678"')
    .get()
    .next();

var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .get()
    .next();

Obwohl beide Code-Snippets identische Ergebnisse liefern, wird der Code durch die zusätzliche Filterung in Code-Snippet 1 mit einer übergeordneten ID (CampaignId="54678") effizienter, da die Liste der Entitäten, die der Server beim Filtern der Ergebnisse durchlaufen muss, eingeschränkt wird.

Bei zu vielen Filterbedingungen Labels verwenden

Wenn Sie zu viele Filterbedingungen haben, ist es ratsam, ein Label für die verarbeiteten Einheiten zu erstellen und dieses Label zum Filtern der Einheiten zu verwenden.

Betrachten Sie das folgende Code-Snippet, mit dem eine Liste von Kampagnen anhand ihres Namens abgerufen wird.

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
}

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.
}

Beide Code-Snippets bieten eine ähnliche Leistung, aber der zweite Ansatz führt tendenziell zu komplexerem Code, wenn die Anzahl der Bedingungen in Ihrem Selektor steigt. Außerdem ist es einfacher, das Label auf eine neue Einheit anzuwenden, als das Skript zu bearbeiten, um eine neue Einheit einzufügen.

Anzahl der Bedingungen in einer IN-Klausel beschränken

Ein häufiger Anwendungsfall beim Ausführen von Scripts ist das Erstellen eines Berichts für eine Liste von Einheiten. Entwickler erreichen dies in der Regel, indem sie eine sehr lange GAQL-Abfrage erstellen, die die Entitäts-IDs mit einer IN-Klausel filtert. Dieser Ansatz funktioniert gut, wenn die Anzahl der Entitäten begrenzt ist. Mit zunehmender Länge der Abfrage verschlechtert sich die Skriptleistung jedoch aus zwei Gründen:

• Bei einer umfangreicheren Abfrage dauert das Parsen länger.
• Jede ID, die Sie einer IN-Klausel hinzufügen, ist eine zusätzliche Bedingung, die ausgewertet werden muss, und dauert daher länger.

Unter solchen Umständen ist es besser, ein Label auf die Entitäten anzuwenden und dann nach LabelId zu filtern.

// 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() + '"');

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…)');

Kontoänderungen

Batch-Änderungen

Wenn Sie Änderungen an einer Google Ads-Entität vornehmen, werden diese nicht sofort von Google Ads-Scripts ausgeführt. Stattdessen wird versucht, mehrere Änderungen in Batches zusammenzufassen, sodass eine einzelne Anfrage mit mehreren Änderungen gesendet werden kann. So werden Ihre Skripts schneller ausgeführt und die Last auf den Google Ads-Servern wird reduziert. Es gibt jedoch einige Codemuster, die Google Ads-Skripts dazu zwingen, den Batch von Vorgängen häufig zu leeren, was dazu führt, dass Ihr Skript langsam ausgeführt wird.

Sehen Sie sich das folgende Code-Snippet zur Aktualisierung der Gebote einer Keyword-Liste an:

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());
}

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());
}

Die zweite Methode wird nicht empfohlen, da durch den Aufruf von keyword.bidding().getCpc() Google Ads-Scripts gezwungen werden, den setCpc()-Vorgang zu leeren und jeweils nur einen Vorgang auszuführen. Der erste Ansatz ähnelt dem zweiten, bietet aber den zusätzlichen Vorteil, dass Batching unterstützt wird, da der getCpc()-Aufruf in einer separaten Schleife erfolgt als der, in der setCpc() aufgerufen wird.

Nach Möglichkeit Generatoren verwenden

Google Ads-Scripts unterstützen zwei Möglichkeiten zum Erstellen neuer Objekte: Builder und Erstellungsmethoden. Builder sind flexibler als Erstellungsmethoden, da Sie damit Zugriff auf das Objekt erhalten, das über den API-Aufruf erstellt wird.

Sehen Sie sich die folgenden Code-Snippets an:

var operation = adGroup.newKeywordBuilder()
    .withText('shoes')
    .build();
var keyword = operation.getResult();

adGroup.createKeyword('shoes');
var keyword = adGroup.keywords()
    .withCondition('KeywordText="shoes"')
    .get()
    .next();

Die zweite Methode wird nicht bevorzugt, da für das Abrufen des Keywords ein zusätzlicher Auswahlvorgang erforderlich ist. Außerdem werden Erstellungsmethoden eingestellt.

Wenn sie jedoch falsch verwendet werden, kann das dazu führen, dass Google Ads-Scripts keine Batchvorgänge ausführen.

Sehen Sie sich die folgenden Code-Snippets an, mit denen eine Liste von Keywords erstellt und die ID der neu erstellten Keywords ausgegeben wird:

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());
}

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());
}

Der zweite Ansatz ist nicht zu empfehlen, da operation.getResult() innerhalb derselben Schleife aufgerufen wird, in der der Vorgang erstellt wird. Dadurch werden Google Ads-Skripts gezwungen, jeweils nur einen Vorgang auszuführen. Der erste Ansatz ist zwar ähnlich, ermöglicht aber die Batchverarbeitung, da wir „operation.getResult()“ in einer anderen Schleife aufrufen als der, in der er erstellt wurde.

Bulk-Uploads für umfangreiche Aktualisierungen

Eine häufige Aufgabe von Entwicklern ist es, Berichte zu erstellen und Entitätsattribute (z. B. Keyword-Gebote) basierend auf aktuellen Leistungswerten zu aktualisieren. Wenn Sie eine große Anzahl von Entitäten aktualisieren müssen, bieten Bulk-Uploads in der Regel eine bessere Leistung. Betrachten Sie beispielsweise die folgenden Scripts, die den MaxCpc von Keywords erhöhen, deren TopImpressionPercentage > 0.4 im letzten Monat:

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();

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);
  }
}

Der zweite Ansatz bietet zwar eine ziemlich gute Leistung, der erste Ansatz ist jedoch in diesem Fall vorzuziehen, da

• In Google Ads-Scripts ist die Anzahl der Objekte, die in einer einzelnen Ausführung abgerufen oder aktualisiert werden können, begrenzt. Die Auswahl- und Aktualisierungsvorgänge im zweiten Ansatz werden auf dieses Limit angerechnet.

• Für Bulk-Uploads gelten höhere Limits sowohl hinsichtlich der Anzahl der zu aktualisierenden Einheiten als auch der Gesamtausführungszeit.

Bulk-Uploads nach Kampagnen gruppieren

Wenn Sie Bulk-Uploads erstellen, sollten Sie die Vorgänge nach der übergeordneten Kampagne gruppieren. Dies erhöht die Effizienz und verringert die Wahrscheinlichkeit von widersprüchlichen Änderungen und Nebenläufigkeitsfehlern.

Sehen wir uns zwei Bulk-Upload-Tasks an, die gleichzeitig ausgeführt werden. Bei der einen werden Anzeigen in einer Anzeigengruppe pausiert, bei der anderen werden Keyword-Gebote angepasst. Auch wenn die Vorgänge nicht zusammenhängen, können sie sich auf Entitäten in derselben Anzeigengruppe (oder in zwei verschiedenen Anzeigengruppen in derselben Kampagne) beziehen. In diesem Fall wird die übergeordnete Einheit (die gemeinsame Anzeigengruppe oder Kampagne) gesperrt, sodass sich die Bulk-Upload-Aufgaben gegenseitig blockieren.

Google Ads-Skripts können die Ausführung innerhalb einer einzelnen Bulk-Upload-Aufgabe optimieren. Am einfachsten ist es daher, jeweils nur eine Bulk-Upload-Aufgabe pro Konto auszuführen. Wenn Sie mehr als einen Bulk-Upload pro Konto ausführen, sollten Sie darauf achten, dass die Bulk-Uploads auf sich gegenseitig ausschließende Listen von Kampagnen (und deren untergeordneten Entitäten) angewendet werden, um eine optimale Leistung zu erzielen.

Berichte

Berichte zum Abrufen von Statistiken verwenden

Wenn Sie große Mengen an Entitäten und deren Statistiken abrufen möchten, ist es oft besser, Berichte anstelle von Standard-AdsApp-Methoden zu verwenden. Die Verwendung von Berichten wird aus folgenden Gründen bevorzugt:

• Berichte erzielen bei großen Abfragen eine bessere Leistung.
• Berichte werden nicht auf die normalen Abrufkontingente angerechnet.

Vergleichen Sie die folgenden Code-Snippets, mit denen die Klicks, Impressionen, Kosten und der Text aller Keywords abgerufen werden, die im letzten Monat mehr als 50 Klicks erhalten haben:

  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);
  }

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());
}

Der zweite Ansatz ist nicht zu empfehlen, da er die Keywords durchläuft und die Statistiken für jede Entität einzeln abruft. Berichte werden in diesem Fall schneller ausgeführt, da alle Daten in einem einzigen Aufruf abgerufen und nach Bedarf gestreamt werden. Außerdem werden die im zweiten Ansatz abgerufenen Keywords auf das Kontingent Ihres Scripts für die Anzahl der Entitäten angerechnet, die mit einem get()-Aufruf abgerufen werden.

Suche statt Bericht verwenden

Die Berichtsmethode wurde für die alte Infrastruktur entwickelt und gibt Ergebnisse in einem flachen Format aus, auch wenn Sie GAQL verwenden. Das bedeutet, dass die Ergebnisse der Abfrage an den alten Stil angepasst werden müssen. Das wird nicht für alle Felder unterstützt und führt zu zusätzlichem Aufwand bei jedem Aufruf.

Wir empfehlen Ihnen, stattdessen die Suche zu verwenden, um alle Funktionen der neuen Google Ads API-Berichterstellung zu nutzen.

GAQL gegenüber AWQL bevorzugen

AWQL funktioniert zwar technisch noch für Berichtsabfragen und withCondition-Aufrufe, wird aber nicht empfohlen. Wenn Sie die vollständige Kontrolle über Ihre Abfragen haben möchten, sollten Sie stattdessen GAQL verwenden.

Nicht mehr Zeilen als nötig auswählen

Die Geschwindigkeit, mit der Berichte (und Selektoren) ausgeführt werden, hängt von der Gesamtzahl der Zeilen ab, die der Bericht zurückgeben würde, unabhängig davon, ob Sie sie durchlaufen. Sie sollten also immer spezifische Filter verwenden, um die Ergebnismenge so weit wie möglich zu minimieren, damit sie Ihrem Anwendungsfall entspricht.

Angenommen, Sie möchten Anzeigengruppen mit Geboten außerhalb eines bestimmten Bereichs finden. Es ist schneller, zwei separate Abfragen zu erstellen – eine für Gebote unter dem unteren Grenzwert und eine für Gebote über dem oberen Grenzwert – als alle Anzeigengruppen abzurufen und die zu ignorieren, die Sie nicht interessieren.

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);
}

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);
  }
}

Google Ads-Verwaltungskonto-Skripts

executeInParallel besser als serielle Ausführung

Verwenden Sie beim Schreiben von Scripts für Verwaltungskonten nach Möglichkeit executeInParallel() anstelle der seriellen Ausführung. executeInParallel() bietet Ihrem Script mehr Verarbeitungszeit (bis zu einer Stunde) und bis zu 30 Minuten pro verarbeitetem Konto (anstatt 30 Minuten insgesamt für die serielle Ausführung). Weitere Informationen finden Sie auf unserer Seite zu den Einschränkungen.

Tabellen

Batch-Operationen zur Aktualisierung von Tabellen

Verwenden Sie beim Aktualisieren von Tabellen nach Möglichkeit Methoden für Bulk-Vorgänge (z. B. getRange()) anstelle von Methoden, die jeweils nur eine Zelle aktualisieren.

Sehen Sie sich das folgende Code-Snippet an, das ein fraktales Muster in einer Tabelle generiert.

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);

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();
}

Google Tabellen versucht zwar, das zweite Code-Snippet durch Zwischenspeichern von Werten zu optimieren, aber die Leistung ist aufgrund der Anzahl der API-Aufrufe im Vergleich zum ersten Snippet immer noch schlecht.