Sprawdzone metody

Na tej stronie znajdziesz sprawdzone metody tworzenia skryptów Google Ads.

Selektory

Filtrowanie za pomocą selektorów

Jeśli to możliwe, używaj filtrów, aby wyświetlać tylko te elementy, których potrzebujesz. Zastosowanie odpowiednich filtrów przynosi następujące korzyści:

  • Kod jest prostszy i łatwiejszy do zrozumienia.
  • Skrypt będzie się wykonywał znacznie szybciej.

Porównaj te fragmenty kodu:

Metoda kodowania Fragment kodu
Filtrowanie za pomocą selektorów (zalecane) 
var keywords = AdsApp.keywords()
    .withCondition('Clicks > 10')
    .forDateRange('LAST_MONTH')
    .get();
while (keywords.hasNext()) {
  var keyword = keywords.next();
  // Do work here.
}
Filtrowanie w kodzie (niezalecane) 
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.
  }
}

Drugie podejście nie jest zalecane, ponieważ próbuje pobrać listę wszystkich słów kluczowych na koncie, aby następnie zastosować do niej filtr.

Unikaj przechodzenia przez hierarchię kampanii

Jeśli chcesz pobrać elementy na określonym poziomie, użyj metody kolekcji na tym poziomie zamiast przeszukiwać całą hierarchię kampanii. Poza tym, że będzie to prostsze, to też znacznie poprawi skuteczność: system nie będzie musiał niepotrzebnie odczytywać wszystkich kampanii i grup reklam.

Porównaj te fragmenty kodu, które pobierają wszystkie reklamy z Twojego konta:

Sposób kodowania Fragment kodu
Używanie odpowiedniej metody zbierania danych (zalecane) 

var ads = AdsApp.ads();
Przeglądanie hierarchii (niezalecane) 
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.
  }
}

Drugie podejście nie jest zalecane, ponieważ próbuje pobrać całą hierarchię obiektów (kampanii i grup reklam), podczas gdy potrzebne są tylko reklamy.

Użyj określonych metod akcesora nadrzędnego

Czasami trzeba uzyskać nadrzędną jednostkę zwróconego obiektu. W takim przypadku zamiast pobierania całych hierarchii powinieneś użyć udostępnionej metody akcesora.

Porównaj te fragmenty kodu, które pobierają grupy reklam zawierające reklamy tekstowe, które w zeszłym miesiącu uzyskały ponad 50 kliknięć:

Metoda kodowania Fragment kodu
Używanie odpowiedniej metody dostępu do rodzica (zalecane) 
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.
}
Przeglądanie hierarchii (niezalecane) 
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.
    }
  }
}

Drugie podejście nie jest zalecane, ponieważ pobiera ono całą hierarchię kampanii i grup reklam na Twoim koncie, podczas gdy potrzebujesz tylko podzbioru kampanii i grup reklam powiązanych z Twoim zestawem reklam. Pierwsze podejście ogranicza się do pobierania tylko odpowiedniej kolekcji reklam i używania odpowiedniej metody do uzyskiwania dostępu do obiektów nadrzędnych.

Korzystanie z określonych filtrów nadrzędnych

Aby uzyskać dostęp do elementów w konkretnej kampanii lub grupie reklam, użyj w selektorze odpowiedniego filtra zamiast pobierania i przechodzenia przez hierarchię.

Porównaj te fragmenty kodu, które pobierają listę reklam tekstowych w określonej kampanii i grupie reklam, która w zeszłym miesiącu uzyskała ponad 50 kliknięć.

Metoda kodowania Fragment kodu
Używanie odpowiednich filtrów na poziomie nadrzędnym (zalecane) 
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.
}
Przeglądanie hierarchii (niezalecane) 
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.
    }
  }
}

Drugie podejście nie jest zalecane, ponieważ powtarza hierarchię kampanii i grup reklam na Twoim koncie, podczas gdy potrzebujesz tylko wybranego zestawu reklam oraz ich nadrzędnych kampanii i grup reklam. Pierwsze podejście ogranicza iterację do listy reklam przez zastosowanie określonego filtra dla elementów nadrzędnych w selektorze.

W miarę możliwości używaj identyfikatorów do filtrowania.

Podczas filtrowania według elementów lepiej jest filtrować według ich identyfikatorów niż według innych pól.

Zapoznaj się z tymi fragmentami kodu, które służą do wybierania kampanii.

Metoda kodowania Fragment kodu
Filtrowanie według identyfikatora (zalecane) 
var campaign = AdsApp.campaigns()
    .withIds([12345])
    .get()
    .next();
