Swift Language
Digitare Casting

Sintassi

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

Una variabile può essere downcasted ad un sottotipo usando gli operatori di tipo cast as? e as! .

Il as? l'operatore tenta di trasmettere a un sottotipo.
Può fallire, quindi restituisce un optional.

let value: Any = "John"

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

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

Il as! l'operatore costringe un cast.
Non restituisce un optional, ma si blocca se il cast fallisce.

let value: Any = "Paul"

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

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

È comune utilizzare gli operatori cast di tipo con lo unwrapping condizionale:

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 con switch

L'istruzione switch può anche essere utilizzata per tentare la trasmissione in tipi diversi:

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

L'operatore as interpreterà un supertipo. Come non può fallire, non restituisce un optional.

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

Esempio di utilizzo di un downcast su un parametro di funzione che coinvolge sottoclassi

Un downcast può essere usato per fare uso del codice e dei dati di una sottoclasse all'interno di una funzione prendendo un parametro della sua superclasse.

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

Digita casting in Swift Language

Digitare Casting

Il cast di tipo è un modo per verificare il tipo di un'istanza o per trattare quell'istanza come una diversa superclasse o sottoclasse da un'altra parte nella propria gerarchia di classi.

Il casting di tipo in Swift è implementato con gli operatori is e as. Questi due operatori forniscono un modo semplice ed espressivo per verificare il tipo di un valore o trasmettere un valore a un tipo diverso.

downcasting

Una costante o variabile di un certo tipo di classe può effettivamente fare riferimento a un'istanza di una sottoclasse dietro le quinte. Dove credi che sia questo il caso, puoi provare a downcast al tipo di sottoclasse con un operatore di cast di tipo (come? O come!).

Poiché il downcasting può fallire, l'operatore di cast del tipo si presenta in due forme diverse. La forma condizionale, come?, Restituisce un valore facoltativo del tipo a cui si sta tentando di eseguire il downcast. La forma forzata, come !, tenta il downcast e forza-scartare il risultato come una singola azione composta.

Usa la forma condizionale dell'operatore di tipo cast (come?) Quando non sei sicuro che il downcast avrà successo. Questa forma dell'operatore restituirà sempre un valore opzionale e il valore sarà pari a zero se il downcast non fosse possibile. Ciò ti consente di verificare un downcast di successo.

Usa la forma forzata dell'operatore di tipo cast (come!) Solo quando sei sicuro che il downcast avrà sempre successo. Questa forma dell'operatore attiverà un errore di runtime se si tenta di eseguire il downcast su un tipo di classe errato. Saperne di più

Conversione da stringa a Int e 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

Conversione Float to 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"

Intero al valore di stringa

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

Converti in valore stringa

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

Valore Float facoltativo a stringa

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

Stringa facoltativa al valore Int

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

Valori di downcast da 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"]

Valori di downcast da JSON opzionale

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

Gestisci la risposta JSON con condizioni

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

Gestisci la risposta negativa con la condizione

    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) 

Uscita: Empty Dictionary