स्विफ्ट में डाउनकास्टिंग वैकल्पिक: जैसा? प्रकार, या के रूप में! प्रकार?

Question

स्विफ्ट में निम्नलिखित को देखते हुए:

var optionalString: String?
let dict = NSDictionary()

निम्नलिखित दो कथनों के बीच व्यावहारिक अंतर क्या है:

optionalString = dict.objectForKey("SomeKey") as? String

बनाम

optionalString = dict.objectForKey("SomeKey") as! String?

Comments

Aslo देखें के रूप में! Apple से ऑपरेटर

— हनी

Answer 1

व्यावहारिक अंतर यह है:

var optionalString = dict["SomeKey"] as? String

optionalStringप्रकार का एक चर होगा String?। यदि अंतर्निहित प्रकार इसके अलावा कुछ और है, तो वैकल्पिक रूप से Stringहानिरहित होगा nil।

var optionalString = dict["SomeKey"] as! String?

यह कहता है, मुझे पता है कि यह बात एक है String?। यह भी optionalStringप्रकार के परिणाम में होगा String?, लेकिन अगर अंतर्निहित प्रकार कुछ और है तो यह दुर्घटनाग्रस्त हो जाएगा।

पहली शैली को तब if letवैकल्पिक रूप से सुरक्षित रखने के लिए उपयोग किया जाता है :

if let string = dict["SomeKey"] as? String {
    // If I get here, I know that "SomeKey" is a valid key in the dictionary, I correctly
    // identified the type as String, and the value is now unwrapped and ready to use.  In
    // this case "string" has the type "String".
    print(string)
}

Comments

क्या पहला तरीका हमेशा बेहतर नहीं होता है? दोनों प्रकार के स्ट्रिंग का एक वैकल्पिक लौटाते हैं? ऐसा लगता है जैसे दूसरा तरीका पहले वाले के समान ही करता है, लेकिन अगर डाउनकास्ट असफल है तो क्रैश हो सकता है। तो इसका उपयोग क्यों करें?

— सिकंदर

हां @ सिकंदर, पहले वाला हमेशा बेहतर होता है। मैं दूसरे का उपयोग कभी नहीं करता।

— टीकामा

Answer 2

as? Types- इसका मतलब है कि डाउन कास्टिंग प्रक्रिया वैकल्पिक है। प्रक्रिया सफल हो सकती है या नहीं (यदि सिस्टम विफल हो जाता है तो डाउन कास्टिंग विफल हो जाती है)। यदि डाउन कास्टिंग विफल हो जाती है तो कोई भी दुर्घटना नहीं होगी।

as! Type?- यहां डाउन कास्टिंग की प्रक्रिया सफल होनी चाहिए (जो !इंगित करता है)। अंतिम प्रश्न चिह्न इंगित करता है कि अंतिम परिणाम शून्य हो सकता है या नहीं।

"के बारे में अधिक जानकारी!" तथा "?"

हम 2 मामले लेते हैं

1. विचार करें:

   let cell = tableView.dequeueReusableCellWithIdentifier("Cell") as? UITableViewCell

   यहाँ हम यह नहीं जानते कि यूआईटेबल व्यूसेल के लिए पहचानकर्ता "सेल" के साथ सेल के डाउन कास्टिंग का परिणाम सफल है या नहीं। यदि असफल होता है तो यह शून्य लौटता है (इसलिए हम यहां दुर्घटना से बचते हैं)। यहां हम नीचे दिए गए अनुसार कर सकते हैं।

   if let cell = tableView.dequeueReusableCellWithIdentifier("Cell") as? UITableViewCell {
       // If we reached here it means the down casting was successful
   }
   else {
       // unsuccessful down casting
   }

   तो आइए हम इसे इस तरह से याद करते हैं - यदि ?इसका मतलब है कि हम निश्चित नहीं हैं कि मूल्य शून्य है या नहीं (प्रश्न चिह्न तब आता है जब हम चीजों को नहीं जानते हैं)।

