बेहतर Docs सेवा

Docs की ऐडवांस सेवा की मदद से, Apps Script में Google Docs API का इस्तेमाल किया जा सकता है. Apps Script की Docs में पहले से मौजूद सेवा की तरह ही, इस एपीआई की मदद से स्क्रिप्ट, Google Docs में मौजूद कॉन्टेंट को पढ़ सकती हैं, उसमें बदलाव कर सकती हैं, और उसे फ़ॉर्मैट कर सकती हैं. ज़्यादातर मामलों में, डिवाइस में पहले से मौजूद सेवा का इस्तेमाल करना आसान होता है. हालांकि, ऐडवांस सेवा में कुछ अतिरिक्त सुविधाएं मिलती हैं.

रेफ़रंस

इस सेवा के बारे में ज़्यादा जानकारी के लिए, Docs API का रेफ़रंस दस्तावेज़ देखें. Apps Script की सभी ऐडवांस सेवाओं की तरह, Docs की ऐडवांस सेवा भी सार्वजनिक एपीआई के जैसे ही ऑब्जेक्ट, तरीकों, और पैरामीटर का इस्तेमाल करती है. ज़्यादा जानकारी के लिए, मेथड सिग्नेचर तय करने का तरीका लेख पढ़ें.

समस्याओं की शिकायत करने और अन्य सहायता पाने के लिए, Docs API की सहायता गाइड देखें.

नमूना कोड

यहां दिए गए सैंपल कोड में, एपीआई के वर्शन 1 का इस्तेमाल किया गया है.

दस्तावेज़ बनाना

इस सैंपल से एक नया दस्तावेज़ बनता है.

advanced/docs.gs
/**
 * Create a new document.
 * @see https://developers.google.com/docs/api/reference/rest/v1/documents/create
 * @return {string} documentId
 */
function createDocument() {
  try {
    // Create document with title
    const document = Docs.Documents.create({'title': 'My New Document'});
    console.log('Created document with ID: ' + document.documentId);
    return document.documentId;
  } catch (e) {
    // TODO (developer) - Handle exception
    console.log('Failed with error %s', e.message);
  }
}

टेक्स्ट ढूंढना और बदलना

इस सैंपल में, किसी दस्तावेज़ के सभी टैब में टेक्स्ट के जोड़े ढूंढे जाते हैं और उन्हें बदला जाता है. यह तब काम आ सकता है, जब टेंप्लेट दस्तावेज़ की कॉपी में मौजूद प्लेसहोल्डर को, डेटाबेस की वैल्यू से बदलना हो.

advanced/docs.gs
/**
 * Performs "replace all".
 * @param {string} documentId The document to perform the replace text operations on.
 * @param {Object} findTextToReplacementMap A map from the "find text" to the "replace text".
 * @return {Object} replies
 * @see https://developers.google.com/docs/api/reference/rest/v1/documents/batchUpdate
 */
function findAndReplace(documentId, findTextToReplacementMap) {
  const requests = [];
  for (const findText in findTextToReplacementMap) {
    const replaceText = findTextToReplacementMap[findText];
    // One option for replacing all text is to specify all tab IDs.
    const request = {
      replaceAllText: {
        containsText: {
          text: findText,
          matchCase: true
        },
        replaceText: replaceText,
        tabsCriteria: {
          tabIds: [TAB_ID_1, TAB_ID_2, TAB_ID_3],
        }
      }
    };
    // Another option is to omit TabsCriteria if you are replacing across all tabs.
    const request = {
      replaceAllText: {
        containsText: {
          text: findText,
          matchCase: true
        },
        replaceText: replaceText
      }
    };
    requests.push(request);
  }
  try {
    const response = Docs.Documents.batchUpdate({'requests': requests}, documentId);
    const replies = response.replies;
    for (const [index] of replies.entries()) {
      const numReplacements = replies[index].replaceAllText.occurrencesChanged || 0;
      console.log('Request %s performed %s replacements.', index, numReplacements);
    }
    return replies;
  } catch (e) {
    // TODO (developer) - Handle exception
    console.log('Failed with error : %s', e.message);
  }
}

टेक्स्ट डालना और उसे स्टाइल देना

