שיטות מומלצות

בדף הזה מפורטות שיטות מומלצות שונות לפיתוח באמצעות סקריפטים של Google Ads.

בוררים

סינון באמצעות בוררים

כשהדבר אפשרי, כדאי להשתמש במסננים כדי לבקש רק את הישויות הרצויות. השימוש בפילטרים מתאימים כולל את היתרונות הבאים:

  • הקוד פשוט וקל יותר להבנה.
  • הסקריפט יפעל הרבה יותר מהר.

משווים את קטעי הקוד הבאים:

גישת תכנות קטע קוד
סינון באמצעות סלקטורים (מומלץ) 
var keywords = AdsApp.keywords()
    .withCondition('Clicks > 10')
    .forDateRange('LAST_MONTH')
    .get();
while (keywords.hasNext()) {
  var keyword = keywords.next();
  // Do work here.
}
סינון בקוד (לא מומלץ) 
var keywords = AdsApp.keywords().get();

while (keywords.hasNext()) {
  var keyword = keywords.next();
  var stats = keyword.getStatsFor(
      'LAST_MONTH');
  if (stats.getClicks() > 10) {
    // Do work here.
  }
}

הגישה השנייה לא מומלצת מפני שהיא מנסה לאחזר את הרשימה של כל מילות המפתח בחשבון רק כדי להחיל מסנן על הרשימה.

הימנעות ממעבר של היררכיית הקמפיינים

כשרוצים לאחזר ישויות ברמה מסוימת, אפשר להשתמש בשיטת איסוף ברמה הזו במקום לעבור את כל היררכיית הקמפיין. בנוסף לפשטות, הביצועים האלה גם ישיגו ביצועים טובים יותר: המערכת לא תצטרך לקרוא שלא לצורך בכל הקמפיינים וקבוצות המודעות.

השוו את קטעי הקוד הבאים שמאחזרים את כל המודעות בחשבון:

גישת תכנות קטע קוד
שימוש בשיטת איסוף מתאימה (מומלץ) 

var ads = AdsApp.ads();
מעבר בהיררכיה (לא מומלץ) 
var campaigns = AdsApp.campaigns().get();
while (campaigns.hasNext()) {
  var adGroups = campaigns.next().
      adGroups().get();
  while (adGroups.hasNext()) {
    var ads = adGroups.next().ads().get();
    // Do your work here.
  }
}

הגישה השנייה לא מומלצת כי היא מנסה לאחזר היררכיות שלמות של אובייקטים (קמפיינים, קבוצות של מודעות), אבל נדרשות רק מודעות.

שימוש בשיטות ספציפיות של רכיבי גישה שמוגדרים כהורה

לפעמים צריך לקבל ישות הורה של אובייקט שאוחזר. במקרה כזה, צריך להשתמש בשיטת גישה שסופקה במקום לאחזר היררכיות שלמות.

השוו את קטעי הקוד הבאים שמאחזרים את קבוצות המודעות שיש בהן מודעות טקסט שקיבלו יותר מ-50 קליקים בחודש שעבר:

גישת תכנות קטע קוד
משתמשים בשיטת גישה מתאימה של רכיב ההורה (מומלץ) 
var ads = AdsApp.ads()
    .withCondition('Clicks > 50')
    .forDateRange('LAST_MONTH')
    .get();

while (ads.hasNext()) {
  var ad = ads.next();
  var adGroup = ad.getAdGroup();
  var campaign = ad.getCampaign();
  // Store (campaign, adGroup) to an array.
}
מעבר בהיררכיה (לא מומלץ) 
var campaigns = AdsApp.campaigns().get();
while (campaigns.hasNext()) {
  var adGroups = campaigns.next()
      .adGroups()
      .get();
  while (adGroups.hasNext()) {
    var ads = adGroups.ads()
       .withCondition('Clicks > 50')
       .forDateRange('LAST_MONTH')
       .get();
    if (ads.totalNumEntities() > 0) {
      // Store (campaign, adGroup) to an array.
    }
  }
}

