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

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

इस पेज पर, 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' क्लॉज़ का इस्तेमाल करके इकाई आईडी को फ़िल्टर करती है. यह तरीका, इकाइयों की संख्या सीमित होने पर ठीक से काम करता है. हालांकि, क्वेरी की लंबाई बढ़ने पर, स्क्रिप्ट की परफ़ॉर्मेंस दो वजहों से खराब होती है:

• लंबी क्वेरी को पार्स करने में ज़्यादा समय लगता है.
• 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 स्क्रिप्ट में, नए ऑब्जेक्ट बनाने के दो तरीके हो��े हैं—बिल्डर और बनाने के तरीके. बिल्डर, ऑब्जेक्ट बनाने के तरीकों के मुकाबले ज़्यादा सुव��धाजनक होते हैं. ऐसा इसलिए, क्योंकि इनकी मदद से एपीआई कॉल से बनाए गए ऑब्जेक्ट को ऐक्सेस किया जा सकता है.

यहां दिए गए कोड स्निपेट देखें:

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() को उस लूप से अलग लूप में कॉल करते हैं जहां इसे बनाया गया था.

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

डेवलपर का एक सामान्य काम, रिपोर्ट चलाना और मौजूदा परफ़ॉर्मेंस वैल्यू के आधार पर इकाई की प्रॉपर्टी (उदाहरण के लिए, कीवर्ड बिड) अपडेट करना होता है. जब आपको बड़ी संख्या में इकाइयों को अपडेट करना हो, तो एक साथ कई फ़ाइलें अपलोड करने से आपको बेहतर परफ़ॉर्मेंस मिलती है. उदाहरण के लिए, नीचे दी गई स्क्रिप्ट देखें. ये उन कीवर्ड के लिए 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);
  }

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 मैनेजर (एमसीसी) स्क्रिप्ट

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