इस सैंपल में, दस्तावेज़ के पहले टैब की शुरुआत में नया टेक्स्ट डाला गया है और उसे किसी खास फ़ॉन्ट और साइज़ में स्टाइल किया गया है. ध्यान दें कि जब भी हो सके, तो बेहतर परफ़ॉर्मेंस के लिए, एक से ज़्यादा ऑपरेशन को एक batchUpdate कॉल में एक साथ डालें.

advanced/docs.gs
/**
 * Insert text at the beginning of the first tab in the document and then style
 * the inserted text.
 * @param {string} documentId The document the text is inserted into.
 * @param {string} text The text to insert into the document.
 * @return {Object} replies
 * @see https://developers.google.com/docs/api/reference/rest/v1/documents/batchUpdate
 */
function insertAndStyleText(documentId, text) {
  const requests = [{
    insertText: {
      location: {
        index: 1,
        // A tab can be specified using its ID. When omitted, the request is
        // applied to the first tab.
        // tabId: TAB_ID
      },
      text: text
    }
  },
  {
    updateTextStyle: {
      range: {
        startIndex: 1,
        endIndex: text.length + 1
      },
      textStyle: {
        fontSize: {
          magnitude: 12,
          unit: 'PT'
        },
        weightedFontFamily: {
          fontFamily: 'Calibri'
        }
      },
      fields: 'weightedFontFamily, fontSize'
    }
  }];
  try {
    const response =Docs.Documents.batchUpdate({'requests': requests}, documentId);
    return response.replies;
  } catch (e) {
    // TODO (developer) - Handle exception
    console.log('Failed with an error %s', e.message);
  }
}

पहला पैराग्राफ़ पढ़ना

यह सैंपल, दस्तावेज़ के पहले टैब के पहले पैराग्राफ़ के टेक्स्ट को लॉग करता है. Docs API में पैराग्राफ़ स्ट्रक्चर्ड होते हैं. इसलिए, इसमें कई सब-एलिमेंट के टेक्स्ट को जोड़ना होता है.

advanced/docs.gs
/**
 * Read the first paragraph of the first tab in a document.
 * @param {string} documentId The ID of the document to read.
 * @return {Object} paragraphText
 * @see https://developers.google.com/docs/api/reference/rest/v1/documents/get
 */
function readFirstParagraph(documentId) {
  try {
    // Get the document using document ID
    const document = Docs.Documents.get(documentId, {'includeTabsContent': true});
    const firstTab = document.tabs[0];
    const bodyElements = firstTab.documentTab.body.content;
    for (let i = 0; i < bodyElements.length; i++) {
      const structuralElement = bodyElements[i];
      // Print the first paragraph text present in document
      if (structuralElement.paragraph) {
        const paragraphElements = structuralElement.paragraph.elements;
        let paragraphText = '';

        for (let j = 0; j < paragraphElements.length; j++) {
          const paragraphElement = paragraphElements[j];
          if (paragraphElement.textRun !== null) {
            paragraphText += paragraphElement.textRun.content;
          }
        }
        console.log(paragraphText);
        return paragraphText;
      }
    }
  } catch (e) {
    // TODO (developer) - Handle exception
    console.log('Failed with error %s', e.message);
  }
}

सबसे सही तरीके

एक साथ कई अपडेट करना

Docs की बेहतर सेवा का इस्तेमाल करते समय, एक से ज़्यादा अनुरोधों को एक कलेक्शन में जोड़ें. इसके लिए, batchUpdate को लूप में कॉल करने के बजाय, ऐसा करें.

ऐसा न करें — batchUpdate को लूप में कॉल करें.

var textToReplace = ['foo', 'bar'];
for (var i = 0; i < textToReplace.length; i++) {
  Docs.Documents.batchUpdate({
    requests: [{
      replaceAllText: ...
    }]
  }, docId);
}

ऐसा करें — अपडेट की सूची के साथ batchUpdate को कॉल करें.

var requests = [];
var textToReplace = ['foo', 'bar'];
for (var i = 0; i < textToReplace.length; i++) {
  requests.push({ replaceAllText: ... });
}

Docs.Documents.batchUpdate({
  requests: requests
}, docId);