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:

Codierungsmethode Code-Snippet
Mithilfe von Auswahlschaltern filtern (empfohlen) 
var keywords = AdsApp.keywords()
    .withCondition('Clicks > 10')
    .forDateRange('LAST_MONTH')
    .get();
while (keywords.hasNext()) {
  var keyword = keywords.next();
  // Do work here.
}
Filter im Code (nicht empfohlen) 
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 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 Erfassungsmethode auf dieser Ebene, anstatt die gesamte Kampagnenhierarchie zu durchlaufen. Das ist nicht nur einfacher, sondern führt auch zu einer deutlich besseren Leistung: Das System muss nicht alle Kampagnen und Anzeigengruppen unnötigerweise einlesen.

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

Codierungsmethode Code-Snippet
Geeignete Erfassungsmethode verwenden (empfohlen) 

var ads = AdsApp.ads();
Hierarchie durchlaufen (nicht empfohlen) 
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, 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 Zugriffsmethode verwenden, anstatt ganze Hierarchien abzurufen.

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

Codierungsmethode Code-Snippet
Geeignete Methode für den Elternzugriff verwenden (empfohlen) 
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.
}
Die Hierarchie durchlaufen (nicht empfohlen) 
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 die gesamte Kampagnen- und Anzeigengruppenhierarchie in Ihrem Konto abgerufen wird. Sie benötigen jedoch nur einen Teil der Kampagnen und Anzeigengruppen, die mit Ihren Anzeigen verknüpft sind. Beim ersten Ansatz wird nur die relevante Anzeigensammlung abgerufen und eine geeignete Methode zum Zugriff auf die übergeordneten Objekte verwendet.

Filter für bestimmte übergeordnete Elemente

Wenn Sie auf Entitäten in einer bestimmten Kampagne oder Anzeigengruppe zugreifen möchten, verwenden Sie einen bestimmten Filter in der Auswahl, anstatt eine Hierarchie abzurufen und dann durchzugehen.

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.

Codierungsmethode Code-Snippet
Entsprechende Filter auf übergeordneter Ebene verwenden (empfohlen) 
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.
}
Hierarchie durchlaufen (nicht empfohlen) 
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.
    }
  }
}

Der zweite Ansatz wird nicht empfohlen, da die Kampagnen- und Anzeigengruppenhierarchie in Ihrem Konto iteriert wird. Sie benötigen jedoch nur eine ausgewählte Gruppe von Anzeigen und die übergeordneten Kampagnen und Anzeigengruppen. Beim ersten Ansatz wird die Iteration auf die Liste der Anzeigen beschränkt, indem ein bestimmter Filter für übergeordnete Entitäten auf den Selektor angewendet wird.

Nach Möglichkeit IDs zum Filtern verwenden

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

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

Codierungsmethode Code-Snippet
Nach ID filtern (empfohlen) 
var campaign = AdsApp.campaigns()
    .withIds([12345])
    .get()
    .next();
Nach Name filtern (weniger geeignet) 
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 beim Filtern der Ergebnisse von den Servern abgerufen werden, eingeschränkt wird.

Sehen Sie sich das folgende Code-Snippet an, das eine Anzeigengruppe anhand ihrer ID abruft. Angenommen, die ID der übergeordneten Kampagne ist bekannt.

Codierungsmethode Code-Snippet
Nach Kampagnen- und Anzeigengruppen-IDs filtern (empfohlen) 
var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .withCondition('CampaignId="54678"')
    .get()
    .next();
Nur nach Anzeigengruppen-ID filtern (weniger optimal) 
var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .get()
    .next();

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

Bei zu vielen Filterbedingungen Labels verwenden

Wenn Sie zu viele Filterbedingungen haben, sollten Sie ein Label für die von Ihnen verarbeiteten Entitäten erstellen und die Entitäten anhand dieses Labels filtern.

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

Codierungsmethode Code-Snippet
Label verwenden (empfohlen) 
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
}
Komplexe Auswahlkriterien erstellen (nicht empfohlen) 
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. Der zweite Ansatz führt jedoch mit zunehmender Anzahl von Bedingungen in der Auswahl zu komplexerem Code. Es ist auch einfacher, das Label auf eine neue Entität anzuwenden, als das Skript so zu bearbeiten, dass es eine neue Entität enthält.

Anzahl der Bedingungen in einer IN-Klausel beschränken

Ein häufiger Anwendungsfall für die Ausführung von Skripts ist die Erstellung eines Berichts für eine Liste von Entitäten. Normalerweise erstellen Entwickler dazu eine sehr lange AWQL-Abfrage, die mit einer IN-Klausel nach den Entitäts-IDs filtert. Dieser Ansatz funktioniert gut, wenn die Anzahl der Entitäten begrenzt ist. Mit zunehmender Länge der Abfrage verschlechtert sich die Scriptleistung 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 auszuwertende Bedingung und dauert daher länger.

