Tuplas de TypeScript

Sabemos que los tipos de datos de los elementos en un array suelen ser los mismos (los arrays de tipo any[] pueden ser diferentes). Si los tipos de datos de los elementos almacenados son diferentes, entonces se necesitan usar tuplas.

Una tupla en TypeScript es un tipo especial de array que permite almacenar diferentes tipos de elementos en el array. A diferencia de los arrays normales, cada elemento en una tupla tiene un tipo y una posición definidos. Las tuplas se pueden usar en muchos escenarios para representar estructuras de datos de longitud fija con tipos de elementos conocidos.

La sintaxis para crear una tupla es la siguiente:

let tuple: [类型1, 类型2, 类型3, ...];

Ejemplo

Declarar una tupla e inicializarla:

let mytuple: [number, string];
mytuple = [42,"Ejemplo"];

En el ejemplo anterior, mytuple es una tupla que contiene un elemento de tipo number y un elemento de tipo string.

Acceder a las tuplas

Los elementos de una tupla se acceden mediante índices. El índice del primer elemento es 0, el segundo es 1, y así sucesivamente, el enésimo es n-1. La sintaxis es la siguiente:

tuple_name[index]

Ejemplo

El siguiente ejemplo define una tupla que contiene elementos de dos tipos: numérico y cadena:

TypeScript

let mytuple: [number, string, boolean] = [42, "Ejemplo", true]; //Acceder a los elementos de la tupla let num = mytuple[0]; //Acceder al primer elemento, valor 42, tipo number let str = mytuple[1]; //Acceder al segundo elemento, valor "Ejemplo", tipo string let bool = mytuple[2]; //Acceder al tercer elemento, valor true, tipo boolean console.log(num); //Salida: 42 console.log(str); //Salida: Ejemplo console.log(bool); //Salida: true

Compila el código anterior y se obtiene el siguiente código JavaScript:

JavaScript

var mytuple = [42, "Ejemplo", true]; //Acceder a los elementos de la tupla var num = mytuple[0]; //Acceder al primer elemento, valor 42, tipo number var str = mytuple[1]; //Acceder al segundo elemento, valor "Ejemplo", tipo string var bool = mytuple[2]; //Acceder al tercer elemento, valor true, tipo boolean console.log(num); //Salida: 42 console.log(str); //Salida: Ejemplo console.log(bool); //Salida: true

El resultado de salida es:

42
Ejemplo
true

Operaciones con tuplas

Podemos usar las siguientes dos funciones para agregar nuevos elementos a la tupla o eliminar elementos:

  • push() agrega un elemento a la tupla, añadiéndolo al final.

  • pop() elimina un elemento de la tupla (el último) y devuelve el elemento eliminado.

El método push puede agregar un elemento al final de la tupla, y el tipo debe cumplir con las restricciones de tipo definidas en la tupla. Si excede las restricciones de tipo de la tupla, TypeScript mostrará un error.

TypeScript

var tuple = [42, "Hello"]; //Agregar un elemento que cumple con el tipo tuple.push("World"); //Válido, porque la tupla define un tipo string opcional console.log(tuple); //Salida: [42, "Hello", "World"]

Compila el código anterior y se obtiene el siguiente código JavaScript:

JavaScript

var tuple = [42, "Hello"]; //Agregar un elemento que cumple con el tipo tuple.push("World"); //Válido, porque la tupla define un tipo string opcional console.log(tuple); //Salida: [42, "Hello", "World"]

El resultado de salida es:

[ 42, 'Hello', 'World' ]

El método pop elimina un elemento del final de la tupla y devuelve ese elemento. El tipo del elemento devuelto se inferirá según el tipo definido de la tupla.

Ejemplo

let tuple: [number, string, boolean] = [42, "Hello", true];

// Eliminar el último elemento
let lastElement = tuple.pop();

console.log(lastElement); // Salida: true
console.log(tuple);       // Salida: [42, "Hello"]

Actualizar tuplas

Las tuplas son mutables, lo que significa que podemos realizar operaciones de actualización en ellas:

TypeScript

var mytuple = [42, "Ejemplo", "Taobao", "Google"]; //Crear una tupla console.log("El primer elemento de la tupla es:" + mytuple[0]) //Actualizar el elemento de la tupla mytuple[0] = 121 console.log("El primer elemento de la tupla se actualiza a:"+ mytuple[0])

Compila el código anterior y se obtiene el siguiente código JavaScript:

JavaScript

var mytuple = [42, "Ejemplo", "Taobao", "Google"]; //Crear una tupla console.log("El primer elemento de la tupla es:" + mytuple[0]); //Actualizar el elemento de la tupla mytuple[0] = 121; console.log("El primer elemento de la tupla se actualiza a:" + mytuple[0]);

El resultado de salida es:

元组的第一个元素为:42
元组中的第一个元素更新为:121

Desestructurar tuplas

También podemos asignar los elementos de una tupla a variables, como se muestra a continuación:

TypeScript

let a: [number, string, boolean] = [42, "Hello", true];//Crear una tupla var [b,c] = a console.log( b ) console.log( c )

Compila el código anterior y se obtiene el siguiente código JavaScript:

JavaScript

var a = [42, "Hello", true]; //Crear una tupla var b = a[0], c = a[1]; console.log(b); console.log(c);

El resultado de salida es:

42
Hello

Usar tuplas etiquetadas

TypeScript también permite agregar etiquetas a cada elemento de la tupla, lo que hace que el significado de la tupla sea más claro:

let tuple: [id: number, name: string] = [1, "John"];

En este ejemplo, id y name son las etiquetas de la tupla, lo que hace que el código sea más legible.


Aplicaciones prácticas de las tuplas

Las tuplas se usan a menudo en escenarios donde una función devuelve múltiples valores, o para representar datos con una estructura fija, por ejemplo:

Ejemplo

function getUserInfo(): [number, string] {
    return [1, "John Doe"];
}

const [userId, userName] = getUserInfo();
console.log(userId);   // Salida: 1
console.log(userName); // Salida: John Doe

Inferencia de tipos en tuplas

TypeScript puede inferir automáticamente el tipo de una tupla según los elementos del array:

let tuple = [42, "Hello"] as const; // 元组类型:[42, "Hello"]

Mediante la aserción as const, TypeScript tratará esta tupla como una tupla constante inmutable.


Concatenar tuplas

Las tuplas se pueden concatenar usando el método concat de los arrays, pero ten en cuenta que el resultado de la concatenación es un array normal, no una tupla.

Ejemplo

let tuple1: [number, string] = [42, "Hello"];
let tuple2: [boolean, number] = [true, 100];

let result = tuple1.concat(tuple2); // El resultado es un array: [42, "Hello", true, 100]
console.log(result); // Salida: [42, "Hello", true, 100]

Cortar tuplas

Puedes usar el método slice de los arrays para realizar una operación de corte en la tupla, que devuelve un nuevo array.

Ejemplo

let tuple: [number, string, boolean] = [42, "Hello", true];

let sliced = tuple.slice(1); // Cortar desde el índice 1
console.log(sliced); // Salida: ["Hello", true]

Iterar sobre tuplas

Puedes usar el bucle for...of o el método forEach para iterar sobre los elementos de la tupla.

Ejemplo

let tuple: [number, string, boolean] = [42, "Hello", true];

// Usar el bucle for...of
for (let item of tuple) {
    console.log(item);
}

// Usar el método forEach
tuple.forEach(item => console.log(item));

Convertir a un array normal

Aunque una tupla es un array de longitud fija y tipo fijo, se puede convertir en un array normal mediante los métodos de Array.prototype para un procesamiento posterior.

Ejemplo

let tuple: [number, string, boolean] = [42, "Hello", true];

// Convertir a array y usar métodos de array
let array = Array.from(tuple);
array.push("New Element");

console.log(array); // Salida: [42, "Hello", true, "New Element"]

Expandir tuplas

Usando el operador de propagación, se pueden combinar fácilmente varias tuplas en una nueva tupla:

Ejemplo

let tuple1: [number, string] = [42, "Hello"];
let tuple2: [boolean] = [true];

let extendedTuple: [number, string, ...typeof tuple2] = [42, "Hello", ...tuple2];

console.log(extendedTuple); // Salida: [42, "Hello", true]
Otras extensiones