> For the complete documentation index, see [llms.txt](https://docs.roboflow.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.roboflow.com/workflows/hi/blocks/blocks/advanced-blocks/expression.md).

# अभिव्यक्ति

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

## यह ब्लॉक कैसे काम करता है

यह ब्लॉक प्रोग्रामिंग में switch-case या if-else-if कथनों जैसी शर्तीय तर्क लागू करता है। यह ब्लॉक:

1. वर्कफ़्लो चरणों से नामित वेरिएबल्स के एक डिक्शनरी के रूप में इनपुट डेटा प्राप्त करता है
2. वैकल्पिक रूप से ऑपरेशनों का उपयोग करके डेटा रूपांतरण लागू करता है:
   * स्थिति मूल्यांकन से पहले डेटा वेरिएबल्स पर ऑपरेशन करता है
   * Property Definition ब्लॉक जैसी ही ऑपरेशन प्रणाली का उपयोग करता है
   * स्थितियों के लिए वेरिएबल तैयार करने हेतु डेटा को रूपांतरित करता है (जैसे, प्रॉपर्टीज़ निकालना, फ़िल्टर करना, चयन करना)
   * रूपांतरित मानों को स्थितियों में उपयोग के लिए वेरिएबल्स के रूप में संग्रहीत करता है
3. स्विच-केस कथनों का क्रमवार मूल्यांकन करता है:
   * क्रम में प्रत्येक केस की शर्त का परीक्षण करता है, जब तक कि कोई एक मेल न खा जाए
   * पहले मेल खाने वाले केस पर रुकता है और उसका परिणाम लौटाता है
   * यदि कोई केस मेल नहीं खाता, तो डिफ़ॉल्ट परिणाम लौटाता है
4. एक लचीली अभिव्यक्ति प्रणाली का उपयोग करके स्थितियों का मूल्यांकन करता है:
   * **द्विआधारी कथन**: ऑपरेटरों (==, !=, >, <, >=, <=, contains, startsWith, endsWith, in, any in, all in) का उपयोग करके दो मानों की तुलना करें
   * **एकक कथन**: एकल मानों का परीक्षण करें (Exists, DoesNotExist, is True, is False, is empty, is not empty)
   * **कथन समूह**: जटिल स्थितियों के लिए AND/OR ऑपरेटरों के साथ कई कथनों को संयोजित करें
   * स्थितियाँ नाम से वेरिएबल्स (DynamicOperand) का संदर्भ ले सकती हैं या लिटरल मानों (StaticOperand) का उपयोग कर सकती हैं
5. मेल खाने वाले केस के आधार पर परिणाम लौटाता है:

   **स्थिर परिणाम:**

   * केस में परिभाषित एक निश्चित मान लौटाता है (जैसे, "सफल", "असफल", संख्यात्मक मान, स्ट्रिंग्स)

   **गतिशील परिणाम:**

   * किसी वेरिएबल से मान लौटाता है (किसी भी इनपुट वेरिएबल का संदर्भ ले सकता है)
   * लौटाने से पहले वेरिएबल को रूपांतरित करने के लिए वैकल्पिक रूप से ऑपरेशन लागू करता है
   * गणना किए गए या निकाले गए मानों को आउटपुट के रूप में लौटाने में सक्षम बनाता है
6. डिफ़ॉल्ट केस को संभालता है:
   * यदि कोई केस-शर्त मेल नहीं खाती, तो डिफ़ॉल्ट परिणाम लौटाता है
   * डिफ़ॉल्ट केस परिणामों की तरह ही, स्थिर या गतिशील हो सकता है

यह ब्लॉक डेटा रूपांतरण ऑपरेशनों को लचीले स्थिति मूल्यांकन के साथ जोड़कर जटिल शर्तीय तर्क सक्षम करता है। स्थितियाँ वेरिएबल्स की तुलना कर सकती हैं, अस्तित्व की जाँच कर सकती हैं, सदस्यता जाँच सकती हैं, स्ट्रिंग ऑपरेशन कर सकती हैं, और तार्किक ऑपरेटरों के साथ कई स्थितियों को जोड़ सकती हैं। इससे यह व्यावसायिक नियमों को लागू करने, सत्यापन तर्क, कई मानदंडों के आधार पर वर्गीकरण, और शर्तीय डेटा रूपांतरण के लिए शक्तिशाली बनता है।

## सामान्य उपयोग के मामले

* **व्यावसायिक तर्क का कार्यान्वयन**: शर्तीय व्यावसायिक नियम और सत्यापन तर्क लागू करें (जैसे, जाँचें कि डिटेक्शन संदर्भ से मेल खाता है, गुणवत्ता जाँच लागू करें, व्यावसायिक नियमों को लागू करें), जिससे व्यावसायिक तर्क वर्कफ़्लो सक्षम होते हैं
* **शर्तीय वर्गीकरण**: कई स्थितियों और मानदंडों के आधार पर डेटा का वर्गीकरण करें (जैसे, प्रॉपर्टीज़ के आधार पर डिटेक्शनों का वर्गीकरण, स्थितियों के अनुसार परिणामों को श्रेणीबद्ध करना, बहु-मानदंड वर्गीकरण लागू करना), जिससे शर्तीय वर्गीकरण वर्कफ़्लो सक्षम होते हैं
* **सत्यापन और गुणवत्ता नियंत्रण**: संदर्भ मानों या सीमाओं के विरुद्ध डेटा या पूर्वानुमानों का सत्यापन करें (जैसे, सुनिश्चित करें कि पूर्वानुमान अपेक्षित वर्गों से मेल खाते हैं, गुणवत्ता सीमाओं की जाँच करें, अनुपालन सत्यापित करें), जिससे सत्यापन वर्कफ़्लो सक्षम होते हैं
* **नियम-आधारित निर्णय-निर्माण**: जटिल नियम-संचयों के आधार पर निर्णय लें (जैसे, कई मानदंडों के आधार पर स्वीकृत/अस्वीकृत करना, स्थितियों के आधार पर डेटा रूट करना, नियम-संचयों का उपयोग करके निर्णय लेना), जिससे नियम-आधारित निर्णय वर्कफ़्लो सक्षम होते हैं
* **गतिशील आउटपुट जनरेशन**: इनपुट स्थितियों के आधार पर अलग-अलग आउटपुट जनरेट करें (जैसे, स्थितियों के आधार पर अलग-अलग मान लौटाना, शर्तीय आउटपुट जनरेट करना, गतिशील परिणाम बनाना), जिससे गतिशील आउटपुट वर्कफ़्लो सक्षम होते हैं
* **बहु-स्थिति फ़िल्टरिंग**: कई स्थितियों के साथ जटिल फ़िल्टरिंग तर्क लागू करें (जैसे, कई मानदंडों के आधार पर फ़िल्टर करना, जटिल शर्तीय फ़िल्टर लागू करना, बहु-कारक फ़िल्टरिंग लागू करना), जिससे शर्तीय फ़िल्टरिंग वर्कफ़्लो सक्षम होते हैं

## अन्य ब्लॉक्स से कनेक्ट करना

यह ब्लॉक वर्कफ़्लो चरणों से डेटा प्राप्त करता है और शर्तीय आउटपुट उत्पन्न करता है:

* **मॉडल या विश्लेषण ब्लॉकों के बाद** पूर्वानुमानों या परिणामों पर शर्तीय तर्क लागू करने के लिए (जैसे, पूर्वानुमानों का सत्यापन, परिणामों का वर्गीकरण, शर्तीय नियम लागू करना), जिससे शर्तीय तर्क वर्कफ़्लो सक्षम होते हैं
* **Property Definition ब्लॉकों के बाद** निकाली गई प्रॉपर्टीज़ को स्थितियों में उपयोग करने के लिए (जैसे, निकाले गए मानों को स्थितियों में उपयोग करना, निकाली गई प्रॉपर्टीज़ की तुलना करना, निकाले गए डेटा पर तर्क लागू करना), जिससे प्रॉपर्टी-से-स्थिति वर्कफ़्लो सक्षम होते हैं
* **लॉजिक ब्लॉक्स से पहले** Continue If की तरह, शर्तीय इनपुट प्रदान करने के लिए (जैसे, फ़िल्टरिंग के लिए शर्तीय मान प्रदान करना, निर्णयों के लिए शर्तीय इनपुट देना), जिससे अभिव्यक्ति-से-तर्क वर्कफ़्लो सक्षम होते हैं
* **डेटा संग्रहण ब्लॉकों से पहले** भंडारण के लिए डेटा को शर्तानुसार स्वरूपित या रूपांतरित करने के लिए (जैसे, भंडारण के लिए शर्तानुसार स्वरूपण, शर्तीय रूपांतरण लागू करना, शर्तीय आउटपुट तैयार करना), जिससे शर्तीय भंडारण वर्कफ़्लो सक्षम होते हैं
* **सूचना ब्लॉकों से पहले** शर्तीय सूचनाएँ भेजने के लिए (जैसे, शर्तीय अलर्ट भेजना, स्थितियों के आधार पर सूचित करना, शर्तीय सूचनाएँ ट्रिगर करना), जिससे शर्तीय सूचना वर्कफ़्लो सक्षम होते हैं
* **वर्कफ़्लो आउटपुट में** शर्तीय अंतिम आउटपुट प्रदान करने के लिए (जैसे, शर्तीय वर्कफ़्लो आउटपुट, गतिशील परिणाम जनरेशन, शर्तीय आउटपुट स्वरूपण), जिससे शर्तीय आउटपुट वर्कफ़्लो सक्षम होते हैं

## आवश्यकताएँ

यह ब्लॉक इनपुट डेटा को एक डिक्शनरी के रूप में मांगता है, जहाँ कुंजियाँ वेरिएबल नाम हैं और मान वर्कफ़्लो चरणों से आए डेटा हैं। switch पैरामीटर उन केसों को परिभाषित करता है जिनमें स्थितियाँ और परिणाम होते हैं। स्थितियाँ द्विआधारी तुलना (==, !=, >, <, >=, <=, contains, in, आदि), एकक परीक्षण (Exists, is empty, आदि), और तार्किक संयोजन (AND/OR) का समर्थन करती हैं। डेटा ऑपरेशन वैकल्पिक हैं और Property Definition ब्लॉक जैसी ही ऑपरेशन प्रणाली का उपयोग करते हैं। ब्लॉक केसों का मूल्यांकन क्रम में करता है और पहले मेल खाने वाले केस का परिणाम लौटाता है, या यदि कोई केस मेल नहीं खाता तो डिफ़ॉल्ट परिणाम लौटाता है। परिणाम स्थिर मान हो सकते हैं या वेरिएबल्स से प्राप्त गतिशील मान हो सकते हैं (वैकल्पिक रूप से लागू ऑपरेशनों के साथ)।

### प्रकार पहचानकर्ता

स्टेप में निम्नलिखित पहचानकर्ता का उपयोग करें `"type"` फ़ील्ड: `roboflow_core/expression@v1` अपने वर्कफ़्लो में ब्लॉक को एक स्टेप के रूप में जोड़ने के लिए।

### गुण

| **नाम**           | **प्रकार**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | **विवरण**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | संदर्भ |
| ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------ |
| `name`            | `str`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | इस स्टेप के लिए एक विशिष्ट पहचानकर्ता दर्ज करें..                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ❌      |
| `data_operations` | `Dict[str, List[Union[ClassificationPropertyExtract, ConvertDictionaryToJSON, ConvertImageToBase64, ConvertImageToJPEG, DetectionsFilter, DetectionsOffset, DetectionsPropertyExtract, DetectionsRename, DetectionsSelection, DetectionsShift, DetectionsToDictionary, Divide, ExtractDetectionProperty, ExtractFrameMetadata, ExtractImageProperty, LookupTable, Multiply, NumberRound, NumericSequenceAggregate, PickDetectionsByParentClass, RandomNumber, SequenceAggregate, SequenceApply, SequenceElementsCount, SequenceLength, SequenceMap, SortDetections, StringMatches, StringSubSequence, StringToLowerCase, StringToUpperCase, TimestampToISOFormat, ToBoolean, ToNumber, ToString]]]` | स्थितियों का मूल्यांकन करने से पहले डेटा वेरिएबल्स को रूपांतरित करने के लिए ऑपरेशनों की वैकल्पिक डिक्शनरी। कुंजियाँ डेटा से लिए गए वेरिएबल नाम हैं, मान ऑपरेशनों की सूचियाँ हैं (Property Definition ब्लॉक जैसी ही)। वेरिएबल्स को स्थितियों में उपयोग करने से पहले उन्हें रूपांतरित करने के लिए ऑपरेशन लागू किए जाते हैं। प्रॉपर्टीज़ निकालने, फ़िल्टर करने, या मूल्यांकन से पहले डेटा रूपांतरित करने के लिए उपयोगी। खाली डिक्शनरी (डिफ़ॉल्ट) का अर्थ है कि कोई रूपांतरण लागू नहीं किए जाते..                                                                                                    | ❌      |
| `switch`          | `CasesDefinition`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | स्विच-केस तर्क परिभाषा जिसमें स्थितियों और परिणामों वाले केस शामिल हैं। प्रत्येक केस में एक शर्त (द्विआधारी/एकक कथनों के साथ StatementGroup) और एक परिणाम (स्थिर मान या गतिशील वेरिएबल) होता है। केसों का मूल्यांकन क्रम में किया जाता है - पहले मेल खाने वाले केस का परिणाम लौटाया जाता है। यदि कोई केस मेल नहीं खाता, तो डिफ़ॉल्ट परिणाम लौटाया जाता है। AND/OR ऑपरेटरों, तुलना ऑपरेटरों (==, !=, >, <, >=, <=), स्ट्रिंग ऑपरेशनों (contains, startsWith, endsWith), सदस्यता परीक्षणों (in, any in, all in), और अस्तित्व परीक्षणों (Exists, is empty) के साथ जटिल स्थितियों का समर्थन करता है। | ❌      |

यह **संदर्भ** स्तंभ यह इंगित करता है कि संपत्ति को वर्कफ़्लो रनटाइम में उपलब्ध गतिशील मानों के साथ पैरामीटराइज़ किया जा सकता है `वर्कफ़्लो` रनटाइम। देखें *बाइंडिंग्स* अधिक जानकारी के लिए।

### इनपुट और आउटपुट बाइंडिंग्स

उपलब्ध कनेक्शन उसके बाइंडिंग प्रकारों पर निर्भर करते हैं। देखें कि कौन-से बाइंडिंग प्रकार `अभिव्यक्ति` संस्करण `v1` है।

<details>

<summary>इनपुट और आउटपुट बाइंडिंग्स</summary>

* इनपुट
  * `डेटा` ([*`*`*](/workflows/hi/developer-guide/developer-guide/kinds/wildcard.md)): वर्कफ़्लो चरणों से आए डेटा को रखने वाले नामित वेरिएबल्स का डिक्शनरी। वेरिएबल नामों का उपयोग स्थितियों और परिणामों में किया जाता है। कुंजियाँ वेरिएबल नाम हैं, मान वर्कफ़्लो चरण आउटपुट का संदर्भ देने वाले सेलेक्टर्स हैं। वेरिएबल्स को स्थितियों और गतिशील परिणामों में संदर्भित किया जा सकता है। उदाहरण: {'predictions': '$steps.model.predictions', 'reference': '$inputs.reference\_class\_names'} 'predictions' और 'reference' नामक वेरिएबल्स बनाता है..
* आउटपुट
  * `आउटपुट` ([`*`](/workflows/hi/developer-guide/developer-guide/kinds/wildcard.md)): किसी भी तत्व का समतुल्य।

</details>

<details>

<summary>उदाहरण JSON परिभाषा</summary>

```json
{
	    "name": "<your_step_name_here>",
	    "type": "roboflow_core/expression@v1",
	    "data": {
	        "predictions": "$steps.model.predictions",
	        "reference": "$inputs.reference_class_names"
	    },
	    "data_operations": {
	        "predictions": [
	            {
	                "property_name": "class_name",
	                "type": "DetectionsPropertyExtract"
	            }
	        ]
	    },
	    "switch": {
	        "cases": [
	            {
	                "condition": {
	                    "statements": [
	                        {
	                            "comparator": {
	                                "type": "=="
	                            },
	                            "left_operand": {
	                                "operand_name": "class_name",
	                                "type": "DynamicOperand"
	                            },
	                            "right_operand": {
	                                "operand_name": "reference",
	                                "type": "DynamicOperand"
	                            },
	                            "type": "BinaryStatement"
	                        }
	                    ],
	                    "type": "StatementGroup"
	                },
	                "result": {
	                    "type": "StaticCaseResult",
	                    "value": "सफल"
	                },
	                "type": "CaseDefinition"
	            }
	        ],
	        "default": {
	            "type": "StaticCaseResult",
	            "value": "असफल"
	        },
	        "type": "CasesDefinition"
	    }
	}
```

</details>