2. इसके विपरीत:

   let cell = tableView.dequeueReusableCellWithIdentifier("Cell") as! UITableViewCell. 

   यहां हम संकलक को बताते हैं कि डाउन कास्टिंग सफल होना चाहिए। यदि यह विफल रहता है तो सिस्टम क्रैश हो जाएगा। इसलिए हम देते हैं !जब हमें यकीन है कि मूल्य गैर शून्य है।

Answer 3

वेवामा ने क्या कहा, यह स्पष्ट करने के लिए, यहाँ एक उदाहरण है ...

स्विफ्ट 3.0:

import UIKit

let str_value:    Any   = String("abc")!
let strOpt_value: Any?  = String("abc")!
let strOpt_nil:   Any?  = (nil as String?)
let int_value:    Any   = Int(1)
let intOpt_value: Any?  = Int(1)
let intOpt_nil:   Any?  = (nil as Int?)

// as String
//str_value     as String // Compile-Time Error: 'Any' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//strOpt_value  as String // Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//strOpt_nil    as String // Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//int_value     as String // Compile-Time Error: 'Any' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//intOpt_value  as String // Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//intOpt_nil    as String // Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?

// as? String
  str_value     as? String // == "abc"
  strOpt_value  as? String // == "abc"
  strOpt_nil    as? String // == nil
  int_value     as? String // == nil
  intOpt_value  as? String // == nil
  intOpt_nil    as? String // == nil

// as! String
  str_value     as! String // == "abc"
  strOpt_value  as! String // == "abc"
//strOpt_nil    as! String // Run-Time Error: unexpectedly found nil while unwrapping an Optional value.
//int_value     as! String // Run-Time Error: Could not cast value of type 'Swift.Int' to 'Swift.String'.
//intOpt_value  as! String // Run-Time Error: Could not cast value of type 'Swift.Int' to 'Swift.String'.
//intOpt_nil    as! String // Run-Time Error: unexpectedly found nil while unwrapping an Optional value.

// as String?
//str_value     as String? // Compile-Time Error: cannot convert value of type 'Any' to type 'String?' in coercion
//strOpt_value  as String? // Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?
//strOpt_nil    as String? // Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?
//int_value     as String? // Compile-Time Error: cannot convert value of type 'Any' to type 'String?' in coercion
//intOpt_value  as String? // Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?
//intOpt_nil    as String? // Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?

// as? String?
//str_value     as? String? // Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
  strOpt_value  as? String? // == "abc"
  strOpt_nil    as? String? // == nil
//int_value     as? String? // Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
  intOpt_value  as? String? // == nil
  intOpt_nil    as? String? // == nil

// as! String?
//str_value     as! String? // Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
  strOpt_value  as! String? // == "abc"
  strOpt_nil    as! String? // == nil
//int_value     as! String? // Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
//intOpt_value  as! String? // Run-Time Error: Could not cast value of type 'Swift.Int' to 'Swift.String'.
  intOpt_nil    as! String? // == nil

// let _ = ... as String
//if let _ = str_value    as String { true } // Compile-Time Error: 'Any' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//if let _ = strOpt_value as String { true } // Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//if let _ = strOpt_nil   as String { true } // Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//if let _ = int_value    as String { true } // Compile-Time Error: 'Any' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//if let _ = intOpt_value as String { true } // Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?
//if let _ = intOpt_nil   as String { true } // Compile-Time Error: 'Any?' is not convertible to 'String'; did you mean to use 'as!' to force downcast?

// let _ = ... as? String
if let _ = str_value    as? String { true } // true
if let _ = strOpt_value as? String { true } // true
if let _ = strOpt_nil   as? String { true } // false
if let _ = int_value    as? String { true } // false
if let _ = intOpt_value as? String { true } // false
if let _ = intOpt_nil   as? String { true } // false

