इस पेज में 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();
|
दोनों कोड स्निपेट एक जैसे नतीजे देते हैं, लेकिन पैरंट आईडी (CampaignId="54678") का इस्तेमाल करके, कोड स्निपेट 1 में ज़्यादा फ़िल्टर करने से,
उन इकाइयों की सूची को सीमित किया जा सकता है जिन्हें सर्वर, नतीजे फ़िल्टर करते समय फिर से लागू करता है. इससे कोड को ज़्यादा बेहतर तरीके से काम करने में मदद मिलती है.
लेबल का इस्तेमाल तब करें, जब फ़िल्टर करने की कई शर्तें हों
जब आपके पास फ़िल्टर करने की बहुत ज़्यादा शर्तें हों, तो बेहतर है कि आप जिन इकाइयों को प्रोसेस करें उनके लिए एक लेबल बनाएं. साथ ही, अपनी इकाइयों को फ़िल्टर करने के लिए, उस लेबल का इस्तेमाल करें.
नीचे दिए गए कोड के स्निपेट का इस्तेमाल करें, जो कैंपेन के नाम के हिसाब से कैंपेन की सूची फिर से हासिल करता है.
| कोडिंग का तरीका | कोड स्निपेट |
|---|---|
| लेबल का इस्तेमाल करें (सुझाया गया) |
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 क्लॉज़ का इस्तेमाल करके इकाई आईडी पर फ़िल्टर करती है. इकाइयों की संख्या सीमित होने पर, यह तरीका ठीक से काम करता है. हालांकि, जैसे-जैसे आपकी क्वेरी की लंबाई बढ़ती है, आपकी स्क्रिप्ट की परफ़ॉर्मेंस दो वजहों से खराब हो जाती है:
- लंबी क्वेरी को पार्स करने में ज़्यादा समय लगता है.
- किसी आईएन क्लॉज़ में जोड़ा जाने वाला हर आईडी, मूल्यांकन करने के लिए एक अतिरिक्त शर्त है और इसलिए ज़्यादा समय लगता है.
ऐसी स्थितियों में, इकाइयों पर एक लेबल लागू करने और
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 स्क्रिप्ट में नए ऑब्जेक्ट बनाने के दो तरीकों का इस्तेमाल किया जाता है—बिल्डर और बनाने के तरीके. बिल्डर बनाने के तरीके के मुकाबले ज़्यादा सुविधाजनक होते हैं, क्योंकि इससे आपको उस ऑब्जेक्ट का ऐक्सेस मिलता है जिसे एपीआई कॉल से बनाया गया है.
इन कोड स्निपेट का इस्तेमाल करें:
| कोडिंग का तरीका | कोड स्निपेट |
|---|---|
| बिल्डर का इस्तेमाल करना (सुझाया गया) |
var operation = adGroup.newKeywordBuilder()
.withText('shoes')
.build();
var keyword = operation.getResult();
|
| प्रॉडक्ट बनाने के तरीकों का इस्तेमाल करें. हम इसका सुझाव नहीं देते |
adGroup.createKeyword('shoes');
var keyword = adGroup.keywords()
.withCondition('KeywordText="shoes"')
.get()
.next();
|
कीवर्ड को फिर से पाने में शामिल अतिरिक्त चुनने की कार्रवाई की वजह से, दूसरे तरीके को प्राथमिकता नहीं दी जाती है. इसके अलावा, बनाने के तरीके भी इस्तेमाल नहीं किए जाते.
हालांकि, ध्यान रखें कि अगर बिल्डर का गलत तरीके से इस्तेमाल किया जाता है, तो यह 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 स्क्रिप्ट को एक बार में एक ही कार्रवाई करनी पड़ती है. हालांकि, पहला तरीका इसके जैसा ही है, लेकिन
एक ही तरीका से बैच बनाने की अनुमति मिलती है, क्योंकि हम actions.getresults() को उस जगह से अलग लूप में कॉल करते हैं जहां इसे
बनाया गया था.
बड़े अपडेट के लिए, एक साथ कई फ़ाइलें अपलोड करने की सुविधा का इस्तेमाल करें
डेवलपर आम तौर पर यह काम करते हैं: रिपोर्ट चलाना और मौजूदा परफ़ॉर्मेंस वैल्यू के आधार पर इकाई प्रॉपर्टी (उदाहरण के लिए, कीवर्ड बिड) अपडेट करना. जब आपको बड़ी संख्या में इकाइयों को अपडेट करना होता है, तो एक साथ कई फ़ाइलें अपलोड करने से आपको बेहतर परफ़ॉर्मेंस मिलती है. उदाहरण के लिए, नीचे दी गई स्क्रिप्ट पर विचार करें, जो उन कीवर्ड के 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);
}
|
| 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 मैनेजर (एमसीसी) स्क्रिप्ट
सीरियल एक्ज़ीक्यूशन के बजाय एक्ज़ीक्यूटइनपैरल को प्राथमिकता दें
मैनेजर खातों के लिए स्क्रिप्ट लिखते समय, सीरियल एक्ज़ीक्यूशन की जगह 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 स्प्रेडशीट वैल्यू को कैश मेमोरी में सेव करके, दूसरे कोड स्निपेट को ऑप्टिमाइज़ करने की कोशिश करती है, फिर भी एपीआई कॉल की संख्या की वजह से, यह आपको पहले स्निपेट की तुलना में खराब परफ़ॉर्मेंस दे रही है.