initial commit

5 files changed, 703 insertions, 0 deletions

diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/apply/index.html b/files/pt-br/web/javascript/reference/global_objects/reflect/apply/index.html
new file mode 100644
index 0000000000..08621fe798
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/reflect/apply/index.html
@@ -0,0 +1,143 @@
+---
+title: Reflect.apply()
+slug: Web/JavaScript/Reference/Global_Objects/Reflect/apply
+tags:
+  - ECMAScript6
+  - JavaScript
+  - Reflect
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/apply
+---
+<div>{{JSRef}}</div>
+
+<p>O método estático <code><strong>Reflect</strong></code><strong><code>.apply()</code></strong> chama uma função alvo com os argumentos especificados.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Reflect.apply(target, thisArgument, argumentsList)
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>target</dt>
+ <dd>Função que será chamada.</dd>
+ <dt>thisArgument</dt>
+ <dd>O valor de "<code>this"</code> que será usado pela function do target.</dd>
+ <dt>argumentsList</dt>
+ <dd>Um objeto do tipo array que especifica os argumentos com que o <em><code>target</code></em> deve ser chamado.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O resultado da função alvo chamada com o <code><strong>this</strong></code>  e argumentos especificados.</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<p>Um {{jsxref("TypeError")}}, se a função especificada no <em>target</em> não for invocável.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>No ES5, tipicamente é usado o método {{jsxref("Function.prototype.apply()")}} para chamar uma função com o valor de <code>this e argumentos</code> <font face="Consolas, Liberation Mono, Courier, monospace">fornecidos como um array</font> (ou um <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Indexed_collections#Working_with_array-like_objects">array-like object</a>).</p>
+
+<pre class="brush: js">Function.prototype.apply.call(Math.floor, undefined, [1.75]);</pre>
+
+<p>Com o <code>Reflect.apply</code> isso se torna menos verboso e mais fácil de entender.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Reflect.apply()">Usando <code>Reflect.apply()</code></h3>
+
+<pre class="brush: js">Reflect.apply(Math.floor, undefined, [1.75]);
+// 1;
+
+Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]);
+// "hello"
+
+Reflect.apply(RegExp.prototype.exec, /ab/, ["confabulation"]).index;
+// 4
+
+Reflect.apply("".charAt, "ponies", [3]);
+// "i"
+</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-reflect.apply', 'Reflect.apply')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-reflect.apply', 'Reflect.apply')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</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>49</td>
+   <td>{{CompatGeckoDesktop(42)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</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>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile(42)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Reflect")}}</li>
+ <li>{{jsxref("Function.prototype.apply()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/construct/index.html b/files/pt-br/web/javascript/reference/global_objects/reflect/construct/index.html
new file mode 100644
index 0000000000..dece94c79a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/reflect/construct/index.html
@@ -0,0 +1,151 @@
+---
+title: Reflect.construct()
+slug: Web/JavaScript/Reference/Global_Objects/Reflect/construct
+translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/construct
+---
+<div>{{JSRef}}</div>
+
+<p>The static <code><strong>Reflect</strong></code><strong><code>.construct()</code></strong> method acts like the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> operator</a>, but as a function. It is equivalent to calling <code>new target(...args)</code>. It gives also the added option to specify a different prototype.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/reflect-construct.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Reflect.construct(target, argumentsList[, newTarget])
+</pre>
+
+<h3 id="Parametros">Parametros</h3>
+
+<dl>
+ <dt><code>target</code></dt>
+ <dd>A função alvo à ser chamada.</dd>
+ <dt><code>argumentsList</code></dt>
+ <dd>Um objeto tipo array que especifica com quais argumentos <code>target</code> deveria ser chamada.</dd>
+ <dt><code>newTarget</code> {{optional_inline}}</dt>
+ <dd>O construtor de quem o protótipo deveria ser usado. Veja também o <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new.target">new.target</a></code> operador. Se <code>newTarget</code> não estiver presente, será <code>target</code>.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>A new instance of <code>target</code> (or <code>newTarget</code>, if present), initialized by <code>target</code> as a constructor with the given arguments.</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<p>A {{jsxref("TypeError")}}, if <code>target</code> or <code>newTarget</code> are not constructors.</p>
+
+<h2 id="Description">Description</h2>
+
+<p><code>Reflect.construct</code> allows you to invoke a constructor with a variable number of arguments (which would also be possible by using the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator">spread operator</a> combined with the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new operator</a>).</p>
+
+<pre class="brush: js">var obj = new Foo(...args);
+var obj = Reflect.construct(Foo, args);
+</pre>
+
+<p> </p>
+
+<h3 id="Reflect.construct()_vs_Object.create()"><code>Reflect.construct()</code> vs <code>Object.create()</code></h3>
+
+<p>Prior to the introduction of <code>Reflect</code>, objects could be constructed using an arbitrary combination of constructor and prototype by using <code>Object.create()</code>.</p>
+
+<pre class="brush: js">function OneClass() {
+    this.name = 'one';
+}
+
+function OtherClass() {
+    this.name = 'other';
+}
+
+// Calling this:
+var obj1 = Reflect.construct(OneClass, args, OtherClass);
+
+// ...has the same result as this:
+var obj2 = Object.create(OtherClass.prototype);
+OneClass.apply(obj2, args);
+
+console.log(obj1.name); // 'one'
+console.log(obj2.name); // 'one'
+
+console.log(obj1 instanceof OneClass); // false
+console.log(obj2 instanceof OneClass); // false
+
+console.log(obj1 instanceof OtherClass); // true
+console.log(obj2 instanceof OtherClass); // true
+</pre>
+
+<p>However, while the end result is the same, there is one important difference in the process. When using <code>Object.create()</code> and <code>Function.prototype.apply()</code>, the <code>new.target</code> operator will point to <code>undefined</code> within the function used as the constructor, since the <code>new</code> keyword is not being used to create the object.</p>
+
+<p>When invoking <code>Reflect.construct()</code>, on the other hand, the <code>new.target</code> operator will point to the <code>newTarget</code> parameter if supplied, or <code>target</code> if not.</p>
+
+<pre class="brush: js">function OneClass() {
+    console.log('OneClass');
+    console.log(new.target);
+}
+function OtherClass() {
+    console.log('OtherClass');
+    console.log(new.target);
+}
+
+var obj1 = Reflect.construct(OneClass, args);
+// Output:
+//     OneClass
+//     function OneClass { ... }
+
+var obj2 = Reflect.construct(OneClass, args, OtherClass);
+// Output:
+//     OneClass
+//     function OtherClass { ... }
+
+var obj3 = Object.create(OtherClass.prototype);
+OneClass.apply(obj3, args);
+// Output:
+//     OneClass
+//     undefined</pre>
+
+<p> </p>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Using_Reflect.construct()">Using <code>Reflect.construct()</code></h3>
+
+<pre class="brush: js">var d = Reflect.construct(Date, [1776, 6, 4]);
+d instanceof Date; // true
+d.getFullYear(); // 1776
+</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('ES2015', '#sec-reflect.construct', 'Reflect.construct')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-reflect.construct', 'Reflect.construct')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Reflect.construct")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Reflect")}}</li>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code></a></li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new.target">new.target</a></code></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/defineproperty/index.html b/files/pt-br/web/javascript/reference/global_objects/reflect/defineproperty/index.html
new file mode 100644
index 0000000000..c4b56f02ca
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/reflect/defineproperty/index.html
@@ -0,0 +1,97 @@
+---
+title: Reflect.defineProperty()
+slug: Web/JavaScript/Reference/Global_Objects/Reflect/defineProperty
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Referencia
+  - Reflect
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/defineProperty
+---
+<div>{{JSRef}}</div>
+
+<p>O método estático <code><strong>Reflect</strong></code><strong><code>.defineProperty()</code></strong> é como o {{jsxref("Object.defineProperty()")}}, mas retorna um {{jsxref("Boolean")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/reflect-defineproperty.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">Reflect.defineProperty(<var>target</var>, <var>propertyKey</var>, <var>attributes</var>)
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code><var>target</var></code></dt>
+ <dd>O objeto de destino onde será definida a propriedade.</dd>
+ <dt><code><var>propertyKey</var></code></dt>
+ <dd>O nome da propriedade a ser definida ou modificada.</dd>
+ <dt><code><var>attributes</var></code></dt>
+ <dd>Os atributos para a propriedade que está sendo definida ou modificada.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um {{jsxref("Boolean")}} indicando se a propriedade foi ou não definida com êxito.</p>
+
+<h3 id="Erros">Erros</h3>
+
+<p>Um {{jsxref("TypeError")}}, se <code><var>target</var></code> não for um {{jsxref("Object")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>Reflect.defineProperty</code> permite a adição precisa ou a modificação de uma propriedade em um objeto. Para mais detalhes veja o {{jsxref("Object.defineProperty")}}, que é semelhante.</p>
+
+<div class="blockIndicator note">
+<p><strong>Uma diferença fundamental:</strong> <code>Object.defineProperty</code> retorna o objeto ou lança um {{jsxref ("TypeError")}} se a propriedade não tiver sido definida com êxito. <code>Reflect.defineProperty</code>, no entanto, simplesmente retorna um {{jsxref ("Boolean")}} indicando se a propriedade foi ou não definida com êxito.</p>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Reflect.defineProperty">Usando <code>Reflect.defineProperty()</code></h3>
+
+<pre class="brush: js notranslate">let obj = {}
+Reflect.defineProperty(obj, 'x', {value: 7})  // true
+obj.x                                         // 7
+</pre>
+
+<h3 id="Verificando_se_a_definição_da_propriedade_foi_bem-sucedida">Verificando se a definição da propriedade foi bem-sucedida</h3>
+
+<p>Com o {{jsxref ("Object.defineProperty")}}, que retorna um objeto se for bem-sucedido ou lança um {{jsxref ("TypeError")}}, você usaria um bloco <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/try...catch">try...catch</a> para detectar qualquer erro que ocorreu ao definir uma propriedade.</p>
+
+<p>Como <code>Reflect.defineProperty</code> retorna um status de sucesso booleano, você pode usar apenas um bloco <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else">if...else</a></code> aqui:</p>
+
+<pre class="brush: js notranslate">if (Reflect.defineProperty(target, property, attributes)) {
+  // success
+} else {
+  // failure
+}</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-reflect.defineproperty', 'Reflect.defineProperty')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Reflect.defineProperty")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Reflect")}}</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/index.html b/files/pt-br/web/javascript/reference/global_objects/reflect/index.html
new file mode 100644
index 0000000000..e001709367
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/reflect/index.html
@@ -0,0 +1,166 @@
+---
+title: Reflect
+slug: Web/JavaScript/Reference/Global_Objects/Reflect
+tags:
+  - ECMAScript6
+  - JavaScript
+  - NeedsTranslation
+  - Overview
+  - Reflect
+  - TopicStub
+translation_of: Web/JavaScript/Reference/Global_Objects/Reflect
+---
+<div>{{JSRef}}</div>
+
+<p><strong>Reflect</strong> é um objeto nativo que provê métodos para operações JavaScript interceptáveis. Os métodos são os mesmos que o dos <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Proxy">manipuladores de Proxy</a>. <code>Reflect</code> não é um objeto de função, então não é construtível.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Ao contrário da maioria dos objetos globais, <code>Reflect</code> não é um construtor. Você não pode usá-lo com o <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/new">operador new</a> ou invocar o objeto <code>Reflect</code> como uma função. Todas as propriedades e métodos do <code>Reflect</code> são estáticos (igual o objeto {{jsxref("Math")}}).</p>
+
+<p>O objeto <code>Reflect</code> provê as seguintes funções estáticas as quais tem os mesmos nomes usados pelos métodos <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Proxy">manipuladores de Proxy</a>.</p>
+
+<p>Alguns deste métodos são também os mesmos correspondentes aos métodos em {{jsxref("Object")}}, embora eles tenham diferenças sutis entre eles.</p>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Reflect.apply()", "Reflect.apply(<var>target</var>, <var>thisArgument</var>, <var>argumentsList</var>)")}}</dt>
+ <dd>Chama uma função de destino com os argumentos, conforme especificado pelo parâmetro <em><code>argumentsList</code></em>. Veja também {{jsxref("Function.prototype.apply()")}}.</dd>
+ <dt>{{jsxref("Reflect.construct()", "Reflect.construct(<var>target</var>, <var>argumentsList</var>[, <var>newTarget</var>])")}}</dt>
+ <dd> O <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/new">operador new</a> como uma função. Equivalente a chamada <code>new target(...args)</code>. Também possui a opção de especificar um <code><em>prototype</em></code> diferente</dd>
+ <dt>{{jsxref("Reflect.defineProperty()", "Reflect.defineProperty(<var>target</var>, <var>propertyKey</var>, <var>attributes</var>)")}}</dt>
+ <dd>Similar ao {{jsxref("Object.defineProperty()")}}. Retorna um {{jsxref("Boolean")}} com o valor <code>true</code><em> se a propriedade foi definida com sucesso</em>.</dd>
+ <dt>{{jsxref("Reflect.deleteProperty()", "Reflect.deleteProperty(<var>target</var>, <var>propertyKey</var>)")}}</dt>
+ <dd>O <a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete">operador delete</a> como uma função. Equivalente a chamada <code>delete target[name]</code>.</dd>
+ <dt>{{jsxref("Reflect.get()")}}, "Reflect.get(<var>target</var>, <var>propertyKey</var>[, <var>receiver</var>])"}}</dt>
+ <dd>Uma função que retorna o valor da propriedade. Funciona como obter uma propriedade de um objeto (<code>target[propertyKey]</code>) como uma função.</dd>
+ <dt>{{jsxref("Reflect.getOwnPropertyDescriptor()", "Reflect.getOwnPropertyDescriptor(<var>target</var>, <var>propertyKey</var>)")}}</dt>
+ <dd>Similar ao {{jsxref("Object.getOwnPropertyDescriptor()")}}. Retorna um descritor de propriedade da propriedade dada se existir no objeto, {{jsxref ("undefined")}} caso contrário.</dd>
+ <dt>{{jsxref("Reflect.getPrototypeOf()", "Reflect.getPrototypeOf(<var>target</var>)")}}</dt>
+ <dd>Igual ao {{jsxref("Object.getPrototypeOf()")}}.</dd>
+ <dt>{{jsxref("Reflect.has()", "Reflect.has(<var>target, propertyKey</var>)")}}</dt>
+ <dd>O <a href="/en-US/docs/Web/JavaScript/Reference/Operators/in">operador in</a> como função. Retorna um {{jsxref("Boolean")}} indicando se existe uma propriedade própria ou herdada.</dd>
+ <dt>{{jsxref("Reflect.isExtensible()", "Reflect.isExtensible(<var>target</var>)")}}</dt>
+ <dd>Igual ao {{jsxref("Object.isExtensible()")}}. Returna um {{jsxref("Boolean")}} com o valor <code>true</code> se o destino (parâmetro target) for extensível.</dd>
+ <dt>{{jsxref("Reflect.ownKeys()", "Reflect.ownKeys(<var>target</var>)")}}</dt>
+ <dd>Retorna uma matriz das chaves de propriedade do próprio objeto de destino (não herdadas).</dd>
+ <dt>{{jsxref("Reflect.preventExtensions()", "Reflect.preventExtensions(<var>target</var>)")}}</dt>
+ <dd>Similar ao {{jsxref("Object.preventExtensions()")}}. Retorna um {{jsxref("Boolean")}} com o valor <code>true</code> se a atualização foi bem sucedida.</dd>
+ <dt>{{jsxref("Reflect.set()", "Reflect.set(<var>target</var>, <var>propertyKey</var>, <var>value</var>[, <var>receiver</var>])")}}</dt>
+ <dd>Uma função que atribui valores a propriedades. Retorna um {{jsxref ("Boolean")}} com o valor <code>true</code> se a atualização foi bem sucedida.</dd>
+ <dt>{{jsxref("Reflect.setPrototypeOf()", "Reflect.setPrototypeOf(<var>target</var>, <var>prototype</var>)")}}</dt>
+ <dd>Uma função que define o <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype">protótipo de um objeto</a>. Retorna um {{jsxref ("Boolean")}} com o valor <code>true</code> se a atualização foi bem sucedida.</dd>
+ <dt>
+ <h2 id="Exemplos">Exemplos</h2>
+
+ <h3 id="Verificando_se_um_objeto_contém_determinadas_propriedades">Verificando se um objeto contém determinadas propriedades</h3>
+
+ <pre class="brush: js notranslate">const duck = {
+  name: 'Maurice',
+  color: 'white',
+  greeting: function() {
+    console.log(`Quaaaack! My name is ${this.name}`);
+  }
+}
+
+Reflect.has(duck, 'color');
+// true
+Reflect.has(duck, 'haircut');
+// false</pre>
+
+ <h3 id="Retornando_as_próprias_chaves_do_objeto">Retornando as próprias chaves do objeto</h3>
+
+ <pre class="brush: js notranslate">Reflect.ownKeys(duck);
+// [ "name", "color", "greeting" ]</pre>
+
+ <h3 id="Adicionando_uma_nova_propriedade_ao_objeto">Adicionando uma nova propriedade ao objeto</h3>
+
+ <pre class="brush: js notranslate">Reflect.set(duck, 'eyes', 'black');
+// returns "true" if successful
+// "duck" now contains the property "eyes: 'black'"</pre>
+ </dt>
+</dl>
+
+<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('ES6', '#sec-reflect-object', 'Reflect')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição Inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-reflect-object', 'Reflect')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Reflect.enumerate foi removido.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("42")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</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>{{CompatChrome(49.0)}}</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{CompatGeckoMobile("42")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>The {{jsxref("Proxy")}} global object.</li>
+ <li>The {{jsxref("Proxy.handler", "handler")}} object.</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/set/index.html b/files/pt-br/web/javascript/reference/global_objects/reflect/set/index.html
new file mode 100644
index 0000000000..45022b89d1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/reflect/set/index.html
@@ -0,0 +1,146 @@
+---
+title: Reflect.set()
+slug: Web/JavaScript/Reference/Global_Objects/Reflect/set
+translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/set
+---
+<div>{{JSRef}}</div>
+
+<p>O método estático <code><strong>Reflect</strong></code><strong><code>.set()</code></strong> define uma propriedade em um objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Reflect.set(alvo, propriedade, valor[, receptor])
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>alvo</code></dt>
+ <dd>O objeto alvo onde a propriedade será definida.</dd>
+ <dt><code>propriedade</code></dt>
+ <dd>O nome da propriedade a ser definida.</dd>
+ <dt>valor</dt>
+ <dd>o valor a ser definido para a propriedade.</dd>
+ <dt>receptor</dt>
+ <dd>
+ <p>O valor do <code>this </code>fornecido para a chamada do alvo se um setter é encontrado.</p>
+ </dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Um {{jsxref("Boolean")}} indicando se a definicão da propriedade ocorreu com sucesso ou não.</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<p>Um {{jsxref("TypeError")}}, se o <code>alvo</code> não for um {{jsxref("Object")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>Reflect.set</code> permite que você defina uma propriedade em um objeto. Ele define a propriedade e is like the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors">property accessor</a> syntax as a function.</p>
+
+<h2 id="Examplos">Examplos</h2>
+
+<h3 id="Usando_Reflect.set()">Usando <code>Reflect.set()</code></h3>
+
+<pre class="brush: js">// Object
+var obj = {};
+Reflect.set(obj, "prop", "value"); // true
+obj.prop; // "value"
+
+// Array
+var arr = ["duck", "duck", "duck"];
+Reflect.set(arr, 2, "goose"); // true
+arr[2]; // "goose"
+
+// É possível truncar o array
+Reflect.set(arr, "length", 1); // true
+arr; // ["duck"];
+
+// Com apenas um argumento, propertKey e valor são undefined
+var obj = {};
+Reflect.set(obj); // true
+Reflect.getOwnPropertyDescriptor(obj, "undefined");
+// { value: undefined, writable: true, enumerable: true, configurable: true }
+</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('ES6', '#sec-reflect.set', 'Reflect.set')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-reflect.set', 'Reflect.set')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatilibidade_com_navegadores">Compatilibidade com 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>49</td>
+   <td>{{CompatGeckoDesktop(42)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</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>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile(42)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Reflect")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors">Property accessors</a></li>
+</ul>