Tuplas

Posted on 2026年7月4日 by

Una tupla es una colección que almacena valores de varios tipos distintos. Las tuplas se crean usando paréntesis (). Cada tupla es por sí misma un valor independiente, su notación de tipo se escribe como (T1, T2, ...), donde T1 y T2 representan el tipo de cada miembro interno de la tupla. Las funciones pueden devolver varios resultados mediante tuplas, ya que una única tupla puede albergar cualquier cantidad de datos.

1 Usar tuplas como parámetros y valores de retorno de funciones

// Las tuplas pueden usarse tanto como parámetros de entrada como valores devueltos por una función
fn reverse(pair: (i32, bool)) -> (bool, i32) {
    // let permite desestructurar los miembros de la tupla y vincularlos a variables independientes
    let (int_param, bool_param) = pair;
    // Devuelve una nueva tupla con el orden intercambiado
    (bool_param, int_param)
}

fn main(){
    // (12, true) es una tupla binaria completa, pasada como un único parámetro
	let res = reverse((12, true));
	// Usar el índice .0 para obtener el primer elemento de la tupla devuelta
	println!("{}", res.0);
}Lenguaje del código: JavaScript (javascript)

Resultado de compilación y ejecución

E:\rustdemo\demo>rustc demo.rs

E:\rustdemo\demo>demo
trueLenguaje del código: JavaScript (javascript)

2 Definición de estructura de tupla (Tuple Struct)

#[derive(Debug)]
struct Matrix(f32, f32, f32, f32);

fn main(){
    let matrix = Matrix(1.1, 1.2, 2.1, 2.2);
    println!("{:?}", matrix);
}Lenguaje del código: PHP (php)

Estructura de tipo tupla: el nombre de la estructura va seguido directamente de paréntesis y una lista de tipos, no tiene campos con nombre, los elementos solo se distinguen por su orden;

Macro derivada #[derive(Debug)]: implementa automáticamente el rasgo Debug para la estructura, permitiendo imprimir información de depuración con {:?};

Matrix(f32,f32,f32,f32) es esencialmente una tupla especial que envuelve cuatro números de punto flotante.

Aparecerá una advertencia durante la ejecución, se puede ignorar

E:\rustdemo\demo>rustc demo.rs
warning: fields `0`, `1`, `2`, and `3` are never read
 --> demo.rs:2:15
  |
2 | struct Matrix(f32, f32, f32, f32);
  |        ------ ^^^  ^^^  ^^^  ^^^
  |        |
  |        fields in this struct
  |
  = help: consider removing these fields
  = note: `Matrix` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis
  = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default

warning: 1 warning emitted


E:\rustdemo\demo>demo
Matrix(1.1, 1.2, 2.1, 2.2)Lenguaje del código: JavaScript (javascript)

3 Tuplas largas con tipos mixtos + obtener valores mediante índices

Veamos primero un ejemplo

fn main(){

    // Tupla larga que contiene múltiples tipos de datos diferentes
    let long_tuple = (1u8, 2u16, 3u32, 4u64,
                      -1i8, -2i16, -3i32, -4i64,
                      0.1f32, 0.2f64,
                      'a', true);

    // Se pueden extraer valores internos usando los índices de la tupla
    println!("Long tuple first value: {}", long_tuple.0);
    println!("Long tuple second value: {}", long_tuple.1);
}Lenguaje del código: JavaScript (javascript)

Permite almacenar simultáneamente datos de tipos distintos (enteros sin signo, enteros con signo, números flotantes, caracteres y booleanos pueden coexistir);

Sintaxis de índices de tupla: variable_tupla.número, los índices empiezan en 0;

  • .0 accede al primer elemento,
  • .1 accede al segundo elemento;
  • y así sucesivamente…

Los índices solo pueden ser literales numéricos fijos, no se pueden usar variables como índices.

Parte no organizada a continuación——

2. Definición de estructura de tupla (Tuple Struct)


// La estructura siguiente es para ejercicios después de clase
#[derive(Debug)]
struct Matrix(f32, f32, f32, f32);
Lenguaje del código: PHP (php)

Puntos de conocimiento complementarios

  1. Estructura de tipo tupla: el nombre de la estructura va seguido de paréntesis con lista de tipos en su interior. No hay nombres de campos, los elementos solo se diferencian por su orden;
  2. Macro derivada #[derive(Debug)]: implementa automáticamente el rasgo Debug para la estructura, permitiendo imprimir información de depuración con {:?};
  3. Matrix(f32,f32,f32,f32) es esencialmente una tupla especial que envuelve cuatro números de punto flotante.