In solchen Fällen sollten Sie den Entitäten ein Label zuweisen und dann nach LabelId filtern.

Codierungsmethode Code-Snippet
Label anwenden und nach Label-ID filtern (empfohlen) 
// 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() + '"');
Lange Abfrage mit der IN-Klausel erstellen (nicht empfohlen) 
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 in Google Ads-Scripts ausgeführt. Stattdessen versucht er, mehrere Änderungen in Batches zu kombinieren, damit eine einzelne Anfrage mit mehreren Änderungen gesendet werden kann. Dadurch werden Ihre Scripts schneller und die Auslastung der Google Ads-Server wird reduziert. Es gibt jedoch einige Codemuster, die Google Ads-Scripts dazu zwingen, ihre Batch-Vorgänge häufig zu löschen, was zu einer langsamen Ausführung des Scripts führt.

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

Codierungsmethode Code-Snippet
Aktualisierte Elemente im Blick behalten (empfohlen) 
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());
}
Aktualisierte Elemente in einer engen Schleife abrufen (nicht empfohlen) 
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());
}

Der zweite Ansatz wird nicht empfohlen, da der Aufruf von keyword.bidding().getCpc() Google Ads-Scripts dazu zwingt, den setCpc()-Vorgang zu löschen und nur einen Vorgang gleichzeitig auszuführen. Der erste Ansatz ähnelt dem zweiten, bietet aber den zusätzlichen Vorteil, dass er das Batching unterstützt, da der getCpc()-Aufruf in einer separaten Schleife erfolgt, in der setCpc() aufgerufen wird.

Nach Möglichkeit Generatoren verwenden

In Google Ads-Scripts gibt es zwei Möglichkeiten, neue Objekte zu erstellen: über Builder und über Erstellungsmethoden. Builder sind flexibler als Erstellungsmethoden, da sie Zugriff auf das Objekt gewähren, das über den API-Aufruf erstellt wird.

Sehen Sie sich die folgenden Code-Snippets an:

Codierungsmethode Code-Snippet
Builder verwenden (empfohlen) 
var operation = adGroup.newKeywordBuilder()
    .withText('shoes')
    .build();
var keyword = operation.getResult();
Erstellungsmethoden verwenden (nicht empfohlen) 
adGroup.createKeyword('shoes');
var keyword = adGroup.keywords()
    .withCondition('KeywordText="shoes"')
    .get()
    .next();

Der zweite Ansatz ist aufgrund des zusätzlichen Auswahlvorgangs beim Abrufen des Keywords nicht empfehlenswert. Darüber hinaus wurden auch Erstellungsmethoden eingestellt.

Beachten Sie jedoch, dass bei falscher Verwendung die Batch-Ausführung von Google Ads-Scripts durch Builders verhindert werden kann.

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

Codierungsmethode Code-Snippet
Aktualisierte Elemente im Blick behalten (empfohlen) 
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());
}
Aktualisierte Elemente in einer engen Schleife abrufen (nicht empfohlen) 
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 empfehlenswert, da operation.getResult() in derselben Schleife aufgerufen wird, in der der Vorgang erstellt wird. Google Ads-Scripts müssen also jeweils nur einen Vorgang ausführen. Der erste Ansatz ist zwar ähnlich, ermöglicht jedoch die Batchverarbeitung, da „operation.getResult()“ in einer anderen Schleife aufgerufen wird als in der Phase, in der er erstellt wurde.

Bulk-Uploads für umfangreiche Aktualisierungen

Eine gängige Aufgabe von Entwicklern besteht darin, Berichte zu erstellen und Entitätseigenschaften (z. B. Keyword-Gebote) anhand aktueller Leistungswerte zu aktualisieren. Wenn Sie eine große Anzahl von Entitäten aktualisieren müssen, erzielen Sie mit Bulk-Uploads in der Regel eine bessere Leistung. Betrachten Sie beispielsweise die folgenden Scripts, mit denen der MaxCpc von Keywords erhöht wird, deren TopImpressionPercentage > 0.4 im letzten Monat:

Codierungsmethode Code-Snippet
Bulk-Upload verwenden (empfohlen) 

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();
Keywords nach ID auswählen und aktualisieren (weniger geeignet) 
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 ist in diesem Fall jedoch vorzuziehen, da

  • Bei Google Ads-Scripts ist die Anzahl der Objekte begrenzt, die bei einer einzelnen Ausführung 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 hinsichtlich der Anzahl der Entitäten, die aktualisiert werden können, als auch der Gesamtausführungszeit.