Filtrowanie według nazwy (mniej optymalne) 
var campaign = AdsApp.campaigns()
    .withCondition('Name="foo"')
    .get()
    .next();

Drugie podejście jest mniej optymalne, ponieważ filtrujemy według pola, które nie jest identyfikatorem.

Filtrowanie według identyfikatorów rodziców, gdy tylko jest to możliwe

Wybierając element, filtruj według identyfikatorów nadrzędnych, jeśli to możliwe. Dzięki temu zapytania będą szybsze, ponieważ ograniczy to listę elementów pobieranych przez serwery podczas filtrowania wyników.

Rozważ ten fragment kodu, który zwraca element AdGroup według jego identyfikatora. Załóżmy, że identyfikator kampanii nadrzędnej jest znany.

Metoda kodowania Fragment kodu
Filtrowanie według identyfikatorów kampanii i grup reklam (zalecane) 
var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .withCondition('CampaignId="54678"')
    .get()
    .next();
Filtrowanie tylko według identyfikatora grupy reklam (mniej optymalne) 
var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .get()
    .next();

Mimo że oba fragmenty kodu dają identyczne wyniki, dodatkowe filtrowanie w fragmentie kodu 1 za pomocą identyfikatora rodzica (CampaignId="54678") powoduje, że kod staje się bardziej wydajny, ponieważ ogranicza listę elementów, które serwer musi przeszukiwać podczas filtrowania wyników.

Używanie etykiet, gdy jest zbyt wiele warunków filtrowania

Jeśli masz zbyt wiele warunków filtrowania, warto utworzyć etykietę dla przetwarzanych encji i używać jej do filtrowania elementów.

Rozważ użycie tego fragmentu kodu, który pobiera listę kampanii według ich nazwy.

Metoda kodowania Fragment kodu
Używanie etykiety (zalecane) 
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
}
Tworzenie złożonych selektorów (niezalecane) 
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.
}

Oba fragmenty kodu zapewniają podobny poziom skuteczności, ale drugie podejście generuje bardziej złożony kod, ponieważ wraz z wzrostem liczby warunków w seletorze kod staje się bardziej skomplikowany. Łatwiej też jest zastosować etykietę do nowego elementu niż edytować skrypt, aby uwzględnić nowy element.

Ogranicz liczbę warunków w klauzuli IN

Podczas uruchamiania skryptów często korzysta się z raportów dotyczących listy obiektów. Aby to zrobić, deweloperzy zwykle tworzą bardzo długie zapytanie AWQL filtrujące identyfikatory jednostek z użyciem klauzuli IN. To podejście sprawdza się, gdy liczba elementów jest ograniczona. Jednak wraz z wydłużaniem się zapytania wydajność skryptu spada z 2 przyczyn:

  • Przetwarzanie dłuższego zapytania zajmuje więcej czasu.
  • Każdy identyfikator dodany do klauzuli „IN” to dodatkowy warunek do sprawdzenia, który wymaga więcej czasu.

W takich warunkach lepiej jest zastosować etykietę do elementów, a następnie filtrować według LabelId.

Metoda kodowania Fragment kodu
Stosowanie etykiety i filtrowanie według jej identyfikatora (zalecane) 
// 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() + '"');
Tworzenie długiego zapytania za pomocą klauzuli IN (niezalecane) 
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…)');

Informacje o koncie

Zmiany zbiorcze

Gdy wprowadzisz zmiany w elemencie Google Ads, skrypty Google Ads nie wykonują tych zmian od razu. Zamiast tego próbuje połączyć wiele zmian w paczki, aby można było wysłać jedno żądanie, które wprowadza wiele zmian. Dzięki temu skrypty będą szybsze, a obciążenie serwerów Google Ads będzie mniejsze. Istnieją jednak wzorce kodu, które powodują, że skrypty Google Ads często muszą czyścić swoje zbiory operacji, co spowalnia ich działanie.

Rozważ poniższy skrypt, który aktualizuje stawki na liście słów kluczowych.

Metoda kodowania Fragment kodu
Śledzenie zaktualizowanych elementów (zalecane) 
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());
}
Pobieraj zaktualizowane elementy w ścisłą zapętlenie (niezalecane) 
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());
}

Drugie podejście nie jest zalecane, ponieważ wywołanie funkcji keyword.bidding().getCpc() powoduje, że skrypty Google Ads muszą opróżniać operacje setCpc() i wykonywać tylko jedną operację naraz. Pierwsze podejście, choć podobne do drugiego, ma tę dodatkową zaletę, że obsługuje grupowanie, ponieważ wywołanie getCpc() jest wykonywane w osobnej pętli niż wywołanie setCpc().

