Best Practices

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

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
Mit Selektoren filtern (empfohlen)
var keywords = AdsApp.keywords()
    .withCondition('Clicks > 10')
    .forDateRange('LAST_MONTH')
    .get();
while (keywords.hasNext()) {
  var keyword = keywords.next();
  // Do work here.
}
Im Code filtern (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.
  }
}

Die zweite Methode wird nicht empfohlen, da nur versucht wird, die Liste aller Keywords in Ihrem Konto abzurufen, um 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. Dies ist nicht nur einfacher, sondern auch leistungsfähiger: Das System muss nicht unnötig alle Kampagnen und Anzeigengruppen auslesen.

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

Die zweite Methode wird nicht empfohlen, da damit 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 zum Abrufen der Anzeigengruppen, die Textanzeigen mit mehr als 50 Klicks im letzten Monat enthalten:

Codierungsmethode Code-Snippet
Geeignete Zugriffsmethode für Eltern 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.
}
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.
    }
  }
}

Die zweite Methode wird nicht empfohlen, da damit die gesamte Kampagnen- und Anzeigengruppenhierarchie in Ihrem Konto abgerufen wird, während Sie nur einen Teil der Kampagnen und Anzeigengruppen benötigen, die mit Ihren Anzeigen verknüpft sind. Die erste Methode beschränkt sich darauf, nur die relevante Anzeigensammlung abzurufen, und nutzt eine geeignete Methode für den Zugriff auf die übergeordneten Objekte.

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

Codierungsmethode Code-Snippet
Geeignete 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.
    }
  }
}

Die zweite Methode wird nicht empfohlen, da damit die Kampagnen- und Anzeigengruppenhierarchie in Ihrem Konto iteriert wird, obwohl Sie nur einen ausgewählten Satz von Anzeigen sowie deren übergeordnete 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 ihren IDs und nicht 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. Dies beschleunigt Ihre Abfragen, da beim Filtern von Ergebnissen die Liste der Entitäten begrenzt wird, die von den Servern abgerufen werden.

Sehen Sie sich das folgende Code-Snippet an, mit dem eine Anzeigengruppe anhand ihrer ID abgerufen wird. 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 geeignet)
var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .get()
    .next();

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

Bei zu vielen Filterbedingungen Labels verwenden

Wenn Sie zu viele Filterbedingungen haben, empfiehlt es sich, ein Label für die zu verarbeitenden Entitäten zu erstellen und dieses Label zum Filtern der Entitäten zu verwenden.

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

Die beiden Code-Snippets erzielen zwar eine ähnliche Leistung, aber beim zweiten Ansatz wird tendenziell komplexerer Code generiert, wenn die Anzahl der Bedingungen in der Auswahl zunimmt. Es ist auch einfacher, das Label auf eine neue Entität anzuwenden, als das Skript so zu bearbeiten, dass eine neue Entität eingeschlossen wird.

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 Entitäten. Entwickler erreichen dies in der Regel, indem sie eine sehr lange AWQL-Abfrage erstellen, die mithilfe 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 jedoch die Skriptleistung 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. Dies dauert länger.

In solchen Fällen ist es besser, ein Label auf die Entitäten anzuwenden und dann nach LabelId zu filtern.

Codierungsmethode Code-Snippet
Label anwenden und nach labelID 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, führen Google Ads-Skripts die Änderung nicht sofort aus. Stattdessen wird versucht, mehrere Änderungen in Batches zusammenzufassen, um eine einzelne Anfrage mit mehreren Änderungen zu senden. Dadurch werden Ihre Skripts schneller und die Google Ads-Server entlastet. Es gibt jedoch einige Codemuster, die Google Ads-Skripts häufig zwingen, Batch-Vorgänge zu beenden, wodurch das Skript langsam ausgeführt wird.

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

Die zweite Methode wird nicht empfohlen, da durch den Aufruf von keyword.bidding().getCpc() Google Ads-Skripts den setCpc()-Vorgang beenden und nur jeweils eine Operation ausführen. Der erste Ansatz hat, ähnlich wie der zweite Ansatz, den zusätzlichen Vorteil, dass er die Batchverarbeitung unterstützt, da der getCpc()-Aufruf in einer anderen Schleife als derjenigen erfolgt, in der setCpc() aufgerufen wird.

Nach Möglichkeit Generatoren verwenden

Google Ads-Skripts 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:

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

Die zweite Methode wird nicht bevorzugt, da ein zusätzlicher Auswahlvorgang beim Abrufen des Keywords erforderlich ist. Auch Erstellungsmethoden werden eingestellt.

Falsch verwendete Generatoren können jedoch verhindern, dass Google Ads-Skripts Operationen im Batch 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:

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

Die zweite Methode wird nicht empfohlen, weil operation.getResult() in derselben Schleife aufgerufen wird, in der die Operation erstellt wurde. Dadurch sind Google Ads-Skripts gezwungen, immer nur eine Operation auszuführen. Der erste Ansatz ist zwar ähnlich, aber das Batching ermöglicht die Batchverarbeitung, da "operation.getResult()" in einer anderen Schleife aufgerufen wird, als wenn sie erstellt wurde.

Bulk-Uploads für umfangreiche Aktualisierungen