לא מומלץ להשתמש בגישה השנייה כי היא מאחזרת את כל ההיררכיות של הקמפיין וקבוצת המודעות בחשבון, בעוד שצריך רק קבוצת משנה של קמפיינים וקבוצות של מודעות שמשויכת לקבוצת המודעות. בגישה הראשונה היא מגבילה את עצמה לאחזור רק את אוסף המודעות הרלוונטי, ומשתמשת בשיטה מתאימה כדי לגשת לאובייקטים ההורה שלו.

שימוש במסננים ספציפיים להורים

כדי לגשת לישויות בקמפיין ספציפי או בקבוצת מודעות ספציפית, צריך להשתמש במסנן ספציפי בבורר במקום לאחזר ולעבור דרך היררכיה.

השוו את קטעי הקוד הבאים שמאחזרים את רשימת מודעות הטקסט בקמפיין ובקבוצת מודעות ספציפיים שקיבלו יותר מ-50 קליקים בחודש שעבר.

גישת תכנות קטע קוד
משתמשים במסננים מתאימים ברמת ההורה (מומלץ) 
var ads = AdsApp.ads()
    .withCondition('CampaignName = "Campaign 1"')
    .withCondition('AdGroupName = "AdGroup 1"')
    .withCondition('Clicks > 50')
    .forDateRange('LAST_MONTH')
    .get();

while (ads.hasNext()) {
  var ad = ads.next();
  var adGroup = ad.getAdGroup();
  var campaign = ad.getCampaign();
  // Store (campaign, adGroup, ad) to
  // an array.
}
מעבר בהיררכיה (לא מומלץ) 
var campaigns = AdsApp.campaigns()
    .withCondition('Name = "Campaign 1"')
    .get();

while (campaigns.hasNext()) {
  var adGroups = campaigns.next()
      .adGroups()
      .withCondition('Name = "AdGroup 1"')
      .get();
  while (adGroups.hasNext()) {
    var ads = adGroups.ads()
       .withCondition('Clicks > 50')
       .forDateRange('LAST_MONTH')
       .get();
    while (ads.hasNext()) {
      var ad = ads.next();
      // Store (campaign, adGroup, ad) to
      // an array.
    }
  }
}

לא מומלץ להשתמש בגישה השנייה כי היא חוזרת על עצמה בהיררכיה של קמפיינים וקבוצות של מודעות בחשבון, אבל צריך רק קבוצה נבחרת של מודעות, וגם את קבוצות המודעות והקמפיינים ברמת ההורה שלהן. הגישה הראשונה מגבילה את האיטרציה לרשימת המודעות על ידי החלה של מסנן ספציפי לישויות הורה בבורר.

שימוש במזהים לסינון כשאפשר

כשמבצעים סינון לפי ישויות, עדיף לסנן ישויות לפי המזהים שלהן במקום לפי שדות אחרים.

היעזרו בקטעי הקוד הבאים לבחירת קמפיין.

גישת תכנות קטע קוד
סינון לפי מזהה (מומלץ) 
var campaign = AdsApp.campaigns()
    .withIds([12345])
    .get()
    .next();
סינון לפי שם (פחות אופטימלי) 
var campaign = AdsApp.campaigns()
    .withCondition('Name="foo"')
    .get()
    .next();

הגישה השנייה פחות אופטימלית מפני שאנחנו מסננים לפי שדה שאינו מזהה.

סינון לפי מזהה הורה כשהדבר אפשרי

כשבוחרים ישות, מומלץ לסנן לפי מזהי הורה כשהדבר אפשרי. פעולה זו תאיץ את השאילתות על ידי הגבלת רשימת הישויות המאוחזרות על ידי השרתים, בזמן סינון התוצאות.

נשתמש בקטע הקוד הבא שמאחזר קבוצת מודעות לפי המזהה שלה. נניח שמזהה קמפיין ההורה ידוע.

