> 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).

# अभिव्यक्ति

परिभाषित इनपुट चर और कॉन्फ़िगर किए गए नियमों के आधार पर एक विशिष्ट आउटपुट बनाएँ।

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

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

यह ब्लॉक प्रोग्रामिंग में स्विच-केस या 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. मेल खाने वाले केस के आधार पर परिणाम लौटाता है:

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

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

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

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

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

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

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

## अन्य ब्लॉक्स से जोड़ना

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

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

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

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

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

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

### गुण

| **नाम**           | **प्रकार**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | **विवरण**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | संदर्भ |
| ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ |
| `नाम`             | `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, SequenceJoin, 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>

* इनपुट
  * `डेटा` ([*`*`*](https://docs.roboflow.com/workflows/hi/developer-guide/developer-guide/kinds/wildcard.md)नामित वेरिएबल्स की एक डिक्शनरी): जिसमें वर्कफ़्लो चरणों का डेटा होता है। वेरिएबल नाम शर्तों और परिणामों में उपयोग किए जाते हैं। कुंजियाँ वेरिएबल नाम हैं, मान वर्कफ़्लो चरण आउटपुट का संदर्भ देने वाले सेलेक्टर्स हैं। वेरिएबल्स का संदर्भ शर्तों और गतिशील परिणामों में लिया जा सकता है। उदाहरण: {'predictions': '$steps.model.predictions', 'reference': '$inputs.reference\_class\_names'} से 'predictions' और 'reference' वेरिएबल्स बनते हैं..
* आउटपुट
  * `आउटपुट` ([`*`](https://docs.roboflow.com/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": "PASS"
	                },
	                "type": "CaseDefinition"
	            }
	        ],
	        "default": {
	            "type": "StaticCaseResult",
	            "value": "FAIL"
	        },
	        "type": "CasesDefinition"
	    }
	}
```

</details>