W miarę możliwości korzystaj z monterów.

Scenariusze Google Ads obsługują 2 sposoby tworzenia nowych obiektów: za pomocą konstruktorów i metod tworzenia. Budowniki są bardziej elastyczne niż metody tworzenia, ponieważ dają dostęp do obiektu utworzonego na podstawie wywołania interfejsu API.

Rozważ te fragmenty kodu:

Metoda kodowania Fragment kodu
Używanie narzędzi do tworzenia (zalecane) 
var operation = adGroup.newKeywordBuilder()
    .withText('shoes')
    .build();
var keyword = operation.getResult();
Używanie metod tworzenia (niezalecane) 
adGroup.createKeyword('shoes');
var keyword = adGroup.keywords()
    .withCondition('KeywordText="shoes"')
    .get()
    .next();

Drugie podejście nie jest zalecane ze względu na dodatkową operację wyboru, która jest wymagana do pobrania słowa kluczowego. Wycofujemy też metody tworzenia.

Pamiętaj jednak, że nieprawidłowe użycie kreatorów może uniemożliwić skryptom Google Ads grupowanie operacji.

Rozważ użycie tych fragmentów kodu, które tworzą listę słów kluczowych i wyświetlają identyfikatory nowo utworzonych słów kluczowych:

Metoda kodowania Fragment kodu
Śledzenie zaktualizowanych elementów (zalecane) 
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());
}
Pobieranie zaktualizowanych elementów w ramach pętli ścisłej (niezalecane) 
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());
}

Drugie podejście nie jest zalecane, ponieważ wywołuje funkcję operation.getResult()w ramach tej samej pętli, która tworzy operację, co powoduje, że skrypty Google Ads wykonują po jednej operacji naraz. Pierwsze podejście, choć podobne, umożliwia grupowanie, ponieważ wywołujemy operation.getResult() w innej pętli niż ta, w której została utworzona.

Rozważ użycie przesyłania zbiorczego w przypadku dużych aktualizacji.

Deweloperzy często uruchamiają raporty i aktualizują właściwości entyfikacji (np. stawki za słowo kluczowe) na podstawie bieżących wartości skuteczności. Gdy musisz zaktualizować dużą liczbę elementów, przesyłanie zbiorcze zazwyczaj przynosi lepsze wyniki. Weźmy na przykład te skrypty, które zwiększają MaxCpc słów kluczowych, których TopImpressionPercentage > 0.4 w ciągu ostatniego miesiąca:

Metoda kodowania Fragment kodu
Użyj przesyłania zbiorczego (zalecane) 

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();
Wybieranie i aktualizowanie słów kluczowych według identyfikatora (mniej optymalne) 
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);
  }
}

Chociaż drugie podejście zapewnia całkiem dobre wyniki, w tym przypadku preferowane jest pierwsze podejście, ponieważ

  • Skrypty Google Ads mają limit liczby obiektów, które można pobrać lub zaktualizować w pojedynczym wywołaniu, a operacje wyboru i aktualizacji w drugim podejściu wliczają się do tego limitu.

  • W przypadku przesyłania zbiorczego obowiązują wyższe limity zarówno pod względem liczby jednostek, które można zaktualizować, jak i ogólnego czasu wykonania.

Grupowanie zbiorczych przesyłań według kampanii

Podczas tworzenia przesyłania zbiorczego staraj się grupować operacje według kampanii nadrzędnej. Zwiększa to wydajność oraz zmniejsza ryzyko konfliktów zmian i błędów równoczesności.

Rozważ 2 zadania przesyłania zbiorczego wykonywane równolegle. Jeden z nich wstrzymuje reklamy w grupie reklam, a drugi dostosowuje stawki za słowa kluczowe. Mimo że operacje nie są powiązane, mogą dotyczyć elementów w ramach tej samej grupy reklam (lub 2 różnych grup reklam w ramach tej samej kampanii). W takim przypadku system zablokuje element nadrzędny (wspólna grupa reklam lub kampania), co spowoduje blokowanie się zadań przesyłania zbiorczego.

Skrypty Google Ads mogą optymalizować wykonywanie w ramach jednego zadania przesyłania zbiorczego, więc najprostsze jest uruchamianie tylko jednego zadania przesyłania zbiorczego na konto naraz. Jeśli zdecydujesz się na przeprowadzenie na koncie więcej niż 1 przesyłania zbiorczego, pamiętaj, aby przesyłane zbiorczo kampanie (i ich elementy podrzędne) były ze sobą niepokrywające się. Dzięki temu uzyskasz optymalną skuteczność.

Raportowanie

Pobieranie statystyk za pomocą raportów

