From dc67b50b8c229d68f9a068d263a6bd096fe93ae9 Mon Sep 17 00:00:00 2001 From: Diogo Marciano Date: Sun, 8 Nov 2026 20:43:00 -0300 Subject: [PATCH 1/2] Translate "Property getters and setters" article to Portuguese Co-Authored-By: Claude Sonnet 5 --- .../02-property-accessors/article.md | 96 +++++++++---------- 1 file changed, 48 insertions(+), 48 deletions(-) diff --git a/1-js/07-object-properties/02-property-accessors/article.md b/1-js/07-object-properties/02-property-accessors/article.md index c2aa35d53..72b91862e 100644 --- a/1-js/07-object-properties/02-property-accessors/article.md +++ b/1-js/07-object-properties/02-property-accessors/article.md @@ -1,31 +1,31 @@ -# Property getters and setters +# Getters e setters de propriedades -There are two kinds of object properties. +Existem dois tipos de propriedades de objeto. -The first kind is *data properties*. We already know how to work with them. All properties that we've been using until now were data properties. +O primeiro tipo são as *propriedades de dados*. Já sabemos como trabalhar com elas. Todas as propriedades que usamos até agora eram propriedades de dados. -The second type of property is something new. It's an *accessor property*. They are essentially functions that execute on getting and setting a value, but look like regular properties to an external code. +O segundo tipo de propriedade é algo novo. É uma *propriedade de acesso*. Elas são, essencialmente, funções que executam ao obter e definir um valor, mas parecem propriedades normais para um código externo. -## Getters and setters +## Getters e setters -Accessor properties are represented by "getter" and "setter" methods. In an object literal they are denoted by `get` and `set`: +Propriedades de acesso são representadas por métodos "getter" e "setter". Num objeto literal, eles são indicados por `get` e `set`: ```js let obj = { *!*get propName()*/!* { - // getter, the code executed on getting obj.propName + // getter, o código executado ao obter obj.propName }, *!*set propName(value)*/!* { - // setter, the code executed on setting obj.propName = value + // setter, o código executado ao definir obj.propName = value } }; ``` -The getter works when `obj.propName` is read, the setter -- when it is assigned. +O getter funciona quando `obj.propName` é lido, o setter -- quando é atribuído. -For instance, we have a `user` object with `name` and `surname`: +Por exemplo, temos um objeto `user` com `name` e `surname`: ```js let user = { @@ -34,7 +34,7 @@ let user = { }; ``` -Now we want to add a `fullName` property, that should be `"John Smith"`. Of course, we don't want to copy-paste existing information, so we can implement it as an accessor: +Agora queremos adicionar uma propriedade `fullName`, que deve ser `"John Smith"`. Claro, não queremos copiar e colar informações já existentes, então podemos implementá-la como um acessor: ```js run let user = { @@ -53,9 +53,9 @@ alert(user.fullName); // John Smith */!* ``` -From the outside, an accessor property looks like a regular one. That's the idea of accessor properties. We don't *call* `user.fullName` as a function, we *read* it normally: the getter runs behind the scenes. +De fora, uma propriedade de acesso parece uma propriedade normal. Essa é a ideia das propriedades de acesso. Nós não *chamamos* `user.fullName` como uma função, nós a *lemos* normalmente: o getter roda nos bastidores. -As of now, `fullName` has only a getter. If we attempt to assign `user.fullName=`, there will be an error: +Por enquanto, `fullName` só tem um getter. Se tentarmos atribuir `user.fullName=`, vai haver um erro: ```js run let user = { @@ -65,11 +65,11 @@ let user = { }; *!* -user.fullName = "Test"; // Error (property has only a getter) +user.fullName = "Test"; // Erro (a propriedade só tem um getter) */!* ``` -Let's fix it by adding a setter for `user.fullName`: +Vamos corrigir isso adicionando um setter para `user.fullName`: ```js run let user = { @@ -87,29 +87,29 @@ let user = { */!* }; -// set fullName is executed with the given value. +// set fullName é executado com o valor dado. user.fullName = "Alice Cooper"; alert(user.name); // Alice alert(user.surname); // Cooper ``` -As the result, we have a "virtual" property `fullName`. It is readable and writable. +Como resultado, temos uma propriedade "virtual" `fullName`. Ela é legível e gravável. -## Accessor descriptors +## Descritores de acesso -Descriptors for accessor properties are different from those for data properties. +Os descritores de propriedades de acesso são diferentes dos de propriedades de dados. -For accessor properties, there is no `value` or `writable`, but instead there are `get` and `set` functions. +Para propriedades de acesso, não existe `value` ou `writable`, mas, em vez disso, existem as funções `get` e `set`. -That is, an accessor descriptor may have: +Ou seja, um descritor de acesso pode ter: -- **`get`** -- a function without arguments, that works when a property is read, -- **`set`** -- a function with one argument, that is called when the property is set, -- **`enumerable`** -- same as for data properties, -- **`configurable`** -- same as for data properties. +- **`get`** -- uma função sem argumentos, que funciona quando uma propriedade é lida, +- **`set`** -- uma função com um argumento, que é chamada quando a propriedade é definida, +- **`enumerable`** -- igual às propriedades de dados, +- **`configurable`** -- igual às propriedades de dados. -For instance, to create an accessor `fullName` with `defineProperty`, we can pass a descriptor with `get` and `set`: +Por exemplo, para criar um acessor `fullName` com `defineProperty`, podemos passar um descritor com `get` e `set`: ```js run let user = { @@ -134,13 +134,13 @@ alert(user.fullName); // John Smith for(let key in user) alert(key); // name, surname ``` -Please note that a property can be either an accessor (has `get/set` methods) or a data property (has a `value`), not both. +Observe que uma propriedade pode ser um acessor (tem métodos `get/set`) ou uma propriedade de dados (tem um `value`), mas não as duas coisas. -If we try to supply both `get` and `value` in the same descriptor, there will be an error: +Se tentarmos fornecer `get` e `value` no mesmo descritor, vai haver um erro: ```js run *!* -// Error: Invalid property descriptor. +// Erro: Invalid property descriptor. */!* Object.defineProperty({}, 'prop', { get() { @@ -151,11 +151,11 @@ Object.defineProperty({}, 'prop', { }); ``` -## Smarter getters/setters +## Getters/setters mais espertos -Getters/setters can be used as wrappers over "real" property values to gain more control over operations with them. +Getters/setters podem ser usados como invólucros sobre valores "reais" de propriedades, pra ganhar mais controle sobre as operações com eles. -For instance, if we want to forbid too short names for `user`, we can have a setter `name` and keep the value in a separate property `_name`: +Por exemplo, se quisermos proibir nomes muito curtos para `user`, podemos ter um setter `name` e manter o valor numa propriedade separada, `_name`: ```js run let user = { @@ -165,7 +165,7 @@ let user = { set name(value) { if (value.length < 4) { - alert("Name is too short, need at least 4 characters"); + alert("O nome é muito curto, precisa ter pelo menos 4 caracteres"); return; } this._name = value; @@ -175,19 +175,19 @@ let user = { user.name = "Pete"; alert(user.name); // Pete -user.name = ""; // Name is too short... +user.name = ""; // O nome é muito curto... ``` -So, the name is stored in `_name` property, and the access is done via getter and setter. +Então, o nome é armazenado na propriedade `_name`, e o acesso é feito via getter e setter. -Technically, external code is able to access the name directly by using `user._name`. But there is a widely known convention that properties starting with an underscore `"_"` are internal and should not be touched from outside the object. +Tecnicamente, código externo consegue acessar o nome diretamente usando `user._name`. Mas existe uma convenção amplamente conhecida de que propriedades começando com um sublinhado `"_"` são internas e não devem ser tocadas de fora do objeto. -## Using for compatibility +## Usando para compatibilidade -One of the great uses of accessors is that they allow to take control over a "regular" data property at any moment by replacing it with a getter and a setter and tweak its behavior. +Um dos grandes usos dos acessores é que eles permitem assumir o controle sobre uma propriedade de dados "normal" a qualquer momento, substituindo-a por um getter e um setter e ajustando seu comportamento. -Imagine we started implementing user objects using data properties `name` and `age`: +Imagine que começamos a implementar objetos de usuário usando as propriedades de dados `name` e `age`: ```js function User(name, age) { @@ -200,7 +200,7 @@ let john = new User("John", 25); alert( john.age ); // 25 ``` -...But sooner or later, things may change. Instead of `age` we may decide to store `birthday`, because it's more precise and convenient: +...Mas, mais cedo ou mais tarde, as coisas podem mudar. Em vez de `age`, podemos decidir armazenar `birthday`, porque é mais preciso e conveniente: ```js function User(name, birthday) { @@ -211,13 +211,13 @@ function User(name, birthday) { let john = new User("John", new Date(1992, 6, 1)); ``` -Now what to do with the old code that still uses `age` property? +Agora, o que fazer com o código antigo que ainda usa a propriedade `age`? -We can try to find all such places and fix them, but that takes time and can be hard to do if that code is used by many other people. And besides, `age` is a nice thing to have in `user`, right? +Podemos tentar encontrar todos esses lugares e corrigi-los, mas isso leva tempo e pode ser difícil se esse código for usado por muitas outras pessoas. E, além disso, `age` é algo bom de se ter em `user`, não é? -Let's keep it. +Vamos mantê-lo. -Adding a getter for `age` solves the problem: +Adicionar um getter para `age` resolve o problema: ```js run no-beautify function User(name, birthday) { @@ -225,7 +225,7 @@ function User(name, birthday) { this.birthday = birthday; *!* - // age is calculated from the current date and birthday + // age é calculado a partir da data atual e do birthday Object.defineProperty(this, "age", { get() { let todayYear = new Date().getFullYear(); @@ -237,8 +237,8 @@ function User(name, birthday) { let john = new User("John", new Date(1992, 6, 1)); -alert( john.birthday ); // birthday is available -alert( john.age ); // ...as well as the age +alert( john.birthday ); // birthday está disponível +alert( john.age ); // ...assim como age ``` -Now the old code works too and we've got a nice additional property. +Agora o código antigo também funciona e ganhamos uma boa propriedade adicional. From 4979c1d30a564d2dd910d6b7965701814e0ca67c Mon Sep 17 00:00:00 2001 From: Diogo Marciano Date: Sat, 21 Nov 2026 14:55:06 -0300 Subject: [PATCH 2/2] Apply review feedback from @gabifs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Unify "acessor"/"acessores" -> "propriedade de acesso", the term this article itself introduces (4 occurrences) - "Object literal" mistranslated as "objeto literal" (an object that is literal) -> "literal de objeto" (the `{...}` syntax) - Fix pronoun gender: "Vamos mantê-lo" -> "Vamos mantê-la" (refers to the `age` property) - Mixed-language comment -> follow the pattern from 01-property-descriptors: keep the original message, with the translation in parentheses - "Getters/setters mais espertos" -> "...mais inteligentes" (more standard in technical material) - Standardize informal "pra" to "para" Co-Authored-By: Claude Sonnet 5 --- .../02-property-accessors/article.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/1-js/07-object-properties/02-property-accessors/article.md b/1-js/07-object-properties/02-property-accessors/article.md index 72b91862e..d0e140aec 100644 --- a/1-js/07-object-properties/02-property-accessors/article.md +++ b/1-js/07-object-properties/02-property-accessors/article.md @@ -9,7 +9,7 @@ O segundo tipo de propriedade é algo novo. É uma *propriedade de acesso*. Elas ## Getters e setters -Propriedades de acesso são representadas por métodos "getter" e "setter". Num objeto literal, eles são indicados por `get` e `set`: +Propriedades de acesso são representadas por métodos "getter" e "setter". Em um literal de objeto, eles são indicados por `get` e `set`: ```js let obj = { @@ -34,7 +34,7 @@ let user = { }; ``` -Agora queremos adicionar uma propriedade `fullName`, que deve ser `"John Smith"`. Claro, não queremos copiar e colar informações já existentes, então podemos implementá-la como um acessor: +Agora queremos adicionar uma propriedade `fullName`, que deve ser `"John Smith"`. Claro, não queremos copiar e colar informações já existentes, então podemos implementá-la como uma propriedade de acesso: ```js run let user = { @@ -109,7 +109,7 @@ Ou seja, um descritor de acesso pode ter: - **`enumerable`** -- igual às propriedades de dados, - **`configurable`** -- igual às propriedades de dados. -Por exemplo, para criar um acessor `fullName` com `defineProperty`, podemos passar um descritor com `get` e `set`: +Por exemplo, para criar uma propriedade de acesso `fullName` com `defineProperty`, podemos passar um descritor com `get` e `set`: ```js run let user = { @@ -134,13 +134,13 @@ alert(user.fullName); // John Smith for(let key in user) alert(key); // name, surname ``` -Observe que uma propriedade pode ser um acessor (tem métodos `get/set`) ou uma propriedade de dados (tem um `value`), mas não as duas coisas. +Observe que uma propriedade pode ser uma propriedade de acesso (tem métodos `get/set`) ou uma propriedade de dados (tem um `value`), mas não as duas coisas. Se tentarmos fornecer `get` e `value` no mesmo descritor, vai haver um erro: ```js run *!* -// Erro: Invalid property descriptor. +// Erro: Invalid property descriptor (descritor de propriedade inválido). */!* Object.defineProperty({}, 'prop', { get() { @@ -151,9 +151,9 @@ Object.defineProperty({}, 'prop', { }); ``` -## Getters/setters mais espertos +## Getters/setters mais inteligentes -Getters/setters podem ser usados como invólucros sobre valores "reais" de propriedades, pra ganhar mais controle sobre as operações com eles. +Getters/setters podem ser usados como invólucros sobre valores "reais" de propriedades, para ganhar mais controle sobre as operações com eles. Por exemplo, se quisermos proibir nomes muito curtos para `user`, podemos ter um setter `name` e manter o valor numa propriedade separada, `_name`: @@ -185,7 +185,7 @@ Tecnicamente, código externo consegue acessar o nome diretamente usando `user._ ## Usando para compatibilidade -Um dos grandes usos dos acessores é que eles permitem assumir o controle sobre uma propriedade de dados "normal" a qualquer momento, substituindo-a por um getter e um setter e ajustando seu comportamento. +Um dos grandes usos das propriedades de acesso é que elas permitem assumir o controle sobre uma propriedade de dados "normal" a qualquer momento, substituindo-a por um getter e um setter e ajustando seu comportamento. Imagine que começamos a implementar objetos de usuário usando as propriedades de dados `name` e `age`: @@ -215,7 +215,7 @@ Agora, o que fazer com o código antigo que ainda usa a propriedade `age`? Podemos tentar encontrar todos esses lugares e corrigi-los, mas isso leva tempo e pode ser difícil se esse código for usado por muitas outras pessoas. E, além disso, `age` é algo bom de se ter em `user`, não é? -Vamos mantê-lo. +Vamos mantê-la. Adicionar um getter para `age` resolve o problema: