From 545af57c211a50011696140dc10a526f8dafc9cf Mon Sep 17 00:00:00 2001 From: Herbert Lago Date: Sun, 25 Jul 2021 16:49:20 -0300 Subject: [PATCH 1/6] feat: translate property-descriptors article --- .../01-property-descriptors/article.md | 165 +++++++++--------- 1 file changed, 82 insertions(+), 83 deletions(-) diff --git a/1-js/07-object-properties/01-property-descriptors/article.md b/1-js/07-object-properties/01-property-descriptors/article.md index edf3e260f..1ccf23775 100644 --- a/1-js/07-object-properties/01-property-descriptors/article.md +++ b/1-js/07-object-properties/01-property-descriptors/article.md @@ -1,40 +1,40 @@ -# Property flags and descriptors +# Sinalizadores e descritores de propriedade -As we know, objects can store properties. +Como sabemos, objetos podem armazenar propriedades. -Until now, a property was a simple "key-value" pair to us. But an object property is actually a more flexible and powerful thing. +Até agora, para nós, uma propriedade era um simples par "chave-valor". Mas uma propriedade de objeto é na verdade uma coisa mais flexível e poderosa. -In this chapter we'll study additional configuration options, and in the next we'll see how to invisibly turn them into getter/setter functions. +Neste capítulo, nós vamos estudar opções de configuração adicional, e no próximo nós vamos ver como invisivelmente tornar elas em funções getter/setter. -## Property flags +## Sinalizadores de propriedade -Object properties, besides a **`value`**, have three special attributes (so-called "flags"): +Propriedades de objeto, além do **`valor`** tem três atributos especiais (também chamados "sinalizadores"): -- **`writable`** -- if `true`, the value can be changed, otherwise it's read-only. -- **`enumerable`** -- if `true`, then listed in loops, otherwise not listed. -- **`configurable`** -- if `true`, the property can be deleted and these attributes can be modified, otherwise not. +- **`gravável`** -- se `true`, o valor pode ser alterado, caso contrário, é apenas-leitura. +- **`enúmeravel`** -- se `true`, então pode ser listado em loops, caso contrário, não pode. +- **`configurável`** -- se `true`, a propriedade pode ser deletada e seus atributos modificados, caso contrário não. -We didn't see them yet, because generally they do not show up. When we create a property "the usual way", all of them are `true`. But we also can change them anytime. +Nós não vimos eles ainda, porque geralmente eles não aparecem. Quando criamos uma propriedade "do jeito comum", todos eles são `true`. Mas nós também podemos mudá-los a qualquer hora. -First, let's see how to get those flags. +Primeiro, vamos ver como obter esses sinalizadores. -The method [Object.getOwnPropertyDescriptor](mdn:js/Object/getOwnPropertyDescriptor) allows to query the *full* information about a property. +O método [Object.getOwnPropertyDescriptor](mdn:js/Object/getOwnPropertyDescriptor) nos permite consultar a informação *completa* sobre a propriedade. -The syntax is: +A sintaxe é: ```js let descriptor = Object.getOwnPropertyDescriptor(obj, propertyName); ``` `obj` -: The object to get information from. +: O objeto do qual vamos obter a informação. `propertyName` -: The name of the property. +: O nome da propriedade. -The returned value is a so-called "property descriptor" object: it contains the value and all the flags. +O valor retornado é também chamado de objeto "descritor de propriedade": ele contém o valor e todos os sinalizadores. -For instance: +Por exemplo: ```js run let user = { @@ -44,7 +44,7 @@ let user = { let descriptor = Object.getOwnPropertyDescriptor(user, 'name'); alert( JSON.stringify(descriptor, null, 2 ) ); -/* property descriptor: +/* descritor de propriedade: { "value": "John", "writable": true, @@ -54,23 +54,23 @@ alert( JSON.stringify(descriptor, null, 2 ) ); */ ``` -To change the flags, we can use [Object.defineProperty](mdn:js/Object/defineProperty). +Para mudar os sinalizadores, nós podemos usar o [Object.defineProperty](mdn:js/Object/defineProperty). -The syntax is: +A sintaxe é: ```js Object.defineProperty(obj, propertyName, descriptor) ``` `obj`, `propertyName` -: The object and property to work on. +: O objeto e a propriedade nos quais atuar. `descriptor` -: Property descriptor object to apply. +: Descritor de propriedade de objeto a aplicar. -If the property exists, `defineProperty` updates its flags. Otherwise, it creates the property with the given value and flags; in that case, if a flag is not supplied, it is assumed `false`. +Se a proprieade existe, `defineProperty` atualiza seu sinalizador. Caso contrário, é criada uma propriedade com os sinalizadores setados; neste caso, se um sinalizador não é enviado, seu valor é assumido como `false`. -For instance, here a property `name` is created with all falsy flags: +Por exemplo, aqui a propriedade `name` é criada com todos os sinalizadores falsos: ```js run let user = {}; @@ -96,13 +96,13 @@ alert( JSON.stringify(descriptor, null, 2 ) ); */ ``` -Compare it with "normally created" `user.name` above: now all flags are falsy. If that's not what we want then we'd better set them to `true` in `descriptor`. +Compare isso com o `user.name` "criado normalmente" acima: agora todos os sinalizadores são falsos. Se não é isso que queremos, então é melhor setá-los como `true` no `descriptor`. -Now let's see effects of the flags by example. +Agora vamos ver os efeitos dos sinalizadores, por exemplo: -## Non-writable +## Não-gravável -Let's make `user.name` non-writable (can't be reassigned) by changing `writable` flag: +Vamos deixar `user.name` não-gravável (não pode ser reatribuído) alterando o sinalizador `writable`: ```js run let user = { @@ -120,13 +120,13 @@ user.name = "Pete"; // Error: Cannot assign to read only property 'name'... */!* ``` -Now no one can change the name of our user, unless they apply their own `defineProperty` to override ours. +Agora, ninguém pode alterar o nome do nosso usuário, a não ser que eles apliquem seus próprios `defineProperty` para sobrescrever o nosso. -```smart header="Errors appear only in strict mode" -In the non-strict mode, no errors occur when writing to non-writable properties and such. But the operation still won't succeed. Flag-violating actions are just silently ignored in non-strict. +```smart header="Erros aparecem apenas em strict mode" +No modo não-estrito, os erros não ocorrem quando gravando em propriedades não-graváveis, etc. Mas a operação ainda não terá sucesso. Ações que violam os sinalizadores são apenas ignoradas silenciosamentes em modo não-estrito. ``` -Here's the same example, but the property is created from scratch: +Aqui está o mesmo exemplo, mas a propriedade é criada do zero. ```js run let user = { }; @@ -134,22 +134,21 @@ let user = { }; Object.defineProperty(user, "name", { *!* value: "John", - // for new properties we need to explicitly list what's true + // para novas proprieades, precisamos explicitamente listar o que é true enumerable: true, configurable: true */!* }); -alert(user.name); // Pete -user.name = "Alice"; // Error +alert(user.name); // John +user.name = "Alice"; // Erro ``` +## Não-enumerável -## Non-enumerable +Agora, vamos adicionar um `toString` customizado ao `user`. -Now let's add a custom `toString` to `user`. - -Normally, a built-in `toString` for objects is non-enumerable, it does not show up in `for..in`. But if we add a `toString` of our own, then by default it shows up in `for..in`, like this: +Normalmente, um `toString` embutido em objetos é não-enumerável, e não aparece em `for...in`. Mas se nós adicionarmos um `toString` por nós mesmos, então por padrão ele aparece em `for...in`, desta forma: ```js run let user = { @@ -159,11 +158,11 @@ let user = { } }; -// By default, both our properties are listed: +// Por padrão, ambas as nossas propriedades são listadas: for (let key in user) alert(key); // name, toString ``` -If we don't like it, then we can set `enumerable:false`. Then it won't appear in a `for..in` loop, just like the built-in one: +Se nós não gostarmos disso, então podemos setar `enumerable:false`. Então ela não vai aparecer no loop `for...in`, assim como as propriedades embutidas: ```js run let user = { @@ -180,24 +179,24 @@ Object.defineProperty(user, "toString", { }); *!* -// Now our toString disappears: +// Agora nosso toString desaparece: */!* for (let key in user) alert(key); // name ``` -Non-enumerable properties are also excluded from `Object.keys`: +Propriedades não-enumeráveis também são excluídas de `Object.keys`: ```js alert(Object.keys(user)); // name ``` -## Non-configurable +## Não-configurável -The non-configurable flag (`configurable:false`) is sometimes preset for built-in objects and properties. +O sinalizador não-configurável (`configurable:false`) algumas vezes é predefinido por objetos e propriedades embutidas. -A non-configurable property can not be deleted. +Uma propriedade não-configurável não pode ser deletada. -For instance, `Math.PI` is non-writable, non-enumerable and non-configurable: +Por exemplo, `Math.PI` é não-gravável, não-enumerável e não-configurável: ```js run let descriptor = Object.getOwnPropertyDescriptor(Math, 'PI'); @@ -212,25 +211,25 @@ alert( JSON.stringify(descriptor, null, 2 ) ); } */ ``` -So, a programmer is unable to change the value of `Math.PI` or overwrite it. +Então, um programador é impossibilitado de mudar o valor de `Math.PI` ou sobrescrevê-lo. ```js run -Math.PI = 3; // Error +Math.PI = 3; // Erro -// delete Math.PI won't work either +// deletar Math.PI também não irá funcionar ``` -Making a property non-configurable is a one-way road. We cannot change it back with `defineProperty`. +Deixar uma propriedade não-configurável, é um caminho só de ida. Nós não podemos alterar isso novamente com `defineProperty`. -To be precise, non-configurability imposes several restrictions on `defineProperty`: -1. Can't change `configurable` flag. -2. Can't change `enumerable` flag. -3. Can't change `writable: false` to `true` (the other way round works). -4. Can't change `get/set` for an accessor property (but can assign them if absent). +Para ser preciso, não-configurabilidade impões várias restrições em `defineProperty`: +1. Não poder mudar o sinalizador `configurable`. +1. Não poder mudar o sinalizador `enumerable`. +3. Não poder mudar `writable: false` para `true` (o contrário funciona). +4. Não poder mudar `get/set` por um acessador de propriedade (mas pode atribuí-los se ausente). -**The idea of "configurable: false" is to prevent changes of property flags and its deletion, while allowing to change its value.** +**A ideia de "configurable: false" é para prevenir mudanças de sinalizadores de propriedades e sua eliminação, enquanto permite alterar seu valor.** -Here `user.name` is non-configurable, but we can still change it (as it's writable): +Aqui `user.name` é não-configurável, mas nós ainda podemos alterá-lo (pois é gravável): ```js run let user = { @@ -241,11 +240,11 @@ Object.defineProperty(user, "name", { configurable: false }); -user.name = "Pete"; // works fine -delete user.name; // Error +user.name = "Pete"; // funciona corretamente +delete user.name; // Erro ``` -And here we make `user.name` a "forever sealed" constant: +E aqui nós deixamos `user.name` uma constante "selada para sempre": ```js run let user = { @@ -257,8 +256,8 @@ Object.defineProperty(user, "name", { configurable: false }); -// won't be able to change user.name or its flags -// all this won't work: +// não será possível alterar user.name ou seus sinalizadores +// nada disso irá funcionar user.name = "Pete"; delete user.name; Object.defineProperty(user, "name", { value: "Pete" }); @@ -267,9 +266,9 @@ Object.defineProperty(user, "name", { value: "Pete" }); ## Object.defineProperties -There's a method [Object.defineProperties(obj, descriptors)](mdn:js/Object/defineProperties) that allows to define many properties at once. +Existe um método [Object.defineProperties(obj, descriptors)](mdn:js/Object/defineProperties) que permite definir várias propriedades de uma vez. -The syntax is: +A sintaxe é: ```js Object.defineProperties(obj, { @@ -279,7 +278,7 @@ Object.defineProperties(obj, { }); ``` -For instance: +Por exemplo: ```js Object.defineProperties(user, { @@ -289,19 +288,19 @@ Object.defineProperties(user, { }); ``` -So, we can set many properties at once. +Então, nós podemos setar várias propriedades de uma vez. ## Object.getOwnPropertyDescriptors -To get all property descriptors at once, we can use the method [Object.getOwnPropertyDescriptors(obj)](mdn:js/Object/getOwnPropertyDescriptors). +Para obter todos os sinalizadores de propriedade de uma vez, nós podemos usar o método [Object.getOwnPropertyDescriptors(obj)](mdn:js/Object/getOwnPropertyDescriptors). -Together with `Object.defineProperties` it can be used as a "flags-aware" way of cloning an object: +Juntamente com `Object.defineProperties` isso pode ser usado como um jeito "consciente-de-sinalizadores" de clonar objetos: ```js let clone = Object.defineProperties({}, Object.getOwnPropertyDescriptors(obj)); ``` -Normally when we clone an object, we use an assignment to copy properties, like this: +Normalmente quando nós clonamos um objeto, nós usamos uma atribuição para copiar propriedades, desta forma: ```js for (let key in user) { @@ -309,34 +308,34 @@ for (let key in user) { } ``` -...But that does not copy flags. So if we want a "better" clone then `Object.defineProperties` is preferred. +...Mas isso não copia os sinalizadores. Então se nós quisermos um clone "melhor" então é preferível `Object.defineProperties`. -Another difference is that `for..in` ignores symbolic properties, but `Object.getOwnPropertyDescriptors` returns *all* property descriptors including symbolic ones. +Outra diferença é que `for..in` ignora propriedades simbólicas, mas `Object.getOwnPropertyDescriptors` returna *todas* as propriedades descritoras, incluindo as simbólicas. -## Sealing an object globally +## Selando um objeto globalmente -Property descriptors work at the level of individual properties. +Descritores de propriedade atuam no mesmo nível de propriedades individuais. -There are also methods that limit access to the *whole* object: +Também existem métodos que limitam o acesso ao objeto *inteiro*: [Object.preventExtensions(obj)](mdn:js/Object/preventExtensions) -: Forbids the addition of new properties to the object. +: Proíbe a adição de novas propriedades ao objeto. [Object.seal(obj)](mdn:js/Object/seal) -: Forbids adding/removing of properties. Sets `configurable: false` for all existing properties. +: Proíbe a adição/remoção de propriedades. Seta `configurable: false` para todas as propriedades existentes. [Object.freeze(obj)](mdn:js/Object/freeze) -: Forbids adding/removing/changing of properties. Sets `configurable: false, writable: false` for all existing properties. +: Proíbe adicionar/remover/alterar propriedades. Seta `configurable: false, writable: false` para todas as propriedades existentes. -And also there are tests for them: +E também existem testes para eles: [Object.isExtensible(obj)](mdn:js/Object/isExtensible) -: Returns `false` if adding properties is forbidden, otherwise `true`. +: Retorna `false` se a adição de propriedades é proibida, caso contrátio `true`. [Object.isSealed(obj)](mdn:js/Object/isSealed) -: Returns `true` if adding/removing properties is forbidden, and all existing properties have `configurable: false`. +: Retorna `true` se adição/remoção de propriedades são proibidas, e todas as propriedades existentes são `configurable: false`. [Object.isFrozen(obj)](mdn:js/Object/isFrozen) -: Returns `true` if adding/removing/changing properties is forbidden, and all current properties are `configurable: false, writable: false`. +: Retorna `true` se adição/remoção/alteração de propriedades são proibidas, e todas as propriedades atuais são `configurable: false, writable: false`. -These methods are rarely used in practice. +Estes métodos são raramentes usados na prática. From bfa132ada9e2f8a6e54694c925fe04ff81b038dc Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Tue, 27 Jul 2021 23:10:04 +0100 Subject: [PATCH 2/6] Add blank line. --- 1-js/07-object-properties/01-property-descriptors/article.md | 1 + 1 file changed, 1 insertion(+) diff --git a/1-js/07-object-properties/01-property-descriptors/article.md b/1-js/07-object-properties/01-property-descriptors/article.md index 1ccf23775..59f35d1ee 100644 --- a/1-js/07-object-properties/01-property-descriptors/article.md +++ b/1-js/07-object-properties/01-property-descriptors/article.md @@ -144,6 +144,7 @@ alert(user.name); // John user.name = "Alice"; // Erro ``` + ## Não-enumerável Agora, vamos adicionar um `toString` customizado ao `user`. From f8e5c3afd3dd91a088636cba9fb1eafd5755fcd0 Mon Sep 17 00:00:00 2001 From: Herbert Lago Date: Wed, 28 Jul 2021 19:19:36 -0300 Subject: [PATCH 3/6] fix(property-descriptors): some translations adjusts --- .../01-property-descriptors/article.md | 45 ++++++++++--------- 1 file changed, 23 insertions(+), 22 deletions(-) diff --git a/1-js/07-object-properties/01-property-descriptors/article.md b/1-js/07-object-properties/01-property-descriptors/article.md index 1ccf23775..5ebbe964a 100644 --- a/1-js/07-object-properties/01-property-descriptors/article.md +++ b/1-js/07-object-properties/01-property-descriptors/article.md @@ -1,15 +1,15 @@ -# Sinalizadores e descritores de propriedade +# Sinalizadores e descritores de propriedades Como sabemos, objetos podem armazenar propriedades. Até agora, para nós, uma propriedade era um simples par "chave-valor". Mas uma propriedade de objeto é na verdade uma coisa mais flexível e poderosa. -Neste capítulo, nós vamos estudar opções de configuração adicional, e no próximo nós vamos ver como invisivelmente tornar elas em funções getter/setter. +Neste capítulo, nós vamos estudar opções de configurações adicionais, e no próximo nós vamos ver como invisivelmente tornar elas em funções getter/setter. ## Sinalizadores de propriedade -Propriedades de objeto, além do **`valor`** tem três atributos especiais (também chamados "sinalizadores"): +Propriedades de objeto, além do **`valor`** têm três atributos especiais (também chamados "sinalizadores"): - **`gravável`** -- se `true`, o valor pode ser alterado, caso contrário, é apenas-leitura. - **`enúmeravel`** -- se `true`, então pode ser listado em loops, caso contrário, não pode. @@ -63,14 +63,14 @@ Object.defineProperty(obj, propertyName, descriptor) ``` `obj`, `propertyName` -: O objeto e a propriedade nos quais atuar. +: O objeto e a propriedade nos quais atuar. `descriptor` : Descritor de propriedade de objeto a aplicar. -Se a proprieade existe, `defineProperty` atualiza seu sinalizador. Caso contrário, é criada uma propriedade com os sinalizadores setados; neste caso, se um sinalizador não é enviado, seu valor é assumido como `false`. +Se a proprieade existe, `defineProperty` atualiza o seu sinalizador. Caso contrário, é criada uma propriedade com os sinalizadores e valor dados; neste caso, se um sinalizador não é fornecido, seu valor é assumido como `false`. -Por exemplo, aqui a propriedade `name` é criada com todos os sinalizadores falsos: +Por exemplo, aqui a propriedade `name` é criada com todos os sinalizadores a falso: ```js run let user = {}; @@ -96,7 +96,7 @@ alert( JSON.stringify(descriptor, null, 2 ) ); */ ``` -Compare isso com o `user.name` "criado normalmente" acima: agora todos os sinalizadores são falsos. Se não é isso que queremos, então é melhor setá-los como `true` no `descriptor`. +Compare isso com o `user.name` "criado normalmente" acima: agora todos os sinalizadores são falsos. Se não é isso que queremos, então é melhor configurá-los como `true` no `descriptor`. Agora vamos ver os efeitos dos sinalizadores, por exemplo: @@ -116,14 +116,15 @@ Object.defineProperty(user, "name", { }); *!* -user.name = "Pete"; // Error: Cannot assign to read only property 'name'... +user.name = "Pete"; +// Error: Cannot assign to read only property 'name'... (Erro: não é possível a atribuição à variável de apenas leitura 'name'...) */!* ``` Agora, ninguém pode alterar o nome do nosso usuário, a não ser que eles apliquem seus próprios `defineProperty` para sobrescrever o nosso. ```smart header="Erros aparecem apenas em strict mode" -No modo não-estrito, os erros não ocorrem quando gravando em propriedades não-graváveis, etc. Mas a operação ainda não terá sucesso. Ações que violam os sinalizadores são apenas ignoradas silenciosamentes em modo não-estrito. +No modo não-estrito, os erros não ocorrem quando escrevendo em propriedades não-graváveis, etc. Mas a operação ainda assim não terá sucesso. Ações que violam os sinalizadores são apenas ignoradas silenciosamentes em modo não-estrito. ``` Aqui está o mesmo exemplo, mas a propriedade é criada do zero. @@ -134,7 +135,7 @@ let user = { }; Object.defineProperty(user, "name", { *!* value: "John", - // para novas proprieades, precisamos explicitamente listar o que é true + // para novas proprieades, precisamos explicitamente de listar o que é true enumerable: true, configurable: true */!* @@ -148,7 +149,7 @@ user.name = "Alice"; // Erro Agora, vamos adicionar um `toString` customizado ao `user`. -Normalmente, um `toString` embutido em objetos é não-enumerável, e não aparece em `for...in`. Mas se nós adicionarmos um `toString` por nós mesmos, então por padrão ele aparece em `for...in`, desta forma: +Normalmente, um `toString` embutido em objetos é não-enumerável, e não aparece em `for..in`. Mas se nós adicionarmos um `toString` por nós mesmos, então por padrão ele aparece em `for..in`, desta forma: ```js run let user = { @@ -162,7 +163,7 @@ let user = { for (let key in user) alert(key); // name, toString ``` -Se nós não gostarmos disso, então podemos setar `enumerable:false`. Então ela não vai aparecer no loop `for...in`, assim como as propriedades embutidas: +Se nós não gostarmos disso, então podemos configurar `enumerable:false`. Então ela não vai aparecer no loop `for..in`, tal como as propriedades embutidas: ```js run let user = { @@ -192,7 +193,7 @@ alert(Object.keys(user)); // name ## Não-configurável -O sinalizador não-configurável (`configurable:false`) algumas vezes é predefinido por objetos e propriedades embutidas. +O sinalizador não-configurável (`configurable:false`) algumas vezes está predefinido para objetos e propriedades embutidas. Uma propriedade não-configurável não pode ser deletada. @@ -221,13 +222,13 @@ Math.PI = 3; // Erro Deixar uma propriedade não-configurável, é um caminho só de ida. Nós não podemos alterar isso novamente com `defineProperty`. -Para ser preciso, não-configurabilidade impões várias restrições em `defineProperty`: +Para ser preciso, a não-configurabilidade impões várias restrições a `defineProperty`: 1. Não poder mudar o sinalizador `configurable`. -1. Não poder mudar o sinalizador `enumerable`. +2. Não poder mudar o sinalizador `enumerable`. 3. Não poder mudar `writable: false` para `true` (o contrário funciona). 4. Não poder mudar `get/set` por um acessador de propriedade (mas pode atribuí-los se ausente). -**A ideia de "configurable: false" é para prevenir mudanças de sinalizadores de propriedades e sua eliminação, enquanto permite alterar seu valor.** +**A ideia de "configurable: false" é para prevenir a mudança de sinalizadores de propriedades e a sua eliminação, enquanto permite alterar o seu valor.** Aqui `user.name` é não-configurável, mas nós ainda podemos alterá-lo (pois é gravável): @@ -256,7 +257,7 @@ Object.defineProperty(user, "name", { configurable: false }); -// não será possível alterar user.name ou seus sinalizadores +// não será possível alterar user.name ou os seus sinalizadores // nada disso irá funcionar user.name = "Pete"; delete user.name; @@ -288,13 +289,13 @@ Object.defineProperties(user, { }); ``` -Então, nós podemos setar várias propriedades de uma vez. +Então, nós podemos configurar várias propriedades de uma vez. ## Object.getOwnPropertyDescriptors Para obter todos os sinalizadores de propriedade de uma vez, nós podemos usar o método [Object.getOwnPropertyDescriptors(obj)](mdn:js/Object/getOwnPropertyDescriptors). -Juntamente com `Object.defineProperties` isso pode ser usado como um jeito "consciente-de-sinalizadores" de clonar objetos: +Juntamente com `Object.defineProperties` isso pode ser usado como um jeito "incluindo-sinalizadores" de clonar objetos: ```js let clone = Object.defineProperties({}, Object.getOwnPropertyDescriptors(obj)); @@ -308,7 +309,7 @@ for (let key in user) { } ``` -...Mas isso não copia os sinalizadores. Então se nós quisermos um clone "melhor" então é preferível `Object.defineProperties`. +...Mas isso não copia os sinalizadores. Assim, se nós quisermos um clone "melhor" então é preferível `Object.defineProperties`. Outra diferença é que `for..in` ignora propriedades simbólicas, mas `Object.getOwnPropertyDescriptors` returna *todas* as propriedades descritoras, incluindo as simbólicas. @@ -322,10 +323,10 @@ Também existem métodos que limitam o acesso ao objeto *inteiro*: : Proíbe a adição de novas propriedades ao objeto. [Object.seal(obj)](mdn:js/Object/seal) -: Proíbe a adição/remoção de propriedades. Seta `configurable: false` para todas as propriedades existentes. +: Proíbe a adição/remoção de propriedades. Coloca `configurable: false` para todas as propriedades existentes. [Object.freeze(obj)](mdn:js/Object/freeze) -: Proíbe adicionar/remover/alterar propriedades. Seta `configurable: false, writable: false` para todas as propriedades existentes. +: Proíbe adicionar/remover/alterar propriedades. Coloca `configurable: false, writable: false` para todas as propriedades existentes. E também existem testes para eles: From 07c3379e7fdbf2a818ce4f77cfb0eabb302b23be Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Sat, 14 Aug 2021 00:07:48 +0100 Subject: [PATCH 4/6] Re-order lines. --- 1-js/07-object-properties/01-property-descriptors/article.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/1-js/07-object-properties/01-property-descriptors/article.md b/1-js/07-object-properties/01-property-descriptors/article.md index ec187486b..22d86a0f0 100644 --- a/1-js/07-object-properties/01-property-descriptors/article.md +++ b/1-js/07-object-properties/01-property-descriptors/article.md @@ -229,6 +229,8 @@ Para ser preciso, a não-configurabilidade impões várias restrições a `defin 3. Não poder mudar `writable: false` para `true` (o contrário funciona). 4. Não poder mudar `get/set` por um acessador de propriedade (mas pode atribuí-los se ausente). + + **A ideia de "configurable: false" é para prevenir a mudança de sinalizadores de propriedades e a sua eliminação, enquanto permite alterar o seu valor.** Aqui `user.name` é não-configurável, mas nós ainda podemos alterá-lo (pois é gravável): From 7e89947328f0211adb1966588d71ee997ba3fbb8 Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Sat, 14 Aug 2021 00:19:34 +0100 Subject: [PATCH 5/6] Resolve conflicts - match original. --- .../01-property-descriptors/article.md | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/1-js/07-object-properties/01-property-descriptors/article.md b/1-js/07-object-properties/01-property-descriptors/article.md index 22d86a0f0..05caefc9c 100644 --- a/1-js/07-object-properties/01-property-descriptors/article.md +++ b/1-js/07-object-properties/01-property-descriptors/article.md @@ -116,8 +116,7 @@ Object.defineProperty(user, "name", { }); *!* -user.name = "Pete"; -// Error: Cannot assign to read only property 'name'... (Erro: não é possível a atribuição à variável de apenas leitura 'name'...) +user.name = "Pete"; // Error: Cannot assign to read only property 'name'... (Erro: não é possível a atribuição à variável de apenas leitura 'name'...) */!* ``` @@ -145,7 +144,6 @@ alert(user.name); // John user.name = "Alice"; // Erro ``` - ## Não-enumerável Agora, vamos adicionar um `toString` customizado ao `user`. @@ -221,15 +219,16 @@ Math.PI = 3; // Erro, porque a propriedade tem gravável: false // deletar Math.PI também não irá funcionar ``` -Deixar uma propriedade não-configurável, é um caminho só de ida. Nós não podemos alterar isso novamente com `defineProperty`. +We also can't change `Math.PI` to be `writable` again: -Para ser preciso, a não-configurabilidade impões várias restrições a `defineProperty`: -1. Não poder mudar o sinalizador `configurable`. -2. Não poder mudar o sinalizador `enumerable`. -3. Não poder mudar `writable: false` para `true` (o contrário funciona). -4. Não poder mudar `get/set` por um acessador de propriedade (mas pode atribuí-los se ausente). +```js run +// Error, because of configurable: false +Object.defineProperty(Math, "PI", { writable: true }); +``` +There's absolutely nothing we can do with `Math.PI`. +Deixar uma propriedade não-configurável, é um caminho só de ida. Nós não podemos alterar isso novamente com `defineProperty`. **A ideia de "configurable: false" é para prevenir a mudança de sinalizadores de propriedades e a sua eliminação, enquanto permite alterar o seu valor.** From c06fd69d1b59d2dc00591ee4a40df9243263e7c8 Mon Sep 17 00:00:00 2001 From: Herbert Lago Date: Mon, 7 Feb 2022 08:50:48 -0300 Subject: [PATCH 6/6] minor fixes --- .../01-property-descriptors/article.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/1-js/07-object-properties/01-property-descriptors/article.md b/1-js/07-object-properties/01-property-descriptors/article.md index 4a1cf384d..ce69a7a00 100644 --- a/1-js/07-object-properties/01-property-descriptors/article.md +++ b/1-js/07-object-properties/01-property-descriptors/article.md @@ -5,14 +5,14 @@ Como sabemos, objetos podem armazenar propriedades. Até agora, para nós, uma propriedade era um simples par "chave-valor". Mas uma propriedade de objeto é na verdade uma coisa mais flexível e poderosa. -Neste capítulo, nós vamos estudar opções de configurações adicionais, e no próximo nós vamos ver como invisivelmente tornar elas em funções getter/setter. +Neste capítulo, nós vamos estudar opções de configuração adicionais, e no próximo nós vamos ver como invisivelmente tornar elas em funções getter/setter. ## Sinalizadores de propriedade Propriedades de objeto, além do **`valor`** têm três atributos especiais (também chamados "sinalizadores"): - **`gravável`** -- se `true`, o valor pode ser alterado, caso contrário, é apenas-leitura. -- **`enúmeravel`** -- se `true`, então pode ser listado em loops, caso contrário, não pode. +- **`enumerável`** -- se `true`, então pode ser listado em loops, caso contrário, não pode. - **`configurável`** -- se `true`, a propriedade pode ser deletada e seus atributos modificados, caso contrário não. Nós não vimos eles ainda, porque geralmente eles não aparecem. Quando criamos uma propriedade "do jeito comum", todos eles são `true`. Mas nós também podemos mudá-los a qualquer hora. @@ -220,14 +220,14 @@ Math.PI = 3; // Erro, porque a propriedade tem gravável: false // deletar Math.PI também não irá funcionar ``` -We also can't change `Math.PI` to be `writable` again: +Nós também não podemos alterar `Math.PI` para ser `writable`(gravável) de novo: ```js run -// Error, because of configurable: false +// Erro, porque configurable: false Object.defineProperty(Math, "PI", { writable: true }); ``` -There's absolutely nothing we can do with `Math.PI`. +Não há absolutamente nada que possamos fazer com `Math.PI`. Deixar uma propriedade não-configurável, é um caminho só de ida. Nós não podemos alterar isso novamente com `defineProperty`. @@ -267,10 +267,10 @@ delete user.name; Object.defineProperty(user, "name", { value: "Pete" }); ``` -```smart header="The only attribute change possible: writable true -> false" -There's a minor exception about changing flags. +```smart header="A única alteração de atributo possível: gravável true -> false" +Há uma pequena excessão sobre alteração de flags. -We can change `writable: true` to `false` for a non-configurable property, thus preventing its value modification (to add another layer of protection). Not the other way around though. +Nós podemos mudar `writable: true` para `false` para uma propriedade não-configurável, evitando assim, sua modificação de valor (para adicionar outra camada de proteção). Mas não o contrário. ``` ## Object.defineProperties