सशर्त फ़ॉर्मेटिंग

Google Sheets API से, स्प्रेडशीट में कंडिशनल फ़ॉर्मैटिंग के नियम बनाए और अपडेट किए जा सकते हैं. कंडिशनल फ़ॉर्मैटिंग के ज़रिए सिर्फ़ कुछ फ़ॉर्मैटिंग टाइप को कंट्रोल किया जा सकता है. जैसे, बोल्ड, इटैलिक, स्ट्राइकथ्रू, फ़ोरग्राउंड कलर, और बैकग्राउंड कलर. इस पेज पर दिए गए उदाहरणों में बताया गया है कि Sheets API की मदद से कंडिशनल फ़ॉर्मैटिंग की कार्रवाइयां कैसे की जा सकती हैं.

ये उदाहरण भाषा न्यूट्रल होने के एचटीटीपी अनुरोधों के तौर पर दिखाए गए हैं. Google API क्लाइंट लाइब्रेरी का इस्तेमाल करके, बैच अपडेट को अलग-अलग भाषाओं में लागू करने का तरीका जानने के लिए, स्प्रेडशीट अपडेट करें देखें.

इन उदाहरणों में, SPREADSHEET_ID और SHEET_ID प्लेसहोल्डर से पता चलता है कि आपको ऐसे आईडी कहां देने हैं. स्प्रेडशीट के यूआरएल में, स्प्रेडशीट आईडी देखा जा सकता है. spreadsheets.get तरीके का इस्तेमाल करके, शीट आईडी पाया जा सकता है. रेंज की जानकारी, A1 नोटेशन का इस्तेमाल करके दी जाती है. उदाहरण के लिए, Sheets1!A1:D5 रेंज का एक उदाहरण है.

एक पंक्ति में, कंडिशनल कलर ग्रेडिएंट जोड़ें

नीचे दिए गए spreadsheets.batchUpdate तरीके के कोड सैंपल में, AddConditionalFormatRuleRequest का इस्तेमाल करके शीट की पंक्ति 10 और 11 के लिए, ग्रेडिएंट कंडिशनल फ़ॉर्मैटिंग के नए नियम बनाने का तरीका बताया गया है. पहला नियम यह बताता है कि उस पंक्ति में मौजूद सेल के बैकग्राउंड रंग उनकी वैल्यू के हिसाब से सेट किए गए हैं. पंक्ति में सबसे कम वैल्यू को गहरे लाल रंग में दिखाया जाता है, जबकि सबसे ज़्यादा वैल्यू को चमकीले हरे रंग में दिखाया जाता है. अन्य वैल्यू का रंग इंटरपोलेट किया जाता है. दूसरा नियम यही करता है, लेकिन उसमें खास न्यूमेरिक वैल्यू के साथ ग्रेडिएंट एंडपॉइंट (और अलग-अलग रंग) तय होते हैं. अनुरोध, type के तौर पर sheets.InterpolationPointType का इस्तेमाल करता है.

अनुरोध का प्रोटोकॉल नीचे दिखाया गया है.

POST https://sheets.googleapis.com/v4/spreadsheets/SPREADSHEET_ID:batchUpdate

{
  "requests": [
    {
      "addConditionalFormatRule": {
        "rule": {
          "ranges": [
            {
              "sheetId": SHEET_ID,
              "startRowIndex": 9,
              "endRowIndex": 10,
            }
          ],
          "gradientRule": {
            "minpoint": {
              "color": {
                "green": 0.2,
                "red": 0.8
              },
              "type": "MIN"
            },
            "maxpoint": {
              "color": {
                "green": 0.9
              },
              "type": "MAX"
            },
          }
        },
        "index": 0
      }
    },
    {
      "addConditionalFormatRule": {
        "rule": {
          "ranges": [
            {
              "sheetId": SHEET_ID,
              "startRowIndex": 10,
              "endRowIndex": 11,
            }
          ],
          "gradientRule": {
            "minpoint": {
              "color": {
                "green": 0.8,
                "red": 0.8
              },
              "type": "NUMBER",
              "value": "0"
            },
            "maxpoint": {
              "color": {
                "blue": 0.9,
                "green": 0.5,
                "red": 0.5
              },
              "type": "NUMBER",
              "value": "256"
            },
          }
        },
        "index": 1
      }
    },
  ]
}

