Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Tuplas

15/22
Recursos

Aportes 60

Preguntas 7

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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

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
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")

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

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)")

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
//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

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.”)

PHP permite tuplas tambien.
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")