גישת תכנות קטע קוד
סינון לפי מזהי קמפיינים וקבוצות של מודעות (מומלץ) 
var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .withCondition('CampaignId="54678"')
    .get()
    .next();
סינון לפי מזהה קבוצת מודעות בלבד (פחות אופטימלי) 
var adGroup = AdsApp.adGroups()
    .withIds([12345])
    .get()
    .next();

למרות ששני קטעי הקוד מניבים תוצאות זהות, הסינון הנוסף בקטע הקוד 1 באמצעות מזהה הורה (CampaignId="54678") מייעל את הקוד, כי הוא מגביל את רשימת הישויות שהשרת צריך לחזור עליהן במהלך סינון התוצאות.

יש להשתמש בתוויות כשיש יותר מדי תנאי סינון

כשיש יותר מדי תנאי סינון, מומלץ ליצור תווית לישויות שאתם מעבדים ולהשתמש בה כדי לסנן את הישויות.

נשתמש בקטע הקוד הבא שמאחזר רשימה של קמפיינים לפי השם.

גישת תכנות קטע קוד
שימוש בתווית (מומלץ) 
var label = AdsApp.labels()
    .withCondition('Name = "My Label"')
    .get()
    .next();
var campaigns = label.campaigns.get();
while (campaigns.hasNext()) {
  var campaign = campaigns.next();
  // Do more work
}
יצירת בוררים מורכבים (לא מומלץ) 
var campaignNames = [‘foo’, ‘bar’, ‘baz’];

for (var i = 0; i < campaignNames.length; i++) {
  campaignNames[i] = '"' + campaignNames[i] + '"';
}

var campaigns = AdsApp.campaigns
    .withCondition('CampaignName in [' + campaignNames.join(',') + ']')
    .get();

while (campaigns.hasNext()) {
  var campaign = campaigns.next();
  // Do more work.
}

שני קטעי הקוד מעניקים רמת ביצועים דומה, אבל הגישה השנייה נוטה ליצור קוד מורכב יותר ככל שמספר התנאים בבורר גדל. כמו כן, קל יותר להחיל את התווית על ישות חדשה מאשר לערוך את הסקריפט כך שיכלול ישות חדשה.

הגבלה של מספר התנאים בסעיף IN

כאשר מריצים סקריפטים, תרחיש נפוץ הוא הרצת דוח על רשימה של ישויות. בדרך כלל המפתחים עושים זאת על ידי יצירה של שאילתת AWQL ארוכה מאוד שמסננת את מזהי הישויות באמצעות סעיף IN. הגישה הזו עובדת טוב כאשר מספר הישויות מוגבל. עם זאת, ככל שאורך השאילתה ארוך יותר, ביצועי הסקריפט יתדרדרו עקב שתי סיבות:

  • ניתוח של שאילתה ארוכה יותר נמשך זמן רב יותר.
  • כל מזהה שמוסיפים לסעיף IN הוא תנאי נוסף להערכה, ולכן נדרש זמן רב יותר.

בתנאים כאלה, עדיף להחיל תווית על הישויות ואז לסנן לפי LabelId.

גישת תכנות קטע קוד
החלת תווית וסינון לפי labelID (מומלץ) 
// 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() + '"');
יצירת שאילתה ארוכה באמצעות משפט IN (לא מומלץ) 
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…)');

עדכונים בחשבון

שינויים בכמות גדולה

כשמבצעים שינויים בישות של Google Ads, סקריפטים של Google Ads לא מבצעים את השינוי באופן מיידי. במקום זאת, הוא מנסה לשלב שינויים מרובים בכמות גדולה, כדי שהוא יוכל לשלוח בקשה אחת עם מספר שינויים. גישה זו מזרזת את הסקריפטים ומפחיתה את העומס על שרתי Google Ads. עם זאת, יש כמה דפוסי קוד שמאלצים את הסקריפטים של Google Ads לבצע שפע של פעולות על אצוות הפעולות, ולכן הסקריפט פועל לאט.

כדאי להיעזר בסקריפט הבא שמעדכן את הצעות המחיר ברשימה של מילות מפתח.