Ejemplo completo a continuación

#[derive(Debug)]
struct Matrix(f32, f32, f32, f32);

fn main() {
    // 1. Crear instancia
    let mat = Matrix(1.0, 2.0, 3.0, 4.0);

    // 2. Imprimir (se requiere #[derive(Debug)] para usar {:?})
    println!("Instancia de matriz: {:?}", mat);

    // 3. Acceder a elementos internos mediante .índice
    let a = mat.0;
    let b = mat.1;
    let c = mat.2;
    let d = mat.3;
    println!("a={}, b={}, c={}, d={}", a, b, c, d);

    // 4. Obtener valores mediante desestructuración
	// Matrix(m0, m1, m2, m3) es una coincidencia de patrones de desestructuración. m0/m1/m2/m3 son nombres de variables temporales definidos por el usuario que reciben los valores de los cuatro miembros de tupla internos de la estructura.
    let Matrix(m0, m1, m2, m3) = mat;
    println!("Desestructurar：{} {} | {} {}", m0, m1, m2, m3);
	

    // 5. Matriz mutable, modificar elementos con mut
    let mut mat_mut = Matrix(0.0, 0.0, 0.0, 0.0);
    mat_mut.0 = 10.0;
    mat_mut.3 = 99.0; // Se pueden modificar los valores
    println!("Matriz mutable: {:?}", mat_mut);
}Lenguaje del código: PHP (php)

Resultado de ejecución

E:\rustdemo\demo>demo
Instancia de matriz: Matrix(1.0, 2.0, 3.0, 4.0)
a=1, b=2, c=3, d=4
Desestructurar：1 2 | 3 4
Matriz mutable: Matrix(10.0, 0.0, 0.0, 99.0)

3 Tuplas largas con tipos mixtos + obtener valores mediante índices

fn main() {
 
    // Tupla larga que contiene múltiples tipos de datos diferentes
    let long_tuple = (1u8, 2u16, 3u32, 4u64,
                      -1i8, -2i16, -3i32, -4i64,
                      0.1f32, 0.2f64,
                      'a', true);

    // Values can be extracted from the tuple using tuple indexing.
    // Se pueden extraer valores internos usando los índices de la tupla
    println!("Long tuple first value: {}", long_tuple.0);
    println!("Long tuple second value: {}", long_tuple.1);
}
Lenguaje del código: JavaScript (javascript)

Resultado de ejecución

E:\rustdemo\demo>demo
Long tuple first value: 1
Long tuple second value: 2

Resumen

  1. Característica principal de las tuplas: permite almacenar simultáneamente datos de tipos distintos (enteros sin signo, enteros con signo, números flotantes, caracteres y booleanos pueden coexistir);
  2. Sintaxis de índices de tupla: variable_tupla.número, los índices empiezan en 0;
    • .0 accede al primer elemento,
    • .1 accede al segundo elemento;
  3. Los índices solo pueden ser literales numéricos fijos, no se pueden usar variables como índices.

4 Tuplas anidadas

fn main() {
 
    // Los miembros de una tupla también pueden ser tuplas, se admite anidación
    let tuple_of_tuples = ((1u8, 2u16, 2u32), (4u64, -1i8), -2i16);

 
    // Las tuplas admiten impresión de depuración
    println!("tuple of tuples: {:?}", tuple_of_tuples);
	
	// Usar dos puntos seguidos para imprimir valores
	println!("tuple of tuples: {:?}", tuple_of_tuples.0.1); // Imprime 2
}
Lenguaje del código: JavaScript (javascript)

Salida

E:\rustdemo\demo>demo
tuple of tuples: ((1, 2, 2), (4, -1), -2)
tuple of tuples: 2

Resumen

  1. Se admite anidación de tuplas de varios niveles, los elementos de la tupla externa pueden ser subtuplas;
  2. Las tuplas con ≤12 elementos implementan automáticamente el rasgo Debug, el especificador de formato {:?} puede imprimir todo el contenido directamente.

5 Restricción de impresión para tuplas excesivamente largas (error de compilación)


   fn main() {
 
    // Las tuplas con más de 12 elementos no se pueden imprimir directamente con Debug
    let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
    println!("Too long tuple: {:?}", too_long_tuple);
    // Consejo: descomenta las dos líneas anteriores para ver el error del compilador
}
Lenguaje del código: JavaScript (javascript)