अनुरोध के बाद, लागू किए गए फ़ॉर्मैट का नियम, शीट में अपडेट हो जाता है. पंक्ति 11 में ग्रेडिएंट का ज़्यादा से ज़्यादा पॉइंट 256 पर सेट है, इसलिए उसके ऊपर की किसी भी वैल्यू का सबसे ज़्यादा रंग है:

रेंज के सेट में कंडिशनल (शर्त के साथ) फ़ॉर्मैटिंग का नियम जोड़ना

नीचे दिए गए spreadsheets.batchUpdate कोड सैंपल में यह बताया गया है कि शीट के कॉलम A और C के लिए, कंडिशनल फ़ॉर्मैटिंग का नया नियम बनाने के लिए, AddConditionalFormatRuleRequest का इस्तेमाल कैसे करना है. यह नियम बताता है कि 10 या उससे कम वैल्यू वाली सेल के बैकग्राउंड रंगों को बदलकर गहरे लाल कर दिया गया है. नियम को इंडेक्स 0 पर डाला जाता है. इसलिए, इसे फ़ॉर्मैटिंग के दूसरे नियमों के मुकाबले प्राथमिकता दी जाती है. अनुरोध, BooleanRule के लिए ConditionType को type के तौर पर इस्तेमाल करता है.

अनुरोध का प्रोटोकॉल नीचे दिखाया गया है.

POST https://sheets.googleapis.com/v4/spreadsheets/SPREADSHEET_ID:batchUpdate

{
  "requests": [
    {
      "addConditionalFormatRule": {
        "rule": {
          "ranges": [
            {
              "sheetId": SHEET_ID,
              "startColumnIndex": 0,
              "endColumnIndex": 1,
            },
            {
              "sheetId": SHEET_ID,
              "startColumnIndex": 2,
              "endColumnIndex": 3,
            },
          ],
          "booleanRule": {
            "condition": {
              "type": "NUMBER_LESS_THAN_EQ",
              "values": [
                {
                  "userEnteredValue": "10"
                }
              ]
            },
            "format": {
              "backgroundColor": {
                "green": 0.2,
                "red": 0.8,
              }
            }
          }
        },
        "index": 0
      }
    }
  ]
}

अनुरोध के बाद, लागू किए गए फ़ॉर्मैट के नियम से शीट में यह बदलाव हो जाता है:

किसी रेंज में, कंडिशनल फ़ॉर्मैटिंग के नियम और तारीख जोड़ें

नीचे दिए गए spreadsheets.batchUpdate तरीके के कोड सैंपल में, AddConditionalFormatRuleRequest के इस्तेमाल का तरीका बताया गया है. इससे किसी शीट में A1:D5 रेंज के लिए, कंडिशनल फ़ॉर्मैटिंग के नए नियम बनाने में मदद मिलेगी. यह नियम उन सेल में तारीख और टेक्स्ट वैल्यू के आधार पर तय किया जाता है. अगर टेक्स्ट में "कीमत" (केस-इनसेंसिटिव) स्ट्रिंग शामिल है, तो पहला नियम, सेल के टेक्स्ट को बोल्ड के तौर पर सेट करता है. अगर सेल में पिछले हफ़्ते से पहले की तारीख है, तो दूसरा नियम सेल के टेक्स्ट को इटैलिक के तौर पर सेट करता है और उसे नीला रंग देता है. अनुरोध, BooleanRule के लिए ConditionType को type के तौर पर इस्तेमाल करता है.

अनुरोध का प्रोटोकॉल नीचे दिखाया गया है.

POST https://sheets.googleapis.com/v4/spreadsheets/SPREADSHEET_ID:batchUpdate