גישת תכנות קטע קוד
מעקב אחר הרכיבים המעודכנים (מומלץ) 
var keywords = AdsApp.keywords()
    .withCondition('Clicks > 50')
    .withCondition('CampaignName = "Campaign 1"')
    .withCondition('AdGroupName = "AdGroup 1"')
    .forDateRange('LAST_MONTH')
    .get();

var list = [];
while (keywords.hasNext()) {
  var keyword = keywords.next();
  keyword.bidding().setCpc(1.5);
  list.push(keyword);
}

for (var i = 0; i < list.length; i++) {
  var keyword = list[i];
  Logger.log('%s, %s', keyword.getText(),
      keyword.bidding().getCpc());
}
אחזור רכיבים מעודכנים בלולאה הדוקה (לא מומלץ) 
var keywords = AdsApp.keywords()
    .withCondition('Clicks > 50')
    .withCondition('CampaignName = "Campaign 1"')
    .withCondition('AdGroupName = "AdGroup 1"')
    .forDateRange('LAST_MONTH')
    .get();

while (keywords.hasNext()) {
  var keyword = keywords.next();
  keyword.bidding().setCpc(1.5);
  Logger.log('%s, %s', keyword.getText(),
      keyword.bidding().getCpc());
}

לא מומלץ להשתמש בגישה השנייה כי הקריאה ל-keyword.bidding().getCpc() מאלצת את הסקריפטים של Google Ads לרוקן את הפעולה setCpc() ולבצע רק פעולה אחת בכל פעם. לגישה הראשונה, אף על פי שהגישה השנייה, יש יתרון נוסף של תמיכה בקיבוץ, מכיוון שהקריאה ל-getCpc() מתבצעת בלולאה נפרדת מזו שבה קוראים ל-setCpc().

שימוש ב-builders כשאפשר

סקריפטים של Google Ads תומכים בשתי דרכים ליצירת אובייקטים חדשים – build ושיטות יצירה. ה-builders גמישים יותר משיטות היצירה, כי הם נותנים גישה לאובייקט שנוצר מהקריאה ל-API.

מומלץ להשתמש בקטעי הקוד הבאים:

גישת תכנות קטע קוד
שימוש ב-builders (מומלץ) 
var operation = adGroup.newKeywordBuilder()
    .withText('shoes')
    .build();
var keyword = operation.getResult();
שימוש בשיטות יצירה (לא מומלץ) 
adGroup.createKeyword('shoes');
var keyword = adGroup.keywords()
    .withCondition('KeywordText="shoes"')
    .get()
    .next();

הגישה השנייה לא מועדפת בגלל פעולת הבחירה הנוספת שכוללת אחזור של מילת המפתח. בנוסף, אנחנו מוציאים משימוש גם שיטות יצירה.

עם זאת, חשוב לזכור שאם משתמשים ב-builders בצורה שגויה, הם עלולים למנוע מהסקריפטים של Google Ads לקבץ את הפעולות שלהם.

השתמשו בקטעי הקוד הבאים שיוצרים רשימה של מילות מפתח, ומדפיסים את המזהה של מילות המפתח החדשות שנוצרו:

גישת תכנות קטע קוד
מעקב אחר הרכיבים המעודכנים (מומלץ) 
var keywords = [‘foo’, ‘bar’, ‘baz’];

var list = [];
for (var i = 0; i < keywords.length; i++) {
  var operation = adGroup.newKeywordBuilder()
      .withText(keywords[i])
      .build();
  list.push(operation);
}

for (var i = 0; i < list.length; i++) {
  var operation = list[i];
  var result = operation.getResult();
  Logger.log('%s %s', result.getId(),
      result.getText());
}
אחזור רכיבים מעודכנים בלולאה הדוקה (לא מומלץ) 
var keywords = [‘foo’, ‘bar’, ‘baz’];

