Object.defineProperty() - JavaScript

Object.defineProperty()
=======================

O método **`Object.defineProperty()`** define uma nova propriedade diretamente em um objeto, ou modifica uma propriedade já existente em um objeto, e retorna o objeto.

**Nota:** Você invoca este método diretamente no construtor do `Object` ao invés de invocar em uma instância do tipo `Object`.

Sintaxe
-------
```

Object.defineProperty(obj, prop, descriptor)
```

### Parâmetros

`obj`

O objeto no qual será definida a propriedade.

`prop`

O nome da propriedade que será definida ou modificada.

`descriptor`

O descritor para a propriedade que será definida ou modificada.

### Valor de retorno

O objeto que foi passado à função.

Descrição
---------

Esse método permite uma precisa inclusão ou modificação de uma propriedade em um objeto. Enquanto a inclusão de propriedades através de atribuição cria propriedades que são visíveis durante a enumeração (por repetições `for...in` ou pelo método `Object.keys`), e cujos valores podem ser alterados e deletados (en-US), esse método permite a modificação deste comportamento padrão. Por padrão, valores incluídos utilizando `Object.defineProperty()` são imutáveis.

Os descritores de propriedades presentes nos objetos se apresentam em duas variedades: descritores de dados e descritores de assessores. Um *descritor de dado* é uma propriedade que contém um valor, podendo este ser gravável ou não. Um *descritor de assessor* é uma propriedade definida como um par de funções getter-setter. Um descritor deve ser de uma destas variedades; não pode ser de ambas.

Ambos os descritores de dados e de assessor são objetos. Eles compartilham as seguintes chaves obrigatórias:

`configurable`

`true` se e somente se o tipo deste descritor de propriedade pode ser alterado e se a propriedade pode ser deletada do objeto correspondente.
 **Valor padrão é `false`.**

`enumerable`

`true` se e somente se esta propriedade aparece durante enumeração das propriedades no objeto correspondente.
 **Valor padrão é `false`.**

Um descritor de dados também possui as seguintes chaves opcionais:

`value`

 O valor associado com a propriedade. Pode ser qualquer valor válido em Javascript (número, objeto, função, etc).
 **Valor padrão é `undefined`.**

`writable`

`true` se e somente se o valor associado com a propriedade pode ser modificada com um operador de atribuição (en-US).
 **Valor padrão é `false`.**

Um descritor de assessor também possui as seguintes chaves opcionais:

`get`

 Uma função que servirá como um getter da propriedade, ou `undefined` se não houver getter. Quando a propriedade é acessada, esta função é chamada sem argumentos e com `this` define para o objeto no qual a propriedade é acessada (este pode não ser o objeto sobre o qual a propriedade está definida devido a herança). O valor retornado será usado como valor da propriedade.
 **Valor padrão é `undefined`.**

`set`

 A função que servirá como um setter para a propriedade, ou `undefined` se não houver setter. Quando a propriedade é atribuída, esta função é chamada com um argumento (o valor sendo atribuído para a propriedade) e com `this` configura o objeto através do qual a propriedade é atribuída.
 **Valor padrão é `undefined`.**

Se um descritor tem nenhum das chaves `value`, `writable`, `get` e `set`, ele é tratado como um descritor de dados. Se um descritor tem ambas chaves `value` ou `writable` e `get` ou `set` keys, uma exceção é lançada.

Tenha em mente que estes atributos não são necessariamente as propriedades do próprio descritor. Propriedades herdadas serão consideradas também. Para garantir que estes padrões sejam preservados, você pode congelar o `Object.prototype` (en-US) previamente, declarar todas as opções explicitamente, ou apontar para `null` com `Object.create(null)`.

```js
// usando \_\_proto\_\_
var obj = {};
var descriptor = Object.create(null); // não herdar propriedades
// não enumerável, não configurável, não gravável por padrão
descriptor.value = "static";
Object.defineProperty(obj, "key", descriptor);

// declarando explicitamente
Object.defineProperty(obj, "key", {
  enumerable: false, // não enumerável
  configurable: false, // não configurável
  writable: false, // não gravável
  value: "static",
});

// reciclando um mesmo objeto
function withValue(value) {
  var d =
    withValue.d ||
    (withValue.d = {
      enumerable: false,
      writable: false,
      configurable: false,
      value: null,
    });
  d.value = value;
  return d;
}

// ... e ...
Object.defineProperty(obj, "key", withValue("static"));

// se o método freeze estiver disponível, prevenir as propriedades
// (value, get, set, enumerable, writable, configurable) de serem
// incluídas ou removidas do protótipo do objeto
(Object.freeze || Object)(Object.prototype);
```

Exemplos
--------

Se você deseja utilizar o método `Object.defineProperty` com uma sintaxe estilo *flags-binárias*, veja os exemplos adicionais.

### Criando uma propriedade

Quando a propriedade especificada não existe no objeto, `Object.defineProperty()` cria uma nova propriedade conforme descrito anteriormente. Campos podem ser omitidos no descritor, e os valores padrão para esses campos serão introduzidos.

Todos os campos do tipo Boolean possuem como valor padrão `false`. Os campos `value`, `get`, e `set` possuem como padrão `undefined`. Uma propriedade que é definida sem os valores para `get`/`set`/`value`/`writable` é dita "genérica" e classificada como um descritor de dados.

```js
var o = {}; // Criar um novo objeto

// Exemplo de propriedade de objeto inserida através
// de defineProperty com descritor do tipo dado
Object.defineProperty(o, "a", {
  value: 37,
  writable: true,
  enumerable: true,
  configurable: true,
});
// A propriedade 'a' existe no objeto com valor 37

// Exemplo de propriedade de objeto inserida através
// de defineProperty com descritor do tipo assessor
var bValue = 38;

Object.defineProperty(o, "b", {
  get: function () {
    return bValue;
  },
  set: function (newValue) {
    bValue = newValue;
  },
  enumerable: true,
  configurable: true,
});

o.b; // 38
// A propriedade 'b' existe no objeto com valor 38
// O valor de o.b será sempre idêntico a bValue, a
// menos que o.b seja redefinido

// Você não pode combinar ambos os tipos:
Object.defineProperty(o, "conflict", {
  value: 0x9f91102,
  get: function () {
    return 0xdeadbeef;
  },
});
// lança um TypeError: value existe apenas em descritores
// de dado, get existe apenas em descritores de assessor
```

### Modificando uma propriedade

Quando uma propriedade já existe, `Object.defineProperty()` tenta modificá-la de acordo com os valores do descritor e a configuração atual do objeto. Se o descritor antigo possuía seu atributo `configurable` como `false` a propriedade é chamada "não configurável" e nenhum atributo pode ser alterado (exceto a alteração irreversível de *writable* para *false*). Não é possível alternar o tipo de uma propriedade entre dados e assessor quando esta for não-configurável.

Um `TypeError` é lançado quando são realizadas tentativas de se alterar propriedades não-configuráveis (exceto o atributo `writable`) a menos que o valor atual e o novo sejam os mesmos.

#### O atributo writable

Quando o atributo `writable` de uma propriedade é definido como `false`, a propriedade é dita "não-gravável". Seu valor não poderá ser alterado.

```js
var o = {}; // Cria um novo objeto

Object.defineProperty(o, "a", {
  value: 37,
  writable: false,
});

console.log(o.a); // escreve 37

o.a = 25; // Nenhum erro é lançado (no modo strict seria
// lançado mesmo que o valor fosse o mesmo)

console.log(o.a); // escreve 37. A atribuição não teve efeito.
```

Como visto no exemplo, tentativas de escrita em uma propriedade não-gravável não alteram seu valor, mas também não lançam erros.

#### O atributo enumerable

O atributo `enumerable` de uma propriedade define se ela deve ser exibida em uma repetição `for...in` e por `Object.keys()` ou não.

```js
var o = {};

Object.defineProperty(o, "a", {
  value: 1,
  enumerable: true,
});

Object.defineProperty(o, "b", {
  value: 2,
  enumerable: false,
});

Object.defineProperty(o, "c", {
  value: 3,
}); // o valor padrão para enumerable é false

o.d = 4; // o valor padrão para enumerable é true quando
// a propriedade é criada em uma atribuição

for (var i in o) {
  console.log(i);
}
// escreve 'a' e 'd' (em ordem indefinida)

Object.keys(o); // ['a', 'd']

o.propertyIsEnumerable("a"); // true
o.propertyIsEnumerable("b"); // false
o.propertyIsEnumerable("c"); // false
```

#### O atributo configurable

O atributo `configurable` controla ao mesmo se uma propriedade pode ser deletada do objeto, e se seus atributos (exceto a mudança de `writable` para `false`) podem ser alterados.

```js
var o = {};

Object.defineProperty(o, "a", {
  get: function () {
    return 1;
  },
  configurable: false,
});

Object.defineProperty(o, "a", {
  configurable: true,
}); // lança um TypeError

Object.defineProperty(o, "a", {
  enumerable: true,
}); // lança um TypeError

Object.defineProperty(o, "a", {
  set: function () {},
}); // lança um TypeError (o atributo set já estava definido)

Object.defineProperty(o, "a", {
  get: function () {
    return 1;
  },
}); // lança um TypeError
// (mesmo o novo get fazendo exatamente a mesma coisa)

Object.defineProperty(o, "a", {
  value: 12,
}); // lança um TypeError

console.log(o.a); // escreve 1
delete o.a; // Nada acontece
console.log(o.a); // escreve 1
```

Se o atributo `configurable` de `o.a` fosse `true`, nenhum dos erros seria lançado e a propriedade estaria deletada ao final.

### Incluindo propriedades e valores padrão

É importante considerar a forma como os valores padrão para atributos são aplicados. Normalmente existe diferença entre usar a notação por ponto para atribuir um valor e usar `Object.defineProperty()`, como pode ser visto no exemplo abaixo:

```js
var o = {};

o.a = 1;

// é equivalente a:
Object.defineProperty(o, "a", {
  value: 1,
  writable: true,
  configurable: true,
  enumerable: true,
});

// Por outro lado,
Object.defineProperty(o, "a", { value: 1 });

// é equivalente a:
Object.defineProperty(o, "a", {
  value: 1,
  writable: false,
  configurable: false,
  enumerable: false,
});
```

### Setters e getters customizados

O exemplo abaixo mostra como implementar um objeto auto-arquivável. Quando a propriedade `temperature` é atribuída, o array `archive` recebe uma nova entrada de log.

```js
function Archiver() {
  var temperature = null;
  var archive = [];

  Object.defineProperty(this, "temperature", {
    get: function () {
      console.log("get!");
      return temperature;
    },
    set: function (value) {
      temperature = value;
      archive.push({ val: temperature });
    },
  });

  this.getArchive = function () {
    return archive;
  };
}

var arc = new Archiver();
arc.temperature; // 'get!'
arc.temperature = 11;
arc.temperature = 13;
arc.getArchive(); // [{ val: 11 }, { val: 13 }]
```

Neste exemplo, um getter sempre retorna o mesmo valor.

```js
var pattern = {
  get: function () {
    return (
      "Eu sempre retorno esta string, " + "não importa o que você atribuiu"
    );
  },
  set: function () {
    this.myname = "esta string é meu nome";
  },
};

function TestDefineSetAndGet() {
  Object.defineProperty(this, "myproperty", pattern);
}

var instance = new TestDefineSetAndGet();
instance.myproperty = "test";

console.log(instance.myproperty);
// Eu sempre retorno esta string, não importa o que você atribuiu

console.log(instance.myname); // esta string é meu nome
```

### Propriedades de Herança