Häufig erstellen Entwickler Berichte und aktualisieren Entitätseigenschaften (z. B. Keyword-Gebote) auf der Grundlage aktueller Leistungswerte. Wenn Sie eine große Anzahl von Entitäten aktualisieren müssen, erzielen Sie mit Bulk-Uploads in der Regel eine bessere Leistung. Sehen Sie sich zum Beispiel die folgenden Skripts an, mit denen der maximale CPC von Keywords erhöht wird, deren TopImpressionPercentage > 0.4 im letzten Monat generiert wurde:

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

Die zweite Methode liefert zwar eine gute Leistung, aber die erste ist in diesem Fall besser geeignet,

  • Bei Google Ads-Skripts gibt es ein Limit für die Anzahl der Objekte, die bei einer einzelnen Ausführung abgerufen oder aktualisiert werden können. Die Auswahl- und Aktualisierungsvorgänge in der zweiten Methode 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

Versuchen Sie beim Erstellen von Bulk-Uploads, die Vorgänge nach der übergeordneten Kampagne zu gruppieren. Dies erhöht die Effizienz und verringert das Risiko von Änderungskonflikten / Gleichzeitigkeitsfehlern.

Sehen wir uns zwei Bulk-Upload-Tasks an, die gleichzeitig ausgeführt werden. Eine pausiert Anzeigen in einer Anzeigengruppe, die andere passt Keyword-Gebote an. Auch wenn es keinen Zusammenhang zwischen den Vorgängen gibt, können sie auf Entitäten in derselben Anzeigengruppe (oder auf zwei verschiedene Anzeigengruppen in derselben Kampagne) angewendet werden. In diesem Fall sperrt das System die übergeordnete Entität (die freigegebene Anzeigengruppe oder Kampagne), wodurch sich die Bulk-Upload-Aufgaben gegenseitig blockieren.

Google Ads-Skripts können die Ausführung innerhalb einer einzelnen Bulk-Upload-Aufgabe optimieren. Die einfachste Methode besteht also darin, 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 optimale Leistung auf Listen von Kampagnen und deren untergeordneten Entitäten ausgeführt werden, die sich gegenseitig ausschließen.

Berichterstellung

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 standardmäßigen AdsApp-Methoden zu verwenden. Berichte sollten aus folgenden Gründen bevorzugt verwendet werden:

  • Berichte erzielen bei großen Abfragen eine bessere Leistung.
  • Berichte erreichen nicht das übliche Abrufkontingent.

Vergleichen Sie die folgenden Code-Snippets, die Klicks, Impressionen, Kosten und Text aller Keywords abrufen, 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-Iterationen 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());
}

Die zweite Methode wird nicht empfohlen, da sie über die Keywords iteriert und die Statistiken entitätsweise abruft. Berichte funktionieren in diesem Fall schneller, da alle Daten in einem einzigen Aufruf abgerufen und nach 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 statt Bericht verwenden

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

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

GAQL gegenüber AWQL bevorzugen

AWQL wird zwar weiterhin in Berichtsabfragen und withCondition-Aufrufen unterstützt, wird jedoch über eine Übersetzungsebene ausgeführt, die nicht vollständig mit echtem AWQL kompatibel ist. Verwenden Sie GAQL, um vollständige Kontrolle über Ihre Abfragen zu haben.

Wenn Sie AWQL-Abfragen übersetzen möchten, können Sie dafür das Migrationstool für Abfragetools verwenden.

Nicht mehr Zeilen als nötig auswählen

Wie schnell Berichte (und Selektoren) ausgeführt werden, hängt von der Gesamtzahl der Zeilen ab, die vom Bericht zurückgegeben werden würden, unabhängig davon, ob sie durchlaufen werden. Das bedeutet, dass Sie immer bestimmte Filter verwenden sollten, um die Ergebnismenge so weit wie möglich zu minimieren, die Ihrem Anwendungsfall entspricht.

Angenommen, Sie möchten Anzeigengruppen mit Geboten außerhalb eines bestimmten Bereichs finden. 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.

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);
}
Aus einer allgemeinen Abfrage 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 das Google Ads-Verwaltungskonto

executeInParallel besser als serielle Ausführung

Verwenden Sie beim Schreiben von Skripts für Verwaltungskonten nach Möglichkeit executeInParallel() anstelle der seriellen Ausführung. Mit executeInParallel() erhält das Skript mehr Verarbeitungszeit (bis zu eine Stunde) und bis zu 30 Minuten pro verarbeitetes Konto (anstatt 30 Minuten bei der seriellen Ausführung zusammen). Weitere Informationen finden Sie auf der Seite zu den Limits.

Tabellen

Batch-Operationen zur Aktualisierung von Tabellen

Versuchen Sie beim Aktualisieren von Tabellen, Bulk-Vorgangsmethoden (z. B. getRange()) anstelle von Methoden zu verwenden, bei denen jeweils nur eine Zelle aktualisiert wird.

Betrachten Sie das folgende Code-Snippet, das ein fraktales Muster in einer Tabelle generiert.

Codierungsmethode Code-Snippet
Zellenbereich in einem 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);
Eine Zelle nach der anderen 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();
}

Google Tabellen versucht zwar, das zweite Code-Snippet durch Caching von Werten zu optimieren, die Leistung ist jedoch aufgrund der hohen Anzahl von API-Aufrufen im Vergleich zum ersten Snippet schlecht.