for (var i = 0; i < keywords.length; i++) {
  var operation = adGroup.newKeywordBuilder()
      .withText(keywords[i])
      .build();
  var result = operation.getResult();
  Logger.log('%s %s', result.getId(),
      result.getText());
}

אין העדפה להשתמש בגישה השנייה כי היא קוראת ל-operation.getResult() באותה לולאה שיוצרת את הפעולה, ולכן מאלצת סקריפטים של Google Ads לבצע פעולה אחת בכל פעם. הגישה הראשונה, למרות הדמיון הזה, מאפשרת קיבוץ ב-batch כי אנחנו קוראים ל-Action.getסת() בלולאה שונה מזו שבה היא נוצרה.

מומלץ להשתמש בהעלאות בכמות גדולה לעדכונים גדולים

משימה נפוצה שמפתחים מבצעים היא להריץ דוחות ולעדכן מאפייני ישויות (למשל הצעות מחיר למילות מפתח) על סמך ערכי הביצועים הנוכחיים. כשצריך לעדכן מספר גדול של ישויות, העלאות בכמות גדולה בדרך כלל מניבות ביצועים טובים יותר. לדוגמה, שקול את הסקריפטים הבאים שמגדילים את MaxCpc של מילות מפתח אשר TopImpressionPercentage > 0.4 שלהן בחודש האחרון:

גישת תכנות קטע קוד
שימוש בהעלאה בכמות גדולה (מומלץ) 

var report = AdsApp.report(
  'SELECT AdGroupId, Id, CpcBid FROM KEYWORDS_PERFORMANCE_REPORT ' +
  'WHERE TopImpressionPercentage > 0.4 DURING LAST_MONTH');

var upload = AdsApp.bulkUploads().newCsvUpload([
  report.getColumnHeader('AdGroupId').getBulkUploadColumnName(),
  report.getColumnHeader('Id').getBulkUploadColumnName(),
  report.getColumnHeader('CpcBid').getBulkUploadColumnName()]);
upload.forCampaignManagement();

var reportRows = report.rows();
while (reportRows.hasNext()) {
  var row = reportRows.next();
  row['CpcBid'] = row['CpcBid'] + 0.02;
  upload.append(row.formatForUpload());
}

upload.apply();
בחירה ועדכון של מילות מפתח לפי מזהה (פחות אופטימלי) 
var reportRows = AdsApp.report('SELECT AdGroupId, Id, CpcBid FROM ' +
    'KEYWORDS_PERFORMANCE_REPORT WHERE TopImpressionPercentage > 0.4 ' +
    ' DURING LAST_MONTH')
    .rows();

var map = {
};

while (reportRows.hasNext()) {
  var row = reportRows.next();
  var adGroupId = row['AdGroupId'];
  var id = row['Id'];

  if (map[adGroupId] == null) {
    map[adGroupId] = [];
  }
  map[adGroupId].push([adGroupId, id]);
}

for (var key in map) {
  var keywords = AdsApp.keywords()
      .withCondition('AdGroupId="' + key + '"')
      .withIds(map[key])
      .get();

  while (keywords.hasNext()) {
    var keyword = keywords.next();
    keyword.bidding().setCpc(keyword.bidding().getCpc() + 0.02);
  }
}

הגישה השנייה מניבה ביצועים די טובים, אך במקרה הזה עדיף להשתמש בגישה הראשונה,

  • לסקריפטים של Google Ads יש מגבלה על מספר האובייקטים שאפשר לאחזר או לעדכן בהרצה אחת, ופעולות הבחירה והעדכון בגישה השנייה נכללות במגבלה הזו.

  • להעלאות בכמות גדולה יש מגבלות גבוהות יותר גם מבחינת מספר הישויות שהן יכולות לעדכן וגם מבחינת זמן הביצוע הכולל.

קיבוץ העלאות בכמות גדולה לפי קמפיינים

כשאתם יוצרים העלאות בכמות גדולה, נסו לקבץ את הפעולות לפי קמפיין ההורה. כך אפשר להגביר את היעילות ולהקטין את הסיכוי לשינויים סותרים או לשגיאות בו-זמניות (concurrency).

