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