Error de compilación

E:\rustdemo\demo>rustc demo.rs
error[E0277]: `({integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer})` doesn't implement `Debug`
 --> demo.rs:5:38
  |
5 |     println!("Too long tuple: {:?}", too_long_tuple);
  |                               ----   ^^^^^^^^^^^^^^ `({integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer})` cannot be formatted using `{:?}` because it doesn't implement `Debug`
  |                               |
  |                               required by this formatting parameter
  |
  = help: the trait `Debug` is not implemented for `({integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer})`
  = help: the following other types implement trait `Debug`:
            ()
            (A, Z, Y, X, W, V, U, T)
            (B, A, Z, Y, X, W, V, U, T)
            (C, B, A, Z, Y, X, W, V, U, T)
            (D, C, B, A, Z, Y, X, W, V, U, T)
            (E, D, C, B, A, Z, Y, X, W, V, U, T)
            (T,)
            (U, T)
          and 5 others
  = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0277`.Lenguaje del código: PHP (php)

Resumen

La biblioteca estándar de Rust solo deriva automáticamente el rasgo Debug para tuplas con 0~12 elementos;

Las tuplas con más de 12 elementos no tienen implementación nativa de Debug, imprimirlas directamente con {:?} provocará un fallo de compilación.

Puede borrar el número 13 de arriba y probar para comprobar si desaparece el error

6 Llamar funciones con parámetros de tupla y observar el resultado intercambiado

// Las tuplas pueden usarse tanto como parámetros de entrada como valores devueltos por una función
fn reverse(pair: (i32, bool)) -> (bool, i32) {
    // let permite desestructurar los miembros de la tupla y vincularlos a variables independientes
    let (int_param, bool_param) = pair;
    // Devuelve una nueva tupla con el orden intercambiado
    (bool_param, int_param)
}

fn main() {
 
    let pair = (1, true);
    println!("Pair is {:?}", pair);

    println!("The reversed pair is {:?}", reverse(pair)); // Llamar a reverse para intercambiar
}Lenguaje del código: JavaScript (javascript)

Resultado de ejecución

E:\rustdemo\demo>demo
Pair is (1, true)
The reversed pair is (true, 1)Lenguaje del código: JavaScript (javascript)

Resumen

  1. Las tuplas binarias normales se pueden pasar directamente como argumentos a funciones que aceptan tuplas;
  2. La función devuelve una tupla totalmente nueva, la tupla original pair no se modifica.

7 Regla especial de la coma para tuplas de un solo elemento (punto común de error)


   fn main() {
 
    // Es obligatorio añadir una coma al crear tuplas de un solo elemento para diferenciarlas de literales comunes solo envueltos en paréntesis
    println!("One element tuple: {:?}", (5u32,)); 
    println!("Just an integer: {:?}", (5u32));

}Lenguaje del código: JavaScript (javascript)

Resumen

  1. (5u32,): lleva coma al final, es una tupla válida de un solo elemento, tipo (u32,);
  2. (5u32): sin coma, equivale simplemente al número normal 5u32 envuelto en paréntesis, no es una tupla;
  3. La coma es el único marcador que distingue tuplas de un solo elemento de expresiones entre paréntesis.

8 Desestructuración completa de tuplas con varios elementos (ver arriba)


    // Las tuplas se pueden desestructurar totalmente para vincular múltiples variables de una vez
    let tuple = (1, "hello", 4.5, true);

    let (a, b, c, d) = tuple;
    println!("{:?}, {:?}, {:?}, {:?}", a, b, c, d);
Lenguaje del código: JavaScript (javascript)

Resumen

  1. Cualquier tupla de cualquier longitud se puede desestructurar completamente; la cantidad de variables a la izquierda debe coincidir exactamente con la cantidad de elementos de la tupla;
  2. Después de la desestructuración, cada variable corresponde al valor de la misma posición de la tupla y se puede usar por separado.

9 Instanciación de estructura de tupla e impresión Debug

#[derive(Debug)]
struct Matrix(f32, f32, f32, f32);

fn main() {
 
    let matrix = Matrix(1.1, 1.2, 2.1, 2.2);
    println!("{:?}", matrix);

}Lenguaje del código: PHP (php)

Resumen

  1. Sintaxis de instanciación de estructura de tupla: NombreEstructura(valor1, valor2, ...);
  2. Al añadir #[derive(Debug)], la estructura admite impresión de depuración mediante {:?}.
POSTED IN Rust Tutorial

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *