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
Compila el código anterior y se obtiene el siguiente código JavaScript:
JavaScript
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
Compila el código anterior y se obtiene el siguiente código JavaScript:
JavaScript
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
// 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
Compila el código anterior y se obtiene el siguiente código JavaScript:
JavaScript
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
Compila el código anterior y se obtiene el siguiente código JavaScript:
JavaScript
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
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 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 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
// 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
// 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 tuple2: [boolean] = [true];
let extendedTuple: [number, string, ...typeof tuple2] = [42, "Hello", ...tuple2];
console.log(extendedTuple); // Salida: [42, "Hello", true]