initial commit

38 files changed, 6105 insertions, 0 deletions

diff --git a/files/pt-br/web/javascript/reference/global_objects/object/__definegetter__/index.html b/files/pt-br/web/javascript/reference/global_objects/object/__definegetter__/index.html
new file mode 100644
index 0000000000..4c942f9ba7
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/__definegetter__/index.html
@@ -0,0 +1,102 @@
+---
+title: Object.prototype.__defineGetter__()
+slug: Web/JavaScript/Reference/Global_Objects/Object/__defineGetter__
+tags:
+  - Depreciado
+  - JavaScript
+  - Objeto
+  - Prototipo
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/__defineGetter__
+---
+<div>{{JSRef}}</div>
+
+<div class="warning">
+<p>Esta característica está descontinuada em favor de definindo getters usando a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">sintaxe de inicialização de objeto </a>ou a API {{jsxref("Object.defineProperty()")}}. Enquanto esta característica é amplamente implementada, ela está somente descrita na <a href="https://tc39.github.io/ecma262/#sec-additional-ecmascript-features-for-web-browsers">especificação ECMAScript </a> por causa do uso legado. Este método não deveria ser usado desde que exista existam melhores alternativas.</p>
+</div>
+
+<p>O método <code><strong>__defineGetter__</strong></code> conecta uma propriedade do objeto à uma função para ser chamada quando isso é consultado.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>obj</var>.__defineGetter__(<var>prop</var>, <var>func</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>prop</code></dt>
+ <dd>Uma string contendo o nome da propriedade para conectar a função dada.</dd>
+ <dt><code>func</code></dt>
+ <dd>Uma função para ser ligada a uma consulta da propriedade especificada.</dd>
+</dl>
+
+<h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+
+<p>{{jsxref("undefined")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O <code>__defineGetter__</code> permite um {{jsxref("Operators/get", "getter", "", 1)}} ser definido sobre um objeto preexistente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: 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
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="spectable standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.__defineGetter__', 'Object.prototype.__defineGetter__()')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Incluido no (normativa) anexo para adicionais características legadas ECMAScript para navegadores Web (note que a especificação codifica o que já está em implementações).</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navagadores">Compatibilidade de navagadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.defineGetter")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.__defineSetter__()")}}</li>
+ <li>{{jsxref("Operators/get", "get")}} operator</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Object.prototype.__lookupGetter__()")}}</li>
+ <li>{{jsxref("Object.prototype.__lookupSetter__()")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">Guia JS: Definindo Getters e Setters</a></li>
+ <li><a href="https://whereswalden.com/2010/04/16/more-spidermonkey-changes-ancient-esoteric-very-rarely-used-syntax-for-creating-getters-and-setters-is-being-removed/">[Blog Post] Depreciação de __defineGetter__ e __defineSetter__</a></li>
+ <li>{{bug(647423)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/__definesetter__/index.html b/files/pt-br/web/javascript/reference/global_objects/object/__definesetter__/index.html
new file mode 100644
index 0000000000..0f82f96400
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/__definesetter__/index.html
@@ -0,0 +1,117 @@
+---
+title: Object.prototype.__defineSetter__()
+slug: Web/JavaScript/Reference/Global_Objects/Object/__defineSetter__
+tags:
+  - Deprecated
+  - Depreciado
+  - JavaScript
+  - Method
+  - Object
+  - Objeto
+  - Prototipo
+  - Prototype
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/__defineSetter__
+---
+<div>{{JSRef}}</div>
+
+<div class="warning">
+<p>Esta funcionalidade está depreciada em favor da definição de setters usando a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">sintaxe de inicialização de objeto</a> ou a API {{jsxref("Object.defineProperty()")}}.</p>
+
+<p>Entretando, como ele é largamente implementado e usado na Web, é bem improvável que os navegadores vão parar de implementá-lo.</p>
+</div>
+
+<p>O método <code><strong>__defineSetter__</strong></code> vincula uma propriedade de um objeto a uma função a ser chamada quando é feita uma tentativa de atribuir algo a aquela propriedade.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>obj</var>.__defineSetter__(<var>prop</var>, <var>fun</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>prop</code></dt>
+ <dd>Uma cadeia de caracteres (<em>string</em>) contendo o nome da propriedade que vai ser vinculada a função dada.</dd>
+ <dt><code>fun</code></dt>
+ <dd>A função a ser chamada quando houver uma tentativa de atribuir na propriedade especificada. Esta função toma a forma
+ <pre class="brush: js notranslate">function(<var>val</var>) { . . . }</pre>
+
+ <dl>
+  <dt><code>val</code></dt>
+  <dd>Um apelido para a variável que contém o valor que se tentou atribuir a <code>prop</code>.</dd>
+ </dl>
+ </dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>{{jsxref("undefined")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>__defineSetter__</code> permite um {{jsxref("Operators/set", "setter", "", 1)}} ser definido a um objeto pré-existente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Não_padronizados_e_forma_depreciada">Não padronizados e forma depreciada</h3>
+
+<pre class="brush: js notranslate">var o = {};
+o.__defineSetter__('value', function(val) { this.anotherValue = val; });
+o.value = 5;
+console.log(o.value); // undefined
+console.log(o.anotherValue); // 5
+</pre>
+
+<h3 id="Formas_compatíveis_padronizadas">Formas compatíveis padronizadas</h3>
+
+<pre class="brush: js notranslate">// 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
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="spectable standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.__defineSetter__', 'Object.prototype.__defineSetter__()')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.defineSetter")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.__defineGetter__()")}}</li>
+ <li>Operador {{jsxref("Operators/set", "set")}}</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Object.prototype.__lookupGetter__()")}}</li>
+ <li>{{jsxref("Object.prototype.__lookupSetter__()")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">JS Guide: Defining Getters and Setters</a></li>
+ <li><a href="http://whereswalden.com/2010/04/16/more-spidermonkey-changes-ancient-esoteric-very-rarely-used-syntax-for-creating-getters-and-setters-is-being-removed/">[Blog Post] Deprecation of __defineGetter__ and __defineSetter__</a></li>
+ <li><a href="https://bugzilla.mozilla.org/show_bug.cgi?id=647423">bug 647423</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/__lookupgetter__/index.html b/files/pt-br/web/javascript/reference/global_objects/object/__lookupgetter__/index.html
new file mode 100644
index 0000000000..c9f2d29fcd
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/__lookupgetter__/index.html
@@ -0,0 +1,84 @@
+---
+title: Object.prototype.__lookupGetter__()
+slug: Web/JavaScript/Reference/Global_Objects/Object/__lookupGetter__
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/__lookupGetter__
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code><strong>__lookupGetter__</strong></code> retorna a função limite como uma getter para a específica propriedade.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>obj</var>.__lookupGetter__(<var>sprop</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>sprop</code></dt>
+ <dd>Uma sequência de caracteres contendo o nome da propriedade cuja getter deve retornar.</dd>
+</dl>
+
+<h3 id="Valores_de_retorno">Valores de retorno</h3>
+
+<p>A função limite como uma getter para a específica propriedade.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>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. <code>__lookupGetter__</code> pode ser usado para obter referência à função getter.</p>
+
+<p>Agora é possível fazer isso de um jeito uniforme usando:. {{jsxref("Object.getOwnPropertyDescriptor()")}} e  {{jsxref("Object.getPrototypeOf()")}}.</p>
+
+<h2 id="Examplos">Examplos</h2>
+
+<pre class="brush: js">var obj = {
+  get foo() {
+    return Math.random() &gt; 0.5 ? 'foo' : 'bar';
+  }
+};
+
+
+// Non-standard and deprecated way
+obj.__lookupGetter__('foo');
+// (function() { return Math.random() &gt; 0.5 ? 'foo' : 'bar'; })
+
+
+// Standard-compliant way
+Object.getOwnPropertyDescriptor(obj, "foo").get;
+// (function() { return Math.random() &gt; 0.5 ? 'foo' : 'bar'; })
+</pre>
+
+<h2 id="Specificações">Specificações</h2>
+
+<table class="spectable standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.__lookupGetter__', 'Object.prototype.__lookupGetter__()')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Incluído no (normativo) anexo para ECMAScript adicional recurso para Web (note que a especificação codificada está tendo implementações).</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nessa página é gerado de data estruturada. Se você gostaria de contribuir para a data, por favor confira <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie para nós uma solicitação.</div>
+
+<p>{{Compat("javascript.builtins.Object.lookupGetter")}}</p>
+</div>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.__lookupSetter__()")}}</li>
+ <li>{{jsxref("Functions/get", "get")}} operador</li>
+ <li>{{jsxref("Object.getOwnPropertyDescriptor()")}} e {{jsxref("Object.getPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.prototype.__defineGetter__()")}}</li>
+ <li>{{jsxref("Object.prototype.__defineSetter__()")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">JS Guide: Defining Getters and Setters</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/__lookupsetter__/index.html b/files/pt-br/web/javascript/reference/global_objects/object/__lookupsetter__/index.html
new file mode 100644
index 0000000000..a84545880f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/__lookupsetter__/index.html
@@ -0,0 +1,92 @@
+---
+title: Object.prototype.__lookupSetter__()
+slug: Web/JavaScript/Reference/Global_Objects/Object/__lookupSetter__
+tags:
+  - Deprecated
+  - Depreciado
+  - JavaScript
+  - Method
+  - Object
+  - Objeto
+  - Prototipo
+  - Prototype
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/__lookupSetter__
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code><strong>__lookupSetter__</strong></code> retorna a função vinculada como <em>setter</em> para a propriedade especificada.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>obj</var>.__lookupSetter__(<var>sprop</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>sprop</code></dt>
+ <dd>Uma cadeia de caracteres (<em>string</em>) contendo o nome da propriedade a qual o <em>setter</em> deve ser retornado.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>A função vinculada como <em>setter</em> para a propriedade especificada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se o <em>setter</em> foi definido para uma propriedade do objeto, não era possível referenciar a função através da propriedade, porque aquela propriedade se refere ao valor de retorno da função. <code>__lookupSetter__</code> pode ser usado para obter a referência para a função <em>setter</em>.</p>
+
+<p>É possível agora fazer isso de forma padronizada usando {{jsxref("Object.getOwnPropertyDescriptor()")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Formas_compatíveis_e_não_padronizadas_de_obter_um_definidor_de_propriedades">Formas compatíveis e não padronizadas de obter um definidor de propriedades</h3>
+
+<pre class="brush: js notranslate">var obj = {
+  set foo(value) {
+    this.bar = value;
+  }
+};
+
+
+// Forma não padronizada e depreciada
+obj.__lookupSetter__('foo')
+// (function(value) { this.bar = value; })
+
+
+// Forma compatível padronizada
+Object.getOwnPropertyDescriptor(obj, 'foo').set;
+// (function(value) { this.bar = value; })
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="spectable standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.__lookupSetter__', 'Object.prototype.__lookupSetter__()')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.lookupSetter")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.__lookupGetter__()")}}</li>
+ <li>Operador {{jsxref("Functions/set", "set")}}</li>
+ <li>{{jsxref("Object.getOwnPropertyDescriptor()")}} e {{jsxref("Object.getPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.prototype.__defineGetter__()")}}</li>
+ <li>{{jsxref("Object.prototype.__defineSetter__()")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">JS Guide: Defining Getters and Setters</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/assign/index.html b/files/pt-br/web/javascript/reference/global_objects/object/assign/index.html
new file mode 100644
index 0000000000..87d62130d2
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/assign/index.html
@@ -0,0 +1,223 @@
+---
+title: Object.assign()
+slug: Web/JavaScript/Reference/Global_Objects/Object/assign
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Method
+  - Object
+  - Reference
+  - polyfill
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/assign
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>Object.assign()</code></strong> é usado para copiar os valores de todas as propriedades próprias enumeráveis de um ou mais objetos <em>de origem</em> para um objeto <em>destino</em>. Este método irá retornar o objeto <em>destino</em>.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/object-assign.html")}}</p>
+
+<div class="hidden">
+<p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples and</a> send us a pull request.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.assign(<var>destino</var>, ...<em>origens</em>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>destino</code></dt>
+ <dd>O objeto <em>destino</em>.</dd>
+ <dt><code>origens</code></dt>
+ <dd>Um ou mais objetos de <em>origem</em>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O objeto <em>destino</em> será retornado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>Object.assign()</code> copia apenas propriedades <em>enumeráveis</em><em> </em>e<em> próprias</em> de um objeto <em>de origem</em> para um objeto destino. Ele usa <code>[[Get]]</code> na origem e <code>[[Put]]</code> no <em>destino</em>, então isto irá invocar <em>getters</em> e <em>setters</em>.</p>
+
+<p>Portanto, ele <em>atribui</em> propriedades, em vez de simplesmente copiar ou definir novas propriedades. Isso pode fazê-lo impróprio para combinar novas propriedades com um <em>prototype</em> se os objetos <em>de origem</em> contiverem getters. Para copiar definições de propriedades, incluindo sua enumerabilidade, para <em>prototypes</em> {{jsxref("Object.getOwnPropertyDescriptor()")}} e {{jsxref("Object.defineProperty()")}} devem ser utilizadas no lugar.</p>
+
+<p>Ambas as propriedades {{jsxref("String")}} e {{jsxref("Symbol")}} são copiadas.</p>
+
+<p>No caso de erro, por exemplo, se uma propriedade não é <em>writable</em>, um {{jsxref("TypeError")}} será lançado e o objeto <em>destino</em> permanecerá inalterado. Note que <code>Object.assign()</code> não lança erros caso algum argumento <em>source</em> seja {{jsxref("null")}} ou {{jsxref("undefined")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Clonando_um_objeto">Clonando um objeto</h3>
+
+<pre class="brush: js">var obj = { a: 1 };
+var copy = Object.assign({}, obj);
+console.log(copy); // { a: 1 }
+</pre>
+
+<h3 id="Mesclando_objetos">Mesclando objetos</h3>
+
+<pre class="brush: 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.
+</pre>
+
+<h3 id="Copiando_propriedades_Symbol">Copiando propriedades Symbol</h3>
+
+<pre class="brush: js">var o1 = { a: 1 };
+var o2 = { [Symbol('foo')]: 2 };
+
+var obj = Object.assign({}, o1, o2);
+console.log(obj); // { a: 1, [Symbol("foo")]: 2 }
+</pre>
+
+<h3 id="Propriedades_herdadas_e_não_enumeráveis_não_podem_ser_copiadas">Propriedades herdadas e não enumeráveis não podem ser copiadas</h3>
+
+<pre class="brush: 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 }
+</pre>
+
+<h3 id="Primitivas_serão_encapsuladas_em_objetos">Primitivas serão encapsuladas em objetos</h3>
+
+<pre class="brush: 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" }
+</pre>
+
+<h3 id="Exceções_irão_interromper_a_tarefa_de_cópia_em_execução">Exceções irão interromper a tarefa de cópia em execução</h3>
+
+<pre class="brush: 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.
+</pre>
+
+<h3 id="Copiando_acessores">Copiando acessores</h3>
+
+<pre class="brush: 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 =&gt; {
+    Object.defineProperties(target, Object.keys(source).reduce((descriptors, key) =&gt; {
+      descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
+      return descriptors;
+    }, {}));
+  });
+  return target;
+}
+
+var copy = myAssign({}, obj);
+console.log(copy);
+// { foo:1, get bar() { return 2 } }
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Este polyfill não suporta propriedades {{jsxref("Symbol")}}, visto que ES5 não possui símbolos:</p>
+
+<pre class="brush: 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 &lt; 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 &lt; len; nextIndex++) {
+          var nextKey = keysArray[nextIndex];
+          var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
+          if (desc !== undefined &amp;&amp; desc.enumerable) {
+            to[nextKey] = nextSource[nextKey];
+          }
+        }
+      }
+      return to;
+    }
+  });
+}
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-object.assign', 'Object.assign')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<div class="hidden">
+<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+</div>
+
+<p>{{Compat("javascript.builtins.Object.assign")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.defineProperties()")}}</li>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Enumerabilidade_e_posse_de_propriedades">Enumerabilidade e posse de propriedades</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/constructor/index.html b/files/pt-br/web/javascript/reference/global_objects/object/constructor/index.html
new file mode 100644
index 0000000000..4a0729a84f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/constructor/index.html
@@ -0,0 +1,192 @@
+---
+title: Object.prototype.constructor
+slug: Web/JavaScript/Reference/Global_Objects/Object/constructor
+tags:
+  - Constructor
+  - Objeto
+  - Propriedade
+  - object.constructor
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/constructor
+---
+<div>{{JSRef("Global_Objects", "Object")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>Retorna uma referência para a função {{jsxref("Global_Objects/Object", "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 <em>read-only</em> para valores primitivos como <code>1</code>, <code>true</code> e <code>"test"</code>.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Todos os objetos herdam a propriedade <em>construtor</em> de seu protótipo:</p>
+
+<pre class="brush: js">var o = {};
+o.constructor === Object; // true
+
+var a = [];
+a.constructor === Array; // true
+
+var n = new Number(3);
+n.constructor === Number; // true
+</pre>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Displaying_the_constructor_of_an_object" name="Example:_Displaying_the_constructor_of_an_object">Exemplo: Apresentando o construtor de um objeto</h3>
+
+<p>O exemplo a seguir cria um protótipo, <code>Tree</code>, e um objeto desse tipo, <code>theTree</code>. O exemplo, então, apresenta a propriedade <em>constructor </em>do objeto <code>theTree</code>.</p>
+
+<pre class="brush: js">function Tree(name) {
+  this.name = name;
+}
+
+var theTree = new Tree('Redwood');
+console.log('theTree.constructor is ' + theTree.constructor);
+</pre>
+
+<p>Esse exemplo apresenta a seguinte saída:</p>
+
+<pre class="brush: js">theTree.constructor is function Tree(name) {
+  this.name = name;
+}
+</pre>
+
+<h3 id="Example:_Changing_the_constructor_of_an_object" name="Example:_Changing_the_constructor_of_an_object">Exemplo: Mudando o construtor de um objeto</h3>
+
+<p>O exemplo a seguir apresenta como modificar o valor do construtor de um objeto genérico. Apenas <code>true</code>, <code>1</code> e <code>"test" </code>não serão afetados sendo que eles tem <code>construtores </code><em>read-only</em> nativos. Esse exemplo apresenta que nem sempre é seguro depender da propriedade <code>constructor</code> de um objeto.</p>
+
+<pre class="brush: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 &lt; types.length; i++) {
+  types[i].constructor = Type;
+  types[i] = [types[i].constructor, types[i] instanceof Type, types[i].toString()];
+}
+
+console.log(types.join('\n'));
+</pre>
+
+<p>Esse exemplo apresenta a seguinte saída:</p>
+
+<pre class="brush: 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
+</pre>
+
+<h2 id="Specifications" name="Specifications">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1ª Edição.</td>
+   <td>Padrão</td>
+   <td>Definição inicial. Implementado no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.4.1', 'Object.prototype.constructor')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.prototype.constructor', 'Object.prototype.constructor')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade de Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/count/index.html b/files/pt-br/web/javascript/reference/global_objects/object/count/index.html
new file mode 100644
index 0000000000..24b13a68b8
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/count/index.html
@@ -0,0 +1,46 @@
+---
+title: Object.prototype.__count__
+slug: Web/JavaScript/Reference/Global_Objects/Object/count
+tags:
+  - JavaScript
+  - Não-padronizado
+  - Objeto
+  - Obsoleto
+  - Propriedade
+  - Prototipo
+  - Prototype
+translation_of: Archive/Web/JavaScript/Object.count
+---
+<div>{{JSRef}}{{Non-standard_Header}}{{obsolete_header("gecko2")}}</div>
+
+<p>A propriedade <strong><code>__count__</code></strong> usada para armazenar a contagem de propriedades enumeráveis sobre o objeto, mas ele foi removido.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>obj</var>.__count__</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">{ 1: 1 }.__count__              // 1
+[].__count__                    // 0
+[1].__count__                   // 1
+[1, /* hole */, 2, 3].__count__ // 3
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não faz parte de qualquer especificação.</p>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.count")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a class="external" href="http://whereswalden.com/2010/04/06/more-changes-coming-to-spidermonkey-the-magical-__count__-property-of-objects-is-being-removed/">[Blog post] Mais trocas vindo para SpiderMonkey: a mágica propriedade __count__ está sendo removid</a>a</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/create/index.html b/files/pt-br/web/javascript/reference/global_objects/object/create/index.html
new file mode 100644
index 0000000000..9c37fa8fcc
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/create/index.html
@@ -0,0 +1,260 @@
+---
+title: Object.create()
+slug: Web/JavaScript/Reference/Global_Objects/Object/create
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/create
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.create()</strong></code> cria um novo objeto, utilizando um outro objecto existente como protótipo para o novo objeto a ser criado.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.create(<var>proto</var>[, <var>propertiesObject</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>proto</code></dt>
+ <dd>O objeto que deve ser o protótipo do objeto recém-criado.</dd>
+ <dt><code>propertiesObject</code></dt>
+ <dd>Opcional. Se especificado e não {{jsxref("undefined")}}, um objeto cuja as propriedades próprias enumeráveis (isto é, aquelas propriedades definidas sobre si mesmo, e <em>não</em> 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 {{jsxref("Object.defineProperties()")}}.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Um novo objeto com o protótipo de objeto e propriedades especificadas.</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<p>Uma exceção {{jsxref("TypeError")}} se o parâmetro <code>proto</code> não for {{jsxref("null")}} ou um objeto.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Herança_tradicional_com_Object.create()">Herança tradicional com <code>Object.create()</code></h3>
+
+<p>A seguir, um exemplo de como usar <code>Object.create()</code> para realizar uma herança tradicional. Isto é para herança simples, que é a única herança suportada pelo JavaScript.</p>
+
+<pre class="brush: 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.'
+</pre>
+
+<p>Caso queira realizar herança de múltiplos objetos, então mixins ("mistura") são uma possibilidade.</p>
+
+<pre class="brush: 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
+};
+</pre>
+
+<p>A função <code>mixin</code> 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 <a href="https://api.jquery.com/jQuery.extend/">jQuery.extend()</a>.</p>
+
+<h3 id="Usando_argumento_propertiesObject_com_Object.create()">Usando argumento <code>propertiesObject</code> com <code>Object.create()</code></h3>
+
+<pre class="brush: 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 function() { return 10; },
+    set function(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
+  }
+});
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>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.</p>
+
+<p>Note que, enquanto a configuração  <code>null</code> as <code>[[Prototype]]</code> é suportada no ES5 <code>Object.create</code>, este polyfill não suporta devido à limitação inerente em versões do ECMAScript inferiores a 5.</p>
+
+<pre class="brush: js">if (typeof Object.create != 'function') {
+  Object.create = (function() {
+    var Temp = function() {};
+    return function (prototype) {
+      if (arguments.length &gt; 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;
+    };
+  })();
+}</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.5', 'Object.create')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.create', 'Object.create')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.create', 'Object.create')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("5")}}</td>
+   <td>{{CompatGeckoDesktop("2")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("11.60")}}</td>
+   <td>{{CompatSafari("5")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("2")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatOperaMobile("11.5")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Object.defineProperties()")}}</li>
+ <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li>
+ <li>Post de John Resig sobre <a href="http://ejohn.org/blog/objectgetprototypeof/">getPrototypeOf()</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/defineproperties/index.html b/files/pt-br/web/javascript/reference/global_objects/object/defineproperties/index.html
new file mode 100644
index 0000000000..da7ca6540a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/defineproperties/index.html
@@ -0,0 +1,233 @@
+---
+title: Object.defineProperties()
+slug: Web/JavaScript/Reference/Global_Objects/Object/defineProperties
+tags:
+  - ECMAScript5
+  - JavaScript
+  - Objeto
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperties
+---
+<div>{{JSRef}}</div>
+
+<p>O método  <code><strong>Object.defineProperties()</strong></code> define uma nova propriedade ou modifica uma existente no objeto, retornando o objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.defineProperties(<var>obj</var>, <var>props</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto no qual se cria ou modifica suas propriedades.</dd>
+ <dt><code>props</code></dt>
+ <dd>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 {{jsxref("Object.defineProperty()")}} para mais detalhes). Descritores têm as seguintes chaves:</dd>
+ <dd>
+ <dl>
+  <dt><code>configurable</code></dt>
+  <dd><code>true</code> se e somente se o tipo deste descritor de propriedades pode ser modificada e se a propriedade pode ser apagada do objeto correspondente.<br>
+  <strong>Valor padrão é <code>false</code>.</strong></dd>
+  <dt><code>enumerable</code></dt>
+  <dd><code>true</code> se e somente se este propriedade aparece durante enumeração das propriedade sobre o objeto correspondente.<br>
+  <strong>Valor padrão é <code>false</code>.</strong></dd>
+ </dl>
+
+ <dl>
+  <dt><code>value</code></dt>
+  <dd>O valor associado com a propriedade. Pode ser qualquer valor válido em JavaScript value (número, objeto, função, etc).<br>
+  <strong>Valor padrão é {{jsxref("undefined")}}.</strong></dd>
+  <dt><code>writable</code></dt>
+  <dd><code>true</code> se e somente se o valor associado com a propriedade pode ser modificada com um {{jsxref("Operators/Assignment_Operators", "assignment operator", "", 1)}}.<br>
+  <strong>Valor padrão é <code>false</code>.</strong></dd>
+ </dl>
+
+ <dl>
+  <dt><code>get</code></dt>
+  <dd>Uma função a qual serve com um getter para a propriedade, ou {{jsxref("undefined")}} se não existe getter. A retorno da função será usado como o valor da propriedade.<br>
+  <strong>Valor padrão é {{jsxref("undefined")}}.</strong></dd>
+  <dt><code>set</code></dt>
+  <dd>Uma função a qual server com um setter para a propriedade, ou {{jsxref("undefined")}} se não existe setter. A função receberá como argumento somente o novo valor sendo atribuído à propriedade.<br>
+  <strong>Valor padrão é {{jsxref("undefined")}}.</strong></dd>
+ </dl>
+ </dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O objeto que foi passado para a função.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>Object.defineProperties</code>, em essência, define todas as propriedades correspondentes para as propriedades próprias  enumeráveis de <code>props</code> sobre o objeto <code>obj</code>.</p>
+
+<h2 id="Exemplo">Exemplo</h2>
+
+<pre class="brush: js">var obj = {};
+Object.defineProperties(obj, {
+  'property1': {
+    value: true,
+    writable: true
+  },
+  'property2': {
+    value: 'Hello',
+    writable: false
+  }
+  // etc. etc.
+});
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Assumindo uma execução intocada com todos os nomes e propriedades referindo para seus valores iniciais, <code>Object.defineProperties</code> é quase completamente equivalente (note o comentário em <code>isCallable</code>) para a seguinte reimplementação em JavaScript:</p>
+
+<pre class="brush: js;highlight:[8]">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) &amp;&amp; typeof g !== 'undefined')
+        throw new TypeError('bad get');
+      d.get = g;
+    }
+    if (hasProperty(desc, 'set')) {
+      var s = desc.set;
+      if (!isCallable(s) &amp;&amp; typeof s !== 'undefined')
+        throw new TypeError('bad set');
+      d.set = s;
+    }
+
+    if (('get' in d || 'set' in d) &amp;&amp; ('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 &lt; keys.length; i++)
+    descs.push([keys[i], convertToDescriptor(properties[keys[i]])]);
+
+  for (var i = 0; i &lt; descs.length; i++)
+    Object.defineProperty(obj, descs[i][0], descs[i][1]);
+
+  return obj;
+}
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.7', 'Object.defineProperties')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.8.5</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.defineproperties', 'Object.defineProperties')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.defineproperties', 'Object.defineProperties')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Firefox (Gecko)</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatGeckoDesktop("2")}}</td>
+   <td>{{CompatChrome("5")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("11.60")}}</td>
+   <td>{{CompatSafari("5")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>Android</th>
+   <th>Edge</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatGeckoMobile("2")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatOperaMobile("11.5")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Object.keys()")}}</li>
+ <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerabilidade e direito de propriedades</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/defineproperty/index.html b/files/pt-br/web/javascript/reference/global_objects/object/defineproperty/index.html
new file mode 100644
index 0000000000..25ad45b438
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/defineproperty/index.html
@@ -0,0 +1,478 @@
+---
+title: Object.defineProperty()
+slug: Web/JavaScript/Reference/Global_Objects/Object/defineProperty
+tags:
+  - ECMAScript5
+  - JavaScript
+  - Método(2)
+  - Objeto
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperty
+---
+<div>{{JSRef}}</div>
+
+<div></div>
+
+<p>O método <code><strong>Object.defineProperty()</strong></code> define uma nova propriedade diretamente em um objeto, ou modifica uma propriedade já existente em um objeto, e retorna o objeto.</p>
+
+<div class="note">
+<p><strong>Nota</strong>: Você invoca este método diretamente no construtor do {{jsxref("Object")}} ao invés de invocar em uma instância do tipo <code>Object</code>.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code>Object.defineProperty(<var>obj</var>, <var>prop</var>, <var>descriptor</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto no qual será definida a propriedade.</dd>
+ <dt><code>prop</code></dt>
+ <dd>O nome da propriedade que será definida ou modificada.</dd>
+ <dt><code>descriptor</code></dt>
+ <dd>O descritor para a propriedade que será definida ou modificada.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O objeto que foi passado à função.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>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 {{jsxref("Statements/for...in", "for...in")}} ou pelo método {{jsxref("Object.keys")}}), e cujos valores podem ser alterados e {{jsxref("Operators/delete", "deletados", "", 1)}}, esse método permite a modificação deste comportamento padrão. Por padrão, valores incluídos utilizando <code>Object.defineProperty()</code> são imutáveis.</p>
+
+<p>Os descritores de propriedades presentes nos objetos se apresentam em duas variedades: descritores de dados e descritores de assessores. Um <em>descritor de dado</em> é uma propriedade que contém um valor, podendo este ser gravável ou não. Um <em>descritor de assessor </em>é 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.</p>
+
+<p>Ambos os descritores de dados e de assessor são objetos. Eles compartilham as seguintes chaves obrigatórias:</p>
+
+<dl>
+ <dt><code>configurable</code></dt>
+ <dd><code>true</code> se e somente se o tipo deste descritor de propriedade pode ser alterado e se a propriedade pode ser deletada do objeto correspondente.<br>
+ <strong>Valor padrão é <code>false</code>.</strong></dd>
+ <dt><code>enumerable</code></dt>
+ <dd><code>true</code> se e somente se esta propriedade aparece durante enumeração das propriedades no objeto correspondente.<br>
+ <strong>Valor padrão é <code>false</code>.</strong></dd>
+</dl>
+
+<p>Um descritor de dados também possui as seguintes chaves opcionais:</p>
+
+<dl>
+ <dt><code>value</code></dt>
+ <dd>O valor associado com a propriedade. Pode ser qualquer valor válido em Javascript  (número, objeto, função, etc).<br>
+ <strong>Valor padrão é {{jsxref("undefined")}}.</strong></dd>
+ <dt><code>writable</code></dt>
+ <dd><code>true</code> se e somente se o valor associado com a propriedade pode ser modificada com um {{jsxref("Operators/Assignment_Operators", "operador de atribuição", "", 1)}}.<br>
+ <strong>Valor padrão é <code>false</code>.</strong></dd>
+</dl>
+
+<p>Um descritor de assessor também possui as seguintes chaves opcionais:</p>
+
+<dl>
+ <dt><code>get</code></dt>
+ <dd>Uma função que servirá como um getter da propriedade, ou {{jsxref("undefined")}} se não houver getter. Quando a propriedade é acessada, esta função é chamada sem argumentos e com <code>this</code> 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.<br>
+ <strong>Valor padrão é {{jsxref("undefined")}}.</strong></dd>
+ <dt><code>set</code></dt>
+ <dd>A função que servirá como um setter para a propriedade, ou {{jsxref("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 <code>this</code> configura o objeto através do qual a propriedade é atribuída.<br>
+ <strong>Valor padrão é {{jsxref("undefined")}}.</strong></dd>
+</dl>
+
+<p>Se um descritor tem  nenhum das chaves <code>value</code>, <code>writable</code>, <code>get</code> e <code>set</code>, ele é tratado como um descritor de dados. Se um descritor tem ambas chaves <code>value</code> ou <code>writable</code> e <code>get</code> ou <code>set</code> keys, uma exceção é lançada.</p>
+
+<p>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 {{jsxref("Object.prototype")}} previamente, declarar todas as opções explicitamente, ou apontar para {{jsxref("null")}} com {{jsxref("Object.create", "Object.create(null)")}}.</p>
+
+<pre class="brush: js notranslate">// 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);</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Se você deseja utilizar o método <code>Object.defineProperty</code> com uma sintaxe estilo <em>flags-binárias</em>, veja os <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty/Additional_examples">exemplos adicionais</a>.</p>
+
+<h3 id="Criando_uma_propriedade">Criando uma propriedade</h3>
+
+<p>Quando a propriedade especificada não existe no objeto, <code>Object.defineProperty()</code>  cria uma nova propriedade conforme descrito anteriormente. Campos podem ser omitidos no descritor, e os valores padrão para esses campos serão introduzidos.</p>
+
+<p>Todos os campos do tipo Boolean possuem como valor padrão <code>false</code>. Os campos <code>value</code>, <code>get</code>, e <code>set</code> possuem como padrão {{jsxref("undefined")}}.  Uma propriedade que é definida sem os valores para <code>get</code>/<code>set</code>/<code>value</code>/<code>writable</code> é dita "genérica" e classificada como um descritor de dados.</p>
+
+<pre class="brush: js notranslate">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</pre>
+
+<h3 id="Modificando_uma_propriedade">Modificando uma propriedade</h3>
+
+<p>Quando uma propriedade já existe, <code>Object.defineProperty()</code> 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 <code>configurable</code> como <code>false</code> a propriedade é chamada "não configurável" e nenhum atributo pode ser alterado <font face="consolas, Liberation Mono, courier, monospace">(exceto a alteração irreversível de <em>writable </em>para <em>false</em>)</font>. Não é possível alternar o tipo de uma propriedade entre dados e assessor quando esta for não-configurável.</p>
+
+<p>Um {{jsxref("TypeError")}} é lançado quando são realizadas tentativas de se alterar propriedades não-configuráveis (exceto o atributo <code>writable</code>) a menos que o valor atual e o novo sejam os mesmos.</p>
+
+<h4 id="O_atributo_writable">O atributo writable</h4>
+
+<p>Quando o atributo <code>writable</code> de uma propriedade é definido como <code>false</code>, a propriedade é dita "não-gravável". Seu valor não poderá ser alterado.</p>
+
+<pre class="brush: js notranslate">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.</pre>
+
+<p>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.</p>
+
+<h4 id="O_atributo_enumerable">O atributo enumerable</h4>
+
+<p>O atributo <code>enumerable</code> de uma propriedade define se ela deve ser exibida em uma repetição {{jsxref("Statements/for...in", "for...in")}} e por {{jsxref("Object.keys()")}} ou não.</p>
+
+<pre class="brush: js notranslate">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</pre>
+
+<h4 id="O_atributo_configurable">O atributo configurable</h4>
+
+<p>O atributo <code>configurable</code> controla ao mesmo se uma propriedade pode ser deletada do objeto, e se seus atributos (exceto a mudança de <code>writable</code> para <code>false</code>) podem ser alterados.</p>
+
+<pre class="brush: js notranslate">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</pre>
+
+<p>Se o atributo <code>configurable</code> de <code>o.a</code> fosse <code>true</code>, nenhum dos erros seria lançado e a propriedade estaria deletada ao final.</p>
+
+<h3 id="Incluindo_propriedades_e_valores_padrão">Incluindo propriedades e valores padrão</h3>
+
+<p>É 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 <code>Object.defineProperty()</code>, como pode ser visto no exemplo abaixo:</p>
+
+<pre class="brush: js notranslate">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
+});</pre>
+
+<h3 id="Setters_e_getters_customizados">Setters e getters customizados</h3>
+
+<p>O exemplo abaixo mostra como implementar um objeto auto-arquivável. Quando a propriedade <code>temperature</code> é atribuída, o array <code>archive</code> recebe uma nova entrada de log.</p>
+
+<pre class="brush: js notranslate">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 }]</pre>
+
+<p>Neste exemplo, um getter sempre returna o mesmo valor.</p>
+
+<pre class="brush: js notranslate">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
+</pre>
+
+<h3 id="Propriedades_de_Herança">Propriedades de Herança </h3>
+
+<p>Se uma propriedade de acessor é herdada, métodos <code>get</code> e <code>set</code> 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.</p>
+
+<pre class="notranslate"><code>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</code></pre>
+
+<p>Isto pode ser corrigido armazenando o valor em outra propriedade. Em métodos <code>get</code> e <code>set</code>, <code>this</code> aponta para o objeto no qual é usado para acessar ou modificar a propriedade.</p>
+
+<pre class="notranslate"><code>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</code></pre>
+
+<p>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.</p>
+
+<pre class="notranslate"><code>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</code>
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table>
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.6', 'Object.defineProperty')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.defineproperty', 'Object.defineProperty')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.defineproperty', 'Object.defineProperty')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browser">Compatibilidade de browser</h2>
+
+<div class="hidden">
+<p>A tabela de compatibilidade nesta página é gerada à partir de dados estruturados. Se você quiser contribuir, consulte <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos mande uma requisição de pull.</p>
+</div>
+
+<p>{{Compat("javascript.builtins.Object.defineProperty")}}</p>
+
+<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2>
+
+<h3 id="Redefinindo_a_propriedade_length_de_um_objeto_Array">Redefinindo a propriedade <code>length</code> de um objeto <code>Array</code> </h3>
+
+<p>É possível redefinir a propriedade {{jsxref("Array.length", "length")}} de arrays, sujeita às restrições de redefinição usuais. (A propriedade {{jsxref("Array.length", "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 {{jsxref("Array.length", "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.</p>
+
+<p>Das versões 4 até 22 do Firefox, um {{jsxref("TypeError")}} é lançado em qualquer tentativa (seja ela permitida ou não) de redefinir a propriedade {{jsxref("Array.length", "length")}} de um array.</p>
+
+<p>Versões do Chrome que implementam <code>Object.defineProperty()</code> em algumas circunstâncias ignoram um valor para <em>length</em> diferente do valor atual da propriedade {{jsxref("Array.length", "length")}} do array. Em algumas circustâncias, alterar o atributo <code>writable</code> 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 <em>length</em> não-gravável.</p>
+
+<p>Versões do Safari que implementam <code>Object.defineProperty()</code> ignoram um valor para <code>length</code> diferente do valor atual da propriedade {{jsxref("Array.length", "length")}}, e tentantivas de alterar o atributo <code>writable</code> executam sem erros embora não modifiquem seu comportamento.</p>
+
+<p>Apenas o Internet Explorer 9 a posteriores, e o Firefox 23 e posteriores, parecem implementar total e corretamente a redefinição da propriedade {{jsxref("Array.length", "length")}} de arrays. Por enquanto, não confie que a redefinição da propriedade {{jsxref("Array.length", "length")}} vá funcionar, mesmo que de uma forma particular. E mesmo quando você <em>puder </em>confiar, <a href="http://whereswalden.com/2013/08/05/new-in-firefox-23-the-length-property-of-an-array-can-be-made-non-writable-but-you-shouldnt-do-it/">existem boas razões para não fazer isso</a>.</p>
+
+<h3 id="Notas_específicas_para_o_Internet_Explorer_8">Notas específicas para o Internet Explorer 8</h3>
+
+<p>O Internet Explorer 8 implementa o método <code>Object.defineProperty()</code> para uso <a href="https://msdn.microsoft.com/en-us/library/dd229916%28VS.85%29.aspx">apenas em objetos DOM</a>. Algumas observações:</p>
+
+<ul>
+ <li>Tentativas de usar <code>Object.defineProperty()</code> em objetos nativos lançam um erro.</li>
+ <li>Todos os atributos da propriedade devem ter seu valor definido. Os atributos <code>configurable</code>, <code>enumerable</code> e <code>writable</code> devem ser <code>true</code> para um descritor do tipo dado, e <code>true</code> para <code>configurable</code> e <code>false</code> para <code>enumerable</code> em descritores do tipo assessor. (?) Qualquer tentativa de usar outros valores (?) resultará no lançamento de um erro.</li>
+ <li>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.</li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Enumerability_and_ownership_of_properties">Enumerabilidade and posse de propriedades</a></li>
+ <li>{{jsxref("Object.defineProperties()")}}</li>
+ <li>{{jsxref("Object.propertyIsEnumerable()")}}</li>
+ <li>{{jsxref("Object.getOwnPropertyDescriptor()")}}</li>
+ <li>{{jsxref("Object.prototype.watch()")}}</li>
+ <li>{{jsxref("Object.prototype.unwatch()")}}</li>
+ <li>{{jsxref("Operators/get", "get")}}</li>
+ <li>{{jsxref("Operators/set", "set")}}</li>
+ <li>{{jsxref("Object.create()")}}</li>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty/Additional_examples">Exemplos adicionais de <code>Object.defineProperty</code></a></li>
+ <li>{{jsxref("Reflect.defineProperty()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/entries/index.html b/files/pt-br/web/javascript/reference/global_objects/object/entries/index.html
new file mode 100644
index 0000000000..1f40f3b693
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/entries/index.html
@@ -0,0 +1,110 @@
+---
+title: Object.entries()
+slug: Web/JavaScript/Reference/Global_Objects/Object/entries
+tags:
+  - Experimental
+  - JavaScript
+  - Objeto
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/entries
+---
+<div>{{JSRef}} {{SeeCompatTable}}</div>
+
+<p>O método <code><strong>Object.entries()</strong></code> retorna uma array dos próprios pares  <code>[key, value] </code>enumeráveis de um dado objeto, na mesma ordem dos objetos providos através do loop {{jsxref("Statements/for...in", "for...in")}} (sendo a diferença que o for-in loop enumera também propriedades dispostas na cadeia de prototipagem - <em>prototype chain</em>).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">Object.entries(<var>obj</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto cujos próprios pares <code>[key, value] </code>de propriedades enumeráveis deverão ser retornados.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma array de pares <code>[key, value] </code>enumeráveis de propriedades de um dado objeto.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>Object.entries()</code> retorna um array cujos elementos são também arrays correspondentes aos pares de propriedades <code>[key, value] </code>enumeráveis encontrados diretamente sobre o objeto. A ordem das propriedades é a mesma que seria se fossem iteradas as propriedades do objeto manualmente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js notranslate">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]) =&gt; {
+    console.log(key + ' ' + value); // "a 5", "b 7", "c 9"
+});
+</pre>
+
+<h3 id="Convertendo_um_Object_em_um_Map">Convertendo um <code>Object</code> em um <code>Map</code></h3>
+
+<p>O construtor {{jsxref("Map", "new Map()")}} aceita entradas iteráveis. Com o <code>Object.entries</code>, você pode facilmente converter de {{jsxref("Object")}} para {{jsxref("Map")}}:</p>
+
+<pre class="brush: js notranslate">var obj = { foo: 'bar', baz: 42 };
+var map = new Map(Object.entries(obj));
+console.log(map); // Map { foo: "bar", baz: 42 }</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Para incluir suporte ao <code>Object.entries</code> em ambientes mais antigos, você pode achar um Polyfill nos repositórios: <a href="https://github.com/tc39/proposal-object-values-entries">tc39/proposal-object-values-entries</a> e <a href="https://github.com/es-shims/Object.entries">es-shims/Object.entries</a>.</p>
+
+<h2 id="Especificaçōes">Especificaçōes</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.entries', 'Object.entries')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<div>{{Compat("javascript.builtins.Object.entries")}}</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Enumerabilidade e posse de propriedades</a></li>
+ <li>{{jsxref("Object.keys()")}}</li>
+ <li>{{jsxref("Object.values()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</li>
+ <li>{{jsxref("Object.create()")}}</li>
+ <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/freeze/index.html b/files/pt-br/web/javascript/reference/global_objects/object/freeze/index.html
new file mode 100644
index 0000000000..b705441dee
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/freeze/index.html
@@ -0,0 +1,205 @@
+---
+title: Object.freeze()
+slug: Web/JavaScript/Reference/Global_Objects/Object/freeze
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/freeze
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.freeze()</strong></code> 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.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.freeze(<var>obj</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto a ser congelado.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O objeto congelado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>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 {{jsxref("TypeError")}} exception (mais frequentemente, mas não exclusivamente, quando em {{jsxref("Strict_mode", "strict mode", "", 1)}}).</p>
+
+<p>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.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: 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
+</pre>
+
+<p>O exemplo a seguir mostra que  valores do tipo objeto, em um objeto congelado, podem ser alterados (freeze é raso).</p>
+
+<pre class="brush: 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' &amp;&amp; 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
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>Em ES5, se um argumento para este método não for um objeto (um primitivo), então isso irá causar um {{jsxref("TypeError")}}. Em ES6, um argumento não-objeto vai ser tratado como se fosse um objeto comum congelado e simplesmente retornado.</p>
+
+<pre class="brush: js">&gt; Object.freeze(1)
+TypeError: 1 is not an object // ES5 code
+
+&gt; Object.freeze(1)
+1                             // ES6 code
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.9', 'Object.freeze')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado em JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.freeze', 'Object.freeze')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.freeze', 'Object.freeze')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Firefox (Gecko)</th>
+   <th>Chrome</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatGeckoDesktop("2")}}</td>
+   <td>{{CompatChrome("6")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("12")}}</td>
+   <td>{{CompatSafari("5.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>Android</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Object.isFrozen()")}}</li>
+ <li>{{jsxref("Object.preventExtensions()")}}</li>
+ <li>{{jsxref("Object.isExtensible()")}}</li>
+ <li>{{jsxref("Object.seal()")}}</li>
+ <li>{{jsxref("Object.isSealed()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/fromentries/index.html b/files/pt-br/web/javascript/reference/global_objects/object/fromentries/index.html
new file mode 100644
index 0000000000..7197f0f9c0
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/fromentries/index.html
@@ -0,0 +1,107 @@
+---
+title: Object.fromEntries()
+slug: Web/JavaScript/Reference/Global_Objects/Object/fromEntries
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/fromEntries
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.fromEntries()</strong></code> transforma uma lista de pares chave-valor em um objeto.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-fromentries.html")}}</div>
+
+<p class="hidden">O código para esse exemplo interativo está em um repositório GitHub repository. Se você tiver interesse em contribuir com o projeto de exemplos interativos, nos envie um <em>pull request </em>em <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Object.fromEntries(<var>iterable</var>);</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code><var>iterable</var></code></dt>
+ <dd>Um iterável como {{jsxref("Array")}} ou {{jsxref("Map")}} ou qualquer outro objeto que implemente <a href="/pt-BR/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol">o protocolo iterável</a>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um novo objeto com suas propriedades definidas pelas entradas fornecidadas pelo iterável.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>Object.fromEntries()</code> recebe uma lista de pares chave-valor e retorna  um novo objeto cujas propriedades foram definidas pelas entradas da lista. O parâmetro <var>iterable</var> deve ser um objeto que implemente o método <code>@@iterator</code>, que retorne um objeto iterador que produza um objeto <em>array-like</em> de dois elementos, onde o primeiro será a chave da propriedade e o segundo será o valor associado à chave.</p>
+
+<p><code>Object.fromEntries()</code> faz o inverso de {{jsxref("Object.entries()")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Convertendo_um_Map_em_um_Object">Convertendo um <code>Map</code> em um <code>Object</code></h3>
+
+<p>Com o método <code>Object.fromEntries</code>, é possível fazer a conveeção de um {{jsxref("Map")}} em um {{jsxref("Object")}}:</p>
+
+<pre class="brush: js">const map = new Map([ ['foo', 'bar'], ['baz', 42] ]);
+const obj = Object.fromEntries(map);
+console.log(obj); // { foo: "bar", baz: 42 }
+</pre>
+
+<h3 id="Convertendo_um_Array_em_um_Object">Convertendo um <code>Array</code> em um <code>Object</code></h3>
+
+<p>Com o método <code>Object.fromEntries</code>, é possível converter um {{jsxref("Array")}} em um {{jsxref("Object")}}:</p>
+
+<pre class="brush: js">const arr = [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ];
+const obj = Object.fromEntries(arr);
+console.log(obj); // { 0: "a", 1: "b", 2: "c" }
+</pre>
+
+<h3 id="Transformações_de_objetos">Transformações de objetos</h3>
+
+<p>Com o método <code>Object.fromEntries</code>, seu inverso {{jsxref("Object.entries()")}}, e os <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#Methods_2">métodos para manipulação de arrays</a>, é possível fazer transformações em objetos como por exemplo:</p>
+
+<pre class="brush: js">const object1 = { a: 1, b: 2, c: 3 };
+
+const object2 = Object.fromEntries(
+  Object.entries(object1)
+  .map(([ key, val ]) =&gt; [ key, val * 2 ])
+);
+
+console.log(object2);
+// { a: 2, b: 4, c: 6 }</pre>
+
+<div class="hidden">
+<p>Please do not add polyfills on MDN pages. For more details, refer to: <a href="https://discourse.mozilla.org/t/mdn-rfc-001-mdn-wiki-pages-shouldnt-be-a-distributor-of-polyfills/24500">https://discourse.mozilla.org/t/mdn-rfc-001-mdn-wiki-pages-shouldnt-be-a-distributor-of-polyfills/24500</a></p>
+</div>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.fromentries', 'Object.fromEntries')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initial definition in ECMAScript 2019.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Object.fromEntries")}}</p>
+
+<h2 id="Veja_Também">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("Object.entries()")}}</li>
+ <li>{{jsxref("Object.keys()")}}</li>
+ <li>{{jsxref("Object.values()")}}</li>
+ <li>{{jsxref("Map.prototype.entries()")}}</li>
+ <li>{{jsxref("Map.prototype.keys()")}}</li>
+ <li>{{jsxref("Map.prototype.values()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html
new file mode 100644
index 0000000000..fad0310e7f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html
@@ -0,0 +1,127 @@
+---
+title: Object.getOwnPropertyDescriptor()
+slug: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor
+tags:
+  - ECMAScript5
+  - ECMAScript6
+  - JavaScript
+  - Método(2)
+  - Objeto
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.getOwnPropertyDescriptor()</strong></code> 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.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.getOwnPropertyDescriptor(<var>obj</var>, <var>prop</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto no qual deve-se procurar pela propriedade.</dd>
+ <dt><code>prop</code></dt>
+ <dd>O nome da propriedade cuja descrição é para ser retornada.</dd>
+</dl>
+
+<h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+
+<p>Um descritor de propriedades da propriedade especificada, se esta existir no objeto, ou {{jsxref("undefined")}}, caso contrário.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Este método permite uma análise da descrição precisa de uma propriedade. Uma propriedade em Javascript consiste de um nome com formato <em>texto-valor </em>e um descritor de propriedades. Mais informações sobre os tipos de descritores de propriedades e seus atributos podem ser encontrados em {{jsxref("Object.defineProperty()")}}.</p>
+
+<p>Um descritor de propriedade é um registro com alguns dos seguintes atributos:</p>
+
+<dl>
+ <dt><code>value</code></dt>
+ <dd>o valor associado com a propriedade (somente para descritores de dados).</dd>
+ <dt><code><strong>writable</strong></code></dt>
+ <dd><code>true</code> se, e somente se, o valor associado com a propriedade pode ser alterado (somente para descritores de dados).</dd>
+ <dt><code>get</code></dt>
+ <dd>Uma função que serve como um <em>getter</em>, para obter o valor da propriedade, ou {{jsxref("undefined")}} se não houver (somente para descritores de acesso).</dd>
+ <dt><code>set</code></dt>
+ <dd>Uma função que serve como um s<em>etter</em>, para atribuir um valor à propriedade, ou {{jsxref("undefined")}} se não houver (somente para descritores de acesso).</dd>
+ <dt><code>configurable</code></dt>
+ <dd><code>true</code> se, e somente se, o tipo deste descritor de propriedade pode ser alterado e se a propriedade pode ser excluída do objeto correspondente.</dd>
+ <dt><code>enumerable</code></dt>
+ <dd><code>true</code> se, e somente se, esta propriedade aparece durante a enumeração das propriedades do objeto correspondente.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">var o, d;
+
+o = { get foo() { return 17; } };
+d = Object.getOwnPropertyDescriptor(o, 'foo');
+// d é { configurable: true, enumerable: true, get: /*A função <em>getter</em>*/, 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 }
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5, o primeiro parâmetro deste método não é um objeto (tipo primitivo), então ele irá gerar um {{jsxref("TypeError")}}. No ES6, um primeiro argumento não-objeto será primeiramente convertido para objeto.</p>
+
+<pre class="brush: 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
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.3', 'Object.getOwnPropertyDescriptor')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.getownpropertydescriptor', 'Object.getOwnPropertyDescriptor')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.getownpropertydescriptor', 'Object.getOwnPropertyDescriptor')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+
+<div>
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.getOwnPropertyDescriptor")}}</p>
+</div>
+</div>
+
+<p> </p>
+
+<h2 id="Veja_Também">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Reflect.getOwnPropertyDescriptor()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/getownpropertydescriptors/index.html b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertydescriptors/index.html
new file mode 100644
index 0000000000..b12a764811
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertydescriptors/index.html
@@ -0,0 +1,104 @@
+---
+title: Object.getOwnPropertyDescriptors()
+slug: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptors
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptors
+---
+<div>{{JSRef}}</div>
+
+<p>O <code><strong>Object.getOwnPropertyDescriptors()</strong></code> método retorna todas as descrições próprias da propriedade de um dado objeto.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-getownpropertydescriptors.html")}}</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">Object.getOwnPropertyDescriptors(<var>obj</var>)</pre>
+
+<h3 id="Parâmetro">P<span><span>arâmetro</span></span></h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd><span class="tlid-translation translation" lang="pt"><span title="">O objeto pelo o qual deseja obter todos os descritores de propriedade próprios.</span></span></dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um objeto contendo todas as propriedades descritivas de um objeto. Pode ser um objeto vazio, se não existir propriedade.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>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 {{jsxref("Symbol")}} e uma propriedade descritora. Outras informações sobre propriedade de tipo descritoras e seus atributos podem ser encontradas em {{jsxref("Object.defineProperty()")}}.</p>
+
+<p>Uma propriedade descritora é um registro com alguns dos seguintes atributos:</p>
+
+<dl>
+ <dt><code>value</code></dt>
+ <dd>O valor associdado com à propriedade (somente descritores de dados).</dd>
+ <dt><code><strong>writable</strong></code></dt>
+ <dd><code>true</code> se somente o valor associado com a propriedade pode ser alterada (somente descritores de dados).</dd>
+ <dt><code>get</code></dt>
+ <dd>Uma função que serve como um capturador para a propriedade ou {{jsxref("undefined")}} se não existir um capturador (somente descritores de acesso).</dd>
+ <dt><code>set</code></dt>
+ <dd>Uma função que serve como um configurador para a propriedade, ou {{jsxref("undefined")}} se não existir um configurador (somente descritores de acesso).</dd>
+ <dt><code>configurable</code></dt>
+ <dd><code>true</code> se e somente se o tipo da propriedade descritora pode ser alterada e se a propriedade pode ser deletada do objeto <span><span>correspondente</span></span>.</dd>
+ <dt><code>enumerable</code></dt>
+ <dd><code>true</code> se e somente se essa propriedade se mostrar durante a enumeração da propriedade no objeto <span><span>correspondente</span></span>.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Criando_um_clone_superficial">Criando um clone superficial</h3>
+
+<p>Enquanto o {{jsxref("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 {{jsxref("Object.create()")}} para uma cópia superficial entre dois objetos desconhecidos:</p>
+
+<pre class="brush: js notranslate">Object.create(
+  Object.getPrototypeOf(obj),
+  Object.getOwnPropertyDescriptors(obj)
+);
+</pre>
+
+<h3 id="Criando_uma_subclasse">Criando uma subclasse</h3>
+
+<p>Um modo típico de criar uma subclasse é definir a subclasse, configurar um <span><span>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 </span></span>:</p>
+
+<pre class="brush: js notranslate">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
+  }
+);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.getownpropertydescriptors', 'Object.getOwnPropertyDescriptors')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibiliadde_de_navegadores">Compatibiliadde de navegadores</h2>
+
+<div>
+<div class="hidden">A tablea de compatibilidade dessa página é gerada de dados estruturados. Se você gostaria de contribuir com os dados, por favor dê uma olhada em <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e <span class="text">mande-nos</span> uma pull request.</div>
+
+<p>{{Compat("javascript.builtins.Object.getOwnPropertyDescriptors")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.getOwnPropertyDescriptor()")}}</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li><a href="https://github.com/tc39/proposal-object-getownpropertydescriptors">Polyfill</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/getownpropertynames/index.html b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertynames/index.html
new file mode 100644
index 0000000000..1843ce8d21
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertynames/index.html
@@ -0,0 +1,211 @@
+---
+title: Object.getOwnPropertyNames()
+slug: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames
+tags:
+  - Objeto
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>Object.getOwnPropertyNames()</code></strong> retorna um vetor com todas as propriedades (enumeráveis ou não) encontradas diretamente em um dado objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Object.getOwnPropertyNames(<var>obj</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto, cujas suas próprias propriedades, enumeráveis ou não, serão retornadas.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>Object.getOwnPropertyNames()</code> retorna um vetor cujos elementos são strings correspondentes as propriedades enumeráveis ou não, encontradas em <code>obj</code>. A ordem das propriedades enumeráveis no vetor é consistente com a ordenação exposta por um laço  {{jsxref("Statements/for...in", "for...in")}} (ou por {{jsxref("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.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Object.getOwnPropertyNames()">Usando <code>Object.getOwnPropertyNames()</code></h3>
+
+<pre class="brush: 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 + ' -&gt; ' + obj[val]);
+});
+// logs
+// 0 -&gt; a
+// 1 -&gt; b
+// 2 -&gt; 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"]
+</pre>
+
+<p>Se voce quer somente as propriedades enumeráveis, veja {{jsxref("Object.keys()")}} ou use um laço {{jsxref("Statements/for...in", "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 {{jsxref("Object.prototype.hasOwnProperty()", "hasOwnProperty()")}}).</p>
+
+<p>Ítens na cadeia prototype não são listados:</p>
+
+<pre class="brush: 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"]
+  )
+);
+</pre>
+
+<h3 id="Obtenha_somente_não-enumeráveis">Obtenha somente não-enumeráveis</h3>
+
+<p>Isto usa a função {{jsxref("Array.prototype.filter()")}} para remover as chaves enumeráveis (obtidas com {{jsxref("Object.keys()")}}) de uma lista com todas as chaves (obtidas com <code>Object.getOwnPropertyNames()</code>) deixando somente as chaves não-enumeráveis.</p>
+
+<pre class="brush: 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);
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5, se o argumento desse método não é um objeto (um tipo primitivo), então isso causará um {{jsxref("TypeError")}}. No ES6, um argumento diferente de objeto será transformado em um objeto.</p>
+
+<pre class="brush: js">Object.getOwnPropertyNames('foo');
+// TypeError: "foo" is not an object (ES5 code)
+
+Object.getOwnPropertyNames('foo');
+// ["0", "1", "2", "length"]  (ES6 code)
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Esperificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.4', 'Object.getOwnPropertyNames')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>
+    <p>Definição inicial. Implementado no JavaScript 1.8.5.</p>
+   </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.getownpropertynames', 'Object.getOwnPropertyNames')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.getownpropertynames', 'Object.getOwnPropertyNames')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_em_navegadores">Compatibilidade em navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("5")}}</td>
+   <td>{{CompatGeckoDesktop("2")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("12")}}</td>
+   <td>{{CompatSafari("5")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Notas_específicas_para_SpiderMonkey">Notas específicas para SpiderMonkey</h2>
+
+<p>Antes do SpiderMonkey 28 {{geckoRelease("28")}}, <code>Object.getOwnPropertyNames</code> não via propriedades não resolvidas de objetos {{jsxref("Error")}}. Isto foi resolvido em versões posteriores ({{bug("724768")}}).</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerabilidade e posse de propriedades</a></li>
+ <li>{{jsxref("Object.prototype.hasOwnProperty()")}}</li>
+ <li>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</li>
+ <li>{{jsxref("Object.create()")}}</li>
+ <li>{{jsxref("Object.keys()")}}</li>
+ <li>{{jsxref("Array.forEach()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/getownpropertysymbols/index.html b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertysymbols/index.html
new file mode 100644
index 0000000000..319253b313
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertysymbols/index.html
@@ -0,0 +1,79 @@
+---
+title: Object.getOwnPropertySymbols()
+slug: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertySymbols
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertySymbols
+---
+<div>{{JSRef}}</div>
+
+<p>O <code><strong>Object.getOwnPropertySymbols()</strong></code> método retorna uma array com todas propriedades de símbolo encontradas diretamente em um determinado objeto dado.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-getownpropertysymbols.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="brush: js notranslate"><code>Object.getOwnPropertySymbols(<var>obj</var>)</code></pre>
+
+<h3 id="Parâmetro"><span><span>Parâmetro</span></span></h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto pelo qual as propriedades de símbolos são retornas.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma array com todas as propriedades de símbolos encontradas diretamente pelo o objeto dado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Similar do {{jsxref("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 {{jsxref("Object.getOwnPropertyNames()")}} não contém as propriedades de símbolo de um objeto e somente as propriedades de string.</p>
+
+<p>Como todos os objetos não possuem símbolos próprios inicialmente, o <code>Object.getOwnPropertySymbols()</code> retorna uma array vazia a menos que você tenha definido as propriedades de símbolo do seu objeto .</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_getOwnPropertySymbols">Usando getOwnPropertySymbols</h3>
+
+<pre class="brush: js notranslate">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)
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.getownpropertysymbols', 'Object.getOwnPropertySymbols')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>
+<div class="hidden">A tablea de compatibilidade dessa página é gerada de dados estruturados. Se você gostaria de contribuir com os dados, por favor dê uma olhada em <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e <span class="text">mande-nos</span> uma pull request.</div>
+
+<p>{{Compat("javascript.builtins.Object.getOwnPropertySymbols")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
+ <li>{{jsxref("Symbol")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/getprototypeof/index.html b/files/pt-br/web/javascript/reference/global_objects/object/getprototypeof/index.html
new file mode 100644
index 0000000000..a1e3bf1910
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/getprototypeof/index.html
@@ -0,0 +1,124 @@
+---
+title: Object.getPrototypeOf()
+slug: Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.getPrototypeOf()</strong></code> retorna o prototype (isto é, o valor da propriedade interna <code>[[Prototype]]</code>) do objeto especificado.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.getPrototypeOf(<var>obj</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto cujo prototype será retornado.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">var proto = {};
+var obj = Object.create(proto);
+Object.getPrototypeOf(obj) === proto; // true
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5 será lançada uma exceção {{jsxref("TypeError")}} se o parâmetro obj não for um objeto. No ES6, no entanto, esse valor será submetido a um {{jsxref("Object")}} equivalente ao seu tipo e retornado.</p>
+
+<pre class="brush: js">Object.getPrototypeOf("foo");
+// TypeError: "foo" não é um objeto (código ES5)
+Object.getPrototypeOf("foo");
+// String.prototype                  (código ES6)
+</pre>
+
+<h2 id="Especificação">Especificação</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.2', 'Object.getPrototypeOf')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.getprototypeof', 'Object.getProtoypeOf')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Características</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("5")}}</td>
+   <td>{{CompatGeckoDesktop("1.9.1")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("12.10")}}</td>
+   <td>{{CompatSafari("5")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Características</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Notas_específicas_para_o_Opera">Notas específicas para o Opera</h2>
+
+<p>Embora as versões mais antigas do Opera não suportem <code>Object.getPrototypeOf()</code>, ele suporta a propriedade não oficial {{jsxref("Object.proto", "__proto__")}} desde de a sua versão 10.50.</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.setPrototypeOf()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Object.prototype.__proto__")}}</li>
+ <li>John Resig's post on <a class="external" href="http://ejohn.org/blog/objectgetprototypeof/">getPrototypeOf</a></li>
+ <li>{{jsxref("Reflect.getPrototypeOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/hasownproperty/index.html b/files/pt-br/web/javascript/reference/global_objects/object/hasownproperty/index.html
new file mode 100644
index 0000000000..aef0554b86
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/hasownproperty/index.html
@@ -0,0 +1,193 @@
+---
+title: Object.prototype.hasOwnProperty()
+slug: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
+---
+<div>{{JSRef("Global_Objects", "Object")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <code><strong>hasOwnProperty()</strong></code> retorna um booleano indicando se o objeto possui a propriedade especificada como uma propriedade definida no próprio objeto em questão (ao contrário de uma propriedade herdada).</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>obj</em>.hasOwnProperty(<em>prop</em>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>prop</code></dt>
+ <dd>Uma {{jsxref("String")}} ou <a href="https://developer.mozilla.org/pt-BR/docs/Glossary/Symbol">symbol</a> indicando o nome da propriedade a ser verificada.</dd>
+</dl>
+
+<h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+
+<p>Um {{jsxref("Boolean", "booleano")}} indicando se o objeto possui ou não a propriedade especificada como uma propriedade do próprio objeto e que a propriedade não é uma propriedade herdada.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Todo objeto descendente de <code>Object</code> herda o método <code>hasOwnProperty</code>. Este método pode ser usado para determinar se um objeto possui a propriedade especificada como propriedade direta do objeto.</p>
+
+<p>Diferentemente do operador {{jsxref("Operators/in", "in")}}, este método não checa a cadeia prototípica do objeto.</p>
+
+<h2 id="Examples" name="Examples">Nota</h2>
+
+<p>o método <code>hasOwnProperty</code> retorna <code>true</code> mesmo se o valor da propridade em questão é <code>null</code> ou <code>undefined</code></p>
+
+<pre class="syntaxbox"><code>o = new Object();
+o.propUm = null;
+o.hasOwnProperty('propUm'); // retorna true
+o.propDois = undefined;
+o.hasOwnProperty('propDois'); // retorna true</code>
+</pre>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example_Using_hasOwnProperty_to_test_for_a_property.27s_existence" name="Example:_Using_hasOwnProperty_to_test_for_a_property.27s_existence">Usando <code>hasOwnProperty</code> para testar a existência de uma propriedade</h3>
+
+<p>O seguinte exemplo determina se o objeto <code>o</code> possui uma propriedade com o nome <code>prop</code>:</p>
+
+<pre><code>o = new Object();
+o.hasOwnProperty('prop'); // retorna false
+o.prop = 'existe';
+o.hasOwnProperty('prop'); // retorna true</code></pre>
+
+<h3 id="Example_Direct_versus_inherited_properties" name="Example:_Direct_versus_inherited_properties">Propriedades Diretas vs Propriedades Herdadas</h3>
+
+<p>O seguinte exemplo diferencia entre propriedade diretas e propriedade herdadas da cadeia prototípica:</p>
+
+<pre class="brush: js">o = new Object();
+o.prop = 'existe';
+o.hasOwnProperty('prop');             // Retorna true
+o.hasOwnProperty('toString');         // Retorna false
+o.hasOwnProperty('hasOwnProperty');   // Retorna false</pre>
+
+<h3 id="Example_Itarate_over_properties_not_considering_inherited_properties" name="Example:_Itarate_over_properties_not_considering_inherited_properties">Percorrer através das propriedades de um objeto</h3>
+
+<p class="syntaxbox">O seguinte exemplo mostra como percorrer as propriedade de um objeto sem executar as propriedade herdadas.</p>
+
+<p class="syntaxbox">Vale observar que o loop {{jsxref("Statements/for...in", "for...in")}} percorre somente itens enumeráveis. Entretanto, o método hasOwnProperty também funciona com propriedades não enumeráveis.</p>
+
+<pre class="brush: js">var buz = {
+    fog: 'stack'
+};
+
+for (var nome in buz) {
+    if (buz.hasOwnProperty(nome)) {
+        alert("this is fog (" + nome + ") for sure. Value: " + buz[nome]);
+    }
+    else {
+        alert(nome); // toString ou qualquer outra coisa
+    }
+}</pre>
+
+<h3 id="Exemplo_hasOwnProperty_como_propriedade">Exemplo: <code>hasOwnProperty</code> como propriedade</h3>
+
+<p>JavaScript não protege o nome <code>hasOwnProperty</code>, assim, se existir a possibilidade do objeto possuir uma propriedade com esse nome, é necessário usar<code> <em>externamente </em>hasOwnProperty</code> para se ter o resultado correto:</p>
+
+<pre class="brush: js">var foo = {
+    hasOwnProperty: function() {
+        return false;
+    },
+    bar: 'Here be dragons'
+};
+
+foo.hasOwnProperty('bar'); // Sempre retorna false
+
+// Usando a propriedade hasOwnProperty de outro objeto e definindo 'this' como foo
+({}).hasOwnProperty.call(foo, 'bar'); // true
+
+// Também é possível usar hasOwnProperty do objeto
+Object.prototype.hasOwnProperty.call(foo, 'bar'); // true
+</pre>
+
+<p>Observe que neste ultimo caso nenhum novo objeto é criado.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 3rd Edition. Implemented in JavaScript 1.5</td>
+   <td>Standard</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.4.5', 'Object.prototype.hasOwnProperty')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.prototype.hasownproperty', 'Object.prototype.hasOwnProperty')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_Also" name="See_Also">Veja Também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties" title="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li>
+ <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a></li>
+ <li>{{jsxref("Operators/in", "in")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Inheritance_Revisited">JavaScript Guide: Inheritance revisted</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/index.html b/files/pt-br/web/javascript/reference/global_objects/object/index.html
new file mode 100644
index 0000000000..eb891fea08
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/index.html
@@ -0,0 +1,180 @@
+---
+title: Object
+slug: Web/JavaScript/Reference/Global_Objects/Object
+tags:
+  - Objeto
+translation_of: Web/JavaScript/Reference/Global_Objects/Object
+---
+<div>{{JSRef}}</div>
+
+<p>O construtor <code>Object</code> cria um wrapper de objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">// Object initialiser or literal
+{ [ <var>nameValuePair1</var>[, <var>nameValuePair2</var>[, ...<var>nameValuePairN</var>] ] ] }
+
+// Called as a constructor
+new Object([<var>value</var>])</pre>
+
+<h3 id="Parametros">Parametros</h3>
+
+<dl>
+ <dt><code>nameValuePair1, nameValuePair2, ... nameValuePair<em>N</em></code></dt>
+ <dd>Pares de nomes (strings) e valores (qualquer valor) em que o nome é separado do valor por dois pontos.</dd>
+ <dt><code>value</code></dt>
+ <dd>Qualquer valor.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O construtor <code>Object</code> cria um wrapper de objeto para o valor fornecido. Se o valor for {{jsxref ("null")}} ou {{jsxref ("undefined")}}, ele criará e retornará um objeto vazio, caso contrário, retornará um objeto de um Type que corresponde ao dado valor. Se o valor já for um objeto, ele retornará o valor.</p>
+
+<p>Quando chamado em um contexto não-construtor, o <code>object</code> se comporta de forma idêntica ao <code>new Object ()</code>.</p>
+
+<p>Veja também <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">object initializer / literal syntax</a>.</p>
+
+<h2 id="Propriedades_do_construtor_Object">Propriedades do construtor <code>Object</code></h2>
+
+<dl>
+ <dt><code>Object.length</code></dt>
+ <dd>Tem um valor de 1.</dd>
+ <dt>{{jsxref("Object.prototype")}}</dt>
+ <dd>Permite a adição de propriedades a todos os objetos do tipo Object.</dd>
+</dl>
+
+<h2 id="Métodos_do_construtor_Object">Métodos do construtor <code>Object</code></h2>
+
+<dl>
+ <dt>{{jsxref("Object.assign()")}}</dt>
+ <dd>Copia os valores de todas as propriedades próprias enumeráveis ​​de um ou mais objetos de origem para um objeto de destino.</dd>
+ <dt>{{jsxref("Object.create()")}}</dt>
+ <dd>Cria um novo objeto com o objeto e as propriedades do protótipo especificado.</dd>
+ <dt>{{jsxref("Object.defineProperty()")}}</dt>
+ <dd>Adiciona a propriedade nomeada descrita por um determinado descritor a um objeto.</dd>
+ <dt>{{jsxref("Object.defineProperties()")}}</dt>
+ <dd>Adiciona as propriedades nomeadas descritas pelos descritores fornecidos a um objeto.</dd>
+ <dt>{{jsxref("Object.entries()")}}</dt>
+ <dd>Retorna uma matriz contendo todos os pares <code>[key, value]</code> das próprias propriedades de string enumeráveis ​​de um determinado objeto.</dd>
+ <dt>{{jsxref("Object.freeze()")}}</dt>
+ <dd>Congela um objeto: outro código não pode excluir ou alterar nenhuma propriedade.</dd>
+ <dt>{{jsxref("Object.fromEntries()")}}</dt>
+ <dd>Retorna um novo objeto de um iterável de pares de valor-chave (reverso à {{jsxref("Object.entries")}}).</dd>
+ <dt>{{jsxref("Object.getOwnPropertyDescriptor()")}}</dt>
+ <dd>Retorna um descritor de propriedade para uma propriedade nomeada em um objeto.</dd>
+ <dt>{{jsxref("Object.getOwnPropertyDescriptors()")}}</dt>
+ <dd>Retorna um objeto contendo todos os descritores de propriedade para um objeto.</dd>
+ <dt>{{jsxref("Object.getOwnPropertyNames()")}}</dt>
+ <dd>Retorna uma matriz contendo os nomes de todas as propriedades enumeráveis ​​e não enumeráveis ​​do próprio objeto fornecido.</dd>
+ <dt>{{jsxref("Object.getOwnPropertySymbols()")}}</dt>
+ <dd>Retorna uma matriz de todas as propriedades de símbolo encontradas diretamente sobre um determinado objeto.</dd>
+ <dt>{{jsxref("Object.getPrototypeOf()")}}</dt>
+ <dd>Retorna o protótipo do objeto especificado.</dd>
+ <dt>{{jsxref("Object.is()")}}</dt>
+ <dd>Compara se dois valores são o mesmo valor. Equivale a todos os valores de <code>NaN</code> (que diferem da Comparação de Igualdade Abstrata e da Comparação de Igualdade Estrita).</dd>
+ <dt>{{jsxref("Object.isExtensible()")}}</dt>
+ <dd>Determina se a extensão de um objeto é permitida.</dd>
+ <dt>{{jsxref("Object.isFrozen()")}}</dt>
+ <dd>Determina se um objeto foi congelado.</dd>
+ <dt>{{jsxref("Object.isSealed()")}}</dt>
+ <dd>Determina se um objeto está selado.</dd>
+ <dt>{{jsxref("Object.keys()")}}</dt>
+ <dd>Retorna uma matriz contendo os nomes de todas as propriedades de string enumeráveis ​​do objeto fornecido.</dd>
+ <dt>{{jsxref("Object.preventExtensions()")}}</dt>
+ <dd>Impede qualquer extensão de um objeto.</dd>
+ <dt>{{jsxref("Object.seal()")}}</dt>
+ <dd>Impede que outro código exclua propriedades de um objeto.</dd>
+ <dt>{{jsxref("Object.setPrototypeOf()")}}</dt>
+ <dd>Define o protótipo (isto é, a propriedade interna <code>[[Prototype]]</code>).</dd>
+ <dt>{{jsxref("Object.values()")}}</dt>
+ <dd>Retorna uma matriz contendo os valores que correspondem a todas as propriedades de string enumeráveis ​​do próprio objeto.</dd>
+</dl>
+
+<h2 id="Instâncias_de_Object_e_Object_de_protótipo_de_objeto">Instâncias de <code>Object</code> e <code>Object</code> de protótipo de objeto</h2>
+
+<p>Todos os objetos em JavaScript são descendentes do <code>Object</code>; todos os objetos herdam métodos e propriedades de {{jsxref("Object.prototype")}}, embora eles possam ser substituídos. Por exemplo, protótipos de outros construtores substituem a propriedade <code>constructor</code> e fornecer seus próprios métodos <code>toString()</code>. As alterações no objeto de protótipo <code>Object</code> são propagadas para todos os objetos, a menos que as propriedades e os métodos sujeitos a essas alterações sejam substituídos na cadeia de protótipos.</p>
+
+<h3 id="Propriedades_(enUS)">Propriedades (enUS)</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype', 'Properties')}}</div>
+
+<h3 id="Métodos_(enUS)">Métodos (enUS)</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype', 'Methods')}}</div>
+
+<h2 id="Excluindo_uma_propriedade_de_um_objeto">Excluindo uma propriedade de um objeto</h2>
+
+<p>Não há nenhum método em um Objeto para excluir suas próprias propriedades (por exemplo, como <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Map/delete" style="">Map.prototype.delete()</a></code>). Para isso, é necessário usar o operador delete.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Object_com_tipos_undefined_e_null">Usando <code>Object</code> com tipos <code>undefined</code> e <code>null</code></h3>
+
+<p>Os exemplos a seguir armazenam um <code>Object</code> vazio na variável "<code>o</code>":</p>
+
+<pre class="brush: js">var o = new Object();
+</pre>
+
+<pre class="brush: js">var o = new Object(undefined);
+</pre>
+
+<pre class="brush: js">var o = new Object(null);
+</pre>
+
+<h3 id="Using_Object_to_create_Boolean_objects">Using <code>Object</code> to create <code>Boolean</code> objects</h3>
+
+<p>Os exemplos a seguir armazenam objetos {{jsxref("Boolean")}} na variável "<code>o</code>":</p>
+
+<pre class="brush: js">// equivalent to o = new Boolean(true);
+var o = new Object(true);
+</pre>
+
+<pre class="brush: js">// equivalent to o = new Boolean(false);
+var o = new Object(Boolean());
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2', 'Object')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>------------------------------------------------</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object-objects', 'Object')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Adicionado <code>Object.assign</code>, <code>Object.getOwnPropertySymbols</code>, <code>Object.setPrototypeOf</code> e <code>Object.is</code></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object-objects', 'Object')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Adicionado  <code>Object.entries</code>, <code>Object.values</code> e <code>Object.getOwnPropertyDescriptors</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">Object initializer</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/is/index.html b/files/pt-br/web/javascript/reference/global_objects/object/is/index.html
new file mode 100644
index 0000000000..ff3131de50
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/is/index.html
@@ -0,0 +1,177 @@
+---
+title: Object.is()
+slug: Web/JavaScript/Reference/Global_Objects/Object/is
+tags:
+  - Comparação
+  - Condição
+  - ECMAScript6
+  - Igualdade
+  - JavaScript
+  - Objeto
+  - condicional
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/is
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.is()</strong></code> determina se dois valores correspondem <a href="/pt-BR/docs/Web/JavaScript/Equality_comparisons_and_sameness">ao mesmo valor</a>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.is(<var>value1</var>, <var>value2</var>);</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>value1</code></dt>
+ <dd>O primeiro valor a ser comparado.</dd>
+ <dt><code>value2</code></dt>
+ <dd>O segundo valor a ser comparado.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>Um {{jsxref("Boolean")}} indicando se os dois argumentos possuem o mesmo valor ou não.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>Object.is()</code> determina se dois valores correspondem <a href="/pt-BR/docs/Web/JavaScript/Equality_comparisons_and_sameness">ao mesmo valor</a>. Dois valores correspondem ao mesmo valor se uma das seguintes condições for verdadeira:</p>
+
+<ul>
+ <li>ambos são {{jsxref("undefined")}}</li>
+ <li>ambos são {{jsxref("null")}}</li>
+ <li>ambos são <code>true</code> ou ambos são <code>false</code></li>
+ <li>ambos são strings do mesmo comprimento, com os mesmos caracteres</li>
+ <li>ambos são o mesmo objeto</li>
+ <li>ambos são numéricos e
+  <ul>
+   <li>ambos são <code>+0</code></li>
+   <li>ambos são <code>-0</code></li>
+   <li>ambos são {{jsxref("NaN")}}</li>
+   <li>ou ambos são não-zero e ambos são não {{jsxref("NaN")}} e ambos correspondem ao mesmo valor</li>
+  </ul>
+ </li>
+</ul>
+
+<p>Isso <em>não é </em>o mesmo que ser igual de acordo com o operador {{jsxref("Operators/Comparison_Operators", "==", "#Equality")}}. O operador {{jsxref("Operators/Comparison_Operators", "==", "#Equality")}} 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 <code>"" == false </code>retornar <code>true</code>), enquanto <code>Object.is</code> não realiza a coerção de nenhum dos valores.</p>
+
+<p>Isso também <em>não</em> <em>é</em> o mesmo que ser igual de acordo com o operador {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}. O operador {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}} (assim como o operador {{jsxref("Operators/Comparison_Operators", "==", "#Equality")}}) trata os valores numéricos <code>-0</code> e <code>+0</code> como iguais e trata {{jsxref("Number.NaN")}} como não igual a {{jsxref("NaN")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: 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
+</pre>
+
+<h2 id="Polyfill_para_navegadores_que_não_suportam_ES6">Polyfill para navegadores que não suportam ES6</h2>
+
+<p><code>Object.is()</code> é 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 <code>Object.is()</code>, mesmo quando não houver suporte por parte do navegador.</p>
+
+<pre class="brush: 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 &amp;&amp; y !== y;
+    }
+  };
+}
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.is', 'Object.is')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.is', 'Object.is')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegador">Compatibilidade com navegador</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("30")}}</td>
+   <td>{{CompatGeckoDesktop("22")}}</td>
+   <td>
+    <p>{{CompatNo}}</p>
+   </td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("22")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Equality_comparisons_and_sameness">Comparações de igualdade</a> — uma comparação dos três recursos implementados para verificação de igualdade.</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/isextensible/index.html b/files/pt-br/web/javascript/reference/global_objects/object/isextensible/index.html
new file mode 100644
index 0000000000..7ef9f5f97c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/isextensible/index.html
@@ -0,0 +1,107 @@
+---
+title: Object.isExtensible()
+slug: Web/JavaScript/Reference/Global_Objects/Object/isExtensible
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/isExtensible
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>Object.isExtensible()</code></strong> verifica se um objeto pode ser extendido (se é ou não possível adicinar novas propriedades).</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-isextensible.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.isExtensible(<var>obj</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto a ser verificado.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um valor booleano ({{jsxref("Boolean")}}) que indica se o objeto pode ser extendido.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Objetos são extensíveis por padrão: novas propriedades podem ser adicionadas, e (em ambientes que suportam {{jsxref("Object.proto", "__proto__")}} {{deprecated_inline}}) a propriedade __proto__ pode ser modificada. Um objeto pode ser marcado como não extensível usando {{jsxref("Object.preventExtensions()")}}, {{jsxref("Object.seal()")}}, ou {{jsxref("Object.freeze()")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: 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
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5, se o argumento fornecido não for um objeto (um tipo primitivo), isso vai causar um erro do tipo {{jsxref("TypeError")}}. No ES2015, um argumento que não é um objeto será tratado como um objeto não extensível, simplesmente retornando <code>false</code>.</p>
+
+<pre class="brush: js">Object.isExtensible(1);
+// TypeError: 1 is not an object (ES5 code)
+
+Object.isExtensible(1);
+// false                         (ES2015 code)
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.13', 'Object.isExtensible')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.isextensible', 'Object.isExtensible')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.isextensible', 'Object.isExtensible')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.isExtensible")}}</p>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Object.preventExtensions()")}}</li>
+ <li>{{jsxref("Object.seal()")}}</li>
+ <li>{{jsxref("Object.isSealed()")}}</li>
+ <li>{{jsxref("Object.freeze()")}}</li>
+ <li>{{jsxref("Object.isFrozen()")}}</li>
+ <li>{{jsxref("Reflect.isExtensible()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/isfrozen/index.html b/files/pt-br/web/javascript/reference/global_objects/object/isfrozen/index.html
new file mode 100644
index 0000000000..1cab1b4843
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/isfrozen/index.html
@@ -0,0 +1,172 @@
+---
+title: Object.isFrozen()
+slug: Web/JavaScript/Reference/Global_Objects/Object/isFrozen
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/isFrozen
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.isFrozen()</strong></code> determina se um objeto está {{jsxref("Object.freeze()", "frozen", "", 1)}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-isfrozen.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.isFrozen(<var>obj</var>)</code></pre>
+
+<h3 id="Parameters">Parameters</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto que será verificado.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>Um valor {{jsxref("Boolean")}} indicando se o objeto está frozen.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Um objeto estará frozen se, e apenas se, ele não for {{jsxref("Object.isExtensible()", "extensible", "", 1)}}, 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.</p>
+
+<h2 id="Examples">Examples</h2>
+
+<pre class="brush: 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
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5, se o argumento deste método não for um objeot (uma primitiva), ele irá lançar um {{jsxref("TypeError")}}. No ES2015, um argumento que não é objeto será sempre tratado como se fosse um objeto frozen, simplesmente retornando <code>true</code>.</p>
+
+<pre class="brush: js">Object.isFrozen(1);
+// TypeError: 1 is not an object (ES5 code)
+
+Object.isFrozen(1);
+// true                          (ES2015 code)
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.12', 'Object.isFrozen')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.isfrozen', 'Object.isFrozen')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.isfrozen', 'Object.isFrozen')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.isFrozen")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.freeze()")}}</li>
+ <li>{{jsxref("Object.preventExtensions()")}}</li>
+ <li>{{jsxref("Object.isExtensible()")}}</li>
+ <li>{{jsxref("Object.seal()")}}</li>
+ <li>{{jsxref("Object.isSealed()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/isprototypeof/index.html b/files/pt-br/web/javascript/reference/global_objects/object/isprototypeof/index.html
new file mode 100644
index 0000000000..07ff5404a3
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/isprototypeof/index.html
@@ -0,0 +1,124 @@
+---
+title: Object.prototype.isPrototypeOf()
+slug: Web/JavaScript/Reference/Global_Objects/Object/isPrototypeOf
+tags:
+  - Objeto
+  - Prototipo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/isPrototypeOf
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>isPrototypeOf()</strong></code> checa se um objeto existe em na cadeia de protótipos de um outro objeto.</p>
+
+<div class="note">
+<p><code>isPrototypeOf()</code> difere do operador {{jsxref("Operators/instanceof", "instanceof")}}. Na expressão "<code>objeto instanceof UmaFuncaoQualquer</code>", a cadeia de protótipos do <code>objeto</code> é comparada com <code>UmaFuncaoQualquer.prototype</code>, e não com a própria função <code>UmaFuncaoQualquer</code>.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>prototypeObj</var>.isPrototypeOf(<var>objeto</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>objeto</code></dt>
+ <dd>Objeto no qual será feito uma busca na cadeia de protótipos.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Um {{jsxref("Boolean")}} indicando se prototypeObj está na cadeia de protótipos do objeto.</p>
+
+<h3 id="Erros_possíveis">Erros possíveis</h3>
+
+<dl>
+ <dt>{{jsxref("TypeError")}}</dt>
+ <dd>Um {{jsxref("TypeError")}} é mostrado se <code><var>prototypeObj</var></code> é <em>undefined </em>ou <em>null</em>.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>isPrototypeOf()</code> lhe permite checar se um objeto está ou não na cadeia de protótipos (cadeia hieráquica) de um outro objeto.</p>
+
+<p>Em outras palavras, você pode descobrir se um objeto x (já instanciado) é herdeiro de um objeto y.</p>
+
+<p> </p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Este exemplo demonstra que <code>Baz.prototype</code>, <code>Bar.prototype</code>, <code>Foo.prototype</code> e<code>Object.prototype</code> estão na cadeia de protótipos de  <code>baz</code> , ou seja, baz herda atributos de Baz, Bar e Foo:</p>
+
+<pre class="brush: js">function Foo() {}
+function Bar() {}
+function Baz() {}
+
+Bar.prototype = Object.create(Foo.prototype);
+Baz.prototype = Object.create(Bar.prototype);
+
+var baz = new Baz();
+
+console.log(Baz.prototype.isPrototypeOf(baz)); // true
+console.log(Bar.prototype.isPrototypeOf(baz)); // true
+console.log(Foo.prototype.isPrototypeOf(baz)); // true
+console.log(Object.prototype.isPrototypeOf(baz)); // true
+</pre>
+
+<p>O método<code>isPrototypeOf()</code>, junto com o operador {{jsxref("Operators/instanceof", "instanceof")}} vêm a ser útil se você tem um código que só pode funcionar quando estiver lidando com objetos que descendem de uma cadeia de protótipos específicos, por exemplo, para garantir que certos métodos ou propriedades estarão presentes naquele objeto que você precisa. </p>
+
+<p>Por exemplo, checar se o objeto <code>baz</code> descende de <code>Foo.prototype</code>:</p>
+
+<pre class="brush: js">if (Foo.prototype.isPrototypeOf(baz)) {
+  // fazer algo seguramente
+}
+</pre>
+
+<h2 id="Specificações">Specificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.4.6', 'Object.prototype.isPrototypeOf')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.prototype.isprototypeof', 'Object.prototype.isPrototypeOf')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.isprototypeof', 'Object.prototype.isPrototypeOf')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_o_Browser">Compatibilidade com o Browser</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade desta página é gerada através de dados estruturados. Se você gostaria de contribuir, por favor veja <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos mande um <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.Object.isPrototypeOf")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Operators/instanceof", "instanceof")}}</li>
+ <li>{{jsxref("Object.getPrototypeOf()")}}</li>
+ <li>
+  <div>{{jsxref("Object.setPrototypeOf()")}}</div>
+ </li>
+ <li>{{jsxref("Object.prototype.__proto__")}} </li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/issealed/index.html b/files/pt-br/web/javascript/reference/global_objects/object/issealed/index.html
new file mode 100644
index 0000000000..67f42f78bc
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/issealed/index.html
@@ -0,0 +1,134 @@
+---
+title: Object.isSealed()
+slug: Web/JavaScript/Reference/Global_Objects/Object/isSealed
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/isSealed
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.isSealed()</strong></code> determina se um objeto está selado.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-issealed.html")}}</div>
+
+<p class="hidden">O código-fonte deste exemplo interativo está armazenado em um repositório do GitHub. Se deseja contribuir com o projeto de exemplos interativos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie-nos uma <em>pull request</em>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.isSealed(<var>obj</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto que deverá ser verificado.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um {{jsxref("Boolean")}} indicando se o objeto fornecido está ou não selado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Retorna <code>true</code> se o objeto está selado, senão <code>false</code>. Um objeto está selado se ele for "não {{jsxref("Object.isExtensible", "extensible", "", 1)}}" 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").</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: 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)
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5, se o argumento para esse método não é um objeto (um primitivo), então ele irá causar um {{jsxref("TypeError")}}. No ES2015, um argumento que não seja objeto irá ser tratado como se fosse um objeto selado qualquer, simplesmente retornando <code>true</code>.</p>
+
+<pre class="brush: js">Object.isSealed(1);
+// TypeError: 1 is not an object (ES5 code)
+
+Object.isSealed(1);
+// true                          (ES2015 code)
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.11', 'Object.isSealed')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.issealed', 'Object.isSealed')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.issealed', 'Object.isSealed')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nesta página é gerado a partir de dados estruturados. Se deseja contribuir com os dados, por favor clone o repositório <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.Object.isSealed")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.seal()")}}</li>
+ <li>{{jsxref("Object.preventExtensions()")}}</li>
+ <li>{{jsxref("Object.isExtensible()")}}</li>
+ <li>{{jsxref("Object.freeze()")}}</li>
+ <li>{{jsxref("Object.isFrozen()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/keys/index.html b/files/pt-br/web/javascript/reference/global_objects/object/keys/index.html
new file mode 100644
index 0000000000..022fdfb410
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/keys/index.html
@@ -0,0 +1,190 @@
+---
+title: Object.keys()
+slug: Web/JavaScript/Reference/Global_Objects/Object/keys
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/keys
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.keys()</strong></code> retorna um array de propriedades enumeraveis de um determinado objeto, na mesma ordem em que é fornecida por um laço {{jsxref("Statements/for...in", "for...in")}} (a diferença é que um laço for-in  enumera propriedades que estejam na cadeia de protótipos).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.keys(<var>obj</var>)</code></pre>
+
+<h3 id="Parametros">Parametros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto cujas propriedades são enumeráveis.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>Object.keys()</code> 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.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: 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']
+</pre>
+
+<p>Se você quiser todas as propriedades, mesmo que não enumeráveis, consulte:{{jsxref("Object.getOwnPropertyNames()")}}.</p>
+
+<h2 id="Notas">Notas</h2>
+
+<p>Em ES5, Se o argumento para o método this não é um objeto(um primitivo), em seguida ele irá causar um {{jsxref("TypeError")}}. Em ES2015, um argumento não-objeto será forçado a um objeto.</p>
+
+<pre class="brush: js">Object.keys("foo");
+// TypeError: "foo" is not an object (ES5 code)
+
+Object.keys("foo");
+// ["0", "1", "2"]                   (ES2015 code)
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Para adicionar suporte Object.keys compatíveis em ambientes mais antigos que não têm suporte nativo para isso, copie o seguinte trecho:</p>
+
+<pre class="brush: js">// De https://developer.mozilla.org/en-US/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' &amp;&amp; (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 &lt; dontEnumsLength; i++) {
+          if (hasOwnProperty.call(obj, dontEnums[i])) {
+            result.push(dontEnums[i]);
+          }
+        }
+      }
+      return result;
+    };
+  }());
+}
+</pre>
+
+<p>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.</p>
+
+<p>Para um simples Browser Polyfill, veja <a href="http://tokenposts.blogspot.com.au/2012/04/javascript-objectkeys-browser.html">Javascript - Object.keys Browser Compatibility</a>.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.14', 'Object.keys')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado em  JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-object.keys', 'Object.keys')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibilidade">Browser compatibilidade</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Caracteristica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("5")}}</td>
+   <td>{{CompatGeckoDesktop("2.0")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("12")}}</td>
+   <td>{{CompatSafari("5")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Caracteristica</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li>
+ <li>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</li>
+ <li>{{jsxref("Object.create()")}}</li>
+ <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/observe/index.html b/files/pt-br/web/javascript/reference/global_objects/object/observe/index.html
new file mode 100644
index 0000000000..c9964127c5
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/observe/index.html
@@ -0,0 +1,161 @@
+---
+title: Object.observe()
+slug: Web/JavaScript/Reference/Global_Objects/Object/observe
+tags:
+  - JavaScript
+  - Obsoleto
+  - observe
+translation_of: Archive/Web/JavaScript/Object.observe
+---
+<div>
+<p>{{JSRef}} {{obsolete_header}}</p>
+
+<p>O método <strong><code>Object.observe()</code></strong> era usado para observações de mudanças, de forma assíncronas de um objeto. Ele fornecia um fluxo de mudanças na ordem em que elas ocorriam. Porém, está API foi depreciada e removida dos navegadores. Você pode utilizar o objeto {{jsxref("Proxy")}} como alternativa.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.observe(<var>obj</var>, <var>callback</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto a ser observado.</dd>
+ <dt><code>callback</code></dt>
+ <dd>A função chamada cada vez que as alterações são feitas, com o seguinte argumento:
+ <dl>
+  <dt><code>changes</code></dt>
+  <dd>Um array de objetos onde cada item representa uma mudança. As propriedades destes objetos de mudança são:
+  <ul>
+   <li><strong><code>name</code></strong>: O nome da propriedade que foi alterada.</li>
+   <li><strong><code>object</code></strong>: O objeto alterado depois que a mudança foi feita.</li>
+   <li><strong><code>type</code></strong>: Uma string indicando o tipo de mudança. Pode ser <code>"add"</code>, <code>"update"</code>, ou <code>"delete"</code>.</li>
+   <li><strong><code>oldValue</code></strong>: Apenas para os tipos <code>"update"</code> e <code>"delete"</code>. O valor antes da alteração.</li>
+  </ul>
+  </dd>
+  <dt><code>acceptList</code></dt>
+  <dd>A lista dos tipos de alterações a serem observadas no objeto dado para o retorno de chamada dado. Se omitida, o array <code>["add", "update", "delete", "reconfigure", "setPrototype", "preventExtensions"]</code> será usado.</dd>
+  <dt>
+  <h3 id="Retorno">Retorno</h3>
+
+  <p>O objeto será retornado.</p>
+  </dt>
+ </dl>
+ </dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O <code>callback</code> é chamado à cada vez que uma mudança ocorre no <code>obj</code>, com um array contendo todas as mudanças na ordem em que elas ocorreram.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Exemplo_Registrando_todos_os_três_tipos_diferentes">Exemplo: Registrando todos os três tipos diferentes</h3>
+
+<pre class="brush: js">var obj = {
+  foo: 0,
+  bar: 1
+};
+
+Object.observe(obj, function(changes) {
+  console.log(changes);
+});
+
+obj.baz = 2;
+// [{name: 'baz', object: &lt;obj&gt;, type: 'add'}]
+
+obj.foo = 'hello';
+// [{name: 'foo', object: &lt;obj&gt;, type: 'update', oldValue: 0}]
+
+delete obj.baz;
+// [{name: 'baz', object: &lt;obj&gt;, type: 'delete', oldValue: 2}]
+</pre>
+
+<h3 id="Exemplo_Data_Binding">Exemplo: Data Binding</h3>
+
+<pre class="brush: js">// Um modelo chamado "user"
+var user = {
+  id: 0,
+  name: 'Brendan Eich',
+  title: 'Mr.'
+};
+
+// Criando uma saudação para o user
+function updateGreeting() {
+  user.greeting = 'Olá, ' + user.title + ' ' + user.name + '!';
+}
+updateGreeting();
+
+Object.observe(user, function(changes) {
+  changes.forEach(function(change) {
+    // Sempre que o name e o title mudarem, o updateGreeting será executado
+    if (change.name === 'name' || change.name === 'title') {
+      updateGreeting();
+    }
+  });
+});
+</pre>
+
+<h2 id="Specifications" name="Specifications">Especificações</h2>
+
+<p><a href="https://github.com/arv/ecmascript-object-observe">Strawman proposal for ECMAScript 7</a>.</p>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com Navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatChrome("36")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("23")}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome("36")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("23")}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.unobserve()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Array.observe()")}} {{experimental_inline}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/preventextensions/index.html b/files/pt-br/web/javascript/reference/global_objects/object/preventextensions/index.html
new file mode 100644
index 0000000000..35446ed876
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/preventextensions/index.html
@@ -0,0 +1,131 @@
+---
+title: Object.preventExtensions()
+slug: Web/JavaScript/Reference/Global_Objects/Object/preventExtensions
+tags:
+  - Objeto
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/preventExtensions
+---
+<div>{{JSRef}}</div>
+
+<p><span id="result_box" lang="pt"><span>O método</span></span> <code><strong>Object.preventExtensions()</strong></code> <span id="result_box" lang="pt"><span> impede que novas propriedades sejam adicionadas a um objeto</span></span> (<span class="short_text" id="result_box" lang="pt"><span>isto é, impede futuras extensões ao objeto</span></span>).</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><code>Object.preventExtensions(<var>obj</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto a tornar-se não-extensível.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um objeto tornado não-extensível.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Um objeto é extensível se novas propriedades puderem der adicionadas ao mesmo. <code>Object.preventExtensions()</code> marca um objeto como não mais extensível, de forma que este nunca terá novas propriedades além daquelas que o objeto tinha quando foi marcado como não-extensível. Note que as propriedades de um objeto não-extensível, em geral, ainda poderão ser <em>apagadas</em>. Tentativas de adicionar novas propriedades a um objeto não-extensível falharão, tanto silenciosamente ou lançando uma exceção {{jsxref("TypeError")}} (mais comumente, mas não exclusivamente, quando em {{jsxref("Functions_and_function_scope/Strict_mode", "strict mode", "", 1)}}).</p>
+
+<p><code>Object.preventExtensions()</code> evita apenas a adição de novas propriedades diretas. Proprieades ainda poderão ser adicionadas ao protótipo do objeto.</p>
+
+<p>É impossível tornar um objeto extensível novamente uma vez que o mesmo tenha se tornado não-extensível.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">// Object.preventExtensions retorna o objeto
+// tornado não-extensível.
+var obj = {};
+var obj2 = Object.preventExtensions(obj);
+obj === obj2; // verdadeiro
+
+// Objetos são extensíveis por padrão...
+var empty = {};
+Object.isExtensible(empty); // === verdadeiro
+
+// ...mas isso pode ser mudado.
+Object.preventExtensions(empty);
+Object.isExtensible(empty); // === falso
+
+// Object.defineProperty lança erro quando adiciona-se
+// uma nova propriedade a um objeto não-extensível.
+var nonExtensible = { removable: true };
+Object.preventExtensions(nonExtensible);
+Object.defineProperty(nonExtensible, 'new', {
+  value: 8675309
+}); // lança um TypeError
+
+// No modo restrito, tentar adicionar novas propriedades a
+// um objeto não-extensível lança um TypeError.
+function fail() {
+  'use strict';
+  // lança um TypeError
+  nonExtensible.newProperty = 'FAIL';
+}
+fail();
+</pre>
+
+<p>O protótipo não-extensível de um objeto é imutável:</p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> fixed <span class="operator token">=</span> Object<span class="punctuation token">.</span><span class="function token">preventExtensions</span><span class="punctuation token">(</span><span class="punctuation token">{</span><span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="comment token">// lança um 'TypeError'.</span>
+fixed<span class="punctuation token">.</span>__proto__ <span class="operator token">=</span> <span class="punctuation token">{</span> oh<span class="punctuation token">:</span> <span class="string token">'hai'</span> <span class="punctuation token">}</span><span class="punctuation token">;</span></code></pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5, se o argumento atribuído a este método não for um objeto (for um primitivo), isso causará um erro de tipo {{jsxref("TypeError")}}. No ES2015, um argumento não-objeto será tratado como se o mesmo fosse um objeto não-extensível comum, simplesmente retornando-o.</p>
+
+<pre class="brush: js">Object.preventExtensions(1);
+// TypeError: 1 não é um objeto (código ES5)
+
+Object.preventExtensions(1);
+// 1                             (código ES2015)
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.10', 'Object.preventExtensions')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado em JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.preventextensions', 'Object.preventExtensions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.preventextensions', 'Object.preventExtensions')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.preventExtensions")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.isExtensible()")}}</li>
+ <li>{{jsxref("Object.seal()")}}</li>
+ <li>{{jsxref("Object.isSealed()")}}</li>
+ <li>{{jsxref("Object.freeze()")}}</li>
+ <li>{{jsxref("Object.isFrozen()")}}</li>
+ <li>{{jsxref("Reflect.preventExtensions()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/propertyisenumerable/index.html b/files/pt-br/web/javascript/reference/global_objects/object/propertyisenumerable/index.html
new file mode 100644
index 0000000000..a68117bc0c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/propertyisenumerable/index.html
@@ -0,0 +1,128 @@
+---
+title: Object.prototype.propertyIsEnumerable()
+slug: Web/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>propertyIsEnumerable()</strong></code> retorna um booleano indicando quando a propriedade especificada é enumerável e é a propriedade do próprio objeto</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-prototype-propertyisenumerable.html", "taller")}}</div>
+
+<p class="hidden">O source deste exemplo interativo é armazenado em um repositório GitHub.Se você deseja contribuir com o projeto de exemplos interativos, vá em:<a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie uma solicitação</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>obj</var>.propertyIsEnumerable(<var>prop</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>prop</code></dt>
+ <dd>O nome da propriedade para teste</dd>
+</dl>
+
+<h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+
+<p>O {{jsxref("Boolean")}} indicando se a propriedade especificada é enumeravel e é a propriedade do objeto</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Every object has a <code>propertyIsEnumerable</code> method. This method can determine whether the specified property in an object can be enumerated by a {{jsxref("Statements/for...in", "for...in")}} loop, with the exception of properties inherited through the prototype chain. If the object does not have the specified property, this method returns <code>false</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="O_uso_basico_de_propertyIsEnumerable">O uso basico de <code>propertyIsEnumerable</code></h3>
+
+<p>O exemplos a seguir mostram o uso de <code>propertyIsEnumerable</code> em um objeto e um array:</p>
+
+<pre class="brush: js notranslate">var o = {};
+var a = [];
+o.prop = 'is enumerable';
+a[0] = 'is enumerable';
+
+o.propertyIsEnumerable('prop');   // returns true
+a.propertyIsEnumerable(0);        // returns true
+</pre>
+
+<h3 id="Objetos_User-defined_vs._built-in">Objetos User-defined vs. built-in</h3>
+
+<p>Os exemplos a seguir demostram a enumerabilidade da propriedade user-defined vs. built-in :</p>
+
+<pre class="brush: js notranslate">var a = ['is enumerable'];
+
+a.propertyIsEnumerable(0);          // returns true
+a.propertyIsEnumerable('length');   // returns false
+
+Math.propertyIsEnumerable('random');   // returns false
+this.propertyIsEnumerable('Math');     // returns false
+</pre>
+
+<h3 id="Propriedade_Direct_vs._inherited">Propriedade Direct vs. inherited</h3>
+
+<pre class="brush: js notranslate">var a = [];
+a.propertyIsEnumerable('constructor');         // returns false
+
+function firstConstructor() {
+  this.property = 'is not enumerable';
+}
+
+firstConstructor.prototype.firstMethod = function() {};
+
+function secondConstructor() {
+  this.method = function() { return 'is enumerable'; };
+}
+
+secondConstructor.prototype = new firstConstructor;
+secondConstructor.prototype.constructor = secondConstructor;
+
+var o = new secondConstructor();
+o.arbitraryProperty = 'is enumerable';
+
+o.propertyIsEnumerable('arbitraryProperty');   // returns true
+o.propertyIsEnumerable('method');              // returns true
+o.propertyIsEnumerable('property');            // returns false
+
+o.property = 'is enumerable';
+
+o.propertyIsEnumerable('property');            // returns true
+
+// These return false as they are on the prototype which
+// propertyIsEnumerable does not consider (even though the last two
+// are iteratable with for-in)
+o.propertyIsEnumerable('prototype');   // returns false (as of JS 1.8.1/FF3.6)
+o.propertyIsEnumerable('constructor'); // returns false
+o.propertyIsEnumerable('firstMethod'); // returns false
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.propertyisenumerable', 'Object.prototype.propertyIsEnumerable')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.propertyIsEnumerable")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li>
+ <li>{{jsxref("Statements/for...in", "for...in")}}</li>
+ <li>{{jsxref("Object.keys()")}}</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/proto/index.html b/files/pt-br/web/javascript/reference/global_objects/object/proto/index.html
new file mode 100644
index 0000000000..11221c8bf9
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/proto/index.html
@@ -0,0 +1,203 @@
+---
+title: Object.prototype.__proto__
+slug: Web/JavaScript/Reference/Global_Objects/Object/proto
+tags:
+  - Depreciado
+  - ECMAScript 2015
+  - JavaScript
+  - Objeto
+  - Propriedade
+  - Prototipo
+  - Referencia
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/proto
+---
+<div class="warning">
+<p><strong>Cuidado:</strong> Alterando o <code>[[Prototype]]</code> de um objeto é, pela natureza que as engines do Javascript modernos otimizam os acessos à propriedades, uma operação muito lenta, em <strong><em>TODOS </em></strong>os mecanismos browsers e JavaScript. Os efeitos no desempenho de alteração na herança são sutis e distantes, e não se limitam simplesmente ao tempo gasto em na declaração <code>obj.__proto__ = ...</code>, mas podem se estender para <strong><em>qualquer</em></strong> código que tenha acesso a <strong><em>qualquer</em></strong> objeto cujo <code>[[Prototype]]</code> foi alterado. Se você se preocupa com desempenho, evite configurar o <code>[[Prototype]]</code> de um objeto. Ao invés disso, crie um novo objeto com o <code>[[Prototype]]</code> desejado usando {{jsxref("Object.create()")}}.</p>
+</div>
+
+<div class="warning">
+<p><strong>Cuidado:</strong> Enquanto <code>Object.prototype.__proto__</code> é suportado hoje em dia em quase todos os navegadores, a existência e o comportamento exato foram padronizados na especificação ECMAScript 2015 como um recurso legado para assegurar compatibilidade com os navegadores. Para melhor suporte, recomenda-se que apenas {{jsxref("Object.getPrototypeOf()")}} seja usado em vez disso.</p>
+</div>
+
+<div>{{JSRef}}</div>
+
+<p>A propriedade <code>__proto__</code> de {{jsxref("Object.prototype")}} é uma propriedade de acesso (uma função getter e uma setter) que expõe o interno <code>[[Prototype]]</code> (ou um objeto ou {{jsxref("Global_Objects/null", "null")}}) de um objeto o qual é acessado.</p>
+
+<p>O uso de <code>__proto__</code> é controverso, e foi desencorajado. Nunca foi incluído originalmente na especificação do idioma EcmaScript, mas os navegadores modernos decidiram implementá-lo de qualquer maneira. Somente recentemente, a propriedade <code>__proto__</code> foi padronizada na especificação de linguagem ECMAScript 2015 para navegadores para garantir compatibilidade, e então ser suportada no futuro. É obsoleta a favor de {{jsxref("Object.getPrototypeOf")}}/{{jsxref("Reflect.getPrototypeOf")}} e {{jsxref("Object.setPrototypeOf")}}/{{jsxref("Reflect.setPrototypeOf")}} (embora ainda, definir <code>[[Prototype]]</code> é uma operação lenta que deve ser evitada se o desempenho for uma preocupação).</p>
+
+<p>A propriedade <code>__proto__</code> também pode ser usada em uma definição literal de objeto para definir o objeto <code>[[Prototype]]</code> na criação, como uma alternativa para {{jsxref("Object.create()")}}. Veja: <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">object initializer / literal syntax</a>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="brush: js">var shape = {};
+var circle = new Circle();
+
+// Define o objeto prototype.
+// OBSOLETO. Isto é somente exemplo. NÃO FAÇA ISSO em código real.
+shape.__proto__ = circle;
+
+// Retorna o objeto prototype
+console.log(shape.__proto__ === circle); // true
+</pre>
+
+<pre class="brush: js">var shape = function () {
+};
+var p = {
+    a: function () {
+        console.log('aaa');
+    }
+};
+shape.prototype.__proto__ = p;
+
+var circle = new shape();
+
+circle.a();//aaa
+
+console.log(shape.prototype === circle.__proto__);//true
+
+//ou
+
+var shape = function () {
+};
+var p = {
+    a: function () {
+        console.log('a');
+    }
+};
+
+var circle = new shape();
+circle.__proto__ = p;
+
+
+circle.a(); //  a
+
+console.log(shape.prototype === circle.__proto__);//false
+
+//ou
+
+function test() {
+}
+test.prototype.myname = function () {
+    console.log('myname');
+
+}
+var a = new test()
+
+console.log(a.__proto__ === test.prototype);//true
+
+a.myname();//myname
+
+
+//ou
+
+var fn = function () {
+};
+fn.prototype.myname = function () {
+    console.log('myname');
+}
+
+var obj = {
+    __proto__: fn.prototype
+};
+
+
+obj.myname();//myname
+</pre>
+
+<p>Nota: são dois underscores(underlines), seguidos de cinco caracteres "proto", seguidos por mais dois underscores(underlines).</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A função getter de <code>__proto__</code> expõe o valor interno de <code>[[Prototype]]</code> de um objeto. Para objetos criado usando um objeto literal, este valor é {{jsxref("Object.prototype")}}. Para os objetos criados usando literais de matrizes, esse valor é {{jsxref("Array.prototype")}}. Para funções, esse valor é {{jsxref("Function.prototype")}}. Para objeto criados usando <code>new fun</code>, onde <code>fun</code> é uma função construtora built-in fornecida pelo JavaScript ({{jsxref("Array")}}, {{jsxref("Boolean")}}, {{jsxref("Date")}}, {{jsxref("Number")}}, {{jsxref("Object")}}, {{jsxref("String")}}, e assim por diante — incluindo novos construtores adicionados como evolução do JavaScript), este valor é sempre <code>fun.prototype</code>. Para objetos criados usando <code>new fun</code>, onde <code>fun</code> é uma função definida em um script, esse valor é o valor de  <code>fun.prototype</code>. (Ou seja, se o construtor não retornou um outro objeto explicitamente, ou o <code>fun.prototype</code> foi reatribuído desde que a instância foi criada).</p>
+
+<p>O setter <code>__proto__</code> permite ao <code>[[Prototype]]</code> de um objeto sejá mutável. O objeto deve ser extensível de acordo com {{jsxref("Object.isExtensible()")}}: se não for, um erro {{jsxref("Global_Objects/TypeError", "TypeError")}} é emitido. O valor fornecido deve ser um objeto ou {{jsxref("Global_Objects/null", "null")}}. Fornecer qualquer outro valor não fará nada.</p>
+
+<p>Para entender como os prototypes são usados para herança, veja o artigo:<a href="/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain">Inheritance and the prototype chain</a>.</p>
+
+<p>A propriedade <code>__proto__</code> é simplesmente uma propriedade acessora {{jsxref("Object.prototype")}} consistindo de uma função getter e setter. Um acesso de propriedade para <code>__proto__</code> que eventualmente consulte {{jsxref("Object.prototype")}} irá encontrar esta propriedade, mas um acesso que não consulta {{jsxref("Object.prototype")}} não a encontrará. Se alguma outra propriedade <code>__proto__</code> for encontrada antes de consultar {{jsxref("Object.prototype")}}, essa propriedade irá ocultar a que encontrou {{jsxref("Object.prototype")}}.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Included in the (normative) annex for additional ECMAScript legacy features for Web browsers (note that the specification codifies what is already in implementations).</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatIE("11")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2>
+
+<p>Enquanto a especificação ECMAScript 2015 dita que o suporte para <code>__proto__</code> é requerido <em>somente</em> para navegadores (apesar de ser normativo), outros ambientes podem suportar também para uso legado.</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.getPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.setPrototypeOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/object/prototype/index.html
new file mode 100644
index 0000000000..5897f91327
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/prototype/index.html
@@ -0,0 +1,226 @@
+---
+title: Object.prototype
+slug: Web/JavaScript/Reference/Global_Objects/Object/prototype
+tags:
+  - JavaScript
+  - Objeto
+  - Propriedade
+translation_of: Web/JavaScript/Reference/Global_Objects/Object
+---
+<div>{{JSRef("Global_Objects", "Object")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>A propriedade <code><strong>Object.prototype</strong></code> representa o {{jsxref("Global_Objects/Object", "Object")}} protótipo do objeto.</p>
+
+<p>{{js_property_attributes(0, 0, 0)}}</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Praticamente todos os objetos em JavaScript descendem de {{jsxref("Global_Objects/Object", "Object")}}; todos os métodos e propriedades herdados de <code>Object.prototype</code>, embora possam ser sobrescritos (exceto um <code>Objeto</code> com protótipo nulo, i.e. <code>Object.create(null)</code>). Por exemplo, outros protótipos construtores sobrescrevem a propriedade construtora e fornece seus próprios {{jsxref("Object.prototype.toString()", "toString()")}} métodos.</p>
+
+<p>Modificações no <code>Objeto protótipo</code> do objeto são propagadas a <strong>todos</strong> objetos através do encadeamento de protótipos, a menos que as propriedades e métodos  submetidos às mudanças sejam sobrescritos mais além no encadeamento dos protótipos. Este recurso oferece um mecânismo muito poderoso apesar de perigoso para <em>sobrescrita</em> e <em>extensão</em> de objetos.</p>
+
+<h2 id="Properties" name="Properties">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("Object.prototype.constructor")}}</dt>
+ <dd>Especifica a função que cria um objeto protótipo.</dd>
+ <dt>{{jsxref("Object.prototype.__proto__")}} {{non-standard_inline}}</dt>
+ <dd>Aponta para o objeto que foi usado como protótipo quando o objeto foi instanciado.</dd>
+ <dt>{{jsxref("Object.prototype.__noSuchMethod__")}} {{non-standard_inline}}</dt>
+ <dd>Permite definir uma função que será executada quando um membro indefinido do objeto for chamado como método.</dd>
+ <dt><s class="obsoleteElement">{{jsxref("Object.prototype.__count__")}} {{obsolete_inline}}</s></dt>
+ <dd><s class="obsoleteElement">Usado para retornar um número de propriedades enumeráveis diretamente num objeto definido pelo usuário, mas foi removida.</s></dd>
+ <dt><s class="obsoleteElement">{{jsxref("Object.prototype.__parent__")}} {{obsolete_inline}}</s></dt>
+ <dd><s class="obsoleteElement">Usado para apontar a um contexto do objeto, mas foi removida.</s></dd>
+</dl>
+
+<h2 id="Methods" name="Methods">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Object.prototype.__defineGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
+ <dd>Associa uma função com uma propriedade que, quando acessada, executa uma função e retorna seu valor de retorno.</dd>
+ <dt>{{jsxref("Object.prototype.__defineSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
+ <dd>Associa uma função com uma propriedade que, quando definida, executa uma função que modifica a propriedade.</dd>
+ <dt>{{jsxref("Object.prototype.__lookupGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
+ <dd>Retorna a função associada com a propriedade específicada pelo {{jsxref("Object.defineGetter", "__defineGetter__")}} método.</dd>
+ <dt>{{jsxref("Object.prototype.__lookupSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
+ <dd>Retorna a função associada com a propriedade especificada pelo {{jsxref("Object.defineSetter", "__defineSetter__")}} método.</dd>
+ <dt>{{jsxref("Object.prototype.hasOwnProperty()")}}</dt>
+ <dd>Retorna um boolean indicando se um objeto contém a propriedade especificada como uma propriedade direta de um objeto e não herdada através da cadeia de protótipo.</dd>
+ <dt>{{jsxref("Object.prototype.isPrototypeOf()")}}</dt>
+ <dd>Retorna uma indicação booleana se o objeto especificado está na cadeia de protótipo do objeto este método é chamado.</dd>
+ <dt>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</dt>
+ <dd>Retorna um boolean indicando se o atributo interno <a href="/en-US/docs/ECMAScript_DontEnum_attribute" title="ECMAScript_DontEnum_attribute">ECMAScript DontEnum attribute</a> está definido.</dd>
+ <dt>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</dt>
+ <dd>Retorna uma string contendo o código de um objeto literal representando o objeto que este método é  chamado; você pode usar este valor para criar um novo objeto.</dd>
+ <dt>{{jsxref("Object.prototype.toLocaleString()")}}</dt>
+ <dd>Chama {{jsxref("Object.toString", "toString()")}}.</dd>
+ <dt>{{jsxref("Object.prototype.toString()")}}</dt>
+ <dd>Retorna uma representação do objeto em forma de string.</dd>
+ <dt>{{jsxref("Object.prototype.unwatch()")}} {{non-standard_inline}}</dt>
+ <dd>Remove um ponto de escuta da propriedade do objeto.</dd>
+ <dt>{{jsxref("Object.prototype.valueOf()")}}</dt>
+ <dd>Retorna o valor primitivo do objeto especificado.</dd>
+ <dt>{{jsxref("Object.prototype.watch()")}} {{non-standard_inline}}</dt>
+ <dd>Adiciona um ponto de escuta à propriedade do objeto.</dd>
+ <dt><s class="obsoleteElement">{{jsxref("Object.prototype.eval()")}} {{obsolete_inline}}</s></dt>
+ <dd><s class="obsoleteElement">Usado para avaliar uma string de código JavaScript no contexto do objeto especificado, mas foi removido.</s></dd>
+</dl>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<p>Quando é alterado o comportamento de um método de um Objeto protótipo, considere injetar código envolvendo sua extensão antes ou depois ta lógica existente. Por exemplo, este (não testado) código irá pré-condicionalmente executar uma lógica personalizada antes da lógica embutida ou a extensão de alguém será executada.</p>
+
+<p>Quando uma função é chamada os argumentos para a chamada são segurados no array de argumentos como "variável". Por exemplo, na chamada "minhaFuncao(a, b, c)", os argumentos no corpo da minhaFuncao irão conter 3 elementos array correspondentes a (a, b, c). Quando modificamos os protótipos com ganchos, simplesmente passamos <em>this</em> &amp; a variável <em>arguments</em> (o estado de chamada) para o comportamento atual pela chamada <em>apply()</em> na função. Este padrão pode ser usado por qualquer protótipo, tal como <em>Node.prototype, Function.prototype, etc.</em></p>
+
+<pre><code>var current = Object.prototype.valueOf;
+
+// Desde que minha propriedade "-prop-value" é transversal e não está
+// sempre na mesma cadeia de protótipo, desejo modificar Object.prototype:
+Object.prototype.valueOf = function() {
+  if (this.hasOwnProperty("-prop-value") {
+    return this["-prop-value"];
+  } else {
+    // Isto não parece com um de meus objetos, então vamos retroceder ao
+    // comportamento padrão para reproduzir o comportamento atual o que
+    // pudermos. O <em>apply</em> se comporta como o<em>"super"</em> em outras linguagens.
+    // Mesmo que <em>valueOf()</em> não receba argumentos, alguns outros ganchos podem.
+    return current.apply(this, arguments);
+  }
+}</code></pre>
+
+<p>Desde que JavaScript não tem exatamente objetos de subclasse, protótipo é uma forma usual de trabalhar para fazer um objeto "classe base" de certas funções que agem como objetos. Por exemplo:</p>
+
+<pre class="brush: js">var Person = function() {
+  this.canTalk = true;
+  this.greet = function() {
+    if (this.canTalk) {
+      console.log('Hi, I\'m ' + this.name);
+    }
+  };
+};
+
+var Employee = function(name, title) {
+  this.name = name;
+  this.title = title;
+  this.greet = function() {
+    if (this.canTalk) {
+      console.log("Hi, I'm " + this.name + ", the " + this.title);
+    }
+  };
+};
+Employee.prototype = new Person();
+
+var Customer = function(name) {
+  this.name = name;
+};
+Customer.prototype = new Person();
+
+var Mime = function(name) {
+  this.name = name;
+  this.canTalk = false;
+};
+Mime.prototype = new Person();
+
+var bob = new Employee('Bob', 'Builder');
+var joe = new Customer('Joe');
+var rg = new Employee('Red Green', 'Handyman');
+var mike = new Customer('Mike');
+var mime = new Mime('Mime');
+bob.greet();
+joe.greet();
+rg.greet();
+mike.greet();
+mime.greet();
+</pre>
+
+<p>O retorno será:</p>
+
+<pre>Hi, I'm Bob, the Builder
+Hi, I'm Joe
+Hi, I'm Red Green, the Handyman
+Hi, I'm Mike
+</pre>
+
+<h2 id="Specifications" name="Specifications">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition. Implemented in JavaScript 1.0.</td>
+   <td>Padrão</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com Navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Aspecto</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Aspecto</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico.</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p> </p>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/seal/index.html b/files/pt-br/web/javascript/reference/global_objects/object/seal/index.html
new file mode 100644
index 0000000000..a3b6ffa66a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/seal/index.html
@@ -0,0 +1,173 @@
+---
+title: Object.seal()
+slug: Web/JavaScript/Reference/Global_Objects/Object/seal
+tags:
+  - objeto selar selado
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/seal
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.seal()</strong></code> 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).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.seal(<var>obj</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O Objeto que deve ser selado.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O Objeto sendo selado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Por padrão, objetos são {{jsxref("Object.isExtensible()", "extensible", "", 1)}} (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 {{jsxref("TypeError")}} (mais comumente, mas não exclusivamente, quando em modo rigoroso {{jsxref("Strict_mode", "strict mode", "", 1)}} de código).</p>
+
+<p>A cadeia de prototipação permanece intocada. Entretanto, a propriedade {{jsxref("Object.proto", "__proto__")}} {{deprecated_inline}} é selada também.</p>
+
+<p>Retorna a referência ao Objeto passado.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: 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
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5, se o argumento passado à este método não é um objeto (primitivo) , irá causar um erro {{jsxref("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</p>
+
+<pre class="brush: js">Object.seal(1);
+// TypeError: 1 não é um Objeto (código ES5)
+
+Object.seal(1);
+// 1                             (código ES6)
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.8', 'Object.seal')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado no Javascript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.seal', 'Object.seal')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.seal', 'Object.seal')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_em_Browsers">Compatibilidade em Browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("6")}}</td>
+   <td>{{CompatGeckoDesktop("2.0")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("12")}}</td>
+   <td>{{CompatSafari("5.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.isSealed()")}}</li>
+ <li>{{jsxref("Object.preventExtensions()")}}</li>
+ <li>{{jsxref("Object.isExtensible()")}}</li>
+ <li>{{jsxref("Object.freeze()")}}</li>
+ <li>{{jsxref("Object.isFrozen()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/setprototypeof/index.html b/files/pt-br/web/javascript/reference/global_objects/object/setprototypeof/index.html
new file mode 100644
index 0000000000..1a27cbd99e
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/setprototypeof/index.html
@@ -0,0 +1,249 @@
+---
+title: Object.setPrototypeOf()
+slug: Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Método(2)
+  - Objeto
+  - Prototype
+  - Protótipo(2)
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf
+---
+<p>{{JSRef}}</p>
+
+<p>O método <code><strong>Object.setPrototypeOf()</strong></code> configura o 'prototype' (i.e., a propriedade interna <code>[[Prototype]]</code>)  de um objeto específico para outro objeto ou {{jsxref("null")}}.</p>
+
+<div class="warning">
+<p><strong>Atenção:</strong> Mudar o <code>[[Prototype]]</code> de um objeto é, pela natureza de como os modernos mecanismos JavaScript otimizam os acessos de propriedade, uma operação muito lenta, em <strong><em>todos</em></strong> navegadores e mecanismos JavaScript. O efeito sobre o desempenho de alterar a herança são sutis e vastas e não se limitam simplesmente ao tempo gasto em <code>obj.__proto__ = ...</code> statement, mas pode estender a <strong><em>qualquer</em></strong> código que tem acesso a <strong><em>qualquer</em></strong> objeto cujo <code>[[Prototype]]</code> foi alterado. Se você se preocupa com desempenho, você deveria evitar configurar o <code>[[Prototype]]</code> de um objeto. Em vez disso, crie um novo objeto com o <code>[[Prototype]] desejado usando</code> {{jsxref("Object.create()")}}.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.setPrototypeOf(<var>obj</var>, <var>prototype</var>);</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto que deve ter seu 'prototype' definido.</dd>
+ <dt><code>prototype</code></dt>
+ <dd>O novo 'prototype' do objeto  (um objeto ou {{jsxref("null")}}).</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O objeto especificado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Gera uma exceção {{jsxref("TypeError")}} se o objeto cujo <code>[[Prototype]]</code> é para ser modificado não for extensível de acordo com {{jsxref("Object.isExtensible()")}}. Não faz nada se o parâmetro '<code>prototype'</code> não for um objeto ou {{jsxref("null")}} (ex., número, texto, boleano, ou {{jsxref("undefined")}}). Caso contrário, este método muda o <code>[[Prototype]]</code> do <code>obj</code> para um novo valor.</p>
+
+<p><code>Object.setPrototypeOf() é uma especificação</code> ECMAScript 2015. É geralmente considerada a maneira correta de definir o 'prototype' de um objeto, em relação à propriedade mais controversa {{jsxref("Object.prototype.__proto__")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">var dict = Object.setPrototypeOf({}, null);
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Usando a propriedade mais antiga {{jsxref("Object.prototype.__proto__")}}, nós podemos facilmente definir <code>Object.setPrototypeOf</code> se já não estiver disponível:</p>
+
+<pre class="brush: js">// Funciona somente no Chrome e FireFox, não funciona no IE:
+Object.setPrototypeOf = Object.setPrototypeOf || function(obj, proto) {
+  obj.__proto__ = proto;
+  return obj;
+}
+</pre>
+
+<h2 id="Adicionando_'Prototype'_em_cadeia">Adicionando 'Prototype' em cadeia</h2>
+
+<p>Uma combinação de <code>Object.getPrototypeOf() e</code> {{jsxref("Object.proto", "Object.prototype.__proto__")}} permite anexar toda uma cadeia de 'prototype' a um novo objeto 'prototype':</p>
+
+<pre class="brush: js">/**
+*** Object.appendChain(@object, @prototype)
+*
+* Acrescente o primeiro 'prototype' não nativo de uma cadeia a um novo 'prototype'.
+* Retorna @object (se for um valor primitivo, será transformado em um objeto).
+*
+*** Object.appendChain(@object [, "@arg_name_1", "@arg_name_2", "@arg_name_3", "..."], "@function_body")
+*** Object.appendChain(@object [, "@arg_name_1, @arg_name_2, @arg_name_3, ..."], "@function_body")
+*
+* Adicione o primeiro 'prototype' não nativo de uma cadeia ao objeto nativo Function.prototype, então anexar a nova função
+* Function(["@arg"(s)], "@function_body") àquela cadeia.
+* Retorna a função.
+*
+**/
+
+Object.appendChain = function(oChain, oProto) {
+  if (arguments.length &lt; 2) {
+    throw new TypeError('Object.appendChain - Argumentos insuficientes');
+  }
+  if (typeof oProto !== 'object' &amp;&amp; typeof oProto !== 'string') {
+    throw new TypeError('segundo argumento de Object.appendChain deve ser um objeto ou uma string');
+  }
+
+  var oNewProto = oProto,
+      oReturn = o2nd = oLast = oChain instanceof this ? oChain : new oChain.constructor(oChain);
+
+  for (var o1st = this.getPrototypeOf(o2nd);
+    o1st !== Object.prototype &amp;&amp; o1st !== Function.prototype;
+    o1st = this.getPrototypeOf(o2nd)
+  ) {
+    o2nd = o1st;
+  }
+
+  if (oProto.constructor === String) {
+    oNewProto = Function.prototype;
+    oReturn = Function.apply(null, Array.prototype.slice.call(arguments, 1));
+    this.setPrototypeOf(oReturn, oLast);
+  }
+
+  this.setPrototypeOf(o2nd, oNewProto);
+  return oReturn;
+}
+</pre>
+
+<h3 id="Exemplos_2">Exemplos</h3>
+
+<h4 id="Primeiro_exemplo_Adicionar_uma_cadeia_a_um_'prototype'.">Primeiro exemplo: Adicionar uma cadeia a um 'prototype'.</h4>
+
+<pre class="brush: js">function Mammal() {
+  this.isMammal = 'yes';
+}
+
+function MammalSpecies(sMammalSpecies) {
+  this.species = sMammalSpecies;
+}
+
+MammalSpecies.prototype = new Mammal();
+MammalSpecies.prototype.constructor = MammalSpecies;
+
+var oCat = new MammalSpecies('Felis');
+
+console.log(oCat.isMammal); // 'yes'
+
+function Animal() {
+  this.breathing = 'yes';
+}
+
+Object.appendChain(oCat, new Animal());
+
+console.log(oCat.breathing); // 'yes'
+</pre>
+
+<h4 id="Segundo_exemplo_Transformar_um_valor_primitivo_em_uma_instância_de_seu_construtor_e_anexar_sua_cadeia_a_um_'prototype'.">Segundo exemplo: Transformar um valor primitivo em uma instância de seu construtor e anexar sua cadeia a um 'prototype'.</h4>
+
+<pre class="brush: js">function MySymbol() {
+  this.isSymbol = 'yes';
+}
+
+var nPrime = 17;
+
+console.log(typeof nPrime); // 'number'
+
+var oPrime = Object.appendChain(nPrime, new MySymbol());
+
+console.log(oPrime); // '17'
+console.log(oPrime.isSymbol); // 'yes'
+console.log(typeof oPrime); // 'object'
+</pre>
+
+<h4 id="Terceiro_exemplo_Anexar_uma_cadeia_ao_objeto_Function.prototype_e_anexar_uma_nova_função_a_essa_cadeia.">Terceiro exemplo: Anexar uma cadeia ao objeto Function.prototype e anexar uma nova função a essa cadeia.</h4>
+
+<pre class="brush: js">function Person(sName) {
+  this.identity = sName;
+}
+
+var george = Object.appendChain(new Person('George'),
+                                'console.log("Hello guys!!");');
+
+console.log(george.identity); // 'George'
+george(); // 'Hello guys!!'
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-object.setprototypeof', 'Object.setProtoypeOf')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.setprototypeof', 'Object.setProtoypeOf')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Configuração</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("34")}}</td>
+   <td>{{CompatGeckoDesktop("31")}}</td>
+   <td>{{CompatIE("11")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<p> </p>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Configuração</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("31")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Reflect.setPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.getPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.prototype.__proto__")}} </li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/tolocalestring/index.html b/files/pt-br/web/javascript/reference/global_objects/object/tolocalestring/index.html
new file mode 100644
index 0000000000..4d857a21e4
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/tolocalestring/index.html
@@ -0,0 +1,115 @@
+---
+title: Object.prototype.toLocaleString()
+slug: Web/JavaScript/Reference/Global_Objects/Object/toLocaleString
+tags:
+  - JavaScript
+  - Method
+  - Object
+  - Objeto
+  - Prototipo
+  - Prototype
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/toLocaleString
+---
+<p>{{JSRef}}</p>
+
+<p>O método <code><strong>toLocaleString()</strong></code> retorna uma cadeia de caracteres (<em>string</em>) representando o objeto. Este método é feito para ser sobrescrito por objetos derivados para propósitos de localização específica.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-prototype-tolocalestring.html")}}</div>
+
+<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>obj</var>.toLocaleString()</pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma <em>string</em> representando o objeto.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>toLocaleString</code> do {{jsxref("Object")}} returna o resultado da chamada {{jsxref("Object.toString", "toString()")}}.</p>
+
+<p>Esta função é provida para dar aos objetos um método <code>toLocaleString</code> genérico, mesmo que nem todos os usem. Veja a lista abaixo.</p>
+
+<h3 id="Objetos_sobrescrevendo_toLocaleString">Objetos sobrescrevendo toLocaleString</h3>
+
+<ul>
+ <li>{{jsxref("Array")}}: {{jsxref("Array.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("Number")}}: {{jsxref("Number.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("Date")}}: {{jsxref("Date.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("TypedArray")}}: {{jsxref("TypedArray.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("BigInt")}}: {{jsxref("BigInt.prototype.toLocaleString()")}}</li>
+</ul>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Sobrescrita_do_Array_toLocaleString">Sobrescrita do Array toLocaleString()</h3>
+
+<p>Em objetos {{jsxref("Array")}}, {{jsxref("Array.toLocaleString", "toLocaleString()")}} pode ser usado para imprimir valores do arranjo como uma <em>string</em>, opcionalmente com identificadores de localização específicos (como símbolos monetários) atrelados a eles:</p>
+
+<p>Por exemplo:</p>
+
+<pre class="brush: js notranslate">const testArray = [4, 7, 10];
+
+let euroPrices = testArray.toLocaleString('fr', { style: 'currency', currency: 'EUR'});
+// "4,00 €,7,00 €,10,00 €"</pre>
+
+<h3 id="Sobrescrita_do_Date_toLocaleString">Sobrescrita do Date toLocaleString()</h3>
+
+<p>Em objetos {{jsxref("Date")}}, {{jsxref("Date.toLocaleString", "toLocaleString()")}} é usado para imprimir datas mais apropriadas para localizações específicas:</p>
+
+<p>Por exemplo:</p>
+
+<pre class="brush: js notranslate">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"</pre>
+
+<h3 id="Sobrescrita_de_Number_toLocaleString">Sobrescrita de Number toLocaleString()</h3>
+
+<p>Em objetos {{jsxref("Number")}}, {{jsxref("Number.toLocaleString", "toLocaleString()")}} é usado para imprimir números para localizações específicas, e.g. com os corretos separadores:</p>
+
+<p>Por exemplo:</p>
+
+<pre class="brush: js notranslate">const testNumber = 2901234564;
+// "2901234564"
+
+let deNumber = testNumber.toLocaleString('de');
+// "2.901.234.564"
+
+let frNumber = testNumber.toLocaleString('fr');
+// "2 901 234 564"</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.tolocalestring', 'Object.prototype.toLocaleString')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Object.toLocaleString")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/object/tosource/index.html
new file mode 100644
index 0000000000..e0a8edcaa5
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/tosource/index.html
@@ -0,0 +1,136 @@
+---
+title: Object.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Object/toSource
+tags:
+  - JavaScript
+  - Method
+  - Non-standard
+  - Não padronizado
+  - Object
+  - Objeto
+  - Obsoleto
+  - Prototipo
+  - Prototype
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/toSource
+---
+<div>{{JSRef}} {{obsolete_header}}</div>
+
+<p>O método <strong><code>toSource()</code></strong> retorna uma cadeia de caracteres (<em>string</em>) representando o código fonte do objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code>Object.toSource();
+<var>obj</var>.toSource();
+</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma <em>string</em> representando o código fonte do objeto.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>toSource()</code> retorna os seguintes valores:</p>
+
+<ul>
+ <li>Para o objeto embutido {{jsxref("Object")}}, <code>toSource()</code> retorna a seguinte <em>string</em> indicando que o código fonte não está disponível:
+
+  <pre class="brush: js notranslate">function Object() {
+    [native code]
+}
+</pre>
+ </li>
+ <li>Para instâncias de {{jsxref("Object")}}, <code>toSource()</code> returna a <em>string</em> representando o código fonte.</li>
+</ul>
+
+<p>Você pode chamar <code>toSource()</code> enquanto debuga para examinar os conteúdos de um objeto.</p>
+
+<h3 id="Sobrescrevendo_o_método_toSource">Sobrescrevendo o método <code>toSource()</code></h3>
+
+<p>É seguro para objetos sobrescreverem o método <code>toSource()</code>. Por exemplo:</p>
+
+<pre class="brush: js notranslate">function Person(name) {
+  this.name = name;
+}
+
+Person.prototype.toSource = function Person_toSource() {
+  return 'new Person(' + uneval(this.name) + ')';
+};
+
+console.log(new Person('Joe').toSource()); // ---&gt; new Person("Joe")
+</pre>
+
+<h3 id="Métodos_toSource_embutidos">Métodos <code>toSource()</code> embutidos</h3>
+
+<p>Cada tipo principal do JavaScript tem seu próprio método <code>toSource()</code>. Esses objetos são:</p>
+
+<ul>
+ <li>{{jsxref("Array.prototype.toSource()")}}  — objeto {{jsxref("Array")}}.</li>
+ <li>{{jsxref("Boolean.prototype.toSource()")}}  — objeto {{jsxref("Boolean")}}.</li>
+ <li>{{jsxref("Date.prototype.toSource()")}}  — objeto {{jsxref("Date")}}.</li>
+ <li>{{jsxref("Function.prototype.toSource()")}}  — objeto {{jsxref("Function")}}.</li>
+ <li>{{jsxref("Number.prototype.toSource()")}}  — objeto {{jsxref("Number")}}.</li>
+ <li>{{jsxref("RegExp.prototype.toSource()")}}  — objeto {{jsxref("RegExp")}}.</li>
+ <li>{{jsxref("String.prototype.toSource()")}}  — objeto {{jsxref("String")}}.</li>
+ <li>{{jsxref("Symbol.prototype.toSource()")}}  — objeto {{jsxref("Symbol")}}.</li>
+ <li><code>Math.toSource()</code> — Retorna a <em>string</em> "Math".</li>
+</ul>
+
+<h3 id="Limitações_em_objetos_cíclicos">Limitações em objetos cíclicos</h3>
+
+<p>Em case de objetos que contém referências para eles mesmos, e.g. uma lista ligada cíclica ou uma árvore que pode ser percorrida pelos dois sentidos, <code>toSource()</code> não irá recriar a auto-referência, como no Firefox 24. Por exemplo:</p>
+
+<pre class="brush: js notranslate">var obj1 = {};
+var obj2 = { a: obj1 };
+obj1.b = obj2;
+
+console.log('Cyclical: ' + (obj1.b.a == obj1));
+
+var objSource = obj1.toSource(); // retorna "({b:{a:{}}})"
+
+obj1 = eval(objSource);
+
+console.log('Cyclical: ' + (obj1.b.a == obj1));
+</pre>
+
+<p>Se uma estrutura cíclica é empregada e <code>toSource()</code> é necessário, o objeto deve prover uma sobrescrita para <code>toSource()</code>, ou usando a referência para um construtor ou provendo uma função anônima.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toSource">Usando <code>toSource()</code></h3>
+
+<p>O seguinte código define o tipo do objeto <code>Dog</code> e cria <code>theDog</code>, um objeto do tipo <code>Dog</code>:</p>
+
+<pre class="brush: js notranslate">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');
+</pre>
+
+<p>Chamando o método <code>toSource()</code> de <code>theDog</code> mostra o código fonte JavaScript que define o objeto:</p>
+
+<pre class="brush: js notranslate">theDog.toSource();
+// returns ({name:"Gabby", breed:"Lab", color:"chocolate", sex:"female"})
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não faz parte de nenhum padrão.</p>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nessa página é gerada de dados estruturados. Se você quiser contribuir a esses dados, por favor cheque <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data </a>e nos mande um pull request.</div>
+
+<p>{{Compat("javascript.builtins.Object.toSource")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/object/tostring/index.html
new file mode 100644
index 0000000000..1e1453778e
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/tostring/index.html
@@ -0,0 +1,163 @@
+---
+title: Object.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Object/toString
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/toString
+---
+<div>{{JSRef("Global_Objects", "Object")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>O método <code><strong>toString()</strong></code> retorna uma string representando o objeto.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>obj</var>.toString()</code></pre>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Todo objeto possui um método <code>toString()</code> 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 <code>toString()</code> é herdado de todo objeto descendente de  <code>Object</code>. Se e o método não é sobrescrito em um objeto personalizado, <code>toString()</code> retorna "[object <em>type</em>]", onde <code><em>type</em></code> é o tipo do objeto. O código a seguir ilustra isso:</p>
+
+<pre class="brush: js">var o = new Object();
+o.toString();           // retorna [object Object]
+</pre>
+
+<div class="note">
+<p><strong>Note:</strong> Starting in JavaScript 1.8.5 <code>toString()</code> called on {{jsxref("Global_Objects/null", "null")}} returns <code>[object <em>Null</em>]</code>, and {{jsxref("Global_Objects/undefined", "undefined")}} returns <code>[object <em>Undefined</em>]</code>, as defined in the 5th Edition of ECMAScript and a subsequent Errata. See {{anch("Example:_Using_toString_to_detect_object_type", "Using toString to detect object type")}}.</p>
+</div>
+
+<h2 id="Examples" name="Examples">Examples</h2>
+
+<h3 id="Example:_Overriding_the_default_toString_method" name="Example:_Overriding_the_default_toString_method">Exemplo: Sobrepondo o método inicial <code>toString</code> </h3>
+
+<p>Você pode criar uma função para ser chamada no lugar do método <code>toString()</code>. O método <code>toString()</code> não requer parâmetros e deve retornar uma string. O método <code>toString()</code> criado por você pode ter o valor que quiser, mas será mais útil se usar informações do objeto.</p>
+
+<p>O código abaixo define o objeto <code>Dog</code> e cria <code>theDog</code>, um objeto do tipo <code>Dog</code>:</p>
+
+<pre class="brush: 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');
+</pre>
+
+<p>Se você chamar o método <code>toString()</code> neste objeto, ele retornará o valor original herdado de {{jsxref("Global_Objects/Object", "Object")}}:</p>
+
+<pre class="brush: js">theDog.toString(); // returns [object Object]
+</pre>
+
+<p>O código abaixo cria e faz com que <code>dogToString()</code> sobrescreva o <code>toString()</code> original. Esta função gera uma string contendo <strong>name, breed, color, and sex</strong> do objeto, na forma de "<code>propriedade = valor;</code>".</p>
+
+<pre class="brush: js">Dog.prototype.toString = function dogToString() {
+  var ret = 'Dog ' + this.name + ' is a ' + this.sex + ' ' + this.color + ' ' + this.breed;
+  return ret;
+}
+</pre>
+
+<p>Usando este código, toda vez que <code>theDog</code> for usado em um texto (string), JavaScript automaticamente chamará a função <code>dogToString()</code>, a qual retornará:</p>
+
+<pre>Dog Gabby is a female chocolate Lab
+</pre>
+
+<h3 id="Example:_Using_toString_to_detect_object_type" name="Example:_Using_toString_to_detect_object_type">Exemplo: Usando <code>toString()</code> para detectar a classe do objeto</h3>
+
+<p><code>toString()</code> pode ser usado com qualquer objeto e permite que você pegue sua classe. Para usar <code>Object.prototype.toString()</code> com qualquer objeto, deverá chamar {{jsxref("Function.prototype.call()")}} ou {{jsxref("Function.prototype.apply()")}} nele, passando o objeto que quer inspecionar como o primeiro parâmetro, chamado <code>thisArg</code>.</p>
+
+<pre class="brush: 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]
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.4.2', 'Object.prototype.toString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Call on {{jsxref("Global_Objects/null", "null")}} returns <code>[object <em>Null</em>]</code>, and {{jsxref("Global_Objects/undefined", "undefined")}} returns <code>[object <em>Undefined</em>]</code></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.prototype.tostring', 'Object.prototype.toString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+ <li>{{jsxref("Object.prototype.valueOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/valueof/index.html b/files/pt-br/web/javascript/reference/global_objects/object/valueof/index.html
new file mode 100644
index 0000000000..a78642c377
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/valueof/index.html
@@ -0,0 +1,110 @@
+---
+title: Object.prototype.valueOf()
+slug: Web/JavaScript/Reference/Global_Objects/Object/valueOf
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/valueOf
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>valueOf()</strong></code> retorna o valor primitivo do objeto especificado.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-prototype-valueof.html")}}</div>
+
+<p class="hidden">A fonte desse exemplo interativo está armazenada em um repositório GitHub. Se você quiser de contrinuir para o projeto interativo de exemplos, por favor, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um pull request.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>object</var>.valueOf()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O valor primitivo do objeto especificado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>JavaScript chama o método <code>valueOf</code> para converter um objeto em um valor primitivo. Você raramente precisará chamar o método <code>valueOf</code> por ele mesmo; O JavaScript chamará ele automaticamente quando encontrar um objeto onde um valor primitivo for esperado.</p>
+
+<p>Por padrão, o método <code>valueOf</code> é herdado por cada objeto descendente de {{jsxref("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, <code>valueOf</code> retorna o próprio objeto.</p>
+
+<p>Você pode usar <code>valueOf</code> 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 <code>Object.prototype.valueOf()</code> para chamar um método customizado ao invés do método padrão  {{jsxref("Object")}}.</p>
+
+<h3 id="Sobrescrevendo_valueOf_para_objetos_customizados">Sobrescrevendo <code>valueOf</code> para objetos customizados</h3>
+
+<p>Você pode criar uma função para ser chamada no lougar do método padrão <code>valueOf</code>. Sua função não pode ter nenhum argumento.</p>
+
+<p>Suponha que você tem um tipo de objeto <code>MyNumberType</code> e você quer criar um método <code>valueOf</code> para ele. O código a seguir atribui uma função definida por usuário para o método <code>valueOf</code> desse objeto:</p>
+
+<pre class="brush: js">MyNumberType.prototype.valueOf = function() { return customPrimitiveValue; };</pre>
+
+<p>Com o código anterior no lugar, a qualquer hora um objeto do tipo <code>MyNumberType</code> é usado em um contexto onde deve ser representado como um valor primitivo, o JavaScript chama automaticamente a função definida no código anterior.</p>
+
+<p>Um método <code>valueOf</code> de um objeto é geralmente chamado pelo JavaScript, mas você pode chamá-lo se quiser da seguinte maneira:</p>
+
+<pre class="brush: js">myNumberType.valueOf()</pre>
+
+<div class="note">
+<p><strong>Nota:</strong> Objetos em contexto de string convertidos através do método {{jsxref("Object.toString", "toString()")}}, o que é diferente de objetos {{jsxref("String")}} convertendo para string primiriva utlizando <code>valueOf</code>. Todos os objetos têm uma conversão string, somente se "<code>[object <em>type</em>]</code>". Mas muitos objetos não convertem para number, boolean, or function.</p>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_valueOf">Usando <code>valueOf</code></h3>
+
+<pre class="brush: js">function MyNumberType(n) {
+    this.number = n;
+}
+
+MyNumberType.prototype.valueOf = function() {
+    return this.number;
+};
+
+var myObj = new MyNumberType(4);
+myObj + 3; // 7
+</pre>
+
+<h2 id="Espeficações">Espeficações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Cometário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.4.4', 'Object.prototype.valueOf')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.prototype.valueof', 'Object.prototype.valueOf')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.valueof', 'Object.prototype.valueOf')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_browser">Compatibilidade do browser</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nessa página é gerada à partidad de dados estruturados. Se você quiser contribuir para os dados, por favor, vá até <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie o pull request.</div>
+
+<p>{{Compat("javascript.builtins.Object.valueOf")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+ <li>{{jsxref("parseInt", "parseInt()")}}</li>
+ <li>{{jsxref("Symbol.toPrimitive")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/values/index.html b/files/pt-br/web/javascript/reference/global_objects/object/values/index.html
new file mode 100644
index 0000000000..a95e01a704
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/values/index.html
@@ -0,0 +1,139 @@
+---
+title: Object.values()
+slug: Web/JavaScript/Reference/Global_Objects/Object/values
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/values
+---
+<div>{{JSRef}} {{SeeCompatTable}}</div>
+
+<p>O método <code><strong>Object.values()</strong></code> retorna um array com os valores das propriedades de um dado objeto, na mesma ordem provida pelo {{jsxref("Statements/for...in", "for...in")}} laço (sendo a diferença que o laço for-in também enumera as propriedades na cadeia prototype).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Object.values(<var>obj</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto cujos valores das propriedades enumeradas serão retornados.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um array contendo os valores das propriedades enumeradas do dado objeto.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>Object.values()</code> retorna um array cujos elementos são os valores das propriedades enumeradas encontradas no objeto. A ordem das propriedades é a mesma que a dada pelo laço sobre os valores da propriedade do objeto manualmente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">var obj = { foo: "bar", baz: 42 };
+console.log(Object.values(obj)); // ['bar', 42]
+
+// array como objeto
+var obj = { 0: 'a', 1: 'b', 2: 'c' };
+console.log(Object.values(obj)); // ['a', 'b', 'c']
+
+// array como objeto com ordenação de chave aleatória
+var an_obj = { 100: 'a', 2: 'b', 7: 'c' };
+console.log(Object.values(an_obj)); // ['b', 'c', 'a']
+
+// getFoo é a propriedade a qual não é enumerável
+var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } });
+my_obj.foo = "bar";
+console.log(Object.values(my_obj)); // ['bar']
+
+// argumento não-objeto será coagido num objeto
+console.log(Object.values("foo")); // ['f', 'o', 'o']
+</pre>
+
+<h2 id="Biblioteca_de_Suporte">Biblioteca de Suporte</h2>
+
+<p><code><font face="Open Sans, Arial, sans-serif">Para adicionar compatibilidade ao suporte de  </font>Object.values</code> em ambientes antigos que nativamente não o suportam, você pode encontrar uma biblioteca de suporte nos repositórios <a href="https://github.com/tc39/proposal-object-values-entries">tc39/proposal-object-values-entries</a> ou no <a href="https://github.com/es-shims/Object.values">es-shims/Object.values</a>.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.values', 'Object.values')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Aspecto</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome(51.0)}} [1]</td>
+   <td>{{CompatGeckoDesktop(47)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}} [2]</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Aspecto</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome para Android</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(51.0)}} [1]</td>
+   <td>{{CompatGeckoMobile(47)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(51.0)}} [1]</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] Por trás de uma flag.</p>
+
+<p>[2] Ver <a href="https://bugs.webkit.org/show_bug.cgi?id=150131">bug 150131</a>.</p>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li>
+ <li>{{jsxref("Object.keys()")}}</li>
+ <li>{{jsxref("Object.entries()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</li>
+ <li>{{jsxref("Object.create()")}}</li>
+ <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
+</ul>