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

इस पेज पर, 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 क्लॉज़ में शर्तों की संख्या सीमित करना

स्क्रिप्ट चलाते समय, इकाइयों की सूची के लिए रिपोर्ट चलाना एक सामान्य उपयोग का उदाहरण है. आम तौर पर, डेवलपर एक बहुत लंबी AWQL क्वेरी बनाकर ऐसा करते हैं जो इकाई आईडी पर 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() को कॉल किया जाता है.

जब भी हो सके, बिल्डर का इस्तेमाल करें

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 का इस्तेमाल करना

रिपोर्ट क्वेरी और withCondition कॉल में AWQL अब भी काम करता है. हालांकि, इसे ट्रांसलेशन लेयर के ज़रिए चलाया जाता है, जो असल 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 मैनेजर (एमसीसी) स्क्रिप्ट

सीरियल एक्ज़ीक्यूशन के बजाय generateInParallel को प्राथमिकता दें

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