Best Practices

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

Selektoren

Filterung mit Selektoren

Verwenden Sie nach Möglichkeit Filter, um nur benötigte Entitäten anzufordern. Die Anwendung der richtigen Filter hat die folgenden 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.
  }
}

Der zweite Ansatz wird nicht empfohlen, da er versucht, 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 Kampagnenhierarchie zu durchlaufen. Das ist nicht nur einfacher, sondern auch viel leistungsfähiger, da das System nicht unnötig alle Kampagnen und Anzeigengruppen 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.
  }
}

Die zweite Methode wird nicht empfohlen, da versucht wird, ganze Hierarchien von Objekten (Kampagnen, Anzeigengruppen) abzurufen, obwohl nur Anzeigen erforderlich sind.

Methoden für den Zugriff auf bestimmte übergeordnete Elemente

Manchmal benötigen Sie die übergeordnete Entität eines abgerufenen Objekts. In diesem Fall sollten Sie eine bereitgestellte Accessormethode 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 enthalten haben:

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

Die zweite Methode wird nicht empfohlen, da die gesamte Kampagnen- und Anzeigengruppenhierarchie in Ihrem Konto abgerufen wird. Sie benötigen jedoch nur eine Teilmenge von Kampagnen und Anzeigengruppen, die mit Ihren Anzeigen verknüpft ist. Beim ersten Ansatz wird nur die relevante Anzeigensammlung abgerufen und eine geeignete Methode verwendet, um auf die übergeordneten Objekte zuzugreifen.

Filter für bestimmte übergeordnete Elemente

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

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

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 ist nicht empfehlenswert, da sie die Kampagnen- und Anzeigengruppenhierarchie in Ihrem Konto durchläuft. Sie benötigen jedoch nur eine ausgewählte Gruppe von Anzeigen sowie die zugehörigen Kampagnen und Anzeigengruppen. Beim ersten Ansatz wird die Iteration auf die Liste der Anzeigen beschränkt, indem ein bestimmter Filter für übergeordnete Einheiten auf den Selektor angewendet wird.

Nach Möglichkeit IDs zum Filtern verwenden

Wenn Sie nach Entitäten filtern, sollten Sie dies vorzugsweise nach ihren IDs und nicht nach anderen Feldern tun.

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 beschleunigt, da die Liste der Entitäten, die von den Servern beim Filtern von Ergebnissen abgerufen werden, eingeschränkt 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, ist der Code durch das zusätzliche Filtern 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.

Im folgenden Code-Snippet wird eine Liste von Kampagnen anhand ihres Namens abgerufen.

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. Beim zweiten Ansatz wird jedoch tendenziell komplexerer Code generiert, wenn die Anzahl der Bedingungen in Ihrem Selektor zunimmt. Außerdem ist es einfacher, das Label auf ein neues Element anzuwenden, als das Skript zu bearbeiten, um ein neues Element einzufügen.

Anzahl der Bedingungen in einer IN-Klausel beschränken

Ein häufiger Anwendungsfall beim Ausführen von Skripts ist das Erstellen eines Berichts für eine Liste von Einheiten. Entwickler erreichen dies in der Regel, indem sie eine sehr lange AWQL-Abfrage erstellen, die die Entitäts-IDs mit einer IN-Klausel filtert. Dieser Ansatz funktioniert gut, wenn die Anzahl der Entitäten begrenzt ist. Wenn die Länge Ihrer Abfrage zunimmt, verschlechtert sich die Leistung Ihres Skripts 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. Das dauert also länger.

Unter solchen Umständen ist es besser, ein Label auf die Einheiten 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 werden mehrere Änderungen in Batches zusammengefasst, 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-Scripts dazu zwingen, den Batch mit Vorgängen häufig zu leeren. Dadurch wird das Script langsam ausgeführt.

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

In Google Ads-Scripts gibt es zwei Möglichkeiten, neue Objekte zu erstellen: mit Builders und mit Creation-Methoden. Builder sind flexibler als Erstellungsmethoden, da Sie Zugriff auf das Objekt haben, das durch 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 dies verhindern, dass Google Ads-Scripts Vorgänge zusammenfassen.

In den folgenden Code-Snippets wird eine Liste mit Keywords erstellt und die ID der neu erstellten Keywords wird ausgegeben:

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

