Tipos de Datos Definidos en Swift – Parte 1

Nube Colectiva

hace 1 año

En esta página:

Estuve mirando la documentación oficial de Swift y vi que tiene muchos tipos de datos, es un lenguaje de programación que es flexible en este aspecto. Si nos ponemos a pensar tiene sentido que Swift sea un lenguaje con muchos tipos de datos, ya que es el único lenguaje de programación que permite crear aplicaciones para los dispositivos Apple, al menos oficialmente lo es, entonces debe que tener los mejores recursos para que los desarrolladores puedan crear aplicaciones. En este post te compartiré todos los Tipos de Datos Definidos en Swift en Swift, vamos con ello.

Partes

Parte 1
Parte 2 (Final)

El lenguaje de programación Swift cuenta con 16 tipos de datos

Tipos de Datos Definidos en Swift – Parte 1

Los tipos de datos definidos en Swift, sono tipos propios definidos por el mismo lenguaje, veamos a continuación estos tipos de datos:

Tipo Anotación (Type Annotation)

Este tipo de dato especifica de manera explicita el tipo de dato de una variable o expresión. Empiezan con dos puntos “:” y termina con un tipo:


let unaTupla: (Double, Double) = (3.14159, 2.71828)
func unaFuncion(a: Int) { /* ... */ }

let unaTupla: (Double, Double) = (3.14159, 2.71828)

func unaFuncion(a: Int) { /* ... */ }

Una anotación puede contener una lista opcional de atributos de tipo antes del tipo.

Tipo Identificador (Type Identifier)

Este tipo se refiere a un tipo con nombre o un alias de tipo con nombre compuesto:


typealias Point = (Int, Int)
let origen: Point = (0, 0)

typealias Point = (Int, Int)

let origen: Point = (0, 0)

Tipo Tupla (Tuple Type)

Una tupla es una lista de tipos separados por comas, entre paréntesis:


var unaTupla = (top: 10, bottom: 12)  
unaTupla = (top: 4, bottom: 42) 
unaTupla = (9, 99)              
unaTupla = (left: 5, right: 5)

var unaTupla = (top: 10, bottom: 12)

unaTupla = (top: 4, bottom: 42)

unaTupla = (9, 99)

unaTupla = (left: 5, right: 5)

Todos los tipos de tupla contienen dos o más tipos, excepto Void el cual es un alias de tipo, para el tipo de tupla vacío, ().

Tipo Función (Function Type)

Este tipo representa un tipo de función, método o cierre y consta de un parámetro y un tipo de retorno separados por una flecha (->):


var operacion: (lhs: Int, rhs: Int) -> Int     // Error
var operacion: (_ lhs: Int, _ rhs: Int) -> Int // OK
var operacion: (Int, Int) -> Int               // OK

var operacion: (lhs: Int, rhs: Int) -> Int // Error

var operacion: (_ lhs: Int, _ rhs: Int) -> Int // OK

var operacion: (Int, Int) -> Int // OK

Restricciones para cierres sin escape (Restrictions for Nonescaping Closures)

Un parámetro que es una función sin escape no se puede almacenar en una propiedad, variable o constante de tipo Any, porque eso podría permitir que el valor escape.

Un parámetro que es una función sin escape no se puede pasar como argumento a otro parámetro de función sin escape. Esta restricción ayuda a Swift a realizar más comprobaciones de acceso conflictivo a la memoria en tiempo de compilación en lugar de en tiempo de ejecución:


let external: (() -> Void) -> Void = { _ in () }

func tomarDosFunciones(first: (() -> Void) -> Void, second: (() -> Void) -> Void) {
    first { first {} }       // Error
    second { second {}  }    // Error

    first { second {} }      // Error
    second { first {} }      // Error

    first { external {} }    // OK
    external { first {} }    // OK
}

let external: (() -> Void) -> Void = { _ in () }

func tomarDosFunciones(first: (() -> Void) -> Void, second: (() -> Void) -> Void) {

first { first {} } // Error

second { second {} } // Error

first { second {} } // Error

second { first {} } // Error

first { external {} } // OK

external { first {} } // OK

}

En el código anterior, ambos parámetros son funciones. Ninguno de los parámetros está marcado, por lo que, como resultado, ambos no tienen escape.takesTwoFunctions(first:second:)@escaping

Tipo Array (Array Type)

Una Array o matriz contiene diferentes elementos en su interior:


let unArray: Array<String> = ["Alex", "Brian", "Dave"]
let unArray: [String] = ["Alex", "Brian", "Dave"]

let unArray: Array<String> = ["Alex", "Brian", "Dave"]

let unArray: [String] = ["Alex", "Brian", "Dave"]

Un Array puede ser multidimensional y los valores están anidados por pares de corchetes.

Tipos Diccionarios (Dictionary Type)

Un diccionario contiene strings y números:


let unDiccionario: [String: Int] = ["Alex": 31, "Paul": 39]
let unDiccionario: Dictionary<String, Int> = ["Alex": 31, "Paul": 39]

let unDiccionario: [String: Int] = ["Alex": 31, "Paul": 39]

let unDiccionario: Dictionary<String, Int> = ["Alex": 31, "Paul": 39]

Tipo Opcional (Optional Type)

Este tipo se utiliza para representar valores que pueden estar presentes o no:


var optionalInteger: Int?
var optionalInteger: Optional<Int>

var optionalInteger: Int?

var optionalInteger: Optional<Int>

Si no proporcionas un valor inicial cuando declaras una variable o propiedad opcional, su valor predeterminado será automáticamente nil.

El lenguaje de programación Swift tiene influencia de los lenguajes Objective-C, Haskell, Rust, Ruby, Python, C#, CL, entre otros.

Ten Paciencia, lo que quiero es que conozcas bien estos tipos de datos de Swift y no llenarte el capitulo de mucho contenido porque te puedes marear y no tendrás un óptimo aprendizaje.

Nota (s)

En la siguiente parte y última, veremos un último grupo de tipos de datos que tiene el lenguaje de programación Swift.
No olvides que debemos usar la Tecnología para hacer cosas Buenas por el Mundo.

Síguenos en nuestras Redes Sociales para que no te pierdas nuestros próximos contenidos.