Se uma propriedade de acessor é herdada, métodos `get` e `set` serão chamados quando a propriedade é acessada e modificada sobre os objetos descendentes. Se estes métodos usam uma variável para armazenar o valor, este valor será compartilhada por todos os objetos.
```

function myclass() {
}

var value;
Object.defineProperty(myclass.prototype, "x", {
  get() {
    return value;
  },
  set(x) {
    value = x;
  }
});

var a = new myclass();
var b = new myclass();
a.x = 1;
console.log(b.x); // 1
```

Isto pode ser corrigido armazenando o valor em outra propriedade. Em métodos `get` e `set`, `this` aponta para o objeto no qual é usado para acessar ou modificar a propriedade.
```

function myclass() {
}

Object.defineProperty(myclass.prototype, "x", {
  get() {
    return this.stored_x;
  },
  set(x) {
    this.stored_x = x;
  }
});

var a = new myclass();
var b = new myclass();
a.x = 1;
console.log(b.x); // undefined
```

Ao contrário das propriedades do acessor, propriedades do valor serão sempre configuradas sobre o próprio objeto, não sobre um protótipo. Entretanto, se uma propriedade de valor não-gravável é herdada, ele ainda previne de modicação a propriedade do objeto.
```

function myclass() {
}

myclass.prototype.x = 1;
Object.defineProperty(myclass.prototype, "y", {
  writable: false,
  value: 1
});

var a = new myclass();
a.x = 2;
console.log(a.x); // 2
console.log(myclass.prototype.x); // 1
a.y = 2; // Ignorado, lança no modo strict
console.log(a.y); // 1
console.log(myclass.prototype.y); // 1
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.defineproperty |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Notas de compatibilidade
------------------------

### Redefinindo a propriedade `length` de um objeto `Array`

É possível redefinir a propriedade `length` de arrays, sujeita às restrições de redefinição usuais. (A propriedade `length` é inicialmente não configurável, não enumerável, mas gravável. Assim, em um array que não foi modificado, é possível alterar o valor da propriedade `length` ou torná-la não-gravável. Não é permitido alterar sua enumerabilidade ou configurabilidade, ou quando se encontrar não-gravável, alterar seu valor ou torná-la gravável novamente.) Entretanto, nem todos os browsers permitem esta redefinição.

Das versões 4 até 22 do Firefox, um `TypeError` é lançado em qualquer tentativa (seja ela permitida ou não) de redefinir a propriedade `length` de um array.

Versões do Chrome que implementam `Object.defineProperty()` em algumas circunstâncias ignoram um valor para *length* diferente do valor atual da propriedade `length` do array. Em algumas circustâncias, alterar o atributo `writable` falha de forma silenciosa (sem lançar uma exceção). Além disso, alguns métodos que modificam o array como {jsxref("Array.prototype.push")}} não respeitam uma propriedade *length* não-gravável.

Versões do Safari que implementam `Object.defineProperty()` ignoram um valor para `length` diferente do valor atual da propriedade `length`, e tentantivas de alterar o atributo `writable` executam sem erros embora não modifiquem seu comportamento.

Apenas o Internet Explorer 9 a posteriores, e o Firefox 23 e posteriores, parecem implementar total e corretamente a redefinição da propriedade `length` de arrays. Por enquanto, não confie que a redefinição da propriedade `length` vá funcionar, mesmo que de uma forma particular. E mesmo quando você *puder* confiar, existem boas razões para não fazer isso.

### Notas específicas para o Internet Explorer 8

O Internet Explorer 8 implementa o método `Object.defineProperty()` para uso apenas em objetos DOM. Algumas observações:

* Tentativas de usar `Object.defineProperty()` em objetos nativos lançam um erro.
* Todos os atributos da propriedade devem ter seu valor definido. Os atributos `configurable`, `enumerable` e `writable` devem ser `true` para um descritor do tipo dado, e `true` para `configurable` e `false` para `enumerable` em descritores do tipo assessor. (?) Qualquer tentativa de usar outros valores (?) resultará no lançamento de um erro.
* Reconfigurar uma propriedade exige que ela seja deletada anteriormente. Se a propriedade não for deletada, ela permanecerá inalterada após a tentativa de reconfiguração.
Veja também
-----------

* Enumerabilidade and posse de propriedades (en-US)
* `Object.defineProperties()`
* `Object.propertyIsEnumerable()`
* `Object.getOwnPropertyDescriptor()`
* `Object.prototype.watch()`
* `Object.prototype.unwatch()`
* `get` (en-US)
* `set` (en-US)
* `Object.create()`
* Exemplos adicionais de `Object.defineProperty`
* `Reflect.defineProperty()`


Object.seal() - JavaScript

Object.seal()
=============

O método **`Object.seal()`** sela um Objeto, evitando que novas propriedades sejam adicionadas à ele e marcando todas as propriedades existentes como não configuráveis. Valores das propriedades atuais ainda podem ser alterados desde que essas propriedades sejam graváveis (writable).

Sintaxe
-------
```

Object.seal(obj)
```

### Parâmetros

`obj`

O Objeto que deve ser selado.

### Valor de retorno

O Objeto sendo selado.

Descrição
---------

Por padrão, objetos são extensible (novas propriedades podem ser adicionadas à eles). Selar um objeto evita que novas propriedades sejam adicionadas e marca todas as propriedades existentes como não configuráveis. Isto tem o efeito de tornar as propriedades no objeto fixas e imutáveis. Tornando todas as propriedades não configuráveis também evita que as mesmas sejam convertidas de propriedades de dados para propriedades de acesso e vice-versa, mas não evita que os valores das propriedades de dados sejam alterados. A tentativa de deletar ou adicionar propriedades à um objeto selado, ou converter uma propriedade de dado para uma propriedade de acesso ou vice-versa, irá falhar, seja silenciosamente como jogando o erro `TypeError` (mais comumente, mas não exclusivamente, quando em modo rigoroso strict mode de código).

A cadeia de prototipação permanece intocada. Entretanto, a propriedade `Object.prototype.__proto__`
Deprecated
 é selada também.

Retorna a referência ao Objeto passado.

Exemplos
--------

```js
var obj = {
  prop: function () {},
  foo: "bar",
};

// Novas propriedades podem ser adicionadas, propriedades existentes podem ser alteradas ou removidas.
obj.foo = "baz";
obj.lumpy = "woof";
delete obj.prop;

var o = Object.seal(obj);

o === obj; // true
Object.isSealed(obj); // === true

// Alterar o valor das propriedades em um objeto selado ainda funciona.
obj.foo = "quux";

// Mas você não pode converter propriedades de dados em propriedades de acesso, e vice-versa.
Object.defineProperty(obj, "foo", {
  get: function () {
    return "g";
  },
}); // throws a TypeError

// Agora quaisquer mudanças, que não sejam aos valores da das propriedades, irão falhar.
obj.quaxxor = "the friendly duck"; // silently doesn't add the property
delete obj.foo; // silently doesn't delete the property

// e em modo rigoroso (strict mode) tais tentativas irão jogar erros do tipo TypeErrors.
function fail() {
  "use strict";
  delete obj.foo; // throws a TypeError
  obj.sparky = "arf"; // throws a TypeError
}
fail();

// Tentativas através do Object.defineProperty também irão falhar.
Object.defineProperty(obj, "ohai", { value: 17 }); // lança um erro do tipo TypeError
Object.defineProperty(obj, "foo", { value: "eit" }); // altera o valor da propriedade existente
```

Notas
-----

No ES5, se o argumento passado à este método não é um objeto (primitivo) , irá causar um erro `TypeError`. No ES6, qualquer argumento que não seja um objeto será tratado como se fosse um objeto ordinário selado e simplesmente irá retorná-lo

```js
Object.seal(1);
// TypeError: 1 não é um Objeto (código ES5)

Object.seal(1);
// 1 (código ES6)
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.seal |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.isSealed()`
* `Object.preventExtensions()`
* `Object.isExtensible()`
* `Object.freeze()`
* `Object.isFrozen()`


Object.prototype.__defineSetter__() - JavaScript

Object.prototype.\_\_defineSetter\_\_()
=======================================

**Aviso:** Esta funcionalidade está depreciada em favor da definição de setters usando a sintaxe de inicialização de objeto ou a API `Object.defineProperty()`.

Entretando, como ele é largamente implementado e usado na Web, é bem improvável que os navegadores vão parar de implementá-lo.

O método **`__defineSetter__`** vincula uma propriedade de um objeto a uma função a ser chamada quando é feita uma tentativa de atribuir algo a aquela propriedade.

Sintaxe
-------
```

obj.__defineSetter__(prop, fun)
```

### Parâmetros

`prop`

Uma cadeia de caracteres (*string*) contendo o nome da propriedade que vai ser vinculada a função dada.

`fun`

A função a ser chamada quando houver uma tentativa de atribuir na propriedade especificada. Esta função toma a forma

```js
function(val) { . . . }
```

`val`

Um apelido para a variável que contém o valor que se tentou atribuir a `prop`.

### Valor de retorno

`undefined`.

Descrição
---------

O método `__defineSetter__` permite um setter (en-US) ser definido a um objeto pré-existente.

Exemplos
--------

### Não padronizados e forma depreciada

```js
var o = {};
o.\_\_defineSetter\_\_("value", function (val) {
  this.anotherValue = val;
});
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5
```

### Formas compatíveis padronizadas

```js
// Usando o operador set
var o = {
  set value(val) {
    this.anotherValue = val;
  },
};
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5

// Usando Object.defineProperty
var o = {};
Object.defineProperty(o, "value", {
  set: function (val) {
    this.anotherValue = val;
  },
});
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.\_\_defineSetter\_\_ |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.prototype.__defineGetter__()`
* Operador `set` (en-US)
* `Object.defineProperty()`
* `Object.prototype.__lookupGetter__()`
* `Object.prototype.__lookupSetter__()`
* JS Guide: Defining Getters and Setters
* [Blog Post] Deprecation of \_\_defineGetter\_\_ and \_\_defineSetter\_\_
* bug 647423


Object.isExtensible() - JavaScript

Object.isExtensible()
=====================

O método **`Object.isExtensible()`** verifica se um objeto pode ser extendido (se é ou não possível adicinar novas propriedades).

Experimente
-----------

Sintaxe
-------
```

Object.isExtensible(obj)
```

### Parâmetros

`obj`

O objeto a ser verificado.

### Valor de retorno

Um valor booleano (`Boolean`) que indica se o objeto pode ser extendido.

Descrição
---------

Objetos são extensíveis por padrão: novas propriedades podem ser adicionadas, e (em ambientes que suportam `Object.prototype.__proto__`
Deprecated
) a propriedade \_\_proto\_\_ pode ser modificada. Um objeto pode ser marcado como não extensível usando `Object.preventExtensions()`, `Object.seal()`, ou `Object.freeze()`.

Exemplos
--------

```js
// Novos objetos podem ser extendidos.
var empty = {};
Object.isExtensible(empty); // === true

// ...mas isso pode mudar.
Object.preventExtensions(empty);
Object.isExtensible(empty); // === false

// Objetos selados, não podem ser extendidos.
var sealed = Object.seal({});
Object.isExtensible(sealed); // === false

// Objetos congelados também não podem ser extendidos.
var frozen = Object.freeze({});
Object.isExtensible(frozen); // === false
```

Notas
-----

No ES5, se o argumento fornecido não for um objeto (um tipo primitivo), isso vai causar um erro do tipo `TypeError`. No ES2015, um argumento que não é um objeto será tratado como um objeto não extensível, simplesmente retornando `false`.

```js
Object.isExtensible(1);
// TypeError: 1 is not an object (ES5 code)

Object.isExtensible(1);
// false (ES2015 code)
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.isextensible |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

See also
--------

* `Object.preventExtensions()`
* `Object.seal()`
* `Object.isSealed()`
* `Object.freeze()`
* `Object.isFrozen()`
* `Reflect.isExtensible()` (en-US)


Object.getPrototypeOf() - JavaScript

Object.getPrototypeOf()
=======================

O método **`Object.getPrototypeOf()`** retorna o prototype (isto é, o valor da propriedade interna `[[Prototype]]`) do objeto especificado.

Sintaxe
-------
```

Object.getPrototypeOf(obj)
```

### Parâmetros

`obj`

O objeto cujo prototype será retornado.

Exemplos
--------

```js
var proto = {};
var obj = Object.create(proto);
Object.getPrototypeOf(obj) === proto; // true
```

Notas
-----

No ES5 será lançada uma exceção `TypeError` se o parâmetro obj não for um objeto. No ES6, no entanto, esse valor será submetido a um `Object` equivalente ao seu tipo e retornado.

```js
Object.getPrototypeOf("foo");
// TypeError: "foo" não é um objeto (código ES5)
Object.getPrototypeOf("foo");
// String.prototype (código ES6)
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.getprototypeof |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Notas específicas para o Opera
------------------------------

Embora as versões mais antigas do Opera não suportem `Object.getPrototypeOf()`, ele suporta a propriedade não oficial `Object.prototype.__proto__` desde de a sua versão 10.50.

Veja também
-----------

* `Object.prototype.isPrototypeOf()`
* `Object.setPrototypeOf()`
Experimental
* `Object.prototype.__proto__`
* John Resig's post on getPrototypeOf
* `Reflect.getPrototypeOf()` (en-US)


Object.getOwnPropertySymbols() - JavaScript

Object.getOwnPropertySymbols()
==============================

O **`Object.getOwnPropertySymbols()`** método retorna uma array com todas propriedades de símbolo encontradas diretamente em um determinado objeto dado.

Experimente
-----------

Sintaxe
-------

```js
Object.getOwnPropertySymbols(obj);
```

### Parâmetro

`obj`

O objeto pelo qual as propriedades de símbolos são retornas.

### Valor retornado

Uma array com todas as propriedades de símbolos encontradas diretamente pelo o objeto dado.

Descrição
---------

Similar do `Object.getOwnPropertyNames()`, você pode obter todas as propriedades de símbolo de um objeto dado como um array de símbolos. Lembre que o próprio `Object.getOwnPropertyNames()` não contém as propriedades de símbolo de um objeto e somente as propriedades de string.

Como todos os objetos não possuem símbolos próprios inicialmente, o `Object.getOwnPropertySymbols()` retorna uma array vazia a menos que você tenha definido as propriedades de símbolo do seu objeto .

Exemplos
--------

### Usando getOwnPropertySymbols

```js
var obj = {};
var a = Symbol("a");
var b = Symbol.for("b");

obj[a] = "localSymbol";
obj[b] = "globalSymbol";

var objectSymbols = Object.getOwnPropertySymbols(obj);

console.log(objectSymbols.length); // retorno esperado 2
console.log(objectSymbols); // retorno esperado (2) [Symbol(a), Symbol(b)]
console.log(objectSymbols[0]); // retorno esperado Symbol(a)
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.getownpropertysymbols |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.getOwnPropertyNames()`
* `Symbol`


Object.hasOwn() - JavaScript

Object.hasOwn()
===============

O método estático **`Object.hasOwn()`** retorna `true` se o objeto específicado tem a propriedade indicada como sua propriedade *own*. Se a propriedade é herdada, ou não existe, o método retorna `false`.

**Nota:** `Object.hasOwn()` Tem a intenção de substituir `Object.hasOwnProperty()`.

Experimente
-----------

Sintaxe
-------

```js
hasOwn(instance, prop);
```

### Parâmetros

`instance`

A instância do objeto javascript para o teste.

`prop`

O nome `String` ou Symbol da propriedade para teste.

### Retorna valor

`true` se o objeto especificado definiu diretamente a propriedade especificada. Por outro lado `false`.

Descrição
---------

O método **`Object.hasOwn()`** retorna `true` se a propriedade especificada é uma propriedade direta do objeto - mesmo se o valor da propriedade é `null` ou `undefined`.

O método retorna `false` se a propriedade é herdada, ou não foi declarada. Diferente do operador `in`, este método não verifica pela propriedade específica na cadeia do objeto.

Ele é mais recomendado do que `Object.hasOwnProperty()` porque ele funciona para objetos criados utilizando `Object.create(null)` e com objetos que sobescreveram o método herdado `hasOwnProperty()`. É possível contornar esse problema chamando o `Object.prototype.hasOwnProperty()` em um objeto externo, `Object.hasOwn()` é mais intuítivo.

Exemplos
--------

### Utilizando hasOwn para o teste de propriedades existentes

O seguinte código mostra como determinar se o seguinte objeto `example` contém a propriedade `prop`.

```js
const example = {};
Object.hasOwn(example, "prop"); // false = 'prop' ela não foi definida

example.prop = "exists";
Object.hasOwn(example, "prop"); // true - 'prop' ela foi definida

example.prop = null;
Object.hasOwn(example, "prop"); // true - a propriedade existe com o valor null

example.prop = undefined;
Object.hasOwn(example, "prop"); // true - a propriedade existe com o valor undefined
```

### Propriedaedes direta vs. herdada

O seguinte exemplo diferencia entre propriedade direta e proprietade errada através do prototype chain:

```js
const example = {};
example.prop = "exists";

// `hasOwn` Só retornará true para propriedades diretas will:
Object.hasOwn(example, "prop"); // returns true
Object.hasOwn(example, "toString"); // returns false
Object.hasOwn(example, "hasOwnProperty"); // returns false

// O operador `in` só retornara tru para propriedades diretas ou herdadas:
"prop" in example; // returns true
"toString" in example; // returns true
"hasOwnProperty" in example; // returns true
```

### Iterando sobre as propriedades de um objeto

Para itererar sobre inúmeras propriedades de um objeto, você deve usar:

```js
const example = { foo: true, bar: true };
for (const name of Object.keys(example)) {
  // …
}
```

Mas se você precisa utilizar `for...in`, você pode utilziar `Object.hasOwn()` para pular as propriedades herdadas.

```js
const example = { foo: true, bar: true };
for (const name in example) {
  if (Object.hasOwn(example, name)) {
    // …
  }
}
```

### Verificando se um index existe em um array

Os elementos de um `Array` são definidos como propriedades diretas, você pode utilizar o método `hasOwn()` para verificar se existe um index específico:

```js
const fruits = ["Apple", "Banana", "Watermelon", "Orange"];
Object.hasOwn(fruits, 3); // true ('Orange')
Object.hasOwn(fruits, 4); // false - not defined
```

### Casos problematicos para hasOwnProperty

Essa seção demonstra `hasOwn()` é imune aos problemas que afetam `hasOwnProperty`. Primeiramente, ele pode ser uasdos em objetos que foram reimplementados `hasOwnProperty()`:

```js
const foo = {
  hasOwnProperty() {
    return false;
  },
  bar: "The dragons be out of office",
};

if (Object.hasOwn(foo, "bar")) {
  console.log(foo.bar); //true - reimplementação do hasOwnProperty() não afetara o objeto
}
```

Ele pode ser usado para testar objetos criados utilizando `Object.create(null)`. Esses não são herdados de `Object.prototype`, e assim o `hasOwnProperty()` é inacessível

```js
const foo = Object.create(null);
foo.prop = "exists";
if (Object.hasOwn(foo, "prop")) {
  console.log(foo.prop); //true - Funciona independente de como o objeto é criado.
}
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.hasown |

Compabitiblidade de navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* Polyfill of `Object.hasOwn` in `core-js`
* `Object.hasOwnProperty()`
* Enumerability and ownership of properties
* `Object.getOwnPropertyNames()`
* `for...in`
* `in`
* JavaScript Guide: Inheritance revisited


Object.prototype.__lookupGetter__() - JavaScript

Object.prototype.\_\_lookupGetter\_\_()
=======================================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método **`__lookupGetter__`** retorna a função limite como uma getter para a específica propriedade.

Sintaxe
-------
```

obj.__lookupGetter__(sprop)
```

### Parâmetros

`sprop`

Uma sequência de caracteres contendo o nome da propriedade cuja getter deve retornar.

### Valores de retorno

A função limite como uma getter para a específica propriedade.

Descrição
---------

Se uma getter foi definida por uma propriedade de um objeto, não é possível referir-se a função getter através da propriedade, porque essa propriedade se refere ao retorno do valor daquela função. `__lookupGetter__` pode ser usado para obter referência à função getter.

Agora é possível fazer isso de um jeito uniforme usando:. `Object.getOwnPropertyDescriptor()` e `Object.getPrototypeOf()`.

Exemplos
--------

```js
var obj = {
  get foo() {
    return Math.random() > 0.5 ? "foo" : "bar";
  },
};

// Non-standard and deprecated way
obj.\_\_lookupGetter\_\_("foo");
// (function() { return Math.random() > 0.5 ? 'foo' : 'bar'; })

// Standard-compliant way
Object.getOwnPropertyDescriptor(obj, "foo").get;
// (function() { return Math.random() > 0.5 ? 'foo' : 'bar'; })
```

Specificações
-------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.\_\_lookupGetter\_\_ |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver também
----------

* `Object.prototype.__lookupSetter__()`
* `get` operador
* `Object.getOwnPropertyDescriptor()` e `Object.getPrototypeOf()`
* `Object.prototype.__defineGetter__()`
* `Object.prototype.__defineSetter__()`
* JS Guide: Defining Getters and Setters


Object.getOwnPropertyDescriptors() - JavaScript

Object.getOwnPropertyDescriptors()
==================================

O **`Object.getOwnPropertyDescriptors()`** método retorna todas as descrições próprias da propriedade de um dado objeto.

Experimente
-----------

Sintaxe
-------
```

Object.getOwnPropertyDescriptors(obj)
```

### Parâmetro

`obj`

O objeto pelo o qual deseja obter todos os descritores de propriedade próprios.

### Valor retornado

Um objeto contendo todas as propriedades descritivas de um objeto. Pode ser um objeto vazio, se não existir propriedade.

Descrição
---------

Esse método permite examinar a descrição precisa de todas as propriedades de um objeto. Uma propriedade em JavaScript consiste de um nome com valor string ou um `Symbol` e uma propriedade descritora. Outras informações sobre propriedade de tipo descritoras e seus atributos podem ser encontradas em `Object.defineProperty()`.

Uma propriedade descritora é um registro com alguns dos seguintes atributos:

`value`

O valor associdado com à propriedade (somente descritores de dados).

**`writable`**

`true` se somente o valor associado com a propriedade pode ser alterada (somente descritores de dados).

`get`

Uma função que serve como um capturador para a propriedade ou `undefined` se não existir um capturador (somente descritores de acesso).

`set`

Uma função que serve como um configurador para a propriedade, ou `undefined` se não existir um configurador (somente descritores de acesso).

`configurable`

`true` se e somente se o tipo da propriedade descritora pode ser alterada e se a propriedade pode ser deletada do objeto correspondente.

`enumerable`

`true` se e somente se essa propriedade se mostrar durante a enumeração da propriedade no objeto correspondente.

Exemplos
--------

### Criando um clone superficial

Enquanto o `Object.assign()` método vai copiar somente o enumerável e as próprias propriedades da origem de um objeto para o objeto alvo, você é capaz de usar esse método e `Object.create()` para uma cópia superficial entre dois objetos desconhecidos:

```js
Object.create(
  Object.getPrototypeOf(obj),
  Object.getOwnPropertyDescriptors(obj),
);
```

### Criando uma subclasse

Um modo típico de criar uma subclasse é definir a subclasse, configurar um protótipo para uma instância da superclasse e depois difinir as propriedades daquela instância. Isso pode ficar estranho especialmente para os capturadores e configuradores. Ao invés disso, você pode usar esse código para configurar o protótipo :

```js
function superclass() {}
superclass.prototype = {
  // Define seu método e propriedades aqui
};
function subclass() {}
subclass.prototype = Object.create(superclass.prototype, {
  // Define seu método e propriedades aqui
});
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.getownpropertydescriptors |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.getOwnPropertyDescriptor()`
* `Object.defineProperty()`
* Polyfill


Object.fromEntries() - JavaScript

Object.fromEntries()
====================

O método **`Object.fromEntries()`** transforma uma lista de pares chave-valor em um objeto.

Experimente
-----------

Sintaxe
-------
```

Object.fromEntries(iterable);
```

### Parâmetros

`iterable`

Um iterável como `Array` ou `Map` ou qualquer outro objeto que implemente o protocolo iterável.

### Valor de retorno

Um novo objeto com suas propriedades definidas pelas entradas fornecidadas pelo iterável.

Descrição
---------

O método `Object.fromEntries()` recebe uma lista de pares chave-valor e retorna um novo objeto cujas propriedades foram definidas pelas entradas da lista. O parâmetro *iterable* deve ser um objeto que implemente o método `@@iterator`, que retorne um objeto iterador que produza um objeto *array-like* de dois elementos, onde o primeiro será a chave da propriedade e o segundo será o valor associado à chave.

`Object.fromEntries()` faz o inverso de `Object.entries()`.

Exemplos
--------

### Convertendo um `Map` em um `Object`

Com o método `Object.fromEntries`, é possível fazer a conveeção de um `Map` em um `Object`:

```js
const map = new Map([
  ["foo", "bar"],
  ["baz", 42],
]);
const obj = Object.fromEntries(map);
console.log(obj); // { foo: "bar", baz: 42 }
```

### Convertendo um `Array` em um `Object`

Com o método `Object.fromEntries`, é possível converter um `Array` em um `Object`:

```js
const arr = [
  ["0", "a"],
  ["1", "b"],
  ["2", "c"],
];
const obj = Object.fromEntries(arr);
console.log(obj); // { 0: "a", 1: "b", 2: "c" }
```

### Transformações de objetos

Com o método `Object.fromEntries`, seu inverso `Object.entries()`, e os métodos para manipulação de arrays, é possível fazer transformações em objetos como por exemplo:

```js
const object1 = { a: 1, b: 2, c: 3 };

const object2 = Object.fromEntries(
  Object.entries(object1).map(([key, val]) => [key, val \* 2]),
);

console.log(object2);
// { a: 2, b: 4, c: 6 }
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.fromentries |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja Também
-----------

* `Object.entries()`
* `Object.keys()`
* `Object.values()`
* `Map.prototype.entries()`
* `Map.prototype.keys()`
* `Map.prototype.values()`


Object.create() - JavaScript

Object.create()
===============

O método **`Object.create()`** cria um novo objeto, utilizando um outro objeto existente como protótipo para o novo objeto a ser criado.

Experimente
-----------

Sintaxe
-------
```

Object.create(proto[, propertiesObject])
```

### Parâmetros

`proto`

O objeto que deve ser o protótipo do objeto recém-criado.

`propertiesObject`

Opcional. Se especificado e não `undefined`, um objeto cuja as propriedades próprias enumeráveis (isto é, aquelas propriedades definidas sobre si mesmo, e *não* propriedades enumeráveis ao longo da sua cadeia protótipa) especificam os nomes das propriedades a serem adicionadas ao objeto recém-criado, com os nomes das propriedades correspondentes. Essas propriedades correspondem ao segundo argumento de `Object.defineProperties()`.

### Retorno

Um novo objeto com o protótipo de objeto e propriedades especificadas.

### Exceções

Uma exceção `TypeError` se o parâmetro `proto` não for `null` ou um objeto.

Exemplos
--------

### Herança tradicional com `Object.create()`

A seguir, um exemplo de como usar `Object.create()` para realizar uma herança tradicional. Isto é para herança simples, que é a única herança suportada pelo JavaScript.

```js
// Shape - superclasse
function Shape() {
  this.x = 0;
  this.y = 0;
}

// método da superclasse
Shape.prototype.move = function (x, y) {
  this.x += x;
  this.y += y;
  console.info("Shape moved.");
};

// Rectangle - subclasse
function Rectangle() {
  Shape.call(this); // chama construtor-pai.
}

// subclasse extende superclasse
Rectangle.prototype = Object.create(Shape.prototype);
Rectangle.prototype.constructor = Rectangle;

var rect = new Rectangle();

console.log("Rect é uma instância de Rectangle?", rect instanceof Rectangle); // true
console.log("Rect é uma instância de Shape?", rect instanceof Shape); // true
rect.move(1, 1); // Saída: 'Shape moved.'
```

Caso queira realizar herança de múltiplos objetos, então mixins ("mistura") são uma possibilidade.

```js
function MyClass() {
  SuperClass.call(this);
  OtherSuperClass.call(this);
}

MyClass.prototype = Object.create(SuperClass.prototype); // herança
mixin(MyClass.prototype, OtherSuperClass.prototype); // mixin

MyClass.prototype.myMethod = function () {
  // faz algo
};
```

A função `mixin` copia as funções do protótipo da superclasse para o protótipo da subclasse, a função mixin precisa ser fornecida pelo usuário. Um exemplo de uma função do tipo mixin seria jQuery.extend().

### Usando argumento `propertiesObject` com `Object.create()`

```js
var o;

// cria um objeto com protótipo null
o = Object.create(null);

o = {};
// equivalente a:
o = Object.create(Object.prototype);

// Exemplo em que criamos um objeto com algumas propriedades
// (Note que o segundo parâmetro mapeia as chaves para \*descritores de propriedade\*.)
o = Object.create(Object.prototype, {
  // foo é uma 'propriedade de valor' ('value property') normal
  foo: { writable: true, configurable: true, value: "hello" },
  // bar é uma propriedade getter-setter (accessor)
  bar: {
    configurable: false,
    get: function () {
      return 10;
    },
    set: function (value) {
      console.log("Setting `o.bar` to", value);
    },
    /\* com os ES5 Accessors nosso código pode ser escrito como:
 get() { return 10; },
 set(value) { console.log('setting `o.bar` to', value); } \*/
  },
});

function Constructor() {}
o = new Constructor();
// equivalente a:
o = Object.create(Constructor.prototype);
// Claro, se há de fato um código de inicialização na função
// Constructor, o Object.create() não pode refleti-la

// Cria um novo objeto cujo protóptipo é um objeto novo, vazio
// e adiciona a propriedade 'p' com o valor 42.
o = Object.create({}, { p: { value: 42 } });

// por padrão, propriedades NÃO SÃO escritas, enumeradas ou configuráveis:
o.p = 24;
o.p;
// 42

o.q = 12;
for (var prop in o) {
  console.log(prop);
}
// 'q'

delete o.p;
// false

// especificar uma propriedade ES3
o2 = Object.create(
  {},
  {
    p: {
      value: 42,
      writable: true,
      enumerable: true,
      configurable: true,
    },
  },
);
```

Polyfill
--------

Este polyfill cobre o caso de uso principal que é a crição de um novo objeto em que o protótipo foi escolhido mas não leva em consideração o segundo argumento.

Note que, enquanto a configuração `null` as `[[Prototype]]` é suportada no ES5 `Object.create`, este polyfill não suporta devido à limitação inerente em versões do ECMAScript inferiores a 5.

```js
if (typeof Object.create != "function") {
  Object.create = (function () {
    var Temp = function () {};
    return function (prototype) {
      if (arguments.length > 1) {
        throw Error("Second argument not supported");
      }
      if (typeof prototype != "object") {
        throw TypeError("Argument must be an object");
      }
      Temp.prototype = prototype;
      var result = new Temp();
      Temp.prototype = null;
      return result;
    };
  })();
}
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.create |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.defineProperty()`
* `Object.defineProperties()`
* `Object.prototype.isPrototypeOf()`
* Post de John Resig sobre getPrototypeOf()


Object.entries() - JavaScript

Object.entries()
================

**Experimental:** **Esta é uma tecnologia experimental (en-US)**
Verifique a tabela de compatibilidade entre Navegadores cuidadosamente antes de usar essa funcionalidade em produção.

O método **`Object.entries()`** retorna uma array dos próprios pares `[key, value]` enumeráveis de um dado objeto, na mesma ordem dos objetos providos através do loop `for...in` (sendo a diferença que o for-in loop enumera também propriedades dispostas na cadeia de prototipagem - *prototype chain*).

Sintaxe
-------
```

Object.entries(obj)
```

### Parâmetros

`obj`

O objeto cujos próprios pares `[key, value]` de propriedades enumeráveis deverão ser retornados.

### Valor de retorno

Uma array de pares `[key, value]` enumeráveis de propriedades de um dado objeto.

Descrição
---------

`Object.entries()` retorna um array cujos elementos são também arrays correspondentes aos pares de propriedades `[key, value]` enumeráveis encontrados diretamente sobre o objeto. A ordem das propriedades é a mesma que seria se fossem iteradas as propriedades do objeto manualmente.

Exemplos
--------

```js
var obj = { foo: "bar", baz: 42 };
console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]

// objeto array-like
var obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]

// objeto array-like com ordenação aleatória de chave (key)
var an_obj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.entries(an_obj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ]

// getFoo é uma propriedade que não é enumerável
var my_obj = Object.create(
  {},
  {
    getFoo: {
      value: function () {
        return this.foo;
      },
    },
  },
);
my_obj.foo = "bar";
console.log(Object.entries(my_obj)); // [ ['foo', 'bar'] ]

// argumento não-objeto será convertido (conversão implícita) para um objeto
console.log(Object.entries("foo")); // [ ['0', 'f'], ['1', 'o'], ['2', 'o'] ]

// itera graciosamente através de chave-valor (key-value)
var obj = { a: 5, b: 7, c: 9 };
for (var [key, value] of Object.entries(obj)) {
  console.log(key + " " + value); // "a 5", "b 7", "c 9"
}

// Ou, usando array extras
Object.entries(obj).forEach(([key, value]) => {
  console.log(key + " " + value); // "a 5", "b 7", "c 9"
});
```

### Convertendo um `Object` em um `Map`

O construtor `new Map()` aceita entradas iteráveis. Com o `Object.entries`, você pode facilmente converter de `Object` para `Map`:

```js
var obj = { foo: "bar", baz: 42 };
var map = new Map(Object.entries(obj));
console.log(map); // Map { foo: "bar", baz: 42 }
```

Polyfill
--------

Para incluir suporte ao `Object.entries` em ambientes mais antigos, você pode achar um Polyfill nos repositórios: tc39/proposal-object-values-entries e es-shims/Object.entries.

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.entries |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* Enumerabilidade e posse de propriedades
* `Object.keys()`
* `Object.values()`
Experimental
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.getOwnPropertyNames()`


Object.prototype.toLocaleString() - JavaScript

Object.prototype.toLocaleString()
=================================

O método **`toLocaleString()`** retorna uma cadeia de caracteres (*string*) representando o objeto. Este método é feito para ser sobrescrito por objetos derivados para propósitos de localização específica.

Experimente
-----------

Sintaxe
-------
```

obj.toLocaleString()
```

### Valor de retorno

Uma *string* representando o objeto.

Descrição
---------

`toLocaleString` do `Object` retorna o resultado da chamada `toString()`.

Esta função é provida para dar aos objetos um método `toLocaleString` genérico, mesmo que nem todos os usem. Veja a lista abaixo.

### Objetos sobrescrevendo toLocaleString

* `Array`: `Array.prototype.toLocaleString()`
* `Number`: `Number.prototype.toLocaleString()`
* `Date`: `Date.prototype.toLocaleString()` (en-US)
* `TypedArray` (en-US): `TypedArray.prototype.toLocaleString()` (en-US)
* `BigInt`: `BigInt.prototype.toLocaleString()` (en-US)
Exemplos
--------

### Sobrescrita do Array toLocaleString()

Em objetos `Array`, `toLocaleString()` pode ser usado para imprimir valores do arranjo como uma *string*, opcionalmente com identificadores de localização específicos (como símbolos monetários) atrelados a eles:

Por exemplo:

```js
const testArray = [4, 7, 10];

let euroPrices = testArray.toLocaleString("fr", {
  style: "currency",
  currency: "EUR",
});
// "4,00 €,7,00 €,10,00 €"
```

### Sobrescrita do Date toLocaleString()

Em objetos `Date`, `toLocaleString()` (en-US) é usado para imprimir datas mais apropriadas para localizações específicas:

Por exemplo:

```js
const testDate = new Date(Date.now());
// "Date Fri May 29 2020 18:04:24 GMT+0100 (British Summer Time)"

let deDate = testDate.toLocaleString("de");
// "29.5.2020, 18:04:24"

var frDate = testDate.toLocaleString("fr");
//"29/05/2020 à 18:04:24"
```

### Sobrescrita de Number toLocaleString()

Em objetos `Number`, `toLocaleString()` é usado para imprimir números para localizações específicas, e.g. com os corretos separadores:

Por exemplo:

```js
const testNumber = 2901234564;
// "2901234564"

let deNumber = testNumber.toLocaleString("de");
// "2.901.234.564"

let frNumber = testNumber.toLocaleString("fr");
// "2 901 234 564"
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.tolocalestring |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.prototype.toString()`


Object.prototype.toString() - JavaScript

Object.prototype.toString()
===========================

Sumário
-------

O método `toString()` retorna uma string representando o objeto.

Experimente
-----------

Sintaxe
-------

```js
obj.toString();
```

Descrição
---------

Todo objeto possui um método `toString()` que é chamado automaticamente quando o objeto precisa ser representado como um valor em texto ou quando o objeto é referenciado de uma maneira que requeira uma string. Por padrão, o método `toString()` é herdado de todo objeto descendente de `Object`. Se e o método não é sobrescrito em um objeto personalizado, `toString()` retorna "[object *type*]", onde `type` é o tipo do objeto. O código a seguir ilustra isso:

```js
var o = new Object();
o.toString(); // retorna [object Object]
```

**Nota:** Starting in JavaScript 1.8.5 `toString()` called on `null` returns `[object Null]`, and `undefined` returns `[object Undefined]`, as defined in the 5th Edition of ECMAScript and a subsequent Errata. See Using toString to detect object type.

Examples
--------

### Exemplo: Sobrepondo o método inicial `toString`

Você pode criar uma função para ser chamada no lugar do método `toString()`. O método `toString()` não requer parâmetros e deve retornar uma string. O método `toString()` criado por você pode ter o valor que quiser, mas será mais útil se usar informações do objeto.

O código abaixo define o objeto `Dog` e cria `theDog`, um objeto do tipo `Dog`:

```js
function Dog(name, breed, color, sex) {
  this.name = name;
  this.breed = breed;
  this.color = color;
  this.sex = sex;
}

theDog = new Dog("Gabby", "Lab", "chocolate", "female");
```

Se você chamar o método `toString()` neste objeto, ele retornará o valor original herdado de `Object`:

```js
theDog.toString(); // returns [object Object]
```

O código abaixo cria e faz com que `dogToString()` sobrescreva o `toString()` original. Esta função gera uma string contendo **name, breed, color, and sex** do objeto, na forma de "`propriedade = valor;`".

```js
Dog.prototype.toString = function dogToString() {
  var ret =
    "Dog " +
    this.name +
    " is a " +
    this.sex +
    " " +
    this.color +
    " " +
    this.breed;
  return ret;
};
```

Usando este código, toda vez que `theDog` for usado em um texto (string), JavaScript automaticamente chamará a função `dogToString()`, a qual retornará:
```

Dog Gabby is a female chocolate Lab
```

### Exemplo: Usando `toString()` para detectar a classe do objeto

`toString()` pode ser usado com qualquer objeto e permite que você determine sua classe. Para usar `Object.prototype.toString()` com qualquer objeto, deverá chamar `Function.prototype.call()` ou `Function.prototype.apply()` nele, passando o objeto que quer inspecionar como o primeiro parâmetro, chamado `thisArg`.

```js
var toString = Object.prototype.toString;

toString.call(new Date()); // [object Date]
toString.call(new String()); // [object String]
toString.call(Math); // [object Math]

// Since JavaScript 1.8.5
toString.call(undefined); // [object Undefined]
toString.call(null); // [object Null]
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.tostring |

Compatibilidade
---------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.prototype.toSource()`
* `Object.prototype.valueOf()`


Object.freeze() - JavaScript

Object.freeze()
===============

O método **`Object.freeze()`** congela um objeto: isto é, impede que novas propriedades sejam adicionadas a ele; impede que as propriedades existentes sejam removidas; e impede que propriedades existentes, ou sua inumerabilidade, configurabilidade, ou capacidade de escrita sejam alteradas. Em essência o objeto é efetivamente imutável. O método retorna o objeto congelado.

Sintaxe
-------
```

Object.freeze(obj)
```

### Parâmetros

`obj`

O objeto a ser congelado.

### Valor de retorno

O objeto congelado.

Descrição
---------

Nada pode ser adicionado ou removido do conjunto de propriedades de um objeto congelado. Qualquer tentativa de fazê-lo irá falhar, ou silenciosamente ou através de um `TypeError` exception (mais frequentemente, mas não exclusivamente, quando em strict mode).

Valores não podem ser alterados para propriedades de dados. As propriedades do Accessor (getters e setters) funcionam da mesma forma (e ainda dão a ilusão de que você está alterando o valor). Observe que valores que são objetos ainda podem ser modificados, a menos que eles também sejam congelados.

Exemplos
--------

```js
var obj = {
  prop: function () {},
  foo: "bar",
};

// Novas propriedades podem ser adicionadas, propriedades existentes podem ser alteradas ou removidas
obj.foo = "baz";
obj.lumpy = "woof";
delete obj.prop;

// Tanto o objeto que está sendo passado, bem como o objeto retornado será congelado.
// É desnecessário salvar o objeto retornado para congelar o objeto original.
var o = Object.freeze(obj);

o === obj; // true
Object.isFrozen(obj); // === true

// De agora em diante qualquer alteração irá falhar
obj.foo = "quux"; // silenciosamente não faz nada.
obj.quaxxor = "the friendly duck"; // silenciosamente não adiciona a propriedade

// ...e em modo strict tais tentativas irão lançar TypeErrors
function fail() {
  "use strict";
  obj.foo = "sparky"; // throws um TypeError
  delete obj.quaxxor; // throws um TypeError
  obj.sparky = "arf"; // throws um TypeError
}

fail();

// As tentativas de alteração através de Object.defineProperty também irão lançar
Object.defineProperty(obj, "ohai", { value: 17 }); // throws um TypeError
Object.defineProperty(obj, "foo", { value: "eit" }); // throws um TypeError
```

O exemplo a seguir mostra que valores do tipo objeto, em um objeto congelado, podem ser alterados (freeze é raso).

```js
obj1 = {
  internal: {},
};

Object.freeze(obj1);
obj1.internal.a = "aValue";

obj1.internal.a; // 'aValue'

// Para fazer um obj completamente imutável, congele cada objeto em obj.
// Para fazer isso, nós usamos essa função.
function deepFreeze(obj) {
  // Recuperar os nomes de propriedade definidos em obj
  var propNames = Object.getOwnPropertyNames(obj);

  // Congelar as propriedades antes de congelar-se
  propNames.forEach(function (name) {
    var prop = obj[name];

    // Congele prop se for um objeto
    if (typeof prop == "object" && prop !== null) deepFreeze(prop);
  });

  // Congele-se (não faz nada se já estiver congelado)
  return Object.freeze(obj);
}

obj2 = {
  internal: {},
};

deepFreeze(obj2);
obj2.internal.a = "anotherValue";
obj2.internal.a; // undefined
```

Notas
-----

Em ES5, se um argumento para este método não for um objeto (um primitivo), então isso irá causar um `TypeError`. Em ES6, um argumento não-objeto vai ser tratado como se fosse um objeto comum congelado e simplesmente retornado.

```js
> Object.freeze(1)
TypeError: 1 is not an object // ES5 code

> Object.freeze(1)
1                             // ES6 code
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.freeze |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver também
----------

* `Object.isFrozen()`
* `Object.preventExtensions()`
* `Object.isExtensible()`
* `Object.seal()`
* `Object.isSealed()`


Object.prototype.constructor - JavaScript

Object.prototype.constructor
============================

Sumário
-------

Retorna uma referência para a função `Object` que cria a instância do protótipo. Note que o valor desse protótipo é uma referência para a própria função, não uma string contendo o nome da função. O valor é apenas *read-only* para valores primitivos como `1`, `true` e `"test"`.

Descrição
---------

Todos os objetos herdam a propriedade *construtor* de seu protótipo:

```js
var o = {};
o.constructor === Object; // true

var a = [];
a.constructor === Array; // true

var n = new Number(3);
n.constructor === Number; // true
```

Exemplos
--------

### Exemplo: Apresentando o construtor de um objeto

O exemplo a seguir cria um protótipo, `Tree`, e um objeto desse tipo, `theTree`. O exemplo, então, apresenta a propriedade *constructor* do objeto `theTree`.

```js
function Tree(name) {
  this.name = name;
}

var theTree = new Tree("Redwood");
console.log("theTree.constructor is " + theTree.constructor);
```

Esse exemplo apresenta a seguinte saída:

```js
theTree.constructor is function Tree(name) {
  this.name = name;
}
```

### Exemplo: Mudando o construtor de um objeto

O exemplo a seguir apresenta como modificar o valor do construtor de um objeto genérico. Apenas `true`, `1` e `"test"` não serão afetados sendo que eles tem `construtores` *read-only* nativos. Esse exemplo apresenta que nem sempre é seguro depender da propriedade `constructor` de um objeto.

```js
function Type() {}

var types = [
  new Array(),
  [],
  new Boolean(),
  true, // remains unchanged
  new Date(),
  new Error(),
  new Function(),
  function () {},
  Math,
  new Number(),
  1, // remains unchanged
  new Object(),
  {},
  new RegExp(),
  /(?:)/,
  new String(),
  "test", // remains unchanged
];

for (var i = 0; i < types.length; i++) {
  types[i].constructor = Type;
  types[i] = [
    types[i].constructor,
    types[i] instanceof Type,
    types[i].toString(),
  ];
}

