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

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

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

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

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

כדאי לעיין בקטע הקוד הבא שמחלץ AdGroup לפי המזהה שלו. נניח שמזהה קמפיין ההורה ידוע.

שיטת התכנות קטע קוד
סינון לפי מזהי קמפיינים וקבוצות מודעות (מומלץ) 
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

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

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

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

כדאי לעיין בקטעי הקוד הבאים:

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

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

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

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

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

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

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

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

דיווח

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

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

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

השוואה בין קטעי הקוד הבאים שמביאים את הערכים Clicks, ‏ Impressions,‏ Cost ו-Text של כל מילות המפתח שקיבלו יותר מ-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 קריאות, לא מומלץ להשתמש בה. כדי לקבל שליטה מלאה על השאילתות, צריך לוודא שאתם משתמשים ב-GAQL.

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

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

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

שיטת התכנות קטע קוד
שימוש בשתי שאילתות (מומלץ) 
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) ב-Google Ads

עדיף להשתמש ב-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.