From 2143b85376bbe55f3a1ffd552874299d75a193be Mon Sep 17 00:00:00 2001 From: Ivan Lynch Date: Mon, 26 Feb 2024 12:58:45 -0300 Subject: [PATCH] fix: improved readability and translations in chapter 8 --- src/ch08-00-common-collections.md | 12 ++--- src/ch08-01-vectors.md | 58 ++++++++++----------- src/ch08-02-strings.md | 58 ++++++++++----------- src/ch08-03-hash-maps.md | 87 +++++++++++++++---------------- 4 files changed, 107 insertions(+), 108 deletions(-) diff --git a/src/ch08-00-common-collections.md b/src/ch08-00-common-collections.md index 28f72f08d..0a570a2b5 100644 --- a/src/ch08-00-common-collections.md +++ b/src/ch08-00-common-collections.md @@ -1,10 +1,10 @@ # Colecciones comunes La biblioteca estándar de Rust incluye una serie de estructuras de datos muy -útiles llamadas *colecciones*. La mayoría de los otros tipos de datos +útiles llamadas _colecciones_. La mayoría de los otros tipos de datos representan un valor específico, pero las colecciones pueden contener varios valores. A diferencia de los tipos de datos built-in array y tupla, los -datos a los que apuntan estas colecciones se almacenan en el montón, lo que +datos a los que apuntan estas colecciones se almacenan en el heap, lo que significa que la cantidad de datos no necesita conocerse en el momento de la compilación y puede crecer o disminuir a medida que se ejecuta el programa. Cada tipo de colección tiene diferentes capacidades y costos, y elegir uno @@ -12,12 +12,12 @@ apropiado para su situación actual es una habilidad que desarrollará con el tiempo. En este capítulo, discutiremos tres colecciones que se usan muy a menudo en los programas Rust: -* Un *vector* le permite almacenar un número variable de valores uno al lado del +- Un _vector_ le permite almacenar un número variable de valores uno al lado del otro. -* Un *string* es una colección de caracteres. Hemos mencionado el tipo `String` +- Un _string_ es una colección de caracteres. Hemos mencionado el tipo `String` anteriormente, pero en este capítulo hablaremos de él en profundidad. -* Un *hash map* le permite asociar un valor con una clave particular. Es una - implementación particular de la estructura de datos más general llamada *map*. +- Un _hash map_ le permite asociar un valor con una clave particular. Es una + implementación particular de la estructura de datos más general llamada _map_. Para aprender sobre los otros tipos de colecciones proporcionados por la biblioteca estándar, consulte [la documentación][collections]. diff --git a/src/ch08-01-vectors.md b/src/ch08-01-vectors.md index 2357ba2fa..5db5640cf 100644 --- a/src/ch08-01-vectors.md +++ b/src/ch08-01-vectors.md @@ -10,13 +10,13 @@ los precios de los artículos en un carrito de compras. ### Creando un nuevo vector Para crear un nuevo vector vacío, llamamos a la función `Vec::new`, como se -muestra en el Listing 8-1. +muestra en el listado 8-1. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-01/src/main.rs:here}} ``` -Listing 8-1: Creando un nuevo vector vacío para mantener +Listado 8-1: Creando un nuevo vector vacío para mantener valores de tipo `i32` Ten en cuenta que agregamos una anotación de tipo aquí. Como no estamos @@ -26,13 +26,13 @@ usando genéricos; cubriremos cómo usar genéricos con tus propios tipos en el Capítulo 10. Por ahora, sepa que el tipo `Vec` proporcionado por la biblioteca estándar puede contener cualquier tipo. Cuando creamos un vector para contener un tipo específico, podemos especificar el tipo dentro de -corchetes angulares. En el Listing 8-1, le hemos dicho a Rust que el `Vec` +corchetes angulares. En el listado 8-1, le hemos dicho a Rust que el `Vec` en `v` contendrá elementos del tipo `i32`. A menudo, crearás un `Vec` con valores iniciales y Rust inferirá el tipo de valor que deseas almacenar, por lo que rara vez necesitarás hacer esta anotación de tipo. Rust proporciona convenientemente la macro `vec!`, que -creará un nuevo vector que contenga los valores que le des. El Listing 8-2 +creará un nuevo vector que contenga los valores que le des. El listado 8-2 crea un nuevo `Vec` que contiene los valores `1`, `2` y `3`. El tipo entero es `i32` porque ese es el tipo entero predeterminado, como discutimos en la sección ["Tipos de datos"][data-types] del Capítulo 3. @@ -41,7 +41,7 @@ en la sección ["Tipos de datos"][data-types] del Capítulo 3. {{#rustdoc_include ../listings/ch08-common-collections/listing-08-02/src/main.rs:here}} ``` -Listing 8-2: Creando un nuevo vector que contiene +Listado 8-2: Creando un nuevo vector que contiene valores Debido a que hemos dado valores iniciales `i32`, Rust puede inferir que el tipo @@ -51,13 +51,13 @@ veremos cómo modificar un vector. ### Actualizando un vector Para crear un vector y luego agregar elementos a él, podemos usar el método -`push`, como se muestra en el Listing 8-3. +`push`, como se muestra en el listado 8-3. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-03/src/main.rs:here}} ``` -Listing 8-3: Usando el método `push` para añadir valores +Listado 8-3: Usando el método `push` para añadir valores a un vector Como con cualquier variable, si queremos poder cambiar su valor, necesitamos @@ -72,14 +72,14 @@ de la indexación o usando el método `get`. En los siguientes ejemplos, hemos anotado los tipos de los valores que se devuelven de estas funciones para obtener una mayor claridad. -En el Listing 8-4 se muestran ambos métodos de acceso a un valor en un vector, +En el listado 8-4 se muestran ambos métodos de acceso a un valor en un vector, con sintaxis de indexación y el método `get`. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-04/src/main.rs:here}} ``` -Listing 8-4: Usando la sintaxis de indexación o el método +Listado 8-4: Usando la sintaxis de indexación o el método `get` accediendo a un objeto en un vector Ten en cuenta algunos detalles aquí. Usamos el valor de índice `2` para obtener @@ -93,13 +93,13 @@ elemento es para que puedas elegir cómo se comporta el programa cuando intentas usar un valor de índice fuera del rango de elementos existentes. Como ejemplo, veamos qué sucede cuando tenemos un vector de cinco elementos y luego intentamos acceder a un elemento en el índice 100 con cada técnica, como se muestra en el -Listing 8-5. +listado 8-5. ```rust,should_panic,panics {{#rustdoc_include ../listings/ch08-common-collections/listing-08-05/src/main.rs:here}} ``` -Listing 8-5: Intentando acceder al elemento en el índice +Listado 8-5: Intentando acceder al elemento en el índice 100 en un vector que contiene 5 elementos Cuando ejecutamos este código, el primer método `[]` causará que el programa @@ -110,8 +110,8 @@ un elemento más allá del final del vector. Cuando el método `get` se pasa un índice que está fuera del rango del vector, simplemente devuelve `None` sin entrar en pánico. Tendrías que usar este método si acceder a un elemento más allá del rango del vector puede suceder con -frecuencia en circunstancias normales. Tu código tendrá lógica para manejar -tener `Some(&element)` o `None`, como se discutió en el Capítulo 6. Por +frecuencia en circunstancias normales. Tu código tendrá entonces la lógica +necesaria para gestionar la presencia de Some(&element) o None, tal y como se explica en el capítulo 6. Por ejemplo, el índice podría provenir de una persona que ingresa un número. Si ingresan accidentalmente un número que es demasiado grande y el programa obtiene un valor `None`, podrías decirle al usuario cuántos elementos hay en el vector @@ -123,7 +123,7 @@ las reglas de ownership y borrowing (cubiertas en el Capítulo 4) para asegurar que esta referencia y cualquier otra referencia a los contenidos del vector permanezcan válidas. Recuerda la regla que establece que no puedes tener referencias mutables e inmutables en el mismo ámbito. Esa regla se aplica en el -Listing 8-6, donde tenemos una referencia inmutable al primer elemento en un +listado 8-6, donde tenemos una referencia inmutable al primer elemento en un vector e intentamos agregar un elemento al final. Este programa no funcionará si también intentamos referirnos a ese elemento más adelante en la función: @@ -131,16 +131,16 @@ también intentamos referirnos a ese elemento más adelante en la función: {{#rustdoc_include ../listings/ch08-common-collections/listing-08-06/src/main.rs:here}} ``` -Listing 8-6: Intentando agregar un elemento a un vector +Listado 8-6: Intentando agregar un elemento a un vector mientras se mantiene una referencia a un elemento -Compiling this code will result in this error: +Al compilar este código se producirá este error: ```console {{#include ../listings/ch08-common-collections/listing-08-06/output.txt}} ``` -El código en el Listing 8-6 podría parecer que debería funcionar: ¿por qué una +El código en el listado 8-6 podría parecer que debería funcionar: ¿por qué una referencia al primer elemento se preocuparía por los cambios al final del vector? Este error se debe a la forma en que funcionan los vectores: porque los vectores colocan los valores uno al lado del otro en la memoria, agregar un @@ -151,13 +151,13 @@ actualmente. En ese caso, la referencia al primer elemento apuntaría a la memoria desasignada. Las reglas de borrowing evitan que los programas terminen en esa situación. -> Note: For more on the implementation details of the `Vec` type, see [“The -> Rustonomicon”][nomicon]. +> Nota: Para más información sobre los detalles de implementación del tipo `Vec`, +> véase ["The Rustonomicon"][nomicon]. ### Iterando sobre los valores en un vector Para acceder a cada elemento en un vector a su vez, iteramos a través de todos -los elementos, en lugar de usar índices para acceder a uno a la vez. El Listing +los elementos, en lugar de usar índices para acceder a uno a la vez. El listado 8-7 muestra cómo usar un bucle `for` para obtener referencias inmutables a cada elemento en un vector de valores `i32` e imprimirlos. @@ -165,18 +165,18 @@ elemento en un vector de valores `i32` e imprimirlos. {{#rustdoc_include ../listings/ch08-common-collections/listing-08-07/src/main.rs:here}} ``` -Listing 8-7: Imprimiendo cada elemento en un vector +Listado 8-7: Imprimiendo cada elemento en un vector iterando sobre los elementos usando un ciclo `for` También podemos iterar sobre referencias mutables a cada elemento en un vector mutable, lo que nos permite cambiar los valores en un vector en el lugar. El -código en el Listing 8-8 agregará `50` a cada elemento en un vector. +código en el listado 8-8 agregará `50` a cada elemento en un vector. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-08/src/main.rs:here}} ``` -Listing 8-8: Iterando sobre referencias mutables a +Listado 8-8: Iterando sobre referencias mutables a elementos en un vector Para cambiar el valor al que se refiere la referencia mutable, tenemos que usar @@ -187,8 +187,8 @@ desreferencia”][deref] del Capítulo 15. Iterando sobre un vector, ya sea inmutable o mutable, es seguro debido a las reglas del borrow checker. Si intentáramos insertar o eliminar elementos en los -cuerpos del ciclo `for` en el Listing 8-7 y el Listing 8-8, obtendríamos un -error del compilador similar al que obtuvimos con el código en el Listing 8-6. +cuerpos del ciclo `for` en el listado 8-7 y el listado 8-8, obtendríamos un +error del compilador similar al que obtuvimos con el código en el listado 8-6. La referencia al vector que el ciclo `for` contiene evita la modificación simultánea de todo el vector. @@ -207,13 +207,13 @@ cadenas de texto. Podemos definir un `enum` cuyas variantes contendrán los diferentes tipos de datos, y todas las variantes se considerarán del mismo tipo: el del `enum`. Luego podemos crear un vector para contener ese `enum` y, por lo tanto, en última instancia, contener diferentes tipos. Hemos demostrado esto en -el Listing 8-9. +el listado 8-9. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-09/src/main.rs:here}} ``` -Listing 8-9: Definiendo un `enum` para almacenar valores +Listado 8-9: Definiendo un `enum` para almacenar valores de diferentes tipos en un vector Rust necesita saber qué tipos habrá en el vector en tiempo de compilación para @@ -239,13 +239,13 @@ estándar. Por ejemplo, además de `push`, un método `pop` elimina y devuelve e ### Liberar un vector libera sus elementos Como cualquier otro `struct`, un vector se libera cuando sale del ámbito, como -se anota en el Listing 8-10. +se anota en el listado 8-10. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-10/src/main.rs:here}} ``` -Listing 8-10: Mostrando dónde se colocan el vector y sus +Listado 8-10: Mostrando dónde se colocan el vector y sus elementos Cuando se libera el vector, también se libera todo su contenido, lo que diff --git a/src/ch08-02-strings.md b/src/ch08-02-strings.md index d64c2bfda..efa3a9abe 100644 --- a/src/ch08-02-strings.md +++ b/src/ch08-02-strings.md @@ -23,11 +23,11 @@ tiene un tipo de string en el lenguaje principal, que es el string slice `str` que generalmente se ve en su forma prestada `&str`. En el Capítulo 4, hablamos sobre _string slices_, que son referencias a algunos datos de cadena codificados en UTF-8 almacenados en otro lugar. Las literales de cadena, por ejemplo, se -almacenan en el binario del programa y, por lo tanto, son rebanadas de cadena. +almacenan en el binario del programa y, por lo tanto, son trozos de cadena. El tipo `String`, que es proporcionado por la biblioteca estándar en lugar de -codificado en el lenguaje principal, es una cadena de bytes mutable, propiedad -y codificada en UTF-8. Cuando los Rustaceans se refieren a "strings" en Rust, +codificado en el lenguaje principal, es un tipo de cadena que puede crecer, mutable, +de propiedad, codificado en UTF-8. Cuando los Rustaceans se refieren a "strings" en Rust, pueden estar refiriéndose a cualquiera de los tipos `String` o `str`, no solo a uno de esos tipos. Aunque esta sección trata principalmente de `String`, ambos tipos se usan mucho en la biblioteca estándar de Rust, y tanto `String` como @@ -40,38 +40,38 @@ disponibles con `String`, ya que `String` se implementa en realidad como un envoltorio alrededor de un vector de bytes con algunas garantías, restricciones y capacidades adicionales. Un ejemplo de una función que funciona de la misma manera con `Vec` y `String` es la función `new` para crear una instancia, -que se muestra en el Listing 8-11. +que se muestra en el listado 8-11. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-11/src/main.rs:here}} ``` -Listing 8-11: Creando un nuevo y vacío `String` +Listado 8-11: Creando un nuevo y vacío `String` Esta línea crea un nuevo `String` vacío llamado `s`, que podemos luego cargar con datos. A menudo, tendremos algunos datos iniciales que queremos comenzar en el string. Para eso, usamos el método `to_string`, que está disponible en cualquier tipo que implemente el trait `Display`, como lo hacen los String -Literals. El Listing 8-12 muestra dos ejemplos. +Literals. El listado 8-12 muestra dos ejemplos. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-12/src/main.rs:here}} ``` -Listing 8-12: Usando el método `to_string` para crear un +Listado 8-12: Usando el método `to_string` para crear un `String` a partir de un string literal Este código crea un string que contiene `initial contents`. Podemos también usar la función `String::from` para crear un `String` a partir -de un string literal. El código en el Listing 8-13 es equivalente al código del -Listing 8-12 que usa `to_string`. +de un string literal. El código en el listado 8-13 es equivalente al código del +listado 8-12 que usa `to_string`. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-13/src/main.rs:here}} ``` -Listing 8-13: Usando la función `String::from` para crear +Listado 8-13: Usando la función `String::from` para crear un `String` a partir de un string literal Debido a que los strings se usan para muchas cosas, podemos usar muchas APIs @@ -81,14 +81,14 @@ este caso, `String::from` y `to_string` hacen lo mismo, por lo que elegir depende del estilo y la legibilidad. Recuerda que los strings son UTF-8 codificados, por lo que podemos incluir -cualquier dato codificado correctamente en ellos, Como se muestra en el Listing +cualquier dato codificado correctamente en ellos, Como se muestra en el listado 8-14. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-14/src/main.rs:here}} ``` -Listing 8-14: Almacenamiento de saludos en diferentes +Listado 8-14: Almacenamiento de saludos en diferentes idiomas en strings Todos estos strings son valores válidos de `String`. @@ -96,45 +96,45 @@ Todos estos strings son valores válidos de `String`. ### Actualizando un String Un `String` puede crecer en tamaño y su contenido puede cambiar, al igual que -el contenido de un `Vec`, si empujas más datos en él. Además, puedes usar -conveniente el operador `+` o el macro `format!` para concatenar valores de +el contenido de un `Vec`, si se introducen más datos en el. Además, puedes usar +convenientemente el operador `+` o el macro `format!` para concatenar valores de `String`. #### Agregando a un String con `push_str` y `push` Podemos hacer crecer un `String` usando el método `push_str` para agregar un -string slice, como se muestra en el Listing 8-15. +string slice, como se muestra en el listado 8-15. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-15/src/main.rs:here}} ``` -Listing 8-15: Agregando un string slice a un `String` +Listado 8-15: Agregando un string slice a un `String` usando el método `push_str` Después de estas dos líneas, `s` contendrá `foobar`. El método `push_str` toma un string slice porque no necesariamente queremos tomar posesión del parámetro. -Por ejemplo, en el código del Listing 8-16, queremos poder usar `s2` después de +Por ejemplo, en el código del listado 8-16, queremos poder usar `s2` después de agregar su contenido a `s1`. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-16/src/main.rs:here}} ``` -Listing 8-16: Uso de un string slice después de agregar +Listado 8-16: Uso de un string slice después de agregar su contenido a un `String` Si el método `push_str` tomara posesión de `s2`, no podríamos imprimir su valor en la última línea. ¡Sin embargo, este código funciona como esperamos! El método `push` toma un solo carácter como parámetro y lo agrega al `String`. -El Listing 8-17 agrega la letra `l` a un `String` usando el método `push`. +El listado 8-17 agrega la letra `l` a un `String` usando el método `push`. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-17/src/main.rs:here}} ``` -Listing 8-17: Agregando un carácter a un valor `String` +Listado 8-17: Agregando un carácter a un valor `String` usando `push` Como resultado, `s` contendrá `lol`. @@ -142,14 +142,14 @@ Como resultado, `s` contendrá `lol`. #### Concatenacion con el operador `+` o la Macro `format!` A veces, necesitarás combinar dos strings. Sin embargo, no es tan simple como -usar el operador `+` con dos referencias a `String`. El código en el Listing +usar el operador `+` con dos referencias a `String`. El código en el listado 8-18 no compilará: ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-18/src/main.rs:here}} ``` -Listing 8-18: Usando el operador `+` para combinar dos +Listado 8-18: Usando el operador `+` para combinar dos valores `String` en un nuevo valor `String` El string `s3` contendrá `Hello, world!`. La razón por la que `s1` ya no es @@ -168,12 +168,12 @@ llamamos a este método con valores `String`. Discutiremos los genéricos en el Capítulo 10. Esta firma nos da las pistas que necesitamos para entender las partes complicadas del operador `+`. -Primero, `2` tiene un &, lo que significa que estamos agregando una referencia +Primero, `s2` tiene un `&`, lo que significa que estamos agregando una referencia del segundo string al primer string. Esto se debe al parámetro `s` en la función `add`: solo podemos agregar un `&str` a un `String`; no podemos agregar dos valores `String` juntos. Pero espera, el tipo de `&s2` es `&String`, no `&str`, como se especifica en el segundo parámetro de `add`. ¿Entonces por qué -compila el Listing 8-18? +compila el listado 8-18? La razón por la que podemos usar `s2` en la llamada a `add` es que el compilador puede _convertir_ el argumento `&String` en un `&str`. Cuando @@ -183,7 +183,7 @@ detalle en el Capítulo 15. Debido a que `add` no toma posesión del parámetro `s`, `s2` seguirá siendo un `String` válido después de esta operación. En segundo lugar, podemos ver en la firma que `add` toma el ownership de `self`, -porque `self` no tiene un `&`. Esto significa que `s1` en el Listing 8-18 se +porque `self` no tiene un `&`. Esto significa que `s1` en el listado 8-18 se moverá a la llamada de `add` y ya no será válido después de eso. Entonces, aunque `let s3 = s1 + &s2;` parece que copiará ambos strings y creará uno nuevo, esta declaración realmente toma posesión de `s1`, agrega una copia del @@ -218,13 +218,13 @@ En muchos otros lenguajes de programación, acceder a caracteres individuales en un string referenciándolos por índice es una operación válida y común. Sin embargo, si intentas acceder a partes de un `String` usando la sintaxis de indexación en Rust, obtendrás un error. Considera el código inválido en el -Listing 8-19. +listado 8-19. ```rust,ignore,does_not_compile {{#rustdoc_include ../listings/ch08-common-collections/listing-08-19/src/main.rs:here}} ``` -Listing 8-19: Intentando usar la sintaxis de indexación con +Listado 8-19: Intentando usar la sintaxis de indexación con un String Este código dará como resultado el siguiente error: @@ -240,7 +240,7 @@ discutir cómo Rust almacena los strings en la memoria. #### Representación Interna Un `String` es un wrapper sobre un `Vec`. Veamos algunos de nuestros -strings de ejemplo UTF-8 correctamente codificados del Listing 8-14. Primero, +strings de ejemplo UTF-8 correctamente codificados del listado 8-14. Primero, este: ```rust @@ -284,7 +284,7 @@ causar errores que podrían no descubrirse de inmediato, Rust no compila este código en absoluto y evita malentendidos al comienzo del proceso de desarrollo. -#### Bytes and Scalar Values and Grapheme Clusters! Oh My! +#### Bytes, valores escalares y grupos de grafemas Otro punto sobre UTF-8 es que hay tres formas relevantes de ver las cadenas desde la perspectiva de Rust: como bytes, valores escalares y grupos de diff --git a/src/ch08-03-hash-maps.md b/src/ch08-03-hash-maps.md index 7611b1744..9d8d6ab5a 100644 --- a/src/ch08-03-hash-maps.md +++ b/src/ch08-03-hash-maps.md @@ -1,8 +1,8 @@ ## Almacenar Claves con Valores Asociados en HashMaps La última de nuestras colecciones comunes es el _hash map_. El tipo `HashMap` almacena un mapeo de keys de tipo `K` a valores de tipo `V` usando una -_función hash_, que determina cómo coloca estas keys y valores en la memoria. +V>` almacena un mapeo de claves de tipo `K` a valores de tipo `V` usando una +_función hash_, que determina cómo coloca estas claves y valores en la memoria. Muchos lenguajes de programación admiten este tipo de estructura de datos, pero a menudo usan un nombre diferente, como hash, map, object, hash table, diccionario o arreglos asociativos, solo para nombrar algunos. @@ -30,8 +30,8 @@ Blue comienza con 10 puntos y el equipo Yellow comienza con 50. {{#rustdoc_include ../listings/ch08-common-collections/listing-08-20/src/main.rs:here}} ``` -Listing 8-20: Creando un nuevo hash map e insertando -algunas keys y valores +Listado 8-20: Creando un nuevo hash map e insertando +algunas claves y valores Ten en cuenta que es importante importar primero el módulo `HashMap` de la biblioteca estándar de colecciones. De nuestras tres colecciones comunes, @@ -41,30 +41,30 @@ parte de la biblioteca estándar; por ejemplo, no hay una macro incorporada para construirlos. Al igual que los vectores, los hash maps almacenan sus datos en el _heap_. Este -`HashMap` tiene keys de tipo `String` y valores de tipo `i32`. Al igual que los -vectores, los hash maps son homogéneos: todas las keys deben tener el mismo +`HashMap` tiene claves de tipo `String` y valores de tipo `i32`. Al igual que los +vectores, los hash maps son homogéneos: todas las claves deben tener el mismo tipo entre sí y todos los valores deben tener el mismo tipo. ### Accediendo a los valores en un HashMap Podemos obtener un valor de un hash map proporcionando su clave al método `get` -como se muestra en el Listing 8-21. +como se muestra en el listado 8-21. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-21/src/main.rs:here}} ``` -Listing 8-21: Acceso al puntaje para el equipo Blue +Listado 8-21: Acceso al puntaje para el equipo Blue almacenado en el hash map Aquí, `score` tendrá el valor que está asociado con el equipo Blue, y el resultado será `10`. El método `get` devuelve un `Option<&V>`; si no hay un -valor para ese key en el hash map, `get` devolverá `None`. Este programa +valor para ese clave en el hash map, `get` devolverá `None`. Este programa maneja un `Option` llamando a `copied` para obtener un `Option` en lugar de un `Option<&i32>`, luego `unwrap_or` para establecer `score` en cero si -`scores` no tiene una entrada para la key. +`scores` no tiene una entrada para la clave. -Podemos iterar sobre cada par key/valor en un hash map de manera similar a +Podemos iterar sobre cada par clave/valor en un hash map de manera similar a como lo hacemos con vectores, usando un ciclo `for`: ```rust @@ -83,13 +83,13 @@ Blue: 10 Para los tipos que implementan el trait `Copy`, como `i32`, los valores se copian en el hash map. Para valores de propiedad como `String`, los valores se moverán y el hash map será el propietario de esos valores, como se demuestra -en el Listing 8-22. +en el listado 8-22. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-22/src/main.rs:here}} ``` -Listing 8-22: Mostrando que keys y valores son propiedad +Listado 8-22: Mostrando que claves y valores son propiedad del hash map una vez que se insertan No podemos usar `field_name` y `field_value` después de que se hayan movido al @@ -98,39 +98,38 @@ hash map con la llamada a `insert`. Si insertamos referencias a valores en el hash map, los valores no se moverán al hash map. Los valores a los que apuntan las referencias deben ser válidos al menos mientras el hash map sea válido. Hablaremos más sobre estos problemas -en la sección [“Validating References with -Lifetimes”][validando-referencias-con-lifetimes] en el +en la sección [“Validando referencias con Lifetimes”][validando-referencias-con-lifetimes] en el Capítulo 10. ### Actualizando un HashMap -Aunque la cantidad de pares key/valor es creciente, cada key única solo puede +Aunque la cantidad de pares clave/valor es creciente, cada clave única solo puede tener un valor asociado con ella a la vez (pero no viceversa: por ejemplo, el equipo Blue y el equipo Yellow podrían tener el valor 10 almacenados en el hash map `scores`). Cuando queremos cambiar los datos en un hash map, tenemos que decidir cómo -manejar el caso en el que una key ya tiene un valor asignado. Podrías +manejar el caso en el que una clave ya tiene un valor asignado. Podrías reemplazar el valor antiguo por el nuevo valor, ignorando completamente el valor antiguo. Podrías mantener el valor antiguo e ignorar el nuevo valor, -agregando el nuevo valor solo si la key _no_ tiene ya un valor. O podrías +agregando el nuevo valor solo si la clave _no_ tiene ya un valor. O podrías combinar el valor antiguo y el nuevo valor. ¡Veamos cómo hacer cada una de estas! #### Reemplazando un valor -Si insertamos una key y un valor en un hash map y luego insertamos esa misma -key con un valor diferente, el valor asociado con esa key se reemplazará. -Aunque el código en el Listing 8-23 llama a `insert` dos veces, el hash map -solo contendrá un par key/valor porque estamos insertando el valor para la key +Si insertamos una clave y un valor en un hash map y luego insertamos esa misma +clave con un valor diferente, el valor asociado con esa clave se reemplazará. +Aunque el código en el listado 8-23 llama a `insert` dos veces, el hash map +solo contendrá un par clave/valor porque estamos insertando el valor para la clave del equipo Blue dos veces. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-23/src/main.rs:here}} ``` -Listing 8-23: Reemplazando un valor almacenado con una -key en particular +Listado 8-23: Reemplazando un valor almacenado con una +clave en particular Este código imprimirá `{"Blue": 25}`. El valor original de `10` ha sido sobrescrito. @@ -141,43 +140,43 @@ sobrescrito. #### Insertando una Key y un valor solo si una Key no está presente -Es común verificar si una key en particular ya existe en el hash map con un -valor y luego realizar las siguientes acciones: si la key existe en el hash -map, el valor existente debe permanecer tal como está. Si la key no existe, -insertarla y un valor para ella. +Es común verificar si una clave en particular ya existe en el hash map con un +valor y luego realizar las siguientes acciones: si la clave existe en el hash +map, el valor existente debe permanecer tal como está. Si la clave no existe, +insertarla junto con su valor. -Los hash maps tienen una API especial para esto llamada `entry` que toma la key +Los hash maps tienen una API especial para esto llamada `entry` que toma la clave que desea verificar como parámetro. El valor de retorno del método `entry` es un enum llamado `Entry` que representa un valor que puede o no existir. Digamos -que queremos verificar si la key para el equipo Yellow tiene un valor +que queremos verificar si la clave para el equipo Yellow tiene un valor asociado. Si no lo tiene, queremos insertar el valor 50, y lo mismo para el -equipo Blue. Usando la API `entry`, el código se ve como el Listing 8-24. +equipo Blue. Usando la API `entry`, el código se ve como el listado 8-24. ```rust {{#rustdoc_include ../listings/ch08-common-collections/listing-08-24/src/main.rs:here}} ``` -Listing 8-24: Usando el método `entry` para insertar solo -si la key aún no tiene un valor +Listado 8-24: Usando el método `entry` para insertar solo +si la clave aún no tiene un valor El método `or_insert` en `Entry` está definido para devolver una referencia -mutable al valor correspondiente a la `Entry` key si esa key existe, y si no, -inserta el parámetro como el nuevo valor para esta key y devuelve una +mutable al valor correspondiente a la clave `Entry` si esa clave existe, y si no, +inserta el parámetro como el nuevo valor para esta clave y devuelve una referencia mutable al nuevo valor. Esta técnica es mucho más limpia que escribir la lógica nosotros mismos y, además, juega mejor con el borrow checker. -Ejecutar el código en el Listing 8-24 imprimirá `{"Yellow": 50, "Blue": 10}`. -La primera llamada a `entry` insertará la key para el equipo Yellow con el +Ejecutar el código en el listado 8-24 imprimirá `{"Yellow": 50, "Blue": 10}`. +La primera llamada a `entry` insertará la clave para el equipo Yellow con el valor 50 porque el equipo Yellow no tiene un valor todavía. La segunda llamada a `entry` no cambiará el hash map porque el equipo Blue ya tiene el valor 10. #### Actualizando un valor basado en el valor anterior -Otro caso común para los hash maps es buscar un valor para una key y luego -actualizar ese valor en función del valor anterior. Por ejemplo, el Listing 8-25 +Otro caso común para los hash maps es buscar un valor para una clave y luego +actualizar ese valor en función del valor anterior. Por ejemplo, el listado 8-25 muestra un código que cuenta cuántas veces aparece cada palabra en algún texto. -Usamos un hash map con las palabras como keys y aumentamos el valor para +Usamos un hash map con las palabras como claves y aumentamos el valor para mantener un recuento de cuántas veces hemos visto esa palabra. Si es la primera vez que vemos una palabra, primero insertaremos el valor 0. @@ -185,17 +184,17 @@ vez que vemos una palabra, primero insertaremos el valor 0. {{#rustdoc_include ../listings/ch08-common-collections/listing-08-25/src/main.rs:here}} ``` -Listing 8-25: Contando ocurrencias de palabras usando un +Listado 8-25: Contando ocurrencias de palabras usando un hash map que almacena palabras y cuenta Este código imprimirá `{"world": 2, "hello": 1, "wonderful": 1}`. Es posible -que veas los mismos pares key/valor en un orden diferente: recuerda la sección +que veas los mismos pares clave/valor en un orden diferente: recuerda la sección [“Accediendo a valores en un hash map”][access] que iterar sobre un hash map ocurre en un orden arbitrario. El método `split_whitespace` devuelve un iterator sobre sub-slices, separados por espacios en blanco, del valor en `text`. El método `or_insert` devuelve una -referencia mutable (`&mut V`) al valor para la key especificada. Aquí +referencia mutable (`&mut V`) al valor para la clave especificada. Aquí almacenamos esa referencia mutable en la variable `count`, por lo que para asignar a ese valor, primero debemos desreferenciar `count` usando el asterisco (`*`). La referencia mutable sale del ámbito al final del ciclo `for`, por lo @@ -233,7 +232,7 @@ Aquí hay algunos ejercicios que ahora deberías estar equipado para resolver: convierte en "rimepay". Sin embargo, si la palabra comienza con una vocal, simplemente agregue "hay" al final de la palabra ("manzanaay"). ¡Ten en cuenta las reglas de UTF-8! -- Usando un has map y vectores, cree un texto de interfaz para permitir que un +- Usando un hash map y vectores, cree un texto de interfaz para permitir que un usuario agregue nombres de empleados a un departamento en una empresa. Por ejemplo, "Agregar Sally a Ingeniería" o "Agregar Amir a Ventas". Luego, permita que el usuario recupere una lista de todas las personas en un