Swift Language
कास्टिंग टाइप करें

वाक्य - विन्यास

• let name = json["name"] as? String ?? "" // आउटपुट: जॉन

• let name = json["name"] as? String // Output: Optional("john")

• let name = rank as? Int // Output: Optional(1)

• let name = rank as? Int ?? 0 // Output: 1

• let name = dictionary as? [String: Any] ?? [:] // Output: ["name" : "john", "subjects": ["Maths", "Science", "English", "C Language"]]

downcasting

एक चर प्रकार के संचालकों के as? उपयोग करके एक उपप्रकार में परिवर्तन किया जा सकता है as? , और as! ।

के as? ऑपरेटर एक उपप्रकार में डालने का प्रयास करता है।
यह विफल हो सकता है, इसलिए यह एक वैकल्पिक रिटर्न देता है।

let value: Any = "John"

let name = value as? String
print(name) // prints Optional("John")

let age = value as? Double
print(age) // prints nil

के as! ऑपरेटर एक कलाकारों को मजबूर करता है।
यह एक वैकल्पिक वापस नहीं करता है, लेकिन अगर कलाकार विफल रहता है तो क्रैश हो जाता है।

let value: Any = "Paul"

let name = value as! String
print(name) // prints "Paul"

let age = value as! Double // crash: "Could not cast value…"

सशर्त अलंकृत के साथ टाइप कास्ट ऑपरेटरों का उपयोग करना आम है:

let value: Any = "George"

if let name = value as? String {
    print(name) // prints "George"
}

if let age = value as? Double {
    print(age) // Not executed
}

स्विच के साथ कास्टिंग

switch स्टेटमेंट का उपयोग विभिन्न प्रकारों में कास्टिंग का प्रयास करने के लिए भी किया जा सकता है:

func checkType(_ value: Any) -> String {
    switch value {

    // The `is` operator can be used to check a type
    case is Double:
        return "value is a Double"

    // The `as` operator will cast. You do not need to use `as?` in a `switch`.
    case let string as String:
        return "value is the string: \(string)"

    default:
        return "value is something else"
    }

}

checkType("Cadena")  // "value is the string: Cadena"
checkType(6.28)      // "value is a Double"
checkType(UILabel()) // "value is something else"

upcasting

ऑपरेटर के as एक सुपरपेप को डाली जाएगी। के रूप में यह विफल नहीं हो सकता, यह एक वैकल्पिक वापस नहीं करता है।

let name = "Ringo"
let value = string as Any  // `value` is of type `Any` now

सबक्लासिंग वाले फ़ंक्शन पैरामीटर पर डाउनकास्ट का उपयोग करने का उदाहरण

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

class Rat {
    var color = "white"
}

class PetRat: Rat {
    var name = "Spot"
}

func nameOfRat(🐭: Rat) -> String {
    guard let petRat = (🐭 as? PetRat) else {
        return "No name"
    }
    
    return petRat.name
}

let noName = Rat()
let spot = PetRat()

print(nameOfRat(noName))
print(nameOfRat(spot))

टाइप करें स्विफ्ट लैंग्वेज में

कास्टिंग टाइप करें

टाइप कास्टिंग एक उदाहरण के प्रकार की जांच करने का एक तरीका है, या उस उदाहरण को अपने स्वयं के वर्ग पदानुक्रम में कहीं और से एक अलग सुपरक्लास या उपवर्ग के रूप में माना जाता है।

स्विफ्ट में टाइप कास्टिंग को ऑपरेटर्स के साथ लागू किया जाता है। ये दो ऑपरेटर एक मूल्य के प्रकार की जांच करने के लिए एक सरल और अभिव्यंजक तरीका प्रदान करते हैं या एक अलग प्रकार के लिए एक मूल्य डालते हैं।

downcasting

एक निश्चित वर्ग प्रकार का एक स्थिर या चर वास्तव में पर्दे के पीछे एक उपवर्ग का उदाहरण हो सकता है। जहां आप मानते हैं कि यह मामला है, आप उप-प्रकार के प्रकार को डाउन कास्ट ऑपरेटर (जैसे (या!)!) के साथ डाउनकास्ट करने का प्रयास कर सकते हैं।

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

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

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

स्ट्रिंग टू इंट एंड फ्लोट रूपांतरण: -

     let numbers = "888.00"
     let intValue = NSString(string: numbers).integerValue
     print(intValue) // Output - 888

     
     let numbers = "888.00"
     let floatValue = NSString(string: numbers).floatValue
     print(floatValue) // Output : 888.0

स्ट्रिंग से रूपांतरण रूपांतरण

    let numbers = 888.00
    let floatValue = String(numbers) 
    print(floatValue) // Output : 888.0

    // Get Float value at particular decimal point 
    let numbers = 888.00
    let floatValue = String(format: "%.2f", numbers) // Here %.2f will give 2 numbers after decimal points we can use as per our need
    print(floatValue) // Output : "888.00"

स्ट्रिंग मूल्य के लिए पूर्णांक

    let numbers = 888
    let intValue = String(numbers)
    print(intValue) // Output : "888"

फ्लोटिंग से स्ट्रिंग मान

    let numbers = 888.00
    let floatValue = String(numbers)
    print(floatValue)

स्ट्रिंग के लिए वैकल्पिक फ्लोट मूल्य

    let numbers: Any = 888.00
    let floatValue = String(describing: numbers)
    print(floatValue) // Output : 888.0

Int मान के लिए वैकल्पिक स्ट्रिंग

    let hitCount = "100"
    let data :AnyObject = hitCount
    let score = Int(data as? String ?? "") ?? 0
    print(score)

JSON से डाउनकास्टिंग मान

    let json = ["name" : "john", "subjects": ["Maths", "Science", "English", "C Language"]] as [String : Any]
    let name = json["name"] as? String ?? ""
    print(name) // Output : john
    let subjects = json["subjects"] as? [String] ?? []
    print(subjects) // Output : ["Maths", "Science", "English", "C Language"]

वैकल्पिक JSON से डाउनकास्टिंग मान

    let response: Any = ["name" : "john", "subjects": ["Maths", "Science", "English", "C Language"]]
    let json = response as? [String: Any] ?? [:]
    let name = json["name"] as? String ?? ""
    print(name) // Output : john
    let subjects = json["subjects"] as? [String] ?? []
    print(subjects) // Output : ["Maths", "Science", "English", "C Language"]

स्थितियों के साथ JSON प्रतिक्रिया का प्रबंधन करें

    let response: Any = ["name" : "john", "subjects": ["Maths", "Science", "English", "C Language"]] //Optional Response 
    
    guard let json = response as? [String: Any] else {
        // Handle here nil value
        print("Empty Dictionary")
        // Do something here
        return
    }
    let name = json["name"] as? String ?? ""
    print(name) // Output : john
    let subjects = json["subjects"] as? [String] ?? []
    print(subjects) // Output : ["Maths", "Science", "English", "C Language"]

निल रिस्पॉन्स को कंडीशन के साथ मैनेज करें

    let response: Any? = nil
    guard let json = response as? [String: Any] else {
        // Handle here nil value
        print("Empty Dictionary")
        // Do something here
        return
    }
    let name = json["name"] as? String ?? ""
    print(name) 
    let subjects = json["subjects"] as? [String] ?? []
    print(subjects) 

आउटपुट: Empty Dictionary