מומלץ לבצע שתי משימות של העלאה בכמות גדולה שפועלות במקביל. אחד מהם משהה מודעות בקבוצת מודעות, והשני מתאים את הצעות המחיר למילות מפתח. גם אם הפעולות לא קשורות זו לזו, ייתכן שהפעולות יחולו על ישויות באותה קבוצת מודעות (או על שתי קבוצות שונות של מודעות באותו קמפיין). במקרה כזה, המערכת תנעל את ישות ההורה (קבוצת המודעות המשותפת או הקמפיין המשותף), וכתוצאה מכך המשימות של ההעלאה בכמות גדולה ייחסמו זו על זו.

סקריפטים של Google Ads יכולים לבצע אופטימיזציה של הביצוע במשימה אחת של העלאה בכמות גדולה, ולכן הכי פשוט להפעיל רק משימה אחת של העלאה בכמות גדולה לכל חשבון בכל פעם. אם מחליטים להפעיל יותר מהעלאה אחת בכמות גדולה לכל חשבון, חשוב לוודא שההעלאות בכמות גדולה פועלות ברשימה בלעדית של קמפיינים (וגם לישויות הצאצא שלהם) כדי להשיג ביצועים אופטימליים.

דיווח

שימוש בדוחות לאחזור נתונים סטטיסטיים

כשרוצים לאחזר כמויות גדולות של ישויות והנתונים הסטטיסטיים שלהן, לעיתים קרובות עדיף להשתמש בדוחות במקום בשיטות רגילות של AdsApp. עדיף להשתמש בדוחות מהסיבות הבאות:

  • הדוחות משפרים את הביצועים של שאילתות גדולות.
  • הדוחות לא יגיעו למכסות הרגילות לאחזור.

השוו את קטעי הקוד הבאים שמאחזרים את נתוני הקליקים, החשיפות, העלות והטקסט של כל מילות המפתח שקיבלו יותר מ-50 קליקים בחודש שעבר:

גישת תכנות קטע קוד
שימוש בדוחות (מומלץ) 
  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 (לא מומלץ) 
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());
}

הגישה השנייה אינה מועדפת מכיוון שהיא עוברת באיטרציות על מילות המפתח ומאחזרת את הנתונים הסטטיסטיים פריט אחד בכל פעם. במקרה כזה, דוחות פועלים מהר יותר, כי הם מאחזרים את כל הנתונים בשיחה אחת ומשדרים אותם לפי הצורך. בנוסף, מילות המפתח שאוחזרו בגישה השנייה נכללות במכסה של הסקריפט למספר הישויות שאוחזרו באמצעות קריאת get().

שימוש בחיפוש במקום בדוח

שיטת הדוח נבנתה לתשתית הישנה, והפלט שלה יפיק בפורמט שטוח גם אם משתמשים ב-GAQL. כלומר, הוא צריך לשנות את תוצאות השאילתה כך שיתאימו לסגנון הישן, שלא נתמך בכל השדות ומוסיף תקורה לכל קריאה.

מומלץ להשתמש בחיפוש במקום זאת, כדי לנצל את כל התכונות של הדיווח החדש ב-Google Ads API.

העדפה ל-GAQL על פני AWQL

AWQL עדיין נתמך בשאילתות של דוחות ובקריאות withCondition, אבל הוא פועל דרך שכבת תרגום שאין לה תאימות מלאה ל-AWQL אמיתי. כדי שתהיה לכם שליטה מלאה על השאילתות, חשוב לוודא שאתם משתמשים ב-GAQL.

אם יש לכם שאילתות AWQL קיימות שאתם רוצים לתרגם, תוכלו להיעזר בכלי להעברת שאילתות.

אין לבחור יותר שורות ממה שצריך

מהירות הביצוע של הדוחות (והסלקטורים) מבוססת על המספר הכולל של השורות שהדוח יחזיר, לא משנה אם עוברים דרכם שוב ושוב. כלומר, תמיד צריך להשתמש במסננים ספציפיים כדי לצמצם ככל האפשר את קבוצת התוצאות בהתאם לתרחיש לדוגמה שלכם.

