Introducción a Swift y XCode

1

Fundamentos de Swift para Desarrollo de Apps en Apple

2

Instalación y Configuración de Xcode para Programar en Swift

Quiz: Introducción a Swift y XCode

Fundamentos de programación iOS

3

Variables, Constantes y Tipos de Datos en Swift para iOS

4

Condicionales en Swift: Uso y Ejemplos Prácticos

5

Funciones en SWIFT: Creación y Uso Eficiente en Código

6

Manejo de Datos Opcionales en Swift: Declaración y Uso Práctico

7

Manipulación de Arrays en Swift: Declaración, Acceso e Inserción

8

Manipulación de Elementos en Arreglos con Swift

9

Uso de Conjuntos (Sets) en Xcode: Declaración y Manipulación

10

Operaciones Básicas con Conjuntos en Programación

11

Diccionarios en Swift: Creación, Modificación y Eliminación de Datos

12

Ciclos While en Swift: Ejecución Condicional Repetitiva

13

Ciclo For en Swift: Ejemplos y Aplicaciones Prácticas

14

Simulación de Batalla Pokémon en Swift

Quiz: Fundamentos de programación iOS

POO en iOS

15

Programación Orientada a Objetos con SWIFT: Clases y Objetos

16

Creación de Structs en Swift para Gestión de Materias

17

Clases y Herencia en Swift: Diferencias entre Class y Struct

18

Uso de Enumerables (Enums) en Swift para Datos Limitados

19

Protocolos en Swift: Creación e Implementación Práctica

20

Funciones avanzadas para manipulación de arreglos en programación

21

Gestión de Estudiantes con Programación Orientada a Objetos en SWIFT

Quiz: POO en iOS

Manejo de errores y programación segura

22

Manejo Seguro de Errores y Opcionales en Swift

23

Errores personalizados en Swift: creación y manejo eficaz

24

Manejo de Errores en Swift con Try, Do y Catch

Quiz: Manejo de errores y programación segura

Programación en el ecosistema de Apple

25

Fundamentos de Programación en Swift para iOS

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Variables, Constantes y Tipos de Datos en Swift para iOS

3/25
Recursos

¿Qué son las variables y constantes en Swift?

Al adentrarnos en el mundo del desarrollo con Swift, es crucial entender las variables y constantes. Imaginémonos que son pequeñas cajas donde almacenamos fragmentos de información para utilizar más adelante. La programación consiste en dar instrucciones claras a una computadora para ejecutar tareas, y las variables y constantes son esenciales para ello. Pero, ¿cuál es la diferencia entre ambos?

¿Cómo declarar variables y constantes?

En Swift, se declara una constante con la palabra reservada let, lo que indica que su valor no cambiará durante la ejecución del programa. Si intentas modificarla, Xcode generará un error. Por otro lado, las variables se declaran con var, permitiendo modificar su valor a lo largo del tiempo. Observemos un ejemplo básico:

let firstConstant = 10 // Una constante, su valor no cambia
var secondVariable = 20 // Una variable, su valor puede cambiar

¿Qué tipos de datos manejan?

Los tipos de datos fundamentales en Swift incluyen los números (enteros y decimales), las cadenas de caracteres (strings) y los valores booleanos. Vamos a explorarlos más a fondo:

  1. Enteros y decimales: Los números sin decimales se conocen como integers o int, y los números con decimales como double. Se pueden realizar operaciones matemáticas entre ellos.
  2. Strings: Son cadenas de caracteres utilizados para representar texto. Se encierran entre comillas.
  3. Booleanos: Solo tienen dos valores posibles, true o false. Son fundamentales para la lógica de control.

Ejemplo de declaración de diferentes tipos de datos:

var myFirstString = "Hello World" // String
let firstDouble = 10.5 // Double
var isTrue = true // Booleano

¿Qué operaciones se pueden realizar?

Operaciones con números

En Swift, puedes realizar operaciones matemáticas básicas, como la suma, resta, multiplicación y división. Es importante notar que el resultado de la división entre enteros devuelve otro entero.

let numberOne = 10
let numberTwo = 20
let sum = numberOne + numberTwo // Resultado: 30

Concatenación de strings

La concatenación de strings se realiza usando el operador + que une dos o más cadenas. También puedes integrar variables dentro de strings utilizando la interpolación.

let greeting = "Hola"
let name = "Mundo"
let welcomeMessage = "\(greeting) \(name)!" // Resultado: "Hola Mundo!"

Operaciones con booleanos

Las operaciones lógicas como or (||) y and (&&) son fundamentales:

  • or: Devuelve true si al menos una de las condiciones es verdadera.

  • and: Devuelve true solo si ambas condiciones son verdaderas.

    let isOnline = true
    let isAvailable = false
    let canChat = isOnline && isAvailable // Resultado: false

¿Cómo hacer definiciones explícitas de tipos de datos?

Swift infiere los tipos de datos al momento de declarar la variable, pero también puedes definirlos explícitamente, lo cual es útil en ciertas circunstancias específicas.

var anotherString: String = "Hello Again"
var specificInt: Int = 42

¿Cómo se realizan las impresiones en consola?

Para mostrar información en la consola, se utiliza print(). Es útil para depurar y verificar el comportamiento del código.

let userName = "Tiago"
let welcomeMessage = "Bienvenido, \(userName), al curso de Swift"
print(welcomeMessage) // Muestra: Bienvenido, Tiago, al curso de Swift

¿Cómo realizar un pequeño desafío?

Finalmente, te desafío a imprimir el número de caracteres en un string. Investiga cómo usar .count en cadenas para expresar la longitud de un nombre dado:

let name = "Tiago"
print("El número de caracteres en el nombre es: \(name.count)")

Aportes 15

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