// let _ = ... as! String
//if let _ = str_value    as! String { true } // Compile-Time Error: initializer for conditional binding must have Optional type, not 'String'
//if let _ = strOpt_value as! String { true } // Compile-Time Error: initializer for conditional binding must have Optional type, not 'String'
//if let _ = strOpt_nil   as! String { true } // Compile-Time Error: initializer for conditional binding must have Optional type, not 'String'
//if let _ = int_value    as! String { true } // Compile-Time Error: initializer for conditional binding must have Optional type, not 'String'
//if let _ = intOpt_value as! String { true } // Compile-Time Error: initializer for conditional binding must have Optional type, not 'String'
//if let _ = intOpt_nil   as! String { true } // Compile-Time Error: initializer for conditional binding must have Optional type, not 'String'

// let _ = ... as String?
//if let _ = str_value    as String? { true } // Compile-Time Error: cannot convert value of type 'Any' to type 'String?' in coercion
//if let _ = strOpt_value as String? { true } // Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?
//if let _ = strOpt_nil   as String? { true } // Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?
//if let _ = int_value    as String? { true } // Compile-Time Error: cannot convert value of type 'Any' to type 'String?' in coercion
//if let _ = intOpt_value as String? { true } // Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?
//if let _ = intOpt_nil   as String? { true } // Compile-Time Error: 'Any?' is not convertible to 'String?'; did you mean to use 'as!' to force downcast?

// let _ = ... as? String?
//if let _ = str_value    as? String? { true } // Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
  if let _ = strOpt_value as? String? { true } // true
  if let _ = strOpt_nil   as? String? { true } // true
//if let _ = int_value    as? String? { true } // Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
  if let _ = intOpt_value as? String? { true } // false
  if let _ = intOpt_nil   as? String? { true } // true

// let _ = ... as! String?
//if let _ = str_value    as! String? { true } // Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
  if let _ = strOpt_value as! String? { true } // true
  if let _ = strOpt_nil   as! String? { true } // false
//if let _ = int_value    as! String? { true } // Compile-Time Error: cannot downcast from 'Any' to a more optional type 'String?'
//if let _ = intOpt_value as! String? { true } // Run-Time Error: Could not cast value of type 'Swift.Int' to 'Swift.String'.
  if let _ = intOpt_nil   as! String? { true } // false

स्विफ्ट 2.0:

import UIKit

let str:    AnyObject   = String("abc")
let strOpt: AnyObject?  = String("abc")
let strNil: AnyObject?  = (nil as String?)
let int:    AnyObject   = Int(1)
let intOpt: AnyObject?  = Int(1)
let intNil: AnyObject?  = (nil as Int?)

str    as? String // == "abc"
strOpt as? String // == "abc"
strNil as? String // == nil
int    as? String // == nil
intOpt as? String // == nil
intNil as? String // == nil

str    as! String? // Compile-Time Error: Cannot downcast from 'AnyObject' to a more optional type 'String?'
strOpt as! String? // == "abc"
strNil as! String? // == nil
int    as! String? // Compile-Time Error: Cannot downcast from 'AnyObject' to a more optional type 'String?'
intOpt as! String? // Run-Time Error: Could not cast value of type '__NSCFNumber' to 'NSString'
intNil as! String? // == nil

Comments

आपके उदाहरण के लिए +1 लेकिन क्या आप मुझे उसी उदाहरण के साथ समझा सकते हैं जैसे कि उपयोग करने के लिए! के स्थान पर? जबकि सेल के रूप में डाउनकास्टिंग करते हुए = tableView.dequeueReusableCellWithIdentifier ("सेल") को! UITableViewCell..i के रूप में अनुमान है? पर्याप्त था क्यों की जरूरत के रूप में था!

— अनीश पराजुली

चलो सेल = tableView.dequeueReusableCellWithIdentifier ("सेल") के रूप में? UITableViewCell। - यहाँ हम यह नहीं जानते कि यूआईटेबल व्यूसेल के लिए पहचानकर्ता "सेल" के साथ सेल की डाउन कास्टिंग का परिणाम शून्य है या नहीं। यदि शून्य है तो यह शून्य लौटाता है (इसलिए हम यहां दुर्घटना से बचते हैं)।

