Swift Academy · Lección

Inferencia de tipos y tipos explícitos

Descubra cómo Swift infiere los tipos y cuándo debe declararlos explícitamente.

Inferencia de tipos y tipos explícitos 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.

Bienvenida

Swift es un lenguaje *tipado estáticamente*: cada valor tiene un tipo conocido en tiempo de compilación. Sin embargo, rara vez necesita escribir el tipo usted mismo, porque Swift lo infiere automáticamente.

¿Qué es la inferencia de tipos?

Swift examina el valor del lado derecho y deduce el tipo automáticamente: ```swift let message = "Hello" // inferred as String let count = 42 // inferred as Int let price = 9.99 // inferred as Double ``` No se necesita ninguna anotación de tipo: el compilador lo determina.

Anotaciones de tipo explícitas

Siempre puede indicar el tipo explícitamente utilizando dos puntos: ```swift let message: String = "Hello" let count: Int = 42 let price: Double = 9.99 ``` Esto resulta útil cuando el tipo inferido no es el que necesita.

Cuando la inferencia elige el tipo incorrecto

Los literales de coma flotante utilizan `Double` de forma predeterminada. Si necesita `Float`, anótelo explícitamente: ```swift let inferred = 3.14 // Double let explicit: Float = 3.14 // Float ``` De forma similar, los literales enteros utilizan `Int` de forma predeterminada: añada una anotación para `Int32`, `UInt8`, etc.

Seguridad de tipos en la práctica

Una vez establecido un tipo, no puede cambiarse: ```swift var score = 0 // Int score = "ten" // ❌ cannot assign String to Int ``` La seguridad de tipos detecta esta clase de errores en tiempo de compilación, mucho antes del tiempo de ejecución.

La función type(of:)

Utilice `type(of:)` para inspeccionar el tipo en tiempo de ejecución: ```swift let value = 42 print(type(of: value)) // Int let name = "Alice" print(type(of: name)) // String ``` Es útil para depurar sorpresas relacionadas con la inferencia de tipos.

Alias de tipos

`typealias` asigna un nombre nuevo a un tipo existente para mejorar la legibilidad: ```swift typealias Celsius = Double typealias UserID = Int var temperature: Celsius = 36.6 var userId: UserID = 1001 ``` Los alias de tipos son puramente estéticos: el tipo subyacente no cambia.

Anotaciones sin inicialización

Cuando declara una variable sin un valor inicial, *debe* anotar el tipo: ```swift var name: String // ✓ annotation required name = "Bob" var total: Int total = 0 ``` Swift no puede inferir un tipo si no hay ningún valor presente.

Literales numéricos y legibilidad

Swift permite utilizar guiones bajos en los literales numéricos para mejorar la legibilidad: ```swift let million = 1_000_000 let hex = 0xFF_EC_D3 let binary = 0b1111_0000 ``` El compilador ignora los guiones bajos: son puramente estéticos.

Conversión de tipos: no hay conversiones implícitas

Swift nunca convierte implícitamente entre tipos. Debe hacerlo de forma explícita: ```swift let intVal: Int = 5 let dblVal: Double = Double(intVal) // explicit conversion let sum = Double(intVal) + 2.5 ``` Esto evita errores sutiles causados por promociones numéricas no intencionadas.

Comprobación rápida

¿Qué tipo infiere Swift para `let x = 3.14`?

Resumen

Puntos clave: • Swift infiere los tipos a partir de los valores iniciales; normalmente no se necesita ninguna anotación • Las anotaciones explícitas (`: Type`) reemplazan la inferencia • Los números de coma flotante utilizan `Double` de forma predeterminada y los enteros, `Int` • No hay conversiones implícitas: utilice `Int()`, `Double()`, etc. • `type(of:)` muestra el tipo en tiempo de ejecución A continuación: los tipos básicos: números, Bool y Character.

Preguntas frecuentes

¿La lección «Inferencia de tipos y tipos explícitos» es gratis?

Sí — el texto completo de «Inferencia de tipos y tipos explícitos» 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 «Inferencia de tipos y tipos explícitos»?

Descubra cómo Swift infiere los tipos y cuándo debe declararlos explícitamente. 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 «Inferencia de tipos y tipos explícitos»?

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

let frente a var: constantes y variables
Inferencia de tipos y tipos explícitos
Números, booleanos y caracteres
Fundamentos de String e interpolación

← Volver a Swift Academy