Tuplas

Después de investigar exactamente qué es una Tupla, ya que no creo que el video explique exactamente qué es, es como un tipo de Array y Objeto que puede tener diferente tipos de variables dentro aunque es más fácil verlo como un Objeto.

Ahora, en este tipo de lenguajes de programación siempre es buena idea no dejar sin declarar el tipo de variables que tendrá la Tupla (Tuple en inglés). La forma de hacerlo es de la siguiente forma:

let httpError: (Int, String) = (404, "Page not found") // Si quieren crearlo como un tipo de Array
let httpErrorObject: (errorType: Int, message: String) = (errorType: 404, message: "Page not found") // Si quieren tratarlos como Objetos

viniendo de js esto es el hijo de un array + un JSON

let pokemon = (name:"MewTwo", type:"mitico", age:100)
print("Hola humanos soy \(pokemon.name) tengo mas de \(pokemon.age) años entrenando y mi poder \(pokemon.type) los destruira a todos")

Comparándolo con Python es parecido a los diccionarios de este lenguaje.
Y ojo las tuplas de python (arrays no modificables) son estructuras de datos diferentes a las tuplas de Swift.

//Reto TUPLAS
let person = (nombre: "Wilson", apellido: "Montenegro", edad: 33)
print("Hola me llamo \(person.nombre) \(person.apellido) y tengo \(person.edad) años")

Hacer esto en Swift

let http202Created = (202, "Created")
let (statusCode, message) = http202Created

Me recuerda mucho al hacer una destructuración en JS:

const http202Created = { code: 202, message: "Created" }
const { code, message } = http202Created

Pues en TypeScript si que existen jeje.
No será lo mismo, pero puede que a alguien le sirva:

TS:

const notFoundResponse: [number, string] = [404, "Page not Found"];

//Access to the array tuple values
notFoundResponse[0]
notFoundResponse[1]

Se lo traduce de Swift:

let http404Error = (404, "Page not found")

//Decompose a tuple's contents into separate constants or variable
let (statusCode, statusMessage) = http404Error

print("StatusCode: \(statusCode)")
print("StatusMessage: \(statusMessage)")

una pequeña corrección, las tuplas sí existen en otros lenguajes, de hecho las tuplas en c# se manejan casi que de la misma manera que en swift

