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

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

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

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

במקרים כאלה, עדיף להחיל תווית על הישויות ואז לסנן לפי 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() + '"');

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. מומלץ להשתמש בדוחות מהסיבות הבאות:

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

השוואה בין קטעי הקוד הבאים שמביאים את הקליקים, החשיפות, העלות והטקסט של כל מילות המפתח שקיבלו יותר מ-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);
  }

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);
  }
}

סקריפטים של חשבון ניהול ב-Google Ads (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.