Die zweite Methode ist nicht zu empfehlen, da operation.getResult() im selben Loop aufgerufen wird, in dem der Vorgang erstellt wird. Dadurch werden Google Ads-Scripts gezwungen, jeweils nur einen Vorgang auszuführen. Der erste Ansatz ist zwar ähnlich, ermöglicht aber das Batching, 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ätseigenschaften (z. B. Keyword-Gebote) basierend auf aktuellen Leistungswerten zu aktualisieren. Wenn Sie eine große Anzahl von Entitäten aktualisieren müssen, ist die Leistung bei Bulk-Uploads in der Regel besser. Sehen Sie sich beispielsweise die folgenden Skripts an, mit denen der maximale CPC von Keywords erhöht wird, 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 recht gute Leistung, der erste Ansatz wird in diesem Fall jedoch bevorzugt, da

• Für Google Ads-Scripts gilt ein Limit für die Anzahl der Objekte, die in einem einzelnen Lauf abgerufen oder aktualisiert werden können. Die Auswahl- und Aktualisierungsvorgänge im zweiten Ansatz werden auf dieses Limit angerechnet.

• Für Bulk-Uploads gelten höhere Limits sowohl in Bezug auf die Anzahl der Entitäten, die aktualisiert werden können, als auch auf die Gesamtausführungszeit.

Bulk-Uploads nach Kampagnen gruppieren

Wenn Sie Bulk-Uploads erstellen, sollten Sie die Vorgänge nach der übergeordneten Kampagne gruppieren. Das erhöht die Effizienz und verringert das Risiko 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 miteinander in Verbindung stehen, 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. Daher ist es am einfachsten, jeweils nur eine Bulk-Upload-Aufgabe pro Konto auszuführen. Wenn Sie mehr als einen Bulk-Upload pro Konto ausführen möchten, sollten Sie darauf achten, dass die Bulk-Uploads für eine sich gegenseitig ausschließende Liste von Kampagnen (und deren untergeordneten Einheiten) ausgeführt werden, um eine optimale Leistung zu erzielen.

Berichte

Berichte zum Abrufen von Statistiken verwenden

Wenn Sie eine große Anzahl von 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 erreichen nicht das übliche Abrufkontingent.

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

Die zweite Methode wird nicht empfohlen, da die Keywords durchlaufen und die Statistiken jeweils für eine Entität abgerufen werden. Berichte werden in diesem Fall schneller erstellt, 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 Skripts für die Anzahl der mit einem get()-Aufruf abgerufenen Elemente angerechnet.

Statt eines Berichts die Suche 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 so transformiert werden müssen, dass sie dem alten Stil entsprechen. Das wird nicht für alle Felder unterstützt und erhöht den Aufwand für jeden Aufruf.

Wir empfehlen Ihnen, die Suche zu verwenden, um alle Funktionen der neuen Google Ads API-Berichte nutzen zu können.

GAQL gegenüber AWQL bevorzugen

AWQL wird zwar weiterhin in Berichtsanfragen und withCondition-Aufrufen unterstützt, aber über eine Übersetzungsebene ausgeführt, die nicht vollständig mit echtem AWQL kompatibel ist. Wenn Sie die vollständige Kontrolle über Ihre Abfragen haben möchten, müssen Sie GAQL verwenden.

Wenn Sie vorhandene AWQL-Abfragen übersetzen möchten, können Sie dazu unser Tool zur Abfragemigration verwenden.

Nicht mehr Zeilen als nötig auswählen

Die Ausführungsgeschwindigkeit von Berichten (und Selektoren) basiert auf der Gesamtzahl der Zeilen, die vom Bericht zurückgegeben werden, unabhängig davon, ob Sie sie durchlaufen. Das bedeutet, dass Sie immer spezifische Filter verwenden sollten, um die Ergebnismenge so weit wie möglich an Ihren Anwendungsfall anzupassen.

Angenommen, Sie möchten nach Anzeigengruppen mit Geboten außerhalb eines bestimmten Bereichs suchen. Es wäre 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 Skripts für Verwaltungskonten nach Möglichkeit executeInParallel() anstelle der sequenziellen Ausführung. Mit executeInParallel() hat Ihr Skript mehr Verarbeitungszeit (bis zu einer Stunde) und bis zu 30 Minuten pro verarbeitetem Konto (statt 30 Minuten insgesamt für die serielle Ausführung). Weitere Informationen finden Sie auf unserer Seite mit den Beschränkungen.

Tabellen

Batch-Operationen zur Aktualisierung von Tabellen

Verwenden Sie beim Aktualisieren von Tabellenkalkulationen möglichst die Methoden für Bulk-Vorgänge (z. B. getRange()) anstelle von Methoden, mit denen jeweils nur eine Zelle aktualisiert wird.

Sehen Sie sich das folgende Code-Snippet an, mit dem ein Fraktalmuster in einer Tabelle generiert wird.

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 das Zwischenspeichern von Werten zu optimieren, aber die Leistung ist aufgrund der Anzahl der API-Aufrufe im Vergleich zum ersten Snippet immer noch schlecht.