//TUPLA
let myPersonalInfo = (edad: 30, nombre: "Oscar", appellido: "Gonzalez")
print("Hola! yo me llamo: \(myPersonalInfo.nombre) \(myPersonalInfo.appellido) y tengo \(myPersonalInfo.edad) años de edad")```

Les comparto mi código 😃

let MyProfile = (name: "Bradley", lastName: "Cardenas", age: 20)
print("Hola, me llamo \(MyProfile.name) \(MyProfile.lastName) y tengo \(MyProfile.age) años" )

ejercicio

Si vienes de React el ejemplo mas claro de una Tupla es un useState, esto ya lo tienen varios lenguajes o super sets de lenguajes como TypeScript

let persona: (edad: Int, nombre: String, apellido: String) = (25, “Jhon”, “Miranda”)
print(“Nombre completo: (persona.nombre) (persona.apellido)”)
print(“Edad: (persona.edad)”)

let User = ( username: "Ronaldo", age: 23, lastname: "avalos")
print("Hola me llamo \(User.username) \(User.lastname) y tengo \(User.age) años")

Lo mas parecido a una Tupla en kotlin es:

val http404Error = Pair<Int, String>(404, "Object not found")

Por que es cierto eso de que en otros lenguajes es medio raro 😝

//Crear tuppla con nombre y edad
let perfilInfo = (name: "Camilo", age: 28)
print("Hola 👋🏼,  mi nombre es \(perfilInfo.name) y tengo \(perfilInfo.age) años")

Es como la destructuración de js

Siempre recuerden intentar dejar claro en todo momento el tipo de variable, para evitar en un futuro errores y ahorrar memoria en datos muy grandes. En una dupla tambien se puede declarar el tipo de dato de la siguiente manera.

let informationOfPerson:(name: String, lastName:String, age:Int8) = ("Alfonso", "Patron", 24)

print("Hola, mi nombre es \(informationOfPerson.name) \(informationOfPerson.lastName) y tengo \(informationOfPerson.age)")

let datos = (edad: 18, primerNombre: yerson, segundoNombre: steven)
print("hola mi nombre es: \(datos.primerNombre) \(datos.segundoNombre) y tengo \(datos.edad)")

Swift es una belleza 😍

Esto se parece a los Maps en Dart

Map persona = {
	'name' : 'Jonathan",
	true : 28,
	19 : [1,'gi',true]
	}

No sabia que las tuplas permitian más de 2 valores, siempre las vi como un mapa, key and value

let personalDate: (name: String, lastname: String, age: Int8) =  (name: "Fernando", lastname: "Romero", age: 25)

print("Hola mi nombre es", personalDate.name, personalDate.lastname, "y tengo", personalDate.age, "años")

Resuelvo el desafío, swift es genial!

let datosJavier = (nombre: "Javier", edad: 28, apellido: "Ayora", deporte: "CrossFit")

print("Hola soy \(datosJavier.nombre) me apellido \(datosJavier.apellido) tengo \(datosJavier.edad) y hago \(datosJavier.deporte) para mantenerme saludable")

Hola soy Javier me apellido Ayora tengo 28 y hago CrossFit para mantenerme saludable

espero este bien xd

let date = (28, "Sebastian Arluna", "Argentinian")
let (Age, Name, Nacionality) = date

print("I am \(age) years old, my name is \(Name), I am \(Nacionality)")

let dateName = (Age : 29, Name : "Sebastian", Nacionality : "Argentinian")

print("I am \(dateName.Age) years old, my name is \(dateName.Name), I am \(dateName.Nacionality)")

Muy bien explicado.

let myInformation = (name: "Sergio", lastName: "Medina", age: 26)
print("Hola, me llamo \(myInformation.name) \(myInformation.lastName) y tengo \(myInformation.age) años" )

Veo que con las tuplas y el typealias también podemos crear algo como las interfaces, ya que podemos podemos indicar la estructura y tipos de datos de una tupla. Siguiendo con el ejemplo de la clase:

typealias httpReponse = (statusCode: UInt16, description: String)

let http200Status: httpReponse = (200, "OK")
let http404Error: httpReponse = (404, "Not Found")
let http500Error: httpReponse = ("500", "Internal Error") //Esto da error por no cumplir el tipo de dato de statusCode que definimos

print("El codigo de estado es \(http200Status.statusCode) y el mensaje \(http200Status.description)")

👨🏽‍💻

let personalData = (name: "Jose", age: 23, job: "QA Analyst", hobby: "Aprender nuevos lenguajes de programación")
print("Hola, me llamo \(personalData.name), tengo \(personalData.age) años, trabajo como \(personalData.job) y mi mayor hobby es \(personalData.hobby)")

Reto realizado

Pfff, me enamoré de las tuplas.

¡Hola! Aquí dejo mi aporte aunque me ha entrado dos dudas.

• La primera es el import, he notado que el tipo de import ha cambiado automáticamente, primero fue UIkit, después cambio a CoreFundation y finalmente a Security, quisiera saber porque es que se da ese cambio.

• A parte de ello, quisiera entender también porque la var (age, name, surName) = myCompleteData puede ser un let a pesar de que *var myCompleteData = (25,“Kenyi Wilson”,“Zuñiga Teran”) es una var y no un let.

PD: Dentro de la captura verán que está con var, pero si en el código lo ponen como let, verán que no saltará ninguna alerta.
¡Quedo atento, muchas gracias!

import UIKit
import CoreFoundation
import Security

var myCompleteData = (25,"Kenyi Wilson","Zuñiga Teran")
var (age, name, surName) = myCompleteData // ¿Por qué puedo usar let?

print("Hola mi nombre es \(myCompleteData.1)\(myCompleteData.2) y tengo \(myCompleteData.0) años de edad.")

SWIFT no es el unico lenguaje que ocupa tuplas. Y hay lenguajes como elixir que permite mas implementaciones con las tuplas y con el pattern matching hasta el punto de poder lograr control flow

Muy buena la clase, pero typeScript también cuenta con tuplas.

Mi propuesta para utilizar tuplas

let personInfo = (name:"Emmanuel",lastName:"H. Ramirez",age:21)

print("""
      Hello my name is 
      \(personInfo.name) \(personInfo.lastName) 
      and I'm \(personInfo.age) years old
      """)

Así es como he hecho el ejercicio propuesto:

let yo = (nombre: "Francisco Javier", apellidos: "Gallego Lahera", edad: 21)
print("Hola, me llamo \(yo.nombre) \(yo.apellidos) y tengo \(yo.edad) años")

Les comparto mí código:

Resultado:

//Reto Tuplas
let myInfo = (age: 22, firstName: "Ricardo", lastName: "Saenz")
print("Hola! mi nombre es \(myInfo.firstName) \(myInfo.lastName) y tengo \(myInfo.age) años")

Acá va el reto completado

let myProfile = (age: 32, firstName: Andres, lastName: Galo)
print(“Hola mi nombres es \(myProfile.firstName)  \(myProfile.lastName) y tengo \(myProfile.age) años de edad”)

My solucion 😃

// tupla --> Edad, Nombre, apellido | luego saludar a usuario

let myInformation = (name: "Gabo", lastName: "Munoz", myAge: 22)

print("Hola soy \(myinformation.name) \(myinformation.lastName) y tengo \(myinformation.myAge) anios de edad") 

El reto resuelto:

let persona = (edad: 31, nombre: "Ivan", apellido: "Mazzalay")
print("El usuario se llama \(persona.nombre) \(persona.apellido) y su edad es \(persona.edad) años")

Reto : Crear una tupla donde aparezca edad, nombre y apellido y con print hacer una oracion

let ejercicio = (edad: 24, nombre : "Andre", apellido: "Bezada")
print("Hola me llamo \(ejercicio.nombre) \(ejercicio.apellido) y tengo \(ejercicio.edad) años de edad") 

Viniendo de python esto me hace recordar a un diccionario

😃

let profile = (name: "Andrea", age:28)
print("Hola, mi nombre es: \(profile.name) y tengo \(profile.age) años ")

let saludo = (nombre: "Carlos", apellido: "Quintana", edad: 42)
print("Hola me llamo \(saludo.nombre) \(saludo.apellido) y tengo \(saludo.edad) años")

En C# 7.0 ya existen las tuplas!

aca va mi ejemplo

let tuplaejemplo = (17, "cami")
let (edad, nombre) = tuplaejemplo
print("Hola, mi nombre es \(nombre)")
print(" Y tengo \(edad) años")

let russianPassportDates = (93062833, “Carlos Adrian Valdes”, “Masculino”)
let (numero, nombre, sexo) = russianPassportDates

print(“El pasajero (russianPassportDates.1) de sexo (russianPassportDates.2), con numnero de pasaporte (russianPassportDates.0) puede ingresar al pais.”)

let me = (name: "José", surname: "Puicon", age: "22")
print("Mi nombre es: \(me.name), mi apellido: \(me.surname) y mi edad es \(me.age) años")

let myself = (name: "Lionel", surname: "Messi" , age: 33)
print("mi nombre es \(myself.name) mi apellido es \(myself.surname) y mi edad es \(myself.age)")

La actividad

let miInformation = (name: "Gera", lastName: "Martinez", age: 25)
print("Mi nombre es \(miInformation.name) \(miInformation.lastName) y tengo \(miInformation.age) años.")

Pienso que en el futuro me será útil tener las tuplas dentro de un array, así que lo hice.

//Creo una variable de tipo array que recibe tuplas
var macoteList : [(name : String, edad : UInt8)] = []

//Creo las tuplas
let perro = (name : "Vincent", edad : UInt8(12))
let gato = (name : "Annie", edad : UInt8(1))

//Agrego las tublas al array
macoteList.append( perro )
macoteList.append( gato )

//Imprimo el nombre del primer registro
print("Hola \(macoteList[0].name) estas viejito")

let iAm = (username: "nix1124", age: 17);
print("Hi, my username in Platzi is: \(iAm.username), and my age is \(iAm.age)");

// Excercise Tuplas

var nameAndSurname = ( name : "Francisco", surname: "Garcia")
var myAge : UInt8 = 25


print("My name is \(nameAndSurname.name) , \(nameAndSurname.surname) and I'm \(myAge) years old")

let data = (nombre: "Donaldo", apellido: "Lopez", edad: 25)
print("Hola mi nombre es \(data.nombre) \(data.apellido) y tengo \(data.edad)")

//RETO

let personalData = (name : "Jonathan", lastName: "Macalupu", age: 31)

print("¡Hola Mundo!, soy \(personalData.name) \(personalData.lastName) y tengo \(personalData.age) años")

Muy buena clase comparto mi código

//En caso de que quiera separar un resultado en tupla y asignarlo a variables se hace
let (statusCode, statusMessage) = http404Error
print(“El códifo del estado es (statusCode)”)
print(“El mensaje del servidor es (statusMessage)”)

/se puede extaer las tuplas sin necesidad de crear variables colocando punto y numero de posición como en un arreglo
print(“El código código del error es (http404Error.0) y el mensajes es (http404Error.1)”)

//otra manera de realizarlo una tapla es colocando las 2 variables directamente en la asignación
let http200Status = (statusPage: 200, description: “OK”)
print(“el código del estado es (http200Status.statusPage) y el mensaje es (http200Status.description)”)

Les comparto mi código:

	 let myInformation = (name: "Marisol", lastName: "Reyes", age: 25)
          print("Mi nombre es \(myInformation.name) \(myInformation.lastName) y tengo \(myInformation.age)")

Nunca habia escuchado sobre Tuplas, pero el concepto es conocido como los arreglos y los hashes, excelente clase

Hay dos formas de acceder a los valores de una tupla
La primera es que con el valor que hayamos escrito

Ejem

let httpError = (404, “Pagina no encontrada”)
print =(htttpError.404)

y la segunda forma de acceder es mediante la posición en la que se encuentra parecido de alguna forma a los arrays

print(htttpError.0)

Uno de los mejores usos que se les darán a las tuplas serán para retornar multiples valores de una función

logre comprender como las tuplas pueden facilitar el realizar muchas tareas y que no es complicado poder implementarlas

Me parece un lenguaje muy parecido a Python en cuanto a estructuras de datos.

var misDatos = (nombre: "jonymac", edad: 31)
print("mi nombre es \(misDatos.nombre) y mi edad es \(misDatos.edad)")```

//Reto: Edad nombre y apellido
let presentacion = (nombre: "Juanse", apellido: "Vargas", edad: 26)

print("Hola soy \(presentacion.nombre) \(presentacion.apellido) y tengo \(presentacion.edad) años")
//Output: Hola soy Juanse Vargas y tengo 26 años

let miNombreCompleto = (nombre: "Fernando", primerApellido: "Paredes", segundoApellido: "Rios")
print("Mi nombre completo es: \(miNombreCompleto.nombre) \(miNombreCompleto.primerApellido) \(miNombreCompleto.segundoApellido)")
**```

El concepto de las tuplas en swift me parecio genial, me diverti mucho en esta clase.

Algo muy similar se puede hacer en C#

let person = (name : "Arturo" , age : 42)
print("Hola me llamo \(person.name) y tengo \(person.age) años")