console.log(types.join("\n"));
```

Esse exemplo apresenta a seguinte saída:

```js
function Type() {},false,
function Type() {},false,
function Type() {},false,false
function Boolean() {
    [native code]
},false,true
function Type() {},false,Mon Sep 01 2014 16:03:49 GMT+0600
function Type() {},false,Error
function Type() {},false,function anonymous() {

}
function Type() {},false,function () {}
function Type() {},false,[object Math]
function Type() {},false,0
function Number() {
    [native code]
},false,1
function Type() {},false,[object Object]
function Type() {},false,[object Object]
function Type() {},false,/(?:)/
function Type() {},false,/(?:)/
function Type() {},false,
function String() {
    [native code]
},false,test
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.constructor |

Compatibilidade de Browser
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.


Object.prototype.__defineGetter__() - JavaScript

Object.prototype.\_\_defineGetter\_\_()
=======================================

**Aviso:** Esta característica está descontinuada em favor de definindo getters usando a sintaxe de inicialização de objetoou a API `Object.defineProperty()`. Enquanto esta característica é amplamente implementada, ela está somente descrita na especificação ECMAScript por causa do uso legado. Este método não deveria ser usado desde que exista existam melhores alternativas.

O método **`__defineGetter__`** conecta uma propriedade do objeto à uma função para ser chamada quando isso é consultado.

Sintaxe
-------
```

obj.__defineGetter__(prop, func)
```

### Parâmetros

`prop`

Uma string contendo o nome da propriedade para conectar a função dada.

`func`

Uma função para ser ligada a uma consulta da propriedade especificada.

### Valor de Retorno

`undefined`.

Descrição
---------

O `__defineGetter__` permite um getter (en-US) ser definido sobre um objeto preexistente.

Exemplos
--------

```js
// Forma não-padrão e depreciada

var o = {};
o.\_\_defineGetter\_\_("gimmeFive", function () {
  return 5;
});
console.log(o.gimmeFive); // 5

// Formas padrão-compatível

// Usando o operador get
var o = {
  get gimmeFive() {
    return 5;
  },
};
console.log(o.gimmeFive); // 5

// Usando Object.defineProperty
var o = {};
Object.defineProperty(o, "gimmeFive", {
  get: function () {
    return 5;
  },
});
console.log(o.gimmeFive); // 5
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.\_\_defineGetter\_\_ |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.prototype.__defineSetter__()`
* `get` (en-US) operator
* `Object.defineProperty()`
* `Object.prototype.__lookupGetter__()`
* `Object.prototype.__lookupSetter__()`
* Guia JS: Definindo Getters e Setters
* [Blog Post] Depreciação de \_\_defineGetter\_\_ e \_\_defineSetter\_\_
* Erro do Firefox 647423


Object.getOwnPropertyNames() - JavaScript

Object.getOwnPropertyNames()
============================

O método **`Object.getOwnPropertyNames()`** retorna um vetor com todas as propriedades (enumeráveis ou não) encontradas diretamente em um dado objeto.

Sintaxe
-------
```

Object.getOwnPropertyNames(obj)
```

### Parâmetros

`obj`

O objeto, cujas suas próprias propriedades, enumeráveis ou não, serão retornadas.

Descrição
---------

`Object.getOwnPropertyNames()` retorna um vetor cujos elementos são strings correspondentes as propriedades enumeráveis ou não, encontradas em `obj`. A ordem das propriedades enumeráveis no vetor é consistente com a ordenação exposta por um laço `for...in` (ou por `Object.keys()`) nas propriedades do objeto. A ordenação das propriedades não-enumeráveis no vetor, e entre as propriedades enumeráveis, não está definida.

Exemplos
--------

### Usando `Object.getOwnPropertyNames()`

```js
var arr = ["a", "b", "c"];
console.log(Object.getOwnPropertyNames(arr).sort());
// logs ["0", "1", "2", "length"]

// Array-like object
var obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.getOwnPropertyNames(obj).sort());
// logs ["0", "1", "2"]

// Logging property names and values using Array.forEach
Object.getOwnPropertyNames(obj).forEach(function (val, idx, array) {
  console.log(val + " -> " + obj[val]);
});
// logs
// 0 -> a
// 1 -> b
// 2 -> c

// non-enumerable property
var my_obj = Object.create(
  {},
  {
    getFoo: {
      value: function () {
        return this.foo;
      },
      enumerable: false,
    },
  },
);
my_obj.foo = 1;

console.log(Object.getOwnPropertyNames(my_obj).sort());
// logs ["foo", "getFoo"]
```

Se voce quer somente as propriedades enumeráveis, veja `Object.keys()` ou use um laço `for...in` (contudo, note que isto irá retornar propriedades enumeráveis não encontradas diretamente naquele objeto, mas também junto com a cadeia prototype do objeto a menos que o último seja filtrado com `hasOwnProperty()`).

Ítens na cadeia prototype não são listados:

```js
function ParentClass() {}
ParentClass.prototype.inheritedMethod = function () {};

function ChildClass() {
  this.prop = 5;
  this.method = function () {};
}
ChildClass.prototype = new ParentClass();
ChildClass.prototype.prototypeMethod = function () {};

console.log(
  Object.getOwnPropertyNames(
    new ChildClass(), // ["prop", "method"]
  ),
);
```

### Obtenha somente não-enumeráveis

Isto usa a função `Array.prototype.filter()` para remover as chaves enumeráveis (obtidas com `Object.keys()`) de uma lista com todas as chaves (obtidas com `Object.getOwnPropertyNames()`) deixando somente as chaves não-enumeráveis.

```js
var target = myObject;
var enum_and_nonenum = Object.getOwnPropertyNames(target);
var enum_only = Object.keys(target);
var nonenum_only = enum_and_nonenum.filter(function (key) {
  var indexInEnum = enum_only.indexOf(key);
  if (indexInEnum == -1) {
    // not found in enum\_only keys mean the key is non-enumerable,
    // so return true so we keep this in the filter
    return true;
  } else {
    return false;
  }
});

console.log(nonenum_only);
```

Notas
-----

No ES5, se o argumento desse método não é um objeto (um tipo primitivo), então isso causará um `TypeError`. No ES6, um argumento diferente de objeto será transformado em um objeto.

```js
Object.getOwnPropertyNames("foo");
// TypeError: "foo" is not an object (ES5 code)

Object.getOwnPropertyNames("foo");
// ["0", "1", "2", "length"] (ES6 code)
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.getownpropertynames |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Notas específicas para SpiderMonkey
-----------------------------------

Antes do SpiderMonkey 28, `Object.getOwnPropertyNames` não via propriedades não resolvidas de objetos `Error`. Isto foi resolvido em versões posteriores (Erro do Firefox 724768).

Veja também
-----------

* Enumerabilidade e posse de propriedades (en-US)
* `Object.prototype.hasOwnProperty()`
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.keys()`
* `Array.forEach()`


Object.prototype.valueOf() - JavaScript

Object.prototype.valueOf()
==========================

O método **`valueOf()`** retorna o valor primitivo do objeto especificado.

Experimente
-----------

Sintaxe
-------
```

object.valueOf()
```

### Valor retornado

O valor primitivo do objeto especificado.

Descrição
---------

JavaScript chama o método `valueOf` para converter um objeto em um valor primitivo. Você raramente precisará chamar o método `valueOf` por ele mesmo; O JavaScript chamará ele automaticamente quando encontrar um objeto onde um valor primitivo for esperado.

Por padrão, o método `valueOf` é herdado por cada objeto descendente de `Object`. Todo núcleo embutido do objeto sobrescreve esse método para retornar um valor apropriado. Se um objeto não tem um valor primitivo, `valueOf` retorna o próprio objeto.

Você pode usar `valueOf` dentro do seu próprio código para converter um objeto embutido, em um valor primitivo. Quando você criar um objeto customizado, você pode sobrescrever `Object.prototype.valueOf()` para chamar um método customizado ao invés do método padrão `Object`.

### Sobrescrevendo `valueOf` para objetos customizados

Você pode criar uma função para ser chamada no lougar do método padrão `valueOf`. Sua função não pode ter nenhum argumento.

Suponha que você tem um tipo de objeto `MyNumberType` e você quer criar um método `valueOf` para ele. O código a seguir atribui uma função definida por usuário para o método `valueOf` desse objeto:

```js
MyNumberType.prototype.valueOf = function () {
  return customPrimitiveValue;
};
```

Com o código anterior no lugar, a qualquer hora um objeto do tipo `MyNumberType` é usado em um contexto onde deve ser representado como um valor primitivo, o JavaScript chama automaticamente a função definida no código anterior.

Um método `valueOf` de um objeto é geralmente chamado pelo JavaScript, mas você pode chamá-lo se quiser da seguinte maneira:

```js
myNumberType.valueOf();
```

**Nota:** Objetos em contexto de string convertidos através do método `toString()`, o que é diferente de objetos `String` convertendo para string primiriva utlizando `valueOf`. Todos os objetos têm uma conversão string, somente se "`[object type]`". Mas muitos objetos não convertem para number, boolean, or function.

Exemplos
--------

### Usando `valueOf`

```js
function MyNumberType(n) {
  this.number = n;
}

MyNumberType.prototype.valueOf = function () {
  return this.number;
};

var myObj = new MyNumberType(4);
myObj + 3; // 7
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.valueof |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.prototype.toString()`
* `parseInt()`
* `Symbol.toPrimitive`


Object.isFrozen() - JavaScript

Object.isFrozen()
=================

O método **`Object.isFrozen()`** determina se um objeto está frozen.

Experimente
-----------

Sintaxe
-------
```

Object.isFrozen(obj)
```

### Parameters

`obj`

O objeto que será verificado.

### Return value

Um valor `Boolean` indicando se o objeto está frozen.

Descrição
---------

Um objeto estará frozen se, e apenas se, ele não for extensible, todas as suas propriedades não são configuráveis e todas suas propriedades de dados (propriedades que não são asessores de propriedades com getters ou setters) não podem ser modificadas.

Examples
--------

```js
// Um novo objeto é extensível, então ele não está frozen.
Object.isFrozen({}); // === false

// Um objeto vazio que não é extensível
// é vagamente frozen.
var vacuouslyFrozen = Object.preventExtensions({});
Object.isFrozen(vacuouslyFrozen); // === true

// Um novo objeto com uma propriedade também é extensível,
// portanto não está frozen.
var oneProp = { p: 42 };
Object.isFrozen(oneProp); // === false

// Impedir extensões do objeto ainda
// não o torna frozen, pois a propriedade ainda será
// configurável (e modificável).
Object.preventExtensions(oneProp);
Object.isFrozen(oneProp); // === false

// ...Porém, deletando a propriedade o objeto se tornará
// vagamente frozen.
delete oneProp.p;
Object.isFrozen(oneProp); // === true

// Um objeto não extensível e não modificável,
// mas com uma propriedade configurável não será frozen.
var nonWritable = { e: "plep" };
Object.preventExtensions(nonWritable);
Object.defineProperty(nonWritable, "e", {
  writable: false,
}); // tornar não modificável
Object.isFrozen(nonWritable); // === false

// Alterando a propriedade para não configurável
// tornará o objeto frozen.
Object.defineProperty(nonWritable, "e", {
  configurable: false,
}); // make non-configurable
Object.isFrozen(nonWritable); // === true

// Um objeto não extensível com uma propriedade não configurável
// mas modificável não será frozen.
var nonConfigurable = { release: "the kraken!" };
Object.preventExtensions(nonConfigurable);
Object.defineProperty(nonConfigurable, "release", {
  configurable: false,
});
Object.isFrozen(nonConfigurable); // === false

// Alterando a propriedade para não modificável
// tornará o objeto frozen.
Object.defineProperty(nonConfigurable, "release", {
  writable: false,
});
Object.isFrozen(nonConfigurable); // === true

// Um objeto não extensível com um assessor de propriedade
// configurável não será frozen.
var accessor = {
  get food() {
    return "yum";
  },
};
Object.preventExtensions(accessor);
Object.isFrozen(accessor); // === false

// ...Mas alterando essa propriedade para não configurável
// o objeto se tornará frozen.
Object.defineProperty(accessor, "food", {
  configurable: false,
});
Object.isFrozen(accessor); // === true

// A forma mais fácil para um objeto ser frozen
// é se o método Object.freeze foi usado nele.
var frozen = { 1: 81 };
Object.isFrozen(frozen); // === false
Object.freeze(frozen);
Object.isFrozen(frozen); // === true

// Por definição, um objeto frozen não é extensível.
Object.isExtensible(frozen); // === false

// Também por definição, um objeto frozen estará sealed.
Object.isSealed(frozen); // === true
```

