Conversión condicional con as?
Intente una conversión que devuelva un opcional si falla.
Conversión condicional con as? es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.
Conversión condicional
El operador de conversión condicional as? intenta realizar una conversión descendente y devuelve un opcional: el valor envuelto si tiene éxito o nil si falla.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
let maybe = a as? Dog
print(maybe != nil)El resultado es un opcional
Como la conversión puede fallar, el tipo del resultado es Dog?, no Dog. Debe desenvolverlo antes de usarlo.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
let maybe: Dog? = a as? Dog
print(type(of: maybe))Desenvolver con if let
La forma idiomática de usar as? es dentro de una vinculación if let, cuyo cuerpo solo se ejecuta cuando la conversión tiene éxito.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
if let dog = a as? Dog {
print(dog.bark())
} else {
print("Not a dog")
}Una conversión fallida devuelve nil
Cuando la instancia no es del tipo de destino, as? produce nil y se omite el cuerpo de if let.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Cat(name: "Mia")
if let dog = a as? Dog {
print(dog.bark())
} else {
print("That is not a dog")
}Combinar con guard let
También puede usar guard let para realizar la conversión al principio y salir si falla, manteniendo la ruta principal sin sangría adicional.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
func describe(_ a: Animal) {
guard let cat = a as? Cat else {
print("Not a cat")
return
}
print(cat.meow())
}
describe(Cat(name: "Mia"))
describe(Dog(name: "Rex"))Conversión condicional en bucles
Recorrer un array mixto y convertir condicionalmente cada elemento es una forma clara de tratar con seguridad distintas subclases.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let zoo: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia"), Dog(name: "Buddy")]
for a in zoo {
if let dog = a as? Dog {
print(dog.bark())
}
}Convertir a protocolos
as? también comprueba la conformidad con un protocolo: devuelve un valor si la instancia cumple el protocolo y, en caso contrario, nil.
protocol Greeter { func greet() -> String }
class Person: Greeter { func greet() -> String { return "Hi" } }
class Rock {}
let items: [Any] = [Person(), Rock()]
for item in items {
if let g = item as? Greeter { print(g.greet()) }
}Nil-coalescing después de una conversión
Puede combinar as? con el operador ?? para proporcionar un valor alternativo cuando la conversión falla.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Cat(name: "Mia")
let sound = (a as? Dog)?.bark() ?? "unknown sound"
print(sound)Encadenar llamadas de conversión opcionales
El encadenamiento opcional permite llamar a un método sobre el resultado de la conversión; la expresión completa es nil si la conversión falla.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
let bark = (a as? Dog)?.bark()
print(bark as Any)Por qué se prefiere la conversión condicional
as? nunca provoca un error: una conversión fallida simplemente produce nil. Por eso es la opción segura predeterminada para las conversiones descendentes.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let unknown: Animal = Cat(name: "Mia")
let result = unknown as? Dog
print("Crashes? No. Value is nil:", result == nil)Ejemplo resumido de conversión condicional
En conjunto: detecte un subtipo de forma segura, actúe sobre él y use una alternativa adecuada en los demás casos.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
func sound(of a: Animal) -> String {
if let d = a as? Dog { return d.bark() }
if let c = a as? Cat { return c.meow() }
return "silence"
}
print(sound(of: Dog(name: "Rex")))
print(sound(of: Cat(name: "Mia")))Comprobación rápida
Recuerde el tipo de resultado de una conversión condicional.
Resumen: conversión condicional con as?
Ha aprendido que as? realiza una conversión descendente segura y devuelve un opcional, que if let y guard let desenvuelven el caso correcto, y que nunca provoca un error porque el fallo simplemente produce nil, lo que lo convierte en el operador de conversión descendente preferido.
class Animal {
let name: String
init(name: String) { self.name = name }
}
class Dog: Animal {
func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
func meow() -> String { return name + " says Meow" }
}
let pets: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]
for p in pets {
if let d = p as? Dog { print(d.bark()) } else if let c = p as? Cat { print(c.meow()) }
}Preguntas frecuentes
¿La lección «Conversión condicional con as?» es gratis?
Sí — el texto completo de «Conversión condicional con as?» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Conversión condicional con as?»?
Intente una conversión que devuelva un opcional si falla. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Swift Academy?
No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Conversión condicional con as?»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Swift Academy?
Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Fundamentos de upcasting y downcasting
- Conversión condicional con as?
- Conversión forzada con as! y sus riesgos
- Comprobación de tipos con is