Bulk-Uploads nach Kampagnen gruppieren

Gruppieren Sie Ihre Bulk-Uploads nach der übergeordneten Kampagne. Dies erhöht die Effizienz und verringert die Wahrscheinlichkeit von in Konflikt stehenden Änderungen/Parallelisierungsfehlern.

Sehen wir uns zwei Bulk-Upload-Tasks an, die gleichzeitig ausgeführt werden. Mit der einen werden Anzeigen in einer Anzeigengruppe pausiert, mit 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 auf zwei verschiedene Anzeigengruppen in derselben Kampagne) beziehen. In diesem Fall sperrt das System das übergeordnete Element (die freigegebene Anzeigengruppe oder Kampagne). Dadurch blockieren sich die Bulk-Upload-Aufgaben gegenseitig.

Mit Google Ads-Scripts lässt sich die Ausführung innerhalb einer einzelnen Bulk-Upload-Aufgabe optimieren. Daher ist es am einfachsten, jeweils nur einen Bulk-Upload pro Konto auszuführen. Wenn Sie mehrere Bulk-Uploads pro Konto ausführen, sollten die Bulk-Uploads für eine optimale Leistung auf einer sich gegenseitig ausschließenden Liste von Kampagnen (und ihren untergeordneten Entitäten) basieren.

Berichte

Berichte zum Abrufen von Statistiken verwenden

Wenn Sie große Mengen an Entitäten und ihre Statistiken abrufen möchten, ist es oft besser, Berichte anstelle der standardmäßigen 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 Klicks, Impressionen, Kosten und Text aller Keywords abgerufen werden, die im letzten Monat mehr als 50 Klicks erhalten haben:

Codierungsmethode Code-Snippet
Berichte verwenden (empfohlen) 
  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);
  }
AdsApp-Iterator verwenden (nicht empfohlen) 
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 wird nicht bevorzugt, da er über die Keywords iteriert und die Statistiken entitätsübergreifend abruft. In diesem Fall sind Berichte schneller, da alle Daten in einem einzigen Aufruf abgerufen und bei Bedarf gestreamt werden. Außerdem werden die mit der zweiten Methode abgerufenen Keywords auf das Kontingent Ihres Skripts bezüglich der Anzahl der mit einem get()-Aufruf abgerufenen Entitäten angerechnet.

Suche anstelle von Bericht verwenden

Die Berichtsmethode wurde für die alte Infrastruktur entwickelt und gibt die Ergebnisse auch dann in einem flachen Format aus, wenn Sie GAQL verwenden. Das bedeutet, dass die Ergebnisse der Abfrage in den alten Stil umgewandelt werden müssen, was nicht für alle Felder unterstützt wird und die Verarbeitung jedes Aufrufs verlangsamt.

Wir empfehlen Ihnen, stattdessen 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, es wird jedoch über eine Übersetzungsschicht ausgeführt, die nicht vollständig mit echter AWQL kompatibel ist. Wenn Sie volle Kontrolle über Ihre Abfragen haben möchten, sollten Sie GAQL verwenden.

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

Wählen Sie nicht mehr Zeilen aus, als Sie benötigen.

Die Ausführungsgeschwindigkeit von Berichten (und Auswahlen) hängt von der Gesamtzahl der Zeilen ab, die vom Bericht zurückgegeben würden, unabhängig davon, ob Sie sie durchgehen. Sie sollten daher immer bestimmte Filter verwenden, um die Ergebnismenge so weit wie möglich für Ihren Anwendungsfall zu minimieren.

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

Codierungsmethode Code-Snippet
Zwei Abfragen verwenden (empfohlen) 
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);
}
Mit einer generischen Abfrage nach unten filtern (nicht empfohlen) 
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);
  }
}

Skripts für Verwaltungskonten (Kundencenterkonten, MCC)

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() gewährt Ihrem Skript mehr Verarbeitungszeit (bis zu einer Stunde) und bis zu 30 Minuten pro verarbeitetes Konto (anstelle von insgesamt 30 Minuten bei serieller Ausführung). Weitere Informationen finden Sie auf der Seite zu Limits.

Tabellen

Batch-Operationen zur Aktualisierung von Tabellen

Verwenden Sie beim Aktualisieren von Tabellen 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, das ein fraktales Muster in einer Tabelle generiert.

Codierungsmethode Code-Snippet
Einen Zellenbereich in einem einzigen Aufruf aktualisieren (empfohlen) 
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);
Zellen einzeln aktualisieren (nicht empfohlen) 
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();
}

In Google Tabellen wird versucht, das zweite Code-Snippet durch Caching von Werten zu optimieren. Aufgrund der Anzahl der API-Aufrufe ist die Leistung jedoch im Vergleich zum ersten Snippet gering.