From f2852ad8793c731e309822c3ab6197e11c88cbd3 Mon Sep 17 00:00:00 2001 From: Diogo Marciano Date: Wed, 4 Nov 2026 11:01:12 -0300 Subject: [PATCH 1/2] Translate 'Object.keys, values, entries' article to Portuguese --- .../01-sum-salaries/solution.md | 8 +-- .../01-sum-salaries/task.md | 10 +-- .../02-count-properties/task.md | 8 +-- .../09-keys-values-entries/article.md | 64 +++++++++---------- 4 files changed, 45 insertions(+), 45 deletions(-) diff --git a/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/solution.md b/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/solution.md index 27a7b418a..aecb1d1d1 100644 --- a/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/solution.md +++ b/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/solution.md @@ -17,12 +17,12 @@ let salaries = { alert( sumSalaries(salaries) ); // 650 ``` -Or, optionally, we could also get the sum using `Object.values` and `reduce`: +Ou, opcionalmente, também podemos obter a soma usando `Object.values` e `reduce`: ```js -// reduce loops over array of salaries, -// adding them up -// and returns the result +// reduce percorre o array de salários, +// somando todos +// e retorna o resultado function sumSalaries(salaries) { return Object.values(salaries).reduce((a, b) => a + b, 0) // 650 } diff --git a/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md b/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md index 211357d03..2876bdef2 100644 --- a/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md +++ b/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md @@ -2,15 +2,15 @@ importance: 5 --- -# Sum the properties +# Soma das propriedades -There is a `salaries` object with arbitrary number of salaries. +Existe um objeto `salaries` com um número qualquer de salários. -Write the function `sumSalaries(salaries)` that returns the sum of all salaries using `Object.values` and the `for..of` loop. +Escreva a função `sumSalaries(salaries)` que retorna a soma de todos os salários, usando `Object.values` e o laço `for..of`. -If `salaries` is empty, then the result must be `0`. +Se `salaries` estiver vazio, o resultado deve ser `0`. -For instance: +Por exemplo: ```js let salaries = { diff --git a/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md b/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md index d7aebb1fa..1ad6a1afb 100644 --- a/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md +++ b/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md @@ -2,9 +2,9 @@ importance: 5 --- -# Count properties +# Conte as propriedades -Write a function `count(obj)` that returns the number of properties in the object: +Escreva uma função `count(obj)` que retorna o número de propriedades no objeto: ```js let user = { @@ -15,7 +15,7 @@ let user = { alert( count(user) ); // 2 ``` -Try to make the code as short as possible. +Tente deixar o código o mais curto possível. -P.S. Ignore symbolic properties, count only "regular" ones. +P.S. Ignore propriedades simbólicas, conte apenas as "normais". diff --git a/1-js/05-data-types/09-keys-values-entries/article.md b/1-js/05-data-types/09-keys-values-entries/article.md index bef678f53..aebd39dbb 100644 --- a/1-js/05-data-types/09-keys-values-entries/article.md +++ b/1-js/05-data-types/09-keys-values-entries/article.md @@ -1,42 +1,42 @@ # Object.keys, values, entries -Let's step away from the individual data structures and talk about the iterations over them. +Vamos dar um passo atrás das estruturas de dados individuais e falar sobre como iterar sobre elas. -In the previous chapter we saw methods `map.keys()`, `map.values()`, `map.entries()`. +No capítulo anterior, vimos os métodos `map.keys()`, `map.values()`, `map.entries()`. -These methods are generic, there is a common agreement to use them for data structures. If we ever create a data structure of our own, we should implement them too. +Esses métodos são genéricos, existe um acordo comum para usá-los em estruturas de dados. Se um dia criarmos nossa própria estrutura de dados, devemos implementá-los também. -They are supported for: +Eles são suportados por: - `Map` - `Set` - `Array` -Plain objects also support similar methods, but the syntax is a bit different. +Objetos simples também suportam métodos parecidos, mas a sintaxe é um pouco diferente. ## Object.keys, values, entries -For plain objects, the following methods are available: +Para objetos simples, os seguintes métodos estão disponíveis: -- [Object.keys(obj)](mdn:js/Object/keys) -- returns an array of keys. -- [Object.values(obj)](mdn:js/Object/values) -- returns an array of values. -- [Object.entries(obj)](mdn:js/Object/entries) -- returns an array of `[key, value]` pairs. +- [Object.keys(obj)](mdn:js/Object/keys) -- retorna um array com as chaves. +- [Object.values(obj)](mdn:js/Object/values) -- retorna um array com os valores. +- [Object.entries(obj)](mdn:js/Object/entries) -- retorna um array de pares `[chave, valor]`. -Please note the distinctions (compared to map for example): +Repare nas diferenças (comparando com o map, por exemplo): | | Map | Object | |-------------|------------------|--------------| -| Call syntax | `map.keys()` | `Object.keys(obj)`, but not `obj.keys()` | -| Returns | iterable | "real" Array | +| Sintaxe de chamada | `map.keys()` | `Object.keys(obj)`, mas não `obj.keys()` | +| Retorna | iterável | Array "de verdade" | -The first difference is that we have to call `Object.keys(obj)`, and not `obj.keys()`. +A primeira diferença é que precisamos chamar `Object.keys(obj)`, e não `obj.keys()`. -Why so? The main reason is flexibility. Remember, objects are a base of all complex structures in JavaScript. So we may have an object of our own like `data` that implements its own `data.values()` method. And we still can call `Object.values(data)` on it. +Por que assim? O principal motivo é flexibilidade. Lembre-se, objetos são a base de todas as estruturas complexas em JavaScript. Então podemos ter um objeto nosso, chamado `data`, que implementa seu próprio método `data.values()`. E ainda assim podemos chamar `Object.values(data)` sobre ele. -The second difference is that `Object.*` methods return "real" array objects, not just an iterable. That's mainly for historical reasons. +A segunda diferença é que os métodos `Object.*` retornam objetos "array de verdade", e não apenas um iterável. Isso é, principalmente, por motivos históricos. -For instance: +Por exemplo: ```js let user = { @@ -49,7 +49,7 @@ let user = { - `Object.values(user) = ["John", 30]` - `Object.entries(user) = [ ["name","John"], ["age",30] ]` -Here's an example of using `Object.values` to loop over property values: +Aqui está um exemplo usando `Object.values` para percorrer os valores das propriedades: ```js run let user = { @@ -57,30 +57,30 @@ let user = { age: 30 }; -// loop over values +// percorre os valores for (let value of Object.values(user)) { - alert(value); // John, then 30 + alert(value); // John, depois 30 } ``` -```warn header="Object.keys/values/entries ignore symbolic properties" -Just like a `for..in` loop, these methods ignore properties that use `Symbol(...)` as keys. +```warn header="Object.keys/values/entries ignoram propriedades simbólicas" +Assim como um laço `for..in`, esses métodos ignoram propriedades que usam `Symbol(...)` como chave. -Usually that's convenient. But if we want symbolic keys too, then there's a separate method [Object.getOwnPropertySymbols](mdn:js/Object/getOwnPropertySymbols) that returns an array of only symbolic keys. Also, there exist a method [Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys) that returns *all* keys. +Normalmente isso é conveniente. Mas se também quisermos as chaves simbólicas, existe um método separado, [Object.getOwnPropertySymbols](mdn:js/Object/getOwnPropertySymbols), que retorna um array apenas com as chaves simbólicas. Também existe o método [Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys), que retorna *todas* as chaves. ``` -## Transforming objects +## Transformando objetos -Objects lack many methods that exist for arrays, e.g. `map`, `filter` and others. +Objetos não têm muitos métodos que existem para arrays, como `map`, `filter` e outros. -If we'd like to apply them, then we can use `Object.entries` followed by `Object.fromEntries`: +Se quisermos aplicá-los, podemos usar `Object.entries` seguido de `Object.fromEntries`: -1. Use `Object.entries(obj)` to get an array of key/value pairs from `obj`. -2. Use array methods on that array, e.g. `map`, to transform these key/value pairs. -3. Use `Object.fromEntries(array)` on the resulting array to turn it back into an object. +1. Use `Object.entries(obj)` para obter um array de pares chave/valor de `obj`. +2. Use métodos de array nesse array, como `map`, para transformar esses pares chave/valor. +3. Use `Object.fromEntries(array)` no array resultante para transformá-lo de volta em um objeto. -For example, we have an object with prices, and would like to double them: +Por exemplo, temos um objeto com preços, e gostaríamos de dobrá-los: ```js run let prices = { @@ -91,8 +91,8 @@ let prices = { *!* let doublePrices = Object.fromEntries( - // convert prices to array, map each key/value pair into another pair - // and then fromEntries gives back the object + // converte prices em um array, mapeia cada par chave/valor para outro par + // e então fromEntries devolve o objeto Object.entries(prices).map(entry => [entry[0], entry[1] * 2]) ); */!* @@ -100,4 +100,4 @@ let doublePrices = Object.fromEntries( alert(doublePrices.meat); // 8 ``` -It may look difficult at first sight, but becomes easy to understand after you use it once or twice. We can make powerful chains of transforms this way. +Pode parecer difícil à primeira vista, mas fica fácil de entender depois que você usa uma ou duas vezes. Dá pra montar cadeias de transformações bem poderosas dessa forma. From 0ec85c6bedfc20fd2b637b3c06dfa40f8c1168f9 Mon Sep 17 00:00:00 2001 From: Diogo Marciano Date: Sat, 7 Nov 2026 13:39:32 -0300 Subject: [PATCH 2/2] Apply review suggestions from gabifs --- .../02-count-properties/task.md | 2 +- .../09-keys-values-entries/article.md | 16 ++++++++-------- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md b/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md index 1ad6a1afb..96f732260 100644 --- a/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md +++ b/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md @@ -17,5 +17,5 @@ alert( count(user) ); // 2 Tente deixar o código o mais curto possível. -P.S. Ignore propriedades simbólicas, conte apenas as "normais". +P.S. Ignore propriedades simbólicas, conte apenas as propriedades "comuns" (com chaves do tipo string). diff --git a/1-js/05-data-types/09-keys-values-entries/article.md b/1-js/05-data-types/09-keys-values-entries/article.md index aebd39dbb..ec643eadf 100644 --- a/1-js/05-data-types/09-keys-values-entries/article.md +++ b/1-js/05-data-types/09-keys-values-entries/article.md @@ -1,11 +1,11 @@ # Object.keys, values, entries -Vamos dar um passo atrás das estruturas de dados individuais e falar sobre como iterar sobre elas. +Vamos deixar de lado as estruturas de dados individuais e falar sobre como iterar sobre elas. No capítulo anterior, vimos os métodos `map.keys()`, `map.values()`, `map.entries()`. -Esses métodos são genéricos, existe um acordo comum para usá-los em estruturas de dados. Se um dia criarmos nossa própria estrutura de dados, devemos implementá-los também. +Esses métodos são genéricos: há uma convenção de usá-los em estruturas de dados. Se um dia criarmos nossa própria estrutura de dados, devemos implementá-los também. Eles são suportados por: @@ -25,16 +25,16 @@ Para objetos simples, os seguintes métodos estão disponíveis: Repare nas diferenças (comparando com o map, por exemplo): -| | Map | Object | -|-------------|------------------|--------------| +| | Map | Object | +|--------------------|---------------|-------------------------------------------| | Sintaxe de chamada | `map.keys()` | `Object.keys(obj)`, mas não `obj.keys()` | -| Retorna | iterável | Array "de verdade" | +| Retorna | iterável | Array "de verdade" | A primeira diferença é que precisamos chamar `Object.keys(obj)`, e não `obj.keys()`. -Por que assim? O principal motivo é flexibilidade. Lembre-se, objetos são a base de todas as estruturas complexas em JavaScript. Então podemos ter um objeto nosso, chamado `data`, que implementa seu próprio método `data.values()`. E ainda assim podemos chamar `Object.values(data)` sobre ele. +Por que assim? O principal motivo é flexibilidade. Lembre-se, objetos são a base de todas as estruturas complexas em JavaScript. Então podemos ter um objeto nosso, chamado `data`, que implementa seu próprio método `data.values()`. E ainda assim podemos chamar `Object.values(data)`. -A segunda diferença é que os métodos `Object.*` retornam objetos "array de verdade", e não apenas um iterável. Isso é, principalmente, por motivos históricos. +A segunda diferença é que os métodos `Object.*` retornam arrays "de verdade", e não apenas iteráveis. Isso se deve principalmente a motivos históricos. Por exemplo: @@ -100,4 +100,4 @@ let doublePrices = Object.fromEntries( alert(doublePrices.meat); // 8 ``` -Pode parecer difícil à primeira vista, mas fica fácil de entender depois que você usa uma ou duas vezes. Dá pra montar cadeias de transformações bem poderosas dessa forma. +Pode parecer difícil à primeira vista, mas fica fácil de entender depois que você usa uma ou duas vezes. Dá para montar cadeias de transformações bem poderosas dessa forma.