Notas
-----

No ES5, se o argumento deste método não for um objeot (uma primitiva), ele irá lançar um `TypeError`. No ES2015, um argumento que não é objeto será sempre tratado como se fosse um objeto frozen, simplesmente retornando `true`.

```js
Object.isFrozen(1);
// TypeError: 1 is not an object (ES5 code)

Object.isFrozen(1);
// true (ES2015 code)
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.isfrozen |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.freeze()`
* `Object.preventExtensions()`
* `Object.isExtensible()`
* `Object.seal()`
* `Object.isSealed()`


Object.defineProperties() - JavaScript

Object.defineProperties()
=========================

O método **`Object.defineProperties()`** define uma nova propriedade ou modifica uma existente no objeto, retornando o objeto.

Sintaxe
-------
```

Object.defineProperties(obj, props)
```

### Parâmetros

`obj`

O objeto no qual se cria ou modifica suas propriedades.

`props`

Um objeto do qual propriedades enumeráveis constitui descritores para as propriedades serem definidas ou modificadas. Descritores de propriedade presente nos objetos provém em dois principais tipos: descritores de dados e de acesso (veja `Object.defineProperty()` para mais detalhes). Descritores têm as seguintes chaves:

`configurable`

`true` se e somente se o tipo deste descritor de propriedades pode ser modificada e se a propriedade pode ser apagada do objeto correspondente.
 **Valor padrão é `false`.**

`enumerable`

`true` se e somente se este propriedade aparece durante enumeração das propriedade sobre o objeto correspondente.
 **Valor padrão é `false`.**

`value`

 O valor associado com a propriedade. Pode ser qualquer valor válido em JavaScript value (número, objeto, função, etc).
 **Valor padrão é `undefined`.**

`writable`

`true` se e somente se o valor associado com a propriedade pode ser modificada com um assignment operator (en-US).
 **Valor padrão é `false`.**

`get`

 Uma função a qual serve com um getter para a propriedade, ou `undefined` se não existe getter. A retorno da função será usado como o valor da propriedade.
 **Valor padrão é `undefined`.**

`set`

 Uma função a qual server com um setter para a propriedade, ou `undefined` se não existe setter. A função receberá como argumento somente o novo valor sendo atribuído à propriedade.
 **Valor padrão é `undefined`.**

### Valor de retorno

O objeto que foi passado para a função.

Descrição
---------

`Object.defineProperties`, em essência, define todas as propriedades correspondentes para as propriedades próprias enumeráveis de `props` sobre o objeto `obj`.

Exemplo
-------

```js
var obj = {};
Object.defineProperties(obj, {
  property1: {
    value: true,
    writable: true,
  },
  property2: {
    value: "Hello",
    writable: false,
  },
  // etc. etc.
});
```

Polyfill
--------

Assumindo uma execução intocada com todos os nomes e propriedades referindo para seus valores iniciais, `Object.defineProperties` é quase completamente equivalente (note o comentário em `isCallable`) para a seguinte reimplementação em JavaScript:

```js
function defineProperties(obj, properties) {
  function convertToDescriptor(desc) {
    function hasProperty(obj, prop) {
      return Object.prototype.hasOwnProperty.call(obj, prop);
    }

    function isCallable(v) {
      // NB: modify as necessary if other values than functions are callable.
      return typeof v === "function";
    }

    if (typeof desc !== "object" || desc === null)
      throw new TypeError("bad desc");

    var d = {};

    if (hasProperty(desc, "enumerable")) d.enumerable = !!desc.enumerable;
    if (hasProperty(desc, "configurable")) d.configurable = !!desc.configurable;
    if (hasProperty(desc, "value")) d.value = desc.value;
    if (hasProperty(desc, "writable")) d.writable = !!desc.writable;
    if (hasProperty(desc, "get")) {
      var g = desc.get;

      if (!isCallable(g) && typeof g !== "undefined")
        throw new TypeError("bad get");
      d.get = g;
    }
    if (hasProperty(desc, "set")) {
      var s = desc.set;
      if (!isCallable(s) && typeof s !== "undefined")
        throw new TypeError("bad set");
      d.set = s;
    }

    if (("get" in d || "set" in d) && ("value" in d || "writable" in d))
      throw new TypeError("identity-confused descriptor");

    return d;
  }

  if (typeof obj !== "object" || obj === null) throw new TypeError("bad obj");

  properties = Object(properties);

  var keys = Object.keys(properties);
  var descs = [];

  for (var i = 0; i < keys.length; i++)
    descs.push([keys[i], convertToDescriptor(properties[keys[i]])]);

  for (var i = 0; i < descs.length; i++)
    Object.defineProperty(obj, descs[i][0], descs[i][1]);

  return obj;
}
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.defineproperties |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.defineProperty()`
* `Object.keys()`
* Enumerabilidade e direito de propriedades (en-US)


Object.getOwnPropertyDescriptor() - JavaScript

Object.getOwnPropertyDescriptor()
=================================

O método **`Object.getOwnPropertyDescriptor()`** retorna um descritor de propriedades para uma propriedade (isto é, uma diretamente presente, e não pertencente ao objeto por força da cadeia de protótipo do objeto) de um dado objeto.

Sintaxe
-------
```

Object.getOwnPropertyDescriptor(obj, prop)
```

### Parâmetros

`obj`

O objeto no qual deve-se procurar pela propriedade.

`prop`

O nome da propriedade cuja descrição é para ser retornada.

### Valor de Retorno

Um descritor de propriedades da propriedade especificada, se esta existir no objeto, ou `undefined`, caso contrário.

Descrição
---------

Este método permite uma análise da descrição precisa de uma propriedade. Uma propriedade em Javascript consiste de um nome com formato *texto-valor* e um descritor de propriedades. Mais informações sobre os tipos de descritores de propriedades e seus atributos podem ser encontrados em `Object.defineProperty()`.

Um descritor de propriedade é um registro com alguns dos seguintes atributos:

`value`

o valor associado com a propriedade (somente para descritores de dados).

**`writable`**

`true` se, e somente se, o valor associado com a propriedade pode ser alterado (somente para descritores de dados).

`get`

Uma função que serve como um *getter*, para obter o valor da propriedade, ou `undefined` se não houver (somente para descritores de acesso).

`set`

Uma função que serve como um s*etter*, para atribuir um valor à propriedade, ou `undefined` se não houver (somente para descritores de acesso).

`configurable`

`true` se, e somente se, o tipo deste descritor de propriedade pode ser alterado e se a propriedade pode ser excluída do objeto correspondente.

`enumerable`

`true` se, e somente se, esta propriedade aparece durante a enumeração das propriedades do objeto correspondente.

Exemplos
--------

```js
var o, d;

o = {
  get foo() {
    return 17;
  },
};
d = Object.getOwnPropertyDescriptor(o, "foo");
// d é { configurable: true, enumerable: true, get: /\*A função getter\*/, set: undefined }

o = { bar: 42 };
d = Object.getOwnPropertyDescriptor(o, "bar");
// d é { configurable: true, enumerable: true, value: 42, writable: true }

o = {};
Object.defineProperty(o, "baz", {
  value: 8675309,
  writable: false,
  enumerable: false,
});
d = Object.getOwnPropertyDescriptor(o, "baz");
// d é { value: 8675309, writable: false, enumerable: false, configurable: false }
```

Notas
-----

No ES5, o primeiro parâmetro deste método não é um objeto (tipo primitivo), então ele irá gerar um `TypeError`. No ES6, um primeiro argumento não-objeto será primeiramente convertido para objeto.

```js
Object.getOwnPropertyDescriptor("foo", 0);
// TypeError: "foo" is not an object // Código ES5

Object.getOwnPropertyDescriptor("foo", 0);
// {configurable:false, enumerable:true, value:"f", writable:false} // Código ES6
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.getownpropertydescriptor |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja Também
-----------

* `Object.defineProperty()`
* `Reflect.getOwnPropertyDescriptor()` (en-US)


Object.keys() - JavaScript

Object.keys()
=============

O método **`Object.keys()`** retorna um array de propriedades enumeraveis de um determinado objeto, na mesma ordem em que é fornecida por um laço `for...in` (a diferença é que um laço for-in enumera propriedades que estejam na cadeia de protótipos).

Sintaxe
-------
```

Object.keys(obj)
```

### Parametros

`obj`

O objeto cujas propriedades são enumeráveis.

Descrição
---------

`Object.keys()` retorna um array cujo os elementos são strings correspondentes para a propriedade enumerável encontrada diretamento sobre o objeto. A ordenação das propriedades é a mesma que a dada pelo loop sobre as propriedades do objeto manualmente.

Exemplos
--------

```js
var arr = ["a", "b", "c"];
console.log(Object.keys(arr)); // console: ['0', '1', '2']

// array com objeto
var obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.keys(obj)); // console: ['0', '1', '2']

// array como objeto com ordenação aleatória por chave
var an_obj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.keys(an_obj)); // console: ['2', '7', '100']

// getFoo é uma propriedade que não é enumerável
var my_obj = Object.create(
  {},
  {
    getFoo: {
      value: function () {
        return this.foo;
      },
    },
  },
);
my_obj.foo = 1;

console.log(Object.keys(my_obj)); // console: ['foo']
```

Se você quiser todas as propriedades, mesmo que não enumeráveis, consulte:`Object.getOwnPropertyNames()`.

Notas
-----

Em ES5, Se o argumento para o método this não é um objeto(um primitivo), em seguida ele irá causar um `TypeError`. Em ES2015, um argumento não-objeto será forçado a um objeto.

```js
Object.keys("foo");
// TypeError: "foo" is not an object (ES5 code)

Object.keys("foo");
// ["0", "1", "2"] (ES2015 code)
```

Polyfill
--------

Para adicionar suporte Object.keys compatíveis em ambientes mais antigos que não têm suporte nativo para isso, copie o seguinte trecho:

```js
// De https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/Object/keys
if (!Object.keys) {
  Object.keys = (function () {
    "use strict";
    var hasOwnProperty = Object.prototype.hasOwnProperty,
      hasDontEnumBug = !{ toString: null }.propertyIsEnumerable("toString"),
      dontEnums = [
        "toString",
        "toLocaleString",
        "valueOf",
        "hasOwnProperty",
        "isPrototypeOf",
        "propertyIsEnumerable",
        "constructor",
      ],
      dontEnumsLength = dontEnums.length;

    return function (obj) {
      if (
        typeof obj !== "object" &&
        (typeof obj !== "function" || obj === null)
      ) {
        throw new TypeError("Object.keys chamado de non-object");
      }

      var result = [],
        prop,
        i;

      for (prop in obj) {
        if (hasOwnProperty.call(obj, prop)) {
          result.push(prop);
        }
      }

      if (hasDontEnumBug) {
        for (i = 0; i < dontEnumsLength; i++) {
          if (hasOwnProperty.call(obj, dontEnums[i])) {
            result.push(dontEnums[i]);
          }
        }
      }
      return result;
    };
  })();
}
```

Por favor, note que o código acima inclui chaves não-enumeráveis no IE7 (e talvez IE8), ao passar em um objeto a partir de uma janela diferente.

Para um simples Browser Polyfill, veja Javascript - Object.keys Browser Compatibility.

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.keys |

Browser compatibilidade
-----------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* Enumerability and ownership of properties (en-US)
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.getOwnPropertyNames()`


