Kotlin => अशक्त सुरक्षा

अशक्त और अशक्त प्रकार के

सामान्य प्रकार, String तरह, अशक्त नहीं हैं। उन्हें शून्य मान रखने में सक्षम बनाने के लिए, आपको स्पष्ट रूप से निरूपित करना होगा ? उनके पीछे: String?

var string        : String = "Hello World!"
var nullableString: String? = null

string = nullableString    // Compiler error: Can't assign nullable to non-nullable type.
nullableString = string    // This will work however!

सुरक्षित कॉल ऑपरेटर

अशक्त प्रकारों के कार्यों और गुणों तक पहुंचने के लिए, आपको विशेष ऑपरेटरों का उपयोग करना होगा।

पहले एक, ?. , आपको वह संपत्ति या फ़ंक्शन देता है जिसे आप एक्सेस करने की कोशिश कर रहे हैं, या यह आपको अशक्त देता है यदि ऑब्जेक्ट अशक्त है:

val string: String? = "Hello World!"
print(string.length)   // Compile error: Can't directly access property of nullable type.
print(string?.length)  // Will print the string's length, or "null" if the string is null.

मुहावरा: एक ही, अशक्त वस्तु पर एक से अधिक विधियाँ कहना

उपयोग कर रहा है Kotlin है एक अशक्त-जाँच की वस्तु के कई तरीकों कॉल करने के लिए एक सुरुचिपूर्ण तरीका apply इस तरह:

obj?.apply { 
    foo()
    bar()
}

यह फोन करेगा foo और bar पर obj (जो this में apply ब्लॉक) केवल तभी obj में गैर-शून्य है, अन्यथा पूरे ब्लॉक लंघन।

एक अशक्त चर को गैर-अशक्त संदर्भ के रूप में लाने के लिए इसे फ़ंक्शन और प्रॉपर्टी कॉल के निहित रिसीवर बनाने के बिना, आप apply बजाय let उपयोग कर सकते हैं:

nullable?.let { notnull ->
    notnull.foo()
    notnull.bar()
}

notnull कुछ भी नाम दिया जा सकता है, या यहां तक कि बाहर छोड़ दिया और निहित लैम्ब्डा पैरामीटर के माध्यम से इसका इस्तेमाल किया जा सकता it ।

स्मार्ट कास्ट

यदि कंपाइलर यह अनुमान लगा सकता है कि एक वस्तु एक निश्चित बिंदु पर शून्य नहीं हो सकती है, तो आपको विशेष ऑपरेटरों का उपयोग करने की आवश्यकता नहीं है:

var string: String? = "Hello!"
print(string.length)  // Compile error
if(string != null) {
    // The compiler now knows that string can't be null
    print(string.length)  // It works now!
}

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

एक Iterable और सरणी से नल हटा दें

कभी-कभी हमें Collection<T?> से Collections<T> तक टाइप बदलने की जरूरत होती है। उस मामले में, filterNotNull हमारा समाधान है।

val a: List<Int?> = listOf(1, 2, 3, null)
val b: List<Int> = a.filterNotNull()

अशक्त तालमेल / एल्विस ऑपरेटर

कभी-कभी एक-और फैशन में एक अशांत अभिव्यक्ति का मूल्यांकन करना वांछनीय है। एल्विस ऑपरेटर ; ?: ; ऐसी स्थिति के लिए कोटलिन में इस्तेमाल किया जा सकता है।

उदाहरण के लिए:

val value: String = data?.first() ?: "Nothing here."

data?.first() "Nothing here" data?.first() या data स्वयं एक null मान देता है "Nothing here" data?.first() के परिणामस्वरूप परिणाम data?.first()

कोड निष्पादन को समाप्त करने के लिए समान सिंटैक्स का उपयोग करके अपवादों को फेंकना भी संभव है।

val value: String = data?.second() 
    ?: throw IllegalArgumentException("Value can't be null!")

अनुस्मारक: NullPointerException को जोर ऑपरेटर (उदाहरण के लिए data!!.second()!! का उपयोग करके फेंक दिया जा सकता है data!!.second()!!

अभिकथन

!! प्रत्यय अशक्तता को अनदेखा करता है और उस प्रकार का एक अशक्त संस्करण लौटाता है। यदि ऑब्जेक्ट null है तो KotlinNullPointerException को फेंक दिया जाएगा।

val message: String? = null
println(message!!) //KotlinNullPointerException thrown, app crashes

एल्विस ऑपरेटर (:)

कोटलिन में, हम वैरिएबल की घोषणा कर सकते हैं जो null reference को धारण कर सकता है। मान लीजिए कि हमें एक नल संदर्भ है a , हम कह सकते हैं, "अगर a अशक्त नहीं है, यह उपयोग करते हैं, अन्यथा कुछ गैर शून्य मान का उपयोग x "

var a: String? = "Nullable String Value"

अब, a शून्य हो सकता है। इसलिए जब हमें मूल्य का उपयोग करने की आवश्यकता होती a , तो हमें सुरक्षा जांच करने की आवश्यकता होती है, चाहे उसमें मूल्य हो या न हो। हम इस सुरक्षा जांच को पारंपरिक if...else कथन द्वारा निष्पादित कर सकते हैं।

val b: Int = if (a != null) a.length else -1

लेकिन यहाँ अग्रिम ऑपरेटर Elvis (ऑपरेटर एल्विस ?: ) आता है। ऊपर if...else नीचे एल्विस ऑपरेटर के साथ व्यक्त किया जा सकता है:

val b = a?.length ?: -1

यदि अभिव्यक्ति बाईं ओर है ?: (यहाँ: a?.length ) शून्य नहीं है, एल्विस ऑपरेटर इसे वापस कर देता है, अन्यथा यह अभिव्यक्ति को दाईं ओर लौटाता है (यहाँ: -1 )। दाएं हाथ की अभिव्यक्ति का मूल्यांकन केवल तभी किया जाता है जब बाएं हाथ की ओर अशक्त हो।

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow

Kotlin
अशक्त सुरक्षा

खोज…