{
  "requests": [
    {
      "addConditionalFormatRule": {
        "rule": {
          "ranges": [
            {
              "sheetId": SHEET_ID,
              "startRowIndex": 0,
              "endRowIndex": 5,
              "startColumnIndex": 0,
              "endColumnIndex": 4,
            }
          ],
          "booleanRule": {
            "condition": {
              "type": "TEXT_CONTAINS",
              "values": [
                {
                  "userEnteredValue": "Cost"
                }
              ]
            },
            "format": {
              "textFormat": {
                "bold": true
              }
            }
          }
        },
        "index": 0
      }
    },
    {
      "addConditionalFormatRule": {
        "rule": {
          "ranges": [
            {
              "sheetId": SHEET_ID,
              "startRowIndex": 0,
              "endRowIndex": 5,
              "startColumnIndex": 0,
              "endColumnIndex": 4,
            }
          ],
          "booleanRule": {
            "condition": {
              "type": "DATE_BEFORE",
              "values": [
                {
                  "relativeDate": "PAST_WEEK"
                }
              ]
            },
            "format": {
              "textFormat": {
                "italic": true,
                "foregroundColor": {
                  "blue": 1
                }
              }
            }
          }
        },
        "index": 1
      }
    }
  ]
}

अनुरोध के बाद, लागू किए गए फ़ॉर्मैट का नियम, शीट में अपडेट हो जाता है. इस उदाहरण में, मौजूदा तारीख 26/9/2016 है:

किसी रेंज में कस्टम फ़ॉर्मूला का नियम जोड़ना

नीचे दिए गए spreadsheets.batchUpdate तरीके के कोड सैंपल में, AddConditionalFormatRuleRequest के इस्तेमाल का तरीका बताया गया है. इससे कस्टम फ़ॉर्मूले के आधार पर, शीट में B5:B8 रेंज के लिए कंडिशनल फ़ॉर्मैटिंग का एक नया नियम बनाया जा सकता है. यह नियम, कॉलम A और B में सेल के गुणनफल की गणना करता है. अगर प्रॉडक्ट का साइज़ 120 से ज़्यादा है, तो सेल का टेक्स्ट बोल्ड और इटैलिक सेट कर दिया जाता है. अनुरोध, BooleanRule के लिए ConditionType को type के तौर पर इस्तेमाल करता है.

अनुरोध का प्रोटोकॉल नीचे दिखाया गया है.

POST https://sheets.googleapis.com/v4/spreadsheets/SPREADSHEET_ID:batchUpdate

{
  "requests": [
    {
      "addConditionalFormatRule": {
        "rule": {
          "ranges": [
            {
              "sheetId": SHEET_ID,
              "startColumnIndex": 2,
              "endColumnIndex": 3,
              "startRowIndex": 4,
              "endRowIndex": 8
            }
          ],
          "booleanRule": {
            "condition": {
              "type": "CUSTOM_FORMULA",
              "values": [
                {
                  "userEnteredValue": "=GT(A5*B5,120)"
                }
              ]
            },
            "format": {
              "textFormat": {
                "bold": true,
                "italic": true
              }
            }
          }
        },
        "index": 0
      }
    }
  ]
}

अनुरोध के बाद, लागू किए गए फ़ॉर्मैट के नियम से शीट में यह बदलाव हो जाता है:

कंडिशनल फ़ॉर्मैटिंग का नियम मिटाना

यहां दिया गया spreadsheets.batchUpdate कोड का सैंपल, SHEET_ID की बताई गई शीट में, इंडेक्स 0 वाले कंडिशनल फ़ॉर्मैटिंग के नियम को मिटाने के लिए, DeleteConditionalFormatRuleRequest का इस्तेमाल करने का तरीका बताता है.

अनुरोध का प्रोटोकॉल नीचे दिखाया गया है.

POST https://sheets.googleapis.com/v4/spreadsheets/SPREADSHEET_ID:batchUpdate

{
  "requests": [
    {
      "deleteConditionalFormatRule": {
        "sheetId": SHEET_ID,
        "index": 0
      }
    }
  ]
}

कंडिशनल फ़ॉर्मैटिंग के नियमों की सूची पढ़ना

यहां दिया गया spreadsheets.get तरीका का सैंपल, स्प्रेडशीट में हर शीट के लिए टाइटल, SHEET_ID, और कंडिशनल फ़ॉर्मैटिंग के सभी नियमों की सूची पाने का तरीका बताता है. fields क्वेरी पैरामीटर से तय होता है कि कौनसा डेटा दिखाना है.

अनुरोध का प्रोटोकॉल नीचे दिखाया गया है.

GET https://sheets.googleapis.com/v4/spreadsheets/SPREADSHEET_ID?fields=sheets(properties(title,sheetId),conditionalFormats)

