Swift Language
Typ Casting

Składnia

• let name = json["name"] as? String ?? "" // Wyjście: 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

Zmienna może zostać spuszczona do podtypu za pomocą operatorów rzutowania typu as? i as! .

Jak as? operator próbuje rzutować na podtyp.
Może się nie powieść, dlatego zwraca opcję opcjonalną.

let value: Any = "John"

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

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

Jak as! operator wymusza rzut.
Nie zwraca opcjonalnego, ale ulega awarii, jeśli rzutowanie nie powiedzie się.

let value: Any = "Paul"

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

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

Często stosuje się operatory rzutowania typu z warunkowym rozpakowywaniem:

let value: Any = "George"

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

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

Przesyłanie za pomocą przełącznika

Instrukcja switch może być również używana do próby rzutowania na różne typy:

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

Operator as przerzuci się na nadtyp. Ponieważ nie może zawieść, nie zwraca wartości opcjonalnej.

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

Przykład użycia downcastu dla parametru funkcji obejmującego podklasę

Downcast może być użyty do wykorzystania kodu i danych podklasy wewnątrz funkcji przyjmującej parametr jej nadklasy.

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

Wpisz casting w Swift Language

Typ Casting

Rzutowanie typów jest sposobem sprawdzenia typu wystąpienia lub potraktowania tego wystąpienia jako innej nadklasy lub podklasy niż gdzie indziej w jej własnej hierarchii klas.

Rzutowanie typu w Swift jest realizowane za pomocą operatorów is i as. Te dwa operatory zapewniają prosty i ekspresyjny sposób sprawdzenia typu wartości lub przekazania wartości na inny typ.

Downcasting

Stała lub zmienna określonego typu klasy może faktycznie odnosić się do wystąpienia podklasy za kulisami. Jeśli uważasz, że tak jest, możesz spróbować sprowadzić do podklasy za pomocą operatora rzutowania typu (as? Lub as!).

Ponieważ upuszczanie może się nie powieść, operator rzutowania typu występuje w dwóch różnych formach. Forma warunkowa as? Zwraca opcjonalną wartość typu, do którego próbujesz sprowadzić. Forma wymuszona, as !, próbuje wykonać operację spuszczania i wymusza rozpakowanie wyniku jako pojedynczą akcję złożoną.

Użyj formy warunkowej operatora rzutowania typu (as?), Jeśli nie masz pewności, czy downcast się powiedzie. Ta forma operatora zawsze zwraca wartość opcjonalną, a wartość będzie zerowa, jeśli obniżenie nie było możliwe. Dzięki temu możesz sprawdzić, czy udało Ci się przeprowadzić downcast.

Użyj wymuszonej formy operatora rzutowania typu (as!) Tylko wtedy, gdy masz pewność, że spuszczanie zawsze się powiedzie. Ta forma operatora spowoduje błąd w czasie wykonywania, jeśli spróbujesz sprowadzić do niepoprawnego typu klasy. Wiedzieć więcej.

Konwersja ciągu na Int i 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

Konwersja typu float na string

    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"

Wartość całkowita do ciągu

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

Wartość zmiennoprzecinkowa

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

Opcjonalna wartość zmiennoprzecinkowa dla String

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

Opcjonalny ciąg do wartości Int

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

Zmniejszanie wartości z 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"]

Wartości downcasting z Opcjonalnego 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"]

Zarządzaj odpowiedzią JSON z warunkami

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

Zarządzaj zerową odpowiedzią z warunkiem

    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) 

Wyjście: Empty Dictionary