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

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

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

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

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

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

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

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

הסקריפטים של 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)

עדיפות ל-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 שמבוצעות.