इस रिस्पॉन्स में Spreadsheet रिसॉर्स शामिल होता है, जिसमें Sheet ऑब्जेक्ट का कलेक्शन होता है. हर ऑब्जेक्ट में SheetProperties एलिमेंट और ConditionalFormatRule एलिमेंट का कलेक्शन होता है. अगर दिया गया रिस्पॉन्स फ़ील्ड डिफ़ॉल्ट वैल्यू पर सेट है, तो उसे रिस्पॉन्स में शामिल नहीं किया जाता. अनुरोध, BooleanRule के लिए ConditionType को type के तौर पर इस्तेमाल करता है.

{
  "sheets": [
    {
      "properties": {
        "sheetId": 0,
        "title": "Sheet1"
      },
      "conditionalFormats": [
        {
          "ranges": [
            {
              "startRowIndex": 4,
              "endRowIndex": 8,
              "startColumnIndex": 2,
              "endColumnIndex": 3
            }
          ],
          "booleanRule": {
            "condition": {
              "type": "CUSTOM_FORMULA",
              "values": [
                {
                  "userEnteredValue": "=GT(A5*B5,120)"
                }
              ]
            },
            "format": {
              "textFormat": {
                "bold": true,
                "italic": true
              }
            }
          }
        },
        {
          "ranges": [
            {
              "startRowIndex": 0,
              "endRowIndex": 5,
              "startColumnIndex": 0,
              "endColumnIndex": 4
            }
          ],
          "booleanRule": {
            "condition": {
              "type": "DATE_BEFORE",
              "values": [
                {
                  "relativeDate": "PAST_WEEK"
                }
              ]
            },
            "format": {
              "textFormat": {
                "foregroundColor": {
                  "blue": 1
                },
                "italic": true
              }
            }
          }
        },
        ...
      ]
    }
  ]
}

कंडिशनल फ़ॉर्मैटिंग के नियम या उसकी प्राथमिकता अपडेट करना

यहां दिए गए spreadsheets.batchUpdate तरीके के कोड सैंपल में, एक से ज़्यादा अनुरोधों के लिए, UpdateConditionalFormatRuleRequest को इस्तेमाल करने का तरीका बताया गया है. पहला अनुरोध करने पर मौजूदा शर्त वाले फ़ॉर्मैट के नियम को ज़्यादा इंडेक्स (0 से 2 कर दिया जाता है और उसकी प्राथमिकता कम हो जाती है) पर ले जाया जाता है. दूसरा अनुरोध, इंडेक्स 0 में मौजूद कंडिशनल फ़ॉर्मैटिंग के नियम को एक नए नियम से बदल देता है. यह नियम उन सेल को फ़ॉर्मैट करता है जिनमें A1:D5 रेंज में दिए गए टेक्स्ट ("कुल लागत") के बारे में बताया गया हो. पहला अनुरोध, दूसरे अनुरोध के शुरू होने से पहले पूरा हो जाता है. इसलिए, दूसरा अनुरोध उस नियम की जगह ले रहा है जो मूल रूप से इंडेक्स 1 पर था. अनुरोध में, BooleanRule के लिए ConditionType को type के तौर पर इस्तेमाल किया जाता है.

अनुरोध का प्रोटोकॉल नीचे दिखाया गया है.

POST https://sheets.googleapis.com/v4/spreadsheets/SPREADSHEET_ID:batchUpdate

{
  "requests": [
    {
      "updateConditionalFormatRule": {
        "sheetId": SHEET_ID,
        "index": 0,
        "newIndex": 2
      },
      "updateConditionalFormatRule": {
        "sheetId": SHEET_ID,
        "index": 0,
        "rule": {
          "ranges": [
            {
              "sheetId": SHEET_ID,
              "startRowIndex": 0,
              "endRowIndex": 5,
              "startColumnIndex": 0,
              "endColumnIndex": 4,
            }
          ],
          "booleanRule": {
            "condition": {
              "type": "TEXT_EQ",
              "values": [
                {
                  "userEnteredValue": "Total Cost"
                }
              ]
            },
            "format": {
              "textFormat": {
                "bold": true
              }
            }
          }
        }
      }
    }
  ]
}