Object.is() - JavaScript

Object.is()
===========

O método **`Object.is()`** determina se dois valores correspondem ao mesmo valor.

Sintaxe
-------
```

Object.is(value1, value2);
```

### Parâmetros

`value1`

O primeiro valor a ser comparado.

`value2`

O segundo valor a ser comparado.

### Return value

Um `Boolean` indicando se os dois argumentos possuem o mesmo valor ou não.

Descrição
---------

`Object.is()` determina se dois valores correspondem ao mesmo valor. Dois valores correspondem ao mesmo valor se uma das seguintes condições for verdadeira:

* ambos são `undefined`
* ambos são `null`
* ambos são `true` ou ambos são `false`
* ambos são strings do mesmo comprimento, com os mesmos caracteres
* ambos são o mesmo objeto
* ambos são numéricos e
    + ambos são `+0`
    + ambos são `-0`
    + ambos são `NaN`
    + ou ambos são não-zero e ambos são não `NaN` e ambos correspondem ao mesmo valor

Isso *não é* o mesmo que ser igual de acordo com o operador `==` (en-US). O operador `==` (en-US) aplica diversas coerções para ambos os lados (se eles não correspondem ao mesmo Tipo) antes de testar a igualdade (resultando em comportamentos como a comparação `"" == false` retornar `true`), enquanto `Object.is` não realiza a coerção de nenhum dos valores.

Isso também *não* *é* o mesmo que ser igual de acordo com o operador `===` (en-US). O operador `===` (en-US) (assim como o operador `==` (en-US)) trata os valores numéricos `-0` e `+0` como iguais e trata `Number.NaN` como não igual a `NaN`.

Exemplos
--------

```js
Object.is("foo", "foo"); // true
Object.is(window, window); // true

Object.is("foo", "bar"); // false
Object.is([], []); // false

var test = { a: 1 };
Object.is(test, test); // true

Object.is(null, null); // true

// Casos especiais
Object.is(0, -0); // false
Object.is(-0, -0); // true
Object.is(NaN, 0 / 0); // true
```

Polyfill para navegadores que não suportam ES6
----------------------------------------------

`Object.is()` é uma adição proposta ao padrão ECMA-262; e como tal, pode não estar presente em todos os navegadores. Você pode contornar essa situação por meio da adição do seguinte código no começo de seus scripts. Isso permitirá a você utilizar `Object.is()`, mesmo quando não houver suporte por parte do navegador.

```js
if (!Object.is) {
  Object.is = function (x, y) {
    // Algoritmo para verificar se os valores sao iguais
    if (x === y) {
      // Passos 1-5, 7-10
      // Passos 6.b-6.e: +0 != -0
      return x !== 0 || 1 / x === 1 / y;
    } else {
      // Passo 6.a: NaN == NaN
      return x !== x && y !== y;
    }
  };
}
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.is |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* Comparações de igualdade — uma comparação dos três recursos implementados para verificação de igualdade.


Object.assign() - JavaScript

Object.assign()
===============

O método **`Object.assign()`** é usado para copiar os valores de todas as propriedades próprias enumeráveis de um ou mais objetos *de origem* para um objeto *destino*. Este método irá retornar o objeto *destino*.

Experimente
-----------

Sintaxe
-------
```

Object.assign(destino, ...origens)
```

### Parâmetros

`destino`

O objeto *destino*.

`origens`

Um ou mais objetos de *origem*.

### Valor retornado

O objeto *destino* será retornado.

Descrição
---------

O método `Object.assign()` copia apenas propriedades *enumeráveis* e *próprias* de um objeto *de origem* para um objeto destino. Ele usa `[[Get]]` na origem e `[[Put]]` no *destino*, então isto irá invocar *getters* e *setters*.

Portanto, ele *atribui* propriedades, em vez de simplesmente copiar ou definir novas propriedades. Isso pode fazê-lo impróprio para combinar novas propriedades com um *prototype* se os objetos *de origem* contiverem getters. Para copiar definições de propriedades, incluindo sua enumerabilidade, para *prototypes* `Object.getOwnPropertyDescriptor()` e `Object.defineProperty()` devem ser utilizadas no lugar.

Ambas as propriedades `String` e `Symbol` são copiadas.

No caso de erro, por exemplo, se uma propriedade não é *writable*, um `TypeError` será lançado e o objeto *destino* permanecerá inalterado. Note que `Object.assign()` não lança erros caso algum argumento *source* seja `null` ou `undefined`.

Exemplos
--------

### Clonando um objeto

```js
var obj = { a: 1 };
var copy = Object.assign({}, obj);
console.log(copy); // { a: 1 }
```

### Mesclando objetos

```js
var o1 = { a: 1 };
var o2 = { b: 2 };
var o3 = { c: 3 };

var obj = Object.assign(o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }
console.log(o1); // { a: 1, b: 2, c: 3 }, target object itself is changed.
```

### Copiando propriedades Symbol

```js
var o1 = { a: 1 };
var o2 = { [Symbol("foo")]: 2 };

var obj = Object.assign({}, o1, o2);
console.log(obj); // { a: 1, [Symbol("foo")]: 2 }
```

### Propriedades herdadas e não enumeráveis não podem ser copiadas

```js
var obj = Object.create(
  { foo: 1 },
  {
    // foo is an inherit property.
    bar: {
      value: 2, // bar is a non-enumerable property.
    },
    baz: {
      value: 3,
      enumerable: true, // baz is an own enumerable property.
    },
  },
);

var copy = Object.assign({}, obj);
console.log(copy); // { baz: 3 }
```

### Primitivas serão encapsuladas em objetos

```js
var v1 = "123";
var v2 = true;
var v3 = 10;
var v4 = Symbol("foo");

var obj = Object.assign({}, v1, null, v2, undefined, v3, v4);
// Primitives will be wrapped, null and undefined will be ignored.
// Note, only string wrappers can have own enumerable properties.
console.log(obj); // { "0": "1", "1": "2", "2": "3" }
```

### Exceções irão interromper a tarefa de cópia em execução

```js
var target = Object.defineProperty({}, "foo", {
  value: 1,
  writeable: false,
}); // target.foo is a read-only property

Object.assign(target, { bar: 2 }, { foo2: 3, foo: 3, foo3: 3 }, { baz: 4 });
// TypeError: "foo" is read-only
// The Exception is thrown when assigning target.foo

console.log(target.bar); // 2, the first source was copied successfully.
console.log(target.foo2); // 3, the first property of the second source was copied successfully.
console.log(target.foo); // 1, exception is thrown here.
console.log(target.foo3); // undefined, assign method has finished, foo3 will not be copied.
console.log(target.baz); // undefined, the third source will not be copied either.
```

### Copiando acessores

```js
var obj = {
  foo: 1,
  get bar() {
    return 2;
  },
};

var copy = Object.assign({}, obj);
console.log(copy);
// { foo: 1, bar: 2 }, the value of copy.bar is obj.bar's getter's return value.

// This is an assign function which can copy accessors.
function myAssign(target, ...sources) {
  sources.forEach((source) => {
    Object.defineProperties(
      target,
      Object.keys(source).reduce((descriptors, key) => {
        descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
        return descriptors;
      }, {}),
    );
  });
  return target;
}

var copy = myAssign({}, obj);
console.log(copy);
// { foo:1, get bar() { return 2 } }
```

Polyfill
--------

Este polyfill não suporta propriedades `Symbol`, visto que ES5 não possui símbolos:

```js
if (!Object.assign) {
  Object.defineProperty(Object, "assign", {
    enumerable: false,
    configurable: true,
    writable: true,
    value: function (target) {
      "use strict";
      if (target === undefined || target === null) {
        throw new TypeError("Cannot convert first argument to object");
      }

      var to = Object(target);
      for (var i = 1; i < arguments.length; i++) {
        var nextSource = arguments[i];
        if (nextSource === undefined || nextSource === null) {
          continue;
        }
        nextSource = Object(nextSource);

        var keysArray = Object.keys(Object(nextSource));
        for (
          var nextIndex = 0, len = keysArray.length;
          nextIndex < len;
          nextIndex++
        ) {
          var nextKey = keysArray[nextIndex];
          var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
          if (desc !== undefined && desc.enumerable) {
            to[nextKey] = nextSource[nextKey];
          }
        }
      }
      return to;
    },
  });
}
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.assign |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.defineProperties()`
* Enumerabilidade e posse de propriedades


Object.isSealed() - JavaScript

Object.isSealed()
=================

O método **`Object.isSealed()`** determina se um objeto está selado.

Experimente
-----------

Sintaxe
-------
```

Object.isSealed(obj)
```

### Parâmetros

`obj`

O objeto que deverá ser verificado.

### Valor retornado

Um `Boolean` indicando se o objeto fornecido está ou não selado.

Descrição
---------

Retorna `true` se o objeto está selado, senão `false`. Um objeto está selado se ele for "não extensible" e se todas as suas propriedades estão como "não configuráveis" e assim sendo "não removíveis" (mas não necessariamente "não escrevíveis").

Exemplos
--------

```js
// Objetos não são selados por padrão.
var empty = {};
Object.isSealed(empty); // === false

// Se você fizer um objeto não extensível vazio,
// ele estará vagamente selado.
Object.preventExtensions(empty);
Object.isSealed(empty); // === true

// O mesmo não é verdadeiro em um objeto "não vazio",
// a não ser que todas as suas propriedades sejam "não configuráveis".
var hasProp = { fee: "fie foe fum" };
Object.preventExtensions(hasProp);
Object.isSealed(hasProp); // === false

// Mas torne-os todos "não configuráveis"
// e o objeto se tornará selado.
Object.defineProperty(hasProp, "fee", {
  configurable: false,
});
Object.isSealed(hasProp); // === true

// O jeito mais fácil de selar um objeto, com certeza,
// é Object.seal.
var sealed = {};
Object.seal(sealed);
Object.isSealed(sealed); // === true

// Um objeto selado é, por definição, não extensível.
Object.isExtensible(sealed); // === false

// Um objeto selado pode estar congelado,
// mas não precisa estar.
Object.isFrozen(sealed); // === true
// (todas as propriedades também não escrevíveis)

var s2 = Object.seal({ p: 3 });
Object.isFrozen(s2); // === false
// ('p' continua "escrevível")

var s3 = Object.seal({
  get p() {
    return 0;
  },
});
Object.isFrozen(s3); // === true
// (somente a configurabilidade importa nos assessores de propriedade)
```

Notas
-----

No ES5, se o argumento para esse método não é um objeto (um primitivo), então ele irá causar um `TypeError`. No ES2015, um argumento que não seja objeto irá ser tratado como se fosse um objeto selado qualquer, simplesmente retornando `true`.

```js
Object.isSealed(1);
// TypeError: 1 is not an object (ES5 code)

Object.isSealed(1);
// true (ES2015 code)
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.issealed |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.seal()`
* `Object.preventExtensions()`
* `Object.isExtensible()`
* `Object.freeze()`
* `Object.isFrozen()`