शर्तें

सीन में कंडिशनल लॉजिक को लागू करने के लिए डेटा मॉडल ऑब्जेक्ट. इन सेक्शन में बताया गया है शर्तों के लिए मान्य सिंटैक्स.

तार्किक ऑपरेटर

ऑपरेटर ब्यौरा
&& लॉजिकल AND. इनर एक्सप्रेशन का फिर से आकलन किया जाता है. अगर किसी एक्सप्रेशन का आकलन गलत के तौर पर होता है, तो इवैलुएशन की जानकारी कम दिखती है.
|| लॉजिकल OR. इनर एक्सप्रेशन का फिर से आकलन किया जाता है. अगर किसी एक्सप्रेशन का आकलन सही लगता है, तो इवैलुएशन की जानकारी कम दिखती है
! लॉजिकल नोट. इनर एक्सप्रेशन का आकलन न किया जाता है

संख्यात्मक और स्ट्रिंग ऑपरेटर

संख्या वाले और स्ट्रिंग ऑपरेटर इस्तेमाल किए जा सकते हैं:

ऑपरेटर ब्यौरा
+ संख्याएं या स्ट्रिंग जोड़ने की प्रोसेस जोड़ना
- संख्याएं घटाना
* संख्याओं को गुणा करें
/ संख्याओं को विभाजित करें

बूलियन

नीचे दिए गए कॉन्स्टेंट बूलियन का इस्तेमाल किया जा सकता है:

स्थिर ब्यौरा
true नाम अंग्रेज़ी के छोटे अक्षरों में होना चाहिए
false नाम अंग्रेज़ी के छोटे अक्षरों में होना चाहिए
!false आकलन का नतीजा true होता है. अंग्रेज़ी के छोटे अक्षरों में लिखा जाना चाहिए.

तुलना करने वाले ऑपरेटर

नीचे दिए गए कंपैरिज़न ऑपरेटर दिए गए हैं:

ऑपरेटर ब्यौरा
== बराबर
!= बराबर नहीं है
< इससे कम
<= बराबर से कम
> इससे ज़्यादा
>= बराबर से बड़ा

सूचियां और मैप

session.params.myList नाम की सूची दी गई:

सिंटैक्स ब्यौरा
x in session.params.myList x मान होने पर 'सही' दिखाता है session.params.myList
myList[x] myList के इंडेक्स x पर मान देता है
size(session.params.myList) सूची का साइज़ दिखाता है

session.params.myMap नाम का मैप दिया गया:

सिंटैक्स ब्यौरा
session.params.myMap == {"one": 1, "two":2} अगर मैप बराबर होते हैं, तो true लौटाता है
session['params']['myMap']['one'] तय की गई कुंजी के साथ मान देता है
size(session.params.myMap) मैप का साइज़ दिखाता है

डेटा मॉडल

इन ऑब्जेक्ट का इस्तेमाल सीन के अंदर किया जा सकता है:

सिंटैक्स ब्यौरा
intent मेल खाने वाले इंटेंट पैरामीटर का डेटा
scene स्लॉट-फ़िल डेटा
session सेशन स्टोरेज का डेटा
user उपयोगकर्ता के स्टोरेज से जुड़ा डेटा
home होम स्टोरेज का डेटा
device डिवाइस की क्षमता और जगह की जानकारी का डेटा
canvas कैनवस की स्थिति से जुड़ा डेटा
resources स्थानीय भाषा में उपलब्ध प्रोजेक्ट के संसाधन (ऑडियो, इमेज, स्ट्रिंग वगैरह) डेटा

JSON में पूरे डेटा मॉडल का एक उदाहरण स्निपेट यहां दिया गया है:

{
  "intent": {
    "params": {
      "<param_name>": {
        "original": "five people",
        "resolved": 5
      }
    }
   },
  "session": {
    "params": {
      "<session_params_key>": "<session_params_value>"
    }
  },
  "scene": {
    "slots": {
      "status": "FINAL",
      "params": {
        "<slot_name>": "<slot_value>"
      }
    }
  },
  "user": {
    "params": {
      "<user_params_key>": "<user_params_value>"
    },
    "permissions": [
      "DEVICE_PRECISE_LOCATION"
    ],
    "accountLinkingStatus": "LINKED",
    "verificationStatus": "VERIFIED",
    "lastSeenTime": {
      "seconds": 123,
      "nanos": 456
    },
    "engagement": {
      "pushNotificationIntents": [
        "intent1",
        "intent2"
      ]
    }
  },
  "home": {
    "params": {
      "<home_params_key>": "<home_params_value>"
    }
  },
  "canvas": {
    "state": {
      "<canvas_state_key>": "<canvas_state_value>"
    }
  },
  "device": {
    "capabilities": [
      "SPEECH",
      "RICH_RESPONSE",
      "LONG_FORM_AUDIO",
      "INTERACTIVE_CANVAS"
    ],
    "currentLocation": {
      "coordinates": {
        "latitude": 37.422,
        "longitude": -122.084
      },
      "postalAddress": {
        "revision": 0,
        "regionCode": "US",
        "languageCode": "en",
        "postalCode": "94043",
        "sortingCode": "",
        "administrativeArea": "California",
        "locality": "Mountain View",
        "sublocality": "",
        "addressLines": ["1600 Amphitheatre Parkway"],
        "recipients": [],
        "organization": ""
      }
    }
  },
  "resources": {
    "strings": {
      "<resource_string_key>": "<resource_string_value>"
    },
    "images": {
      "<resource_image_key>": "<resource_image_value>"
    }
  }
}

इस्तेमाल के बारे में जानकारी

यहां दिए गए सिंटैक्स के उदाहरणों में माना गया है कि आपको session.params ऑब्जेक्ट के साथ:

session.params = {
  "flag": true,
  "count": 10,
  "name": "john smith",
  "myList": [1, 2, 3],
  "myMap": {"one": 1, "two":2}
}

आपके पास ये कंडिशनल ऑपरेशन करने का विकल्प होता है:

// numbers and boolean logic
session.params.count > 0 && session.params.count < 100    // AND
session.params.count == 0 || session.params.count != 5    // OR
!(session.params.count <= 0)         // NOT

// booleans
!false                      // true constant
session.params.flag         // boolean variable
session.params.flag == true // explicitly compare with true constant

// strings
session.params.name == "john smith"  // double quotes supported
session.params.name == 'john smith'  // single quotes supported
session.params.name.contains("john") // substring
session.params.name + "!!!" == "john smith!!!" // string concatenation
session.params.name < "abc"          // compares lexicographically
size(session.params.name) == 10      // length of string

// lists
1 in session.params.myList        // "contains in list" operator
session.params.myList[0] == 1     // "index into list" operator
size(session.params.myList) == 3  // returns number of elements in the list

// maps
session.params.myMap == {"one": 1, "two":2} // compare map with json
session['params']['myMap']['one'] == 1      // index using square brackets
size(session.params.myMap) == 2             // number of entries in the map