— जिष्णु बाला

दिलचस्प है, intNil as! String? // ==nilदुर्घटना का कारण नहीं बनता है !!! ???, वैकल्पिक के रूप में <Int>। कोई वैकल्पिक <string> से अलग है। कोई

— onmyway133

आप खिन्न क्यों as?करने के लिए String? आप इसे डाउनकास्ट क्यों नहीं करते String?? तुम क्यों खिन्न नहीं as!करने के लिए String?

— Honey

इस खेल के मैदान को स्विफ्ट 3 में करने का प्रयास किया जा रहा है, लेकिन आपको Anyइसके बजायAnyObject

— Honey

Answer 4

• as उपयोग करने के लिए इस्तेमाल किया और टाइप करने के लिए कास्टिंग प्रकार bridged करने के लिए
• as? सुरक्षित कास्टिंग के लिए उपयोग किया जाता है, यदि विफल हो तो वापसी करें
• as! कास्ट करने के लिए उपयोग किया जाता है, यदि विफल रहा तो क्रैश

ध्यान दें:

• as! वैकल्पिक करने के लिए कच्चे प्रकार कास्ट नहीं कर सकते

उदाहरण:

let rawString: AnyObject = "I love swift"
let optionalString: AnyObject? = "we love swift"
let nilString: AnyObject? = (nil as String?)

let rawInt: AnyObject = Int(3)
let optionalInt: AnyObject? = Int(3)
let nilInt: AnyObject? = (nil as Int?)

---

उदाहरण

var age: Int? = nil
var height: Int? = 180

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

जब हमें "का उपयोग करना चाहिए?" और कब "!"

मान लीजिए कि हमारे पास UIKit आधारित सरल ऐप है। हमारे पास हमारे व्यू कंट्रोलर में कुछ कोड है और इसके ऊपर एक नया व्यू कंट्रोलर प्रस्तुत करना चाहता है। और हमें नेविगेशन कंट्रोलर का उपयोग करके स्क्रीन पर नए दृश्य को पुश करने का निर्णय लेने की आवश्यकता है।

जैसा कि हम जानते हैं कि प्रत्येक ViewController उदाहरण में एक संपत्ति नेविगेशन नियंत्रक है। यदि आप नेविगेशन कंट्रोलर आधारित ऐप बना रहे हैं तो आपके ऐप के मास्टर व्यू कंट्रोलर की यह संपत्ति अपने आप सेट हो जाती है और आप इसका इस्तेमाल कंट्रोलर्स को पुश या पॉप करने के लिए कर सकते हैं। यदि आप एकल एप्लिकेशन प्रोजेक्ट टेम्पलेट का उपयोग करते हैं - तो आपके लिए स्वचालित रूप से बनाया गया नेविगेशन नियंत्रक नहीं होगा, इसलिए आपके ऐप के डिफ़ॉल्ट दृश्य नियंत्रक के पास नेविगेशनकंट्रोलर संपत्ति में संग्रहीत कुछ भी नहीं होगा।

मुझे यकीन है कि आप पहले से ही अनुमान लगा चुके हैं कि यह एक वैकल्पिक डेटाटाइप के लिए एक मामला है। यदि आप UIViewController की जाँच करते हैं, तो आप देखेंगे कि संपत्ति के रूप में परिभाषित किया गया है:

var navigationController: UINavigationController? { get }

तो चलिए अपने उपयोग के मामले पर वापस आते हैं। यदि आप इस तथ्य के लिए जानते हैं कि आपके दृश्य नियंत्रक में हमेशा एक नेविगेशन नियंत्रक होगा जिसे आप आगे बढ़ सकते हैं और इसे खोल सकते हैं:

