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

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

סקריפטים של חשבון ניהול ב-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 שמתבצעות.