Swift Language
Casting de type

Syntaxe

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

Une variable peut être réduite à un sous-type en utilisant les opérateurs as? type cast as? et as! .

Le as? l'opérateur tente de convertir en sous-type.
Il peut échouer, donc il retourne une option.

let value: Any = "John"

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

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

Le as! l'opérateur force un casting.
Il ne renvoie pas une option, mais se bloque si la distribution échoue.

let value: Any = "Paul"

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

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

Il est courant d'utiliser des opérateurs de type cast avec un dépliage conditionnel:

let value: Any = "George"

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

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

Coulée avec interrupteur

L'instruction switch peut également être utilisée pour tenter de convertir en différents types:

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'opérateur as jettera un supertype. Comme il ne peut pas échouer, il ne retourne pas une option.

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

Exemple d'utilisation d'un downcast sur un paramètre de fonction impliquant un sous-classement

Un downcast peut être utilisé pour utiliser le code et les données d'une sous-classe à l'intérieur d'une fonction en prenant un paramètre de sa super-classe.

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

Type casting en langue rapide

Casting de type

Le transtypage est un moyen de vérifier le type d'une instance ou de traiter cette instance comme une super-classe ou une sous-classe différente de quelque part dans sa propre hiérarchie de classes.

Le type casting dans Swift est implémenté avec les opérateurs is et as. Ces deux opérateurs fournissent un moyen simple et expressif de vérifier le type d'une valeur ou de convertir une valeur en un type différent.

Downcasting

Une constante ou une variable d'un certain type de classe peut en fait se référer à une instance d'une sous-classe en coulisse. Lorsque vous pensez que cela est le cas, vous pouvez essayer de réduire à un type de sous-classe avec un opérateur de type cast (comme? Ou comme!).

Le downcasting pouvant échouer, l'opérateur de type cast se présente sous deux formes différentes. La forme conditionnelle, comme?, Renvoie une valeur facultative du type que vous essayez de réduire à. La forme forcée, as !, tente la diffusion descendante et force le défilement du résultat en une seule action composée.

Utilisez la forme conditionnelle de l'opérateur de type cast (comme?) Lorsque vous n'êtes pas sûr que le downcast réussira. Cette forme de l'opérateur renverra toujours une valeur facultative et la valeur sera nulle si le downcast n'était pas possible. Cela vous permet de vérifier la réussite d'un downcast.

Utilisez la forme forcée de l'opérateur de type cast (comme!) Uniquement lorsque vous êtes sûr que le downcast réussira toujours. Cette forme de l'opérateur déclenchera une erreur d'exécution si vous essayez de réduire à un type de classe incorrect. Savoir plus.

String to Int & Float conversion: -

     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 to String Conversion

    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"

Entier à valeur de chaîne

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

Valeur flottante en chaîne

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

Valeur flottante facultative pour la chaîne

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

Chaîne facultative à la valeur Int

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

Valeurs de downcasting de 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"]

Valeurs de downcasting de JSON facultatif

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

Gérer la réponse JSON avec des conditions

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

Gérer la réponse Nil avec condition

    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) 

Sortie: Empty Dictionary