לדוגמה, נניח שרוצים למצוא קבוצות של מודעות עם הצעות מחיר מחוץ לטווח מסוים. יהיה מהיר יותר לבצע שתי שאילתות נפרדות, אחת להצעות מחיר מתחת לסף התחתון, ואחת להצעות מחיר מעל לסף העליון, מאשר אחזור כל קבוצות המודעות ולהתעלמות מהקבוצות שלא מעניינות אתכם.

גישת תכנות קטע קוד
שימוש בשתי שאילתות (מומלץ) 
var adGroups = []
var report = AdsApp.search(
    'SELECT ad_group.name, ad_group.cpc_bid_micros' +
    ' FROM ad_group WHERE ad_group.cpc_bid_micros < 1000000');

while (report.hasNext()) {
  var row = report.next();
  adGroups.push(row.adGroup);
}
var report = AdsApp.search(
    'SELECT ad_group.name, ad_group.cpc_bid_micros' +
    ' FROM ad_group WHERE ad_group.cpc_bid_micros > 2000000');

while (report.hasNext()) {
  var row = report.next();
  adGroups.push(row.adGroup);
}
סינון משאילתה כללית (לא מומלץ) 
var adGroups = []
var report = AdsApp.search(
    'SELECT ad_group.name, ad_group.cpc_bid_micros' +
    ' FROM ad_group');

while (report.hasNext()) {
  var row = report.next();
  var cpcBidMicros = row.adGroup.cpcBidMicros;
  if (cpcBidMicros < 1000000 || cpcBidMicros > 2000000) {
    adGroups.push(row.adGroup);
  }
}

סקריפטים של מנהל המודעות (MCC)

עדיפות ל-executeInParallel על פני ביצוע טורי

כשכותבים סקריפטים לחשבונות ניהול, כדאי להשתמש ב-executeInParallel() במקום בביצוע סדרתי כשאפשר. executeInParallel() נותן לסקריפט זמן עיבוד נוסף (עד שעה) ועד 30 דקות לכל חשבון שעובר עיבוד (במקום 30 דקות במשולב להפעלה טורית). לפרטים נוספים, קראו את דף המגבלות.

גיליונות אלקטרוניים

שימוש בפעולות אצווה בעדכון גיליונות אלקטרוניים

כשמעדכנים גיליונות אלקטרוניים, כדאי להשתמש בשיטות לפעולה בכמות גדולה (לדוגמה, getRange()) על פני שיטות שמעדכנות תא אחד בכל פעם.

נשתמש בקטע הקוד הבא שיוצר דפוס פרקטלי בגיליון אלקטרוני.

גישת תכנות קטע קוד
עדכון של טווח של תאים בהפעלה אחת (מומלץ) 
var colors = new Array(100);
for (var y = 0; y < 100; y++) {
  xcoord = xmin;
  colors[y] = new Array(100);
  for (var x = 0; x < 100; x++) {
    colors[y][x] = getColor_(xcoord, ycoord);
    xcoord += xincrement;
  }
  ycoord -= yincrement;
}
sheet.getRange(1, 1, 100, 100).setBackgroundColors(colors);
עדכון של כל תא בנפרד (לא מומלץ) 
var cell = sheet.getRange('a1');
for (var y = 0; y < 100; y++) {
  xcoord = xmin;
  for (var x = 0; x < 100; x++) {
    var c = getColor_(xcoord, ycoord);
    cell.offset(y, x).setBackgroundColor(c);
    xcoord += xincrement;
  }
  ycoord -= yincrement;
  SpreadsheetApp.flush();
}

Google Sheets מנסה לבצע אופטימיזציה לקטע הקוד השני על ידי שמירת ערכים במטמון, אבל הביצועים שלו עדיין נמוכים בהשוואה לקטע הראשון, בגלל מספר הקריאות ל-API.