```js let name = "Miguel" let numberCharacters = "Number of characters in the name: \(name.count)" print(numberCharacters) ```
*Constante* `let firstConstant = 10` *Variable* `var secondVarible = 20` *Actualiza su valor de la variable* `secondVarible = 10` *Cadena de caracteres* `var myfirstString = "Hello World"` *Tipo de dato con punto decimal* `var myfirstDouble = 2.0` *Tipo de dato* `var myfirstBool = true` *Se especifica explícitamente tipo de dato* ```txt var otherString: String = "Hello World 2" var otherInt: Int = 10 var otherDouble: Double = 2.0 var otherBool: Bool = true ``` ***Operaciones*** *Suma de dos variables* ```txt var n1 = 10 var n2 = 20 var sum = n1 + n2 ``` *Resta* `var res = n1 - n2` *Multiplicación* `var mult = n1 * n2` *Division* `var div = n1 / n2` *El resultado fue 0 por que interpreta que el tipo de dato es entero* *El resultado exacto 0.5* *Division entre tipo de dato Double* ```txt var n3: Double = 10 var n4: Double = 20 var division2 = n3 / n4 ``` *Concatenación* ```txt var s1 = "Hola" var s2 = "mundo" var concatenacion = s1 + " " + s2 ``` *Datos Booleanos* `var b1 = true` `var b2 = false` *OR* `var or = b1 || b2` *AND* `var and = b1 && b2` *Uso de concatenación de Strings* *Bienvenida al usuario* ```txt let name = "Miguel" let greeting = "Hola! \(name), Estas en el curso de Swift." print(greeting) ```
//other way to concatenate **let** name = "John" **let** lastName = "Doe" **let** greeting = "Hello \\(name) \\(lastName)" print(greeting) print("the number of characters in the name is \\(name.count)")
```js let name = "Jesse" let numberCharacters = "Numero de caracteres en el nombre es: \(name.count)" print(numberCharacters) ```
![](https://static.platzi.com/media/user_upload/codye-2c6bd273-34a4-40c8-a98d-9fe9270cb045.jpg)
```txt let name = "Ivan" let numberCharacters = "Number of characters in the name: \(name.count)" print(numberCharacters) ```
/\* Variables, constantes y tipos de datos básicos Clase 3/25 • Curso de Swift para Apps iOS \*/ //Constante **let** firstConstant = 10 //Variable **var** secondVarible = 20 //Actualiza su valor de la variable secondVarible = 10 //Cadena de caracteres **var** myfirstString = "Hello World" //Tipo de dato con punto decimal **var** myfirstDouble = 2.0 //Tipo de dato **var** myfirstBool = **true** //Se especifica explícitamente tipo de dato **var** otherString: String = "Hello World\_2" **var** otherInt: Int = 10 **var** otherDouble: Double = 2.0 **var** otherBool: Bool = **true** //Operaciones //Suma de dos variables **var** n1 = 10 **var** n2 = 20 **var** sum = n1 + n2 //Resta **var** res = n1 - n2 //Multiplicacion **var** mult = n1 \* n2 //Division **var** div = n1 / n2 /\*El resultado fue 0 por que interpreta que el tipo de dato es entero El resultado exacto 0.5 \*/ //Division entre tipo de dato Double **var** n3: Double = 10 **var** n4: Double = 20 **var** division2 = n3 / n4 //Concatenación **var** s1 = "Hola" **var** s2 = "mundo" **var** concatenacion = s1 + " " + s2 //Datos Booleanos **var** b1 = **true** **var** b2 = **false** //OR **var** or = b1 || b2 //AND **var** and = b1 && b2 //Uso de concatenacion de Strings //Bienvenida al usuario P.E **let** name = "Daniel" **let** grethings = "Hola! \\(name), Estas en el curso de Swift." print(grethings)
````js /* Variables, constantes y tipos de datos básicos Clase 3/25 • Curso de Swift para Apps iOS */ //Constante let firstConstant = 10 //Variable var secondVarible = 20 //Actualiza su valor de la variable secondVarible = 10 //Cadena de caracteres var myfirstString = "Hello World" //Tipo de dato con punto decimal var myfirstDouble = 2.0 //Tipo de dato var myfirstBool = true //Se especifica explícitamente tipo de dato var otherString: String = "Hello World_2" var otherInt: Int = 10 var otherDouble: Double = 2.0 var otherBool: Bool = true //Operaciones //Suma de dos variables var n1 = 10 var n2 = 20 var sum = n1 + n2 //Resta var res = n1 - n2 //Multiplicacion var mult = n1 * n2 //Division var div = n1 / n2 /*El resultado fue 0 por que interpreta que el tipo de dato es entero El resultado exacto 0.5 */ //Division entre tipo de dato Double var n3: Double = 10 var n4: Double = 20 var division2 = n3 / n4 //Concatenación var s1 = "Hola" var s2 = "mundo" var concatenacion = s1 + " " + s2 //Datos Booleanos var b1 = true var b2 = false //OR var or = b1 || b2 //AND var and = b1 && b2 //Uso de concatenacion de Strings //Bienvenida al usuario P.E let name = "Daniel" let grethings = "Hola! \(name), Estas en el curso de Swift." print(grethings) ```/\* Variables, constantes y tipos de datos básicos Clase 3/25 • Curso de Swift para Apps iOS \*/ //Constante **let** firstConstant = 10 //Variable **var** secondVarible = 20 //Actualiza su valor de la variable secondVarible = 10 //Cadena de caracteres **var** myfirstString = "Hello World" //Tipo de dato con punto decimal **var** myfirstDouble = 2.0 //Tipo de dato **var** myfirstBool = **true** //Se especifica explícitamente tipo de dato **var** otherString: String = "Hello World\_2" **var** otherInt: Int = 10 **var** otherDouble: Double = 2.0 **var** otherBool: Bool = **true** //Operaciones //Suma de dos variables **var** n1 = 10 **var** n2 = 20 **var** sum = n1 + n2 //Resta **var** res = n1 - n2 //Multiplicacion **var** mult = n1 \* n2 //Division **var** div = n1 / n2 /\*El resultado fue 0 por que interpreta que el tipo de dato es entero El resultado exacto 0.5 \*/ //Division entre tipo de dato Double **var** n3: Double = 10 **var** n4: Double = 20 **var** division2 = n3 / n4 //Concatenación **var** s1 = "Hola" **var** s2 = "mundo" **var** concatenacion = s1 + " " + s2 //Datos Booleanos **var** b1 = **true** **var** b2 = **false** //OR **var** or = b1 || b2 //AND **var** and = b1 && b2 //Uso de concatenacion de Strings //Bienvenida al usuario P.E **let** name = "Daniel" **let** grethings = "Hola! \\(name), Estas en el curso de Swift." print(grethings) ````
```js //Uso de concatenacion de Strings //Bienvenida al usuario P.E let name = "Daniel" let grethings = "Hola! \(name), Estas en el curso de Swift." print(grethings) /*RETO: Cuantos caracteres tiene la variable name*/ let characterCout = name.count print("El número de caracteres en el nombre: \(name): \(characterCout)") ```//Uso de concatenacion de Strings //Bienvenida al usuario P.E **let** name = "Daniel" **let** grethings = "Hola! \\(name), Estas en el curso de Swift." print(grethings) /\*RETO: Cuantos caracteres tiene la variable name\*/ **let** characterCout = name.count print("El número de caracteres en el nombre: \\(name): \\(characterCout)")
ChatGPT me dijo que la diferencia entre variable y constante está en el compilador, los bits utilizados para una variable n = 7 no se diferencian de los bits utilizados para una constante n = 7
// "let" se aplica para una constante **let** const1 = 1 // "var" es para crear variables **var** const2 = 2 const2 = 32 // string **var** my1ststring = "Hello World" // floating number **var** my1stdouble = 3.14 // boolean expresion **var** my1stbool = **true** // Se puede tener variables explícitas **let** constStr: String = "hola como estas?" **let** constDouble: Double = 3.0001 **let** constBool: Bool = **true** //Se pueden hacer operaciones entre ellos mismos y otros tipos de datos con ciertas restricciones y se procede con cuidado **var** n1 = 10 **var** n2 = 20 **var** suma = n1 + n2 **var** resta = n1 - n2 **var** multi = n1 \* n2 **var** divi = n1 / n2 //Suma de 10.0 y 20.0 es: 30.0 print("Suma de", n1, "y", n2, "es: \\(suma)") //Resta: -10.0 print("Resta: \\(resta)") //Multiplicacion: 200.0 print("Multiplicacion: \\(multi)") print("Division: \\(divi)") //Division: 0 debido a que se que se asume que son int //para lograr que se opere con regularidad se puede //definir el tipo de viriable, y no es necesario poner el . //también funciona como float **var** n3: Double = 10 **var** n4: Double = 20 **var** n5: Float = 10 **var** n6: Float = 20 //De esta manera puedes dividir con normalidad print("La nueva división, ya corregida es: \\(n3 / n4)") //La nueva división, ya corregida es: 0.5 print("La división de flotantes es: \\(n5 / n6)") //Operar datos str, string o de texto: **var** s1 = "Hola" **var** s2 = "Mundo" // En la siguiente linea está la concatenación que está representada // por el símbolo de suma, tener en consideración que la concatenación // junta inmediatamente las variables, luego del último caracter **var** s3 = s1 + " " + s2 print(s3) //Operar datos tipo bool, boolean, booleanos: **var** b1 = **true** **var** b2 = **false** // en booleanos el operado "or" es representado como || una de las // varibales a operar tiene que ser verdadero para que el // resultado sea verdadero **var** or = b1 || b2 // para el operadon "and" se tiene que representar con el doble ampersent // o sea &&, mabas variables tienen que ser verdadero para que // el resultado sea verdadero **var** and = b1 && b2 //Imaginando que queremos saludar a alguien dentro de la aplicación //principal, podemos hacer lo siguiente: **let** nombreUsuario = "Marcelo" **let** greeting = "¡Hola, \\(nombreUsuario)!" // De esta manera podemos agregar la variable al string print(greeting) //Reto: hacer que muestre la cantidad de caracteres print(nombreUsuario.count)
print("Ingresa tu nombre:") if let nombre = readLine() { print("Tu nombre es: \\(nombre)") print("La cantidad de caracteres en tu nombre es: \\(nombre.count)") }
el reto: print("La cantidad de caracteres en el nombre \\(name) es de \\(name.count)")
var name = "ORI" print("Número de caracteres en el nombre: \\(name.count) .")
print(name.count)