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

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 Sammlungsmethode 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
Passende Methode zur Datenerhebung 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.
}
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. Das erste wird nur die relevante Anzeigensammlung abgerufen, eine geeignete Methode für den Zugriff auf ihre übergeordneten Objekte.

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 in der Auswahl, anstatt eine Hierarchie abzurufen und zu durchsuchen.

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

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.
}
Die 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 sie Kampagnen und Anzeigen iteriert. in Ihrem Konto erstellen können, obwohl Sie nur einen ausgewählten Satz von Anzeigen benötigen, sowie deren übergeordnete Kampagnen und Anzeigengruppen. Der erste Ansatz schränkt Iteration der Anzeigenliste durch Anwenden eines speziellen Filters für übergeordnete Elemente in der Auswahl.

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.

Im folgenden Code-Snippet wird eine Werbegruppe anhand ihrer ID abgerufen. 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, werden die zusätzlichen Durch Filtern im Code-Snippet 1 mit der übergeordneten ID (CampaignId="54678") wird durch Einschränken der Liste der Entitäten auf dem Server beim Filtern der Ergebnisse iterieren.

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.

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

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 ein ähnliches Leistungsniveau, während das zweite -Ansatz tendenziell komplexeren Code generieren, da die Anzahl der Bedingungen in erhöht sich die Auswahl. Es ist auch einfacher, das Label auf eine neue Entität anzuwenden. anstatt das Skript so zu bearbeiten, dass sie eine neue Entität enthalten.

Anzahl der Bedingungen in einer IN-Klausel beschränken

Bei der Ausführung von Skripts wird häufig ein Bericht 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 problemlos, wenn die Anzahl der Entitäten begrenzt ist. Da es sich jedoch um die Länge Ihrer Abfrage nimmt, verschlechtert sich die Leistung des Skripts, Gründe:

  • 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 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, führen Google Ads-Skripts nicht sofort ändern. 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-Skripts Batch-Vorgänge häufig löschen, wodurch das Skript ausgeführt wird langsam.

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 der Aufruf von keyword.bidding().getCpc() erzwingt Google Ads-Skripts, setCpc() zu leeren und nur jeweils einen Vorgang ausfü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

Google Ads-Skripts unterstützen zwei Möglichkeiten zum Erstellen neuer Objekte: Generator und Erstellung. . Builder sind flexibler als Erstellungsmethoden, Zugriff auf das Objekt, 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. Außerdem werden die Erstellungsmethoden eingestellt.

Falsch verwendete Generatoren können jedoch verhindern, Anzeigenskripts aus der Stapelverarbeitung von Vorgängen.

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 aber Batchverarbeitung, da wir „operation.getResult()“ in einer anderen Schleife aufrufen, als in der sie 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);
  }
}

Während Sie mit der zweiten Methode eine ziemlich gute Leistung erzielen, ist in diesem Fall zu bevorzugen,

  • 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. Das erhöht die Effizienz und verringert die Wahrscheinlichkeit von Konflikten Änderungen / Nebenläufigkeitsfehler.

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 Operationen nichts miteinander zu tun haben, können sich die Operationen auf Elemente in derselben Anzeigengruppe (oder auf zwei verschiedene Anzeigengruppen derselben Kampagne). 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 durchführen möchten, Sicherstellen, dass die Bulk-Uploads auf eine sich gegenseitig ausschließende Liste von Kampagnen angewendet werden und deren untergeordnete Entitäten, um eine optimale Leistung zu erzielen.

Berichte

Berichte zum Abrufen von Statistiken verwenden

Wenn Sie große Mengen von Entitäten und deren Statistiken abrufen möchten, ist es oft besser als mit AdsApp-Standardmethoden. Die Verwendung von Berichte werden 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:

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 ist nicht empfehlenswert, da er die Keywords durchläuft und die Statistiken jeweils für eine Entität abruft. Berichte werden in diesem da alle Daten in einem einzigen Aufruf abgerufen und erforderlich. Außerdem werden die mit der zweiten Methode abgerufenen Keywords auf das Kontingent Ihres Skripts bezüglich der abgerufenen Anzahl von Entitäten mit einen get()-Anruf.

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 es die Ergebnisse der Abfrage so transformieren, dass sie dem alten Stil entsprechen, wird für alle Felder unterstützt und erhöht den Overhead für jeden Aufruf.

Wir empfehlen Ihnen, stattdessen die Suche zu verwenden, um alle Funktionen des neuen Google Ads API-Berichten.

GAQL AWQL bevorzugen

AWQL wird zwar weiterhin in Berichtsanfragen und withCondition-Aufrufen unterstützt, aber ü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 konvertieren möchten, können Sie das Abfragemigrationstool verwenden.

Wählen Sie nicht mehr Zeilen als nötig aus

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. Daher sollten Sie immer spezifische 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 wäre schneller, zwei separate Abfragen zu erstellen, eine für Gebote. unterhalb des unteren Grenzwerts und ein weiteres für Gebote oberhalb der höchsten Schwelle als abgerufen werden, werden alle Anzeigengruppen abgerufen, an denen Sie interessiert sind.

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 Google Ads Manager (Kundencenter)

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 (anstelle von insgesamt 30 Minuten bei serieller Ausführung). Informationen zu unseren Limits .

Tabellen

Batch-Operationen zur Aktualisierung von Tabellen

Verwenden Sie beim Aktualisieren von Tabellen die Bulk-Vorgangsmethoden. (z. B. getRange()) gegenüber Methoden, bei denen jeweils nur eine Zelle aktualisiert wird.

Im folgenden Code-Snippet wird ein Fraktalmuster in einer Tabelle generiert.

Codierungsmethode Code-Snippet
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);
Einzelne Zelle 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();
}

Während Google Tabellen versucht, das zweite Code-Snippet durch Caching zu optimieren, ist die Leistung im Vergleich zum ersten Snippet dennoch schwach. der Anzahl der erfolgten API-Aufrufe.