controller.navigationController!.pushViewController(myViewController, animated: true)

जब आप एक डाल! संपत्ति के नाम के पीछे आप संकलक को बताएं कि मुझे परवाह नहीं है कि यह संपत्ति वैकल्पिक है, मुझे पता है कि जब यह कोड निष्पादित होता है तो हमेशा एक मूल्य स्टोर होगा इसलिए इस वैकल्पिक को एक सामान्य डेटाटाइप की तरह व्यवहार करें। अच्छा है कि अच्छा नहीं है? हालांकि अगर आपके व्यू कंट्रोलर के लिए नेविगेशन कंट्रोलर नहीं है तो क्या होगा? यदि आप सुझाव देते हैं कि हमेशा नेविगेशनकोंट्रोलर में संग्रहीत मूल्य गलत होगा? आपका ऐप क्रैश हो जाएगा। सरल और बदसूरत के रूप में।

तो, का उपयोग करें! केवल अगर आप 101% सुनिश्चित हैं कि यह सुरक्षित है।

कैसे के बारे में यदि आप सुनिश्चित नहीं हैं कि हमेशा एक नेविगेशन नियंत्रक होगा? तब आप उपयोग कर सकते हैं? के बजाय एक !:

controller.navigationController?.pushViewController(myViewController, animated: true)

क्या ? प्रॉपर्टी के नाम के पीछे कंपाइलर बताता है कि मुझे नहीं पता कि इस प्रॉपर्टी में एनआईएल है या वैल्यू है, इसलिए: अगर इसका वैल्यू यूज है, और ओटवाइज सिर्फ पूरे एक्सप्रेशन को मानते हैं। प्रभावी रूप से? आपको उस संपत्ति का उपयोग करने की अनुमति देता है बस मामले में एक नेविगेशन नियंत्रक है। किसी प्रकार की जाँच या किसी भी प्रकार की कास्टिंग नहीं। यह सिंटैक्स सही है जब आपको परवाह नहीं है कि आपके पास एक नेविगेशन नियंत्रक है या नहीं, और केवल तभी कुछ करना चाहता है।

फंताजेक के लिए बहुत धन्यवाद

Answer 5

वे स्विफ्ट में डाउनकास्टिंग के दो अलग-अलग रूप हैं ।

( as?) , जिसे कंडिशनल फॉर्म के रूप में जाना जाता है , उस प्रकार का एक वैकल्पिक मान देता है जिसे आप डाउनकास्ट करने का प्रयास कर रहे हैं।

आप इसका उपयोग तब कर सकते हैं जब आप सुनिश्चित नहीं हैं कि डाउनकास्ट सफल होगा। ऑपरेटर का यह रूप हमेशा एक वैकल्पिक मान लौटाएगा, और डाउनकास्ट संभव नहीं होने पर मूल्य शून्य हो जाएगा। यह आपको एक सफल डाउनकास्ट की जांच करने में सक्षम बनाता है।

---

( as!) , जिसे फोर्स्ड फॉर्म के रूप में जाना जाता है , डाउनकास्ट का प्रयास करता है और बल को एकल यौगिक क्रिया के रूप में उजागर करता है।

आपको इसका उपयोग केवल तभी करना चाहिए जब आप सुनिश्चित हों कि डाउनकास्ट हमेशा सफल होगा। यदि आप गलत श्रेणी प्रकार के डाउनकास्ट करने का प्रयास करते हैं, तो ऑपरेटर का यह रूप एक रनटाइम त्रुटि को ट्रिगर करेगा ।

अधिक जानकारी के लिए, कृपया Apple के प्रलेखन के प्रकार कास्टिंग अनुभाग की जाँच करें ।

Answer 6

हो सकता है कि यह कोड उदाहरण किसी व्यक्ति को सिद्धांत को समझने में मदद करेगा:

var dict = [Int:Any]()
dict[1] = 15

let x = dict[1] as? String
print(x) // nil because dict[1] is an Int

