Swift Language
Geben Sie Casting ein

Syntax

• let name = json["name"] as? String ?? "" // Ausgabe: john

• 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

Eine Variable kann unter Verwendung der Typumwandlungsoperatoren as? und as! .

Die as? Operator versucht , in einen Untertyp umzuwandeln.
Es kann fehlschlagen, daher wird optional zurückgegeben.

let value: Any = "John"

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

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

Die as! Operator zwingt einen Abguss.
Es wird kein optionales Ergebnis zurückgegeben, stürzt jedoch ab, wenn die Besetzung fehlschlägt.

let value: Any = "Paul"

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

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

Normalerweise werden Typumwandlungsoperatoren mit bedingtem Auspacken verwendet:

let value: Any = "George"

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

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

Casting mit Schalter

Die switch Anweisung kann auch verwendet werden, um zu versuchen, in verschiedene Typen zu gießen:

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

Der as Operator wird in einen Supertyp umgewandelt. Da es nicht fehlschlagen kann, wird keine Option zurückgegeben.

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

Beispiel für die Verwendung eines Downcasts für einen Funktionsparameter, der Unterklassen umfasst

Ein Downcast kann verwendet werden, um den Code und die Daten einer Unterklasse innerhalb einer Funktion zu verwenden, wobei ein Parameter der Oberklasse verwendet wird.

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

Geben Sie Casting in Swift Language ein

Geben Sie Casting ein

Typumwandlung ist eine Möglichkeit, den Typ einer Instanz zu prüfen oder diese Instanz als eine andere Oberklasse oder Unterklasse von einer anderen Klasse in ihrer eigenen Klassenhierarchie zu behandeln.

Das Type Casting in Swift wird mit dem Ist und als Operator implementiert. Diese beiden Operatoren bieten eine einfache und ausdrucksstarke Methode, um den Typ eines Werts zu überprüfen oder einen Wert in einen anderen Typ umzuwandeln.

Downcasting

Eine Konstante oder Variable eines bestimmten Klassentyps kann sich tatsächlich auf eine Instanz einer Unterklasse hinter den Kulissen beziehen. Wenn Sie glauben, dass dies der Fall ist, können Sie versuchen, mit einem Typumwandlungsoperator (als? Oder als!) Auf den Unterklassentyp zu downcasten.

Da das Downcasting fehlschlagen kann, gibt es zwei verschiedene Formen für den Typumwandlungsoperator. Das bedingte Formular als? Gibt einen optionalen Wert des Typs zurück, zu dem Sie einen Downcast ausführen möchten. Die erzwungene Form, as! Versucht den Downcast und erzwingt das Ergebnis als eine einzelne zusammengesetzte Aktion.

Verwenden Sie die bedingte Form des Typumwandlungsoperators (als?), Wenn Sie nicht sicher sind, ob der Downcast erfolgreich ist. Diese Form des Operators gibt immer einen optionalen Wert zurück, und der Wert ist Null, wenn der Downcast nicht möglich war. So können Sie nach einem erfolgreichen Downcast suchen.

Verwenden Sie das Forced Form-Operator (als!) Nur, wenn Sie sicher sind, dass der Downcast immer erfolgreich ist. Diese Form des Operators löst einen Laufzeitfehler aus, wenn Sie versuchen, einen falschen Klassentyp zu verwenden. Mehr wissen.

Umwandlung von String in Int & Float: -

     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

Float-zu-String-Konvertierung

    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"

Integer bis String Wert

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

Float to String-Wert

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

Optionaler Float-Wert für String

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

Optionaler String bis Int-Wert

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

Downcasting-Werte von 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"]

Downcasting von Werten aus optionalem 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-Antwort mit Bedingungen verwalten

    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"]

Verwalten Sie keine Antwort mit Bedingung

    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) 

Ausgabe: Empty Dictionary