A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Tupla

15/32
Recursos

Aportes 27

Preguntas 10

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

Una tupla en TypeScript es un array de elementos que est谩n tipados. De esta manera cada vez que haya que insertar un elemento se validar谩 que dicho elemento coincida con el tipo de dato establecido en la tupla.

Genial me gusta mas usar la notaci贸n

let matriz: Array<[number, string, boolean]> = [];
// Tipo tuple
// Tuplas: permiten expresar un arreglo con un numero fijo de elementos

export {}; // -> user ya fue declarado en otro archivo

// [1, 'user']
let user: [number, string]; // -> user ya fue declarado en otro archivo
user = [1, 'luixaviles'];

console.log('user : ', user);
console.log('username : ', user[1]);
console.log('username.length : ', user[1].length);
console.log('id : ', user[0]);

// Tuplas con varios valores
// id, username, isPro
let userInfo: [number, string, boolean];
userInfo = [2, 'paparazzi', true];
console.log('userInfo : ', userInfo);

// Arreglo de Tuplas
let array: [number, string][] = [];
array.push([1, 'luixaviles']);
array.push([2, 'paparazzi']);
array.push([3, 'lensQueen']);   // indice: 2
console.log('array : ', array);

// Uso de funciones array
// lensQueen --> lensQueen001
array[2][1] = array[2][1].concat('001');  // --> concatena
console.log('array : ', array);

este curso hay que verlo a 1.5

Me surge un problema con el arreglo de tuplas.

Error en consola:

驴Qu茅 estoy haciendo mal?

Me sorprende que el profesor diga esto鈥 y que nadie a煤n lo haya comprobado. Las tuplas si pueden tener mas de una vez un mismo tipo. Os pongo un ejemplo que compila y ejecuta sin problemas:

let tupla: [number, string, number] = [1, 'foo', 2]
console.log('tupla', tupla)
  • En TS, las tuplas permiten expresar un arreglo con un n煤mero fijo de elementos.
  • La sintax铆s es la misma que en un array [] pero los tipos de datos deben ser distintos

Documentaci贸n oficial de Tuplas

export {} //*Exportamos un objeto vac铆o, ya que TS no permite usar los mismos nombres de variables que tenemos en otros archivos

//* [1, 'Miguel']
let user: [number, string] = [1,'Miguel']

console.log('user: ', user)
console.log('user id: ', user[0])
console.log('username length: ', user[1].length)

//* Podemos aplicar m茅todos de string a la posici贸n user[1] ya que es un string.
//*Podemos aplicar m茅todode de int a la posici贸n user[0] ya que es un int.

//*Tuplas con varios valores
let userInfo: [number, string, boolean] = [2, 'paparazzi', true]
console.log('userinfo: ', userInfo)

//* Arreglo de Tuplas
let arrayDeTuplas: [number, string][] = []
arrayDeTuplas.push([1, 'Erik']) //*0
arrayDeTuplas.push([2, 'Logan']) //*1
arrayDeTuplas.push([3, 'Xavier']) //*2

console.log('arrayDeTuplas: ', arrayDeTuplas)

//* Uso de funciones Array
//*Xavier -> Charles X

arrayDeTuplas[2][1] = arrayDeTuplas[2][1].replace('Xavier', 'Charles Xavier')

console.log('Array de mutantes: ', arrayDeTuplas)

Tupla: Permite expresar un arreglo con un numero fijo de elementos. Los tipos de datos son conocidos.
Asi se crean las tuplas.

let userInfo = [number,string];
userInfo = [1,'danijazzero'];

Se accede con indices.

userInfo[0]; // esto es 1
userInfo[1]; // esto es 'danijazzero'

Definimos arreglo de tuplas

let usersInfo = [number,string][] = [];
//usamos push para agregar users a usersInfo

Para crear matrices con valores de 鈥榗olumnas鈥 conocidas, tal cual una hoja de calculo en excel

ustedes tabmbien ven los videos en x2? jajaja

Wao esto de las tuplas se asemeja un poco en como firestore almacena los documentos, como tuplas

Tupla: Permite expresar un arreglo con un n煤mero fijo de elementos. Los tipos de datos son conocidos.