dict[2] = "Yo"

let z = dict[2] as! String?
print(z) // optional("Yo")
let zz = dict[1] as! String // crashes because a forced downcast fails


let m = dict[3] as! String?
print(m) // nil. the forced downcast succeeds, but dict[3] has no value

Comments

इसके अलावा, z2 = तानाशाही [2] के रूप में! स्ट्रिंग // "यो" (वैकल्पिक नहीं)

— जे

Answer 7

पहला एक "सशर्त कास्ट" है (मेरे द्वारा लिंक किए गए दस्तावेज़ में "टाइप-कास्टिंग ऑपरेटरों" के तहत देखें) । यदि कास्ट सफल होता है, तो अभिव्यक्ति का मूल्य वैकल्पिक में लिपट जाता है और वापस आ जाता है, अन्यथा लौटाया गया मान शून्य होता है।

दूसरे का अर्थ है कि वैकल्पिक स्ट्रिंग एक स्ट्रिंग ऑब्जेक्ट हो सकता है या यह शून्य हो सकता है।

इस संबंधित प्रश्न में अधिक जानकारी मिली ।

Answer 8

स्विफ्ट में इन ऑपरेटरों के लिए पैटर्न को याद रखना सबसे आसान हो सकता है: !इसका मतलब है कि "यह फंस सकता है," जबकि ?इंगित करता है "यह शून्य हो सकता है।"

यहां देखें: https://developer.apple.com/swift/blog/?id=23

Answer 9

मैं स्विफ्ट के लिए नौसिखिया हूं और इस उदाहरण को लिखने की कोशिश कर रहा हूं क्योंकि मैं 'वैकल्पिक' के बारे में समझता हूं। अगर मैं ग़लत हूँ तो कृपया मुझे सही कीजियेगा।

धन्यवाद।

---

class Optional {

    var lName:AnyObject! = "1"

    var lastName:String!
}

let obj = Optional()

print(obj.lName)

print(obj.lName!)

obj.lastName = obj.lName as? String

print(obj.lastName)

---

(1): obj.lastName = obj.lName as! String

बनाम

(२): obj.lastName = obj.lName as? String

उत्तर: (1) यहाँ प्रोग्रामर यह सुनिश्चित करता है कि “obj.lName”स्ट्रिंग प्रकार ऑब्जेक्ट है। तो बस उस मूल्य को दे “obj.lastName”।

अब, यदि प्रोग्रामर सही है "obj.lName"तो स्ट्रिंग टाइप ऑब्जेक्ट है, तो कोई समस्या नहीं है। "obj.lastName" समान मान पर सेट होगा।

लेकिन अगर प्रोग्रामर गलत है "obj.lName", तो स्ट्रिंग प्रकार ऑब्जेक्ट नहीं है, अर्थात इसमें कुछ अन्य प्रकार की वस्तु जैसे "NSNumber" आदि हैं, फिर CRASH (रन टाइम एरर)।

(2) प्रोग्रामर सुनिश्चित नहीं है कि “obj.lName”स्ट्रिंग प्रकार ऑब्जेक्ट या किसी अन्य प्रकार ऑब्जेक्ट है। तो यह मान सेट करें “obj.lastName”यदि यह स्ट्रिंग प्रकार है।

अब, यदि प्रोग्रामर सही है “obj.lName”तो स्ट्रिंग टाइप ऑब्जेक्ट है, तो कोई समस्या नहीं है। “obj.lastName”उसी मूल्य पर सेट होगा।

लेकिन अगर प्रोग्रामर गलत है तो इसका मतलब है कि obj.lName स्ट्रिंग प्रकार ऑब्जेक्ट नहीं है, अर्थात इसमें कुछ अन्य प्रकार की ऑब्जेक्ट जैसे "NSNumber"आदि हैं । फिर “obj.lastName”शून्य मान पर सेट हो जाएगा। तो, नो क्रैश (हैप्पी :)