Jeśli chcesz pobrać dużą liczbę elementów i ich statystyk, lepiej jest użyć raportów niż standardowych metod interfejsu AdsApp. Korzystanie z raportów jest preferowane z tych powodów:

  • Raporty zapewniają lepszą wydajność w przypadku dużych zapytań.
  • Raporty nie będą wyczerpywać normalnych limitów pobierania.

Porównaj te fragmenty kodu, które pobierają liczbę kliknięć, wyświetleń, koszt i tekst wszystkich słów kluczowych, które w zeszłym miesiącu uzyskały ponad 50 kliknięć:

Metoda kodowania Fragment kodu
Korzystanie z raportów (zalecane) 
  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);
  }
Użyj iteratorów AdsApp (niezalecane) 
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());
}

Drugie podejście nie jest zalecane, ponieważ sprawdza słowa kluczowe i pobiera statystyki po jednej jednostce naraz. W tym przypadku raporty działają szybciej, ponieważ pobierają wszystkie dane w jednym wywołaniu i przesyłają je strumieniowo w miarę potrzeby. Ponadto słowa kluczowe pobrane w drugim podejściu są wliczane do limitu wywołań get() w skrypcie.

Używanie wyszukiwania zamiast raportu

Ta metoda raportowania została stworzona na potrzeby starej infrastruktury i wyświetla wyniki w formacie płaskim, nawet jeśli używasz GAQL. Oznacza to, że musi przekształcić wyniki zapytania, aby pasowały do starego stylu, który nie jest obsługiwany w przypadku wszystkich pól i zwiększa obciążenie każdego wywołania.

Zalecamy korzystanie z wyszukiwarki, aby mieć dostęp do wszystkich funkcji nowego raportowania interfejsu Google Ads API.

Preferuj GAQL zamiast AWQL

Mimo że zapytania dotyczące raportów i wywołania withCondition nadal obsługują język AWQL, jest on tłumaczony przez warstwę tłumaczenia, która nie jest w pełni zgodna z prawdziwym językiem AWQL. Aby mieć pełną kontrolę nad zapytaniami, upewnij się, że używasz GAQL.

Jeśli masz zapytania AWQL, które chcesz przetłumaczyć, możesz skorzystać z narzędzia do migracji zapytań.

Nie wybieraj większej liczby wierszy niż potrzebujesz

Szybkość wykonywania raportów (i selektorów) zależy od łącznej liczby wierszy, które zostaną zwrócone przez raport, niezależnie od tego, czy będziesz je iterować. Oznacza to, że zawsze należy używać określonych filtrów, aby jak najbardziej ograniczyć zestaw wyników, tak aby pasował do przypadku użycia.

Załóżmy, że chcesz znaleźć grupy reklam ze stawkami spoza określonego zakresu. Szybciej będzie wykonać 2 osobne zapytania, jedno dotyczące stawek poniżej dolnego progu, a drugie – powyżej górnego progu, niż pobrać wszystkie grupy reklam i zignorować te, które Cię nie interesują.

Metoda kodowania Fragment kodu
Używanie 2 zapytań (zalecane) 
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);
}
Filtrowanie na podstawie zapytania ogólnego (niezalecane) 
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);
  }
}

Skrypty Ad Managera (MCK)

Zamiast sekwencyjnego wykonywania użyj funkcji executeInParallel.

Podczas pisania skryptów na potrzeby kont menedżera, gdy to możliwe, zamiast sekwencyjnego wykonywania kodu używaj funkcji executeInParallel(). executeInParallel() zapewnia skryptowi więcej czasu na przetwarzanie (do 1 godziny) i do 30 minut na przetwarzanie każdego konta (zamiast 30 minut łącznie w przypadku wykonywania sekwencyjnego). Więcej informacji znajdziesz na stronie z limitami.

Arkusze kalkulacyjne

Podczas aktualizowania arkuszy kalkulacyjnych używać operacji wsadowych

Aktualizując arkusze kalkulacyjne, używaj operacji zbiorczych (np. getRange()) zamiast metod, które aktualizują tylko 1 komórkę.

Rozważ poniższy fragment kodu, który generuje wzór fraktalny w arkuszu kalkulacyjnym.

Metoda kodowania Fragment kodu
Aktualizowanie zakresu komórek w pojedynczym wywołaniu (zalecane) 
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);
Aktualizowanie jednej komórki naraz (niezalecane) 
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();
}

Arkusze Google próbują zoptymalizować drugi fragment kodu przez zaimplementowanie w nim pamięci podręcznej, ale nadal ma on gorszą wydajność niż pierwszy fragment kodu ze względu na liczbę wywołań interfejsu API.