let userInfo = [number,string];
userInfo = [1,鈥榙anijazzero鈥橾;

Tuple

  • Las tuplas permiten expresar un arreglo con un n煤mero fijo de elementos
  • Los tipo de datos son conocidos
// [1, 'user']
let user: [number, string];
user = [1, "username"];

console.log({ user });
console.log("username", user[1]);
console.log("username.length", user[1].length);
console.log("id", user[0]);

// Tuplas con varios valores
// id, username, isPro
let userInfo: [number, string, boolean];
userInfo = [2, "username", true];
console.log("user info", userInfo);

// Arreglo de tuplas
let myArr: [number, string][] = [];
myArr.push([1, "username"]);
myArr.push([2, "username2"]);
myArr.push([3, "username3"]);

console.log(myArr);

Ok, cual es la diferencia entre un array normal y una tupla?

No, no solo es el nombre!! Lo que sucede, es que la tupla es un array con ciertos elementos espeficos y estos DEBEN ser de distintos tipos.

Array

Array de puros strings en este caso

let arr = string[];

Tupla

Array de distitntos tipos de datos

let tupla = [strin, boolean, number]

Tupla, array con n煤mero fijo de elementos, los tipos de dato son diferentes. se accede por indices. A los incies les puedo agregar m茅todos de cadenas.
Para hacer un array de tuplas se usan [] dsp de el tipado. Se pueden usar m茅todos para modificar las tuplas utilizando los 铆ndices (de la tupla & del 铆ndica a modificar)

Una tupla sirve para agrupar, como si fueran un 煤nico valor, varios valores que, por su naturaleza, deben ir juntos.

Un buen uso de las tuplas es hacer unpacking de variables, tipicamente como retorno de una funci贸n. e.g

let v: [string, number];
v = ['res', 1];

// Unpacking values
let [a, b] = v;
console.log(a); // 'res'
console.log(b); // 1

Comparto mi codigo espero les sirvan鈥

export {}

// 篓[1, 'user']
let user: [number, string]
user = [1, 'Juan']

console.log(user)
console.log(user[1])
console.log(user[1].length)
console.log(user[0])


// Tuplas con varios valores
// id, username, isPro
let userInfo: [number, string, boolean]
userInfo = [2, 'David', true]
console.log(userInfo)

// Arreglo de Tuplas
let array: [number, string][] = []
array.push([1,'Juan']) // 0
array.push([2,'David']) // 1
array.push([3,'Gonzalez']) //2
console.log(array)

//Uso de funciones Array
// Juan -> Juanda1803
array[0][1]=array[0][1].concat('da1803')
console.log(array)
$ node dist/type-tuple.js
[ 1, 'Juan' ]
Juan
4
1
[ 2, 'David', true ]
[ [ 1, 'Juan' ], [ 2, 'David' ], [ 3, 'Gonzalez' ] ]
[ [ 1, 'Juanda1803' ], [ 2, 'David' ], [ 3, 'Gonzalez' ] ]

Como que me esta comenzando a gustar Taipscript

export {}

//[1,'user']

let user: [number, string];
user = [1, 'aviles'];

console.log('user', user); //Output: user [1, 'aviles']
console.log('username', user[1]); //Output: username aviles
console.log('id', user[0]); //Output: id 1


//Tuplas con varios valores
// id, username, isPro
let userinfo: [number, string, boolean];
userinfo= [9890, 'Karina', true];
console.log('userinfo', userinfo); //Output: user [9890, 'Karina', true]

//Arreglo de tuplas
let array: [number, string][] =[]; //Inicializar el valor para ARRAY
array.push([1, 'julio']);
array.push([2, 'Limones']);
array.push([3, 'Lensqueen']);

console.log('array', array) // Output: array [ [ 1, 'julio' ], [ 2, 'Limones' ], [ 3, 'Lensqueen' ] ]

//Uso de funciones de Arrays

// Lensqueen -> Lensqueen001

array[2][1]= array[2][1].concat('001'); //Lensqueen001
console.log('Array[2][1]', array);

Esta interesante este lenguaje de tipado

馃憣

tuplas, interesante.

export {};

// [1, 'Luis']
console.clear();
let user: [number, string];
user = [1, 'Luis'];

console.log(user);
console.log('id', user[0]);
console.log('username', user[1]);
console.log('username', user[1].length);

// Tuplas con varios valores
// id,username,isPro
let userInfo: [number, string, boolean];
userInfo = [2, 'Luis', true];
console.log(userInfo);

// Arreglo de Tuplas
let array: [number, string][] = [];
array.push([1, 'Luis']);
array.push([2, 'Reyna']);
array.push([3, 'Rocio']);
array.push([4, 'Rodrigo']);
console.log(array);

array[2] = [3, 'Rocio Fernanda'];
console.log(array);

m

MY NOTES FOR TUPLES 馃槃

  • Las tuplas permiten expresar un arreglo con un n煤mero fijo de elementos
  • Los tipos de datos son conocidos
export {}
//Tuplas
  //En esta tumpla estre guardando dos tipos de datos
let user: [number, string];
user = [22, 'andres'];

console.log('user', user);

//Podremos acceder a la tupla normalmente como en cualquier array
  //Aaunque sea una tupla con distintos tipos de datos dependiendo de al valor
    //que estemos accediendo podremos utilizar sus respectivas funciones
console.log('user', user);
console.log('username', user[1]);
console.log('id', user[0]);

//Tuplas con varios valores
// id, username, isPro
  //Para definir tuplas debemos definir tipos de datos diferentes para cada una 
   //de las posiciones esa es una de las restricciones
let userInfo: [number, string, boolean];
userInfo = [2, 'paparazzi', true];
console.log('userInfo', userInfo);

//Arreglo de Tuplas
  //utilizamos unos [] adicionales para indicar que vamos a guardar en la variable
    //Un conjunto de tuplas
      //Dara error si solo lo declaramos y no le asignamos ningun valor
let arrayy: [number,string][] = [];
arrayy.push([1, 'andres']);
arrayy.push([2, 'andresb']);
arrayy.push([3, 'andresc']);

//Uso de funciones Array
//lensQueen -> lensQueen001
  //accedemos a la posicion de andesc y con concat le agregamos 001 y este valor se lo
    //reasignamos a esa misma posicion
arrayy[2][1] = arrayy[2][1].concat('001');
  • Expresar o representar un conjunto de elementos.
  • Es demasiado parecido a un Array y concretamente es un registro de datos, que pueden ser una estructura, una funci贸n, una variable, una constante
  • Dependiendo del tipo de datos que se encuentre en el registro de la tupla, se puede ejecutar m茅todos para el tipo de valor.
//Tuple

let userOfMine: [number, string]; 
userOfMine = [3, 'rosita'];

console.log(
    'substract of the string -> ', userOfMine[1].substr(3, 3), // Ejecuta los m茅todos del tipo de valor, en este caso un string 
    'substract of the string -> ', userOfMine[0]  // Ejecuta m茅todos de los tipos de valor number
);

//M煤ltiples tuplas expl铆citas
let tuples: Array<[number, string, boolean]> = [
    [1,'jhonsi', true],
    [2, 'afelipelds', false],
    [4, 'ivy', false],
];

tuples[2][1]= tuples[2][1].concat(' fullstack');

console.log(tuples);