Swift Language
Tipo de fundición

Sintaxis

• let name = json["name"] as? String ?? "" // Salida: 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 variable puede reducirse a un subtipo utilizando los operadores de conversión de tipos as? , y as! .

El as? El operador intenta lanzar un subtipo.
Puede fallar, por lo tanto devuelve un opcional.

let value: Any = "John"

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

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

El as! El operador fuerza un yeso.
No devuelve un opcional, pero se bloquea si falla la conversión.

let value: Any = "Paul"

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

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

Es común usar operadores de conversión de tipos con desenvolvimiento condicional:

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 interruptor

La instrucción de switch también se puede utilizar para intentar convertir en diferentes tipos:

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

El operador as se convertirá en un supertipo. Como no puede fallar, no devuelve un opcional.

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

Ejemplo de uso de un downcast en un parámetro de función que involucra subclases

Se puede utilizar un downcast para hacer uso del código y los datos de una subclase dentro de una función que toma un parámetro de su superclase.

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

Tipo casting en Swift Language

Tipo de fundición

La conversión de tipos es una forma de verificar el tipo de una instancia, o de tratar esa instancia como una superclase o subclase diferente de otro lugar en su propia jerarquía de clases.

La conversión de tipos en Swift se implementa con los operadores de y como. Estos dos operadores proporcionan una forma simple y expresiva de verificar el tipo de un valor o convertir un valor en un tipo diferente.

Downcasting

Una constante o variable de un cierto tipo de clase puede en realidad referirse a una instancia de una subclase detrás de escena. Cuando crea que este es el caso, puede intentar reducir al tipo de subclase con un operador de conversión de tipo (como? O como!).

Debido a que el downcasting puede fallar, el operador de conversión de tipo viene en dos formas diferentes. La forma condicional, as ?, devuelve un valor opcional del tipo que está intentando reducir. La forma forzada, as !, intenta abatir y forzar el resultado como una acción compuesta única.

Utilice la forma condicional del operador de conversión de tipo (¿como?) Cuando no esté seguro de si el derrumbe tendrá éxito. Esta forma del operador siempre devolverá un valor opcional, y el valor será nulo si no fuera posible la reducción. Esto le permite verificar un descenso exitoso.

Use la forma forzada del operador de conversión de tipos (como!) Solo cuando esté seguro de que el retroceso siempre tendrá éxito. Esta forma del operador desencadenará un error de tiempo de ejecución si intenta reducir a un tipo de clase incorrecto. Saber más.

Conversión de cadena a 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

Conversión de flotar a cadena

    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"

Entero a valor de cadena

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

Flotante a valor de cadena

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

Valor flotante opcional a la cadena

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

Cadena opcional a valor de Int

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

Disminuyendo los valores 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"]

Disminución de valores desde JSON opcional

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

Gestionar JSON Response con condiciones.

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

Gestionar respuesta nula con condición

    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) 

Salida: Empty Dictionary