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

בדף הזה מפורטות שיטות מומלצות שונות לפיתוח באמצעות סקריפטים של 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 תומכים בשתי דרכים ליצירת אובייקטים חדשים – בניית אובייקטים ויצירה שיטות. בנאים הם יותר גמישים משיטות יצירה, כי הם גישה לאובייקט שנוצר מהקריאה ל-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();

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

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

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

שיטת הקוד קטע קוד
מעקב אחרי הרכיבים המעודכנים (מומלץ) 
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 לבצע פעולה אחת בכל פעם. הגישה הראשונה דומה, אבל היא מאפשרת צבירה של משימות כי אנחנו קוראים ל-operation.getResult() בלולאה אחרת מזו שבה היא נוצרה.

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

משימה נפוצה שמפתחים מבצעים היא להריץ דוחות ולעדכן מאפייני ישות (לדוגמה, הצעות מחיר למילות מפתח) על סמך ערכי הביצועים הנוכחיים. כשצריך לעדכן מספר גדול של ישויות, בדרך כלל כדאי לבצע העלאות בכמות גדולה כדי לשפר את הביצועים. לדוגמה, נבחן את הסקריפטים הבאים שמגדילים את העלות המקסימלית לקליק של מילות מפתח שה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 יש מגבלה על מספר האובייקטים שאפשר לאחזר או לעדכן בהפעלה אחת, והפעולות select ו-update בשיטה השנייה נספרות במסגרת המגבלה הזו.

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

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

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

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

הסקריפטים של 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);
  }
שימוש ב-iterators של 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);
  }
}

סקריפטים של Ads Manager (MCC)

העדפה של ActivateInParallel על פני ביצוע טורי

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

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

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

כשמעדכנים גיליונות אלקטרוניים, כדאי להשתמש בשיטות של פעולות בכמות גדולה (למשל, 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 מנסים לבצע אופטימיזציה של קטע הקוד השני על ידי שמירה במטמון עדיין מניב ביצועים נמוכים בהשוואה לקטע הקוד הראשון, למספר הקריאות ל-API שמתבצעות.