सबसे अच्छे तरीके

इस पेज पर, 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") का इस्तेमाल करके अतिरिक्त फ़िल्टरिंग की जाती है. इससे कोड ज़्यादा असरदार हो जाता है, क्योंकि यह उन इकाइयों की सूची को सीमित कर देता है जिन्हें सर्वर को नतीजों को फ़िल्टर करते समय दोहराना पड़ता है.

फ़िल्टर करने की बहुत ज़्यादा शर्तें होने पर लेबल का इस्तेमाल करना

अगर आपके पास फ़िल्टर करने की कई शर्तें हैं, तो जिन इकाइयों को प्रोसेस किया जाता है उनके लिए लेबल बनाना और उन इकाइयों को फ़िल्टर करने के लिए उस लेबल का इस्तेमाल करना एक अच्छा आइडिया है.

कोड के इस स्निपेट को देखें, जो कैंपेन के नाम के हिसाब से उनकी सूची को वापस लाता है.

कोडिंग का तरीका कोड स्निपेट
लेबल का इस्तेमाल करना (इसका सुझाव दिया जाता है) 
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 क्लॉज़ में शर्तों की संख्या सीमित करें

स्क्रिप्ट चलाते समय, आम तौर पर इकाइयों की सूची के लिए रिपोर्ट चलाई जाती है. डेवलपर आम तौर पर, IN क्लॉज़ का इस्तेमाल करके, इकाई आईडी पर फ़िल्टर करने वाली एक लंबी GAQL क्वेरी बनाकर ऐसा करते हैं. यह तरीका तब सही से काम करता है, जब इकाइयों की संख्या सीमित हो. हालांकि, क्वेरी की लंबाई बढ़ने पर, आपकी स्क्रिप्ट की परफ़ॉर्मेंस इन दो वजहों से खराब हो जाती है:

  • लंबी क्वेरी को पार्स करने में ज़्यादा समय लगता है.
  • 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() + '"');
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 स्क्रिप्ट को एक बार में एक ही ऑपरेशन को लागू करना पड़ता है. पहला तरीका, पहले वाले तरीके से मिलता-जुलता है. हालांकि, इसमें बैचिंग की जा सकती है, क्योंकि हम 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 स्क्रिप्ट में, एक बार में वापस लाए जा सकने वाले या अपडेट किए जा सकने वाले ऑब्जेक्ट की संख्या सीमित होती है. साथ ही, दूसरे तरीके में चुनने और अपडेट करने की कार्रवाइयां उस सीमा में गिनी जाती हैं.

  • एक साथ कई फ़ाइलें अपलोड करने में, अपडेट की जा सकने वाली इकाइयों की संख्या और कुल समय, दोनों के हिसाब से ज़्यादा सीमाएं होती हैं.

एक साथ कई फ़ाइलें अपलोड करने की सुविधा का इस्तेमाल करके, कैंपेन के हिसाब से ग्रुप बनाना

एक साथ कई फ़ाइलें अपलोड करने की सुविधा का इस्तेमाल करते समय, अपने ऑपरेशन को पैरंट कैंपेन के हिसाब से ग्रुप में बांटने की कोशिश करें. इससे काम करने की क्षमता बढ़ती है. साथ ही, कॉन्फ़्लिक्टिंग चेंज (परस्पर विरोधी बदलाव) / एक साथ होने वाली गड़बड़ियों की संभावना कम हो जाती है.

मान लें कि एक साथ कई फ़ाइलें अपलोड करने के दो टास्क एक साथ चल रहे हैं. एक नियम, विज्ञापन ग्रुप में विज्ञापनों को रोकता है और दूसरा नियम, कीवर्ड बिड में बदलाव करता है. भले ही, कार्रवाइयां एक-दूसरे से जुड़ी न हों, लेकिन हो सकता है कि वे एक ही विज्ञापन ग्रुप (या एक ही कैंपेन के तहत दो अलग-अलग विज्ञापन ग्रुप) में मौजूद इकाइयों पर लागू हों. ऐसा होने पर, सिस्टम पैरंट इकाई (शेयर किया गया विज्ञापन ग्रुप या कैंपेन) को लॉक कर देगा. इस वजह से, एक साथ कई फ़ाइलें अपलोड करने के टास्क एक-दूसरे को ब्लॉक कर देंगे.

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 की नई रिपोर्टिंग की सभी सुविधाओं का फ़ायदा पाने के लिए, खोज सुविधा का इस्तेमाल करें.

AWQL के बजाय GAQL का इस्तेमाल करना

हालांकि, 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 Spreadsheets, वैल्यू को कैश मेमोरी में सेव करके, दूसरे कोड स्निपेट को ऑप्टिमाइज़ करने की कोशिश करता है. हालांकि, एपीआई कॉल की संख्या की वजह से, यह पहले स्निपेट की तुलना में अब भी खराब परफ़ॉर्मेंस देता है.