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

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

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

इन उदाहरणों में, SPREADSHEET_ID और SHEET_ID प्लेसहोल्डर से पता चलता है कि आपको आईडी कहां देने हैं. स्प्रेडशीट आईडी को स्प्रेडशीट के यूआरएल में देखा जा सकता है. spreadsheets.get तरीके का इस्तेमाल करके, शीट का आईडी पाया जा सकता है. रेंज को A1 नोटेशन का इस्तेमाल करके बताया जाता है. उदाहरण के लिए, Sheet1!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 पर सेट है. इसलिए, इसके ऊपर की किसी भी वैल्यू का maxpoint रंग है:

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

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

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

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 के लिए, type के तौर पर ConditionType का इस्तेमाल किया जाता है.

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

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 के लिए, type के तौर पर ConditionType का इस्तेमाल किया जाता है.

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

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 के लिए, type के तौर पर ConditionType का इस्तेमाल किया जाता है.

{
  "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 के लिए, type के तौर पर ConditionType का इस्तेमाल करता है.

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

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
              }
            }
          }
        }
      }
    }
  ]
}