diff options
Diffstat (limited to 'files/pt-br/web/javascript/reference/global_objects')
380 files changed, 52490 insertions, 0 deletions
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/@@iterator/index.html b/files/pt-br/web/javascript/reference/global_objects/array/@@iterator/index.html new file mode 100644 index 0000000000..4256678efd --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/@@iterator/index.html @@ -0,0 +1,122 @@ +--- +title: 'Array.prototype[@@iterator]()' +slug: Web/JavaScript/Reference/Global_Objects/Array/@@iterator +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@iterator +--- +<div>{{JSRef}}</div> + +<p>O valor inicial da propriedade <code><strong>@@iterator</strong></code> é o mesmo objeto função que o valor inicial da propriedade {{jsxref("Array.prototype.values()", "values()")}}.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>arr</var>[Symbol.iterator]()</code></pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Iteração_usando_laço_for...of">Iteração usando laço <code>for...of</code></h3> + +<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p']; +// seu navegador deve suportar laço for..of +// e variáveis de escopo let em laços for +for (let letter of arr) { + console.log(letter); +} +</pre> + +<h3 id="Iteração_alternativa">Iteração alternativa</h3> + +<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p']; +var eArr = arr[Symbol.iterator](); +console.log(eArr.next().value); // w +console.log(eArr.next().value); // y +console.log(eArr.next().value); // k +console.log(eArr.next().value); // o +console.log(eArr.next().value); // p +</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-array.prototype-@@iterator', 'Array.prototype[@@iterator]()')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype-@@iterator', 'Array.prototype[@@iterator]()')}}</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>Suporte básico</td> + <td>{{CompatChrome("38")}}</td> + <td>{{CompatGeckoDesktop("36")}} [1]</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("25")}}</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>Suporte básico</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("36")}} [1]</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("25")}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] A partir do Gecko 17 (Firefox 17 / Thunderbird 17 / SeaMonkey 2.14) até o Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2) a propriedade <code>iterator</code> era usada (<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=907077">bug 907077</a>), e a partir do Gecko 27 até o Gecko 35 o placeholder <code>"@@iterator"</code> era usado. No Gecko 36 (Firefox 36 / Thunderbird 36 / SeaMonkey 2.33), o <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Symbol">símbolo</a> <code>@@iterator</code> foi implementado (<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=918828">bug 918828</a>).</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.keys()")}}</li> + <li>{{jsxref("Array.prototype.entries()")}}</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> + <li>{{jsxref("Array.prototype.values()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/@@unscopables/index.html b/files/pt-br/web/javascript/reference/global_objects/array/@@unscopables/index.html new file mode 100644 index 0000000000..53805d6ada --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/@@unscopables/index.html @@ -0,0 +1,75 @@ +--- +title: 'Array.prototype[@@unscopables]' +slug: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables +tags: + - ES2015 + - JS + - Propriedade + - Prototipo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables +--- +<div>{{JSRef}}</div> + +<div>A propriedade de símbolo <code><strong>@@unscopable</strong></code> contém nomes de propriedades que não foram incluídos no padrão ECMAScript antes da versão ES2015. Essas propriedades são excluídas do statement bindings <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code>. </div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><var>arr</var>[Symbol.unscopables]</pre> + +<h2 id="Descrição">Descrição</h2> + +<p>As propriedades padrão de array que são excluídas dos bindings <code>with</code> são: copyWithin, entries, fill, find, findIndex, includes, keys, e values.</p> + +<p>Veja {{jsxref("Symbol.unscopables")}} para saber como definir <code>unscopables</code> para seus objetos.</p> + +<p>{{js_property_attributes(0,0,1)}}</p> + +<h2 id="Exemplos">Exemplos</h2> + +<p>O código a seguir funciona bem no ES5 e abaixo. No entanto, no ECMAScript 2015 e posterior, o método {{jsxref("Array.prototype.keys()")}} foi introduzido. Isso significa que dentro de ambientes <code>with</code>, as "keys" seriam agora o método e não a variável. É aqui que a propriedade de símbolo <code>@@unscopables</code> <code>Array.prototype[@@unscopables]</code> entra em ação e impede que alguns métodos do Array estejam sendo definidos na instrução <code>with</code>.</p> + +<pre class="brush: js">var keys = []; + +with (Array.prototype) { + keys.push('alguma coisa'); +} + +Object.keys(Array.prototype[Symbol.unscopables]); +// ["copyWithin", "entries", "fill", "find", "findIndex", +// "includes", "keys", "values"]</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('ES2015', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.@@unscopables")}}</p> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Symbol.unscopables")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/concat/index.html b/files/pt-br/web/javascript/reference/global_objects/array/concat/index.html new file mode 100644 index 0000000000..dc8fc20d38 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/concat/index.html @@ -0,0 +1,159 @@ +--- +title: Array.prototype.concat() +slug: Web/JavaScript/Reference/Global_Objects/Array/concat +translation_of: Web/JavaScript/Reference/Global_Objects/Array/concat +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>O método concat() retorna um novo array contendo todos os arrays ou valores passados como parâmetro</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>arr</em>.concat(<em>valor1</em>, <em>valor2</em>, ..., <em>valorN</em>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><font face="Courier New, Andale Mono, monospace"><span style="line-height: normal;">valorN</span></font></dt> + <dd>Arrays ou valores para concatenar (unir) ao array retornado.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p><strong>concat </strong>cria um novo array unindo todos os elementos que foram passados como parâmetro, na ordem dada, para cada argumento e seus elementos (se o elemento passado for um array).</p> + +<p><strong>concat </strong>não altera a si mesmo ou a qualquer um dos argumentos passados, apenas providencia um novo array contendo uma cópia de si mesmo e dos argumentos passados. Os elementos copiados são:</p> + +<ul> + <li>Referência aos objetos (e não o objeto): concat copia a referência aos objetos para o novo array. Tanto o original quanto a cópia apontam para o mesmo objeto. Ou seja, se o objeto foi modificado, tais mudanças serão visíveis no objeto original e no array.</li> +</ul> + +<ul> + <li>Strings e numbers (diferente dos objetos {{jsxref("Global_Objects/String", "String")}} e {{jsxref("Global_Objects/Number", "Number")}}): <code>concat</code> copia os valores de strings e numbers para o novo array. Qualquer alteração no novo array não refletirá no original, e vice versa.</li> +</ul> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Concatenating_two_arrays" name="Example:_Concatenating_two_arrays">Exemplo: Concatenando dois arrays</h3> + +<p>O código a seguir une dois arrays:</p> + +<pre class="brush: js">var alpha = ["a", "b", "c"]; +var numeric = [1, 2, 3]; + +// creates array ["a", "b", "c", 1, 2, 3]; alpha and numeric are unchanged +var alphaNumeric = alpha.concat(numeric); +</pre> + +<h3 id="Example:_Concatenating_three_arrays" name="Example:_Concatenating_three_arrays">Exemplo: Concatenando três arrays</h3> + +<p>O código a seguir une três arrays:</p> + +<pre class="brush: js">var num1 = [1, 2, 3]; +var num2 = [4, 5, 6]; +var num3 = [7, 8, 9]; + +// creates array [1, 2, 3, 4, 5, 6, 7, 8, 9]; num1, num2, num3 are unchanged +var nums = num1.concat(num2, num3); +</pre> + +<h3 id="Example:_Concatenating_values_to_an_array" name="Example:_Concatenating_values_to_an_array">Exemplo: Concatenando valores ao array</h3> + +<p>O código a seguir une três valores ao array</p> + +<pre class="brush: js">var alpha = ['a', 'b', 'c']; + +// creates array ["a", "b", "c", 1, 2, 3], leaving alpha unchanged +var alphaNumeric = alpha.concat(1, [2, 3]); +</pre> + +<h2 id="Especificação">Especificação</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 3rd Edition</td> + <td>Standard</td> + <td>Initial definition.<br> + Implemented in JavaScript 1.2</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.4', 'Array.prototype.concat')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.concat', 'Array.prototype.concat')}}</td> + <td>{{Spec2('ES6')}}</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>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>1.0</td> + <td>{{CompatGeckoDesktop("1.7")}}</td> + <td>5.5</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("Array.push", "push")}} / {{jsxref("Array.pop", "pop")}} - add/remove elements from the end of the array;</li> + <li>{{jsxref("Array.unshift", "unshift")}} / {{jsxref("Array.shift", "shift")}} - add/remove elements from the beginning of the array;</li> + <li>{{jsxref("Array.splice", "splice")}} - add/remove elements from the specified location of the array.</li> + <li>{{jsxref("String.prototype.concat")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/contains/index.html b/files/pt-br/web/javascript/reference/global_objects/array/contains/index.html new file mode 100644 index 0000000000..a0f794df1a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/contains/index.html @@ -0,0 +1,106 @@ +--- +title: Array.prototype.includes() +slug: Web/JavaScript/Reference/Global_Objects/Array/contains +tags: + - Array + - ECMAScript7 + - Experimental + - Expérimental(2) + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Array/includes +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Sumário">Sumário</h2> + +<p><span class="seoSummary">O método includes<code>()</code> determina se um array contém um determinado elemento, retornando <code>true</code> ou <code>false</code> apropriadamente.</span></p> + +<p><strong style="font-size: 2.14285714285714rem; font-weight: 700; letter-spacing: -1px; line-height: 30px;">Sintaxe</strong></p> + +<pre class="syntaxbox"><code><var>array</var>.includes(<var>searchElement</var>[, <var>fromIndex</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>searchElement</code></dt> + <dd>O elemento a buscar</dd> + <dt><code>fromIndex</code></dt> + <dd>Opcional. A posição no array de onde a busca pelo <code>searchElement </code>se iniciará. Por padrão, 0.</dd> +</dl> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js">[1, 2, 3].includes(2); // true +[1, 2, 3].includes(4); // false +[1, 2, 3].includes(3, 3); // false +[1, 2, 3].includes(3, -1); // true +[1, 2, NaN].includes(NaN); // true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">// https://tc39.github.io/ecma262/#sec-array.prototype.includes +if (!Array.prototype.includes) { + Object.defineProperty(Array.prototype, 'includes', { + value: function(searchElement, fromIndex) { + + // 1. Let O be ? ToObject(this value). + if (this == null) { + throw new TypeError('"this" is null or not defined'); + } + + var o = Object(this); + + // 2. Let len be ? ToLength(? Get(O, "length")). + var len = o.length >>> 0; + + // 3. If len is 0, return false. + if (len === 0) { + return false; + } + + // 4. Let n be ? ToInteger(fromIndex). + // (If fromIndex is undefined, this step produces the value 0.) + var n = fromIndex | 0; + + // 5. If n ≥ 0, then + // a. Let k be n. + // 6. Else n < 0, + // a. Let k be len + n. + // b. If k < 0, let k be 0. + var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0); + + // 7. Repeat, while k < len + while (k < len) { + // a. Let elementK be the result of ? Get(O, ! ToString(k)). + // b. If SameValueZero(searchElement, elementK) is true, return true. + // c. Increase k by 1. + // NOTE: === provides the correct "SameValueZero" comparison needed here. + if (o[k] === searchElement) { + return true; + } + k++; + } + + // 8. Return false + return false; + } + }); +} +</pre> + +<h2 id="Especificações">Especificações</h2> + +<p>Proposta ES7: <a href="https://github.com/domenic/Array.prototype.contains/blob/master/spec.md">https://github.com/domenic/Array.prototype.contains/blob/master/spec.md</a></p> + +<h2 id="Compatibilidade">Compatibilidade</h2> + +<div>{{Compat("javascript.builtins.Array.includes")}}</div> + +<h2 id="Veja_Também">Veja Também</h2> + +<ul> + <li>{{jsxref("TypedArray.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/copywithin/index.html b/files/pt-br/web/javascript/reference/global_objects/array/copywithin/index.html new file mode 100644 index 0000000000..4802e87b94 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/copywithin/index.html @@ -0,0 +1,203 @@ +--- +title: Array.prototype.copyWithin() +slug: Web/JavaScript/Reference/Global_Objects/Array/copyWithin +translation_of: Web/JavaScript/Reference/Global_Objects/Array/copyWithin +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>copyWithin()</strong></code> copia parte de um array para outra localização dentro deste mesmo array e o retorna, sem alterar seu tamanho. </p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>arr</var>.copyWithin(<var>target</var>, <var>start</var>[, <var>end</var> = this.length])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>target</code></dt> + <dd>Posição para a qual os elementos serão copiados. Caso negativo, o <code>target</code> será contado a partir do final.</dd> + <dt><code>start</code></dt> + <dd>Índice inicial de onde se copiará os elementos. Caso negativo, o <code>start</code> será contado a partir do final.</dd> + <dt><code>end </code>{{optional_inline}}</dt> + <dd>Índice final de onde se copiará os elementos. Caso negativo, o <code>end</code> será contado a partir do final.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Os argumentos <code>target</code>, <code>start</code> e <code>end</code> são restritos a {{jsxref("Number")}} e truncados para valores inteiros.</p> + +<p>Se <code>start</code> for negativo, ele é tratado como <code>length+start</code>, onde <code>length</code> é o comprimento do array. Se <code>end</code> for negativo, ele é tratado como <code>length+end</code>.</p> + +<p>A função <code>copyWithin</code> é intencionalmente <em>genérica</em>, não requer que seu valor <code>this</code> seja um objeto {{jsxref("Array")}} e, adicionalmente, <code>copyWithin</code> é um <em>método mutável</em>, irá mudar o próprio objeto <code>this</code> e retorná-lo, não apenas retornar uma cópia dele.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js">[1, 2, 3, 4, 5].copyWithin(0, 3); +// [4, 5, 3, 4, 5] + +[1, 2, 3, 4, 5].copyWithin(0, 3, 4); +// [4, 2, 3, 4, 5] + +[1, 2, 3, 4, 5].copyWithin(0, -2, -1); +// [4, 2, 3, 4, 5] + +[].copyWithin.call({length: 5, 3: 1}, 0, 3); +// {0: 1, 3: 1, length: 5} + +// Typed Arrays do ES6 são subclasses de Array +var i32a = new Int32Array([1, 2, 3, 4, 5]); + +i32a.copyWithin(0, 2); +// Int32Array [3, 4, 5, 4, 5] + +// Em plataformas que ainda não são compatíveis com ES6: +[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4); +// Int32Array [4, 2, 3, 4, 5] +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (!Array.prototype.copyWithin) { + Array.prototype.copyWithin = function(target, start/*, end*/) { + // Passos 1-2. + if (this == null) { + throw new TypeError('this é null ou não definido'); + } + + var O = Object(this); + + // Passos 3-5. + var len = O.length >>> 0; + + // Passos 6-8. + var relativeTarget = target >> 0; + + var to = relativeTarget < 0 ? + Math.max(len + relativeTarget, 0) : + Math.min(relativeTarget, len); + + // Passos 9-11. + var relativeStart = start >> 0; + + var from = relativeStart < 0 ? + Math.max(len + relativeStart, 0) : + Math.min(relativeStart, len); + + // Passos 12-14. + var end = arguments[2]; + var relativeEnd = end === undefined ? len : end >> 0; + + var final = relativeEnd < 0 ? + Math.max(len + relativeEnd, 0) : + Math.min(relativeEnd, len); + + // Passo 15. + var count = Math.min(final - from, len - to); + + // Passos 16-17. + var direction = 1; + + if (from < to && to < (from + count)) { + direction = -1; + from += count - 1; + to += count - 1; + } + + // Passo 18. + while (count > 0) { + if (from in O) { + O[to] = O[from]; + } else { + delete O[to]; + } + + from += direction; + to += direction; + count--; + } + + // Passo 19. + return O; + }; +} +</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-array.prototype.copyWithin', 'Array.prototype.copyWithin')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.copyWithin', 'Array.prototype.copyWithin')}}</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>Suporte básico</td> + <td>{{CompatChrome("45")}}</td> + <td>{{CompatGeckoDesktop("32")}}</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>Suporte básico</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("32")}}</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("Array")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/entries/index.html b/files/pt-br/web/javascript/reference/global_objects/array/entries/index.html new file mode 100644 index 0000000000..8abb0cf088 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/entries/index.html @@ -0,0 +1,117 @@ +--- +title: Array.prototype.entries() +slug: Web/JavaScript/Reference/Global_Objects/Array/entries +translation_of: Web/JavaScript/Reference/Global_Objects/Array/entries +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>entries()</strong></code> retorna um novo objeto <code><strong>Array Iterator</strong></code> que contém os pares chave/valor para cada índice no array.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>arr</var>.entries()</code></pre> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush:js">var arr = ['a', 'b', 'c']; +var eArr = arr.entries(); + +console.log(eArr.next().value); // [0, 'a'] +console.log(eArr.next().value); // [1, 'b'] +console.log(eArr.next().value); // [2, 'c'] +</pre> + +<h3 id="O_mesmo_que_acima_utilizando_um_loop_for…of">O mesmo que acima, utilizando um loop <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Statements/for...of">for…of</a></h3> + +<pre class="brush:js">var arr = ['a', 'b', 'c']; +var eArr = arr.entries(); + +for (let e of eArr) { + console.log(e); +} +// [0, 'a'] +// [1, 'b'] +// [2, 'c']</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-array.prototype.entries', 'Array.prototype.entries')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.entries', 'Array.prototype.entries')}}</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>Suporte básico</td> + <td>{{CompatChrome("38")}}</td> + <td>{{CompatGeckoDesktop("28")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("25")}}</td> + <td>{{CompatSafari("7.1")}}</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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("28")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8.0</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.keys()")}}</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/every/index.html b/files/pt-br/web/javascript/reference/global_objects/array/every/index.html new file mode 100644 index 0000000000..a7d290e58a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/every/index.html @@ -0,0 +1,176 @@ +--- +title: Array.prototype.every() +slug: Web/JavaScript/Reference/Global_Objects/Array/every +tags: + - Array + - JavaScript + - Método(2) + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/every +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>every() </strong>testa se todos os elementos do array passam pelo teste implementado pela função fornecida.</code></p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>arr</var>.every(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Função que testa cada elemento, recebe três parametros: + <dl> + <dt><code>currentValue</code> (obrigatório)</dt> + <dd>O elemento atual sendo processado na array. </dd> + <dt><code>index</code> (opcional)</dt> + <dd>O índice do elemento atual sendo processado na array.</dd> + <dt><code>array</code> (opcional)</dt> + <dd>O array de origem.</dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Opcional. Valor a ser usado como <code>this</code> quando o <code>callback</code> é executado.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p><strong>true</strong> se a função de callback retorna um valor {{Glossary("truthy")}} para cada um dos elementos do array; caso contrário, <strong>false</strong>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>every </code>executa a função <code>callback </code>fornecida uma vez para cada elemento presente no array, até encontrar algum elemento em que a função retorne um valor false (valor que se torna false quando convertido para boolean). Se esse elemento é encontrado, o método <code>every </code>imediatamente retorna false. Caso contrário, se a função <code>callback </code>retornar true para todos elementos, o método retorna true. A função <code>callback</code> é chamada apenas para os elementos do array original que tiverem valores atribuídos; os elementos que tiverem sido removidos ou os que nunca tiveram valores atribuídos não serão considerados.</p> + +<p>A função <code>callback</code> é chamada com três argumentos: o valor do elemento corrente, o índice do elemento corrente e o array original que está sendo percorrido.</p> + +<p>Se o parâmetro <code>thisArg</code> foi passado para o método <code>every</code>, ele será repassado para a função <code>callback</code> no momento da chamada para ser utilizado como o <code>this</code>. Caso contrário, o valor <code>undefined </code>será repassado para uso como o <em><code>this</code></em>. O valor do <code>this</code> a ser repassado para o <code>callback</code> é determinado de acordo com as <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/this">regras usuais para determinar o this visto por uma função</a>.</p> + +<p>O método <code>every </code>não modifica o array original.</p> + +<p>A lista de elementos que serão processados pelo <font face="Consolas, Liberation Mono, Courier, monospace"><code>every</code> </font>é montada antes da primeira chamada da função <code>callback</code>. Se um elemento for acrescentado ao array original após a chamada ao <code>every</code> , ele não será visível para o callback. Se os elementos existentes forem modificados, os valores que serão repassados serão os do momento em que o método <code>every</code> chamar o <code>callback</code>. Elementos removidos não serão considerados.</p> + +<p><code>every</code> funciona como o qualificador "for all" em matemática. Particularmente, para um vetor vazio, é retornado true. (<a href="https://pt.wikipedia.org/wiki/Verdade_por_vacuidade">É verdade por vacuidade</a> que todos os elementos do <a href="https://pt.wikipedia.org/wiki/Conjunto_vazio">conjunto vazio</a> satisfazem qualquer condição.)</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Testando_tamanho_de_todos_os_elementos_do_vetor">Testando tamanho de todos os elementos do vetor</h3> + +<p>O exemplo a seguir testa se todos elementos no array são maiores que 10.</p> + +<pre class="brush: js">function isBigEnough(element, index, array) { + return element >= 10; +} +[12, 5, 8, 130, 44].every(isBigEnough); // false +[12, 54, 18, 130, 44].every(isBigEnough); // true +</pre> + +<h3 id="Usando_arrow_functions">Usando arrow functions</h3> + +<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Arrow functions</a> fornecem sintaxe mais curta para o mesmo teste. </p> + +<pre class="brush: js">[12, 5, 8, 130, 44].every(elem => elem >= 10); // false +[12, 54, 18, 130, 44].every(elem => elem >= 10); // true</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>every</code> foi adicionado ao padrão ECMA-262 na 5ª edição; como tal, pode não estar presente em outras implementações do padrão. Você pode contornar isso adicionando o seguinte código no começo dos seus scripts, permitindo o uso de every em implementações que não o suportam nativamente. Esse algoritimo é exatamente o mesmo especificado no ECMA-262, 5ª edição, assumindo que <code>Object e<font face="Open Sans, arial, x-locale-body, sans-serif"> </font></code><code>TypeError tem os seus valores originais e que</code> <code>callbackfn.call retorna o valor original de </code>{{jsxref("Function.prototype.call")}}</p> + +<pre class="brush: js">if (!Array.prototype.every) { + Array.prototype.every = function(callbackfn, thisArg) { + 'use strict'; + var T, k; + + if (this == null) { + throw new TypeError('this is null or not defined'); + } + + // 1. Let O be the result of calling ToObject passing the this + // value as the argument. + var O = Object(this); + + // 2. Let lenValue be the result of calling the Get internal method + // of O with the argument "length". + // 3. Let len be ToUint32(lenValue). + var len = O.length >>> 0; + + // 4. If IsCallable(callbackfn) is false, throw a TypeError exception. + if (typeof callbackfn !== 'function') { + throw new TypeError(); + } + + // 5. If thisArg was supplied, let T be thisArg; else let T be undefined. + if (arguments.length > 1) { + T = thisArg; + } + + // 6. Let k be 0. + k = 0; + + // 7. Repeat, while k < len + while (k < len) { + + var kValue; + + // a. Let Pk be ToString(k). + // This is implicit for LHS operands of the in operator + // b. Let kPresent be the result of calling the HasProperty internal + // method of O with argument Pk. + // This step can be combined with c + // c. If kPresent is true, then + if (k in O) { + + // i. Let kValue be the result of calling the Get internal method + // of O with argument Pk. + kValue = O[k]; + + // ii. Let testResult be the result of calling the Call internal method + // of callbackfn with T as the this value and argument list + // containing kValue, k, and O. + var testResult = callbackfn.call(T, kValue, k, O); + + // iii. If ToBoolean(testResult) is false, return false. + if (!testResult) { + return false; + } + } + k++; + } + return true; + }; +} +</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.4.4.16', 'Array.prototype.every')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definição inicial. Implementada no JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.every', 'Array.prototype.every')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_em_navegadores">Compatibilidade em navegadores</h2> + +<div>{{Compat("javascript.builtins.Array.every")}}</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> + <li>{{jsxref("TypedArray.prototype.every()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/fill/index.html b/files/pt-br/web/javascript/reference/global_objects/array/fill/index.html new file mode 100644 index 0000000000..8957bf3023 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/fill/index.html @@ -0,0 +1,125 @@ +--- +title: Array.prototype.fill() +slug: Web/JavaScript/Reference/Global_Objects/Array/fill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>fill()</strong></code> preenche todos os valores do array a partir do índice inicial a um índice final com um valor estático.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>arr</var>.fill(<var>valor</var>[, <var>ínicio<var> = 0[, <var>fim</var> = this.length]])</var></var></code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code><var>valor</var></code></dt> + <dd>Valor para preencher o array.</dd> + <dt><code><var>ínicio</var></code></dt> + <dd>Opcional. Índice inicial.</dd> + <dt><code><var><var><var>fim</var></var></var></code></dt> + <dd>Opcional. Índice final.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>O intervalo de preenchimento dos elementos é [<code>início</code>, <code>fim</code>).</p> + +<p>O método <strong><code>fill</code></strong> pode receber até três argumentos <code>valor</code>, <code>ínicio</code> e <code>fim</code>. Os argumentos <code>ínicio</code> e <code>fim</code> são opcionais com valor padrão <code>0 (valor) </code>e o tamanho do objeto <code>(fim)</code>.</p> + +<p>Se o <code>ínicio</code> for negativo, ele será tratado como <code>tamanho + ínicio</code> onde <code>tamanho é o tamanho total do array</code>. Se o <code>fim</code> for negativo, ele será tratado como <code>tamanho + fim</code>.</p> + +<p>A função <strong>fill</strong> é intencionalmente genérica, ele não precisa que o valor do this seja um objeto Array.</p> + +<p>O método <strong>fill</strong> é um método mutável, ele irá mudar o objeto em si, e retorná-lo, não somente uma cópia do objeto.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js">[1, 2, 3].fill(4); // [4, 4, 4] +[1, 2, 3].fill(4, 1); // [1, 4, 4] +[1, 2, 3].fill(4, 1, 2); // [1, 4, 3] +[1, 2, 3].fill(4, 1, 1); // [1, 2, 3] +[1, 2, 3].fill(4, -3, -2); // [4, 2, 3] +[1, 2, 3].fill(4, NaN, NaN); // [1, 2, 3] +Array(3).fill(4); // [4, 4, 4] +[].fill.call({ length: 3 }, 4); // {0: 4, 1: 4, 2: 4, length: 3} +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (!Array.prototype.fill) { + Array.prototype.fill = function(value) { + + // Passo 1-2. + if (this == null) { + throw new TypeError('this is null or not defined'); + } + + var O = Object(this); + + // Passo 3-5. + var len = O.length >>> 0; + + // Passo 6-7. + var start = arguments[1]; + var relativeStart = start >> 0; + + // Passo 8. + var k = relativeStart < 0 ? + Math.max(len + relativeStart, 0) : + Math.min(relativeStart, len); + + // Passo 9-10. + var end = arguments[2]; + var relativeEnd = end === undefined ? + len : end >> 0; + + // Passo 11. + var final = relativeEnd < 0 ? + Math.max(len + relativeEnd, 0) : + Math.min(relativeEnd, len); + + // Passo 12. + while (k < final) { + O[k] = value; + k++; + } + + // Passo 13. + return O; + }; +} +</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-array.prototype.fill', 'Array.prototype.fill')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2> + +<div>{{Compat("javascript.builtins.Array.fill")}}</div> + +<div id="compat-desktop"></div> + +<p>[1] Começando com Chrome 36, isto era disponível com uma mudança nas preferencias. Em chrome://flags, ativar a entrada “Enable Experimental JavaScript”.</p> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("TypedArray.prototype.fill()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/filtro/index.html b/files/pt-br/web/javascript/reference/global_objects/array/filtro/index.html new file mode 100644 index 0000000000..c7b0c08915 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/filtro/index.html @@ -0,0 +1,227 @@ +--- +title: Array.prototype.filter() +slug: Web/JavaScript/Reference/Global_Objects/Array/filtro +tags: + - Array + - ECMAScript 5 + - JavaScript + - Prototype + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>filter()</strong></code> cria um novo array com todos os elementos que passaram no teste implementado pela função fornecida.</p> + +<pre class="brush: js">function isBigEnough(value) { + return value >= 10; +} + +var filtered = [12, 5, 8, 130, 44].filter(isBigEnough); +// filtrado é [12, 130, 44] +</pre> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>var newArray = arr</var>.filter(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Função é um predicado, para testar cada elemento do array. Retorna <code>true</code> para manter o elemento, <code>false</code> caso contrário, recebendo três argumentos:</dd> + <dd> + <dl> + <dt><code>element</code></dt> + <dd> + <p>O elemento que está sendo processado no array.</p> + </dd> + <dt><code>index</code></dt> + <dd>O índice do elemento atual que está sendo processado no array.</dd> + <dt><code>array</code></dt> + <dd>O array para qual <code>filter</code> foi chamada.</dd> + </dl> + </dd> + <dt><code>thisArg {{Optional_inline}}</code></dt> + <dd>Opcional. Valor a ser usado como <code>this</code> durante a execução do <code>callback</code>.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Um novo array com os elementos que passaram no teste.</p> + +<h2 id="Descrição">Descrição</h2> + +<p><code>filter()</code> chama a função callback fornecida, uma vez para cada elemento do array, e constrói um novo array com todos os valores para os quais o <code>callback</code> retornou o valor <code>true</code> ou <a href="/en-US/docs/Glossary/Truthy">um valor que seja convertido para true</a>. O <code>callback</code> é chamado apenas para índices do array que possuem valores atribuídos; Ele não é invocado para índices que foram excluídos ou para aqueles que não tiveram valor atribuído. Elementos do array que não passaram no teste do <code>callback</code> são simplesmente ignorados, e não são incluídos no novo array.</p> + +<p><code>callback</code> é invocado com estes três argumentos:</p> + +<ol> + <li>o valor do elemento</li> + <li>o índice do elemento</li> + <li>o objeto do array a ser preenchido</li> +</ol> + +<p>Se o parâmetro <code>thisArg</code> for provido para o filter, ele será passado para o callback<code> quando invocado</code>, para ser usado como o valor do this. Caso contrário, será passado <code>undefined</code> como o valor de <code>this</code>. O valor do <code>this</code> finalmente observado pela função de <code>callback</code> é determinado de acordo com <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">a regra que define o valor do <code>this</code> geralmente visto por uma função</a>.</p> + +<p><code>filter()</code> não altera o <code>array</code> a partir da qual foi invocado.</p> + +<p>O intervalo de elementos processados pela função <code>filter()</code> é definido antes da invocação do primeiro callback. Elementos que forem adicionados ao array depois da invocação do <code>filter()</code> não serão visitados pelo <code>callback</code>. Se elementos existentes no array forem alterados ou deletados, os valores deles que serão passados para o callback são os que eles tiverem quando o <code>filter()</code> visitá-los; Elementos que forem deletados não são visitados.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Exemplo_Filtrando_todos_os_valores_pequenos">Exemplo: Filtrando todos os valores pequenos</h3> + +<p>Os exemplos a seguir usam <code>filter()</code> para criar um <code>array</code> filtrado em que todos os elementos com valores menores que 10 são removidos.</p> + +<pre class="brush: js">function isBigEnough(value) { + return value >= 10; +} +var filtered = [12, 5, 8, 130, 44].filter(isBigEnough); +// filtered is [12, 130, 44] +</pre> + +<h3 id="Exemplo_Filtrando_entradas_inválidas_para_JSON">Exemplo: Filtrando entradas inválidas para JSON</h3> + +<p>O exemplo a seguir usa <code>filter()</code> para criar um <code>JSON</code> filtrado com todos seus elementos diferentes de zero, e <code>id</code> numérico.</p> + +<pre class="brush: js">var arr = [ + { id: 15 }, + { id: -1 }, + { id: 0 }, + { id: 3 }, + { id: 12.2 }, + { }, + { id: null }, + { id: NaN }, + { id: 'undefined' } +]; + +var invalidEntries = 0; + +function filterByID(obj) { + if ('id' in obj && typeof(obj.id) === 'number' && !isNaN(obj.id)) { + return true; + } else { + invalidEntries++; + return false; + } +} + +var arrByID = arr.filter(filterByID); + +console.log('Filtered Array\n', arrByID); +// [{ id: 15 }, { id: -1 }, { id: 0 }, { id: 3 }, { id: 12.2 }] + +console.log('Number of Invalid Entries = ', invalidEntries); +// Number of Invalid Entries = 4 +</pre> + +<h3 id="Procurando_em_um_array">Procurando em um array</h3> + +<p>O exemplo a seguir usa <code>filter()</code> para filtrar o conteúdo de um array baseado em um critério de busca</p> + +<pre class="brush: js">var fruits = ['apple', 'banana', 'grapes', 'mango', 'orange']; + +/** + * Array filters items based on search criteria (query) + */ +function filterItems(query) { + return fruits.filter(function(el) { + return el.toLowerCase().indexOf(query.toLowerCase()) > -1; + }) +} + +console.log(filterItems('ap')); // ['apple', 'grapes'] +console.log(filterItems('an')); // ['banana', 'mango', 'orange']</pre> + +<h3 id="Implementação_ES2015">Implementação ES2015</h3> + +<pre class="brush: js">const fruits = ['apple', 'banana', 'grapes', 'mango', 'orange']; + +/** + * Array filters items based on search criteria (query) + */ +const filterItems = (query) => { + return fruits.filter(el => el.toLowerCase().indexOf(query.toLowerCase()) > -1); +}; + +console.log(filterItems('ap')); // ['apple', 'grapes'] +console.log(filterItems('an')); // ['banana', 'mango', 'orange']</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>filter()</code> foi adicionado ao padrão ECMA-262 na 5ª edição; assim como pode não estar presente em todas as implementações do padrão. Você pode trabalhar com isso adicionando o seguinte código no início de seus scripts, permitindo o uso do <code>filter()</code> na implementação ECMA-262 que não tem suporte nativo. Esse algoritmo é exatamente aquele especificado na 5ª edição do ECMA-262, assumindo que <code>fn.call</code> veja o valor original de {{jsxref("Function.prototype.call()")}}, e que {{jsxref("Array.prototype.push()")}} tenha seu valor original.</p> + +<pre class="brush: js">if (!Array.prototype.filter) { + Array.prototype.filter = function(fun/*, thisArg*/) { + 'use strict'; + + if (this === void 0 || this === null) { + throw new TypeError(); + } + + var t = Object(this); + var len = t.length >>> 0; + if (typeof fun !== 'function') { + throw new TypeError(); + } + + var res = []; + var thisArg = arguments.length >= 2 ? arguments[1] : void 0; + for (var i = 0; i < len; i++) { + if (i in t) { + var val = t[i]; + + // NOTE: Technically this should Object.defineProperty at + // the next index, as push can be affected by + // properties on Object.prototype and Array.prototype. + // But that method's new, and collisions should be + // rare, so use the more-compatible alternative. + if (fun.call(thisArg, val, i, t)) { + res.push(val); + } + } + } + + return res; + }; +} +</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.4.4.20', 'Array.prototype.filter')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definição inicial. Implementada no JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.filter', 'Array.prototype.filter')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2> + +<div>{{Compat("javascript.builtins.Array.filter")}}</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> + <li>{{jsxref("Array.prototype.reduce()")}}</li> +</ul> + +<div id="link64_adl_tabid" style="display: none;">24</div> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/find/index.html b/files/pt-br/web/javascript/reference/global_objects/array/find/index.html new file mode 100644 index 0000000000..904f65c200 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/find/index.html @@ -0,0 +1,157 @@ +--- +title: Array.prototype.find() +slug: Web/JavaScript/Reference/Global_Objects/Array/find +translation_of: Web/JavaScript/Reference/Global_Objects/Array/find +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>find()</strong></code> retorna o <strong>valor </strong>do <strong>primeiro elemento</strong> do array que satisfizer a função de teste provida. Caso contrario, {{jsxref("undefined")}} é retornado.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-find.html")}}</div> + +<p class="hidden">O código-fonte desse exemplo interativo está em um repositório do GitHub. Se você quiser contribuir para o projeto de exemplos interativos, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um pull request.</p> + +<p>Veja também o método {{jsxref("Array.findIndex", "findIndex()")}}, que retorna o <strong>índice</strong> do elemento encontrado no array ao invés do seu valor.</p> + +<p>Se você precisa encontrar a posição de um elemento ou se um elemento existe em um array, use {{jsxref("Array.prototype.indexOf()")}} ou {{jsxref("Array.prototype.includes()")}}.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>arr</var>.find(<var>callback(element[, index[, array]])</var>[, <var>thisArg</var>])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Função executada a cada iteração do array, recebendo três argumentos: + <dl> + <dt><code>element</code></dt> + <dd>O elemento atual que está sendo processado no array.</dd> + <dt><code>index</code>{{optional_inline}}</dt> + <dd>O índice do elemento atualmente sendo processado no array.</dd> + <dt><code>array</code>{{optional_inline}}</dt> + <dd>O array sobre o qual <code>find</code> foi chamado.</dd> + </dl> + </dd> + <dt><code>thisArg</code>{{optional_inline}}</dt> + <dd>Opcional. Objeto usado como <code>this</code> quando executando o <code>callback</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O <strong>valor</strong> do <strong>primeiro elemento</strong> do array que satisfaz a função de teste fornecida; caso contrário, {{jsxref("undefined")}}.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>find</code> executa a função <code>callback </code>uma vez para cada elemento presente no array até que encontre um onde <code>callback</code> retorne o valor true. Se o elemento é encontrado, <code>find</code> retorna imediatamente o valor deste elemento. Caso contrário, <code>find</code> retorna {{jsxref("Global_Objects/undefined", "undefined")}}. O <code>callback </code>é acionado para todos os índices do array de <code>0</code> a <code>tamanho-1</code>, não apenas para aqueles que possuem valores atribuídos. Sendo assim, ele pode ser menos eficiente para arrays muito grandes em que existem outros métodos que só visitam os índices que tenham valor atribuído.</p> + +<p>O <code>callback</code> é acionado com três argumentos: o valor do elemento, o índice do elemento e o objeto do Array que está sendo executado.</p> + +<p>Se um parâmetro <code>thisArg</code> é provido ao <code>find</code>, ele será usado como o <code>this</code> para cada acionamento do <code>callback</code>. Se não for provido, então {{jsxref("Global_Objects/undefined", "undefined")}} é usado.</p> + +<p>O <code>find</code> não altera a array à qual foi acionado.</p> + +<p>O conjunto dos elementos processados por <code>find</code> é definido antes do primeiro acionamento do <code>callback</code>. Elementos que são anexados à array após o início da chamada ao <code>find</code> não serão visitados pelo <code>callback</code>. Se um elemento existente ainda não visitado da array for alterado pelo <code>callback</code>, o valor passado ao <code>callback</code> quando o visitar será o valor no momento que <code>find</code> visita o índice daquele elemento; elementos excluídos ainda são visitados.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Encontrar_um_objeto_em_um_array_por_uma_de_suas_propriedades">Encontrar um objeto em um array por uma de suas propriedades</h3> + +<pre class="brush: js notranslate">const inventory = [ + {name: 'apples', quantity: 2}, + {name: 'bananas', quantity: 0}, + {name: 'cerejas', quantity: 5} +]; + +function isCherries(fruit) { + return fruit.name === 'cerejas'; +} + +console.log(inventory.find(isCherries)); +// { name: 'cerejas', quantity: 5 }</pre> + +<h4 id="Utilizando_arrow_function">Utilizando arrow function</h4> + +<pre class="brush: js notranslate">const inventory = [ + {name: 'maças', quantity: 2}, + {name: 'bananas', quantity: 0}, + {name: 'cherries', quantity: 5} +]; + +const result = inventory.find( fruit => fruit.name === 'cherries' ); + +console.log(result) // { name: 'cherries', quantity: 5 }</pre> + +<h3 id="Encontrar_um_número_primo_em_um_array">Encontrar um número primo em um array</h3> + +<p>O exemplo a seguir encontra um elemento dentro da array que é número primo (ou retorna {{jsxref("Global_Objects/undefined", "undefined")}} se não houverem números primos).</p> + +<pre class="brush: js notranslate">function isPrime(element, index, array) { + var start = 2; + while (start <= Math.sqrt(element)) { + if (element % start++ < 1) { + return false; + } + } + return element > 1; +} + +console.log([4, 6, 8, 12].find(isPrime)); // undefined, not found +console.log([4, 5, 8, 12].find(isPrime)); // 5 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Este método foi adicionado à especificação do ECMAScript 2015 e pode não estar disponível em todas as implementações do JavaScript. Entretanto, você pode fazer um polyfill para o <code>Array.prototype.find</code> com o trecho de código abaixo:</p> + +<pre class="brush: js notranslate">if (!Array.prototype.find) { + Array.prototype.find = function(predicate) { + if (this === null) { + throw new TypeError('Array.prototype.find called on null or undefined'); + } + if (typeof predicate !== 'function') { + throw new TypeError('predicate must be a function'); + } + var list = Object(this); + var length = list.length >>> 0; + var thisArg = arguments[1]; + var value; + + for (var i = 0; i < length; i++) { + value = list[i]; + if (predicate.call(thisArg, value, i, list)) { + return value; + } + } + return undefined; + }; +} +</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-array.prototype.find', 'Array.prototype.find')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_do_Navegador">Compatibilidade do Navegador</h2> + +<div>{{Compat("javascript.builtins.Array.find")}}</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/findindex/index.html b/files/pt-br/web/javascript/reference/global_objects/array/findindex/index.html new file mode 100644 index 0000000000..75c677d20d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/findindex/index.html @@ -0,0 +1,127 @@ +--- +title: Array.prototype.findIndex() +slug: Web/JavaScript/Reference/Global_Objects/Array/findIndex +translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>findIndex()</strong></code> retorna o <strong>índice</strong> no array do primeiro elemento que satisfizer a função de teste provida. Caso contrário, retorna -1, indicando que nenhum elemento passou no teste.</p> + +<p>Veja também o método {{jsxref("Array.find", "find()")}}, que retorna o <strong>valor</strong> de um elemento encontrado no array em vez de seu índice.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>arr</var>.findIndex(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Função para executar em cada valor no array, tomando três argumentos: + <dl> + <dt><code>element</code></dt> + <dd>O elemento atual sendo processado no array.</dd> + <dt><code>index</code></dt> + <dd>O índice do elemento atual sendo processado no array.</dd> + <dt><code>array</code></dt> + <dd>O array sobre o qual <code>findIndex</code> foi chamado.</dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Opcional. Objeto para usar como <code>this</code> na execução do <code>callback</code>.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>findIndex</code> executa a função <code>callback</code> uma vez para cada elemento presente no array até encontrar um onde o <code>callback</code> retorna um valor verdadeiro. Se tal elemento for encontrado, <code>findIndex</code> imediatamente retorna o índice deste elemento. Caso contrário, <code>findIndex</code> retorna -1. <code>callback</code> é invocado apenas para índices no array que têm valores atribuídos; nunca é invocado para índices que foram deletados ou que nunca tiveram valores atribuídos.</p> + +<p><code>callback</code> é invocado com três argumentos: o valor do elemento, o índice do elemento e o objeto Array sendo percorrido.</p> + +<p>Se um parâmetro <code>thisArg</code> for fornecido para <code>findIndex</code>, ele será usado como o <code>this</code> para cada invocação do <code>callback</code>. Se não for fornecido, então {{jsxref("undefined")}} é usado.</p> + +<p><code>findIndex</code> não modifica o array sobre o qual é chamado.</p> + +<p>A série de elementos processados por <code>findIndex</code> é definida antes da primeira invocação do <code>callback</code>. Elementos que são adicionados ao array depois que a chamada a <code>findIndex</code> começa não serão visitados pelo <code>callback</code>. Se um elemento existente não visitado do array for modificado pelo <code>callback</code>, seu valor passado ao <code>callback</code> será o valor no momento em que <code>findIndex</code> visitar o índice deste elemento; elementos que forem deletados não são visitados.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Encontrar_o_índice_de_um_número_primo_em_um_array">Encontrar o índice de um número primo em um array</h3> + +<p>O seguinte exemplo encontra o índice de um elemento no array que é um número primo (ou retorna -1 se não houver número primo).</p> + +<pre class="brush: js notranslate">function isPrime(element, index, array) { + var start = 2; + while (start <= Math.sqrt(element)) { + if (element % start++ < 1) { + return false; + } + } + return element > 1; +} + +console.log([4, 6, 8, 12].findIndex(isPrime)); // -1, não encontrado +console.log([4, 6, 7, 12].findIndex(isPrime)); // 2 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Esse método foi adicionado à especificação do ECMAScript 6 e pode não estar disponível em todas as implementações de JavaScript ainda. Contudo, você pode fazer o polyfill de <code>Array.prototype.findIndex</code> com o seguinte trecho de código:</p> + +<pre class="brush: js notranslate">if (!Array.prototype.findIndex) { + Array.prototype.findIndex = function(predicate) { + if (this === null) { + throw new TypeError('Array.prototype.findIndex called on null or undefined'); + } + if (typeof predicate !== 'function') { + throw new TypeError('predicate must be a function'); + } + var list = Object(this); + var length = list.length >>> 0; + var thisArg = arguments[1]; + var value; + + for (var i = 0; i < length; i++) { + value = list[i]; + if (predicate.call(thisArg, value, i, list)) { + return i; + } + } + return -1; + }; +} +</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-array.prototype.findIndex', 'Array.prototype.findIndex')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<div>{{Compat("javascript.builtins.Array.findIndex")}}</div> + +<div></div> + +<div><span style="">Veja também</span></div> + +<ul> + <li>{{jsxref("Array.prototype.find()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/flat/index.html b/files/pt-br/web/javascript/reference/global_objects/array/flat/index.html new file mode 100644 index 0000000000..b14ffb006f --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/flat/index.html @@ -0,0 +1,121 @@ +--- +title: Array.prototype.flat() +slug: Web/JavaScript/Reference/Global_Objects/Array/flat +tags: + - Array + - Experimental + - JavaScript + - Method + - Prototype + - flat +translation_of: Web/JavaScript/Reference/Global_Objects/Array/flat +--- +<div>{{JSRef}} {{SeeCompatTable}}</div> + +<p>O método <code><strong>flat()</strong></code> cria um novo array com todos elementos sub-arrays concatenados nele de forma recursiva até a profundidade<em> </em>especificada.</p> + +<p class="hidden">\{{EmbedInteractiveExample("pages/js/array-flatten.html")}}</p> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>var novoArray = arr</var>.flat(<var>depth</var>)</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>depth</code> {{optional_inline}}</dt> + <dd>O nível de profundidade especifíca o quanto um array aninhando deve ser achatado. O Default é 1.</dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>Um novo array com os elementos sub-array concatenados nele.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Achatando_arrays_aninhados">Achatando arrays aninhados</h3> + +<pre class="brush: js notranslate">var arr1 = [1, 2, [3, 4]]; +arr1.flat(); +// [1, 2, 3, 4] + +var arr2 = [1, 2, [3, 4, [5, 6]]]; +arr2.flat(); +// [1, 2, 3, 4, [5, 6]] + +var arr3 = [1, 2, [3, 4, [5, 6]]]; +arr3.flat(2); +// [1, 2, 3, 4, 5, 6] + +<code>const arr4 = [1, 2, [3, 4, [5, 6, [7, 8]]]]; +arr4.flat(Infinity); +// [1, 2, 3, 4, 5, 6, 7, 8]</code></pre> + +<h3 id="Achatando_e_buracos_em_array">Achatando e buracos em array</h3> + +<p>o método flat remove espaços vazios do array:</p> + +<pre class="brush: js notranslate">var arr4 = [1, 2, , 4, 5]; +arr4.flat(); +// [1, 2, 4, 5]</pre> + +<div class="line"></div> + +<h2 id="Alternativa">Alternativa</h2> + +<h3 id="reduce_e_concat"><code>reduce</code> e <code>concat</code></h3> + +<pre class="brush: js notranslate">var arr1 = [1, 2, [3, 4]]; +arr1.flat(); + +//achatar array de nível único +arr1.reduce((acc, val) => acc.concat(val), []); +// [1, 2, 3, 4] + +//para achatamentos mais profundos, use recursividade com reduce e concat +var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]]; + +(function flattenDeep(arr1){ + return arr1.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val), []); +})(arr1); + +// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4] + + +</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><a href="https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flat"><code>Array.prototype.flat</code> proposal</a></td> + <td>Draft</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_em_Navegadores">Compatibilidade em Navegadores</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Array.flat")}}</p> +</div> + +<h2 id="Veja_Também">Veja Também</h2> + +<ul> + <li>{{jsxref("Array.prototype.flatMap()")}}</li> + <li>{{jsxref("Array.prototype.map()")}}</li> + <li>{{jsxref("Array.prototype.reduce()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/flatmap/index.html b/files/pt-br/web/javascript/reference/global_objects/array/flatmap/index.html new file mode 100644 index 0000000000..f75edaf3ef --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/flatmap/index.html @@ -0,0 +1,126 @@ +--- +title: Array.prototype.flatMap() +slug: Web/JavaScript/Reference/Global_Objects/Array/flatMap +translation_of: Web/JavaScript/Reference/Global_Objects/Array/flatMap +--- +<div>{{JSRef}} {{SeeCompatTable}}</div> + +<p>O método <strong><code>flatMap()</code></strong> primeiro mapeia cada elemento usando uma função de mapeamento e, em seguida, nivela o resultado em um novo array. É idêntico a um <code>map</code> seguido por um <code>flat</code> de profundidade 1, mas <strong><code>flatMap</code></strong> é bastante útil e mescla ambos em um método um pouco mais eficiente.\{{EmbedInteractiveExample("pages/js/array-flatmap.html")}}</p> + +<p class="hidden">A fonte deste exemplo interativo é armazenada em um repositório GitHub. Se você quiser contribuir com o projeto de exemplos interativos, clone https://github.com/mdn/interactive-examples e envie-nos um PR</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><var>var new_array = arr</var>.flatMap(function <var>callback(currentValue[, index[, array]]) { + // retorna o elemento para new_array +}</var>[, <var>thisArg</var>])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Função que produz um elemento de uma nova Array, pegando três argumentos: + <dl> + <dt></dt> + <dt><code>currentValue</code></dt> + <dd>O valor atual sendo processo na array.</dd> + <dt><code>index</code>{{optional_inline}}</dt> + <dd>O index do valor atual sendo processo na array.</dd> + <dt><code>array</code>{{optional_inline}}</dt> + </dl> + + <p>O <code>map</code> da array que foi chamado.</p> + </dd> + <dt><code>thisArg</code>{{optional_inline}}</dt> + <dd>Valor para ser usado como <code>this</code> quando <code>callback</code> estiver sendo executado.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Uma nova array com cada elemento sendo o resultado da função callback e achatado ao valor de 1.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Veja {{jsxref("Array.prototype.map()")}} para uma detalhada descrição da função callback. O método <code>flatMap</code> é idêntico ao <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map">map</a></code> seguido por um chamado a <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flatten">flatten</a></code> de profundidade 1.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="map_e_flatMap"><code>map</code> e <code>flatMap</code></h3> + +<pre class="brush: js">var arr1 = <span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>[</span></span><span class="constant decimal js numeric"><span>1</span></span><span class="comma delimiter js meta object"><span>,</span></span><span> </span><span class="brace js meta square"><span>2, 3, 4]; + +arr1.map(</span></span></span></span></span>x => [x * 2]<span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>);</span></span></span></span></span> +// [[2], [4], [6], [8]] + +arr1.flatMap(x => [x * 2]<span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>); +// [2, 4, 6, 8]</span></span></span></span></span> + +// Só o primeiro nível +arr1.flatMap(x => [[x * 2]]); +// [[2], [4], [6], [8]] +</pre> + +<p>Enquanto que acima poderíamos alcançar apenas com a utilização de map, já aqui temos um exemplo onde <code>flatMap</code> é mais apropriado.</p> + +<p>Vamos gerar uma lista de palavras a partir de uma lista de sentenças.</p> + +<pre class="brush: js">let arr1 = ["it's Sunny in", "", "California"]; + +arr1.map(x=>x.split(" ")); +// [["it's","Sunny","in"],[""],["California"]] + +arr1.flatMap(x => x.split(" ")<span class="js source"><span class="function-call js meta"><span class="br brace js meta square"><span>); +// ["it's","Sunny","in", "", "California"]</span></span></span></span> +</pre> + +<p>Perceba, o comprimento da lista de saída pode ser diferente do comprimento da lista de entrada.</p> + +<div class="line"><span class="js source"><span class="comment double-slash js line"><span class="comment definition js punctuation"><span>//</span></span><span>=> [1, 2, 3, 4, 5, 6, 7, 8, 9]</span></span></span></div> + +<h2 id="Alternativa">Alternativa</h2> + +<h3 id="reduce_e_concat"><code>reduce</code> e <code>concat</code></h3> + +<pre class="brush: js">var arr1 = <span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>[</span></span><span class="constant decimal js numeric"><span>1</span></span><span class="comma delimiter js meta object"><span>,</span></span><span> </span><span class="brace js meta square"><span>2, 3, 4]; +</span></span></span></span></span> +arr1.flatMap(x => [x * 2]<span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>);</span></span></span></span></span> +// é equivalente a +arr1.reduce((acc, x) => acc.concat([x * 2]<span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>), []);</span></span></span></span></span> +<span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>// [2, 4, 6, 8]</span></span></span></span></span> +</pre> + +<div class="line"><span class="js source"><span class="comment double-slash js line"><span class="comment definition js punctuation"><span>//</span></span><span>=> [1, 2, 3, 4, 5, 6, 7, 8, 9]</span></span></span></div> + +<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><a href="https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatMap"><code>Array.prototype.flatMap</code> proposal</a></td> + <td>Rascunho</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_browser">Compatibilidade de browser</h2> + +<div> +<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, confira https://github.com/mdn/browser-compat-data e envie-nos uma PR</div> + +<p>{{Compat("javascript.builtins.Array.flatMap")}}</p> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.flatten()")}}</li> + <li>{{jsxref("Array.prototype.map()")}}</li> + <li>{{jsxref("Array.prototype.reduce()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/foreach/index.html b/files/pt-br/web/javascript/reference/global_objects/array/foreach/index.html new file mode 100644 index 0000000000..3ff4e43901 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/foreach/index.html @@ -0,0 +1,212 @@ +--- +title: Array.prototype.forEach() +slug: Web/JavaScript/Reference/Global_Objects/Array/forEach +translation_of: Web/JavaScript/Reference/Global_Objects/Array/forEach +--- +<div>{{JSRef}}</div> + +<p>O método <code>forEach()</code> executa uma dada função em cada elemento de um array.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><var>arr</var>.forEach(<var>callback(currentValue [, index [, array]])</var>[, <var>thisArg</var>]);</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Função para executar em cada elemento, recebendo três argumentos: + <dl> + <dt><code>currentValue</code></dt> + <dd>O valor atual do elemento sendo processado no array.</dd> + <dt><code>index</code> {{optional_inline}}</dt> + <dd>O índice do elemento atual sendo processado no array.</dd> + <dt><code>array</code> {{optional_inline}}</dt> + <dd>O array que <code>forEach()</code> está sendo aplicado.</dd> + </dl> + </dd> + <dt><code>thisArg</code> {{optional_inline}}</dt> + <dd>Opcional. Valor a ser usado como <code>this</code> quando executar <code>callback</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p><code>undefined</code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O <code>forEach</code> executa o <code>callback</code> fornecido uma vez para cada elemento da ordem com um valor atribuido. Ele não é invocado para propriedades de índices que foram deletados ou que não foram inicializados (por ex. em arrays esparsos).</p> + +<p><code>callback</code> é invocado com <strong>três argumentos</strong>:</p> + +<ul> + <li>o <strong>valor do elemento</strong></li> + <li>o <strong>índice do elemento</strong></li> + <li>o <strong>array que está sendo percorrido</strong></li> +</ul> + +<p>Se um parâmetro <code>thisArg</code> for passado para <code>forEach()</code>, ele será passado para o <code>callback</code> quando invocado como valor para <code>this</code>. Caso contrário, o valor {{jsxref("undefined")}} será passado como valor para <code>this</code>. O valor de <code>this</code> assumido no <code>callback</code> é determinado de acordo com as <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this">regras usuais para determinação do <code>this</code> visto por uma função</a>.</p> + +<p>O intervalo dos elementos processados por <code>forEach()</code> é determinado antes da primeira invocação do <code>callback</code>. Elementos que forem adicionados ao array depois da chamada ao <code>forEach()</code> começar não serão visitados pelo <code>callback</code>. Se os valores dos elementos existentes do array forem alterados, o valor passado para o <code>callback</code> será o valor no momento em que o <code>forEach()</code> visitá-los; elementos que forem deletados antes de serem visitados não serão visitados.</p> + +<p><code>forEach()</code> executa a a função <code>callback</code> uma vez para cada elemento do array – diferentemente de {{jsxref("Array.prototype.map()", "map()")}} ou {{jsxref("Array.prototype.reduce()", "reduce()")}}, ele sempre retorna o valor {{jsxref("undefined")}} e não é encadeável. O caso de uso típico é alterar o array no final do loop.</p> + +<div class="note"> +<p>A única maneira de parar ou interromper um loop <code>forEach()</code> é disparando uma exceção. Se você precisa desse recurso, o método <code>forEach()</code> é a ferramenta errada. Você estará mais bem servido com um loop simples nesse caso. Se estiver testando o array de elementos para um predicado e precisar de um valor de retorno Boleano, você pode usar {{jsxref("Array.prototype.every()", "every()")}} ou {{jsxref("Array.prototype.some()", "some()")}}. Se estiverem disponíveis, os novos métodos {{jsxref("Array.prototype.find()", "find()")}} e {{jsxref("Array.prototype.findIndex()", "findIndex()")}} também podem ser usados para terminação antecipada em predicados verdadeiros.</p> +</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Imprimindo_os_conteúdos_de_uma_ordem">Imprimindo os conteúdos de uma ordem</h3> + +<p>Os códigos a seguir logam uma linha para cada elemento na ordem:</p> + +<pre class="brush:js">function logArrayElements(element, index, array) { + console.log("a[" + index + "] = " + element); +} +[2, 5, 9].forEach(logArrayElements); +// logs: +// a[0] = 2 +// a[1] = 5 +// a[2] = 9 +</pre> + +<h3 id="Função_para_cópia_de_um_objeto">Função para cópia de um objeto</h3> + +<p>O código a seguir cria uma cópia para cada objeto dado. Há diferentes formas de criar uma cópia para um objeto. Esta é somente uma forma de explicar como <code>Array.prototype.forEach</code> funciona. Ela usa um grupo de novas funções ECMAScript 5 Object.*</p> + +<pre class="brush: js">function copy(o){ + var copy = Object.create( Object.getPrototypeOf(o) ); + var propNames = Object.getOwnPropertyNames(o); + + propNames.forEach(function(name){ + var desc = Object.getOwnPropertyDescriptor(o, name); + Object.defineProperty(copy, name, desc); + }); + + return copy; +} + +var o1 = {a:1, b:2}; +var o2 = copy(o1); // o2 looks like o1 now +</pre> + +<h2 id="Compatibilidade">Compatibilidade</h2> + +<p><code>forEach</code> é uma adição recente para o ECMA-262 standard; assim sendo, pode não estar presente em outras implementações do standard. Você pode contornar isto pela inserção do código a seguir no começo de seus scripts, permitindo o uso de <code>forEach</code> em implementações que normalmente não possuem este suporte.</p> + +<pre class="brush:js">if ( !Array.prototype.forEach ) { + Array.prototype.forEach = function(fn, scope) { + for(var i = 0, len = this.length; i < len; ++i) { + fn.call(scope, this[i], i, this); + } + }; +} +</pre> + +<p>Um algorítimo 100% verdadeiro para a 5ª Edição do ECMA-262, pode ser visto abaixo:</p> + +<p>O algoritmo é exatamente o especificado na 5ª Edição da ECMA-262, assumindo <code>Object</code> e<code> TypeError</code> possuem seus valores originais e avalia <code>callback.call</code> para o valor original de <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function/call" title="JavaScript/Reference/Global Objects/Function/call">Function.prototype.call</a></code>.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.18 +// Reference: http://es5.github.com/#x15.4.4.18 +if ( !Array.prototype.forEach ) { + + Array.prototype.forEach = function forEach( callback, thisArg ) { + + var T, k; + + if ( this == null ) { + throw new TypeError( "this is null or not defined" ); + } + + // 1. Let O be the result of calling ToObject passing the |this| value as the argument. + var O = Object(this); + + // 2. Let lenValue be the result of calling the Get internal method of O with the argument "length". + // 3. Let len be ToUint32(lenValue). + var len = O.length >>> 0; // Hack to convert O.length to a UInt32 + + // 4. If IsCallable(callback) is false, throw a TypeError exception. + // See: http://es5.github.com/#x9.11 + if ( {}.toString.call(callback) !== "[object Function]" ) { + throw new TypeError( callback + " is not a function" ); + } + + // 5. If thisArg was supplied, let T be thisArg; else let T be undefined. + if ( thisArg ) { + T = thisArg; + } + + // 6. Let k be 0 + k = 0; + + // 7. Repeat, while k < len + while( k < len ) { + + var kValue; + + // a. Let Pk be ToString(k). + // This is implicit for LHS operands of the in operator + // b. Let kPresent be the result of calling the HasProperty internal method of O with argument Pk. + // This step can be combined with c + // c. If kPresent is true, then + if ( Object.prototype.hasOwnProperty.call(O, k) ) { + + // i. Let kValue be the result of calling the Get internal method of O with argument Pk. + kValue = O[ k ]; + + // ii. Call the Call internal method of callback with T as the this value and + // argument list containing kValue, k, and O. + callback.call( T, kValue, k, O ); + } + // d. Increase k by 1. + k++; + } + // 8. return undefined + }; +} +</pre> + +<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2> + +<p>{{Compat("javascript.builtins.Array.forEach")}}</p> + +<h2 id="Specifications">Specifications</h2> + +<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.4.4.18', 'Array.prototype.forEach')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.find()")}}</li> + <li>{{jsxref("Array.prototype.findIndex()")}}</li> + <li>{{jsxref("Array.prototype.map()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> + <li>{{jsxref("Map.prototype.forEach()")}}</li> + <li>{{jsxref("Set.prototype.forEach()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/from/index.html b/files/pt-br/web/javascript/reference/global_objects/array/from/index.html new file mode 100644 index 0000000000..798f1c727d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/from/index.html @@ -0,0 +1,205 @@ +--- +title: Array.from() +slug: Web/JavaScript/Reference/Global_Objects/Array/from +tags: + - Array + - ECMAScript 2015 + - ES6 + - Method + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/from +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <code><strong>Array.from()</strong></code> cria uma nova instância <code>de um Array</code> quando for passado um array-like ou um iterable object como argumento.</p> + +<p>No ES6, <span id="result_box" lang="pt"><span class="hps">a sintaxe</span> <span class="hps">de classe</span> permite a<span class="hps"> subclassificação de </span>classes nativas e classes <span class="hps">definidas pelo usuário; como </span><span class="hps">resultado</span><span>, os métodos estáticos</span> <span class="hps">pertencentes a classe,</span> <span class="hps">como</span> </span> <code><strong>Array.from,</strong></code><span lang="pt"> <span class="hps">são</span> <span class="atn hps">"</span><span>herdadas</span><span>"</span> por <span class="hps">subclasses</span> <span class="hps">do </span></span><code><strong>Array</strong></code><span lang="pt"> <span class="hps">e criam </span><span class="hps">novas instâncias da</span> <span class="hps">subclasse,</span> <span class="hps">não</span> <span class="hps">do </span></span><code><strong>Array</strong></code><span lang="pt"><span class="hps">.</span></span></p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code>Array.from(arrayLike[, mapFn[, thisArg]]) +</code></pre> + +<h3 id="Parameters" name="Parameters"><span>Parâmetros</span></h3> + +<dl> + <dt><code>arrayLike</code></dt> + <dd>Um array-like ou um objeto iterável para converter em array.</dd> + <dt><code>mapFn</code></dt> + <dd><em>Opcional</em>. Função Map que será chamada para cada elemento do array.</dd> + <dt><code>thisArg</code></dt> + <dd><em>Opcional</em>. Valor a ser utilizado como this quando a mapFn for chamada.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p><code>Array.from()</code> deixa você criar um Array de:</p> + +<ul> + <li>objetos array-like (objetos com a propriedade <code>length</code> e elementos indexados); ou</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/iterable">Objetos iteráveis</a> (objetos onde você pode coletar seus elementos, assim como {{jsxref("Map")}} e {{jsxref("Set")}}).</li> +</ul> + +<p><code>Array.from()</code> tem um parametro opcional <code>mapFn</code>, que permite executar a função {{jsxref("Array.prototype.map", "map")}} para cada elemento do array (ou subclasse de objeto) que está sendo criado. Simplificando,<code> Array.from(obj, mapFn, thisArg)</code> é o mesmo que <code>Array.from(obj).map(mapFn, thisArg)</code>, com a excessão de não cria um array intermediário . Isso é importante, principalmente para certas subclasses de array, como <a href="/en-US/docs/Web/JavaScript/Typed_arrays">typed array</a>, no qual o array intermediário iria necessáriamente ter o valor truncado para encaixar-se no tipo apropriado.</p> + +<p>A propriedade <code>length</code> do método <code>from()</code> é <code>1</code>.</p> + +<p>No ES2015, a sintaxe de class permite a definição de subclasses tanto internas quando definidas pelo usuário. Como resultado, métodos estáticos como <code>Array.from()</code> são "herdados" pelas subclasses de <code>Array</code>, e cria novas instâncias da subclasse, não de <code>Array</code>.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>Array.from</code> foi adicionado ao padrão ECMA-262 em sua 6ª edição; desta forma, <span id="result_box" lang="pt"><span class="hps">não</span> <span class="hps">está presente</span> <span class="hps">na</span> <span class="hps">aplicações anteriores da especificação</span></span>. Na ausência do código nativo, você pode inserir o código seguinte no início do script, permitindo <code>o uso parcial da funcionalidade do Array.from</code>. Esse algorítmo é equivalente ao especificado no ECMA-262, 6ª edição, exceto que <code>Object</code> e <code>TypeError</code> tem seus valores originais e que <code>callback.call</code> retorna o valor original de {{jsxref("Function.prototype.call")}}. Além disso, <span id="result_box" lang="pt"><span class="hps">os verdadeiros</span> <span class="hps">iterables</span> <span class="hps">não</span> podem ser representados</span> genéricamente no polyfill, criando a principal distinção do que foi definido na especificação.</p> + +<pre class="brush: js notranslate">// Production steps of ECMA-262, Edition 6, 22.1.2.1 +// Reference: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-array.from +if (!Array.from) { + Array.from = (function () { + var toStr = Object.prototype.toString; + var isCallable = function (fn) { + return typeof fn === 'function' || toStr.call(fn) === '[object Function]'; + }; + var toInteger = function (value) { + var number = Number(value); + if (isNaN(number)) { return 0; } + if (number === 0 || !isFinite(number)) { return number; } + return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number)); + }; + var maxSafeInteger = Math.pow(2, 53) - 1; + var toLength = function (value) { + var len = toInteger(value); + return Math.min(Math.max(len, 0), maxSafeInteger); + }; + + // The length property of the from method is 1. + return function from(arrayLike/*, mapFn, thisArg */) { + // 1. Let C be the this value. + var C = this; + + // 2. Let items be ToObject(arrayLike). + var items = Object(arrayLike); + + // 3. ReturnIfAbrupt(items). + if (arrayLike == null) { + throw new TypeError("Array.from requires an array-like object - not null or undefined"); + } + + // 4. If mapfn is undefined, then let mapping be false. + var mapFn = arguments.length > 1 ? arguments[1] : void undefined; + var T; + if (typeof mapFn !== 'undefined') { + // 5. else + // 5. a If IsCallable(mapfn) is false, throw a TypeError exception. + if (!isCallable(mapFn)) { + throw new TypeError('Array.from: when provided, the second argument must be a function'); + } + + // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined. + if (arguments.length > 2) { + T = arguments[2]; + } + } + + // 10. Let lenValue be Get(items, "length"). + // 11. Let len be ToLength(lenValue). + var len = toLength(items.length); + + // 13. If IsConstructor(C) is true, then + // 13. a. Let A be the result of calling the [[Construct]] internal method of C with an argument list containing the single item len. + // 14. a. Else, Let A be ArrayCreate(len). + var A = isCallable(C) ? Object(new C(len)) : new Array(len); + + // 16. Let k be 0. + var k = 0; + // 17. Repeat, while k < len… (also steps a - h) + var kValue; + while (k < len) { + kValue = items[k]; + if (mapFn) { + A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k); + } else { + A[k] = kValue; + } + k += 1; + } + // 18. Let putStatus be Put(A, "length", len, true). + A.length = len; + // 20. Return A. + return A; + }; + }()); +} +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js notranslate">// Array-like object (arguments) para um Array +function f() { + return Array.from(arguments); +} + +f(1, 2, 3); +// [1, 2, 3] + + +// Qualquer iterable object ... +// com Set +var s = new Set(["foo", window]); +Array.from(s); +// ["foo", window] + + +// Map +var m = new Map([[1, 2], [2, 4], [4, 8]]); +Array.from(m); +// [[1, 2], [2, 4], [4, 8]] + + +// String +Array.from("foo"); +// ["f", "o", "o"] + + +// Usando um arrow function como função map para +// manipular os elementos +Array.from([1, 2, 3], x => x + x); +// [2, 4, 6] + + +// Gerando uma sequência de números +Array.from({length: 5}, (v, k) => k); +// [0, 1, 2, 3, 4] +</pre> + +<h2 id="Especificação">Especificação</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-array.from', 'Array.from')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + </tbody> +</table> + +<h2 id="compatibilidade_com_navegadores">compatibilidade com navegadores</h2> + +<div> +<p>{{Compat("javascript.builtins.Array.from")}}</p> +</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Array.prototype.map()")}}</li> + <li>{{jsxref("TypedArray.from()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/index.html b/files/pt-br/web/javascript/reference/global_objects/array/index.html new file mode 100644 index 0000000000..6130c8d949 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/index.html @@ -0,0 +1,511 @@ +--- +title: Array +slug: Web/JavaScript/Reference/Global_Objects/Array +tags: + - Array + - JavaScript + - NeedsTranslation + - Refer + - TopicStub +translation_of: Web/JavaScript/Reference/Global_Objects/Array +--- +<p>{{JSRef("Global_Objects", "Array")}}</p> + +<h2 id="Sumário">Sumário</h2> + +<p>O objeto <code>Array</code> do JavaScript é um objeto global usado na construção de 'arrays': objetos de alto nível semelhantes a listas.</p> + +<p><strong>Criando um Array</strong></p> + +<pre class="brush: js">var frutas = ['Maçã', 'Banana']; + +console.log(frutas.length); +// 2 +</pre> + +<p><strong>Acessar um item (<em>index</em>) do Array</strong></p> + +<pre class="brush: js"><code>var primeiro = frutas[0]; +// Maçã + +var ultimo = frutas[frutas.length - 1]; +// Banana</code></pre> + +<p><strong>Iterar um Array</strong></p> + +<pre class="brush: js"><code>frutas.forEach(function (item, indice, array) { + console.log(item, indice); +}); +// Maçã 0 +// Banana 1</code></pre> + +<p><strong>Adicionar um item ao final do Array</strong></p> + +<pre class="brush: js"><code>var adicionar = frutas.push('Laranja'); +// ['Maçã', 'Banana', 'Laranja']</code></pre> + +<p><strong>Remover um item do final do Array</strong></p> + +<pre class="brush: js"><code>var ultimo = frutas.pop(); // remove Laranja (do final) +// ['Maçã', 'Banana'];</code></pre> + +<p><strong>Remover do início do Array</strong></p> + +<pre class="brush: js"><code>var primeiro = frutas.shift(); // remove Maçã do início +// ['Banana'];</code></pre> + +<p><strong>Adicionar ao início do Array</strong></p> + +<pre class="brush: js"><code>var adicionar = frutas.unshift('Morango') // adiciona ao início +// ['Morango', 'Banana'];</code></pre> + +<p><strong>Procurar o índice de um item na Array</strong></p> + +<pre class="brush: js"><code>frutas.push('Manga'); +// ['Morango', 'Banana', 'Manga'] + +var pos = frutas.indexOf('Banana'); +// 1</code></pre> + +<p><strong>Remover um item pela posição do índice</strong></p> + +<pre class="brush: js"><code>var removedItem = frutas.splice(pos, 1); // é assim que se remove um item +// ['Morango', 'Manga']</code></pre> + +<p><strong>Remover itens de uma posição de índice</strong></p> + +<pre class="brush: js">var vegetais = ['Repolho', 'Nabo', 'Rabanete', 'Cenoura']; +console.log(vegetais); +// ['Repolho', 'Nabo', 'Rabanete', 'Cenoura'] + +var pos = 1, n = 2; + +var itensRemovidos = vegetais.splice(pos, n); +// Isso é como se faz para remover itens, n define o número de itens a se remover, +// a partir da posição (pos) em direção ao fim da array. + +console.log(vegetais); +// ['Repolho', 'Cenoura'] (o array original é alterado) + +console.log(itensRemovidos); +// ['Nabo', 'Rabanete']</pre> + +<p><strong>Copiar um Array</strong></p> + +<pre class="brush: js"><code>var copiar = frutas.slice(); // é assim que se copia +// ['Morango', 'Manga']</code></pre> + +<p> </p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><var><span style="font-style: normal;">[</span>element0</var>, <var>element1</var>, ..., <var>elementN</var>] +new Array(<em>element0</em>, <em>element1</em>, ..., <em>elementN</em>) +new Array(<em>arrayLength</em>) +</pre> + +<dl> + <dt><code><var>element0</var>, <var>element1</var>, ..., <var>elementN</var> </code></dt> + <dd>Um array JavaScript é inicializado com os elementos contém, exceto no caso onde um único argumento é passado para o construtor do <code>Array</code> e esse argumento é um número (veja o parâmetro arrayLength abaixo). Esse caso especial só se aplica para os arrays JavaScript criados com o construtor <code>Array</code> , e não para literais de array criados com a sintaxe de colchetes [].</dd> + <dt><code><var>arrayLength</var></code></dt> + <dd>Se o único argumento passado para o construtor do <code>Array</code> for um número inteiro entre 0 and 2<sup>32</sup>-1 (inclusive), um novo array com o tamanho desse número é retornado. Se o argumento for qualquer outro número, uma exceção <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/RangeError" title="JavaScript/Reference/Global_Objects/RangeError">RangeError</a></code> é lançada.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Arrays são objetos semelhantes a listas que vêm com uma série de métodos embutidos para realizar operações de travessia e mutação. Nem o tamanho de um array JavaScript nem os tipos de elementos são fixos. Já que o tamanho de um array pode ser alterado a qualquer momento e os dados podem ser armazenados em posições não contíguas, arrays JavaScript não tem a garantia de serem densos; isso depende de como o programador escolhe usá-los. De uma maneira geral, essas são características convenientes, mas, se esses recursos não são desejáveis para o seu caso em particular, você pode considerar usar arrays tipados.</p> + +<p>Arrays não podem usar strings como índices (como em um <a href="https://pt.wikipedia.org/wiki/Vetor_associativo">array associativo</a>), devem ser usados números inteiros. Definir ou acessar não-inteiros usando <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Property_Accessors">notação de colchetes (ou notação de ponto)</a> não vai definir ou recuperar um elemento do array em si, mas sim definir ou acessar uma variável associada com a <a href="/pt-BR/docs/Web/JavaScript/Data_structures#Propriedades">coleção de propriedades de objeto</a> daquele array. As propriedades de objeto do array e a lista de elementos do array são separados, e as operações de travessia e mutação não podem ser aplicadas a essas propriedades nomeadas.</p> + +<h3 id="Accessando_elementos_de_um_array">Accessando elementos de um array </h3> + +<p>Arrays JavaScript começam com índice zero: o primeiro elemento de um array está na posição <code>0</code> e o último elemento está na posição equivalente ao valor da propriedade <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/length" title="JavaScript/Reference/Global_Objects/Array/length">length</a></code> (tamanho) menos 1.</p> + +<pre class="brush: js">var arr = ['este é o primeiro elemento', 'este é o segundo elemento']; +console.log(arr[0]); // exibe '<span style="font-size: 1rem;">este é o primeiro elemento'</span> +console.log(arr[1]); // exibe 'este é o segundo elemento' +console.log(arr[arr.length - 1]); // exibe 'este é o segundo elemento' +</pre> + +<p>Elementos de um array são somente propriedades de objetos, da forma que <code><a href="/en-US/docs/toString" title="toString">toString</a></code> é uma propriedade. Contudo, note que tentando acessar o primeiro elemento de um array da seguinte forma causará um erro de sintaxe, pois o nome da propriedade é inválido:</p> + +<pre class="brush: js">console.log(arr.0); // um erro de sintaxe +</pre> + +<p>Não há nada de especial a respeito de arrays JavaScript e suas propriedades que causam isso. As propriedades JavaScript que começam com um dígito não podem ser referenciadas com notação de ponto. Elas necesitam usar notação de colchetes para poderem ser acessadas. Por exemplo, se você tivesse um objeto com a propriedade "3d", também teria que ser referenciá-la usando notação de colchetes. Por exemplo:</p> + +<pre class="brush: js">var anos = [1950, 1960, 1970, 1980, 1990, 2000, 2010]; +console.log(anos.0); // um erro de sintaxe +console.log(anos[0]); // funciona corretamente +</pre> + +<pre class="brush: js">renderer.3d.setTexture(model, 'personagem.png'); // um erro de sintaxe +renderer['3d'].setTexture(model, 'personagem.png'); //funciona corretamente +</pre> + +<p>Note que no exemplo <code>3d</code>, <code>'3d'</code> teve de ser colocado entre aspas. É possivel também colocar entre aspas os índices de arrays JavaScript (ou seja, <code>years['2']</code> ao invés de <code>years[2]</code>), contudo isto não é necessário. O valor 2 em <code>years[2]</code> eventualmente será convertido a uma string pela engine do JavaScript através de uma conversão explicita com o método <code>toString</code>. E é por esta razão que <code>'2'</code> e <code>'02'</code> irão referenciar dois slots diferentes no objeto <code>anos</code> e o seguinte exemplo pode ser <em><code>true</code></em>:</p> + +<pre class="brush: js">console.log(anos['2'] != anos['02']); +</pre> + +<p>De forma similar, propriedades de objeto que sejam palavras reservadas(!) só podem ser acessadas como strings em notação de colchetes:</p> + +<pre class="brush: js">var promessa = { + 'var': 'texto', + 'array': [1, 2, 3, 4] +}; + +console.log(promessa['var']); +</pre> + +<h3 id="Relação_entre_length_e_propriedades_numéricas">Relação entre <em><code>length</code></em> e propriedades numéricas</h3> + +<p>As propriedades <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/length" title="JavaScript/Reference/Global_Objects/Array/length">length</a></code> e numéricas de um array Javascript são conectadas. Varios dos métodos javascript pré-definidos (por exemplo, <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/join" title="JavaScript/Reference/Global_Objects/Array/join">join</a></code>, <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/slice" title="JavaScript/Reference/Global_Objects/Array/slice">slice</a></code>, <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOf" title="JavaScript/Reference/Global_Objects/Array/indexOf">indexOf</a></code> etc.) levam em conta o valor da propriedade <code>length</code> de um array quando eles são chamados. Outros métodos (por exemplo, <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/push" title="JavaScript/Reference/Global_Objects/Array/push">push</a></code>, <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/splice" title="JavaScript/Reference/Global_Objects/Array/splice">splice</a></code> etc.) também resultam em uma atualização na propriedade <code>length</code> do array.</p> + +<pre class="brush: js">var frutas = []; +frutas.push('banana', 'maça', 'pêssego'); + +console.log(frutas.length); // 3</pre> + +<p>Quando configurar uma propriedade num array Javascript em que a propriedade é um índice valido do array e este índice está fora do atual limite do array, o array irá crescer para um tamanho grande o suficiente para acomodar o elemento neste índice, e a engine irá atualizar a propriedade <em>length</em> do array de acordo com isto:</p> + +<pre class="brush: js">frutas[5] = 'manga'; +console.log(frutas[5]); // 'manga' +console.log(Object.keys(frutas)); // ['0', '1', '2', '5'] +console.log(frutas.length); // 6</pre> + +<p>Configurar a propriedade <code>length</code> diretamente, também resulta em um comportamento especial:</p> + +<pre class="brush: js">frutas.length = 10; +console.log(Object.keys(frutas)); // ['0', '1', '2', '5'] +console.log(frutas.length); // 10 +</pre> + +<p>Diminuir o valor de <code>length</code>, entretanto, apaga elementos:</p> + +<pre class="brush: js">frutas.length = 2; +console.log(Object.keys(frutas)); // ['0', '1'] +console.log(frutas.length); // 2</pre> + +<h3 id="Criando_um_array_usando_o_resultado_de_uma_comparação">Criando um array usando o resultado de uma comparação</h3> + +<p>O resultado de uma comparação entre uma <em>expressão regular</em> e uma string pode criar um array Javascript. Este array tem propriedades e elementos que disponibilizam informações sobre a comparação. Esse array é o valor de retorno dos métodos {{jsxref("RegExp.exec")}}, {{jsxref("String.match")}}, e {{jsxref("String.replace")}}. Para explicar melhor sobre estas propriedades e elementos, veja o seguinte exemplo e então consulte a tabela abaixo:</p> + +<pre class="brush: js">// Encontra um d seguido por um ou mais b's seguido por um d +// Salva os b's encontrados e o d seguinte +// Ignora caixa (maiúscula/minúscula) + +var minhaRegex = /d(b+)(d)/i; +var meuArray = minhaRegex.exec('cdbBdbsbz'); +</pre> + +<p>As propriedades e elementos retornados desta comparação são os seguintes:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Propriedade/Elemento</td> + <td class="header">Descrição</td> + <td class="header">Exemplo</td> + </tr> + <tr> + <td><code>input</code></td> + <td> + <p>Uma propriedade somente-leitura que reflete a string original a qual a expressão regular foi comparada.</p> + </td> + <td>cdbBdbsbz</td> + </tr> + <tr> + <td><code>index</code></td> + <td>Uma propriedade somente-leitura que é o índice baseado em zero da comparação na string.</td> + <td>1</td> + </tr> + <tr> + <td><code>[0]</code></td> + <td>Um elemento somente-leitura que especifica os ultimos caracteres que foram encontrados.</td> + <td>dbBd</td> + </tr> + <tr> + <td><code>[1], ...[n]</code></td> + <td>Elementos somente-leitura que especificam as <em>substrings</em> de comparações entre parênteses encontradas, se incluidas na expressão regular. O número de possíveis <em>substrings </em>entre parenteses é ilimitado.</td> + <td>[1]: bB<br> + [2]: d</td> + </tr> + </tbody> +</table> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>Array.length</code></dt> + <dd>Propriedade comprimento do construtor <code>Array</code>, cujo valor é 1.</dd> + <dt>{{jsxref("Array.@@species", "get Array[@@species]")}}</dt> + <dd>A função de construtor que é utilizada para criar objetos derivados.</dd> +</dl> + +<dl> + <dt>{{jsxref("Array.prototype")}}</dt> + <dd>Permite a adição de propriedades para todos os objetos array.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<div> +<dl> + <dt>{{jsxref("Array.from()")}}</dt> + <dd>Cria uma nova instância de <code>Array</code> a partir de um objeto semelhante ou iterável.</dd> + <dt>{{jsxref("Array.isArray()")}}</dt> + <dd>Retorna <code>true</code> se a variável é um array e <code>false</code> caso contrário.</dd> + <dt>{{jsxref("Array.of()")}}</dt> + <dd>Cria uma nova instância de <code>Array</code> com um número variável de argumentos, independentemente do número ou tipo dos argumentos.</dd> +</dl> +</div> + +<div> </div> + +<h2 id="Instâncias_de_Array">Instâncias de <code>Array</code></h2> + +<p>Todas as instâncias de <code>Array</code> herdam de <span style="font-family: monospace;"><code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/prototype" title="Core_JavaScript_1.5_Reference/Global_Objects/Array/prototype">Array.prototype</a></code></span>. O protótipo do construtor <code>Array</code> pode ser modificado de forma a afetar todas as instâncias de <code>Array</code>.</p> + +<h3 id="Properties_of_Array_instances" name="Properties_of_Array_instances">Propriedades</h3> + +<div>{{ page('/pt-BR/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Properties') }}</div> + +<h3 id="Methods_of_Array_instances" name="Methods_of_Array_instances">Métodos</h3> + +<h4 id="Métodos_modificadores">Métodos modificadores</h4> + +<div>{{ page('/pt-BR/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Mutator_methods') }}</div> + +<h4 id="Métodos_de_acesso"><span>Métodos de acesso</span></h4> + +<div>{{ page('/pt-BR/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Accessor_methods') }}</div> + +<h4 id="Métodos_de_iteração"><span>Métodos de iteração</span></h4> + +<div>{{ page('/pt-BR/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Iteration_methods') }}</div> + +<h2 id="Métodos_genéricos_de_Array">Métodos genéricos de <code>Array</code></h2> + +<div class="warning"> +<p><strong>Métodos genéricos de arrays não seguem o padrão, são obsoletos e serão removidos em breve.</strong></p> +</div> + +<p>Algumas vezes você poderá querer aplicar métodos de arrays para strings ou outros objetos parecidos com arrays (como em <code><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments" title="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments">argumentos</a></code> de funções). Ao fazer isto, você trata uma string como um array de caracteres (ou em outros casos onde trata-se não-arrays como um array). Por exemplo, para checar se cada caractere em uma varivável <var>str</var> é uma letra, você poderia escrever:</p> + +<pre class="brush: js">function isLetter(character) { + return (character >= "a" && character <= "z"); +} + +if (Array.prototype.every.call(str, isLetter)) + alert("A string '" + str + "' contém somente letras!"); +</pre> + +<p>Esta notação é um pouco despendiosa e o JavaScript 1.6 introduziu a seguinte abreviação genérica:</p> + +<pre class="brush: js">if (Array.every(isLetter, str)) + alert("A string '" + str + "' contém somente letras!"); +</pre> + +<p><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String#String_generic_methods" title="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String#String_generic_methods">Generics</a> também estão disponíveis em <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String" title="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String"><code>String</code></a>.</p> + +<p>Estes não são atualmente parte dos padrões ECMAScript (através do ES2015 <a href="https://github.com/monolithed/ECMAScript-6" title="https://github.com/monolithed/ECMAScript-5"><code>Array.from()</code></a> pode se conseguir isto). A seguir segue uma adaptação para permitir o uso em todos os navegadores:</p> + +<pre class="brush: js">/*globals define*/ +// Assumes Array extras already present (one may use shims for these as well) +(function () { + 'use strict'; + + var i, + // We could also build the array of methods with the following, but the + // getOwnPropertyNames() method is non-shimable: + // Object.getOwnPropertyNames(Array).filter(function (methodName) {return typeof Array[methodName] === 'function'}); + methods = [ + 'join', 'reverse', 'sort', 'push', 'pop', 'shift', 'unshift', + 'splice', 'concat', 'slice', 'indexOf', 'lastIndexOf', + 'forEach', 'map', 'reduce', 'reduceRight', 'filter', + 'some', 'every', 'isArray' + ], + methodCount = methods.length, + assignArrayGeneric = function (methodName) { + var method = Array.prototype[methodName]; + Array[methodName] = function (arg1) { + return method.apply(arg1, Array.prototype.slice.call(arguments, 1)); + }; + }; + + for (i = 0; i < methodCount; i++) { + assignArrayGeneric(methods[i]); + } +}());</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Exemplo_Criando_um_array">Exemplo: Criando um array</h3> + +<p>O exemplo a seguir cria um array, <code>msgArray</code>, com <em>length</em> 0, então atribui valores para <code>msgArray[0]</code> e <code>msgArray[99]</code>, trocando o <em>length</em> do array para 100.</p> + +<pre class="brush: js">var msgArray = new Array(); +msgArray[0] = "Hello"; +msgArray[99] = "world"; + +if (msgArray.length == 100) + print("O length é 100."); +</pre> + +<h3 id="Exemplo_Criando_um_array_bi-dimensional">Exemplo: Criando um array bi-dimensional</h3> + +<p>O exemplo a seguir cria um tabuleiro de xadrez usando dois arrays bi-dimensionais de string. A primeira jogada é feita copiando o 'p' em 6,4 para 4,4. A posição antiga de 6,4 é colocada em branco.</p> + +<pre class="brush: js">var board = +[ ['R','N','B','Q','K','B','N','R'], + ['P','P','P','P','P','P','P','P'], + [' ',' ',' ',' ',' ',' ',' ',' '], + [' ',' ',' ',' ',' ',' ',' ',' '], + [' ',' ',' ',' ',' ',' ',' ',' '], + [' ',' ',' ',' ',' ',' ',' ',' '], + ['p','p','p','p','p','p','p','p'], + ['r','n','b','q','k','b','n','r']]; +print(board.join('\n') + '\n\n'); + +// Fazendo o King's Pawn avançar 2 +board[4][4] = board[6][4]; +board[6][4] = ' '; +print(board.join('\n')); +</pre> + +<p>Saída:</p> + +<pre class="eval">R,N,B,Q,K,B,N,R +P,P,P,P,P,P,P,P + , , , , , , , + , , , , , , , + , , , , , , , + , , , , , , , +p,p,p,p,p,p,p,p +r,n,b,q,k,b,n,r + +R,N,B,Q,K,B,N,R +P,P,P,P,P,P,P,P + , , , , , , , + , , , , , , , + , , , ,p, , , + , , , , , , , +p,p,p,p, ,p,p,p +r,n,b,q,k,b,n,r +</pre> + +<h3 id="Browser_compatibility" name="Browser_compatibility">Utilizando um array para tabular um conjunto de valores</h3> + +<pre class="brush: js line-numbers language-js"><code class="language-js">values <span class="operator token">=</span> <span class="punctuation token">[</span><span class="punctuation token">]</span><span class="punctuation token">;</span> +<span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> x <span class="operator token">=</span> <span class="number token">0</span><span class="punctuation token">;</span> x <span class="operator token"><</span> <span class="number token">10</span><span class="punctuation token">;</span> x<span class="operator token">++</span><span class="punctuation token">)</span><span class="punctuation token">{</span> + values<span class="punctuation token">.</span><span class="function token">push</span><span class="punctuation token">(</span><span class="punctuation token">[</span> + <span class="number token">2</span> <span class="operator token">*</span><span class="operator token">*</span> x<span class="punctuation token">,</span> + <span class="number token">2</span> <span class="operator token">*</span> x <span class="operator token">*</span><span class="operator token">*</span> <span class="number token">2</span> + <span class="punctuation token">]</span><span class="punctuation token">)</span> +<span class="punctuation token">}</span><span class="punctuation token">;</span> +console<span class="punctuation token">.</span><span class="function token">table</span><span class="punctuation token">(</span>values<span class="punctuation token">)</span></code></pre> + +<p>Saída:</p> + +<pre class="eval line-numbers language-html"><code class="language-html">0 1 0 +1 2 2 +2 4 8 +3 8 18 +4 16 32 +5 32 50 +6 64 72 +7 128 98 +8 256 128 +9 512 162</code></pre> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Especificações</h2> + +<table> + <tbody> + <tr> + <th scope="col">Especificação</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</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4', 'Array')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Novos metodos adicionados: {{jsxref("Array.isArray")}}, {{jsxref("Array.prototype.indexOf", "indexOf")}}, {{jsxref("Array.prototype.lastIndexOf", "lastIndexOf")}}, {{jsxref("Array.prototype.every", "every")}}, {{jsxref("Array.prototype.some", "some")}}, {{jsxref("Array.prototype.forEach", "forEach")}}, {{jsxref("Array.prototype.map", "map")}}, {{jsxref("Array.prototype.filter", "filter")}}, {{jsxref("Array.prototype.reduce", "reduce")}}, {{jsxref("Array.prototype.reduceRight", "reduceRight")}}</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-array-objects', 'Array')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Novos metodos adicionados: {{jsxref("Array.from")}}, {{jsxref("Array.of")}}, {{jsxref("Array.prototype.find", "find")}}, {{jsxref("Array.prototype.findIndex", "findIndex")}}, {{jsxref("Array.prototype.fill", "fill")}}, {{jsxref("Array.prototype.copyWithin", "copyWithin")}}</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array-objects', 'Array')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Novo metodo adicionado: {{jsxref("Array.prototype.includes()")}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com os navegadores</h2> + +<p>{{ CompatibilityTable }}</p> + +<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 (WebKit)</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>Configuração</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Phone</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> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Ver também</h2> + +<ul> + <li><a href="/en-US/docs/JavaScript/Guide/Working_with_Objects#Indexing_object_properties" title="JavaScript/Guide/Working_with_objects#Indexing_object_properties">"Indexing object properties" in JavaScript Guide: "Working with objects"</a></li> + <li><a href="/en-US/docs/JavaScript/New_in_JavaScript/1.7#Array_comprehensions" title="New_in_JavaScript_1.7#Array_comprehensions">New in JavaScript 1.7: Array comprehensions</a></li> + <li><a href="/en-US/docs/JavaScript/New_in_JavaScript/1.6#Array_extras" title="New_in_JavaScript_1.6#Array_extras">New in JavaScript 1.6: Array extras</a></li> + <li><a href="/en-US/docs/JavaScript_typed_arrays" title="JavaScript_typed_arrays">Draft: Typed Arrays</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/indexof/index.html b/files/pt-br/web/javascript/reference/global_objects/array/indexof/index.html new file mode 100644 index 0000000000..1cb6328be8 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/indexof/index.html @@ -0,0 +1,186 @@ +--- +title: Array.prototype.indexOf() +slug: Web/JavaScript/Reference/Global_Objects/Array/indexOf +tags: + - Array + - JavaScript + - Método(2) + - Prototype + - Referência(2) + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf +--- +<div>{{JSRef}}</div> + +<div>O método <code><strong>indexOf() </strong></code>retorna o primeiro índice em que o elemento pode ser encontrado no array, retorna -1 caso o mesmo não esteja presente.</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>array</var>.indexOf(<var>elementoDePesquisa</var>, [pontoInicial = 0])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>elementoDePesquisa</code></dt> + <dd><code>Elemento a ser pesquisado no array.</code></dd> + <dt><code>pontoInicial</code></dt> + <dd>O índice para iniciar a procura. Se o índice for maior ou igual ao tamanho do array, é retornado -1 e signfica que o item não será procurado. Se o<code> pontoInicial é fornecido</code> com um número negativo, é tomado como deslocamento da extremidade do array. Nota: se o <code>pontoInicial</code> fornecido é negativo, a procura no array acontece de frente para trás. Se o <code>pontoInicial</code> fornecido é 0, então o array inteiro será pesquisado. Padrão: 0 (pesquisa em todo array).</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p><code>indexOf()</code> compara o <code>elementoDePesquisa</code> com os elementos do Array usando <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Using_the_Equality_Operators">igualdade estrita</a> (o mesmo método usado pelo ===, ou triple-equals operator). </p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_indexOf">Usando <code>indexOf()</code></h3> + +<p><code>O exemplo seguinte usa indexOf() para localizar valores em um array</code></p> + +<pre class="brush: js notranslate">var array = [2, 5, 9]; +array.indexOf(2); // 0 +array.indexOf(7); // -1 +array.indexOf(9, 2); // 2 +array.indexOf(2, -1); // -1 +array.indexOf(2, -3); // 0 +</pre> + +<h3 id="Encontrar_todas_as_ocorrências_de_um_elemento">Encontrar todas as ocorrências de um elemento</h3> + +<pre class="brush: js notranslate">var indices = []; +var array = ['a', 'b', 'a', 'c', 'a', 'd']; +var elemento = 'a'; +var idx = array.indexOf(elemento); +while (idx != -1) { + indices.push(idx); + idx = array.indexOf(elemento, idx + 1); +} +console.log(indices); +// [0, 2, 4] +</pre> + +<h3 id="Encontrar_se_um_elemento_existe_ou_não_e_atualizar_o_array">Encontrar se um elemento existe ou não e atualizar o array</h3> + +<pre class="brush: js notranslate">function atualizarColecaoVegetais (vegetais, vegetal) { + if (vegetais.indexOf(vegetal) === -1) { + vegetais.push(vegetal); + console.log('Nova coleção de vegetais é : ' + vegetais); + } else if (vegetais.indexOf(vegetal) > -1) { + console.log(vegetal + ' já existe na coleção de vegetais.'); + } +} + +var vegetais = ['batata', 'tomate', 'pimenta', 'pimentao']; + +atualizarColecaoVegetais(vegetais, 'espinafre'); +// Nova coleção de vegatais é : batata,tomate,pimenta,pimentao,espinafre +atualizarColecaoVegetais(vegetais, 'espinafre'); +// espinafre já existe na coleção de vegetais. +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>indexOf() </code>foi adicionado ao ECMA-262 standard em sua 5 edição; como tal, não pode estar presente em todos navegadores.Você pode contornar isso utilizando o seguinte codigo no inicio de seus scripts. Isto permitirá que voce use o <code>indexOf() </code>quando não possuir suporte nativo. Esse algoritmo corresponde ao especificado no ECMA-262, edição 5, assumindo {{jsxref("Global_Objects/TypeError", "TypeError")}} e {{jsxref("Math.abs()")}} tem seus valores originais.</p> + +<pre class="brush: js notranslate">// Passos para a produção do ECMA-262, Edition 5, 15.4.4.14 +// Referência: http://es5.github.io/#x15.4.4.14 +if (!Array.prototype.indexOf) { + Array.prototype.indexOf = function(elementoDePesquisa, pontoInicial) { + + var k; + + //1. Deixe-o ser o resultado da chamada de toObject + // passando o valor de this como argumento. + if (this == null) { + throw new TypeError('"this" é nulo (null) ou não foi definido (undefined)'); + } + + var O = Object(this); + + // 2. Deixar o tamanhoValor ser o resultado da + // chamada do método interno Get de 0 com o + // argumento "length" + // 3. Deixar o tamanhoValor ser um ToUint32(tamanhoValor). + var tamanho = O.length >>> 0; + + // 4. se o tamanho é 0, retorna -1. + if (tamanho === 0) { + return -1; + } + + // 5. Se o argumento pontoInicial for passado, + // use o ToInteger(pontoInicial); senao use 0. + var n = + pontoInicial || 0; + + if (Math.abs(n) === Infinity) { + n = 0; + } + + //6. Se n >= tamanho, retorna -1. + if (n >= tamanho) { + return -1; + } + + // 7. Se n>= 0, entao k seja n. + // 8. Senao, n<0, k seja tamanho - abs(n). + // Se k é menor que 0, entao k seja 0. + k = Math.max(n >= 0 ? n : tamanho - Math.abs(n), 0); + + // 9. Repita, enquanto k < tamanho + while (k < tamanho) { + // a. Deixe Pk ser ToString(k). + // isto é implicito para operandos LHS de um operador + + // b. Deixe o kPresent ser o resultado da chamada do método + // interno de 0 com argumento Pk + // Este passo pode ser combinado com c. + // c. Se kPresent é true, entao + // i. Deixe o elementK ser o resultado da chamada do metodo + // interno Get de 0 com argumento ToString(k) + // ii. Deixe o resultado ser aplicado pelo Algoritmo de + // Comparação de Igualdade Estrita (Strict Equality Comparison) + // para o elementoDePesquisa e elementK + // iii. caso verdadeiro, retorne k. + if (k in O && O[k] === elementoDePesquisa) { + return k; + } + k++; + } + return -1; + }; +}</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.4.4.14', 'Array.prototype.indexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> + <p>Definição inicial implementada no Javascript 1.6.</p> + </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_entre_Navegadores">Compatibilidade entre Navegadores</h2> + +<div id="compat-mobile">{{Compat("javascript.builtins.Array.indexOf")}}</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("TypedArray.prototype.indexOf()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/isarray/index.html b/files/pt-br/web/javascript/reference/global_objects/array/isarray/index.html new file mode 100644 index 0000000000..328790b8e9 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/isarray/index.html @@ -0,0 +1,141 @@ +--- +title: Array.isArray() +slug: Web/JavaScript/Reference/Global_Objects/Array/isArray +translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p><font face="Open Sans, Arial, sans-serif">O método </font><code><strong>Array.isArray()</strong></code> retorna <code>true</code> se um objeto é uma array, e <code>false</code> se não é.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code>Array.isArray(<var>obj</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>O objeto a ser verificado.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Se o objeto é um {{jsxref("Array")}}, retorna <code>true</code>(verdadeiro), caso contrário é retornado <code>false</code>(falso).</p> + +<p>Veja o artigo <a href="http://web.mit.edu/jwalden/www/isArray.html">“Determinando com absoluta precisão se um objeto em Javascript é ou não uma array”</a> para mais detalhes.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<pre class="brush: js">// todas as chamadas conseguintes retornam <code style="font-style: normal;">true</code> +Array.isArray([]); +Array.isArray([1]); +Array.isArray(new Array()); +// Pequeno detalhe: Array.prototype por si só é uma array: +Array.isArray(Array.prototype); + +// todas as conseguintes retornam false +Array.isArray(); +Array.isArray({}); +Array.isArray(null); +Array.isArray(undefined); +Array.isArray(17); +Array.isArray('Array'); +Array.isArray(true); +Array.isArray(false); +Array.isArray({ __proto__: Array.prototype }); +</pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p>Executando o seguinte código antes de qualquer outro, o método <code>Array.isArray()</code> será criado, caso o browser não o disponibilize nativamente.</p> + +<pre class="brush: js">if (!Array.isArray) { + Array.isArray = function(arg) { + return Object.prototype.toString.call(arg) === '[object Array]'; + }; +} +</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>{{SpecName('ES5.1', '#sec-15.4.3.2', 'Array.isArray')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definição Inicial. Implementado em JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.isarray', 'Array.isArray')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com o 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>{{CompatChrome("5")}}</td> + <td>{{CompatGeckoDesktop("2.0")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("10.5")}}</td> + <td>{{CompatSafari("5")}}</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>{{CompatGeckoMobile("2.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<p>Baseado na <a href="http://kangax.github.com/es5-compat-table/">Tabela de Compatibilidade de Kangax</a>.</p> + +<h2 id="See_also" name="See_also">Veja Também</h2> + +<ul> + <li>{{jsxref("Global_Objects/Array", "Array")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/join/index.html b/files/pt-br/web/javascript/reference/global_objects/array/join/index.html new file mode 100644 index 0000000000..703cc76de0 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/join/index.html @@ -0,0 +1,108 @@ +--- +title: Array.prototype.join() +slug: Web/JavaScript/Reference/Global_Objects/Array/join +translation_of: Web/JavaScript/Reference/Global_Objects/Array/join +--- +<div>{{JSRef}}</div> + +<div><font face="Open Sans, Arial, sans-serif">O método </font><code><strong>join()</strong></code> junta todos os elementos de um array (ou um <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Indexed_collections#Working_with_array-like_objects">array-like object</a>) em uma string e retorna esta string.</div> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>arr</var>.join([separador = ','])</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>separador</code> {{optional_inline}}</dt> + <dd>Específica uma string para separar cada elemento adjacente do array. O separador é convertido em uma string se necessário. Se omitido, os elementos do array são separados com uma vírgula (","). Se o <code style="font-style: normal;">separador</code> for uma string vazia, todos os elementos são juntados sem nenhum caracter entre eles.</dd> +</dl> + +<h3 id="Parameters" name="Parameters">Valor de retorno</h3> + +<dl> + <dd>Uma string com todos os elementos do array juntos. Se <code>arr.length</code> é <code>0</code>, uma string vazia é retornada.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>As conversões em string de todos os elementos de um array são juntados em apenas uma string.</p> + +<div class="warning"> +<p>Obs: Se um elemento é <code>undefined</code> ou <code>null</code>, ele é convertido em uma string vazia.</p> +</div> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Joining_an_array_three_different_ways" name="Example:_Joining_an_array_three_different_ways">Juntando um array de quatro formas diferentes</h3> + +<p>O exemplo interativo a seguir cria um array, <code>a</code>, com três elementos, e o junta três vezes: a primeira com virgulas, a segunda so junta os elementos e a terceira com um sinal de menos.</p> + +<p>{{EmbedInteractiveExample("pages/js/array-join.html")}} </p> + +<div class="hidden"> +<p>O codigo para o exemplo interativo esta disponivel em um repositorio no GitHub. Se você deseja contribuir projeto, clone o repositório <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um pull request.</p> +</div> + + + +<h3 id="Juntando_um_array-like_object_objeto_estilo-array">Juntando um array-like object (objeto estilo-array)</h3> + +<p>O exemplo abaixo junta um array-like object (ex: o objeto <code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a></code>), chamando {{jsxref("Function.prototype.call")}} no <code>Array.prototype.join</code>.</p> + +<pre class="brush: js notranslate"><code>function f(a, b, c) { + var s = Array.prototype.join.call(arguments); + console.log(s); // '1,a,true' +} +f(1, 'a', true); +//saida esperada: "1,a,true"</code></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>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado em JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.5', 'Array.prototype.join')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.join', 'Array.prototype.join')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.join', 'Array.prototype.join')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com o Browser</h2> + +<div class="hidden"> +<p>A tabela de compatibilidade nesta pagina é gerada a partir de dados estruturados. Se voce deseja contribuir para os dados, de uma olhada no repositorio <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</p> +</div> + +<div>{{Compat("javascript.builtins.Array.join")}}</div> + +<h2 id="See_also" name="See_also">Veja Também</h2> + +<ul> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.toString()")}}</li> + <li>{{jsxref("TypedArray.prototype.join()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/keys/index.html b/files/pt-br/web/javascript/reference/global_objects/array/keys/index.html new file mode 100644 index 0000000000..99a61b896a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/keys/index.html @@ -0,0 +1,115 @@ +--- +title: Array.prototype.keys() +slug: Web/JavaScript/Reference/Global_Objects/Array/keys +tags: + - Iteração + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>O método <code><strong>keys()</strong></code> retorna um novo <code><strong>Array Iterator</strong></code> que contém as chaves para cada <em>index</em> do array.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>arr</var>.keys()</code></pre> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Exemplo_uso_básico">Exemplo: uso básico</h3> + +<pre class="brush: js">var arr = ["a", "b", "c"]; +var iterator = arr.keys(); + +console.log(iterator.next()); // { value: 0, done: false } +console.log(iterator.next()); // { value: 1, done: false } +console.log(iterator.next()); // { value: 2, done: false } +console.log(iterator.next()); // { value: undefined, done: true } +</pre> + +<h3 id="Exemplo_keys_iterator_não_ignora_lacunas">Exemplo: keys iterator não ignora lacunas</h3> + +<pre class="brush: js">var arr = ["a", , "c"]; +var sparseKeys = Object.keys(arr); +var denseKeys = [...arr.keys()]; +console.log(sparseKeys); // [0, 2] +console.log(denseKeys); // [0, 1, 2] +</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>{{SpecName('ES6', '#sec-array.prototype.keys', 'Array.prototype.keys')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</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>{{CompatChrome("38")}}</td> + <td>{{CompatGeckoDesktop("28")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("25")}}</td> + <td>{{CompatSafari("7.1")}}</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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("28")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>iOS 8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.values()")}}</li> + <li>{{jsxref("Array.prototype.entries()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/lastindexof/index.html b/files/pt-br/web/javascript/reference/global_objects/array/lastindexof/index.html new file mode 100644 index 0000000000..0dc189d7f1 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/lastindexof/index.html @@ -0,0 +1,184 @@ +--- +title: Array.prototype.lastIndexOf() +slug: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>lastIndexOf()</strong></code> retorna o ultimo índice que um certo elemento pode ser encontrado no array, ou -1 se o elemento não estiver presente. O array é pesquisado de trás para frente, começando pelo <code>fromIndex</code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>arr</var>.lastIndexOf(<var>searchElement</var>[, <var>fromIndex</var> = arr.length - 1])</code></pre> + +<h2 id="Parâmetros">Parâmetros</h2> + +<dl> + <dt><code>searchElement</code></dt> + <dd>Elemento para ser localizado no array.</dd> + <dt><code>fromIndex</code></dt> + <dd>Opcional. O índice ao qual a busca será iniciada de traz para frente. O valor padrão é o tamanho total do array menos um (array.length -1), ou seja, todo o array será pesquisado. Se o índice for maior ou igual ao tamanho do array, o array inteiro será pesquisado. Se for negativo, ele é tomado como deslocamento no final do array. Note que mesmo se o índice for negativo, o array ainda será pesquisado de traz para frente. Se o índice calculado for menor que 0, -1 será retornado, ou seja, o array não será pesquisado.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p><code>lastIndexOf</code> compara <code>searchElement</code> a elementos do Array usando <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Using_the_Equality_Operators">igualdade rigorosa</a> (o mesmo método usado pelo operador ===, ou "igual triplo").</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Examplo_Usando_lastIndexOf">Examplo: Usando <code>lastIndexOf</code></h3> + +<p>O seguinte exemplo utiliza <code>lastIndexOf</code> para localizar elementos em um array.</p> + +<pre class="brush: js">var array = [2, 5, 9, 2]; +array.lastIndexOf(2); // 3 +array.lastIndexOf(7); // -1 +array.lastIndexOf(2, 3); // 3 +array.lastIndexOf(2, 2); // 0 +array.lastIndexOf(2, -2); // 0 +array.lastIndexOf(2, -1); // 3 +</pre> + +<h3 id="Exemplo_Encontrando_todas_as_ocorrências_de_um_elemento">Exemplo: Encontrando todas as ocorrências de um elemento</h3> + +<p>O seguinte exemplo utiliza <code>lastIndexOf</code> para encontrar todos os índices de um elemento em um dado array, utilizando {{jsxref("Array.prototype.push", "push")}} para adicioná-los em outro array quando são encontrados.</p> + +<pre class="brush: js">var indices = []; +var array = ['a', 'b', 'a', 'c', 'a', 'd']; +var element = 'a'; +var idx = array.lastIndexOf(element); +while (idx != -1) { + indices.push(idx); + idx = (idx > 0 ? array.lastIndexOf(element, idx - 1) : -1); +} + +console.log(indices); +// [4, 2, 0] +</pre> + +<p>Note que devemos tratar o caso <code>idx == 0</code> separadamente aqui pois o elemento será sempre encontrado independente do parâmetro <code>fromIndex</code> se ele for o primeiro elemento do array. Isso é diferente do método {{jsxref("Array.prototype.indexOf", "indexOf")}}.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>lastIndexOf</code> foi adicionado ao padrão ECMA-262 na 5ª edição; devido a isso, não deve estar presente em outras implementações do padrão. Você pode contornar isso inserindo o seguinte código no início dos seus scripts, permitindo o uso de <code>lastIndexOf</code> em implementações que não o suportam nativamente. Esse algorítimo é exatamente o mesmo especificado no padrão ECMA-262, 5ª edição, assumindo que {{jsxref("Global_Objects/Object", "Object")}}, {{jsxref("Global_Objects/TypeError", "TypeError")}}, {{jsxref("Global_Objects/Number", "Number")}}, {{jsxref("Math.floor")}}, {{jsxref("Math.abs")}}, e {{jsxref("Math.min")}} possuem seus valores originais.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.15 +// Reference: http://es5.github.io/#x15.4.4.15 +if (!Array.prototype.lastIndexOf) { + Array.prototype.lastIndexOf = function(searchElement /*, fromIndex*/) { + 'use strict'; + + if (this === void 0 || this === null) { + throw new TypeError(); + } + + var n, k, + t = Object(this), + len = t.length >>> 0; + if (len === 0) { + return -1; + } + + n = len - 1; + if (arguments.length > 1) { + n = Number(arguments[1]); + if (n != n) { + n = 0; + } + else if (n != 0 && n != (1 / 0) && n != -(1 / 0)) { + n = (n > 0 || -1) * Math.floor(Math.abs(n)); + } + } + + for (k = n >= 0 ? Math.min(n, len - 1) : len - Math.abs(n); k >= 0; k--) { + if (k in t && t[k] === searchElement) { + return k; + } + } + return -1; + }; +} +</pre> + +<p>Novamente, perceba que essa implementação foca na absoluta compatibilidade com <code>lastIndexOf</code> no Firefox e no motor JavaScript SpiderMonkey, incluíndo vários casos que são, indiscutivelmente, extremos. Se você pretende usar isso em aplicações reais, é possível calcular <code>from</code> com um código menos complicado se você ignorar esses casos.</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.4.4.15', 'Array.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.lastindexof', 'Array.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Browser">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>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatIE("9")}}</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="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> + <li>{{jsxref("TypedArray.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/length/index.html b/files/pt-br/web/javascript/reference/global_objects/array/length/index.html new file mode 100644 index 0000000000..a03b16502c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/length/index.html @@ -0,0 +1,128 @@ +--- +title: Array.prototype.length +slug: Web/JavaScript/Reference/Global_Objects/Array/length +translation_of: Web/JavaScript/Reference/Global_Objects/Array/length +--- +<div>{{JSRef}}</div> + +<p>A propriedade <code><strong>length</strong></code> representa um inteiro de 32-bit sem sinal, que especifíca o número de elementos em um array.</p> + +<div>{{js_property_attributes(1, 0, 0)}}</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>arr</var>.length</code></pre> + +<h2 id="Descrição">Descrição</h2> + +<p>O valor da propriedade length é um inteiro com um sinal positivo e valor menor que 2 elevado na 32ª potência(2<sup>32</sup>).</p> + +<p>Você pode setar o a propriedade <code>length</code> para truncar um array a qualquer momento. Quando você extende um array mudando sua propriedade <code>length</code>, o numero de elementos atuais não é incrementado; por exemplo, se você setar o tamanho para 3 quando ele é atualmente 2, o array continua somente com 2 elementos. Assim, a propriedade <code>length</code> não diz nada sobre o tamanho de valores definidos no array. Veja também <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#Relationship_between_length_and_numerical_properties" title="Relationship between length and numerical properties">Relacionamento entre <code>length</code> e propriedades numérica</a>s.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Iterando_sobre_um_array">Iterando sobre um array</h3> + +<p>No exemplo a seguir <code>numbers </code>é iterado considerando a propriedade <code>length</code> para ver quantos elementos ele tem. O valor de cada elemento recebe então o dobro.</p> + +<pre class="brush: js">var numbers = [1, 2, 3, 4, 5]; + +for (var i = 0; i < numbers.length; i++) { + numbers[i] *= 2; +} +// numbers is now [2, 4, 6, 8, 10] +</pre> + +<h3 id="Encurtando_um_array">Encurtando um array</h3> + +<p>O exemplo a seguir encurta o array <code>statesUS</code> para um tamanho de 50 se o tamanho corrente for maior do que 50.</p> + +<pre class="brush: js">if (statesUS.length > 50) { + statesUS.length = 50; +} +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.5.2', 'Array.length')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-array-instances-length', 'Array.length')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Browser">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>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="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/map/index.html b/files/pt-br/web/javascript/reference/global_objects/array/map/index.html new file mode 100644 index 0000000000..278e9ba6a4 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/map/index.html @@ -0,0 +1,255 @@ +--- +title: Array.prototype.map() +slug: Web/JavaScript/Reference/Global_Objects/Array/map +translation_of: Web/JavaScript/Reference/Global_Objects/Array/map +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <strong>map()</strong> invoca a função <code>callback</code> passada por argumento para cada elemento do Array e devolve um novo Array como resultado.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>arr</var>.map(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Função cujo retorno produz o elemento do novo Array. Recebe três argumentos: + <dl> + <dt><code>valorAtual</code></dt> + <dd>O valor do elemento original do Array de origem. </dd> + <dt><code>indice</code></dt> + <dd>O índice do elemento atual que está sendo processado no array.</dd> + <dt><code>array</code></dt> + <dd>O Array de origem.</dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Opcional. Valor a ser utilizado como o <em><code>this</code></em> no momento da execução da função <code>callback</code>.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>O método <strong><code>map</code></strong> chama a função <code>callback</code> recebida por parâmetro para cada elemento do Array original, em ordem, e constrói um novo array com base nos retornos de cada chamada. A função <code>callback</code> é chamada apenas para os elementos do array original que tiverem valores atribuídos; os elementos que estiverem como <code>undefined</code>, que tiverem sido removidos ou os que nunca tiveram valores atribuídos não serão considerados.</p> + +<p>A função <code>callback</code> é chamada com três argumentos: o valor do elemento corrente, o índice do elemento corrente e o array original que está sendo percorrido.</p> + +<p>Se o parametro <code>thisArg</code> foi passado para o método <code>map</code>, ele será repassado para a função <code>callback</code> no momento da invocação para ser utilizado como o <code>this</code>. Caso contrário, o valor {{jsxref("Global_Objects/undefined", "undefined")}} será repassado para uso como o <em><code>this</code></em>. O valor do <code>this</code> a ser repassado para o <code>callback</code> deve respeitar as <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">regras para determinar como o this é acessado por uma função</a> (em inglês).</p> + +<p>O método <code>map</code> não modifica o array original. No entanto, a função <code>callback</code> invocada por ele pode fazê-lo.</p> + +<p>A lista de elementos que serão processados pelo <code>map</code> é montada antes da primeira invocação à função <code>callback</code>. Se um elemento for acrescentado ao array original após a chamada ao <code>map</code>, ele não será visível para o <code>callback</code>. Se os elementos existentes forem modificados, os valores que serão repassados serão os do momento em que o método <code>map</code> invocar o <code>callback</code>. Elementos removidos não serão visitados.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Mapping_an_array_of_numbers_to_an_array_of_square_roots" name="Example:_Mapping_an_array_of_numbers_to_an_array_of_square_roots">Exemplo: Mapeando um array de números para um array de raízes quadradas</h3> + +<p>O código a seguir mapeia um array de números e cria um novo array contendo o valor da raiz quadrada de cada número do primeiro array.</p> + +<pre class="brush: js">var numbers = [1, 4, 9]; +var roots = numbers.map(Math.sqrt); +// roots é [1, 2, 3], numbers ainda é [1, 4, 9] +</pre> + +<h3 id="Example_Mapping_an_array_of_numbers_using_a_function_containing_an_argument" name="Example:_Mapping_an_array_of_numbers_using_a_function_containing_an_argument">Exemplo: Mapeando um array de números usando uma função <code>callback</code> que contém um argumento</h3> + +<p>O código a seguir mostrar como o método <code>map</code> funciona quando a função <code>callback</code> possui apenas um argumento. Esse argumento será automaticamente atribuído para cada elemento do array conforme o <code>map</code> itera sobre o array original.</p> + +<pre class="brush: js">var numbers = [1, 4, 9]; +var doubles = numbers.map(function(num) { + return num * 2; +}); +// doubles é agora [2, 8, 18]. numbers ainda é [1, 4, 9] +</pre> + +<h3 id="Example_using_map_generically" name="Example:_using_map_generically">Exemplo: usando <code>map</code> genericamente</h3> + +<p>Esse exemplo demonstra como usar o map em um {{jsxref("Global_Objects/String", "String")}} para recuperar a representação em ASCII de cada caracter em um array de bytes:</p> + +<pre class="brush: js">var map = Array.prototype.map; +var a = map.call('Hello World', function(x) { return x.charCodeAt(0); }); +// a agora vale [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100] +</pre> + +<h3 id="Example_using_map_generically_querySelectorAll" name="Example:_using_map_generically_querySelectorAll">Exemplo: usando <code>map</code> genericamente com <code>querySelectorAll</code></h3> + +<p>Esse exemplo demonstra como iterar sobre uma coleção de objetos recuperada através de querySelectorAll. Nesse caso, vamos pegar todos os options selecionados na tela e imprimir no console:</p> + +<pre class="brush: js">var elems = document.querySelectorAll('select option:checked'); +var values = [].map.call(elems, function(obj) { + return obj.value; +}); +</pre> + +<h3 id="Exemplo_Usando_map_para_inverter_uma_string">Exemplo: Usando <code>map</code> para inverter uma string</h3> + +<pre class="brush: js">var str = '12345'; +[].map.call(str, function(x) { + return x; +}).reverse().join(''); + +// Output: '54321' +// Bonus: utilize '===' para verificar se a string original e a nova string são palíndromos +</pre> + +<h3 id="Example_Tricky_use_case" name="Example:_Tricky_use_case">Exemplo: Caso de uso mais complexo</h3> + +<p><a href="http://www.wirfs-brock.com/allen/posts/166">(inspirado nesse post)</a> (em inglês)</p> + +<p>É uma prática comum utilizar o callback com apenas um argumento (o elemento atual do array original). Algumas funções também são comumente utilizadas com um argumento, mesmo tendo argumentos adicionais opcionais. Esses hábitos podem resultar em comportamentos indesejado:</p> + +<pre class="brush: js">// Considere: +['1', '2', '3'].map(parseInt); +// Enquanto era de se esperar [1, 2, 3] +// O resultado atual é [1, NaN, NaN] + +// <code>parseInt é normalmente usado com apenas um argumento, mas ele possui dois</code>. +// O primeiro é uma expressão, e o segundo o radical. +// Para a função callback, o Array.prototype.map repassa 3 argumentos: +// o elemento corrente, o indice e o array original +// O terceiro argumento é ignorado pelo parseInt, mas o segundo não, o que certamente gerou o comportamento inesperado. Veja o post para maiores detalhes + +function returnInt(element) { + return parseInt(element, 10); +} + +['1', '2', '3'].map(returnInt); // [1, 2, 3] +// O resultado atual é um array de números (como esperado) + +// Bonus: Um jeito mais simples de conseguir o mesmo resultado sem nenhuma "pegadinha do Malandro": +['1', '2', '3'].map(Number); // [1, 2, 3] +</pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p>(veja definição em <a href="https://pt.wikipedia.org/wiki/Polyfill">Polyfill</a>)</p> + +<p>O método <code>map</code> foi introduzido ao padrão ECMA-262 na sua 5ª edição, o que significa que ele pode não estar presente em todas as implementações desse padrão. Você pode contornar esse problema inserindo o código a seguir no início dos seus scripts, permitindo o uso do <code>map</code> mesmo que ele não esteja sendo suportado nativamente. Esse algoritmo é exatamente o especificado no ECMA-262 5ª edição, assumindo que {{jsxref("Global_Objects/Object", "Object")}}, {{jsxref("Global_Objects/TypeError", "TypeError")}}, e {{jsxref("Global_Objects/Array", "Array")}} tenham seus valores originais, e que <code style="font-style: normal;">callback.call</code> avalie para o valor original de <code style="font-style: normal;">{{jsxref("Function.prototype.call")}}</code>.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.19 +// Reference: http://es5.github.io/#x15.4.4.19 +if (!Array.prototype.map) { + + Array.prototype.map = function(callback, thisArg) { + + var T, A, k; + + if (this == null) { + throw new TypeError(' this is null or not defined'); + } + + // 1. Let O be the result of calling ToObject passing the |this| + // value as the argument. + var O = Object(this); + + // 2. Let lenValue be the result of calling the Get internal + // method of O with the argument "length". + // 3. Let len be ToUint32(lenValue). + var len = O.length >>> 0; + + // 4. If IsCallable(callback) is false, throw a TypeError exception. + // See: http://es5.github.com/#x9.11 + if (typeof callback !== 'function') { + throw new TypeError(callback + ' is not a function'); + } + + // 5. If thisArg was supplied, let T be thisArg; else let T be undefined. + if (arguments.length > 1) { + T = thisArg; + } + + // 6. Let A be a new array created as if by the expression new Array(len) + // where Array is the standard built-in constructor with that name and + // len is the value of len. + A = new Array(len); + + // 7. Let k be 0 + k = 0; + + // 8. Repeat, while k < len + while (k < len) { + + var kValue, mappedValue; + + // a. Let Pk be ToString(k). + // This is implicit for LHS operands of the in operator + // b. Let kPresent be the result of calling the HasProperty internal + // method of O with argument Pk. + // This step can be combined with c + // c. If kPresent is true, then + if (k in O) { + + // i. Let kValue be the result of calling the Get internal + // method of O with argument Pk. + kValue = O[k]; + + // ii. Let mappedValue be the result of calling the Call internal + // method of callback with T as the this value and argument + // list containing kValue, k, and O. + mappedValue = callback.call(T, kValue, k, O); + + // iii. Call the DefineOwnProperty internal method of A with arguments + // Pk, Property Descriptor + // { Value: mappedValue, + // Writable: true, + // Enumerable: true, + // Configurable: true }, + // and false. + + // In browsers that support Object.defineProperty, use the following: + // Object.defineProperty(A, k, { + // value: mappedValue, + // writable: true, + // enumerable: true, + // configurable: true + // }); + + // For best browser support, use the following: + A[k] = mappedValue; + } + // d. Increase k by 1. + k++; + } + + // 9. return A + return A; + }; +} +</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>{{SpecName('ES5.1', '#sec-15.4.4.19', 'Array.prototype.map')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definição inicial implementada no JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.map', 'Array.prototype.map')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com os browsers</h2> + +<div>{{Compat("javascript.builtins.Array.map")}}</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Map")}} object</li> + <li>{{jsxref("Array.from()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/observe/index.html b/files/pt-br/web/javascript/reference/global_objects/array/observe/index.html new file mode 100644 index 0000000000..d1b06c5ecf --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/observe/index.html @@ -0,0 +1,128 @@ +--- +title: Array.observe() +slug: Web/JavaScript/Reference/Global_Objects/Array/observe +translation_of: Archive/Web/JavaScript/Array.observe +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>O método <strong><code>Array.observe()</code></strong> é usado para observar mudanças de forma assíncrona em Arrays, de forma similar ao método {{jsxref("Object.observe()")}} para objetos. O método fornece um conjunto de mudanças em ordem de ocorrência. É equivalente ao método <code>Object.observe()</code> invocado com a lista aceita <code>["add", "update", "delete", "splice"]</code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Array.observe(<var>arr</var>, <var>callback</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>arr</code></dt> + <dd>O array a ser observado.</dd> + <dt><code>callback</code></dt> + <dd>A função chamado cada vez que ocorrem mudanças, com o seguinte argumento: + <dl> + <dt><code>changes</code></dt> + <dd>Um array de objetos, sendo que cada um representa uma mudança. As propriedades destes objetos são: + <ul> + <li><strong><code>name</code></strong>: O nome da propriedade que mudou.</li> + <li><strong><code>object</code></strong>: O array modificado depois que a mudança ocorreu.</li> + <li><strong><code>type</code></strong>: Uma string que indica o tipo de mudança que ocorreu. Pode ser <code>"add"</code>, <code>"update"</code>, <code>"delete"</code>, ou <code>"splice"</code>.</li> + <li><strong><code>oldValue</code></strong>: Apenas para os tipos <code>"update"</code> e <code>"delete"</code>. O valor antes da mudança.</li> + <li><strong><code>index</code></strong>: Apenas para o tipo <code>"splice"</code>. O índice no qual ocorreu a mudança.</li> + <li><strong><code>removed</code></strong>: Apenas para o tipo <code>"splice"</code>. Um array de elementos removidos.</li> + <li><strong><code>addedCount</code></strong>: Apenas para o tipo <code>"splice"</code>. O número de elementos adicionados.</li> + </ul> + </dd> + </dl> + </dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>A função <code>callback</code> é chamada cada vez que uma mudança é feita em <code>arr</code>, com um array de todas as mudanças na ordem em que elas ocorreram.</p> + +<div class="note"> +<p>Mudanças feitas via métodos de Array, tais como <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop"><code>Array.prototype.pop()</code></a> serão reportados como mudanças do tipo <code>"splice"</code>. Mudanças do tipo índice que não alteram o tamanho do array podem ser reportadas como mudanças do tipo <code>"update"</code>.</p> +</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Adicionando_diferentes_tipos_em_log">Adicionando diferentes tipos em log</h3> + +<pre class="brush: js">var arr = ['a', 'b', 'c']; + +Array.observe(arr, function(changes) { + console.log(changes); +}); + +arr[1] = 'B'; +// [{type: 'update', object: <arr>, name: '1', oldValue: 'b'}] + +arr[3] = 'd'; +// [{type: 'splice', object: <arr>, index: 3, removed: [], addedCount: 1}] + +arr.splice(1, 2, 'beta', 'gamma', 'delta'); +// [{type: 'splice', object: <arr>, index: 1, removed: ['B', 'c', 'd'], addedCount: 3}] +</pre> + +<h2 id="Especificações">Especificações</h2> + +<p><a href="https://github.com/arv/ecmascript-object-observe">Strawman proposal specification</a>.</p> + +<h2 id="Compatibilidade_com_Browser">Compatibilidade com Browser</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("36")}}</td> + <td>{{CompatNo}}</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>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>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</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><a href="//stackoverflow.com/q/29269057/778272">Em qual condição a chamada Array.observe irá "adicionar" um gatilho para um evento?</a></li> + <li>{{jsxref("Array.unobserve()")}} {{non-standard_inline}}</li> + <li>{{jsxref("Object.observe()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/of/index.html b/files/pt-br/web/javascript/reference/global_objects/array/of/index.html new file mode 100644 index 0000000000..d7d72259cb --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/of/index.html @@ -0,0 +1,108 @@ +--- +title: Array.of() +slug: Web/JavaScript/Reference/Global_Objects/Array/of +tags: + - Array + - ECMAScript6 + - JavaScript + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/of +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>Array.of()</strong></code> cria um nova instância de <code>Array</code> com um número variável de argumentos, independentemente do número ou do tipo dos argumentos.</p> + +<p>A diferença entre o <code><strong>Array.of()</strong></code> e o construtor de <code><strong>Array</strong></code> é no tratamento dos argumentos inteiros: <code><strong>Array.of(7)</strong></code> cria um array com um único elemento, <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">7</span></font>, enquanto <code><strong>Array(7)</strong></code> cria um array vazio de propriedade <code>length</code> igual a <code>7</code> (<strong>Nota</strong>: isso quer dizer um array com <code>7</code> espaços vazios, e não com valores do tipo {{jsxref("undefined")}}).</p> + +<pre>Array.of(7); // [7] +Array.of(1, 2, 3); // [1, 2, 3] + +Array(7); // array com 7 espaços vazios +Array(1, 2, 3); // [1, 2, 3] +</pre> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><code>Array.of(<var>element0</var>[, <var>element1</var>[, ...[, <var>elementN</var>]]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>element<em>N</em></code></dt> + <dd>Elementos usados para criar o <code>array</code>.</dd> + <dt> + <h3 id="Valor_de_retorno">Valor de retorno</h3> + </dt> + <dd>Uma nova instância de {{jsxref("Array")}}. </dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Esta função é parte do padrão ECMAScript 6 (ou ECMAScript 2015).</p> + +<p>Para maiores informações veja:</p> + +<ul> + <li><a href="https://gist.github.com/rwaldron/1074126"><code>Array.of</code> </a></li> + <li><a href="https://gist.github.com/rwaldron/1074126"><code>Array.from</code> proposal</a></li> + <li><a href="https://gist.github.com/rwaldron/3186576"><code>Array.of</code> polyfill</a>.</li> +</ul> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js">Array.of(1); // [1] +Array.of(1, 2, 3); // [1, 2, 3] +Array.of(undefined); // [undefined] +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Executando o seguinte código antes de qualquer outro c[odigo criará o <code>Array.of()</code> se ele não for disponível nativamente.</p> + +<pre class="brush: js">if (!Array.of) { + Array.of = function() { + return Array.prototype.slice.call(arguments); + // Or + let vals = []; + for(let prop in arguments){ + vals.push(arguments[prop]); + } + return vals; + }; +} +</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-array.of', 'Array.of')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2> + +<div id="compat-mobile"> +<div class="hidden"> +<p>A tabela de compatibilidade nesta página é gerada por dados estruturados. Se você quiser contribuir com os dados, visite <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie uma <em>pull request</em>.</p> +</div> + +<p>{{Compat("javascript.builtins.Array.of")}}</p> +</div> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Array.from()")}}</li> + <li>{{jsxref("TypedArray.of()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/pop/index.html b/files/pt-br/web/javascript/reference/global_objects/array/pop/index.html new file mode 100644 index 0000000000..6bd4c55b5e --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/pop/index.html @@ -0,0 +1,81 @@ +--- +title: Array.prototype.pop() +slug: Web/JavaScript/Reference/Global_Objects/Array/pop +tags: + - Array + - JavaScript + - Pop +translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <code><strong>pop()</strong></code> remove o <strong>último</strong> elemento de um array e retorna aquele elemento.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>arr</var>.pop()</code></pre> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>O método <code>pop</code> remove o último elemento de um array e retorna aquele valor.</p> + +<p>Esse método é intencionalmente genérico. Podendo ser utilizado por {{jsxref("Function.call", "call", "", 1)}} ou {{jsxref("Function.apply", "apply", "", 1)}} em objetos que implementam arrays.</p> + +<p>Se você chamar <code>pop()</code> em um array vazio, ele retorna o valor {{jsxref("Global_Objects/undefined", "undefined")}}.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Removing_the_last_element_of_an_array" name="Example:_Removing_the_last_element_of_an_array">Exemplo: Removendo o último elemento de um array</h3> + +<p>O código seguinte cria o array <code>meuPeixe </code>contendo quatro elementos e então remove seu último elemento.</p> + +<pre class="brush: js notranslate">var meuPeixe = ['acara-bandeira', 'palhaco', 'mandarim', 'esturjao']; + +console.log(meuPeixe); // ['acara-bandeira', 'palhaco', 'mandarim', 'esturjao'] + +var meuPeixePop = meuPeixe.pop(); + +console.log(meuPeixe); // ['acara-bandeira', 'palhaco', 'mandarim' ] + +console.log(meuPeixePop); // 'esturjao'</pre> + +<h2 id="Specifications" name="Specifications">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>ECMAScript 3ª Edição</td> + <td>Padrão</td> + <td>Definição inicial. Implementado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.6', 'Array.prototype.pop')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade nos Navegadores</h2> + +<div>{{Compat("javascript.builtins.Array.pop")}}</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.push()")}}</li> + <li>{{jsxref("Array.prototype.shift()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/array/prototype/index.html new file mode 100644 index 0000000000..e863d9cc69 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/prototype/index.html @@ -0,0 +1,206 @@ +--- +title: Array.prototype +slug: Web/JavaScript/Reference/Global_Objects/Array/prototype +tags: + - Array + - JavaScript + - Propriedade +translation_of: Web/JavaScript/Reference/Global_Objects/Array/prototype +--- +<div>{{JSRef}}</div> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Instâncias de {{jsxref("Global_Objects/Array", "Array")}} herdam de <code>Array.prototype</code>. Como em todos os construtores, você pode mudar o protótipo desse construtor para modificar todas as instâncias de {{jsxref("Global_Objects/Array", "Array")}}.</p> + +<p>Contudo, a adição de métodos não-padronizados ao objeto array pode causar problemas futuros, seja com seu próprio código, ou na <a href="https://developers.google.com/web/updates/2018/03/smooshgate">adição de novas funcionalidades ao JavaScript</a>.</p> + +<p>Um fato pouco conhecido: O próprio <code>Array.prototype </code>é um {{jsxref("Global_Objects/Array", "Array")}}</p> + +<pre class="brush: js">Array.isArray(Array.prototype); // true +</pre> + +<h2 id="Properties" name="Properties">Propriedades</h2> + +<dl> + <dt><code>Array.prototype.constructor</code></dt> + <dd>Especifica a função que cria um objeto do protótipo.<br> + </dd> + <dt>{{jsxref("Array.prototype.length")}}</dt> + <dd>Reflete o número de elementos em um array.</dd> +</dl> + +<h2 id="Methods" name="Methods">Métodos</h2> + +<h3 id="Mutator_methods" name="Mutator_methods">Métodos modificadores</h3> + +<p>Esses métodos modificam o array:</p> + +<dl> + <dt>{{jsxref("Array.prototype.copyWithin()")}} {{experimental_inline}}</dt> + <dd>Copia uma sequência de elementos do array dentro do array.</dd> + <dt>{{jsxref("Array.prototype.fill()")}} {{experimental_inline}}</dt> + <dd>Preenche todos os elementos de um array com um elemento estático, começando de um índice inicial até um índice final.</dd> + <dt>{{jsxref("Array.prototype.pop()")}}</dt> + <dd>Remove e retorna o último elemento de um array.</dd> + <dt>{{jsxref("Array.prototype.push()")}}</dt> + <dd>Adiciona um ou mais elementos ao fim de um array e retorna o novo comprimeiro do array.</dd> + <dt>{{jsxref("Array.prototype.reverse()")}}</dt> + <dd>Reverte a ordem dos elementos de um array - o primeiro vira o último e o último vira o primeiro.</dd> + <dt>{{jsxref("Array.prototype.shift()")}}</dt> + <dd>Remove o primeiro elemento de um array e o retorna.</dd> + <dt>{{jsxref("Array.prototype.sort()")}}</dt> + <dd>Ordena os elementos do array em questão e retorna o array.</dd> + <dt>{{jsxref("Array.prototype.splice()")}}</dt> + <dd>Adiciona e/ou remove elementos de um array.</dd> + <dt>{{jsxref("Array.prototype.unshift()")}}</dt> + <dd>Adiciona um ou mais elementos ao início de um array e retorna o novo comprimento do array.</dd> +</dl> + +<h3 id="Accessor_methods" name="Accessor_methods">Métodos de acesso</h3> + +<p>Esses métodos não modificam o array, mas sim retornam alguma representação dele.</p> + +<dl> + <dt>{{jsxref("Array.prototype.concat()")}}</dt> + <dd>Retorna um novo array formado por esse array concatenado com outro(s) array(s) e/ou valores.</dd> + <dt>{{jsxref("Array.prototype.contains()")}} {{experimental_inline}}</dt> + <dd>Verifica se o array possui cer, retornando<code>true</code> ou <code>false</code> apropriadamente.</dd> + <dt>{{jsxref("Array.prototype.join()")}}</dt> + <dd>Retorna uma string com todos os elementos do array</dd> + <dt>{{jsxref("Array.prototype.slice()")}}</dt> + <dd>Retorna um novo array com uma parte do array sobre o qual o método foi chamado</dd> + <dt>{{jsxref("Array.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Retorna um array literal representando o array especificado; você pode usar esse valor para criar um novo array. Esse método sobrescreve o método {{jsxref("Object.prototype.toSource()")}}.</dd> + <dt>{{jsxref("Array.prototype.toString()")}}</dt> + <dd>Retonar uma string representando o array e seus elementos. Esse método sobrescreve o método {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("Array.prototype.toLocaleString()")}}</dt> + <dd>Retonar uma string adequada ao idioma do usuário representando o array e seus elementos. Esse método sobrescreve o método {{jsxref("Object.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("Array.prototype.indexOf()")}}</dt> + <dd>Representa o índice da primeira ocorrência de um valor especificado no array, ou -1 se o valor não estiver incluso no array.</dd> + <dt>{{jsxref("Array.prototype.lastIndexOf()")}}</dt> + <dd>Representa o índice da última ocorrência de um valor especificado no array, ou -1 se o valor não estiver incluso no array</dd> +</dl> + +<h3 id="Iteration_methods" name="Iteration_methods">Métodos de iteração</h3> + +<p>Vários métodos tomam como funções de argumento para serem chamados de volta ao processar o array. Quando esses métodos são chamados, o `<code>length` do array</code> é amostrado e qualquer elemento adicionado além deste comprimento (length) de dentro da função (callback) não é visitado. Outras alterações para o array (Definindo o valor de ou apagando um elemento) pode afetar os resultados da operação se o método visita o elemento alterado posteriormente. Enquanto o comportamento específico destes métodos nestes casos é bem definido, não se deve confiar nisso para não confundir os outros que possoam ler seu código. Em vez disso, deve-se copiar para um novo array para modificá-lo.</p> + +<dl> + <dt>{{jsxref("Array.prototype.forEach()")}}</dt> + <dd>Chama a função para cada elemento no array.</dd> + <dt>{{jsxref("Array.prototype.entries()")}} {{experimental_inline}}</dt> + <dd>Retorna um novo objeto <code>Array Iterator</code> que contem o par chave/valor para cada índice no array.</dd> + <dt>{{jsxref("Array.prototype.every()")}}</dt> + <dd>Retorna true se todos elementos no array satisfizer a função de teste fornecida.</dd> + <dt>{{jsxref("Array.prototype.some()")}}</dt> + <dd>Retorna true se pelo menos um elemento no array satisfizer a função de teste fornecida.</dd> + <dt>{{jsxref("Array.prototype.filter()")}}</dt> + <dd>Cria um novo array com todos os elementos do array para qual a função de filtragem fornecida retorne true.</dd> + <dt>{{jsxref("Array.prototype.find()")}} {{experimental_inline}}</dt> + <dd>Retorna o valor encontrado no array, se um elemento no array satisfizer a funçào de teste fornecida ou `<code>undefined` </code>se não for encontrado.</dd> + <dt>{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}</dt> + <dd>Retorna o índice no array, se um elemento no array satisfizer a função de teste fornecida ou -1 se não for encontrado.</dd> + <dt>{{jsxref("Array.prototype.keys()")}} {{experimental_inline}}</dt> + <dd>Retorna um novo <code>Array Iterator</code> que contem a chave para cada índice no array.</dd> + <dt>{{jsxref("Array.prototype.map()")}}</dt> + <dd>Cria um novo array com os resultados da função fornecida chamada em cada elemento na array.</dd> + <dt>{{jsxref("Array.prototype.reduce()")}}</dt> + <dd>Aplica uma função contra um acumulador e cada valor do array (da esquerda para direita) para reduzi-los a um único valor.</dd> + <dt>{{jsxref("Array.prototype.reduceRight()")}}</dt> + <dd>Aplica uma função contra um acumulador e cada valor do array (da direita para esquerda) para reduzi-los a um único valor.</dd> + <dt>{{jsxref("Array.prototype.values()")}} {{experimental_inline}}</dt> + <dd>Retorna um novo objeto <code>Array Iterator</code> que contem os valores de cada índice no array.</dd> + <dt>{{jsxref("Array.prototype.@@iterator()", "Array.prototype[@@iterator]()")}} {{experimental_inline}}</dt> + <dd>Retorna um novo objeto <code>Array Iterator</code> que contem os valores de cada índice no array.</dd> +</dl> + +<h3 id="Generic_methods" name="Generic_methods">Métodos genéricos</h3> + +<p>Vários métodos do objeto Array em Javascript foram feitos para serem aplicados genericamentes em todos os objetos que "pareçam" Arrays. Isso é, eles podem ser usados em qualquer objeto que possuam uma propriedade <code>length</code> (comprimento), e que possa ser usado a partir de propriedades numéricas (como índices no formato <code>array[5]</code>). Alguns métodos, como {{jsxref("Array.join", "join")}}, apenas lêem e as propriedades numéricas do objeto sobre o qual eles sãochamados. Outros, como {{jsxref("Array.reverse", "reverse")}}, exigem que as propriedades numéricas e <code>length </code>sejam mutáveis; sendo assim, esses métodos não podem ser chamados em objetos como {{jsxref("Global_Objects/String", "String")}}, que não permitem que nenhuma das duas propriedades sejam modificadas.</p> + +<h2 id="Specifications" name="Specifications">Especifiaçõ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>ECMAScript 1st Edition.</td> + <td>Padrão</td> + <td>Definição inicial</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.3.1', 'Array.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype', 'Array.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>Característica</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>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>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("Global_Objects/Array", "Array")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/push/index.html b/files/pt-br/web/javascript/reference/global_objects/array/push/index.html new file mode 100644 index 0000000000..7b93843b2b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/push/index.html @@ -0,0 +1,184 @@ +--- +title: Array.prototype.push() +slug: Web/JavaScript/Reference/Global_Objects/Array/push +tags: + - Array + - JavaScript + - Push +translation_of: Web/JavaScript/Reference/Global_Objects/Array/push +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <strong>push() </strong>adiciona um ou mais elementos ao final de um array e retorna o novo comprimento desse array.</p> + +<pre class="brush: js">var numeros = [1, 2, 3]; +numeros.push(4); + +console.log(numeros); // [1, 2, 3, 4] + +numeros.push(5, 6, 7); + +console.log(numeros); // [1, 2, 3, 4, 5, 6, 7] +</pre> + +<p><strong style="font-size: 2.14285714285714rem; font-weight: 700; letter-spacing: -1px; line-height: 30px;">Sintaxe</strong></p> + +<pre class="syntaxbox"><code><var>arr</var>.push(<var>elemento1</var>, ..., <var>elementoN</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>elemento<em>N</em></code></dt> + <dd>Os elementos a serem incluídos ao final do array.</dd> +</dl> + +<h3 id="Returns" name="Returns">Retorno</h3> + +<p>O novo valor da propriedade {{jsxref("Array.length", "length")}} do objeto no qual o método foi chamado.</p> + +<p><strong style="font-size: 2.14285714285714rem; font-weight: 700; letter-spacing: -1px; line-height: 30px;">Descrição</strong></p> + +<p>O método <code style="font-style: normal;">push</code> adiciona valores a um array.</p> + +<p>Esse método é intencionalmente genérico. Podendo ser utilizado por {{jsxref("Function.call", "call()")}} ou {{jsxref("Function.apply", "apply()")}} em objetos que implementam arrays. O método <span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">push </span><span style="line-height: 1.5;">depende da propriedade </span><span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">length</span><span style="line-height: 1.5;"> para determinar onde começar a inserir os valores. Caso a propriedade <code>length</code></span> não possa ser convertida em número, é utilizado 0 como índice. Isto inclui a possibilidade de <code>length </code>não existir, nesse caso, essa propriedade será criada.</p> + +<p>Os únicos objetos que implementam nativamente array são as {{jsxref("Global_Objects/String", "strings", "", 1)}}, porém elas não são adequadas para a aplicação desse método, pois são imutáveis.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Adding_elements_to_an_array" name="Example:_Adding_elements_to_an_array">Exemplo: Adicionando elementos a um array</h3> + +<p>O seguinte código cria um array <code>esportes</code> que contém dois elementos. Então adiciona dois elementos a ele. A variável <code>total</code> contém o novo comprimento do array.</p> + +<pre class="brush: js">var esportes = ['futebol', 'beisebol']; +var total = esportes.push('handebol', 'natacao'); + +console.log(esportes); // ['futebol, 'beisebol', 'handebol', 'natacao'] +console.log(total); // 4 +</pre> + +<h3 id="Example:_Adding_elements_to_an_array" name="Example:_Adding_elements_to_an_array" style="line-height: 24px; font-size: 1.71428571428571rem;">Exemplo: Fusão de dois arrays</h3> + +<p>Este exemplo utiliza {{jsxref("Function.apply", "apply()")}} para adicionar todos os elementos de um segundo array.</p> + +<pre class="brush: js language-js" style="padding: 1em 0px 1em 30px; font-size: 14px; white-space: normal; color: rgb(77, 78, 83);"><code class="language-js" style="direction: ltr; white-space: pre;"><span class="keyword token" style="color: #0077aa;">var</span> vegetais <span class="operator token" style="background: rgba(255, 255, 255, 0.498039); color: #a67f59;">=</span> <span class="punctuation token" style="color: #999999;">[</span><span class="string token" style="color: #669900;">'cenoura'</span><span class="punctuation token" style="color: #999999;">,</span> <span class="string token" style="color: #669900;">'batata'</span><span class="punctuation token" style="color: #999999;">]</span><span class="punctuation token" style="color: #999999;">;</span> +<span class="keyword token" style="color: #0077aa;">var</span> maisVegetais <span class="operator token" style="background: rgba(255, 255, 255, 0.498039); color: #a67f59;">=</span> <span class="punctuation token" style="color: #999999;">[</span><span class="string token" style="color: #669900;">'aipo'</span><span class="punctuation token" style="color: #999999;">,</span> <span class="string token" style="color: #669900;">'beterraba'</span><span class="punctuation token" style="color: #999999;">]</span><span class="punctuation token" style="color: #999999;">;</span> +<span class="comment token" style="color: #708090;"> +// Adiciona o segundo array no primeiro +</span><span class="comment token" style="color: #708090;">// Equivalente a vegetais.push('aipo', 'beterraba'); +</span>Array<span class="punctuation token" style="color: #999999;">.</span>prototype<span class="punctuation token" style="color: #999999;">.</span>push<span class="punctuation token" style="color: #999999;">.</span><span class="function token" style="color: #dd4a68;">apply<span class="punctuation token" style="color: #999999;">(</span></span>vegetais<span class="punctuation token" style="color: #999999;">,</span> maisVegetais<span class="punctuation token" style="color: #999999;">)</span><span class="punctuation token" style="color: #999999;">;</span> + +console<span class="punctuation token" style="color: #999999;">.</span><span class="function token" style="color: #dd4a68;">log<span class="punctuation token" style="color: #999999;">(</span></span>vegetais<span class="punctuation token" style="color: #999999;">)</span><span class="punctuation token" style="color: #999999;">;</span><span class="comment token" style="color: #708090;"> // ['cenoura', 'batata', 'aipo', 'beterraba']</span></code></pre> + +<h3 id="Example:_Using_an_object_in_an_array-like_fashion" name="Example:_Using_an_object_in_an_array-like_fashion" style="line-height: 24px; font-size: 1.71428571428571rem;">Exemplo: Utilizando um object como um array-like</h3> + +<p>Como mencionado acima, <code>push</code> é intencionalmente genérico, e podemos usar isso para nossa vantagem. <code>Array.prototype.push</code> pode trabalhar em um objeto muito bem, como mostra este exemplo. Observe que não criamos um array para armazenar uma coleção de objetos. Em vez disso, armazenamos a coleção no objeto em si e usamos a chamada em <code>Array.prototype.push</code> para enganar o método e pensar que estamos lidando com um array, e ele simplesmente funciona, graças à forma como o JavaScript nos permite estabelecer o contexto de execução quando queremos.</p> + +<pre class="brush: js">var obj = { + length: 0, + + addElem: function addElem(elem) { + // obj.length é automaticamente incrementado + // toda vez que um elemento for adicionado. + [].push.call(this, elem); + } +}; + +// Vamos adicionar alguns objetos vazios apenas para ilustrar. +obj.addElem({}); +obj.addElem({}); +console.log(obj.length); +// → 2 +</pre> + +<p>Observe que, embora <code>obj</code> não seja um array, o método <code>push</code> aumentou com sucesso a propriedade de comprimento (<code>length</code>) do <code>obj</code> como se estivéssemos lidando com um array.</p> + +<h2 id="Specifications" name="Specifications">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>ECMAScript 3ª Edição</td> + <td>Padrão</td> + <td>Implementação inicial. Implentado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.7', 'Array.prototype.push')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.push', 'Array.prototype.push')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">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("1.0")}}</td> + <td>{{CompatGeckoDesktop("1.7")}}</td> + <td>{{CompatIE("5.5")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th><span style="font-family: 'Open Sans Light',sans-serif; font-size: 16px; line-height: 16px;">Característica</span></th> + <th>Android</th> + <th>Chrome para Android</th> + <th>Firefox Móvel (Gecko)</th> + <th>IE M<span style="font-family: 'Open Sans Light',sans-serif; font-size: 16px; line-height: 16px;">óvel</span></th> + <th>Opera <span style="font-family: 'Open Sans Light',sans-serif; font-size: 16px; line-height: 16px;">Móvel</span></th> + <th>Safari <span style="font-family: 'Open Sans Light',sans-serif; font-size: 16px; line-height: 16px;">Móvel</span></th> + </tr> + <tr> + <td><span style="font-size: 12px; line-height: 18px;">Suporte básico</span></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("Array.prototype.pop()")}}</li> + <li>{{jsxref("Array.prototype.shift()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/reduce/index.html b/files/pt-br/web/javascript/reference/global_objects/array/reduce/index.html new file mode 100644 index 0000000000..0268b64c00 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/reduce/index.html @@ -0,0 +1,513 @@ +--- +title: Array.prototype.reduce() +slug: Web/JavaScript/Reference/Global_Objects/Array/Reduce +tags: + - Array + - JavaScript + - Métodos + - Prototipo + - Referencia + - reduce() +translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>reduce()</strong></code> executa uma função <strong>reducer</strong> (fornecida por você) para cada elemento do array, resultando num único valor de retorno.</p> + +<div>{{EmbedInteractiveExample("pages/js/array-reduce.html")}}</div> + +<p class="hidden">A fonte desse exemplo interativo está armazenada em um repositório do GitHub. Se você quiser contribuir com o projeto de exemplos interativos, clone https://github.com/mdn/interactive-examples e envie-nos um pull request.</p> + +<p>A função <strong>reducer</strong> recebe quatro parâmetros:</p> + +<ol> + <li>Acumulador (<code>acc</code>)</li> + <li>Valor Atual (<code>cur</code>)</li> + <li>Index Atual (<code>idx</code>)</li> + <li>Array original (<code>src</code>)</li> +</ol> + +<p>O valor de retorno da sua função <strong>reducer</strong> é atribuída ao acumulador. O acumulador, com seu valor atualizado, é repassado para cada iteração subsequente pelo array, que por fim, se tornará o valor resultante, único, final.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="brush: js notranslate"><code><var>array</var>.reduce(<var>callback( acumulador, valorAtual</var>[, index[, array]] )[, <var>valorInicial</var>]))</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Função que é executada em cada valor no array (exceto no primeiro, se nenhum <font face="Consolas, Liberation Mono, Courier, monospace"><code>valorInicial</code></font> for passado); recebe quatro argumentos:</dd> +</dl> + +<p><strong><font face="Consolas, Liberation Mono, Courier, monospace"><code>acumulador</code></font></strong></p> + +<p>Opcional. O índice do elemento atual que está sendo processado no array. Começa a partir do index <code>0</code> se um <font face="Consolas, Liberation Mono, Courier, monospace"><code>valorInicial</code> </font>for fornecido. Do contrário, começa do index <code>1</code>.</p> + +<dl> + <dt><code>valorInicial</code></dt> + <dd>Opcional. Valor a ser usado como o primeiro argumento da primeira chamada da função <code>callback</code>. Se nenhum <code>valorInicial</code> é fornecido, o primeiro elemento do array será usado como o valor inicial do <font face="Consolas, Liberation Mono, Courier, monospace"><code>acumulador</code></font> e o <code>valorAtual</code> não será lido. Chamar <code>reduce()</code> em uma array vazia sem valor inicial retornará um erro.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O valor que resulta da redução.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>O método <code>reduce()</code> executa a função de <code>callback</code> uma vez para cada elemento presente no array, excluindo furos (valores indefinidos), recebendo quatro argumentos:</p> + +<ol> + <li><font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);"><em>acumulador</em></span></font> - valor inicial (ou o valor do callback anterior),</li> + <li><font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);"><em>valorAtual</em></span></font> - o valor do elemento atual</li> + <li><font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);"><em>index</em></span></font> - o índice atual e</li> + <li><code><var>array</var></code> - o array onde a iteração está ocorrendo.</li> +</ol> + +<p>A primeira vez que o callback é chamado, o<font face="Consolas, Liberation Mono, Courier, monospace"> <code>acumulador</code> e o <code>valorAtual</code> </font>podem ter um de dois valores possíveis<font face="Consolas, Liberation Mono, Courier, monospace">. </font>Se o <code><font face="Consolas, Liberation Mono, Courier, monospace">valorInicial</font></code><font face="Consolas, Liberation Mono, Courier, monospace"> </font>tiver<font face="Consolas, Liberation Mono, Courier, monospace"> </font>sido fornecido na chamada à função <font face="Consolas, Liberation Mono, Courier, monospace"><code>reduce()</code></font>, então o <font face="Consolas, Liberation Mono, Courier, monospace"><code>acumulador</code></font> será igual ao <code>valorInicial</code> e o <font face="consolas, Liberation Mono, courier, monospace"><code>valorAtual</code> </font>será igual ao primeiro valor no array. Caso nenhum <code>valorInicial</code> seja fornecido, <font face="Consolas, Liberation Mono, Courier, monospace"><code>acumulador</code></font> será igual ao primeiro valor no array, e <code>valorAtual</code> será igual ao segundo.</p> + +<div class="note"> +<p><strong>Nota</strong>: Se o <code>valorInicial</code> não tiver sido passado como argumento, então <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">reduce()</span></font> executará o callback da função começando a partir do índice 1 (<font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">index 1</span></font>), pulando o primeiro índice (<code>index 0</code>). Se o <code>valorInicial</code> for passado como argumento, a função irá começar no <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">index 0</span></font>.</p> +</div> + +<p>Se a array estiver vazia e o <code>valorInicial</code> não tiver sido informado, uma exceção do tipo {{jsxref("Global_Objects/TypeError", "TypeError")}} será lançada.</p> + +<p>Se a array possuir somente um elemento (independente da posição) e o <code>valorInicial</code> não tiver sido fornecido, ou se <code>valorInicial</code> for fornecido, mas a array estiver vazia, o valor será retornado sem que a função de <code>callback</code> seja chamada.</p> + +<p>É mais seguro provir um <code>valorInicial</code>, porque existem até <em>quatro</em> possíveis saídas sem o <code>valorInicial</code>, como mostrado no exemplo:</p> + +<pre class="brush: js notranslate">var maxCallback = ( acc, cur ) => Math.max( acc.x, cur.x ); +var maxCallback2 = ( max, cur ) => Math.max( max, cur ); + +// reduce() sem valores iniciais +[ { x: 22 }, { x: 42 } ].reduce( maxCallback ); // 42 +[ { x: 22 } ].reduce( maxCallback ); // { x: 22 } +[ ].reduce( maxCallback ); // TypeError + +// map/reduce; melhor solução, funciona para vetores vazios e tambem para vetores grandes +[ { x: 22 }, { x: 42 } ].map( el => el.x ) + .reduce( maxCallback2, -Infinity );</pre> + +<h3 id="Como_funciona_o_reduce">Como funciona o reduce()</h3> + +<p>Suponha que o seguinte uso de <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">reduce()</span></font> tenha ocorrido:</p> + +<pre class="brush: js notranslate">[0, 1, 2, 3, 4].reduce(function(a<font face="Consolas, Liberation Mono, Courier, monospace"><code>cumulador</code></font>, valorAtual, index, array) { + return a<font face="Consolas, Liberation Mono, Courier, monospace"><code>cumulador</code></font> + valorAtual; +}); +// 10</pre> + +<p>O callback será invocado quatro vezes, com os argumentos e valores em cada chamada sendo:</p> + +<table style="width: 100%;"> + <thead> + <tr> + <th scope="col"></th> + <th scope="col"><font face="Consolas, Liberation Mono, Courier, monospace"><code>acumulador</code></font></th> + <th scope="col"><font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">valorAtual</span></font></th> + <th scope="col"><font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">index</span></font></th> + <th scope="col"><code>array</code></th> + <th scope="col"><strong>valor de retorno</strong></th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">primeira chamada</th> + <td><code>0</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>1</code></td> + </tr> + <tr> + <th scope="row">segunda chamada</th> + <td><code>1</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>3</code></td> + </tr> + <tr> + <th scope="row">terceira chamada</th> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>6</code></td> + </tr> + <tr> + <th scope="row">quarta chamada</th> + <td><code>6</code></td> + <td><code>4</code></td> + <td><code>4</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + </tbody> +</table> + +<p>O valor retornado pelo <code>reduce</code> será o da última chamada à callback <code>(10)</code>.</p> + +<p>Você também pode usar uma {{jsxref("Functions/Arrow_functions", "Arrow Function","",1)}} em vez de uma função completa. O código abaixo produz a mesma saída que o código do bloco acima:</p> + +<pre class="brush: js line-numbers language-js notranslate">[0, 1, 2, 3, 4].reduce( (accum, curr) => accum + curr );</pre> + +<p>Se você informar um <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">valorInicial</span></font> como o segundo argumento de reduce, o resultado será:</p> + +<pre class="brush: js notranslate">[0, 1, 2, 3, 4].reduce(function(acumulador, valorAtual, indice, array) { + return acumulador + valorAtual; +}, 10); + +// 20</pre> + +<table style="width: 100%;"> + <thead> + <tr> + <th scope="col"><code>callback</code></th> + <th scope="col"><font face="Consolas, Liberation Mono, Courier, monospace"><code>acumulador</code></font></th> + <th scope="col"><code>valorAtual</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>array</code></th> + <th scope="col"><code>valor de retorno</code></th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">primeira chamada</th> + <td><code>10</code></td> + <td><code>0</code></td> + <td><code>0</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + <tr> + <th scope="row">segunda chamada</th> + <td><code>10</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>11</code></td> + </tr> + <tr> + <th scope="row">terceira chamada</th> + <td><code>11</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>13</code></td> + </tr> + <tr> + <th scope="row">quarta chamada</th> + <td><code>13</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>16</code></td> + </tr> + <tr> + <th scope="row">quinta chamada</th> + <td><code>16</code></td> + <td><code>4</code></td> + <td><code>4</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>20</code></td> + </tr> + </tbody> +</table> + +<p>O retorno da última chamada <code>20</code>,é retornado como resultado da função <code>reduce()</code>.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Sum_up_all_values_within_an_array" name="Example:_Sum_up_all_values_within_an_array">Soma todos os valores de uma array</h3> + +<pre class="brush: js notranslate">let total = [0, 1, 2, 3].reduce(function(acumulador, valorAtual) { + return acumulador + valorAtual; + }, 0) +// retorna 6</pre> + +<p>outra alternativa é usar uma arrow function:</p> + +<pre class="notranslate"><code>var total = [ 0, 1, 2, 3 ].reduce( + ( acumulador, valorAtual ) => acumulador + valorAtual, + 0 +);</code></pre> + +<h3 id="Soma_de_valores_de_um_objeto_de_um_array">Soma de valores de um objeto de um array</h3> + +<p>Para resumir os valores contidos em um array, você <strong>deve </strong>fornecer um <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">valorInicial</span></font>, para que cada item passe por sua função.</p> + +<pre class="notranslate"><code>var valorInicial = 0; +var soma = [{x: 1}, {x: 2}, {x: 3}].reduce(function (acumulador, valorAtual) { + return acumulador + valorAtual.x; +}, valorInicial) + +console.log(soma) // retorna 6</code></pre> + +<p>Utilizando uma arrow function:</p> + +<pre class="notranslate"><code>var valorInicial = 0; +var soma = [{x: 1}, {x: 2}, {x: 3}].reduce( + (acumulador , valorAtual) => acumulador + valorAtual.x + , valorInicial +); + +console.log(soma) // retorna 6</code> +</pre> + +<h3 id="Example_Flatten_an_array_of_arrays" name="Example:_Flatten_an_array_of_arrays">Redução de um array de arrays</h3> + +<pre class="notranslate">let reduzido = [[0, 1], [2, 3], [4, 5]].reduce( + function(acumulador, valorAtual) { + return acumulador.concat(valorAtual) + }, + [] +) +// reduzido é [0, 1, 2, 3, 4, 5]</pre> + +<p>Utilizando uma arrow function:</p> + +<pre class="notranslate"><code>let reduzido = [[0, 1], [2, 3], [4, 5]].reduce( + ( acumulador, valorAtual ) => acumulador.concat(valorAtual), + [] +);</code></pre> + +<h3 id="Contando_valores_iguais_em_um_objeto">Contando valores iguais em um objeto</h3> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js">let nomes = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice']; + +let quantidadeNomes = nomes.reduce(function (todosNomes, nome) { + if (nome in todosNomes) { + todosNomes[nome]++; + } + else { + todosNomes[nome] = 1; + } + return todosNomes; +}, {}); +// quantidade de nomes: +// { 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 }</code> +</pre> + +<h3 id="Agrupando_objetos_por_uma_propriedade">Agrupando objetos por uma propriedade</h3> + +<pre class="notranslate"><code>let pessoas = [ + { nome: 'Alice', idade: 21 }, + { nome: 'Max', idade: 20 }, + { nome: 'Jane', idade: 20 } +]; + +function agruparPor(objetoArray, propriedade) { + return objetoArray.reduce(function (acc, obj) { + let key = obj[propriedade]; + if (!acc[key]) { + acc[key] = []; + } + acc[key].push(obj); + return acc; + }, {}); +} + +let grupodePessoas = agruparPor(pessoas, 'idade'); +// grupodePessoas é: +// { +// 20: [ +// { nome: 'Max', idade: 20 }, +// { nome: 'Jane', idade: 20 } +// ], +// 21: [{ nome: 'Alice', idade: 21 }] +// }</code></pre> + +<h3 id="Juntando_arrays_contidos_num_array_de_objetos_usando_o_operador_spread_e_o_valorInicial">Juntando arrays contidos num array de objetos usando o operador spread e o <code>valorInicial</code></h3> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js">// friends - um array de objetos +// onde o campo "books" é a lista de livros favoritos +var friends = [{ + name: 'Anna', + books: ['Bible', 'Harry Potter'], + age: 21 +}, { + name: 'Bob', + books: ['War and peace', 'Romeo and Juliet'], + age: 26 +}, { + name: 'Alice', + books: ['The Lord of the Rings', 'The Shining'], + age: 18 +}]; + +// allbooks - lista que contém todos os livros de friends + +// lista adicional contida em valorInicial +var allbooks = friends.reduce(function(prev, curr) { + return [...prev, ...curr.books]; +}, ['Alphabet']); + +// allbooks = [ +// 'Alphabet', 'Bible', 'Harry Potter', 'War and peace', +// 'Romeo and Juliet', 'The Lord of the Rings', +// 'The Shining' +// ]</code></pre> + +<h3 id="Removendo_itens_duplicados_num_array">Removendo itens duplicados num array</h3> + +<div class="blockIndicator note"> +<p><strong>Nota:</strong> Se você estiver usando um ambiente compatível com {{jsxref("Set")}} and {{jsxref("Array.from()")}}, você pode usar <code>let orderedArray = Array.from(new Set(myArray))</code> para obter um array em que os itens duplicados tenham sido removidos.</p> +</div> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js">let arr = [1, 2, 1, 2, 3, 5, 4, 5, 3, 4, 4, 4, 4]; +let result = arr.sort().reduce((init, current) => { + if (init.length === 0 || init[init.length - 1] !== current) { + init.push(current); + } + return init; +}, []); +console.log(result); //[1,2,3,4,5]</code> +</pre> + +<h3 id="Substituindo_.filter.map_por_.reduce">Substituindo .filter().map() por .reduce()</h3> + +<p>Usar {{jsxref("Array.filter()")}} seguido por {{jsxref("Array.map()")}} faz com que o array seja percorrido duas vezes. Você pode obter o mesmo resultado percorrendo o array apenas uma vez com {{jsxref("Array.reduce()")}}, o que é, portanto, mais eficiente. (Se você gosta de for loops, você pode usar filter e map percorrendo o array apenas uma vez com {{jsxref("Array.forEach()")}}).</p> + +<pre class="notranslate">const numbers = [-5, 6, 2, 0,]; + +const doubledPositiveNumbers = numbers.reduce((accumulator, currentValue) => { + if (currentValue > 0) { + const doubled = currentValue * 2; + accumulator.push(doubled); + } + return accumulator; +}, []); + +console.log(doubledPositiveNumbers); // [12, 4]</pre> + +<h3 id="Rodando_promises_em_sequência">Rodando promises em sequência</h3> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js">/** + * Roda promises de um promise array de uma maneira encadeada + * + * @param {array} arr - promise arr + * @return {Object} promise object + */ +function runPromiseInSequense(arr) { + return arr.reduce((promiseChain, currentPromise) => { + return promiseChain.then((chainedResult) => { + return currentPromise(chainedResult) + .then((res) => res) + }) + }, Promise.resolve()); +} + +// promise function 1 +function p1() { + return new Promise((resolve, reject) => { + resolve(5); + }); +} + +// promise function 2 +function p2(a) { + return new Promise((resolve, reject) => { + resolve(a * 2); + }); +} + +// promise function 3 +function p3(a) { + return new Promise((resolve, reject) => { + resolve(a * 3); + }); +} + +const promiseArr = [p1, p2, p3]; +runPromiseInSequense(promiseArr) + .then((res) => { + console.log(res); // 30 + });</code></pre> + +<h3 id="Escrever_map_usando_reduce">Escrever map usando reduce</h3> + +<pre class="notranslate">if (!Array.prototype.mapUsingReduce) { + Array.prototype.mapUsingReduce = function(callback, thisArg) { + return this.reduce(function(mappedArray, currentValue, index, array) { + mappedArray[index] = callback.call(thisArg, currentValue, index, array) + return mappedArray + }, []) + } +} + +[1, 2, , 3].mapUsingReduce( + (currentValue, index, array) => currentValue + index + array.length +) // [5, 7, , 10]</pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p><code>Array.prototype.reduce</code> foi adicionado ao padrão ECMA-262 na quinta edição; e portanto, pode não estar presente em todas as implementações do padrão. Você pode contornar isso inserindo o código a seguir no início de seus scripts, permitindo o uso do <code>reduce()</code> em implementações que não possuem suporte nativo a ele.</p> + +<pre class="brush: js notranslate">// Etapas de produção para o ECMA-262, Edition 5, 15.4.4.21 +// Referencia: http://es5.github.io/#x15.4.4.21 +if (!Array.prototype.reduce) { + Array.prototype.reduce = function(callback /*, valorInicial*/) { + 'use strict'; + if (this == null) { + throw new TypeError('Array.prototype.reduce chamado é nulo (null) ou indefinido (undefined)'); + } + if (typeof callback !== 'function') { + throw new TypeError(callback + ' não é uma função') + } + var t = Object(this), len = t.length >>> 0, k = 0, value; + if (arguments.length == 2) { + value = arguments[1]; + } else { + while (k < len && !(k in t)) { + k++; + } + if (k >= len) { + throw new TypeError('Reduce possui um array vazio sem um valor inicial'); + } + value = t[k++]; + } + for (; k < len; k++) { + if (k in t) { + value = callback(value, t[k], k, t); + } + } + return value; + }; +} +</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>{{SpecName('ES5.1', '#sec-15.4.4.21', 'Array.prototype.reduce')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> + <p>Definição inicial. Implemetada no JavaScript 1.8.</p> + </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.reduce', 'Array.prototype.reduce')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Navegadores compatíveis</h2> + +<p>A tabela de compatibilidade encontrada nesta página é gerada a partir de dados estruturados. Se você deseja contribuir com os dados, consulte : <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um "pull request".</p> + +<div>{{Compat("javascript.builtins.Array.reduce")}}</div> + +<h2 id="See_also" name="See_also">Leia também</h2> + +<ul> + <li>{{jsxref("Array.prototype.reduceRight()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/reduceright/index.html b/files/pt-br/web/javascript/reference/global_objects/array/reduceright/index.html new file mode 100644 index 0000000000..67ad0a2bdd --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/reduceright/index.html @@ -0,0 +1,258 @@ +--- +title: Array.prototype.reduceRight() +slug: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight +translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>O método <code><strong>reduceRight()</strong></code> aplica à uma função um acumulador e cada valor do array (da direita para esquerda) é reduzido para um valor único.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>arr</var>.reduceRight(<var>callback</var>[, <var>initialValue</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Função para executar em cada valor do array, recebendo quatro argumentos: + <dl> + <dt><code>previousValue</code></dt> + <dd>O valor anteriormente retornado na ultima invocação do callback, ou o <code>initialValue</code>, se este for o recebido. (Ver abaixo.)</dd> + <dt><code>currentValue</code></dt> + <dd>O valor atualmente sendo processado no array.</dd> + <dt><code>index</code></dt> + <dd>O índice do valor atualmente sendo processado no array.</dd> + <dt><code>array</code></dt> + <dd>O array que foi chamado para ser reduzido.</dd> + </dl> + </dd> + <dt><code>initialValue</code></dt> + <dd>Opcional. Objeto para ser usado como argumento inicial da primeria chamada do callback.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p><code>reduceRight</code> executa a função callback uma vez para cada elemento presente no array, excluindo buracos no array, recebendo quatro argumentos: o valor inicial (ou o valor da chamada anterior do callback), o valor do elemento atual, o índice do elemento atual, e o array onde a operação está acontecendo.</p> + +<p>A chamada ao callback reduceRight <font face="Consolas, Liberation Mono, Courier, monospace">irá parecer com uma chamada assim</font>:</p> + +<pre class="brush: js">array.reduceRight(function(previousValue, currentValue, index, array) { + // ... +}); +</pre> + +<p>A primeira vez que a função é chamada, o <code>previousValue</code> e o <code>currentValue</code> podem ser um de dois valores. Se um <code>initialValue</code> foi recebido na chamada do <code>reduceRight</code>, então o <code>previousValue</code> sera iqual ao <code>initialValue</code> e o <code>currentValue</code> será igual ao ultimo valor no array. Se o <code>initialValue</code> não foi recebido, então o <code>previousValue será igual ao ultimo valor no array e o </code><code>currentValue</code> será igual ao penultimo valor no array.</p> + +<p>Se o array é vazio e nenhum <code>initialValue </code>foi recebido, {{jsxref("Global_Objects/TypeError", "TypeError")}} será lançado. Se o array somente tem um elemento (independentemente da posição dele) e o <code>initialValue </code>não foi recebido, ou se o <code>initialValue</code> foi recebido mas o array é vazio, o valor em si será retornado sem chamar o <code>callback</code>.</p> + +<p>Alguns exemplos de execuções da função e como será parecida a chamada:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) { + return previousValue + currentValue; +}); +</pre> + +<p>O callback será invocado quatro vezes, com os argumentos e valores de retornos em cada chamada será como o seguinte:</p> + +<table style="width: 100%;"> + <thead> + <tr> + <th scope="col"></th> + <th scope="col"><code>previousValue</code></th> + <th scope="col"><code>currentValue</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>array</code></th> + <th scope="col">return value</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">Primeira chamada</th> + <td><code>4</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>7</code></td> + </tr> + <tr> + <th scope="row">Segunda chamada</th> + <td><code>7</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>9</code></td> + </tr> + <tr> + <th scope="row">Terceira chamada</th> + <td><code>9</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + <tr> + <th scope="row">Quarta chamada</th> + <td><code>10</code></td> + <td><code>0</code></td> + <td><code>0</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + </tbody> +</table> + +<p>O valor retornado pelo <code>reduceRight</code> será o valor retornado pela ultima chamada ao callback(<code>10</code>).</p> + +<p>E se você também passou um <code>initialValue</code>, o resultado irá ser como a seguir:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) { + return previousValue + currentValue; +}, 10); +</pre> + +<table style="width: 100%;"> + <thead> + <tr> + <th scope="col"></th> + <th scope="col"><code>previousValue</code></th> + <th scope="col"><code>currentValue</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>array</code></th> + <th scope="col">return value</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">Primeira chamada</th> + <td><code>10</code></td> + <td><code>4</code></td> + <td><code>4</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>14</code></td> + </tr> + <tr> + <th scope="row">Segunda chamada</th> + <td><code>14</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>17</code></td> + </tr> + <tr> + <th scope="row">Terceira chamada</th> + <td><code>17</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>19</code></td> + </tr> + <tr> + <th scope="row">Quarta chamada</th> + <td><code>19</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>20</code></td> + </tr> + <tr> + <th scope="row">Quinta chamada</th> + <td><code>20</code></td> + <td><code>0</code></td> + <td><code>0</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>20</code></td> + </tr> + </tbody> +</table> + +<p>O valor retornado pelo <code>reduceRight</code> desta vez será, obviamente, <code>20</code>.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Sum_up_all_values_within_an_array" name="Example:_Sum_up_all_values_within_an_array">Exemplo: Somando todos os valores presente em um array</h3> + +<pre class="brush: js">var total = [0, 1, 2, 3].reduceRight(function(a, b) { + return a + b; +}); +// total == 6 +</pre> + +<h3 id="Example_Flatten_an_array_of_arrays" name="Example:_Flatten_an_array_of_arrays">Exemplo: Juntando um array de arrays</h3> + +<pre class="brush: js">var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) { + return a.concat(b); +}, []); +// flattened is [4, 5, 2, 3, 0, 1] +</pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p><code>reduceRight</code> foi adicionado no padrão ECMA-262 em sua Quinta edição; sendo assim pode não estar presente em todas as implementações deste padrão. Você pode contornar isso adicionando o seguinte codigo ao inicio do seu script, adicionando a possibilidade de uso do <code>reduceRight</code> em implementações que não o suportam nativamente.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.22 +// Reference: http://es5.github.io/#x15.4.4.22 +if ('function' !== typeof Array.prototype.reduceRight) { + Array.prototype.reduceRight = function(callback /*, initialValue*/) { + 'use strict'; + if (null === this || 'undefined' === typeof this) { + throw new TypeError('Array.prototype.reduce called on null or undefined' ); + } + if ('function' !== typeof callback) { + throw new TypeError(callback + ' is not a function'); + } + var t = Object(this), len = t.length >>> 0, k = len - 1, value; + if (arguments.length >= 2) { + value = arguments[1]; + } else { + while (k >= 0 && !(k in t)) { + k--; + } + if (k < 0) { + throw new TypeError('Reduce of empty array with no initial value'); + } + value = t[k--]; + } + for (; k >= 0; k--) { + if (k in t) { + value = callback(value, t[k], k, t); + } + } + return value; + }; +} +</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>{{SpecName('ES5.1', '#sec-15.4.4.22', 'Array.prototype.reduceRight')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definição inicial. Implementado em JavaScript 1.8.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com os navegadores</h2> + +<div>{{Compat("javascript.builtins.Array.reduceRight")}}</div> + +<h2 id="See_also" name="See_also">Ver também</h2> + +<ul> + <li>{{jsxref("Array.prototype.reduce()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/reverse/index.html b/files/pt-br/web/javascript/reference/global_objects/array/reverse/index.html new file mode 100644 index 0000000000..ed3b3fe160 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/reverse/index.html @@ -0,0 +1,121 @@ +--- +title: Array.prototype.reverse() +slug: Web/JavaScript/Reference/Global_Objects/Array/reverse +translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <code><strong>reverse()</strong></code> inverte os itens de um array. O primeiro elemento do array se torna o último e o último torna-se o primeiro.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>arr</var>.reverse()</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<p>Nenhum.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>O método <code>reverse</code> transpõe os elementos do objeto array no mesmo lugar, mutando o array, e retornando uma referência para o mesmo.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Reversing_the_elements_in_an_array" name="Example:_Reversing_the_elements_in_an_array">Exemplo: Invertendo os elementos em um array</h3> + +<p>O seguinte exemplo cria um array <code>myArray</code>, contendo três elementos, em seguida inverte-o.</p> + +<pre class="brush: js">var myArray = ['one', 'two', 'three']; +myArray.reverse(); + +console.log(myArray) // ['three', 'two', 'one'] +</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.4.4.8', 'Array.prototype.reverse')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com navegador</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>{{CompatChrome("1.0")}}</td> + <td>{{CompatGeckoDesktop("1.7")}}</td> + <td>{{CompatIE("5.5")}}</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 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> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.join()")}}</li> + <li>{{jsxref("Array.prototype.sort()")}}</li> + <li>{{jsxref("TypedArray.prototype.reverse()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/shift/index.html b/files/pt-br/web/javascript/reference/global_objects/array/shift/index.html new file mode 100644 index 0000000000..34aedcaa51 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/shift/index.html @@ -0,0 +1,104 @@ +--- +title: Array.prototype.shift() +slug: Web/JavaScript/Reference/Global_Objects/Array/shift +tags: + - Array + - JavaScript + - Prototype + - Reference + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/shift +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>O método <strong style="font-family: courier new,andale mono,monospace; line-height: 1.5;">shift()</strong><span style="line-height: 1.5;">remove o <strong>primeiro</strong> elemento de um array e retorna esse elemento. Este método muda o tamanho do array.</span><strong style="font-family: courier new,andale mono,monospace; line-height: 1.5;"> </strong></p> + +<p>{{EmbedInteractiveExample("pages/js/array-shift.html")}}</p> + +<div class="hidden"> +<p>O código deste exemplo interativo está salvo em um repositório do GitHub. Se você quiser contribuir com o projeto de exemplos interativos, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie-nos um pull request.</p> +</div> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>arr</var>.shift()</code></pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O elemento removido do array; {{jsxref("undefined")}} se o array estiver vazio.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>O método shift remove o elemento de índice zero, diminui em 1 os indices dos demais valores e retorna o valor removido. Se a propriedade {{jsxref("Array.length", "length")}} for 0, então {{jsxref("undefined")}} é retornado.</p> + +<p><code>shift</code> é intencionalmente genérico; esse método pode ser {{jsxref("Function.call", "chamado", "", 1)}} ou {{jsxref("Function.apply", "aplicado", "", 1)}} para objetos parecidos com arrays. Objetos que não contém a propriedade <code>length </code>representando o tamanho de uma série consecutiva, começando em zero, podem não se comportar de maneira correta.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Removing_an_element_from_an_array" name="Example:_Removing_an_element_from_an_array">Removendo um elemento de array</h3> + +<p>O código a seguir mostra o array <code>minhaLista</code> antes e depois de remover seu primeiro elemento. Ele também mostra o elemento removido.</p> + +<pre class="brush: js notranslate">var minhaLista = ['anjo', 'casa', 'mandarim', 'medico']; + +console.log('minhaLista antes: ' + minhaLista); +// minhaList antes: ['anjo', 'casa', 'mandarim', 'medico'] +var shifted = minhaLista.shift(); + +console.log('minhaLista depois: ' + minhaLista); +// minhaList depois: ['casa', 'mandarim', 'medico'] +console.log('Elemento removido: ' + shifted); +// Elemento removido: anjo +</pre> + +<h3 id="Example_Removing_an_element_from_an_array" name="Example:_Removing_an_element_from_an_array">Usando o método shift() dentro de um loop de while</h3> + +<p>O médodo shift() é frequentemente usado como condição dentro de um loop de while. No exemplo a seguir, cada iteração removerá o elemento seguinte do array, até que ele esteja vazio:</p> + +<pre class="brush: js notranslate">var nomes = ["André", "Eduardo", "Paulo", "Cris", "João"]; +while( (i = nomes.shift()) !== undefined ) { + console.log(i); +} +// André Eduardo Paulo Cris João</pre> + +<h2 id="Specifications" name="Specifications">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>ECMAScript 3rd Edition</td> + <td>Standard</td> + <td>Implementação inicial. Implementado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.9', 'Array.prototype.shift')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.shift', 'Array.prototype.shift')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade de Browser</h2> + +<div>{{Compat("javascript.builtins.Array.shift")}}</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.push()")}}</li> + <li>{{jsxref("Array.prototype.pop()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/slice/index.html b/files/pt-br/web/javascript/reference/global_objects/array/slice/index.html new file mode 100644 index 0000000000..daff58f51f --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/slice/index.html @@ -0,0 +1,224 @@ +--- +title: Array.prototype.slice() +slug: Web/JavaScript/Reference/Global_Objects/Array/slice +tags: + - Array + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>slice()</strong></code> retorna uma cópia de parte de um array a partir de um subarray criado entre as posições <code>início</code> e <code>fim</code> (<font face="consolas, Liberation Mono, courier, monospace"><span>fim</span></font> não é necessário) de um array original. O Array original não é modificado.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>arr</var>.slice([<var>início</var>[,<em>fim</em>]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>início</code> {{optional_inline}}</dt> + <dd>Índice baseado em zero no qual se inicia a extração.</dd> + <dd>Como um índice negativo, <code>início</code> indica um deslocamento em relação ao fim da sequência. <code>slice(-2)</code> extrai os dois últimos elementos do array.</dd> + <dd>Se <font face="consolas, Liberation Mono, courier, monospace"><span>início</span></font> for omitido, <code>slice</code> inicia a partir do índice <font face="Consolas, Liberation Mono, Courier, monospace">0</font>.</dd> + <dd>Se <font face="consolas, Liberation Mono, courier, monospace"><span>início</span></font> for maior que o comprimento do array, é retornado um array vazio.</dd> + <dt><code>fim</code> {{optional_inline}}</dt> + <dd>Índice baseado em zero o qual é o final da extração. <code>slice</code> extrai até, não incluindo, <code>fim</code>.</dd> + <dd><code>slice(1,4)</code> extrai do segundo até o quarto elemento (elementos de índice 1, 2 e 3).</dd> + <dd>Como índice negativo, <code>fim</code> indica um deslocamento em relação ao fim do array. <code>slice(2,-1)</code> extrai o terceiro elemento através do segundo-para-o-último elemento no array.</dd> + <dd>Se <code>fim</code> for omitido ou for maior que o tamanho do array, <code>slice</code> considerará o último elemento do array como sendo o <code>fim </code>(<code>arr.length</code>)<code>.</code></dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Um novo array contendo os elementos extraídos.</p> + +<h2 id="Descrição">Descrição</h2> + +<p><code>slice</code> não altera o array original. Retorna uma cópia de elementos do array original. Elementos do array original são copiados para o array retornado da seguinte maneira:</p> + +<ul> + <li>Para referências de objeto (e não o objeto real), <code>slice</code> copia referencias de objeto em um novo array. Ambos, o original e o novo array referem-se ao mesmo objeto. Se um objeto referenciado é alterado, as alterações são visiveis em ambos, no novo array e no array original.</li> + <li>Para strings e números (não objetos {{jsxref("String")}} e {{jsxref("Number")}}), <code>slice</code> copia strings e números em um novo array. Alterações na string ou número em um array não afetam o outro array.</li> +</ul> + +<p>Se um novo elemento é adicionado a qualquer array, o outro não é afetado.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Retorna_uma_parte_de_um_array_existente">Retorna uma parte de um array existente</h3> + +<pre class="brush: js notranslate">// Exemplo para extrair 'Laranja' e 'Limao' do array frutas +var frutas = ['Banana', 'Laranja', 'Limao', 'Maçã', 'Manga']; +var citricos = frutas.slice(1, 3); + +// citricos contem ['Laranja','Limao'] +</pre> + +<h3 id="Usando_slice">Usando <code>slice</code></h3> + +<p>No exemplo seguinte, <code>slice</code> cria um novo array, <code>novoCarro</code>, do original <code>meuCarro</code>. Ambos incluem uma referência ao objeto, <code>meuHonda</code>. Quando a cor de <code>meuHonda</code> é alterada para roxo, ambos os arrays sofrem alteração.</p> + +<pre class="brush: js notranslate">// Usando slice para criar novoCarro a partir de meuCarro. +var meuHonda = { cor: 'vermelho', rodas: 4, motor: { cilindros: 4, tamanho: 2.2 } }; +var meuCarro = [meuHonda, 2, 'perfeitas condições', 'comprado em 1997']; +var novoCarro = meuCarro.slice(0, 2); + +// Exibe os valores de meuCarro, novoCarro, e a cor de meuHonda +// referenciado de ambos arrays. +console.log('meuCarro = ' + meuCarro.toSource()); +console.log('novoCarro = ' + novoCarro.toSource()); +console.log('meuCarro[0].cor = ' + meuCarro[0].cor); +console.log('novoCarro[0].cor = ' + novoCarro[0].cor); + +// Altera a cor de meuHonda. +meuHonda.cor= 'roxo'; +console.log('A nova cor do meu Honda é ' + meuHonda.cor); + +// Exibe a cor de meuHonda referenciado de ambos arrays. +console.log('meuCarro[0].cor = ' + meuCarro[0].cor); +console.log('novoCarro[0].cor = ' + novoCarro[0].cor); +</pre> + +<p>Esse script escreve:</p> + +<pre class="brush: js notranslate">meuCarro = [{cor:'vermelho', rodas:4, motor:{cilindros:4, tamanho:2.2}}, 2,'perfeitas condições', 'comprado em 1997'] +novoCarro = [{cor:'vermelho', rodas:4, motor:{cilindros:4, tamanho:2.2}},2] +meuCarro[0].cor = vermelho +novoCarro[0].cor = vermelho +A nova cor do meu Honda é roxo +meuCarro[0].cor = roxo +novoCarro[0].cor = roxo +</pre> + +<h2 id="Objetos_Array-like">Objetos Array-like</h2> + +<p>O método <code>slice</code> pode também ser chamado para converter objetos ou coleções Array-like em um novo Array. Você só precisa encadear o método no Array. Os {{jsxref("Functions/arguments", "arguments")}} dentro de uma função são um exemplo de 'objeto array-like'.</p> + +<pre class="brush: js notranslate">function list() { + return Array.prototype.slice.call(arguments); +} + +var list1 = list(1, 2, 3); // [1, 2, 3] +</pre> + +<p>Ligações podem ser feitas com a função .<code>call</code> de {{jsxref("Function.prototype")}} and it can also be reduced using <code>[].slice.call(arguments)</code> ao invés de <code>Array.prototype.slice.call</code>. De qualquer forma, ela pode ser simplificada com {{jsxref("Function.prototype.bind", "bind")}}.</p> + +<pre class="brush: js notranslate">var unboundSlice = Array.prototype.slice; +var slice = Function.prototype.call.bind(unboundSlice); + +function list() { + return slice(arguments); +} + +var list1 = list(1, 2, 3); // [1, 2, 3] +</pre> + +<h2 id="Simplificando_o_comportamento_entre_navegadores"><span class="short_text" id="result_box" lang="pt"><span>Simplificando o comportamento entre navegadores</span></span></h2> + +<p><span id="result_box" lang="pt"><span>Embora os objetos de host (como objetos DOM) não sejam obrigados pela especificação a seguir o comportamento do Mozilla quando convertidos por Array.prototype.slice e IE <9 não o fazem</span></span>, versões do IE começando pela versão 9 permitem isso. “Shimming” pode permitir um comportamento confiável entre navegadores. Enquanto outros navegadores modernos continuem suportando essa habilidade, como atualmente IE, Mozilla, Chrome, Safari, e Opera fazem, desenvolvedores lendo (DOM-supporting) o código slice confiando neste shim não serão desencaminhados pela semântica; eles podem confiar seguramente na semântica para fornecer o agora aparentemente comportamento padrão de fato. (Isso também corrige o problema com IE < 9 onde o segundo argumento do <code>slice</code> era explicitamente {{jsxref("null")}}/{{jsxref("undefined")}})</p> + +<pre class="brush: js notranslate">(function () { + 'use strict'; + var _slice = Array.prototype.slice; + + try { + // Produzirá erro no IE < 9 + _slice.call(document.documentElement); + } catch (e) { + // Funciona para arrays, objetos array-like, + // NamedNodeMap (atributos, entidades, notações), + // NodeList (por exemplo, getElementsByTagName), HTMLCollection (por exemplo, childNodes), + // e não vai falhar em outros objetos do DOM (como falham no IE < 9) + Array.prototype.slice = function(begin, end) { + end = (typeof end !== 'undefined') ? end : this.length; + + // Para arrays, chamamos o método nativo + if (Object.prototype.toString.call(this) === '[object Array]'){ + return _slice.call(this, begin, end); + } + + // Para array-like, o processo é manual. + var i, cloned = [], + size, len = this.length; + + // Lidando com valor negativo para "begin" + var start = begin || 0; + start = (start >= 0) ? start : Math.max(0, len + start); + + // Lidando com valor negativo para "end" + var upTo = (typeof end == 'number') ? Math.min(end, len) : len; + if (end < 0) { + upTo = len + end; + } + + // Tamanho real do corte feito pelo slice + size = upTo - start; + + if (size > 0) { + cloned = new Array(size); + if (this.charAt) { + for (i = 0; i < size; i++) { + cloned[i] = this.charAt(start + i); + } + } else { + for (i = 0; i < size; i++) { + cloned[i] = this[start + i]; + } + } + } + + return cloned; + }; + } +}()); +</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('ESDraft', '#sec-array.prototype.slice', 'Array.prototype.slice')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.slice', 'Array.prototype.slice')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.10', 'Array.prototype.slice')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial. Implementada no JavaScript 1.2.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<div>{{Compat("javascript.builtins.Array.slice")}}</div> + +<div id="compat-mobile"></div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Function.prototype.bind()")}}</li> + <li>{{jsxref("Array.prototype.splice()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/some/index.html b/files/pt-br/web/javascript/reference/global_objects/array/some/index.html new file mode 100644 index 0000000000..f4724488dd --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/some/index.html @@ -0,0 +1,134 @@ +--- +title: Array.prototype.some() +slug: Web/JavaScript/Reference/Global_Objects/Array/some +translation_of: Web/JavaScript/Reference/Global_Objects/Array/some +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>some()</strong></code> testa se ao menos um dos elementos no array passa no teste implementado pela função atribuída e retorna um valor <code><strong>true</strong></code> ou <code><strong>false</strong></code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>arr</var>.some(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Função para testar cada elemento, recebendo três argumentos: + <dl> + <dt><code>currentValue</code></dt> + <dd>O valor atual do elemento sendo processado no array.</dd> + <dt><code>index</code></dt> + <dd>O índice do elemento atual sendo processado no array.</dd> + <dt><code>array</code></dt> + <dd>O array onde o método <code>some()</code> foi chamado.</dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Opcional. Valor para usar como <em><code>this</code> </em>durante a execução do <code>callback</code>.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Esta função retorna <code><strong>true</strong></code> se a função callback retornar <code><strong>true</strong></code> para qualquer elemento do array; caso contrário, <code><strong>false</strong></code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p><code>some()</code> executa a função callback uma vez para cada elemento presente no array até achar um onde o <code>callback</code> retorne um valor <em>true</em>. Se em qualquer dos elementos o valor for encontrado, <code>some()</code> imediatamente retorna <code>true</code>. Caso contrario, <code>some()</code> retorna <code>false</code>. <code>callback</code> é invocado somente para índices do array que contenham valor definido; não é invocado para índices que foram deletados ou os quais nunca tiveram valor definido.</p> + +<p><code>callback</code> é invocado com três argumentos: o valor do elemento, o índice do elemento, e o array onde a função foi chamada.</p> + +<p>Se o parâmetro <code>thisArg</code> foi passado ao <code>some()</code>, ele sera passado ao <code>callback</code> quando o mesmo for invocado,<font face="Open Sans, Arial, sans-serif"> para ser usado como o valor de </font><code>this</code> internamente na função callback. Caso contrario, o valor {{jsxref("undefined")}} será passado para uso como <code>this</code>. O valor <code>this</code> observado pela <code>callback</code> é determinado de acordo com as regras usuais para determinar o que é visto por uma função.</p> + +<p><code>some()</code> não altera o array dentro do qual ele é chamado. </p> + +<p>O intervalo de elementos processado por <code>some()</code> é definido antes da primeira invocação da <code>callback</code>. Elementos contidos no array antes da chamada <code>some()</code> ser iniciada não serão testados pela <em>callback</em>. Se algum elemento pertencente ao array for alterado pela <code><var>callback</var></code>, o valor passado para a <code><var>callback</var></code> será o valor do momento em que a função <code>some()</code> encontra o índice daquele elemento. Elementos deletados não são testados.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Testando_valores_de_elementos_de_um_array">Testando valores de elementos de um array</h3> + +<p>O exemplo a seguir testa se algum elemento de um array é maior que 10.</p> + +<pre class="brush: js notranslate">function isBiggerThan10(element, index, array) { + return element > 10; +} +[2, 5, 8, 1, 4].some(isBiggerThan10); // false +[12, 5, 8, 1, 4].some(isBiggerThan10); // true +</pre> + +<h3 id="Testando_valores_de_elementos_de_um_array_usando_arrow_functions">Testando valores de elementos de um array usando arrow functions</h3> + +<p><a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Arrow functions</a> fornece uma sintaxe mais curta para o mesmo teste.</p> + +<pre class="brush: js notranslate">[2, 5, 8, 1, 4].some(elem => elem > 10); // false +[12, 5, 8, 1, 4].some(elem => elem > 10); // true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>some()</code> was added to the ECMA-262 standard in the 5th edition; as such it may not be present in all implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of <code>some()</code> in implementations which do not natively support it. This algorithm is exactly the one specified in ECMA-262, 5th edition, assuming {{jsxref("Object")}} and {{jsxref("TypeError")}} have their original values and that <code>fun.call</code> evaluates to the original value of {{jsxref("Function.prototype.call()")}}.</p> + +<pre class="brush: js notranslate">// Production steps of ECMA-262, Edition 5, 15.4.4.17 +// Reference: http://es5.github.io/#x15.4.4.17 +if (!Array.prototype.some) { + Array.prototype.some = function(fun/*, thisArg*/) { + 'use strict'; + + if (this == null) { + throw new TypeError('Array.prototype.some called on null or undefined'); + } + + if (typeof fun !== 'function') { + throw new TypeError(); + } + + var t = Object(this); + var len = t.length >>> 0; + + var thisArg = arguments.length >= 2 ? arguments[1] : void 0; + for (var i = 0; i < len; i++) { + if (i in t && fun.call(thisArg, t[i], i, t)) { + return true; + } + } + + return false; + }; +} +</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.4.4.17', 'Array.prototype.some')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definição inicial. Implementada em JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.some', 'Array.prototype.some')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_em_navegadores">Compatibilidade em navegadores</h2> + +<div>{{Compat("javascript.builtins.Array.some")}}</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("TypedArray.prototype.some()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/sort/index.html b/files/pt-br/web/javascript/reference/global_objects/array/sort/index.html new file mode 100644 index 0000000000..6b1f8fcc15 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/sort/index.html @@ -0,0 +1,232 @@ +--- +title: Array.prototype.sort() +slug: Web/JavaScript/Reference/Global_Objects/Array/sort +translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>sort()</strong></code> ordena os elementos do próprio array e retorna o array. A ordenação não é necessariamente <a href="https://pt.wikipedia.org/wiki/Ordena%C3%A7%C3%A3o_est%C3%A1vel">estável</a>. A ordenação padrão é de acordo com a pontuação de código unicode.</p> + +<p>A complexidade do tempo de execução ou a quantidade de memória utilizada pela ordenação não pode ser garantido e depende da implementação realizada.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>arr</var>.sort([funcaoDeComparacao])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>funcaoDeComparacao</code> {{optional_inline}}</dt> + <dd>Especifica uma função que define a ordenação. Se omitido, o array é ordenado de acordo com a pontuação de código <a href="/en-US/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Unicode">Unicode</a> de cada um dos caracteres, de acordo com a conversão de cada elemento para string.</dd> + <dt> <code>primeiroElemento</code></dt> + <dd> O primeiro elemento para a comparação.</dd> + <dt> <code>segundoElemento</code></dt> + <dd> O segundo elemento para comparação.</dd> + <dt> + <h3 id="Valor_de_Retorno">Valor de Retorno</h3> + </dt> + <dd>O array ordenado. Note que o array é ordenado de acordo com a pontuação de código <a href="/en-US/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Unicode">Unicode</a> de cada um dos caracteres, e nenhuma cópia é feita.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Se <strong><code>funcaoDeComparacao</code></strong> não for informado, os elementos serão ordenados de acordo com a sua conversão para texto e o texto comparado na pontuação unicode do texto convertido. Por exemplo, "banana" vem antes de "cherry". Em uma ordenação numérica, 9 vem antes de 80, mas porque os números são convertidos para texto e, "80" vem antes de "9" na ordenação Unicode.</p> + +<pre class="brush: js notranslate">var fruit = ['cherries', 'apples', 'bananas']; +fruit.sort(); // ['apples', 'bananas', 'cherries'] + +var scores = [1, 10, 2, 21]; +scores.sort(); // [1, 10, 2, 21] +// Observe que 10 vem antes do 2, +// porque '10' vem antes de '2' em ponto de código Unicode. + +var things = ['word', 'Word', '1 Word', '2 Words']; +things.sort(); // ['1 Word', '2 Words', 'Word', 'word'] +// Em Unicode, números vêem antes de letras maiúsculas, +// as quais vêem antes das minúsculas. +</pre> + +<p>Se o parametro <code>funcaoDeComparacao</code> é fornecido, o array será ordenado de acordo com o valor de retorno da <code>funcaoDeComparacao</code>. Considerando que <code>a</code> e <code>b</code> são dois elementos sendo comparados, então:</p> + +<ul> + <li>Se <code>funcaoDeComparacao(a, b)</code> for menor que 0, ordena <code>a</code> para um índice anterior a <code>b</code>, i.e. a vem primeiro.</li> + <li>Se <code>funcaoDeComparacao(a, b)</code> retornar 0, deixa <code>a</code> e <code>b</code> inalterados em relação um ao outro, mas ordenado em relação a todos os outros elementos. Nota: O padrão ECMAscript não garante este comportamento, e, portanto, nem todos os navegadores (e.g. Versões do Mozilla anteriores a 2003) respeitarão isto.</li> + <li>Se <code>funcaoDeComparacao(a, b)</code> é maior que 0, ordena b para um índice anterior que a.</li> + <li><code>funcaoDeComparacao(a, b)</code> sempre deve retornar o mesmo valor dado um par específico de elementos a e b como seus dois parametros. Se resultados inconsistentes são retornados, então a ordenação é indefinida.</li> +</ul> + +<p>Então, a função de comparação tem a seguinte forma:</p> + +<pre class="brush: js notranslate">function comparar(a, b) { + if (a é menor que b em algum critério de ordenação) { + return -1; + } + if (a é maior que b em algum critério de ordenação) { + return 1; + } + // a deve ser igual a b + return 0; +} +</pre> + +<p>Para comparar números ao invés de texto, a função de comparação pode simplesmente subtrair b de a. A função abaixo irá ordenar o array em ordem crescente:</p> + +<pre class="brush: js notranslate">function compararNumeros(a, b) { + return a - b; +} +</pre> + +<p>O método de ordenação pode convenientemente ser usada com {{jsxref("Operators/function", "funções anônimas", "", 1)}} (e <a href="/en-US/docs/Web/JavaScript/Guide/Closures">closures</a>):</p> + +<pre class="brush: js notranslate">var numbers = [4, 2, 5, 1, 3]; +numbers.sort(function(a, b) { + return a - b; +}); +console.log(numbers); +</pre> + +<p>Objetos podem ser ordenados de acordo com o valor de uma de suas propriedades.</p> + +<pre class="brush: js notranslate" id="expanded-example">var items = [ + { name: 'Edward', value: 21 }, + { name: 'Sharpe', value: 37 }, + { name: 'And', value: 45 }, + { name: 'The', value: -12 }, + { name: 'Magnetic' }, + { name: 'Zeros', value: 37 } +]; +items.sort(function (a, b) { + if (a.name > b.name) { + return 1; + } + if (a.name < b.name) { + return -1; + } + // a must be equal to b + return 0; +}); +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Criando_exibindo_e_ordenando_um_array">Criando, exibindo, e ordenando um array</h3> + +<p>O exemplo abaixo cria quatro arrays e mostra seu conteúdo original, então o conteúdo dos arrays ordenado. Os arrays numéricos são ordenados sem a função de comparação, e então, com a função.</p> + +<pre class="brush: js notranslate">var stringArray = ['Blue', 'Humpback', 'Beluga']; +var numericStringArray = ['80', '9', '700']; +var numberArray = [40, 1, 5, 200]; +var mixedNumericArray = ['80', '9', '700', 40, 1, 5, 200]; + +function compararNumeros(a, b) { + return a - b; +} + +console.log('stringArray:', stringArray.join()); +console.log('Ordenada:', stringArray.sort()); + +console.log('numberArray:', numberArray.join()); +console.log('Ordenada sem função de comparação:', numberArray.sort()); +console.log('Ordenada com compararNumeros:', numberArray.sort(compararNumeros)); + +console.log('numericStringArray:', numericStringArray.join()); +console.log('Ordenada sem função de comparação:', numericStringArray.sort()); +console.log('Ordenada com compararNumeros:', numericStringArray.sort(compararNumeros)); + +console.log('mixedNumericArray:', mixedNumericArray.join()); +console.log('Ordenada sem função de comparação:', mixedNumericArray.sort()); +console.log('Ordenada com compararNumeros:', mixedNumericArray.sort(compararNumeros)); +</pre> + +<p>Este exemplo gera a saída abaixo. Como as saídas mostram, quando a função de comparação é usada, os números são ordenados corretamente, sejam eles números ou strings numéricas.</p> + +<pre class="notranslate">stringArray: Blue,Humpback,Beluga +Ordenada: Beluga,Blue,Humpback + +numberArray: 40,1,5,200 +Ordenada sem função de comparação: 1,200,40,5 +Ordenada com compararNumeros: 1,5,40,200 + +numericStringArray: 80,9,700 +Ordenada sem função de comparação: 700,80,9 +Ordenada com compararNumeros: 9,80,700 + +mixedNumericArray: 80,9,700,40,1,5,200 +Ordenada sem função de comparação: 1,200,40,5,700,80,9 +Ordenada com compararNumeros: 1,5,9,40,80,200,700 +</pre> + +<h3 id="Ordenando_caracteres_não-ASCII">Ordenando caracteres não-ASCII</h3> + +<p>Para ordenar strings com caracteres não-ASCII, i.e. strings com caracteres acentuados (e, é, è, a, ä, etc.), strings de línguas diferentes do Inglês: use {{jsxref("String.localeCompare")}}. Esta função pode comparar estes caracteres, então eles aparecerão na ordem correta.</p> + +<pre class="brush: js notranslate">var items = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu']; +items.sort(function (a, b) { + return a.localeCompare(b); +}); + +// items é ['adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé'] +</pre> + +<h3 id="Ordenando_com_mapa">Ordenando com mapa</h3> + +<p>A <code>funcaoDeComparacao</code> pode ser invocada múltiplas vezes por elemento do array. Dependendo da natureza da <code>funcaoDeComparacao</code>, isto pode causar um excesso processamento. Quanto mais trabalho a <code>funcaoDeComparacao</code> fizer, e quanto mais elementos houverem para ordenar, seria mais inteligente considerar o uso de um mapa para a ordenação. A idéia é percorrer o array uma vez para extrair os valores já processados para a ordenação e armazenar em um array temporário, ordenar o array temporário e então percorrer o array temporário para conseguir a ordenação correta.</p> + +<pre class="brush: js notranslate">// o array a ser ordenado +var list = ['Delta', 'alpha', 'CHARLIE', 'bravo']; + +// array temporário que armazena os objetos com o índice e o valor para ordenação +var mapped = list.map(function(el, i) { + return { index: i, value: el.toLowerCase() }; +}) + +// ordenando o array mapeado contendo os dados resumidos +mapped.sort(function(a, b) { + return +(a.value > b.value) || +(a.value === b.value) - 1; +}); + +// container para o resultado ordenado +var result = mapped.map(function(el){ + return list[el.index]; +}); +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição Inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.11', 'Array.prototype.sort')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.sort', 'Array.prototype.sort')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<div id="compat-desktop">{{Compat("javascript.builtins.Array.sort")}}</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.reverse()")}}</li> + <li>{{jsxref("String.prototype.localeCompare()")}}</li> +</ul> + +<div id="link64_adl_tabid" style="display: none;">253</div> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/splice/index.html b/files/pt-br/web/javascript/reference/global_objects/array/splice/index.html new file mode 100644 index 0000000000..d9296f4101 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/splice/index.html @@ -0,0 +1,173 @@ +--- +title: Array.prototype.splice() +slug: Web/JavaScript/Reference/Global_Objects/Array/splice +tags: + - Array + - JavaScript + - Lista + - splice +translation_of: Web/JavaScript/Reference/Global_Objects/Array/splice +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Resumo">Resumo</h2> + +<p>O método <strong>splice() </strong>altera o conteúdo de uma lista, adicionando novos elementos enquanto remove elementos antigos.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>array</em>.splice(<em>indice</em>[,<em> deleteCount</em>[<em>,</em><em> elemento1</em>[, ...[, <em>elementoN</em>]]])</code> + +<code><em>array</em>.splice(<em>indice</em>) // SpiderMonkey/Firefox extension</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>indice</code></dt> + <dd>Índice o qual deve iniciar a alterar a lista. Se maior que o tamanho total da mesma, nenhum elemento será alterado. Se negativo, irá iniciar a partir daquele número de elementos a partir do fim.</dd> +</dl> + +<dl> + <dt><code>deleteCount</code></dt> + <dd>Um inteiro indicando o número de antigos elementos que devem ser removidos.</dd> + <dd>Se o parâmetro <code><em>deleteCount</em></code> não é especificado, ou se é maior que o número de elementos restantes na lista iniciando pelo índice, então todos os elementos até o fim da lista serão deletados.</dd> + <dd>Se <code><em>deleteCount</em></code> é 0, nenhum elemento é removido. Neste caso você deve especificar pelo menos um novo elemento.</dd> +</dl> + +<dl> + <dt><code>elemento1, ..., elemento<em>N</em></code></dt> + <dd>Os elementos a adicionar na lista. Se você não especificar nenhum elemento, splice simplesmente removerá elementos da mesma.</dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>Uma lista contendo os elementos removidos. Se apenas um elemento é removido, por exemplo, uma lista contendo apenas um elemento é retornada. Se nenhum elemento é removido, uma lista vazia é retornada.</p> + +<p><strong style="font-size: 30px; font-weight: 700; letter-spacing: -1px; line-height: 30px;">Descrição</strong></p> + +<p>Se você especificar um número diferente de elementos a inserir comparado ao número de elementos que você está removendo, a lista terá um tamanho diferente no final da execução.</p> + +<h2 id="Exemplo">Exemplo</h2> + +<h3 id="Exemplo_Removendo_0_elementos_do_indice_2_e_inserindo_drum">Exemplo: Removendo 0 elementos do indice 2, e inserindo "drum"</h3> + +<p>O script a seguir ilustra o uso do <em>splice</em>:</p> + +<pre class="brush: js">var myFish = ["angel", "clown", "mandarin", "surgeon"]; + +//remove 0 elementos a partir do índice 2, e insere "drum" +var removed = myFish.splice(2, 0, "drum"); +//myFish é ["angel", "clown", "drum", "mandarin", "surgeon"] +//removed é [], nenhum elemento removido + +//remove 1 elemento do índice 3 +removed = myFish.splice(3, 1); +//myFish é ["angel", "clown", "drum", "surgeon"] +//removed é ["mandarim"] + +//remove 1 elemento a partir do índice 2, e insere "trumpet" +removed = myFish.splice(2, 1, "trumpet"); +//myFish é ["angel", "clown", "trumpet", "surgeon"] +//removed é ["drum"] + +//remove 2 elementos a partir do índice 0, e insere "parrot", "anemone" e "blue" +removed = myFish.splice(0, 2, "parrot", "anemone", "blue"); +//myFish é ["parrot", "anemone", "blue", "trumpet", "surgeon"] +//removed é ["angel", "clown"] + +//remove 2 elementos a partir do indice 3 +removed = myFish.splice(3, Number.MAX_VALUE); +//myFish é ["parrot", "anemone", "blue"] +//removed é ["trumpet", "surgeon"]</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>ECMAScript 3rd Edition</td> + <td>Padrão</td> + <td>Definição inicial.<br> + Implementado no JavaScript 1.2</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.12', 'Array.prototype.splice')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.splice', 'Array.prototype.splice')}}</td> + <td>{{Spec2('ES6')}}</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>Atributo</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>1.0</td> + <td>{{CompatGeckoDesktop("1.7")}}</td> + <td>5.5</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Atributo</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> + +<h3 id="Compatibilidade_com_Navegadores_Antigos">Compatibilidade com Navegadores Antigos</h3> + +<p>O método <em>splice</em> retorna o elemento removido, se somente um elemento é removido (parâmetro <code><em>deleteCount</em></code> é 1); caso contrário, o método retorna uma lista contendo os elementos removidos. Note que o último navegador a utilizar JavaScript 1.2 foi o Netscape Navigator 4, então você pode utilizar o <em>splice</em> esperando sempre retornar uma lista.</p> + +<h2 id="See_also" name="See_also">Veja Também</h2> + +<ul> + <li>{{jsxref("Array.push", "push")}} / {{jsxref("Array.pop", "pop")}} - adiciona/remove elementos do final do array;</li> + <li>{{jsxref("Array.unshift", "unshift")}} / {{jsxref("Array.shift", "shift")}} - adiciona/remove elementos do início do array;</li> + <li>{{jsxref("Array.concat", "concat")}} - returns a new array comprised of this array joined with other array(s) and/or value(s).</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/tolocalestring/index.html b/files/pt-br/web/javascript/reference/global_objects/array/tolocalestring/index.html new file mode 100644 index 0000000000..7912113ff7 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/tolocalestring/index.html @@ -0,0 +1,140 @@ +--- +title: Array.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString +--- +<div>{{JSRef}}</div> + +<div>O método <code><strong>toLocaleString()</strong></code> retorna uma representaçao de elementos de um array. Os elementos são convertidos para Strings utilizando seus respectivos métodos <code>toLocaleString</code> e essas cadeias são separadas por uma sequência específica de localidade (separados por virgula ","). </div> + +<div> </div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>array</var>.toLocaleString();</code> +</pre> + +<p> </p> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>locales</code> {{optional_inline}}</dt> + <dd>Uma string com uma tag de linguagem BCP 47, ou um array como strings. Para uma forma geral e uma interpretação do arquivo <code>locales</code>, veja a página {{jsxref("Intl")}}.</dd> + <dt><code>options</code> {{optional_inline}}</dt> + <dd>Um objeto com as propriedades de configurações, para números veja {{jsxref("Number.prototype.toLocaleString()")}}, e para datas veja {{jsxref("Date.prototype.toLocaleString()")}}.</dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>Uma string que representa os elementos de um array.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toLocaleString">Usando <code>toLocaleString</code></h3> + +<p>Os elementos de um array são convertidos para strings usando seus respectivos métodos <code>toLocaleString:</code></p> + +<ul> + <li><code>Object</code>: {{jsxref("Object.prototype.toLocaleString()")}}</li> + <li><code>Number</code>: {{jsxref("Number.prototype.toLocaleString()")}}</li> + <li><code>Date</code>: {{jsxref("Date.prototype.toLocaleString()")}}</li> +</ul> + +<pre class="brush: js">var numero = 1337; +var data = new Date(); +var meuArray = [numero, data, 'foo']; + +var resultado = meuArray.toLocaleString(); + +console.log(resultado); +// saída '1337,July 26, 2015 at 20:02:23 GMT-3,foo' +// se estiver no Brasil com o fuso horario GMT-0300 (BRT) de Brasília. +</pre> + +<p>Para mais exemplos, veja as páginas {{jsxref("Intl")}}, {{jsxref("NumberFormat")}}, e {{jsxref("DateTimeFormat")}}.</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.4.3', 'Array.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_do_Browser">Compatibilidade do 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> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.toString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/array/tosource/index.html new file mode 100644 index 0000000000..0eeea7211c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/tosource/index.html @@ -0,0 +1,113 @@ +--- +title: Array.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Array/toSource +tags: + - Não-padrão + - Referencia + - prototipos +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>O método <code><strong>toSource()</strong></code> retorna uma representação string do código fonte do array.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>arr</var>.toSource()</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<p>Nenhum.</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 {{jsxref("Array")}} pré-construido, <code>toSource</code> retorna a seguinte string indicando que o código fonte não está disponível: + + <pre class="brush: js">function Array() { + [native code] +} +</pre> + </li> + <li>Para instancias de {{jsxref("Array")}}, <code>toSource</code> retorna uma representação string do código fonte.</li> +</ul> + +<p>Este método normalmente é chamando internamente pelo JavaScript e não explicitamente no código. Você pode chamar <code>toSource</code> durante o debug para examinar o conteúdo de um array.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Examinando_o_código_fonte_de_um_array">Examinando o código fonte de um array</h3> + +<p>Para examinar o código fonte de um array:</p> + +<pre class="brush: js">var alpha = new Array('a', 'b', 'c'); + +alpha.toSource(); //retorna ['a', 'b', 'c'] +</pre> + +<h2 id="Especificações">Especificações</h2> + +<p>Não é parte de nenhum padrão. Implementado no JavaScript 1.3.</p> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2> + +<p>A tabela de compatibilidade encontrada nesta página é gerada a partir de dados estruturados. Se você deseja contribuir com os dados, consulte <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um "pull request".</p> + +<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>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</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>Suporte básico</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> + <li>{{jsxref("Array.prototype.toString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/array/tostring/index.html new file mode 100644 index 0000000000..d10cd2e032 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/tostring/index.html @@ -0,0 +1,115 @@ +--- +title: Array.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Array/toString +translation_of: Web/JavaScript/Reference/Global_Objects/Array/toString +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>toString()</strong></code> retorna uma string representando um array específico e seus elementos.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>arr</var>.toString()</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<p>Nenhum.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O objeto {{jsxref("Array")}} substitui o método toString() de {{jsxref("Object")}}. Para objetos do tipo Array, o método toString() concatena todos os valores em apenas uma string. Segue exemplo abaixo, de como ele se comporta.</p> + +<pre class="brush: js">var monthNames = ['Jan', 'Feb', 'Mar', 'Apr']; +var myVar = monthNames.toString(); // atribui 'Jan,Feb,Mar,Apr' para myVar. +</pre> + +<p>JavaScript chama o método toString automaticamente quando um Array é para ser representado como um valor de texto ou quando um Array é designado em uma concatenação.</p> + +<h3 id="Semântica_ECMAScript_5">Semântica ECMAScript 5</h3> + +<p>Implementado no JavaScript 1.8.5 (Firefox 4), e compatível com a 5ª versão do ECMAScript, a função toString() é genérica e pode ser usada em qualquer Objeto. Se o objeto tem um método join(), ele será chamado e esse valor será devolvido. Do contrário, {{jsxref("Object.prototype.toString()")}} será chamado, e o valor será retornado.</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.2', 'Array.prototype.toString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.tostring', 'Array.prototype.toString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browsers_compatíveis">Browsers compatíveis</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>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>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>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="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/unobserve/index.html b/files/pt-br/web/javascript/reference/global_objects/array/unobserve/index.html new file mode 100644 index 0000000000..a509f16afb --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/unobserve/index.html @@ -0,0 +1,129 @@ +--- +title: Array.unobserve() +slug: Web/JavaScript/Reference/Global_Objects/Array/unobserve +translation_of: Archive/Web/JavaScript/Array.unobserve +--- +<div>{{JSRef}}</div> + +<div>O método Array<strong>.unobserve()</strong> é usado para remover observers adicionados pelo {{jsxref("Array.observe()")}}.</div> + +<div> </div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Array.unobserve(<var>arr</var>, <var>callback</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>arr</code></dt> + <dd>O array para remover os observers.</dd> + <dt><code>callback</code></dt> + <dd><code>A referência para o observer para parar de ser chamada a toda vez em que algo é modificado no array </code><strong>arr</strong>.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p><code>Array.unobserve()</code> deve ser chamado após o {{jsxref("Array.observe()")}} a fim de remover um observers de um array.</p> + +<p>O callback deve ser uma referencia à uma função e não a uma função anônima, porquê esta referencia será usada para remover o observer anterior. É inútil chamar o <strong>Array.unobserve() </strong>com uma função anônima como callback, não removerá nenhum observer.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Desobservando_um_array">Desobservando um array</h3> + +<pre class="brush: js">var arr = [1, 2, 3]; + +var observer = function(changes) { + console.log(changes); +} + +Array.observe(arr, observer); + +arr.push(4); +// [{type: "splice", object: <arr>, index: 3, removed:[], addedCount: 1}] + +Array.unobserve(arr, observer); + +arr.pop(); +// O callback não foi chamado</pre> + +<h3 id="Usando_uma_função_anônima">Usando uma função anônima</h3> + +<pre class="brush: js">var persons = ['Khalid', 'Ahmed', 'Mohammed']; + +Array.observe(persons, function (changes) { + console.log(changes); +}); + +persons.shift(); +// [{type: "splice", object: <arr>, index: 0, removed: [ "Khalid" ], addedCount: 0 }] + +Array.unobserve(persons, function (changes) { + console.log(changes); +}); + +persons.push('Abdullah'); +// [{type: "splice", object: <arr>, index: 2, removed: [], addedCount: 1 }] +// O callback sempre será chamado +</pre> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os 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>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>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>{{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="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("Array.observe()")}} {{experimental_inline}}</li> + <li>{{jsxref("Object.observe()")}} {{experimental_inline}}</li> + <li>{{jsxref("Object.unobserve()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/unshift/index.html b/files/pt-br/web/javascript/reference/global_objects/array/unshift/index.html new file mode 100644 index 0000000000..bdf6c0e4d9 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/unshift/index.html @@ -0,0 +1,90 @@ +--- +title: Array.prototype.unshift() +slug: Web/JavaScript/Reference/Global_Objects/Array/unshift +tags: + - Array + - JavaScript + - Prototype + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Array/unshift +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Introdução</h2> + +<p>O método <code><strong>unshift()</strong></code> adiciona um ou mais elementos no início de um array e retorna o número de elementos (propriedade <code style="font-style: normal;">length</code>) atualizado.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>arr</var>.unshift([<var>element1</var>[, ...[, <var>elementN</var>]]])</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>element<em>N</em></code></dt> + <dd>Os elementos a serem adicionados no começo do array.</dd> +</dl> + +<h3 id="Returns" name="Returns">Retorna</h3> + +<p>A nova propriedade {{jsxref("Array.length", "length")}} do objeto acima onde o método foi chamado.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>O método <code>unshift</code> insere os valores fornecidos no início de um objeto do tipo array.</p> + +<p><code>unshift</code> é intencionalmente genérico; este método pode ser chamado via {{jsxref("Function.call", "call", "", 1)}} ou {{jsxref("Function.apply", "apply", "", 1)}} em objetos que se assemelham aos arrays. <span style="line-height: 1.5;">Objetos que não contêm uma propriedade </span><code style="font-style: normal; line-height: 1.5;">length</code><span style="line-height: 1.5;"> que reflete a última de uma série consecutiva de propriedades numéricas, </span><span style="line-height: 1.5;">iniciada por 0, podem não comportar-se de maneira significativa.</span></p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<pre class="brush: js notranslate">var arr = [1, 2]; + +arr.unshift(0); // result of call is 3, the new array length +// arr is [0, 1, 2] + +arr.unshift(-2, -1); // = 5 +// arr is [-2, -1, 0, 1, 2] + +arr.unshift([-3]); +// arr is [[-3], -2, -1, 0, 1, 2] +</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 3ª Edição</td> + <td>Padrão</td> + <td>Definição inicial. Implementado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.13', 'Array.prototype.unshift')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.unshift', 'Array.prototype.unshift')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade entre browsers</h2> + +<div>{{Compat("javascript.builtins.Array.unshift")}}</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.push()")}}</li> + <li>{{jsxref("Array.prototype.pop()")}}</li> + <li>{{jsxref("Array.prototype.shift()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/array/values/index.html b/files/pt-br/web/javascript/reference/global_objects/array/values/index.html new file mode 100644 index 0000000000..d3e918e1b9 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/array/values/index.html @@ -0,0 +1,121 @@ +--- +title: Array.prototype.values() +slug: Web/JavaScript/Reference/Global_Objects/Array/values +translation_of: Web/JavaScript/Reference/Global_Objects/Array/values +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>values()</code></strong> retorna um novo objeto de <strong><code>Array Iterator</code></strong> que contém os valores para cada índice no array.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>arr</var>.values()</code></pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Iteração_usando_for...of_loop">Iteração usando <code>for...of</code> loop</h3> + +<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p']; +var eArr = arr.values(); +// seu navegador deve suportar for..of loop +// e deixar variáveis let-scoped no for loops +for (let letter of eArr) { + console.log(letter); +} +</pre> + +<h3 id="Iteração_alternativa">Iteração alternativa</h3> + +<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p']; +var eArr = arr.values(); +console.log(eArr.next().value); // w +console.log(eArr.next().value); // y +console.log(eArr.next().value); // k +console.log(eArr.next().value); // o +console.log(eArr.next().value); // p +</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-array.prototype.values', 'Array.prototype.values')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</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>Suporte básico</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</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>Suporte básico</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notas_específicas_do_Firefox">Notas específicas do Firefox</h2> + +<ul> + <li>Devido a um <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=875433">problema de compatibilidade</a>, <code>Array.prototype.values()</code> foi removido do SpiderMonkey por enquanto.</li> +</ul> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("Array.prototype.keys()")}}</li> + <li>{{jsxref("Array.prototype.entries()")}}</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/arraybuffer/index.html b/files/pt-br/web/javascript/reference/global_objects/arraybuffer/index.html new file mode 100644 index 0000000000..443a570305 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/arraybuffer/index.html @@ -0,0 +1,148 @@ +--- +title: ArrayBuffer +slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer +tags: + - ArrayBuffer + - Constructor + - JavaScript + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer +--- +<p>{{JSRef}}</p> + +<p>O objeto <strong><code>ArrayBuffer</code></strong> é um tipo de dado usado para representar um genérico, <span class="short_text" id="result_box" lang="pt"><span class="hps">buffer de</span> <span class="hps">dados binários</span> <span class="hps">de tamanho</span> <span class="hps">fixo</span></span>. Você não pode manipular diretamente os conteúdos de um <code>ArrayBuffer</code>; em vez disso, você cria um objeto <a href="/en/JavaScript_typed_arrays/ArrayBufferView" title="en/JavaScript typed arrays/ArrayBufferView"><code>ArrayBufferView</code></a> que representa o buffer em um formato específico, e usa para ler e escrever os conteúdos do buffer.</p> + +<p>{{EmbedInteractiveExample("pages/js/arraybuffer-constructor.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</a> and send us a pull request.</p> +</div> + +<h2 id="Syntax">Syntax</h2> + +<pre>new ArrayBuffer(length) +</pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>length</code></dt> + <dd>The size, in bytes, of the array buffer to create.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>A new <code>ArrayBuffer</code> object of the specified size. Its contents are initialized to 0.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<p>A {{jsxref("RangeError")}} is thrown if the <code>length</code> is larger than {{jsxref("Number.MAX_SAFE_INTEGER")}} (>= 2 ** 53) or negative.</p> + +<h2 id="Description">Description</h2> + +<p>The <code>ArrayBuffer</code> constructor creates a new <code>ArrayBuffer</code> of the given length in bytes.</p> + +<h3 id="Getting_an_array_buffer_from_existing_data">Getting an array buffer from existing data</h3> + +<ul> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#Appendix.3A_Decode_a_Base64_string_to_Uint8Array_or_ArrayBuffer">From a Base64 string</a></li> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/API/FileReader#readAsArrayBuffer()">From a local file</a></li> +</ul> + +<h2 id="Properties">Properties</h2> + +<dl> + <dt><code>ArrayBuffer.length</code></dt> + <dd>The <code>ArrayBuffer</code> constructor's length property whose value is 1.</dd> + <dt>{{jsxref("ArrayBuffer.@@species", "get ArrayBuffer[@@species]")}}</dt> + <dd>The constructor function that is used to create derived objects.</dd> + <dt>{{jsxref("ArrayBuffer.prototype")}}</dt> + <dd>Allows the addition of properties to all <code>ArrayBuffer</code> objects.</dd> +</dl> + +<h2 id="Methods">Methods</h2> + +<dl> + <dt>{{jsxref("ArrayBuffer.isView", "ArrayBuffer.isView(arg)")}}</dt> + <dd>Returns <code>true</code> if <code>arg</code> is one of the ArrayBuffer views, such as <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray">typed array objects</a> or a {{jsxref("DataView")}}. Returns <code>false</code> otherwise.</dd> + <dt>{{jsxref("ArrayBuffer.transfer", "ArrayBuffer.transfer(oldBuffer [, newByteLength])")}} {{experimental_inline}}</dt> + <dd> + <p>Returns a new <code>ArrayBuffer</code> whose contents are taken from the <code>oldBuffer</code>'s data and then is either truncated or zero-extended by <code>newByteLength</code>.</p> + </dd> +</dl> + +<h2 id="Instances">Instances</h2> + +<p>All <code>ArrayBuffer</code> instances inherit from {{jsxref("ArrayBuffer.prototype")}}.</p> + +<h3 id="Properties_2">Properties</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype','Properties')}}</p> + +<h3 id="Methods_2">Methods</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype','Methods')}}</p> + +<dl> + <dt>{{jsxref("ArrayBuffer.slice()")}} {{non-standard_inline}}</dt> + <dd>Has the same functionality as {{jsxref("ArrayBuffer.prototype.slice()")}}.</dd> +</dl> + +<h2 id="Exemplo">Exemplo</h2> + +<p>In this example, we create a 8-byte buffer with a {{jsxref("Global_Objects/Int32Array", "Int32Array")}} view referring to the buffer:</p> + +<pre><code>var buffer = new ArrayBuffer(8); +var view = new Int32Array(buffer);</code></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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Substituído pelo ECMAScript 6</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial no ECMA standard. Specified that <code>new</code> is required.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_entre_Navegadores">Compatibilidade entre 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.ArrayBuffer")}}</p> + +<h2 id="Compatibility_notes">Compatibility notes</h2> + +<p>Starting with ECMAScript 2015, <code>ArrayBuffer</code> constructors require to be constructed with a {{jsxref("Operators/new", "new")}} operator. Calling an <code>ArrayBuffer</code> constructor as a function without <code>new</code>, will throw a {{jsxref("TypeError")}} from now on.</p> + +<pre class="brush: js example-bad">var dv = ArrayBuffer(10); +// TypedError: calling a builtin ArrayBuffer constructor +// without new is forbidden</pre> + +<pre class="brush: js example-good">var dv = new ArrayBuffer(10);</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays">JavaScript typed arrays</a></li> + <li>{{jsxref("SharedArrayBuffer")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/asyncfunction/index.html b/files/pt-br/web/javascript/reference/global_objects/asyncfunction/index.html new file mode 100644 index 0000000000..3a463c8184 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/asyncfunction/index.html @@ -0,0 +1,173 @@ +--- +title: AsyncFunction +slug: Web/JavaScript/Reference/Global_Objects/AsyncFunction +tags: + - Constructor + - Construtor + - Experimental + - JavaScript + - Reference + - Referência(2) +translation_of: Web/JavaScript/Reference/Global_Objects/AsyncFunction +--- +<div>{{JSRef}}</div> + +<p>O <strong>construtor</strong> <code><strong>Async</strong></code><strong><code>Function</code> </strong>cria um novo objeto {{jsxref("Statements/async_function", "async function")}}. Em JavaScript cada função assíncrona é atualmente um objeto do tipo <code>AsyncFunction</code>.</p> + +<p>Note que<code>AsyncFunction</code> não é um objeto global. Ele poderia ser obtido analisando o seguinte código:</p> + +<pre class="brush: js">Object.getPrototypeOf(async function(){}).constructor +</pre> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox">new AsyncFunction([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>arg1, arg2, ... arg<em>N</em></code></dt> + <dd>Nomes que vão ser usados pela função como argumentos formais. Cada um deve ser uma string que corresponde a um indentificador JavaScript válido ou uma lista das strings separadas com uma vírgula; por exemplo "<code>x</code>", "<code>oValor</code>", or "<code>a,b</code>".</dd> + <dt><code>functionBody</code></dt> + <dd>Uma string contendo as declarações JavaScript que compõem a definição da função.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Objetos {{jsxref("Statements/async_function", "async function")}} criados com o construtor <code>AsyncFunction</code> são tratados quando a função é criada. Isso é menos eficiente que declarar uma função async com a {{jsxref("Statements/async_function", "expression async function")}} e chama-la com seu código, porque essas funções são tratadas com o resto do código.</p> + +<p>Todos os argumentos passado para a função são tratados como nomes dos identificadores dos parâmetros na função que vai ser criada, na ordem que eles são passados.</p> + +<div class="note"> +<p><strong>Nota:</strong> {{jsxref("Statements/async_function", "async functions")}} criadas com o construtor <code>AsyncFunction</code> não cria closures para seus contextos de criação; elas sempre criadas no escopo global. Quando rodar eles, eles só poderão acessar suas variáveis local e as globais, mas não as que estão no escopo que o construtor foi <code>AsyncFunction</code> chamado. Isso é diferente de usar {{jsxref("Global_Objects/eval", "eval")}} com código para uma expressão async function.</p> +</div> + +<p>Invocar o construtor <code>AsyncFunction</code> como uma função (sem usar o operador <code>new</code>) tem o mesmo efeito de invocá-lo como um construtor.</p> + +<h2 id="Propriedas">Propriedas</h2> + +<dl> + <dt><code><strong>AsyncFunction.length</strong></code></dt> + <dd>A propriedade tamanho do construtor da <code>AsyncFunction</code> cujo valor é 1.</dd> + <dt>{{jsxref("AsyncFunction.prototype")}}</dt> + <dd>Permite a adição de propriedades para todos os objetos async function.</dd> +</dl> + +<h2 id="AsyncFunction_prototype_object"><code>AsyncFunction </code>prototype object</h2> + +<h3 id="Propriedades">Propriedades</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction/prototype', 'Propriedades')}}</div> + +<h2 id="AsyncFunction_instances"><code>AsyncFunction</code> instances</h2> + +<p>Instância <code>AsyncFunction</code> herdam métodos e propriedades do {{jsxref("AsyncFunction.prototype")}}. Com todos os contrutores, que podem mudar o prototype do objeto construtor para fazer mudanças em todas as instâncias do <code>AsyncFunction</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Criando_uma_async_function_a_partir_do_construtor_de_uma_AsyncFunction">Criando uma async function a partir do construtor de uma <code>AsyncFunction</code></h3> + +<pre class="brush: js">function resolveAfter2Seconds(x) { + return new Promise(resolve => { + setTimeout(() => { + resolve(x); + }, 2000); + }); +} + +var AsyncFunction = Object.getPrototypeOf(async function(){}).constructor + +var a = new AsyncFunction('a', + 'b', + 'return await resolveAfter2Seconds(a) + await resolveAfter2Seconds(b);'); + +a(10, 20).then(v => { + console.log(v); // imprime 30 após 4 seconds +}); +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Situação</th> + <th scope="col">Comentário</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-async-function-objects', 'AsyncFunction object')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Definição inicial no ES2017.</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> Edge</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome(55)}}</td> + <td>{{CompatGeckoDesktop("52.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatOpera(42)}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</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 for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("52.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatOpera(42)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatChrome(55)}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Statements/async_function", "async function function")}}</li> + <li>{{jsxref("Operators/async_function", "async function expression")}}</li> + <li>{{jsxref("Global_Objects/Function", "Function")}}</li> + <li>{{jsxref("Statements/function", "function statement")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Functions_and_function_scope", "Funções e escopo de função", "", 1)}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/atomics/add/index.html b/files/pt-br/web/javascript/reference/global_objects/atomics/add/index.html new file mode 100644 index 0000000000..6d187893bb --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/atomics/add/index.html @@ -0,0 +1,132 @@ +--- +title: Atomics.add() +slug: Web/JavaScript/Reference/Global_Objects/Atomics/add +tags: + - Atomics + - Atômico + - JavaScript + - Memória Compartilhada + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/add +--- +<div>{{JSRef}}</div> + +<p>O método estátitico <code><strong>Atomics</strong></code><strong><code>.add()</code></strong> adiciona um dado valor em uma determinada posição no array e retorna o valor antigo daquela posição. Esta operação atômica garante que nenhuma outra escrita ocorra até que o valor modificado seja escrito de volta.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox">Atomics.add(typedArray, index, value) +</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>typedArray</code></dt> + <dd>Um array tipado de inteiros compartilhado. Pode ser {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}}, ou {{jsxref("Uint32Array")}}.</dd> + <dt><code>index</code></dt> + <dd>A posição no <code>typedArray</code> onde o <code>value</code> será adicionado.</dd> + <dt><code>value</code></dt> + <dd>Número que será adicionado.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O valor antigo na determinada posição (<code>typedArray[index]</code>).</p> + +<h3 id="Exceções">Exceções</h3> + +<ul> + <li>Lança uma exceção {{jsxref("TypeError")}}, se o <code>typedArray</code> não for um dos tipos de inteiro permitidos.</li> + <li>Lança uma exceção {{jsxref("TypeError")}}, se o <code>typedArray</code> não for tipo array tipado compartilhado.</li> + <li>Lança uma exceção {{jsxref("RangeError")}}, se o <code>index</code> estiver fora dos limites no <code>typedArray</code>.</li> +</ul> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +var ta = new Uint8Array(sab); + +Atomics.add(ta, 0, 12); // retorna 0, o valor antigo +Atomics.load(ta, 0); // 12</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('ESDraft', '#sec-atomics.add', 'Atomics.add')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Definição inicial no ES2017.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Recurso</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatNo}} [2]</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoDesktop("55")}} [1]</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>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>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("55")}} [1]</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] No Firefox da versão 46 até a versão 54, este recurso fica desabilitado por uma configuração. Em about:config, altere o <code>javascript.options.shared_memory</code> para <code>true</code>. </p> + +<p>[2] A implementação está sob desenvolvimento e necessita dessas flags de runtime: <code>--js-flags=--harmony-sharedarraybuffer --enable-blink-feature=SharedArrayBuffer</code></p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Atomics")}}</li> + <li>{{jsxref("Atomics.sub()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/atomics/index.html b/files/pt-br/web/javascript/reference/global_objects/atomics/index.html new file mode 100644 index 0000000000..6f6a1dfabe --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/atomics/index.html @@ -0,0 +1,155 @@ +--- +title: Atomics +slug: Web/JavaScript/Reference/Global_Objects/Atomics +translation_of: Web/JavaScript/Reference/Global_Objects/Atomics +--- +<div>{{JSRef}} {{SeeCompatTable}}</div> + +<p>O objeto <strong><code>Atomics </code></strong>fornece operações atômicas como metodos estáticos. Eles são usados com objetos {{jsxref("SharedArrayBuffer")}}.</p> + +<p>As operações atômicas estão localizadas no modulo <code>Atomics</code>. Diferente de outros <em>global objects</em>, <code>Atomics</code> não é um construtor. Você não deve usa-lo com o <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> operator</a> ou invocar objetos <code>Atomics</code> como funções. Todas as propriedades e método do <code>Atomics</code> são estáticos (como é o caso com o objeto {{jsxref("Math")}}, por exemplo).</p> + +<h2 id="Métodos">Métodos</h2> + +<h3 id="Operações_Atômicas">Operações Atômicas</h3> + +<p>Quando a memória é compartilhada, multiplas threads podem ser lidas e escritas no mesmo dado da memória. Operações atômicas garantem que os valores previstos sejam lidos e escritos, estas operações são finalizadas antes da próxima operação iniciar e que as mesmas não sejam interrompidas.</p> + +<dl> + <dt>{{jsxref("Atomics.add()")}}</dt> + <dd>Adiciona o valor recebido na posiçao recebida no array. Retorna o valor anterior nesta posição.</dd> + <dt>{{jsxref("Atomics.and()")}}</dt> + <dd>Calcula um bit a bit AND na posição recebida no array. Retorna o valor anterior nesta posição.</dd> + <dt>{{jsxref("Atomics.compareExchange()")}}</dt> + <dd>Armazena o valor recebido na posição recebida no array, se este foi igual ao valor recebido. Retorna o valor anterior nesta posição.</dd> + <dt>{{jsxref("Atomics.exchange()")}}</dt> + <dd>Armazena o valor recebido na posição recebida no array. Retorna o valor anterior.</dd> +</dl> + +<dl> + <dt>{{jsxref("Atomics.load()")}}</dt> + <dd>Retorna o valor na posição recebida no array.</dd> + <dt>{{jsxref("Atomics.or()")}}</dt> + <dd>Calcula um bit a bit OR na posição recebida no array. Retorna o valor anterior nesta posição.</dd> + <dt>{{jsxref("Atomics.store()")}}</dt> + <dd>Armazena o valor recebido na posição recebida no array. Retorna o valor.</dd> + <dt>{{jsxref("Atomics.sub()")}}</dt> + <dd>Subtrai o valor recebido na posição recebida no array. Retorna o valor anterior nesta posição.</dd> + <dt>{{jsxref("Atomics.xor()")}}</dt> + <dd>Calcula um bit a bit XOR na posição recebida no array. Retorna o valor anterior nesta posição.</dd> +</dl> + +<h3 id="Wait_e_wake">Wait e wake</h3> + +<p>Os métodos <code>wait()</code> e <code>wake()</code> são modelados no Linux futexes ("fast user-space mutex") e fornece formas de aguardar até que certas condições se tornem <code>true</code> e são tipicamente usadas como construtores de bloco.</p> + +<dl> + <dt>{{jsxref("Atomics.wait()")}}</dt> + <dd> + <p>Verifica se a posição informada no array ainda contém a valor recebido e <span id="result_box" lang="pt"><span>dorme</span> <span>à espera</span> <span>ou</span> até o <span>tempo limite. Retorna </span></span> <code>"ok"</code>, <code>"not-equal"</code>, ou <code>"timed-out"</code>. <span id="result_box" lang="pt"><span>Se</span> a <span>espera não</span> for<span> permitida</span> <span>no agente</span> <span>de chamada</span> <span>ele irá lançar uma exceção</span> <span>de erro (muitos navegadores não permitem </span></span> <code>wait()</code> na thread main do navegador).</p> + </dd> + <dt>{{jsxref("Atomics.wake()")}}</dt> + <dd>"Acorda" alguns agentes que estavam "dormindo" na lista de espera na posição recebida do array. Retorna o número de agentes que estão sendo "acordados".</dd> + <dt>{{jsxref("Atomics.isLockFree()", "Atomics.isLockFree(size)")}}</dt> + <dd> + <p><span id="result_box" lang="pt"><span>Uma otimização</span> <span>primitiva</span> <span>que</span> <span>pode</span> <span>ser usada para</span> <span>determinar se deve ser usado</span> lock<span> ou</span> <span>operações</span> <span>atômicas. Retorna <code>true</code>, se</span> <span>uma operação</span> <span>atômica</span> <span>em matrizes</span> <span>de</span> um <span>dado</span> <span>tamanho do elemento</span> <span>vai</span> <span>ser</span> <span>implementado</span> <span>utilizando uma operação</span> <span>atômica</span> <span>de hardware</span> <span>(</span><span>como</span> <span>oposição a lock)</span><span>.</span> <span>Só para experientes</span><span>.</span></span></p> + </dd> +</dl> + +<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('Shared Memory', '#AtomicsObject', 'Atomics')}}</td> + <td>{{Spec2('Shared Memory')}}</td> + <td>Definição inicial.</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>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}} [2]</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoDesktop("46")}} [1] [3]</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("46")}} [1]</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] This feature is disabled by a preference setting. In about:config, set <code>javascript.options.shared_memory</code> to <code>true</code>. </p> + +<p>[2] The implementation is under development and needs these runtime flags: <code>--js-flags=--harmony-sharedarraybuffer --enable-blink-feature=SharedArrayBuffer</code></p> + +<h2 id="Observações_de_compatibilidade">Observações de compatibilidade</h2> + +<p>[3] A especificação de compartilhamento de memória está sendo estabilizada. Anterior ao SpiderMonkey 48 {{geckoRelease(48)}}, a última API e semântica não foram implementadas ainda. As alterações entre as versões 46 e 48 do Firefox são:</p> + +<ul> + <li>Os métodos <code>Atomics.futexWakeOrRequeue()</code> e <code>Atomics.fence()</code> foram totalmente removidos ({{bug(1259544)}} e {{bug(1225028)}}).</li> + <li>O método {{jsxref("Atomics.wait()")}} e {{jsxref("Atomics.wake()")}} foram nomeados como <code>Atomics.futexWait()</code> e <code>Atomics.futexWake()</code> ({{bug(1260910)}}). Os nomes antigos foram mantidos como alias, e serão removidos na versão 49 ({{bug(1262062)}}).</li> + <li>As propriedades <code>Atomics.OK</code>, <code>Atomics.TIMEDOUT</code>, <code>Atomics.NOTEQUAL</code> foram removidas. O método {{jsxref("Atomics.wait()")}} agora retorna "ok", "timed-out" e "not-equal" ({{bug(1260835)}}).</li> + <li> + <p>O parâmetro <code>count</code> do método {{jsxref("Atomics.wake()")}} foi alterado: este agora possui o valor padrão <code>+Infinity</code>, e não <code>0</code> ({{bug(1253350)}}).</p> + </li> +</ul> + +<h2 id="Veja_Também">Veja Também</h2> + +<ul> + <li>{{jsxref("ArrayBuffer")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays">JavaScript typed arrays</a></li> + <li><a href="/en-US/docs/Web/API/Web_Workers_API">Web Workers</a></li> + <li><a href="https://github.com/lars-t-hansen/parlib-simple">parlib-simple </a>– a simple library providing synchronization and work distribution abstractions.</li> + <li><a href="https://github.com/tc39/ecmascript_sharedmem/blob/master/TUTORIAL.md">Shared Memory – a brief tutorial</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/bigint/index.html b/files/pt-br/web/javascript/reference/global_objects/bigint/index.html new file mode 100644 index 0000000000..fc9cd37807 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/bigint/index.html @@ -0,0 +1,240 @@ +--- +title: BigInt +slug: Web/JavaScript/Reference/Global_Objects/BigInt +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt +--- +<div>{{JSRef}}</div> + +<p><code>BigInt</code> é um objeto nativo que fornece um modo de representar números inteiros maiores que 2<sup>53</sup>, que é o maior número que o JavaScript consegue, com exatidão, representar com o tipo primitivo {{jsxref("Number")}}.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="brush: js">BigInt(value); +</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>value</code></dt> + <dd>O valor numérico do objeto que está sendo criado. Pode ser uma <em>string</em> ou um número inteiro.</dd> +</dl> + +<div class="blockIndicator note"> +<p><strong>Observação</strong>: <code>BigInt()</code> não é usado com o operador {{jsxref("Operators/new", "new")}}.</p> +</div> + +<dl> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Um <code>BigInt</code> é criado com a acrescentação de <code>n</code> ao final de um inteiro literal — <code>10n</code> — ou chamando a função <code>BigInt()</code>.</p> + +<pre class="brush: js">const theBiggestInt = 9007199254740991n; + +const alsoHuge = BigInt(9007199254740991); +// ↪ 9007199254740991n + +const hugeString = BigInt("9007199254740991"); +// ↪ 9007199254740991n + +const hugeHex = BigInt("0x1fffffffffffff"); +// ↪ 9007199254740991n + +const hugeBin = BigInt("0b11111111111111111111111111111111111111111111111111111"); +// ↪ 9007199254740991n +</pre> + +<p>Isso é parecido com um {{jsxref("Number")}} em algumas partes, mas difere-se em alguns assuntos importantes — ele não pode ser usado com métodos no objeto {{jsxref("Math")}} e não pode ser misturado em operações ou qualquer instância de <code>Number</code>.</p> + +<div class="blockIndicator warning"> +<p>{{jsxref("Number")}} e <code>BigInt</code> não podem ser misturados em operações — eles devem ser manipulados com o mesmo tipo.</p> + +<p>Tenha cuidado com a conversão e desconversão de valores, visto que a precisão de <code>BigInt</code> pode ser perdida com a conversào para <code>Number</code>.</p> +</div> + +<h3 id="Informações_do_tipo">Informações do tipo</h3> + +<p>Quando testado com <code>typeof</code> , um <code>BigInt</code> vai devolver "bigint":</p> + +<pre class="brush: js">typeof 1n === 'bigint'; // true +typeof BigInt('1') === 'bigint'; // true +</pre> + +<p>Quando envolvido em um <code>Object</code>, um <code>BigInt</code> vai ser considerado como um tipo normal de "object".</p> + +<pre class="brush: js">typeof Object(1n) === 'object'; // true +</pre> + +<h3 id="Operadores">Operadores</h3> + +<p>Os seguintes operadores podem ser usados com <code>BigInt</code>s (ou com <code>BigInt</code>s envolvidos em objetos): <code>+</code>, `<code>*</code>`, `<code>-</code>`, `<code>**</code>`, `<code>%</code>` .</p> + +<pre class="brush: js">const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER); +// ↪ 9007199254740991 + +const maxPlusOne = previousMaxSafe + 1n; +// ↪ 9007199254740992n + +const theFuture = previousMaxSafe + 2n; +// ↪ 9007199254740993n, isso funciona agora! + +const multi = previousMaxSafe * 2n; +// ↪ 18014398509481982n + +const subtr = multi – 10n; +// ↪ 18014398509481972n + +const mod = multi % 10n; +// ↪ 2n + +const bigN = 2n ** 54n; +// ↪ 18014398509481984n + +bigN * -1n +// ↪ –18014398509481984n +</pre> + +<p>O operador <code>/</code> também funciona com o esperado com números inteiros. No entanto, desde que esses sejam <code>BigInt</code>s e não <code>BigDecimal</code>s, essa operação vai arredondar para 0, o que significa que não vai retornar qualquer valor fracional.</p> + +<div class="blockIndicator warning"> +<p>Uma operação com um resultado fracional será arredondado com <code>BigInt.</code></p> +</div> + +<pre class="brush: js">const expected = 4n / 2n; +// ↪ 2n + +const rounded = 5n / 2n; +// ↪ 2n, e não 2.5n + +</pre> + +<h3 id="Comparações">Comparações</h3> + +<p>Um <code>BigInt</code> não é estritamente igual a um {{jsxref("Global_Objects/Number", "Number")}}, mas é mais ou menos assim.</p> + +<pre class="brush: js">0n === 0 +// ↪ false + +0n == 0 +// ↪ true</pre> + +<p>Um {{jsxref("Global_Objects/Number", "Number")}} e um <code>BigInt</code> podem ser comparado normalmente.</p> + +<pre class="brush: js">1n < 2 +// ↪ true + +2n > 1 +// ↪ true + +2 > 2 +// ↪ false + +2n > 2 +// ↪ false + +2n >= 2 +// ↪ true</pre> + +<p>Eles podem ser misturados em <em>arrays</em> e sorteados.</p> + +<pre class="brush: js">const mixed = [4n, 6, -12n, 10, 4, 0, 0n]; +// ↪ [4n, 6, -12n, 10, 4, 0, 0n] + +mixed.sort(); +// ↪ [-12n, 0, 0n, 10, 4n, 4, 6] +</pre> + +<p>Observe que comparações com <code>BigInt</code>s envolvidos em <code>Object</code> atuam com outros objetos, indicando somente a igualdade onde a mesma instância do objeto é comparada.</p> + +<pre class="brush: js">0n === Object(0n); // false +Object(0n) === Object(0n); // false + +const o = Object(0n); +o === o // true +</pre> + +<h3 id="Conditionals">Conditionals</h3> + +<p>A <code>BigInt</code> behaves like a {{jsxref("Global_Objects/Number", "Number")}} in cases where it is converted to a {{jsxref("Global_Objects/Boolean", "Boolean")}}: via the {{jsxref("Global_Objects/Boolean", "Boolean")}} function; when used with logical operators {{jsxref("Operators/Logical_Operators", "Logical Operators")}} <code>||</code>, `<code>&&</code>`, and <code>!</code>; or within a conditional test like an {{jsxref("Statements/if...else", "if statement")}}.</p> + +<pre class="brush: js">if (0n) { + console.log('Hello from the if!'); +} else { + console.log('Hello from the else!'); +} + +// ↪ "Hello from the else!" + +0n || 12n +// ↪ 12n + +0n && 12n +// ↪ 0n + +Boolean(0n) +// ↪ false + +Boolean(12n) +// ↪ true + +!12n +// ↪ false + +!0n +// ↪ true +</pre> + +<h2 id="Methods">Methods</h2> + +<dl> + <dt><strong><code>BigInt.asIntN()</code></strong></dt> + <dd>Wraps a BigInt between -2<sup>width-1</sup> and 2<sup>width-1</sup>-1</dd> + <dt><code>BigInt.asUintN()</code></dt> + <dd>Wraps a BigInt between 0 and 2<sup>width</sup>-1</dd> +</dl> + +<h2 id="Properties">Properties</h2> + +<dl> + <dt>{{jsxref("BigInt.prototype")}}</dt> + <dd><span style="letter-spacing: -0.00278rem;">Allows the addition of properties to a </span><code style="letter-spacing: -0.00278rem;">BigInt</code><span style="letter-spacing: -0.00278rem;"> object.</span></dd> +</dl> + +<h2 id="BigInt_instances"><code>BigInt</code> instances</h2> + +<p>All <code>BigInt</code> instances inherit from <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">BigInt.prototype</span></font>. The prototype object of the <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">BigInt</span></font> constructor can be modified to affect all <code>BigInt</code> instances.</p> + +<h3 id="Methods_2">Methods</h3> + +<p>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/prototype', 'Methods')}}</p> + +<h2 id="Examples">Examples </h2> + +<h3 id="Calculating_Primes">Calculating Primes</h3> + +<pre class="brush: js">function isPrime(p) { + for (let i = 2n; i * i <= p; i++) { + if (p % i === 0n) return false; + } + return true; +} + +// Takes a BigInt as an argument and returns a BigInt +function nthPrime(nth) { + let maybePrime = 2n; + let prime = 0n; + + while (nth >= 0n) { + if (isPrime(maybePrime)) { + nth -= 1n; + prime = maybePrime; + } + maybePrime += 1n; + } + + return prime; +} + +nthPrime(20n) +// ↪ 73n</pre> diff --git a/files/pt-br/web/javascript/reference/global_objects/bigint/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/bigint/prototype/index.html new file mode 100644 index 0000000000..ff8de05541 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/bigint/prototype/index.html @@ -0,0 +1,61 @@ +--- +title: BigInt.prototype +slug: Web/JavaScript/Reference/Global_Objects/BigInt/prototype +tags: + - BigInt + - JavaScript + - Propriedade + - Prototipo + - Referencia +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/prototype +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>BigInt.prototype</code></strong> representa o protótipo para o construtor {{JSxRef("BigInt")}} .</p> + +<p>{{JS_Property_Attributes(0, 0, 0)}}</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Todas instância de {{JSxRef("BigInt")}} herdam de <code>BigInt.prototype</code>. O objeto protótipo do construtor {{JSxRef("BigInt")}} pode ser modificado para afetar todas instâncias de {{JSxRef( "BigInt")}} .</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>BigInt.prototype.constructor</code></dt> + <dd>Retorna a função que cria instâncias deste objeto. Por padrão é o objeto<br> + {{JSxRef("BigInt")}}.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{JSxRef("BigInt.prototype.toLocaleString()")}}</dt> + <dd>Retorna uma string com uma representação sensível ao idioma para este número. Sobrescreve o método {{JSxRef("Object.prototype.toLocaleString()")}}<br> + </dd> + <dt>{{JSxRef("BigInt.prototype.toString()")}}</dt> + <dd>Retorna uma string respresentando o objeto específicado em um base específica. Sobrescreve o método {{JSxRef("Object.prototype.toString()")}} .</dd> + <dt>{{JSxRef("BigInt.prototype.valueOf()")}}</dt> + <dd>Retorna o valor primitivo de um objeto específicado. Sobrescreve o método {{JSxRef("Object.prototype.valueOf()")}}.</dd> +</dl> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificações</th> + <th scope="col">Estado</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-bigint.prototype', 'BigInt.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade">Compatibilidade</h2> + +<p class="hidden">Para contribuir para este dado de compatibilidade, por favor escreva um pull resquest para este repositório: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.BigInt.prototype")}}</p> diff --git a/files/pt-br/web/javascript/reference/global_objects/boolean/index.html b/files/pt-br/web/javascript/reference/global_objects/boolean/index.html new file mode 100644 index 0000000000..5d8f195d2f --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/boolean/index.html @@ -0,0 +1,194 @@ +--- +title: Boolean +slug: Web/JavaScript/Reference/Global_Objects/Boolean +tags: + - Boolean + - Constructor + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean +--- +<div>{{JSRef}}</div> + +<p>O objeto <strong><code>Boolean</code></strong> é um objeto wrapper para um valor booleano.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>new Boolean([<var>value</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>value</code></dt> + <dd>Opcional. O valor inicial do objeto <code>Boolean.</code></dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>O valor passado como primeiro parâmetro é convertido para um valor boleano, se necessário. Se o valor é omitido ou é <code>0</code>, <code>-0</code>, {{jsxref("null")}}, <code>false</code>, {{jsxref("NaN")}}, {{jsxref("undefined")}} ou é uma string vazia(<code>""</code>), o objeto terá um valor inicial de <code>false</code>. Todos outros valores, incluindo qualquer objeto ou string <code>"false"</code>, criam um objeto com valor inicial <code>true</code>.</p> + +<p>Não confunda os valores primitivos Boolean <code>true</code> e <code>false</code> com os valores <code>true</code> and <code>false</code> do objeto <code>Boolean</code>.</p> + +<p>Qualquer objeto cujo o valor não é {{jsxref("undefined")}} ou {{jsxref("null")}}, incluindo um objeto <code>Boolean</code> que o valor seja <code>false</code>, é avaliado para <code>true</code> quando passa por uma declaração condicional. Por exemplo, a condição a seguir {{jsxref("Statements/if...else", "if")}} a declaração é avaliada como <code>true</code>:</p> + +<pre class="brush: js">var x = new Boolean(false); +if (x) { + // esse código é executado +} +</pre> + +<p>Esse comportamento não se aplica aos primitivos <code>Boolean</code>. Por exemplo, a condição a seguir {{jsxref("Statements/if...else", "if")}} a declaração é avaliada como <code>false</code>:</p> + +<pre class="brush: js">var x = false; +if (x) { + // esse código não é executado +} +</pre> + +<p>Não use um objeto <code>Boolean</code> para converter um valor não-boleano para um valor boleano. Ao invés disso use <code>Boolean</code> como uma função para executar essa tarefa:</p> + +<pre class="brush: js">var x = Boolean(expression); // preferido +var x = new Boolean(expression); // não use +</pre> + +<p>Se você especificar qualquer objeto, incluindo um objeto <code>Boolean</code> cujo valor é <code>false</code>, como valor inicial de um objeto <code>Boolean</code>, o novo objeto <code>Boolean</code> terá o valor de <code>true</code>.</p> + +<pre class="brush: js">var myFalse = new Boolean(false); // valor inicial false +var g = new Boolean(myFalse); // valor inicial true +var myString = new String('Hello'); // objeto String +var s = new Boolean(myString); // valor inicial true +</pre> + +<p>Não use um um objeto <code>Boolean</code> no lugar de um primitivo B<code>oolean</code>.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>Boolean.length</code></dt> + <dd>Propriedade Length cujo valor é 1.</dd> + <dt>{{jsxref("Boolean.prototype")}}</dt> + <dd>Representa o protótipo para o construtor <code>Boolean</code>.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<p>O objeto global <code>Boolean</code> contém métodos próprios, entretanto, ele herda alguns métodos através da cadeia de protótipos:</p> + +<h2 id="Instâncias_Boolean">Instâncias <code>Boolean</code></h2> + +<p>Todas instâncias <code>Boolean</code> herdam de {{jsxref("Boolean.prototype")}}. Assim como todos os construtores, o protótipo do objeto dita as propriedades e métodos herdados.</p> + +<h3 id="Propriedades_2">Propriedades</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean/prototype', 'Properties')}}</div> + +<h3 id="Métodos_2">Métodos</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean/prototype', 'Methods')}}</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Criando_objetos_Boolean_com_um_valor_inicial_false">Criando objetos <code>Boolean</code> com um valor inicial <code>false</code></h3> + +<pre class="brush: js">var bNoParam = new Boolean(); +var bZero = new Boolean(0); +var bNull = new Boolean(null); +var bEmptyString = new Boolean(''); +var bfalse = new Boolean(false); +</pre> + +<h3 id="Criando_objetos_Boolean_com_um_valor_inicial_true">Criando objetos <code>Boolean</code> com um valor inicial <code>true</code></h3> + +<pre class="brush: js">var btrue = new Boolean(true); +var btrueString = new Boolean('true'); +var bfalseString = new Boolean('false'); +var bSuLin = new Boolean('Su Lin'); +var bArrayProto = new Boolean([]); +var bObjProto = new Boolean({}); +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no Java Script 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.6', 'Boolean')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-boolean-objects', 'Boolean')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatIE("6.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Boolean.prototype")}}</li> + <li>{{Glossary("Boolean")}}</li> + <li><a href="http://en.wikipedia.org/wiki/Boolean_data_type">Boolean data type (Wikipedia)</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/boolean/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/boolean/prototype/index.html new file mode 100644 index 0000000000..614272be40 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/boolean/prototype/index.html @@ -0,0 +1,111 @@ +--- +title: Boolean.prototype +slug: Web/JavaScript/Reference/Global_Objects/Boolean/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Boolean.prototype</code></strong> representa o prototype para o construtor de {{jsxref("Boolean")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Instancias de {{jsxref("Boolean")}} herdam de <code>Boolean.prototype</code>. Você pode usar os construtores do objeto prototype para adicionar propriedados ou metodos para todas as instancias de {{jsxref("Boolean")}} instances.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>Boolean.prototype.constructor</code></dt> + <dd>Retorna a função que criou a instancia do prototype. Esta é a função {{jsxref("Boolean")}} por padrão.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("Boolean.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Retorna a string contendo o codigo do objeto {{jsxref("Boolean")}} ; pode-se usar esta string para criar um objeto equivalente. Sobreescreve o método {{jsxref("Object.prototype.toSource()")}}.</dd> + <dt>{{jsxref("Boolean.prototype.toString()")}}</dt> + <dd>Retorna uma string com valor <code>"true"</code> ou <code>"false"</code> dependendo qual o valor do objeto. Sobreescreve o método {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("Boolean.prototype.valueOf()")}}</dt> + <dd>Retorna o valor primitivo do objeto {{jsxref("Boolean")}}. Sobreescreve o método {{jsxref("Object.prototype.valueOf()")}}.</dd> +</dl> + +<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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementano no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.6.3.1', 'Boolean.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-boolean.prototype', 'Boolean.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</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/boolean/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/boolean/tosource/index.html new file mode 100644 index 0000000000..5acf8e00fa --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/boolean/tosource/index.html @@ -0,0 +1,96 @@ +--- +title: Boolean.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Boolean/toSource +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>O método <code><strong>toSource()</strong></code> retorna uma representação string do código fonte do objeto.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>booleanObj</var>.toSource() +Boolean.toSource()</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<p>Nenhum.</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 pré-construido {{jsxref("Boolean")}}, <code>toSource</code> retorna a seguinte string indicando que o código não está disponível: + + <pre class="brush: js">function Boolean() { + [native code] +} +</pre> + </li> + <li>Para instancias de {{jsxref("Boolean")}}, <code>toSource</code> retorna a string representando o código fonte.</li> +</ul> + +<p>Este método normalmente é chamando internamente pelo JavaScript e não explicitamente no código fonte.</p> + +<h2 id="Especificações">Especificações</h2> + +<p>Não é parte de nenhum padrão. Implementado no Javascript 1.3.</p> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os 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>Suporte básico</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</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>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</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.prototype.toSource()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/boolean/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/boolean/tostring/index.html new file mode 100644 index 0000000000..45820dc57d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/boolean/tostring/index.html @@ -0,0 +1,128 @@ +--- +title: Boolean.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Boolean/toString +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toString +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>toString()</strong></code> retorna uma string representando o objeto Boolean específico.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>bool</var>.toString()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string representando o objeto {{jsxref("Boolean")}} específico.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O objeto {{jsxref("Boolean")}} sobrepõe o método <code>toString</code> do objeto {{jsxref("Object")}}; ele não herda {{jsxref("Object.prototype.toString()")}}. Para objetos Boolean, o método <code>toString</code> retorna uma representação do objeto como string.</p> + +<p>O JavaScript chama o método <code>toString</code> automaticamente quando uma {{jsxref("Boolean")}} deve ser representado como texto ou quando uma {{jsxref("Boolean")}} é referenciada como uma concatenação de string.</p> + +<p>Para objetos e valores {{jsxref("Boolean")}}, o método nativo <code>toString</code> retorna a string "<code>true</code>" ou "<code>false</code>", dependendo do valor do objeto boleano.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toString">Usando <code>toString</code></h3> + +<p>No código a seguir, <code>flag.toString()</code> retorna "<code>true</code>":</p> + +<pre class="brush: js">var flag = new Boolean(true); +var myVar = flag.toString(); +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.6.4.2', 'Boolean.prototype.toString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-boolean.prototype.tostring', 'Boolean.prototype.toString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-boolean.prototype.tostring', 'Boolean.prototype.toString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<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>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> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</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> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</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/boolean/valueof/index.html b/files/pt-br/web/javascript/reference/global_objects/boolean/valueof/index.html new file mode 100644 index 0000000000..e61d65033f --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/boolean/valueof/index.html @@ -0,0 +1,115 @@ +--- +title: Boolean.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/Boolean/valueOf +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/valueOf +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>valueOf()</strong></code> retorna o valor primitivo de um objeto {{jsxref("Boolean")}}.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>bool</var>.valueOf()</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<p>Nenhum.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>valueOf do </code>{{jsxref("Boolean")}} retorna o valor primitivo de um objeto {{jsxref("Boolean")}} ou um literal {{jsxref("Boolean")}} como tipo de dado Boolean.</p> + +<p>Esse método é geralmente chamado internamente pelo JavaScript e não explicitamente no código.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_valueOf">Usando <code>valueOf</code></h3> + +<pre class="brush: js">x = new Boolean(); +myVar = x.valueOf(); // atribui o valor false à variável myVar +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Condição</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.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.6.4.3', 'Boolean.prototype.valueOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-boolean.prototype.valueof', 'Boolean.prototype.valueOf')}}</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í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>{{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>Característica</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> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/dataview/index.html b/files/pt-br/web/javascript/reference/global_objects/dataview/index.html new file mode 100644 index 0000000000..7f4974b123 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/dataview/index.html @@ -0,0 +1,168 @@ +--- +title: DataView +slug: Web/JavaScript/Reference/Global_Objects/DataView +tags: + - Constructor + - DataView + - JavaScript + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView +--- +<div>{{JSRef}}</div> + +<p>O <strong><code>DataView</code></strong> provê uma interface de baixo nível para leitura e escrita de múltiplos tipos de número em um {{jsxref("ArrayBuffer")}}, independentemente da <a href="/pt-BR/docs/Glossario/Endianness">extremidade (<em>endianness</em>) da plataforma</a>.</p> + +<p>{{EmbedInteractiveExample("pages/js/dataview-constructor.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</a> and send us a pull request.</p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox">new DataView(buffer [, byteOffset [, byteLength]])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>buffer</code></dt> + <dd>{{jsxref("ArrayBuffer")}} ou {{jsxref("SharedArrayBuffer")}} {{experimental_inline}} existente para usar como armazenamento de um novo objeto <code>DataView</code>.</dd> + <dt><code>byteOffset</code> {{optional_inline}}</dt> + <dd>A mudança, em bytes, do primeiro byte determinado em um buffer, que será referenciado pela nova view. Se não for especificado, a view do buffer começará no primeiro byte.</dd> + <dt><code>byteLength</code> {{optional_inline}}</dt> + <dd>O número de elementos no array de bytes. Se não especificado, o tamanho da view será do mesmo tamanho do buffer.</dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>Um novo objeto <code>DataView</code> que representa o buffer de dados especificado. (Provavelmente não foi uma descrição muito útil.)</p> + +<p><font>Você pode pensar nesse objeto retornado como um "intérprete" de um array buffer de bytes - ele sabe como converter números para inserir em um buffer corretamente, tanto ao ler quanto ao gravar. </font><font>Isso significa lidar com conversões <em>integer,</em> <em>float,</em> <em>endianness</em> e outros detalhes da representação de números em formato binário.</font></p> + +<h3 id="Exceções">Exceções</h3> + +<dl> + <dt><code>{{jsxref("RangeError")}}</code></dt> + <dd>Lançado se o <code>byteOffset</code> ou <code>byteLength</code> especificados ultrapassarem o final do buffer.</dd> + <dd><font><font>Por exemplo, se o buffer tem 16 bytes de comprimento, o </font></font><code>byteOffset</code> <font><font>é 8 e o </font></font><code>byteLength</code> <font><font>é 10, esse erro será lançado porque a view resultante tenta estender 2 bytes acima do comprimento total do buffer.</font></font></dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<h3 id="Endianness"><em>Endianness</em></h3> + +<p>Formatos de números <em>Multi-byte</em> são representados de maneira diferente na memória, dependendo da arquitetura da máquina, veja {{Glossary("Endianness")}} para mais informações. Assessores de <code>DataView</code> fornecem controle explícito de como o dado será acessado, independente do <em>endianness </em>da arquitetura em execução. </p> + +<pre class="brush: js">var littleEndian = (function() { + var buffer = new ArrayBuffer(2); + new DataView(buffer).setInt16(0, 256, true /* littleEndian */); + // Int16Array uses the platform's endianness. + return new Int16Array(buffer)[0] === 256; +})(); +console.log(littleEndian); // true or false +</pre> + +<h3 id="Valores_inteiros_de_64_bits"><font><font>Valores inteiros de 64 bits</font></font></h3> + +<p>Como JavaScript atualmente não inclui suporte padrão para valores inteiros de 64 bits, <code>DataView</code> não oferece operações nativas de 64 bits. Como solução alternativa, você poderia implementar sua própria função getUint64() para obter um valor com a precisão de {{jsxref("Number.MAX_SAFE_INTEGER")}}, o que pode ser bom para determinados casos.</p> + +<pre class="brush: js">function getUint64(dataview, byteOffset, littleEndian) { + // split 64-bit number into two 32-bit (4-byte) parts + const left = dataview.getUint32(byteOffset, littleEndian); + const right = dataview.getUint32(byteOffset+4, littleEndian); + + // combine the two 32-bit values + const combined = littleEndian? left + 2**32*right : 2**32*left + right; + + if (!Number.isSafeInteger(combined)) + console.warn(combined, 'exceeds MAX_SAFE_INTEGER. Precision may be lost'); + + return combined; +}</pre> + +<p>Como alternativa, se você precisar de um intervalo completo de 64 bits, poderá criar um {{jsxref("BigInt")}}.</p> + +<pre class="brush: js">function getUint64BigInt(dataview, byteOffset, littleEndian) { + // split 64-bit number into two 32-bit (4-byte) parts + const left = dataview.getUint32(byteOffset, littleEndian); + const right = dataview.getUint32(byteOffset + 4, littleEndian); + + // combine the two 32-bit values as their hex string representations + const combined = littleEndian ? + right.toString(16) + left.toString(16).padStart(8, '0') : + left.toString(16) + right.toString(16).padStart(8, '0'); + + return BigInt(`0x${combined}`); +} +</pre> + +<h2 id="Propriedades">Propriedades</h2> + +<p>Todas as instâncias de <code>DataView</code> herdam {{jsxref("DataView.prototype")}} e permitem a adição de propriedades a todos os objetos DataView.</p> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Properties')}}</p> + +<h2 id="Métodos">Métodos</h2> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Methods')}}</p> + +<h2 id="Exemplo">Exemplo</h2> + +<pre class="brush: js">var buffer = new ArrayBuffer(16); +var dv = new DataView(buffer, 0); + +dv.setInt16(1, 42); +dv.getInt16(1); //42 +</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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Substituído pelo ECMAScript 6</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-dataview-constructor', 'DataView')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial no ECMA standard</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-dataview-constructor', 'DataView')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre 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.DataView")}}</p> + +<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2> + +<p>Começando com o Firefox 40, <code>DataView</code> deve ser construído com o operador {{jsxref("Operators/new", "new")}} . Chamando <code>DataView()</code> como uma função sem o <code>new</code>, irá lançar um {{jsxref("TypeError")}} de agora em diante.</p> + +<pre class="brush: js example-bad">var dv = DataView(buffer, 0); +// TypeError: calling a builtin DataView constructor without new is forbidden</pre> + +<pre class="brush: js example-good">var dv = new DataView(buffer, 0);</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a class="link-https" href="https://github.com/jDataView/jDataView">jDataView</a>: Biblioteca javascript que faz o polyfill e extende a API do <code>DataView</code> para todos os browsers e para o Node.js.</li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("SharedArrayBuffer")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/@@toprimitive/index.html b/files/pt-br/web/javascript/reference/global_objects/date/@@toprimitive/index.html new file mode 100644 index 0000000000..bc2c7b5f35 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/@@toprimitive/index.html @@ -0,0 +1,77 @@ +--- +title: 'Date.prototype[@@toPrimitive]' +slug: Web/JavaScript/Reference/Global_Objects/Date/@@toPrimitive +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/@@toPrimitive +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>[@@toPrimitive]()</strong></code> converte o objeto <code>Date</code> para um valor primitivo.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>Date()[Symbol.toPrimitive](hint); +</var></pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O valor primitivo do objeto {{jsxref("Date")}}. Dependendo do argumento, o método pode retornar uma cadeia de caracteres (<em>string</em>) ou um número.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>[@@toPrimitive]()</code> do objeto {{jsxref("Date")}} retorna um valor primitivo, que pode ser tanto um tipo numérico quanto uma string.</p> + +<p>Se <code>hint</code> é <code>"string"</code> ou <code>"default"</code>, <code>[@@toPrimitive]()</code> tenta chamar o método {{jsxref("Object.prototype.toString()", "toString")}}. Se a propriedade <code>toString</code> não existe, ele tenta chamar o método {{jsxref("Object.prototype.valueOf()", "valueOf")}} e se o <code>valueOf</code> não existir, <code>[@@toPrimitive]()</code> joga um {{jsxref("TypeError")}}.</p> + +<p>Se <code>hint</code> é <code>"number"</code>, <code>[@@toPrimitive]()</code> tenta primeiro chamar <code>valueOf</code>, e se ele falha, chama <code>toString</code>.</p> + +<p>O JavaScript chama o método <code>[@@toPrimitive]()</code> para converter um objeto para um valor primitivo. Você raramente precisa invocar o método <code>[@@toPrimitive]()</code> em si; JavaScript automaticamente o invoca quando encontra um objeto onde um valor primitivo é esperado.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Retornando_primitivos_de_data">Retornando primitivos de data</h3> + +<pre class="brush: js notranslate">const testDate = new Date(1590757517834); +// "Date Fri May 29 2020 14:05:17 GMT+0100 (British Summer Time)" + +testDate[Symbol.toPrimitive]('string'); +// Returns "Date Fri May 29 2020 14:05:17 GMT+0100 (British Summer Time)" + +testDate[Symbol.toPrimitive]('number'); +// Returns "1590757517834" + +testDate[Symbol.toPrimitive]('default'); +// Returns "Date Fri May 29 2020 14:05:17 GMT+0100 (British Summer Time)"</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-date.prototype-@@toprimitive', 'Date.prototype.@@toPrimitive')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.@@toPrimitive")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Symbol.toPrimitive")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getdate/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getdate/index.html new file mode 100644 index 0000000000..0e4244c42d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getdate/index.html @@ -0,0 +1,127 @@ +--- +title: Date.prototype.getDate() +slug: Web/JavaScript/Reference/Global_Objects/Date/getDate +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDate +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <strong><code>getDate()</code></strong> retorna o dia do mês da data especificada de acordo com a hora local.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getDate()</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<p>Nenhum.</p> + +<h3 id="Returns" name="Returns">Retorna</h3> + +<p>O valor retornado por <code>getDate()</code> é um inteiro entre 1 e 31.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Using_getDate" name="Example:_Using_getDate">Exemplo: Usando <code>getDate()</code></h3> + +<p>O segundo statement abaixo atribui o valor 25 à variável day, baseado no valor do objeto {{jsxref("Global_Objects/Date", "Date")}} <span style="font-family: courier,andale mono,monospace;">Xmas95</span>.</p> + +<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30'); +var day = Xmas95.getDate(); + +console.log(day); // 25 +</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>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Definição inicial. Implementado em JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.14', 'Date.prototype.getDate')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getdate', 'Date.prototype.getDate')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</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("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.getUTCDay()")}}</li> + <li>{{jsxref("Date.prototype.setDate()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getday/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getday/index.html new file mode 100644 index 0000000000..594f2aa427 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getday/index.html @@ -0,0 +1,127 @@ +--- +title: Date.prototype.getDay() +slug: Web/JavaScript/Reference/Global_Objects/Date/getDay +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDay +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <strong><code>getDay()</code></strong> retorna o dia da semana para a data especificada de acordo com a hora local, onde 0 representa o Domingo.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getDay()</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<p>Nenhum.</p> + +<h3 id="Returns" name="Returns">Retorna</h3> + +<p>O valor retornado por <code>getDay()</code> é um inteiro que corresponde com o dia da semana: 0 para Domingo, 1 para Segunda-Feira, 2 para Terça-Feira, e assim por diante.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Using_getDay" name="Example:_Using_getDay">Exemplo: Usando <code>getDay()</code></h3> + +<p>O segundo statement abaixo atribui o valor 1 à variável weekday (dia da semana), baseado no valor do objeto {{jsxref("Global_Objects/Date", "Date")}} <code>Xmas95</code>. A data 25 de Dezembro de 1995 é uma Segunda-Feira.</p> + +<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30'); +var weekday = Xmas95.getDay(); + +console.log(weekday); // 1 +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif; font-weight: bold;">Especificação</strong></th> + <th scope="col">Status</th> + <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif; font-weight: bold;">Comentário</strong></th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td><span style="background-color: rgba(212, 221, 228, 0.14902);">Definição inicial. Implementado em JavaScript 1.0.</span></td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.16', 'Date.prototype.getDay')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getday', 'Date.prototype.getDay')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</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("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.getUTCDay()")}}</li> + <li>{{jsxref("Date.prototype.setDate()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getfullyear/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getfullyear/index.html new file mode 100644 index 0000000000..140fca67d4 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getfullyear/index.html @@ -0,0 +1,127 @@ +--- +title: Date.prototype.getFullYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/getFullYear +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getFullYear +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <strong><code>getFullYear()</code></strong> retorna o ano da data especificada de acordo com a hora local.</p> + +<p>Use este método ao invés do {{jsxref("Date.prototype.getYear()", "getYear()")}}.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getFullYear()</code></pre> + +<h3 id="Parameters" name="Parameters" style="font-size: 1.71428571428571rem;">Parâmetros</h3> + +<p>Nenhum.</p> + +<h3 id="Returns" name="Returns">Retorna</h3> + +<p>O valor retornado por <code>getFullYear()</code> é um número absoluto. Para datas entre os anos 1000 e 9999, <code>getFullYear()</code> retorna um número de quatro dígitos, por exemplo, 1995. Use esta função para ter certeza de que o ano é compatível com os anos depois de 2000.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Using_getFullYear" name="Example:_Using_getFullYear">Exemplo: Usando <code>getFullYear()</code></h3> + +<p>O exemplo seguinte atribui o valor de quatro dígitos do ano corrente à variável year.</p> + +<pre class="brush: js">var today = new Date(); +var year = today.getFullYear(); +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif; font-weight: bold;">Especificação</strong></th> + <th scope="col">Status</th> + <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif; font-weight: bold;">Comentário</strong></th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td><span style="background-color: rgba(212, 221, 228, 0.14902);">Definição inicial. Implementado em JavaScript </span>1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.10', 'Date.prototype.getFullYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getfullyear', 'Date.prototype.getFullYear')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</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("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getYear()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/gethours/index.html b/files/pt-br/web/javascript/reference/global_objects/date/gethours/index.html new file mode 100644 index 0000000000..49c79ae5ae --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/gethours/index.html @@ -0,0 +1,126 @@ +--- +title: Date.prototype.getHours() +slug: Web/JavaScript/Reference/Global_Objects/Date/getHours +tags: + - Date + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getHours +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <strong><code>getHours()</code></strong> retorna a hora para a data especificada, de acordo com a hora local.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getHours()</code></pre> + +<h3 id="Parameters" name="Parameters" style="font-size: 1.71428571428571rem;">Parâmetros</h3> + +<p>Nenhum.</p> + +<h3 id="Returns" name="Returns">Retorna</h3> + +<p>O valor retornado por <code>getHours()</code> é um inteiro entre 0 e 23.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Using_getHours" name="Example:_Using_getHours">Exemplo: Usando <code>getHours()</code></h3> + +<p>O segundo statement abaixo atribui o valor 23 à variável <code>hours</code>, baseado no valor do objeto {{jsxref("Global_Objects/Date", "Date")}} <code>Xmas95</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30'); +var hours = Xmas95.getHours(); + +console.log(hours); // 23 +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif; font-weight: bold;">Especificação</strong></th> + <th scope="col">Status</th> + <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif; font-weight: bold;">Comentário</strong></th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td><span style="background-color: rgba(212, 221, 228, 0.14902);">Definição inicial. Implementado em JavaScript </span>1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.18', 'Date.prototype.getHours')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.gethours', 'Date.prototype.getHours')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</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("Date.prototype.getUTCHours()")}}</li> + <li>{{jsxref("Date.prototype.setHours()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getmilliseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getmilliseconds/index.html new file mode 100644 index 0000000000..4bbd37b571 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getmilliseconds/index.html @@ -0,0 +1,117 @@ +--- +title: Date.prototype.getMilliseconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>getMilliseconds()</code></strong> retorna os milissegundos em uma data específica de acordo com o horário local.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMilliseconds()</code></pre> + +<h3 id="Retorna">Retorna</h3> + +<p>Um número, entre 0 e 999, representando os milissegundos de uma data de acordo com o horário local.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_getMilliseconds()">Usando o <code>getMilliseconds()</code></h3> + +<p>O exemplo a seguir atribui a porção de milissegundos do horário atual à variável <code>milliseconds</code>:</p> + +<pre class="brush: js">var today = new Date(); +var milliseconds = today.getMilliseconds(); +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.24', 'Date.prototype.getMilliseconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getmilliseconds', 'Date.prototype.getMilliseconds')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getmilliseconds', 'Date.prototype.getMilliseconds')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers</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> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getminutes/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getminutes/index.html new file mode 100644 index 0000000000..c053d864c4 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getminutes/index.html @@ -0,0 +1,121 @@ +--- +title: Date.prototype.getMinutes() +slug: Web/JavaScript/Reference/Global_Objects/Date/getMinutes +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMinutes +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>getMinutes()</code></strong> retorna os minutos em uma data específica de acordo com o horário local.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMinutes()</code></pre> + +<h3 id="Retorna">Retorna</h3> + +<p>Um número inteiro, entre 0 e 59, representando os minutos em uma data de acordo com o horário local.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_getMinutes()">Usando o <code>getMinutes()</code></h3> + +<p>The second statement below assigns the value 15 to the variable <code>minutes</code>, based on the value of the {{jsxref("Global_Objects/Date", "Date")}} object <code>Xmas95</code>.</p> + +<p>No exemplo abaixo, a segunda linha atribui o valor 15 à variável <code>minutes</code>, baseado no valor de objeto {{jsxref("Global_Objects/Date")}} <code>Xmas95</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30'); +var minutes = Xmas95.getMinutes(); + +console.log(minutes); // 15 +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.20', 'Date.prototype.getMinutes')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getminutes', 'Date.prototype.getMinutes')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getminutes', 'Date.prototype.getMinutes')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers</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> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setMinutes()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getmonth/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getmonth/index.html new file mode 100644 index 0000000000..9685a3a383 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getmonth/index.html @@ -0,0 +1,121 @@ +--- +title: Date.prototype.getMonth() +slug: Web/JavaScript/Reference/Global_Objects/Date/getMonth +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMonth +--- +<div>{{JSRef}}</div> + +<div> </div> + +<p>O método <strong><code>getMonth()</code></strong> retorna o mês na data especificada de acordo com o horário local, como um valor zero-based (onde o zero indica o primeiro mês do ano).</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMonth()</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<p>Nenhum.</p> + +<h3 id="Retorno">Retorno</h3> + +<p>O valor retornado pelo método <code>getMonth()</code> é um inteiro entre 0 e 11. 0 corresponde a Janeiro, 1 a Fevereiro, e assim sucessivamente.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_getMonth()">Usando o <code>getMonth()</code></h3> + +<p>A segunda declaração abaixo atribui o valor 11 à variavel <code>month</code>, baseado no valor do objeto {{jsxref("Date")}} <code>Xmas95</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30'); +var month = Xmas95.getMonth(); + +console.log(month); // 11 +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.12', 'Date.prototype.getMonth')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getmonth', 'Date.prototype.getMonth')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</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>{{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>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>{{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"><br> + Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li> + <li>{{jsxref("Date.prototype.setMonth()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getseconds/index.html new file mode 100644 index 0000000000..4d4aa2b8c2 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getseconds/index.html @@ -0,0 +1,121 @@ +--- +title: Date.prototype.getSeconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/getSeconds +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getSeconds +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>getSeconds()</code></strong> retorna os segundos de uma data específica de acordo com o horário local.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getSeconds()</code></pre> + +<h3 id="Retorna">Retorna</h3> + +<p>Um número inteiro, entre 0 e 59, representando os segundos de uma data específica de acordo com o horário local.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Usando_o_getSeconds()">Usando o <code>getSeconds()</code></h3> + +<p>The second statement below assigns the value 30 to the variable <code>seconds</code>, based on the value of the {{jsxref("Global_Objects/Date", "Date")}} object <code>Xmas95</code>.</p> + +<p>No exemplo a seguir, a segunda linha atribui o valor 30 à variável <code>seconds</code>, baseado no valor do objeto {{jsxref("Global_Objects/Date", "Date")}} <code>Xmas95</code>.</p> + +<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30'); +var seconds = Xmas95.getSeconds(); + +console.log(seconds); // 30 +</pre> + +<h2 id="Espeficicações">Espeficicaçõ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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.22', 'Date.prototype.getSeconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getseconds', 'Date.prototype.getSeconds')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getseconds', 'Date.prototype.getSeconds')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers</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>Suport 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> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setSeconds()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/gettime/index.html b/files/pt-br/web/javascript/reference/global_objects/date/gettime/index.html new file mode 100644 index 0000000000..15bf8855fb --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/gettime/index.html @@ -0,0 +1,137 @@ +--- +title: Date.prototype.getTime() +slug: Web/JavaScript/Reference/Global_Objects/Date/getTime +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTime +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>getTime()</code></strong> retorna o valor numérico correspondente ao horário da data especificada de acordo com o horário universal.</p> + +<p>Você pode usar este método para atribuir uma data e horário a outro objeto {{jsxref("Date")}}. Este método é funcionalmente equivalente ao método {{jsxref("Date.valueof", "valueOf()")}}.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getTime()</code></pre> + +<h3 id="Retorna">Retorna</h3> + +<p>Um número representando os milissegundos passados entre 1 de Janeiro de 1970 00:00:00 UTC e a data atual.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_getTime()_para_duplicar_datas">Usando <code>getTime()</code> para duplicar datas</h3> + +<p>Construindo um objeto de data com um horário idêntico.</p> + +<pre class="brush: js">// Sendo o mês iniciado em zero, birthday será 10 de Janeiro de 1995 +var birthday = new Date(1994, 12, 10); +var copy = new Date(); +copy.setTime(birthday.getTime()); +</pre> + +<h3 id="Medindo_tempo_de_execução">Medindo tempo de execução</h3> + +<p>Subtrair duas chamadas subsequentes a <code>getTime()</code> em objetos {{jsxref("Date")}} recém criados resultará no intervalo de tempo entre essas duas chamadas. Isso pode ser usado para calcular o tempo de execução de algumas operações. Veja também {{jsxref("Date.now()")}} para evitar instanciar objetos {{jsxref("Date")}} desnecessariamente.</p> + +<pre class="brush: js">var end, start; + +start = new Date(); +for (var i = 0; i < 1000; i++) { + Math.sqrt(i); +} +end = new Date(); + +console.log('Operation took ' + (end.getTime() - start.getTime()) + ' msec'); +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado em JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.9', 'Date.prototype.getTime')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.gettime', 'Date.prototype.getTime')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.gettime', 'Date.prototype.getTime')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers</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> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Date.prototype.setTime()")}}</li> + <li>{{jsxref("Date.prototype.valueOf()")}}</li> + <li>{{jsxref("Date.now()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html b/files/pt-br/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html new file mode 100644 index 0000000000..2a10c9b6d6 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html @@ -0,0 +1,107 @@ +--- +title: Date.prototype.getTimezoneOffset() +slug: Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>getTimezoneOffset()</code></strong> retorna a diferença, em minutos, do deslocamento de fuso horário entre o UTC (Tempo Universal Coordenado) e a localidade atual.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getTimezoneOffset()</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<p>Nenhum</p> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O deslocamento de fuso horário é a diferença, em minutos, entre o UTC (Tempo Universal Coordenado) e o horário local. Perceba que isto significa que o deslocamento será negativo se o fuso horário local está à direita do UTC e positivo se está a esquerda. Por exemplo, se seu fuso horário é UTC+10(Padrão da Austrália Oriental), -600 será retornado. O Horário de verão evita que este valor seja sempre o mesmo para uma determinada localidade.</p> + +<p>Exemplo</p> + +<h3 id="Utilizando_getTimezoneOffset()">Utilizando <code>getTimezoneOffset()</code></h3> + +<pre class="brush: js">var x = new Date(); +var currentTimeZoneOffsetInHours = x.getTimezoneOffset() / 60; +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.26', 'Date.prototype.getTimezoneOffset')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.gettimezoneoffset', 'Date.prototype.getTimezoneOffset')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre 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>{{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>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>{{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/date/getutcdate/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutcdate/index.html new file mode 100644 index 0000000000..8b370ec07d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getutcdate/index.html @@ -0,0 +1,118 @@ +--- +title: Date.prototype.getUTCDate() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCDate +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDate +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>getUTCDate()</code></strong> retorna o dia (data) do mês na data especificada de acordo com o horário universal.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCDate()</code></pre> + +<h3 id="Retorna">Retorna</h3> + +<p>Um número inteiro, entre 1 e 31, representando o dia do mês na data especificada de acordo com o horário universal.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_getUTCDate()">Usando <code>getUTCDate()</code></h3> + +<p>O exemplo a seguir atribui o dia da data atual à variável <code>day</code>:</p> + +<pre class="brush: js">var today = new Date(); +var day = today.getUTCDate(); +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.15', 'Date.prototype.getUTCDate')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcdate', 'Date.prototype.getUTCDate')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcdate', 'Date.prototype.getUTCDate')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers</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> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getDate()")}}</li> + <li>{{jsxref("Date.prototype.getUTCDay()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutcday/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutcday/index.html new file mode 100644 index 0000000000..d7eb82b8b4 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getutcday/index.html @@ -0,0 +1,117 @@ +--- +title: Date.prototype.getUTCDay() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCDay +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDay +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>getUTCDay()</code></strong> retorna o dia da semana na data especificada de acordo com o horário universal, onde 0 representa domingo.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.getUTCDay()</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<p>Nenhum.</p> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O valor retornado por <code>getUTCDay()</code> é um inteiro correspondente ao dia da semana: 0 para domingo, 1 para segunda-feira, 2 para terça-feira e assim por diante.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_getUTCDay">Usando <code>getUTCDay()</code></h3> + +<p>O exemplo a seguir atribui a parte do dia da semana da data atual à variável <code>diaDaSemana</code>.</p> + +<pre class="brush: js notranslate">var hoje = new Date(); +var <code>diaDaSemana</code> = hoje.getUTCDay(); +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.17', 'Date.prototype.getUTCDay')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcday', 'Date.prototype.getUTCDay')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos 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>{{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>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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.getDay()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutcfullyear/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutcfullyear/index.html new file mode 100644 index 0000000000..4c6788fc72 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getutcfullyear/index.html @@ -0,0 +1,81 @@ +--- +title: Date.prototype.getUTCFullYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>getUTCFullYear()</code></strong> retorna o ano na data indicada de acordo com o horário universal.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getutcfullyear.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCFullYear()</code></pre> + +<h3 id="Retorna">Retorna</h3> + +<p>Um número que representa o ano na data indicada de acordo com o horário universal.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O valor retornado por <code>getUTCFullYear()</code> é um número absoluto compatível com ano 2000, por exemplo, 1995.</p> + +<h2 id="Exemplos"> Exemplos</h2> + +<h3 id="Usando_getUTCFullYear()">Usando <code>getUTCFullYear()</code></h3> + +<p>O exemplo a seguir atribui o valor de 4 dígitos do ano atual à variável <code>year.</code></p> + +<pre class="brush: js">var today = new Date(); +var year = today.getUTCFullYear(); +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td> + <p>Definição inicial. Implementado no JavaScript 1.3.</p> + </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.11', 'Date.prototype.getUTCFullYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcfullyear', 'Date.prototype.getUTCFullYear')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcfullyear', 'Date.prototype.getUTCFullYear')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.getUTCFullYear")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutchours/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutchours/index.html new file mode 100644 index 0000000000..7f962f722e --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getutchours/index.html @@ -0,0 +1,63 @@ +--- +title: Date.prototype.getUTCHours() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCHours +tags: + - Date + - JavaScript + - Prototipo + - Prototype + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCHours +--- +<div>{{JSRef}}</div> + +<div>O método <strong><code>getUTCHours()</code></strong> retorna o número de horas na data especificada de acordo com o horário universal (UTC).</div> + +<p>{{EmbedInteractiveExample("pages/js/date-getutchours.html")}}</p> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.getUTCHours()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um número inteiro, entre 0 e 23, representando as horas em uma data de acordo com o horário universal (UTC).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_getUTCHours">Usando <code>getUTCHours()</code></h3> + +<p>O exemplo a seguir atribui a porção de horas do horário corrente à variável <code>hours</code>.</p> + +<pre class="brush: js notranslate">var today = new Date(); +var hours = today.getUTCHours(); +</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-date.prototype.getutchours', 'Date.prototype.getUTCHours')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.getUTCHours")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getHours()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html new file mode 100644 index 0000000000..9f9fd540bf --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html @@ -0,0 +1,77 @@ +--- +title: Date.prototype.getUTCMilliseconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds +tags: + - JavaScript + - Prototipo + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds +--- +<div>{{JSRef}}</div> + +<p>o método <strong><code>getUTCMilliseconds()</code></strong> retorna os milisegundos na data especificada, de acordo com o horário universal (UTC).</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMilliseconds()</code></pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Um número inteiro, entre 0 e 999, representando os milisegundos na data especificada de acordo com o horário universal (UTC).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_getUTCMilliseconds()">Usando <code>getUTCMilliseconds()</code></h3> + +<p>O exemplo a seguir associa a parte dos milissegundos do tempo atual à variável <code>milissegundos</code>.</p> + +<pre class="brush: js">var hoje = new Date(); +var <code>milissegundos </code>= today.getUTCMilliseconds(); +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>definição inicial. Implementado no JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.25', 'Date.prototype.getUTCMilliseconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcmilliseconds', 'Date.prototype.getUTCMilliseconds')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcmilliseconds', 'Date.prototype.getUTCMilliseconds')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.getUTCMilliseconds")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutcminutes/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutcminutes/index.html new file mode 100644 index 0000000000..98eaee648d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getutcminutes/index.html @@ -0,0 +1,62 @@ +--- +title: Date.prototype.getUTCMinutes() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes +tags: + - Date + - JavaScript + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>getUTCMinutes()</code></strong> retorna os minutos na data especificada de acordo com o tempo universal.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getutcminutes.html")}}</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.getUTCMinutes()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um número inteiro, entre 0 e 59, representando os minutos na data especificada de acordo com o horário universal (UTC).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_getUTCMinutes">Usando <code>getUTCMinutes()</code></h3> + +<p>O seguinte exemplo atribui a parte dos minutos do tempo atual para a variável <code>minutes</code>.</p> + +<pre class="brush: js notranslate">var today = new Date(); +var minutes = today.getUTCMinutes(); +</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-date.prototype.getutcminutes', 'Date.prototype.getUTCMinutes')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.getUTCMinutes")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutcmonth/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutcmonth/index.html new file mode 100644 index 0000000000..9eeed116d8 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getutcmonth/index.html @@ -0,0 +1,77 @@ +--- +title: Date.prototype.getUTCMonth() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth +tags: + - Design + - JavaScript + - Prototipo + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>getUTCMonth()</code></strong> retorna o mês da data especificada de acordo com o horário universal, como um valor iniciado em zero (aonde zero indica o primeiro mês do ano).</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMonth()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um número inteiro, entre 0 e 11, correspondente ao mês da data informada de acordo com o horário universal. 0 para Janeiro, 1 para Fevereiro, 2 para Março, e assim em diante.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_getUTCMonth()">Usando <code>getUTCMonth()</code></h3> + +<p>O exemplo a seguir atribui a parte do mês da data atual a variável <code>month</code>.</p> + +<pre class="brush: js">var today = new Date(); +var month = today.getUTCMonth(); +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.13', 'Date.prototype.getUTCMonth')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcmonth', 'Date.prototype.getUTCMonth')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcmonth', 'Date.prototype.getUTCMonth')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.getUTCMonth")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMonth()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutcseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutcseconds/index.html new file mode 100644 index 0000000000..40b747c1cb --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getutcseconds/index.html @@ -0,0 +1,75 @@ +--- +title: Date.prototype.getUTCSeconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>getUTCSeconds()</code></strong> retorna os segundos na data informada de acordo com a hora universal.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-getutcseconds.html")}}</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCSeconds()</code></pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Um número inteiro, entre 0 e 59, representando os segundos da data informada de acordo com a hora universal.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_getUTCSeconds()">Usando <code>getUTCSeconds()</code></h3> + +<p>The following example assigns the seconds portion of the current time to the variabl</p> + +<p>O exemplo a seguir atribui a parte dos segundos da hora atual à variável <code>seconds</code>.</p> + +<pre class="brush: js">var today = new Date(); +var seconds = today.getUTCSeconds(); +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.23', 'Date.prototype.getUTCSeconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcseconds', 'Date.prototype.getUTCSeconds')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcseconds', 'Date.prototype.getUTCSeconds')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.getUTCSeconds")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getyear/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getyear/index.html new file mode 100644 index 0000000000..47ece39f41 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/getyear/index.html @@ -0,0 +1,169 @@ +--- +title: Date.prototype.getYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/getYear +tags: + - Date + - Deprecated + - JavaScript + - Method + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getYear +--- +<div>{{JSRef("Global_Objects", "Date")}} {{deprecated_header}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <strong><code>getYear()</code></strong> retorna o ano especificado pela data de acordo com a hora local. Por conta do fato de que <code>getYear()</code> não retorna anos completos ("problema do ano 2000"), este método não é mais utilizado e foi substituido pelo método {{jsxref("Date.prototype.getFullYear", "getFullYear()")}}.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getYear()</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<p>Nenhum.</p> + +<h3 id="Returns" name="Returns">Retorna</h3> + +<p>O método <code>getYear()</code> retorna o ano menos 1900; então:</p> + +<ul> + <li>Para ano maior ou igual a 2000, o valor retornado por <code>getYear()</code> é 100 ou mais. Por exemplo, se o ano for 2026, <code>getYear()</code> retorna 126.</li> + <li>Para ano entre e incluindo 1900 e 1999, o valor retornado por <code>getYear()</code> é entre 0 e 99. Por exemplo, se o anor for 1976, <code>getYear()</code> retorna 76.</li> + <li>Para ano menor que 1900, o valor retornado por <code>getYear()</code> é menor que 0. Por exemplo, se o ano for 1800, <code>getYear()</code> retorna -100.</li> +</ul> + +<p>Para levar em consideração anos antes e depois de 2000, você deve utilizar {{jsxref("Date.prototype.getFullYear", "getFullYear()")}} ao invés de <code>getYear()</code> para que o ano seja especificado por completo.</p> + +<h2 id="Backward_compatibility" name="Backward_compatibility">Retrocombatibilidade</h2> + +<h3 id="JavaScript_1.2_and_earlier" name="JavaScript_1.2_and_earlier">Comportamento em JavaScript 1.2 e anteriores</h3> + +<p>O método <code>getYear()</code> retorna um ano de 2 ou 4 dígitos:</p> + +<ul> + <li>Para anos entre e incluindo 1900 e 1999, o valor retornado por <code>getYear()</code> é o ano menos 1900. Por exemplo, se o ano é 1976, o valor retornado é 76.</li> + <li>Para anos menores que 1900 ou maiores que 1999, o valor retornado por <code>getYear()</code> é um ano de 4 dígitos. Por exemplo, se o ano é 1856, o valor retornado é 1856. Se o ano é 2026, o valor retornado é 2026.</li> +</ul> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Years_between_1900_and_1999" name="Example:_Years_between_1900_and_1999">Exemplo: Anos entre 1900 e 1999</h3> + +<p>O segundo statement atribui o valor 95 à variável <code>year</code>.</p> + +<pre class="brush: js">var Xmas = new Date('December 25, 1995 23:15:00'); +var year = Xmas.getYear(); // returns 95 +</pre> + +<h3 id="Example:_Years_above_1999" name="Example:_Years_above_1999">Exemplo: Anos depois de 1999</h3> + +<p>O segundo statement atribui o valor 100 à variável <code>year</code>.</p> + +<pre class="brush: js">var Xmas = new Date('December 25, 2000 23:15:00'); +var year = Xmas.getYear(); // returns 100 +</pre> + +<h3 id="Example:_Years_below_1900" name="Example:_Years_below_1900">Exemplo: Anos antes de 1900</h3> + +<p>O segundo statement atribui o valor -100 à variável <code>year</code>.</p> + +<pre class="brush: js">var Xmas = new Date('December 25, 1800 23:15:00'); +var year = Xmas.getYear(); // returns -100 +</pre> + +<h3 id="Example:_Setting_and_getting_a_year_between_1900_and_1999" name="Example:_Setting_and_getting_a_year_between_1900_and_1999">Exemplo: Setando e recuperando um ano entre 1900 e 1999</h3> + +<p>O segundo statement atribui o valor 95 à variável <code>year</code>, representanto o ano 1995.</p> + +<pre class="brush: js">var Xmas.setYear(95); +var year = Xmas.getYear(); // returns 95 +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif;">Especificação</strong></th> + <th scope="col">Status</th> + <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif;">Comentário</strong></th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td><span style="background-color: rgba(212, 221, 228, 0.14902);">Definição inicial. Implementado em JavaScript</span> 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.4', 'Date.prototype.getYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definido em (informativo) compatibilidade annex.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getyear', 'Date.prototype.getYear')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definido em (normativo) annex para funcionalidades adicionais para futuros browsers web.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</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("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setYear()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/index.html b/files/pt-br/web/javascript/reference/global_objects/date/index.html new file mode 100644 index 0000000000..b83fe9a4fd --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/index.html @@ -0,0 +1,271 @@ +--- +title: Date +slug: Web/JavaScript/Reference/Global_Objects/Date +tags: + - Date + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Date +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>Cria uma instância JavaScript de <strong><code>Date</code></strong> que representa um único momento no tempo. Objetos Date são baseados no valor de tempo que é o número de milisegundos desde 1º de Janeiro de 1970 (UTC).</p> + +<h2 id="Syntax" name="Syntax">Construtor</h2> + +<pre class="brush: js">new Date(); +new Date(<em>valor</em>); +new Date(<em>dataString</em>); +new Date(<em>ano</em>, <em>mês</em>, <em>dia</em>, <em>hora</em>, <em>minuto</em>, <em>segundo</em>, <em>milissegundo</em>);</pre> + +<p>{{ note('Note que objetos JavaScript <code>Date</code> só podem ser instanciados chamando JavaScript <code>Date</code> como um construtor: chamá-lo como uma função regular (ou seja, sem o operador <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a>) irá retornar uma string ao invés de um objeto <code>Date</code>; ao contrário de outros tipos de objetos JavaScript, objetos JavaScript <code>Date</code> não têm sintaxe literal.') }}</p> + +<h3 id="Parameters" name="Parameters">Parâmetros para o constructor Date</h3> + +<p>Nota: Quando Date for chamado como um construtor com mais de um argumento, se os valores forem maiores do que seu limite lógico (e.g. se 13 for fornecido como um valor para mês ou 70 for o valor para minuto), o valor adjacente será ajustado. E.g. new Date(2013, 13, 1) é equivalente a new Date(2014, 1, 1), ambos criam uma data para 2014-02-01 (note que o mês começa em 0). Similarmente para outros valores: new Date(2013, 2, 1, 0, 70) é equivalente a new Date(2013, 2, 1, 1, 10), pois ambos criam uma data para 2013-03-01T01:10:00.</p> + +<dl> + <dt><em><code>value</code></em></dt> + <dd>Um valor inteiro representando o número de milisegundos desde 1 de Janeiro de 1970 00:00:00 UTC (Era Unix ou Marco Zero).</dd> +</dl> + +<dl> + <dt><em><code>dataString</code></em></dt> + <dd>Um valor do tipo String que representa uma data. A string deverá estar uma formato reconhecido pelo método {{jsxref("Date.parse()")}} (<a class="external" href="http://tools.ietf.org/html/rfc2822#page-14" title="http://tools.ietf.org/html/rfc2822#page-14">IETF-compliant RFC 2822 timestamps</a> e também uma <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15">versão da ISO8601</a>).</dd> +</dl> + +<dl> + <dt><em><code>year</code></em></dt> + <dd>Um valor inteiro que representa o ano. Valores de 0 a 99 correspondem aos anos de 1900 a 1999. Veja o <a href="#Two digit years">exemplo abaixo</a>.</dd> +</dl> + +<dl> + <dt><em><code>month</code></em></dt> + <dd>Um valor inteiro que representa o mês, começando com 0 para Janeiro até 11 para Dezembro.</dd> +</dl> + +<dl> + <dt><em><code>day</code></em></dt> + <dd>Um valor inteiro que representa o dia do mês.</dd> +</dl> + +<dl> + <dt><em><code>hour</code></em></dt> + <dd>Um valor inteiro que representa a hora do dia.</dd> +</dl> + +<dl> + <dt><em><code>minute</code></em></dt> + <dd>Um valor inteiro que representa o segmento de um minuto de tempo.</dd> +</dl> + +<dl> + <dt><em><code>second</code></em></dt> + <dd>Um valor inteiro que representa o segmento de segundo do tempo.</dd> +</dl> + +<dl> + <dt><em><code>millisecond</code></em></dt> + <dd>Um valor inteiro que representa o segmento de milisegundo do tempo.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<ul> + <li>Se nenhum argumento for fornecido, o construtor criará um objeto JavaScript Date com a data e hora corrente de acordo com as configurações do sistema.</li> + <li>Se ao menos 2 argumentos forem fornecidos, os argumentos ausentes serão configurados como 1 (se o dia estiver ausente) ou 0 para todos os outros.</li> + <li>A data do JavaScript é baseada no valor de tempo em milisegundos desde a meia noite de 01 de Janeiro de 1970, UTC. Um dia corresponde a 86.400,000 milisegundos. O intervalo do objeto Date no JavaScript é de -100.000,000 dias a 100.000,000 dias relativo a 01 de Janeiro de 1970, UTC.</li> + <li>O objeto Date no JavaScript tem um comportamento uniforme nas plataformas. O valor do tempo pode ser transmitido entre sistemas para representar o mesmo instante no tempo e se for usado para criar um objeto de data local, ele refletirá o tempo local equivalente.</li> + <li>O objeto Date JavaScript suporta vários métodos UTC (universal), assim como métodos de tempo locais. UTC, também conhecido como Tempo Médio de Greenwich (Greenwich Mean Time, GMT), refere-se ao tempo como definido pelo Padrão de Tempo Mundial (World Time Standard). O tempo local é o tempo conhecido pelo computador onde o JavaScript é executado.</li> + <li>Invocar o objeto Date no JavaScript como uma função (i.e., sem o operador <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a>) retornatá uma string representando a data e hora corrente.</li> +</ul> + +<h2 id="Properties" name="Properties">Propriedades</h2> + +<dl> + <dt>{{jsxref("Date.prototype")}}</dt> + <dd>Permite adicionar propriedades a um objeto javaScript Date.</dd> + <dt>Date.length</dt> + <dd>O valor de <code>Date.length</code> é 7. Esse é o número de argumentos manipulados pelo construtor.</dd> +</dl> + +<p>{{ jsOverrides("Function", "properties", "prototype") }}</p> + +<h2 id="Methods" name="Methods">Métodos</h2> + +<dl> + <dt>{{jsxref("Date.now()")}}</dt> + <dd>Retorna o valor numérico correspondente ao tempo corrente - o número de milisegundos passados desde 1 de Janeiro de 1970 00:00:00 UTC.</dd> + <dt>{{jsxref("Date.parse()")}}</dt> + <dd>Analisa uma string que representa uma data e retorna o número de milisegundos desde 1 de Janeiro, 1970, 00:00:00, hora local.</dd> + <dt>{{jsxref("Date.UTC()")}}</dt> + <dd>Aceita os mesmos parâmetros como a forma mais longa do construtor (i.e. 2 até 7) e retorna o número de milisegundos desde 1 de Janeiro, 1970, 00:00:00 UTC. </dd> +</dl> + +<p>{{ jsOverrides("Function", "Methods", "now", "parse", "UTC") }}</p> + +<h2 id="Date_instances" name="Date_instances">Instâncias JavaScript de <code>Date</code> </h2> + +<p>Todas as instâncias <code>Date</code> são herdadas de {{jsxref("Date.prototype")}}. O objeto protótipo do construtor <code>Date</code> pode ser modificado para afetar todas as instâncias de <code>Date</code>.</p> + +<h3 id="Métodos">Métodos</h3> + +<p>{{ page("/en-US/docs/JavaScript/Reference/Global_Objects/Date/prototype", "Methods") }}</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Several_ways_to_assign_dates" name="Example:_Several_ways_to_assign_dates">Várias formas de se criar um objeto Date</h3> + +<p>Os seguintes exemplos mostram várias formas de se criar datas em JavaScript: </p> + +<div class="note"> +<p><strong>Nota:</strong> a conversão de <em>strings</em> com o construtor de <code>Date</code> (<code>Date.parse</code> é equivalente ao contrutor) é fortemente desencorajada devido às inconsistências e diferenças dos navegadores.</p> +</div> + +<pre class="brush: js">var today = new Date(); +var birthday = new Date("December 17, 1995 03:24:00"); +var birthday = new Date("1995-12-17T03:24:00"); +var birthday = new Date(1995,11,17); +var birthday = new Date(1995,11,17,3,24,0); +</pre> + +<h3 id="Anos_com_dois_dígitos_mapeados_para_1900_-_1999"><a name="Two digit years">Anos com dois dígitos mapeados para 1900 - 1999</a></h3> + +<p>Para criar e obter datas entre os anos 0 e 99 os métodos {{jsxref("Date.prototype.setFullYear()")}} e {{jsxref("Date.prototype.getFullYear()")}} devem ser usados.</p> + +<pre class="brush: js">var data = new Date(98, 1); //<span class="objectBox objectBox-string"> Dom Fev 01 1998 00:00:00 GMT+0000 (GMT)</span> + +// Métodos em desuso, 98 mapeia para 1998 aqui também +data.setYear(98); // Dom Fev 01 1998 00:00:00 GMT+0000 (GMT) + +data.setFullYear(98); // Sab Fev 01 0098 00:00:00 GMT+0000 (BST)</pre> + +<h3 id="Example:_Calculating_elapsed_time" name="Example:_Calculating_elapsed_time">Calculando o tempo decorrido</h3> + +<p>Os seguintes exemplos mostram como determinar o tempo decorrido entre duas datas no JavaScript em milissegundos.</p> + +<p>Devido aos tamanhos diferentes dos dias (devido à mudança do horário de verão), meses e dias, expressar o tempo decorrido em unidades maiores que horas, minutos e segundos requer analisar os problemas e deve ser cuidadosamente investigado antes de se tentar utilizar.</p> + +<pre class="brush: js">// usando objetos Date +var inicio = Date.now(); + +// o evento para o tempo vai aqui: +facaAlgoPorUmLongoTempo(); +var fim = Date.now(); +var decorrido = fim - inicio; // tempo decorrido em milisegundos +</pre> + +<pre class="brush: js">// utilizando métodos embutidos +var inicio = new Date(); + +// o evento para o tempo vai aqui: +facaAlgoPorUmLongoTempo(); +var fim = new Date(); +var decorrido = fim.getTime() - inicio.getTime(); // tempo decorrido em milisegundos +</pre> + +<pre class="brush: js">// para testar uma função e obter o seu retorno +function imprimirTempoDecorrido(fTeste) { + var nHoraInicial = Date.now(), + vRetorno = fTeste(), + nHoraFinal = Date.now(); + + alert("Tempo decorrido: " + String(nHoraFinal - nHoraInicial) + " milisegundos"); + return vRetorno; +} + +retornoDaSuaFuncao = imprimirTempoDecorrido(suaFuncao); +</pre> + +<div class="note"> +<p>Nota: Em navegadores que suportam a API de Desempenho Web ({{domxref("window.performance", "Web Performance API", "", 1)}}) com o recurso de tempo de alta resolução, {{domxref("Performance.now()")}} pode fornecer medidas de tempo decorrido mais confiáveis e precisas do que {{jsxref("Date.now()")}}.</p> +</div> + +<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('ESDraft', '#sec-date-objects', 'Date')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date-objects', 'Date')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9', 'Date')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.1.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2> + +<p>{{ CompatibilityTable() }}</p> + +<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>{{CompatVersionUnknown()}} [1]</td> + <td>{{CompatVersionUnknown()}} [1]</td> + <td>{{CompatVersionUnknown()}} [2]</td> + <td>{{CompatVersionUnknown()}} [1]</td> + <td>{{CompatVersionUnknown()}} [1]</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><span style="font-size: 12px; line-height: 18px;">Suporte Básico</span></td> + <td>{{CompatVersionUnknown()}}</td> + <td>{{CompatVersionUnknown()}}</td> + <td>{{CompatVersionUnknown()}}</td> + <td>{{CompatVersionUnknown()}}</td> + <td>{{CompatVersionUnknown()}}</td> + <td>{{CompatVersionUnknown()}}</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] Alguns navegadores pode ter problemas quando verificam datas: <a href="http://dygraphs.com/date-formats.html">3/14/2012 blog from danvk Comparing FF/IE/Chrome on Parsing Date Strings</a></p> + +<p>[2] <a href="https://msdn.microsoft.com/en-us//library/ie/ff743760(v=vs.94).aspx">ISO8601 Date Format não é suportado</a> o Internet Explorer 8 e outras versões podem ter <a href="http://dygraphs.com/date-formats.html">problemas quando convertem datas</a></p> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/now/index.html b/files/pt-br/web/javascript/reference/global_objects/date/now/index.html new file mode 100644 index 0000000000..2eef32c0b7 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/now/index.html @@ -0,0 +1,126 @@ +--- +title: Date.now() +slug: Web/JavaScript/Reference/Global_Objects/Date/now +tags: + - JavaScript + - Reference + - Referencia + - data + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Date/now +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método<strong><code> Date.now()</code></strong> retorna o número de milisegundos decorridos desde 1 de janeiro de 1970 00:00:00 UTC.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox">var timeInMs = Date.now(); +</pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<p>Nenhum.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>O método <strong><code>now()</code></strong> retorna os milisegundos decorridos desde 1 de janeiro de 1970 00:00:00 UTC até agora como um {{jsxref("Global_Objects/Number", "Number")}}.</p> + +<p>Por que <strong><code>now</code> </strong>é um método estático de <strong><code>Date</code></strong>, você sempre o usará como <strong><code>Date.now()</code></strong>.</p> + +<h2 id="Compatibility" name="Compatibility">Polyfill</h2> + +<p>Este método foi padronizado no ECMA-262 5<sup>th</sup> edition. Em ambientes que não estão atualizados para suportar este método você pode suprir esta carência utilizando o seguinte:</p> + +<pre class="brush: js">if (!Date.now) { + Date.now = function now() { + return new Date().getTime(); + }; +} +</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.9.4.4', 'Date.now')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.5</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.now', 'Date.now')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2> + +<p>Baseado em <a href="http://kangax.github.com/es5-compat-table/">Kangax's compat table</a>.</p> + +<p>{{ CompatibilityTable() }}</p> + +<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>5</td> + <td>3</td> + <td>9</td> + <td>10.50</td> + <td>4</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> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{domxref("window.performance.now")}} - fornece timestamps com sub-millisegundo precisão para uso em medir o desempenho da página</li> + <li>{{domxref("console.time")}} / {{domxref("console.timeEnd")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/parse/index.html b/files/pt-br/web/javascript/reference/global_objects/date/parse/index.html new file mode 100644 index 0000000000..ccba92e923 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/parse/index.html @@ -0,0 +1,214 @@ +--- +title: Date.parse() +slug: Web/JavaScript/Reference/Global_Objects/Date/parse +translation_of: Web/JavaScript/Reference/Global_Objects/Date/parse +--- +<div> {{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <strong><code>Date.parse()</code></strong> analisa uma representação de data em <em>string</em>, e retorna o número de milisegundos desde 01 de Janeiro de 1970, 00:00:00 UTC ou NaN se a string não for reconhecida ou, em alguns casos, contiver valores inválidos de data (ex. 2015-02-31).</p> + +<p>O uso de <code>Date.parse</code> não é recomendado, uma vez que até ES5 a análise de strings era inteiramente dependente de implementação. Ainda existem muitas diferenças de como diferentes plataformas analisam strings de data, então strings de data devem ser manualmente analisadas (uma biblioteca pode ajudar caso seja necessário atender a vários formatos)</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<p>Chamada direta:</p> + +<pre class="syntaxbox notranslate"><code>Date.parse(<var>dateString</var>)</code></pre> + +<p>Chamada implícita:</p> + +<pre class="syntaxbox notranslate"><code>new Date(<var>dateString</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>dateString</code></dt> + <dd>Uma <em>string</em> de representação de datas no format <a href="http://tools.ietf.org/html/rfc2822#page-14">RFC2822</a> ou ISO 8601 (outros formatos podem ser utilizados, mas os resultados podem não ser os esperados).</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>O método <code>parse()</code> analisa uma <em>string</em> de data (como <code>"Dec 25, 1995"</code>) e retorna o número de milisegundos desde 01 de Janeiro de 1970, 00:00:00 UTC. Esta função é útil para definir valores de data baseados em valores de <em>string</em>, por exemplo em conjunto com o método {{jsxref("Date.prototype.setTime()", "setTime()")}} e o objeto {{jsxref("Global_Objects/Date", "Date")}}.</p> + +<p>Dada uma string representando um tempo, <code>parse()</code> retorna o valor temporal. É aceito o RFC2822 / IETF sintaxe de data (<a href="http://tools.ietf.org/html/rfc2822#page-14">RFC2822 Section 3.3</a>), ex.: <code>"Mon, 25 Dec 1995 13:30:00 GMT"</code>. A função entende as abreviações dos fusos horários continentais dos EUA, mas para uso geral, use um deslocamento de fuso horário, por exemplo, <code>"Seg, 25 Dez 1995 13:30:00 +0430"</code> (4 horas, 30 minutos à leste do Meridiano de Greenwich). Se o fuso horário não é especificado e a string está em um formato ISO reconhecido pela ES5, então é adotado o formato UTC (Tempo Universal Coordenado). GMT e UTC são considerados equivalentes. O fuso horário do seu horário local é usado para interpreatar argumentos na <a href="http://tools.ietf.org/html/rfc2822#page-14">RFC2822 Formato 3.3</a> (ou qualquer formato não reconhecido como ISO 8601 na ES5) que não contenha informação de fuso horário. + +</p><h3 id="Suporte_ao_formato_ECMAScript_5_ISO-8601">Suporte ao formato ECMAScript 5 ISO-8601</h3> + +<p><em>Astring </em>Data e hora pode ser no formato <a href="http://www.w3.org/TR/NOTE-datetime">ISO 8601</a>. Por exemplo, <code>"2011-10-10"</code> (apenas data) ou <code>"2011-10-10T14:48:00"</code> (data e hora) podem ser passados ou convertidos. O fuso horario UTC é usado para interpretar argumentos no formato <a href="http://www.w3.org/TR/NOTE-datetime">ISO 8601</a> que não contenham informação de fuso horário (note que <a href="http://people.mozilla.org/~jorendorff/es6-draft.html#sec-date-time-string-format">ECMAScript ed 6 draft</a> especifica que a <em>string </em>do tipo data e hora sem um fuso horário são tratados como data local, não UTC).</p> + +<p>While time zone specifiers are used during date string parsing to interpret the argument, the value returned is always the number of milliseconds between January 1, 1970 00:00:00 UTC and the point in time represented by the argument.</p> + +<p>Because <code>parse()</code> is a static method of {{jsxref("Global_Objects/Date", "Date")}}, it is called as <code>Date.parse()</code> rather than as a method of a {{jsxref("Global_Objects/Date", "Date")}} instance.</p> + +<h3 id="Differences_in_assumed_time-zone" name="Differences_in_assumed_time-zone">Differences in assumed time zone</h3> + +<p>Given a date string of <code>"March 7, 2014"</code>, <code>parse()</code> assumes a local time zone, but given an ISO format such as <code>"2014-03-07"</code> it will assume a time zone of UTC. Therefore {{jsxref("Global_Objects/Date", "Date")}} objects produced using those strings will represent different moments in time unless the system is set with a local time zone of UTC. This means that two date strings that appear equivalent may result in two different values depending on the format of the string that is being converted (this behavior is changed in ECMAScript ed 6 so that both will be treated as local).</p> + +<h3 id="Fall-back_to_implementation-specific_date_formats">Fall-back to implementation-specific date formats</h3> + +<p>The ECMAScript specification states: If the String does not conform to the standard format the function may fall back to any implementation–specific heuristics or implementation–specific parsing algorithm. Unrecognizable strings or dates containing illegal element values in ISO formatted strings shall cause <code>Date.parse()</code> to return {{jsxref("Global_Objects/NaN", "NaN")}}.</p> + +<p>However, invalid values in date strings not recognized as ISO format as defined by ES5 may or may not result in {{jsxref("Global_Objects/NaN", "NaN")}}, depending on the browser and values provided, e.g.:</p> + +<pre class="brush: js notranslate">// Non-ISO string with invalid date values +new Date('23/25/2014'); +</pre> + +<p>will be treated as a local date of 25 November, 2015 in Firefox 30 and an invalid date in Safari 7. However, if the string is recognized as an ISO format string and it contains invalid values, it will return {{jsxref("Global_Objects/NaN", "NaN")}} in all browsers compliant with ES5:</p> + +<pre class="brush: js notranslate">// ISO string with invalid values +new Date('2014-25-23').toISOString(); +// returns "RangeError: invalid date" in all es5 compliant browsers +</pre> + +<p>SpiderMonkey's implementation-specific heuristic can be found in <a href="http://mxr.mozilla.org/mozilla-central/source/js/src/jsdate.cpp?rev=64553c483cd1#889"><code>jsdate.cpp</code></a>. The string <code>"10 06 2014"</code> is an example of a non–conforming ISO format and thus falls back to a custom routine. See also this <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=1023155#c6">rough outline</a> on how the parsing works.</p> + +<pre class="brush: js notranslate">new Date('10 06 2014'); +</pre> + +<p>will be treated as a local date of 6 October, 2014 and not 10 June, 2014. Other examples:</p> + +<pre class="brush: js notranslate">new Date('foo-bar 2014').toString(); +// returns: "Invalid Date" + +Date.parse('foo-bar 2014'); +// returns: NaN +</pre> + +<h2 id="Examples" name="Examples">Examples</h2> + +<h3 id="Example_Using_parse" name="Example:_Using_parse">Example: Using <code>Date.parse()</code></h3> + +<p>If <code>IPOdate</code> is an existing {{jsxref("Global_Objects/Date", "Date")}} object, it can be set to August 9, 1995 (local time) as follows:</p> + +<pre class="brush: js notranslate">IPOdate.setTime(Date.parse('Aug 9, 1995'));</pre> + +<p>Some other examples of parsing non–standard date strings:</p> + +<pre class="brush: js notranslate">Date.parse('Aug 9, 1995');</pre> + +<p>Returns <code>807937200000</code> in time zone GMT-0300, and other values in other time zones, since the string does not specify a time zone and is not ISO format, therefore the time zone defaults to local.</p> + +<pre class="brush: js notranslate">Date.parse('Wed, 09 Aug 1995 00:00:00 GMT');</pre> + +<p>Returns <code>807926400000</code> no matter the local time zone as GMT (UTC) is provided.</p> + +<pre class="brush: js notranslate">Date.parse('Wed, 09 Aug 1995 00:00:00');</pre> + +<p>Returns <code>807937200000</code> in time zone GMT-0300, and other values in other time zones, since there is no time zone specifier in the argument and it is not ISO format, so is treated as local.</p> + +<pre class="brush: js notranslate">Date.parse('Thu, 01 Jan 1970 00:00:00 GMT');</pre> + +<p>Returns <code>0</code> no matter the local time zone as a time zone GMT (UTC) is provided.</p> + +<pre class="brush: js notranslate">Date.parse('Thu, 01 Jan 1970 00:00:00');</pre> + +<p>Returns <code>14400000</code> in time zone GMT-0400, and other values in other time zones, since no time zone is provided and the string is not in ISO format, therfore the local time zone is used.</p> + +<pre class="brush: js notranslate">Date.parse('Thu, 01 Jan 1970 00:00:00 GMT-0400');</pre> + +<p>Returns <code>14400000</code> no matter the local time zone as a time zone GMT (UTC) is provided.</p> + +<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>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.4.2', 'Date.parse')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>ISO 8601 format added.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.parse', 'Date.parse')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</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> + <tr> + <td>ISO 8601 format</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckodesktop("2.0")}}</td> + <td>{{CompatIE("9")}}</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>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>ISO 8601 format</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">See also</h2> + +<ul> + <li>{{jsxref("Date.UTC()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setdate/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setdate/index.html new file mode 100644 index 0000000000..92748130fc --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/setdate/index.html @@ -0,0 +1,80 @@ +--- +title: Date.prototype.setDate() +slug: Web/JavaScript/Reference/Global_Objects/Date/setDate +tags: + - Date + - JavaScript + - Métodos + - Prototype + - Referencia +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setDate +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>setDate()</code></strong> configura o dia do objeto {{jsxref("Date")}} relativamente ao início do mês configurado previamente.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setdate.html")}}</div> + +<p class="hidden">A fonte desse exemplo interativo fica guardada em um repositóiro no GitHub. Se você quiser contribuir para o projeto de exemplos interativos, 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 notranslate"><code><var>dateObj</var>.setDate(<var>dayValue</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>dayValue</code></dt> + <dd>Um número inteiro que representa o dia do mês.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milisegundos entre 1o de janeiro de 1970 00:00:00 UTC e a data indicada (o objeto {{jsxref("Date")}} é mudado no lugar).</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se o <code>dayValue</code> estiver fora da extensão de valores de data para o mês, <code>setDate()</code> vai atualizar o objeto {{jsxref("Date")}} consequentemente.</p> + +<p>Por exemplo, se 0 for fornecido para <code>dayValue</code>, a data será configurada para o último dia do mês anterior.</p> + +<p>Se um número negativo for fornecido para <code>dayValue</code>, a data será configurada contando-se regressivamente desde o último dia do mês anterior. -1 resultará na data sendo configurada para um dia antes do último dia o mês anterior.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setDate">Usando <code>setDate()</code></h3> + +<pre class="brush: js notranslate">var theBigDay = new Date(1962, 6, 7); // 1962-07-07 (7th of July 1962) +theBigDay.setDate(24); // 1962-07-24 (24th of July 1962) +theBigDay.setDate(32); // 1962-08-01 (1st of August 1962) +theBigDay.setDate(22); // 1962-08-22 (22th of August 1962) +theBigDay.setDate(0); // 1962-07-31 (31th of July 1962) +theBigDay.setDate(98); // 1962-10-06 (6th of October 1962) +theBigDay.setDate(-50); // 1962-08-11 (11th of August 1962) +</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-date.prototype.setdate', 'Date.prototype.setDate')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Browsers">Compatibilidade de Browsers</h2> + +<p class="hidden">A tabela de compatibilidade nessa página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, por favor veja <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</p> + +<p>{{Compat("javascript.builtins.Date.setDate")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getDate()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setfullyear/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setfullyear/index.html new file mode 100644 index 0000000000..4f38399a21 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/setfullyear/index.html @@ -0,0 +1,80 @@ +--- +title: Date.prototype.setFullYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/setFullYear +tags: + - Date + - JavaScript + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setFullYear +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>setFullYear()</code></strong> atribui o ano completo para a data especificada de acordo com o horário universal (UTC). Retorna uma nova data e hora.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setfullyear.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setFullYear(<var>yearValue</var>[, <var>monthValue</var>[, <var>dateValue</var>]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>yearValue</code></dt> + <dd>Um inteiro especificando o valor número de um ano, por exemplo, 1995.</dd> + <dt><code>monthValue</code></dt> + <dd>Opcional. Um inteiro entre 0 e 11 representando os meses Janeiro até Dezembro.</dd> + <dt><code>dateValue</code></dt> + <dd>Opcional. Um inteiro entre 1 e 31 representando o dia do mês. Se você especificar o parâmetro <code>dateValue</code>, você deve também especificar <code>monthValue</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O número de milisegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se você não especificar os parâmetros <code>monthValue</code> e <code>dateValue</code>, os valores retornados dos métodos {{jsxref("Date.prototype.getMonth()", "getMonth()")}} e {{jsxref("Date.prototype.getDate()", "getDate()")}} são usados.</p> + +<p>Se um parâmetro que você especificou está fora do alcance esperado, <code>setFullYear()</code> tenta atualizar os outros parâmetros e a informação de data no objeto {{jsxref("Date")}} adequadamente. Por exemplo, se você especificar 15 para o <code>monthValue</code>, o ano será incrementado em 1 (<code>yearValue + 1</code>), e 3 é usado para o mês.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setFullYear">Usando <code>setFullYear()</code></h3> + +<pre class="brush: js notranslate">var theBigDay = new Date(); +theBigDay.setFullYear(1997); +</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-date.prototype.setfullyear', 'Date.prototype.setFullYear')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.setFullYear")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setYear()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/sethours/index.html b/files/pt-br/web/javascript/reference/global_objects/date/sethours/index.html new file mode 100644 index 0000000000..77b161e0ce --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/sethours/index.html @@ -0,0 +1,85 @@ +--- +title: Date.prototype.setHours() +slug: Web/JavaScript/Reference/Global_Objects/Date/setHours +tags: + - Date + - JavaScript + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setHours +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>setHours()</code></strong> atribui as horas para uma data especificada de acordo com a hora local e retorna o número de milissegundos desde do dia 1 de Janeiro de 1970 00:00:00 UTC até o tempo representado pela instância {{jsxref("Date")}} atualizada.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-sethours.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setHours(<var>hoursValue</var>[, <var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]]])</code></pre> + +<h3 id="Versões_anteriores_ao_JavaScript_1.3">Versões anteriores ao JavaScript 1.3</h3> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setHours(<var>hoursValue</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>hoursValue</code></dt> + <dd>Idealmente, um número inteiro entre 0 e 23, representando a hora. Se um valor maior que 23 for fornecido, a data e hora será incrementada pelas horas extras.</dd> + <dt><code>minutesValue</code></dt> + <dd>Opcional. Idealmente, um número inteiro entre 0 e 59, representando os minutos. Se um valor maior que 59 for fornecido, a data e hora será incrementada em minutos extras.</dd> + <dt><code>secondsValue</code></dt> + <dd>Opcional. Idealmente, um número inteiro entre 0 e 59, representando os segundos. Se um valor maior que 59 for fornecido, a data e hora será incrementada em segundos extras. Se você especificar o parâmetro <code>secondsValue</code>, também deverá especificar parâmetro <code>minutesValue</code>.</dd> + <dt><code>msValue</code></dt> + <dd>Opcional. Idealmente, um número entre 0 e 999, representando os milissegundos. Se um valor maior que 999 for fornecido, a data e hora será incrementada em milissegundos extras. Se você especificar o parâmetro <code>msValue</code>, você também deve especificar <code>minutesValue</code> e <code>secondsValue</code>.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milissegundos entre dia 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se você não especifica os parâmetros <code>minutesValue</code>, <code>secondsValue</code>, e <code>msValue</code>, os valores retornados dos métodos {{jsxref("Date.prototype.getMinutes()", "getMinutes()")}}, {{jsxref("Date.prototype.getSeconds()", "getSeconds()")}}, e {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}} são usados.</p> + +<p>Se um parâmetro que você especificar estiver fora do intervalo esperado, <code>setHours()</code> tenta atualizar as informações de data no objeto {{jsxref("Date")}}. Por exemplo, se você usa 100 para <code>secondsValue</code>, os minutos serão incrementados em 1 (<code>minutesValue + 1</code>), e 40 serão usados para os segundos.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setHours">Usando <code>setHours()</code></h3> + +<pre class="brush:js notranslate">var theBigDay = new Date(); +theBigDay.setHours(7); +</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-date.prototype.sethours', 'Date.prototype.setHours')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.setHours")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getHours()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setmilliseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setmilliseconds/index.html new file mode 100644 index 0000000000..f632e02bf9 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/setmilliseconds/index.html @@ -0,0 +1,74 @@ +--- +title: Date.prototype.setMilliseconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>setMilliseconds()</code></strong> atribui os milissegundos para a data específica de acordo com a hora local.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setmilliseconds.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setMilliseconds(<var>millisecondsValue</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>millisecondsValue</code></dt> + <dd>Um número entre 0 e 999, representando os milissegundos.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milissegundos entre dia 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se você especifica um número fora do alcance esperado, a informação de data no objeto {{jsxref("Date")}} é atualizado de acordo. Por exemplo, se você especifica 1005, o número de segundos é incrementado em 1, e 5 é utilizado para os milissegundos.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setMilliseconds">Usando <code>setMilliseconds()</code></h3> + +<pre class="brush: js notranslate">var theBigDay = new Date(); +theBigDay.setMilliseconds(100); +</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-date.prototype.setmilliseconds', 'Date.prototype.setMilliseconds')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.setMilliseconds")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setminutes/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setminutes/index.html new file mode 100644 index 0000000000..ece5608638 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/setminutes/index.html @@ -0,0 +1,84 @@ +--- +title: Date.prototype.setMinutes() +slug: Web/JavaScript/Reference/Global_Objects/Date/setMinutes +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMinutes +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>setMinutes()</code></strong> atribui os minutos para uma data específica de acordo com o horário local.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setminutes.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setMinutes(<var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]])</code></pre> + +<h3 id="Versões_anteriores_ao_JavaScript_1.3">Versões anteriores ao JavaScript 1.3</h3> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setMinutes(<var>minutesValue</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>minutesValue</code></dt> + <dd>Um inteiro entre 0 e 59, representando os mintuos.</dd> + <dt><code>secondsValue</code></dt> + <dd>Opcional. Um inteiro entre 0 e 59, representando os segundos. Se você especificar o parâmetro <code>secondsValue</code>, você também deve especificar <code>minutesValue</code>.</dd> + <dt><code>msValue</code></dt> + <dd>Opcional. Um número entre 0 e 999, representando os milissegundos. Se você especificar o parâmetro <code>msValue</code>, você deve também especificar <code>minutesValue</code> e <code>secondsValue</code>.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milissegundos entre dia 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se você não especifica os parâmetros <code>secondsValue</code> e <code>msValue</code>, os valores retornados dos métodos {{jsxref("Date.prototype.getSeconds()", "getSeconds()")}} e {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}} são usados.</p> + +<p>Se um parâmetro que você especificou estiver fora do alcance esperado, <code>setMinutes()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usa 100 para <code>secondsValue</code>, os minutos serão incrementados em 1 (<code>minutesValue + 1</code>), e 40 serão usados para segundos.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setMinutes">Usando <code>setMinutes()</code></h3> + +<pre class="brush: js notranslate">var theBigDay = new Date(); +theBigDay.setMinutes(45); +</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-date.prototype.setminutes', 'Date.prototype.setMinutes')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.setMinutes")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setmonth/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setmonth/index.html new file mode 100644 index 0000000000..e9ac42302a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/setmonth/index.html @@ -0,0 +1,87 @@ +--- +title: Date.prototype.setMonth() +slug: Web/JavaScript/Reference/Global_Objects/Date/setMonth +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMonth +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>setMonth()</code></strong> atribui o mês para uma data específica de acordo com o ano corrente.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setmonth.html")}}</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setMonth(<var>monthValue</var>[, <var>dayValue</var>])</code></pre> + +<h3 id="Versões_anteriores_ao_JavaScript_1.3">Versões anteriores ao JavaScript 1.3</h3> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setMonth(<var>monthValue</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>monthValue</code></dt> + <dd>Um inteiro baseado em zero representando o mês do ano a partir do começo do ano. Então, 0 representa Janeiro, 11 representa Dezembro, -1 representa Dezembro do ano passado, e 12 representa Janeiro do ano seguinte.</dd> + <dt><code>dayValue</code></dt> + <dd>Opcional. Um inteiro de 1 a 31, representando o dia do mês.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milissegundos entre dia 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se você não especifica o parâmetro <code>dayValue</code>, o valor retornado do método {{jsxref("Date.prototype.getDate()", "getDate()")}} é utilizado.</p> + +<p>Se um parâmetro que você especificou estiver fora do alcance esperado, <code>setMonth()</code> tenta atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usa 15 para <code>monthValue</code>, o ano será incrementado em 1, e 3 será usado para o mês.</p> + +<p>O dia corrente do mês terá um impacto no comportamento deste método. Conceitualmente ele irá adicionar o número de dias dado pelo dia corrente do mês ao primeiro dia do novo mês especificado como parâmetro, retornando uma nova data. Por exemplo, se o valor corrente é 31 de agosto de 2016, chamando <code>setMonth()</code> com um valor de 1 irá retornar 2 de Março de 2016. Isso acontece porque Fevereiro de 2016 tem 29 dias.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setMonth">Usando <code>setMonth()</code></h3> + +<pre class="brush: js notranslate">var theBigDay = new Date(); +theBigDay.setMonth(6); + +//Cuidado com transições de final de mês +var endOfMonth = new Date(2016, 7, 31); +endOfMonth.setMonth(1); +console.log(endOfMonth); //Wed Mar 02 2016 00:00:00 +</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-date.prototype.setmonth', 'Date.prototype.setMonth')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.setMonth")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getMonth()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setseconds/index.html new file mode 100644 index 0000000000..b474ec29a2 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/setseconds/index.html @@ -0,0 +1,82 @@ +--- +title: Date.prototype.setSeconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/setSeconds +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setSeconds +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>setSeconds()</code></strong> atribui os segundos na data especificada de acordo com o tempo local.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setseconds.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setSeconds(<var>secondsValue</var>[, <var>msValue</var>])</code></pre> + +<h3 id="Versões_anteriores_ao_JavaScript_1.3">Versões anteriores ao JavaScript 1.3</h3> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setSeconds(<var>secondsValue</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>secondsValue</code></dt> + <dd>Um inteiro entre 0 e 59, representando os segundos.</dd> + <dt><code>msValue</code></dt> + <dd>Opcional. Um número entre 0 e 999, representando os milissegundos.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se você não especifica o parâmetro <code>msValue</code>, o valor retornado do método {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}} é utilizado.</p> + +<p>Se um parâmetro que você especificou está fora do alcance esperado, <code>setSeconds()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usar 100 para <code>secondsValue</code>, os minutos guardados no objeto {{jsxref("Date")}} serão incrementados em 1, e 40 serão usados para os segundos.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setSeconds">Usando <code>setSeconds()</code></h3> + +<pre class="brush: js notranslate">var theBigDay = new Date(); +theBigDay.setSeconds(30); +</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-date.prototype.setseconds', 'Date.prototype.setSeconds')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.setSeconds")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/settime/index.html b/files/pt-br/web/javascript/reference/global_objects/date/settime/index.html new file mode 100644 index 0000000000..cc4f4472ba --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/settime/index.html @@ -0,0 +1,95 @@ +--- +title: Date.prototype.setTime() +slug: Web/JavaScript/Reference/Global_Objects/Date/setTime +tags: + - Date + - JavaScript + - Prototype + - Referencia + - Tempo + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setTime +--- +<div>{{JSRef}}</div> + +<div>O método <strong><code>setTime() </code></strong>atribui ao objecto {{jsxref("Date")}} a hora representada pelo número de milisegundos desde 1 de janeiro de 1970 as 00:00:00 UTC.</div> + +<div> </div> + +<div>{{EmbedInteractiveExample("pages/js/date-settime.html")}}</div> + +<p class="hidden">A fonte para este exemplo interativo está armazenado em um repositório do GitHub. Se você gostaria de contribuir para o projeto de exemplos interativos, 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="Sintáxe">Sintáxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.setTime(<var>timeValue</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>timeValue</code></dt> + <dd>Um inteiro representando o número de milisegundos desde 1 de janeiro 1970, 00:00:00 UTC.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O número de milisegundos entre 1 de janeiro de 1970 00:00:00 UTC e a data atualizada (efetivamente, o valor do argumento).</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Use o método <code>setTime()</code> para ajudar a atribuir data e hora para outro objeto {{jsxref("Date")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setTime()">Usando <code>setTime()</code></h3> + +<pre class="brush: js">var theBigDay = new Date('July 1, 1999'); +var sameAsBigDay = new Date(); +sameAsBigDay.setTime(theBigDay.getTime()); +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.27', 'Date.prototype.setTime')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.settime', 'Date.prototype.setTime')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.settime', 'Date.prototype.setTime')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_nos_Browsers">Compatibilidade nos Browsers</h2> + +<p class="hidden">A tabela de compatibilidade nesta página é gerada a patir de dados estruturados. Caso queira contribuir com os dados, por favor confira <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</p> + +<p>{{Compat("javascript.builtins.Date.setTime")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getTime()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setutcdate/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setutcdate/index.html new file mode 100644 index 0000000000..4190b96120 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/setutcdate/index.html @@ -0,0 +1,74 @@ +--- +title: Date.prototype.setUTCDate() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCDate +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCDate +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>setUTCDate()</code></strong> atribui o dia do mês para uma data especifica de acordo com o horário universal.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setutcdate.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setUTCDate(<var>dayValue</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>dayValue</code></dt> + <dd>Um inteiro entre 1 e 31, representando o dia do mês.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se um parâmetro que você especificou está fora do alcance esperado, <code>setUTCDate()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usar 40 para <code>dayValue</code>, e o mês guardado no objeto {{jsxref("Date")}} é Junho, o dia será trocado para 10 e o mês será incrementado para Julho.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setUTCDate">Usando <code>setUTCDate()</code></h3> + +<pre class="brush: js notranslate">var theBigDay = new Date(); +theBigDay.setUTCDate(20); +</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-date.prototype.setutcdate', 'Date.prototype.setUTCDate')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.setUTCDate")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.setDate()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setutcfullyear/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setutcfullyear/index.html new file mode 100644 index 0000000000..657b65d9aa --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/setutcfullyear/index.html @@ -0,0 +1,80 @@ +--- +title: Date.prototype.setUTCFullYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>setUTCFullYear()</code></strong> atribui o ano completo na data especificada de acordo com o horário universal.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setutcfullyear.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setUTCFullYear(<var>yearValue</var>[, <var>monthValue</var>[, <var>dayValue</var>]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>yearValue</code></dt> + <dd>Um inteiro especificando o valor numérico do ano, por exemplo, 1995.</dd> + <dt><code>monthValue</code></dt> + <dd>Opcional. Um inteiro entre 0 e 11 representando os meses Janeiro até Dezembro.</dd> + <dt><code>dayValue</code></dt> + <dd>Opcional. Um inteiro entre 1 e 31 representando o dia do mês. Se você especificar o parâmetro <code>dayValue</code>, vocẽ deve especificar <code>monthValue</code> também.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se você não especificar os parâmetros <code>monthValue</code> e <code>dayValue</code>, os valores retornados dos métodos {{jsxref("Date.prototype.getUTCMonth()", "getUTCMonth()")}} e {{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}} serão utilizados.</p> + +<p>Se um parâmetro que você especificou está fora do alcance esperado, <code>setUTCFullYear()</code> tentará atualizar os outros parâmetros e a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você especificar 15 para o <code>monthValue</code>, o ano será incrementado em 1 (<code>yearValue + 1</code>), e 3 será usado para o mês.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setUTCFullYear">Usando <code>setUTCFullYear()</code></h3> + +<pre class="brush: js notranslate">var theBigDay = new Date(); +theBigDay.setUTCFullYear(1997); +</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-date.prototype.setutcfullyear', 'Date.prototype.setUTCFullYear')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.setUTCFullYear")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setutchours/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setutchours/index.html new file mode 100644 index 0000000000..5d1304b708 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/setutchours/index.html @@ -0,0 +1,82 @@ +--- +title: Date.prototype.setUTCHours() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>setUTCHours()</code></strong> atribui a hora para a data especificada de acordo com o horário universal, e retorna o número de milissegundos desde 1 de Janeiro de 1970 00:00:00 UTC até o horário representado pela instância {{jsxref("Date")}} atualizada.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setutchours.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setUTCHours(<var>hoursValue</var>[, <var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>hoursValue</code></dt> + <dd>Um inteiro entre 0 e 23, representando a hora.</dd> + <dt><code>minutesValue</code></dt> + <dd>Opcional. Um inteiro entre 0 e 59, representando os minutos.</dd> + <dt><code>secondsValue</code></dt> + <dd>Opcional. Um inteiro entre 0 e 59, representando os segundos. Se você especificar o parâmetro <code>secondsValue</code>, você também deve especificar <code>minutesValue</code>.</dd> + <dt><code>msValue</code></dt> + <dd>Opcional. Um número entre 0 e 999, representando os milissegundos. Se você especificar o parâmetro <code>msValue</code>, você também deve especificar <code>minutesValue</code> e <code>secondsValue</code>.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se você não especificar os parâmetros <code>minutesValue</code>, <code>secondsValue</code>, e <code>msValue</code>, os valores retornados dos métodos {{jsxref("Date.prototype.getUTCMinutes()", "getUTCMinutes()")}}, {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}}, e {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}} serão utilizados.</p> + +<p>Se o parâmetro que você especificou estiver fora do alcance esperado, <code>setUTCHours()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usa 100 para <code>secondsValue</code>, os minutos serão incrementados em 1 (<code>minutesValue + 1</code>), e 40 será usado para os segundos.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setUTCHours">Usando <code>setUTCHours()</code></h3> + +<pre class="brush: js notranslate">var theBigDay = new Date(); +theBigDay.setUTCHours(8); +</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-date.prototype.setutchours', 'Date.prototype.setUTCHours')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.setUTCHours")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCHours()")}}</li> + <li>{{jsxref("Date.prototype.setHours()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html new file mode 100644 index 0000000000..3d52820944 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html @@ -0,0 +1,74 @@ +--- +title: Date.prototype.setUTCMilliseconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>setUTCMilliseconds()</code></strong> atribui os milissegundos para a data especificada de acordo com o horário universal.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setutcmilliseconds.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setUTCMilliseconds(<var>millisecondsValue</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>millisecondsValue</code></dt> + <dd>Um número entre 0 e 999, representando os milissegundos.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se o parâmetro que você especificou estiver fora do alcance esperado, <code>setUTCMilliseconds()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usar 1100 para <code>millisecondsValue</code>, os segundos guardados no objeto {{jsxref("Date")}} serão incrementados em 1, e 100 serão usados para os milissegundos.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setUTCMilliseconds">Usando <code>setUTCMilliseconds()</code></h3> + +<pre class="brush: js notranslate">var theBigDay = new Date(); +theBigDay.setUTCMilliseconds(500); +</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-date.prototype.setutcmilliseconds', 'Date.prototype.setUTCMilliseconds')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.setUTCMilliseconds")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setutcminutes/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setutcminutes/index.html new file mode 100644 index 0000000000..d0dd60beda --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/setutcminutes/index.html @@ -0,0 +1,80 @@ +--- +title: Date.prototype.setUTCMinutes() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>setUTCMinutes()</code></strong> atribui os minutos para uma data específica de acordo com o horário universal.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setutcminutes.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setUTCMinutes(<var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>minutesValue</code></dt> + <dd>Um inteiro entre 0 e 59, representando os minutos.</dd> + <dt><code>secondsValue</code></dt> + <dd>Opcional. Um inteiro entre 0 e 59, reprensentando os segundos. Se vocẽ especificar o parâmetro <code>secondsValue</code>, você também deve especificar <code>minutesValue</code>.</dd> + <dt><code>msValue</code></dt> + <dd>Opcional. Um número entre 0 e 999, representando os milissegundos. Se você especificar o parâmetro <code>msValue</code>, você também deve especificar <code>minutesValue</code> e <code>secondsValue</code>.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se vocẽ não especificar os parâmetros <code>secondsValue</code> e <code>msValue</code>, os valores retornados dos métodos {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}} e {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}} são utilizados.</p> + +<p>Se o parâmetro que você especificou estiver fora do alcance esperado, <code>setUTCMinutes()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usar 100 para <code>secondsValue</code>, os minutos serão incrementados em 1 (<code>minutesValue + 1</code>), e 40 será usado para os segundos.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setUTCMinutes">Usando <code>setUTCMinutes()</code></h3> + +<pre class="brush: js notranslate">var theBigDay = new Date(); +theBigDay.setUTCMinutes(43); +</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-date.prototype.setutcminutes', 'Date.prototype.setUTCMinutes')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.setUTCMinutes")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setMinutes()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setutcmonth/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setutcmonth/index.html new file mode 100644 index 0000000000..3dd9758665 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/setutcmonth/index.html @@ -0,0 +1,78 @@ +--- +title: Date.prototype.setUTCMonth() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>setUTCMonth()</code></strong> atribui o mês para a data especificada de acordo com o horário universal.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setutcmonth.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setUTCMonth(<var>monthValue</var>[, <var>dayValue</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>monthValue</code></dt> + <dd>Um inteiro entre 0 e 11, representando os meses de Janeiro até Dezembro.</dd> + <dt><code>dayValue</code></dt> + <dd>Opcional. Um inteiro de 1 a 31, representando o dia do mês.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se você não especificar o parâmetro <code>dayValue</code>, o valor returnado do método {{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}} é utilizado.</p> + +<p>Se um parâmetro que você especificou está fora do alcance especificado, <code>setUTCMonth()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usar 15 para <code>monthValue</code>, o ano irá incrementar em 1, e 3 será usado para o mês.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setUTCMonth">Usando <code>setUTCMonth()</code></h3> + +<pre class="brush: js notranslate">var theBigDay = new Date(); +theBigDay.setUTCMonth(11); +</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-date.prototype.setutcmonth', 'Date.prototype.setUTCMonth')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.setUTCMonth")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li> + <li>{{jsxref("Date.prototype.setMonth()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setutcseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setutcseconds/index.html new file mode 100644 index 0000000000..2876f9a69b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/setutcseconds/index.html @@ -0,0 +1,78 @@ +--- +title: Date.prototype.setUTCSeconds() +slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>setUTCSeconds()</code></strong> atribui os segundos para a data especificada de acordo com o horário universal.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-setutcseconds.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setUTCSeconds(<var>secondsValue</var>[, <var>msValue</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>secondsValue</code></dt> + <dd>Um inteiro entre 0 e 59, representando os segundos.</dd> + <dt><code>msValue</code></dt> + <dd>Opcional. Um número entre 0 e 999, representando os milissegundos.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se você não especifica o parâmetro <code>msValue</code>, o valor retornado pelo método {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}} é utilizado.</p> + +<p>Se o parâmetro que você especificou está fora do alcance esperado, <code>setUTCSeconds()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usar 100 para <code>secondsValue</code>, os minutos guardados no objeto {{jsxref("Date")}} irá ser incrementado em 1, e 40 será usado para os segundos.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setUTCSeconds">Usando <code>setUTCSeconds()</code></h3> + +<pre class="brush: js notranslate">var theBigDay = new Date(); +theBigDay.setUTCSeconds(20); +</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-date.prototype.setutcseconds', 'Date.prototype.setUTCSeconds')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.setUTCSeconds")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setSeconds()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setyear/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setyear/index.html new file mode 100644 index 0000000000..afd2bfa615 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/setyear/index.html @@ -0,0 +1,79 @@ +--- +title: Date.prototype.setYear() +slug: Web/JavaScript/Reference/Global_Objects/Date/setYear +tags: + - Date + - Deprecated + - Depreciado + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setYear +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <strong><code>setYear()</code></strong> atribui o ano para a data especificada de acordo com o horário local. Devido <code>setYear()</code> não colocar o anos cheios ("problema do ano 2000"), ele não é mais utilizado e foi substituído pelo método {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}}.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setYear(<var>yearValue</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>yearValue</code></dt> + <dd>Um inteiro.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se <code>yearValue</code> é um número entre 0 e 99 (inclusivo), então o ano para <code>dateObj</code> é atribuido para <code>1900 + yearValue</code>. Caso contrário, o ano para <code>dateObj</code> é atribuido para <code>yearValue</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_setYear">Usando <code>setYear()</code></h3> + +<p>As duas primeiras linhas atribuem o ano para 1996. O terceiro atribui o ano para 2000.</p> + +<pre class="brush: js notranslate">var theBigDay = new Date(); + +theBigDay.setYear(96); +theBigDay.setYear(1996); +theBigDay.setYear(2000); +</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-date.prototype.setyear', 'Date.prototype.setYear')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.setYear")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/todatestring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/todatestring/index.html new file mode 100644 index 0000000000..ac4e3cbc11 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/todatestring/index.html @@ -0,0 +1,127 @@ +--- +title: Date.prototype.toDateString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toDateString +tags: + - Date + - JavaScript + - Prototipo + - Prototype + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toDateString +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toDateString()</code></strong> retorna a porção da data de um objeto {{jsxref("Date")}} em um formato legível para humanos em inglês dos Estados Unidos.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>objetoDate</var>.toDateString()</code></pre> + +<h2 id="Descrição">Descrição</h2> + +<p>Exemplares de {{jsxref("Date")}} referem-se a um ponto específico no tempo. Chamar {{jsxref("Date.prototype.toString()", "toString()")}} retorna a data num formato legível para humanos em inglês dos Estados Unidos. No <a href="/en-US/docs/SpiderMonkey">SpiderMonkey</a>, isso consiste na porção da data (dia, mês e ano) seguida pela porção da hora (horas, minutos, segundos e fuso horário). Ás vezes, deseja-se obter uma string apenas da porção da data; Isso pode ser conseguido com o método <code>toDateString()</code>.</p> + +<p><code>O método toDateString()</code> é especialmente útil porque motores que implementam o padrão <a href="/en-US/docs/ECMAScript">ECMA-262</a> podem divergir na string retornada pelo {{jsxref("Date.prototype.toString()", "toString()")}} de objetos {{jsxref("Date")}} , pois o formato é dependente da implentação e abordagens simples que repartem a string podem não produzir resultados consistentes nos vários motores.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Um_uso_básico_de_toDateString()">Um uso básico de <code>toDateString()</code></h3> + +<pre class="brush: js">var d = new Date(1993, 6, 28, 14, 39, 7); + +console.log(d.toString()); // exibe Wed Jul 28 1993 14:39:07 GMT-0600 (PDT) no log +console.log(d.toDateString()); // exibe Wed Jul 28 1993 no log +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.3', 'Date.prototype.toDateString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.todatestring', 'Date.prototype.toDateString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.todatestring', 'Date.prototype.toDateString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre 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>{{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>Funcionalidade</th> + <th>Android</th> + <th>Chrome para Android</th> + <th>Firefox Móvel (Gecko)</th> + <th>IE Móvel</th> + <th>Opera Móvel</th> + <th>Safari Móvel</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> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/togmtstring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/togmtstring/index.html new file mode 100644 index 0000000000..1df4801950 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/togmtstring/index.html @@ -0,0 +1,70 @@ +--- +title: Date.prototype.toGMTString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toGMTString +tags: + - Date + - Deprecated + - Depreciado + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toGMTString +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <strong><code>toGMTString()</code></strong> converte a data para uma cadeia de caracteres (<em>string)</em>, usando as convenções de Internet para o Horário de Greenwich (GMT). O formato exato do valor retornado por <code>toGMTString()</code> varia de acordo com plataforma e navegador, em geral ele deve representar uma <em>string</em> legível para um ser humano.</p> + +<div class="note"> +<p><strong>Nota:</strong> <code>toGMTString()</code> está depreciado e não deve ser mais usado. Ele se mantém implementado somente para retrocompatibilidade; por favor use {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}}.</p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.toGMTString()</code></pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Uma <em>string</em> representando a data seguindo a convenção de Internet para o Horário de Greenwich (GMT).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Simple_example">Simple example</h3> + +<p>Neste exemplo, o método <code>toGMTString()</code> converte a data para GMT (UTC) usando o deslocamento de fuso horário do sistema operacional e retorna uma <em>string </em>que é similar a seguinta forma. O formato exato depende da plataforma.</p> + +<pre class="brush: js notranslate">var today = new Date(); +var str = today.toGMTString(); // depreciado! use toUTCString() + +console.log(str); // Mon, 18 Dec 1995 17:28:35 GMT +</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-date.prototype.togmtstring', 'Date.prototype.toGMTString')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.toGMTString")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toUTCString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/toisostring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/toisostring/index.html new file mode 100644 index 0000000000..14fb14cfc1 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/toisostring/index.html @@ -0,0 +1,97 @@ +--- +title: Date.prototype.toISOString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toISOString +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toISOString +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toISOString()</code></strong> retorna uma cadeia de caracteres (<em>string</em>) simplificada no formato ISO extendido (<a href="http://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a>), que é sempre 24 ou 27 caracteres de tamanho (<code><var>YYYY</var>-<var>MM</var>-<var>DD</var>T<var>HH</var>:<var>mm</var>:<var>ss.sss</var>Z</code> ou <code><var>±</var><var>YYYYYY</var>-<var>MM</var>-<var>DD</var>T<var>HH</var>:<var>mm</var>:<var>ss.sss</var>Z</code>, respectivamente). O fuso horário é sempre o deslocamente zero UTC, como denotado pelo sufixo "<code>Z</code>".</p> + +<div>{{EmbedInteractiveExample("pages/js/date-toisostring.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.toISOString()</code></pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Uma <em>string</em> representando a data no formato <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a> de acordo com o horário universal.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Este método foi padronizado na quinta edição da ECMA-262. Motores que não foram atualizados para suportar este método podem funcionar com uma gambiarra na ausência deste método da seguinte forma:</p> + +<pre class="brush: js notranslate">if (!Date.prototype.toISOString) { + (function() { + + function pad(number) { + if (number < 10) { + return '0' + number; + } + return number; + } + + Date.prototype.toISOString = function() { + return this.getUTCFullYear() + + '-' + pad(this.getUTCMonth() + 1) + + '-' + pad(this.getUTCDate()) + + 'T' + pad(this.getUTCHours()) + + ':' + pad(this.getUTCMinutes()) + + ':' + pad(this.getUTCSeconds()) + + '.' + (this.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + + 'Z'; + }; + + })(); +} +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toISOString">Usando <code>toISOString()</code></h3> + +<pre class="brush: js notranslate">let today = new Date('05 October 2011 14:48 UTC') + +console.log(today.toISOString()) // Returna 2011-10-05T14:48:00.000Z +</pre> + +<p>O exemplo acima usa uma conversão de uma <em>string</em> não-padrão que pode não ser convertida corretamente em navegadores que não sejam da Mozilla..</p> + +<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-date.prototype.toisostring', 'Date.prototype.toISOString')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.toISOString")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toUTCString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/tojson/index.html b/files/pt-br/web/javascript/reference/global_objects/date/tojson/index.html new file mode 100644 index 0000000000..d35a98c99a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/tojson/index.html @@ -0,0 +1,75 @@ +--- +title: Date.prototype.toJSON() +slug: Web/JavaScript/Reference/Global_Objects/Date/toJSON +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toJSON +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toJSON()</code></strong> retorna uma representação representation do objeto {{jsxref("Date")}} como string.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-tojson.html")}}</div> + +<p class="hidden">O código fonte para este exemplo interativo está armazenado em um repositório no GitHub. Caso queira contribuir com os exemplos interativos do projeto, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie-nos um pull request.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toJSON()</code></pre> + +<h3 id="Retorno">Retorno</h3> + +<p>Uma representação da data como string.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Instâncias de {{jsxref("Date")}} referem-se a um específico ponto no tempo. Invocar <code>toJSON()</code> retorna uma string (usando {{jsxref("Date.prototype.toISOString()", "toISOString()")}}) representando o valor do objeto {{jsxref("Date")}}. Por padrão este método é destinado a serializar objetos {{jsxref("Date")}} em serializações {{Glossary("JSON")}}.</p> + +<h2 id="Examplos">Examplos</h2> + +<h3 id="Usando_toJSON()">Usando <code>toJSON()</code></h3> + +<pre class="brush:js">var jsonDate = (new Date()).toJSON(); +var backToDate = new Date(jsonDate); + +console.log(jsonDate); //2015-10-26T07:46:36.611Z +</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.9.5.44', 'Date.prototype.toJSON')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_navagadores">Compatibilidade com navagadores</h2> + +<p class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Caso queira contribuir com dados confira <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um pull request.</p> + +<p>{{Compat("javascript.builtins.Date.toJSON")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toUTCString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/tolocaledatestring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/tolocaledatestring/index.html new file mode 100644 index 0000000000..410807cb37 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/tolocaledatestring/index.html @@ -0,0 +1,239 @@ +--- +title: Date.prototype.toLocaleDateString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toLocaleDateString()</code></strong> retorna uma string com a representação de parte da data baseando-se no idioma. Os novos argumentos <code>locales</code> e <code>options</code> deixam as aplicações especificarem o idioma cujas convenções de formatação devem ser usadas e permitem customizar o comportamento da função. Em implementações antigas, nas quais ignoram os argumentos <code>locales</code> e <code>options</code>, o locale usado e a forma da string retornada são inteiramente dependente da implementação nativa.</p> + +<h2 id="Sintáxe">Sintáxe</h2> + +<pre class="syntaxbox"><var>dateObj</var>.toLocaleDateString([<var>locales</var> [, <var>options</var>]])</pre> + +<h3 id="Parametros">Parametros</h3> + +<p>Verifique a seção {{anch("Compatibilidade entre navegadores")}} para ver quais navegadores dão suporte aos argumentos <code>locales</code> e <code>options</code>, e o <a href="#Example:_Checking_for_support_for_locales_and_options_arguments">Example: Verificação para suporte dos argumentos<code> locales</code> e <code>options</code></a> para detectar a funcionalidade.</p> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div> + +<div>O valor padrão para cada propriedade do componente date-time é {{jsxref("undefined")}}, mas se as propriedades <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code> são todas {{jsxref("undefined")}}, então <code>year</code>, <code>month </code>and <code>day </code>são assumidos como "<code>numeric</code>".</div> + +<h3 id="sect1"></h3> + +<h3 id="Return_value">Return value</h3> + +<p>Uma representação em string de parte da data dada a instância {{jsxref("Global_Objects/Date", "Date")}} de acordo com as convenções específicas do idioma. </p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toLocaleDateString">Usando <code>toLocaleDateString()</code></h3> + +<p>Em uso básico sem especificação de locale, uma string formatada no padrão do locale e com as opções padrões é retornada.</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0)); + +// toLocaleDateString() sem argumentos depende da implementação, +// o locale padrão, e o time zone padrão +console.log(date.toLocaleDateString()); +// → "12/11/2012" se rondando em locale en-US com time zone de America/Los_Angeles +</pre> + +<h3 id="Checagem_para_o_suporte_dos_argumentos_locales_e_options">Checagem para o suporte dos argumentos <code>locales</code> e <code>options</code></h3> + +<p>Os argumentos <code>locales</code> e <code>options</code> não são suportados em todos os browser ainda. Para verificar se uma uma implementação já suporta eles, você pode usar o requisito de que tags de idioma ilegal são rejeitadas com uma exceção {{jsxref("RangeError")}}:</p> + +<pre class="brush: js">function toLocaleDateStringSupportsLocales() { + try { + new Date().toLocaleDateString('i'); + } catch (e) { + return e.name === 'RangeError'; + } + return false; +} +</pre> + +<h3 id="Usando_locales">Usando <code>locales</code></h3> + +<p>Esse exemplo mostra algumas das variações em formatos de data localizados. A fim de obter oformato do idioma usado na interface de usuário da usa aplicação, certifique-se de especificar esse idioma (e possivelmente algumas outros idiomas de reserva) usando o argumento <code>locales</code>: </p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// os formatos abaixo assumem o time zone local do locale; +// America/Los_Angeles for the US + +// Inglês americano usa a ordem mês-dia-ano +console.log(date.toLocaleDateString('en-US')); +// → "12/19/2012" + +// Inglês Britânico usa a ordem dia-mês-ano +console.log(date.toLocaleDateString('en-GB')); +// → "20/12/2012" + +// Coreano usa a ordem ano-mês-dia +console.log(date.toLocaleDateString('ko-KR')); +// → "2012. 12. 20." + +// Árabe na maioria dos países de língua árabe usa dígitos árabes reais +console.log(date.toLocaleDateString('ar-EG')); +// → "<span dir="rtl">٢٠/١٢/٢٠١٢</span>" + +// para Japonês, aplicações podem querer usar o calendário japonês, +// onde 2012 foi o ano 24 da era Heisei +console.log(date.toLocaleDateString('ja-JP-u-ca-japanese')); +// → "24/12/20" + +// quando um idioma que pode não ser suportado é requerido, tal como +// Balinês, inclua um idioma de reserva, nesse caso Indonésio +console.log(date.toLocaleDateString(['ban', 'id'])); +// → "20/12/2012" +</pre> + +<h3 id="Usando_options">Usando <code>options</code></h3> + +<p>O resultados gerados por <code>toLocaleDateString()</code> podem ser customizado usando o argumento <code>options</code>:</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// requer um dia da semana jutamente com uma data longa +var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' }; +console.log(date.toLocaleDateString('de-DE', options)); +// → "Donnerstag, 20. Dezember 2012" + +// uma aplicação pode querer usar UTC e fazê-lo visível +options.timeZone = 'UTC'; +options.timeZoneName = 'short'; +console.log(date.toLocaleDateString('en-US', options)); +// → "Thursday, December 20, 2012, GMT" +</pre> + +<h2 id="Performance">Performance</h2> + +<p>Ao formatar um grande número de datas, é melhor criar um objeto {{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}} e usar a função fornecido porsua propriedade {{jsxref("DateTimeFormat.prototype.format", "format")}}.</p> + +<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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial. Implementada no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', 'sec-15.9.5.6', 'Date.prototype.toLocaleDateString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.tolocaledatestring', 'Date.prototype.toLocaleDateString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.tolocaledatestring', 'Date.prototype.toLocaleDateString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES Int 1.0', '#sec-13.3.2', 'Date.prototype.toLocaleDateString')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Define os argumentos <code>locales</code> e <code>options</code>.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-13.3.2', 'Date.prototype.toLocaleDateString')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleDateString', 'Date.prototype.toLocaleDateString')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_o_navegador">Compatibilidade com o navegador</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> + <tr> + <td><code>locales</code> and <code>options</code> arguments</td> + <td>{{CompatChrome("24")}} [1]</td> + <td>{{CompatGeckoDesktop("29")}}</td> + <td>{{CompatIE("11")}}</td> + <td>{{CompatOpera("15")}}</td> + <td>{{CompatSafari("10")}}</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> + <tr> + <td><code>locales</code> and <code>options</code> arguments</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("26")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari("10")}}</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] Chrome 24 also added support for passing timeZones other than UTC.</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/tolocalestring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/tolocalestring/index.html new file mode 100644 index 0000000000..06d9b1f30c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/tolocalestring/index.html @@ -0,0 +1,202 @@ +--- +title: Date.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString +tags: + - Internacionalização + - JavaScript + - Prototype + - Referencia + - data + - i18n + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toLocaleString()</code></strong> retorna uma <em>string</em><strong> </strong>com uma representação sensível ao idioma da data presente na mesma. Os novos argumentos <code>locales</code> e <code>options</code> permitem que as aplicações especifiquem o idioma cujas convenções de formatação devem ser utilizadas e personalizar o comportamento do método. Em implementações antigas, que ignoram os argumentos <code>locales</code> and <code>options</code>, o local utilizado e o formato da <em>string</em> retornada são completamente dependentes da implementação.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-tolocalestring.html")}}</div> + +<p class="hidden">O código-fonte deste exemplo interativo está armazenado em um repositório do GitHub. Se você quiser contribuir com o projeto de exemplos interativos, por favor clone o repositório <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie-nos <em>pull requests</em>.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>dateObj</var>.toLocaleString([<var>locales</var>[, <var>options</var>]])</pre> + +<h3 id="Parameters">Parameters</h3> + +<p>Check the <a href="#Browser_Compatibility">Browser compatibility</a> section to see which browsers support the <code>locales</code> and <code>options</code> arguments, and the <a href="#Example:_Checking_for_support_for_locales_and_options_arguments">Example: Checking for support for <code>locales</code> and <code>options</code> arguments</a> for feature detection.</p> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div> + +<p>The default value for each date-time component property is {{jsxref("undefined")}}, but if the <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code>, <code>second</code> properties are all {{jsxref("undefined")}}, then <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code>, and <code>second</code> are assumed to be <code>"numeric"</code>.</p> + +<h3 id="Return_value">Return value</h3> + +<p>A string representing the given date according to language-specific conventions.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_toLocaleString()">Using <code>toLocaleString()</code></h3> + +<p>In basic use without specifying a locale, a formatted string in the default locale and with default options is returned.</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0)); + +// toLocaleString() without arguments depends on the implementation, +// the default locale, and the default time zone +console.log(date.toLocaleString()); +// → "12/11/2012, 7:00:00 PM" if run in en-US locale with time zone America/Los_Angeles +</pre> + +<h3 id="Checking_for_support_for_locales_and_options_arguments">Checking for support for <code>locales</code> and <code>options</code> arguments</h3> + +<p>The <code>locales</code> and <code>options</code> arguments are not supported in all browsers yet. To check whether an implementation supports them already, you can use the requirement that illegal language tags are rejected with a {{jsxref("RangeError")}} exception:</p> + +<pre class="brush: js">function toLocaleStringSupportsLocales() { + try { + new Date().toLocaleString('i'); + } catch (e) { + return e instanceof RangeError; + } + return false; +} +</pre> + +<h3 id="Using_locales">Using <code>locales</code></h3> + +<p>This example shows some of the variations in localized date and time formats. In order to get the format of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the <code>locales</code> argument:</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// formats below assume the local time zone of the locale; +// America/Los_Angeles for the US + +// US English uses month-day-year order and 12-hour time with AM/PM +console.log(date.toLocaleString('en-US')); +// → "12/19/2012, 7:00:00 PM" + +// British English uses day-month-year order and 24-hour time without AM/PM +console.log(date.toLocaleString('en-GB')); +// → "20/12/2012 03:00:00" + +// Korean uses year-month-day order and 12-hour time with AM/PM +console.log(date.toLocaleString('ko-KR')); +// → "2012. 12. 20. 오후 12:00:00" + +// Arabic in most Arabic speaking countries uses real Arabic digits +console.log(date.toLocaleString('ar-EG')); +// → "<span dir="rtl">٢٠/١٢/٢٠١٢ ٥:٠٠:٠٠ ص</span>" + +// for Japanese, applications may want to use the Japanese calendar, +// where 2012 was the year 24 of the Heisei era +console.log(date.toLocaleString('ja-JP-u-ca-japanese')); +// → "24/12/20 12:00:00" + +// when requesting a language that may not be supported, such as +// Balinese, include a fallback language, in this case Indonesian +console.log(date.toLocaleString(['ban', 'id'])); +// → "20/12/2012 11.00.00" +</pre> + +<h3 id="Using_options">Using <code>options</code></h3> + +<p>The results provided by <code>toLocaleString()</code> can be customized using the <code>options</code> argument:</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// request a weekday along with a long date +var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' }; +console.log(date.toLocaleString('de-DE', options)); +// → "Donnerstag, 20. Dezember 2012" + +// an application may want to use UTC and make that visible +options.timeZone = 'UTC'; +options.timeZoneName = 'short'; +console.log(date.toLocaleString('en-US', options)); +// → "Thursday, December 20, 2012, GMT" + +// sometimes even the US needs 24-hour time +console.log(date.toLocaleString('en-US', { hour12: false })); +// → "12/19/2012, 19:00:00" +</pre> + +<h3 id="Avoid_comparing_formatted_date_values_to_static_values">Avoid comparing formatted date values to static values</h3> + +<p>Most of the time, the formatting returned by <code>toLocaleString()</code> is consistent. However, this might change in the future and isn't guaranteed for all languages — output variations are by design and allowed by the specification. Most notably, the IE and Edge browsers insert bidirectional control characters around dates, so the output text will flow properly when concatenated with other text.</p> + +<p>For this reason you cannot expect to be able to compare the results of <code>toLocaleString()</code> to a static value:</p> + +<pre class="brush: js; example-bad">"1.1.2019, 01:00:00" === new Date("2019-01-01T00:00:00.000000Z").toLocaleString(); +// true in Firefox and others +// false in IE and Edge</pre> + +<div class="blockIndicator note"> +<p><strong>Note</strong>: See also this <a href="https://stackoverflow.com/questions/25574963/ies-tolocalestring-has-strange-characters-in-results">StackOverflow thread</a> for more details and examples.</p> +</div> + +<h2 id="Performance">Performance</h2> + +<p>When formatting large numbers of dates, it is better to create an {{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}} object and use the function provided by its {{jsxref("DateTimeFormat.prototype.format", "format")}} property.</p> + +<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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.5', 'Date.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES Int 1.0', '#sec-13.3.1', 'Date.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Defines <code>locales</code> and <code>options</code> arguments.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-13.3.1', 'Date.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleString', 'Date.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.toLocaleString")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/tolocaletimestring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/tolocaletimestring/index.html new file mode 100644 index 0000000000..9b149abb00 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/tolocaletimestring/index.html @@ -0,0 +1,180 @@ +--- +title: Date.prototype.toLocaleTimeString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString +tags: + - Internacionalização + - Prototype + - data + - data formatada + - fuso horário + - metodo + - time zone +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString +--- +<div>{{JSRef}}</div> + +<div>O método <strong><code>toLocaleTimeString()</code></strong> retorna uma string com uma representação sensível ao idioma de uma porção de tempo desta data. Os novos argumentos <code>locales</code> e <code>options</code> possibilitam aplicações especificarem que formato de linguagem deve ser usado, podendo customizar o comportamento da função. Em implementações antigas, que ignoram os argumentos <code>locales</code> e <code>options</code>, o local utilizado e o formato retornado da string são implementações completamente dependentes.</div> + +<div> </div> + +<div>{{EmbedInteractiveExample("pages/js/date-tolocaletimestring.html")}}</div> + +<p class="hidden">A fonte deste exemplo interativo é armazenado em um repositório do GitHub. Se você deseja contribuir em exemplos interativos, 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>dateObj</var>.toLocaleTimeString([<var>locales</var>[, <var>options</var>]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<p>Confira a seção <a href="#Browser_Compatibility">Browser compatibility</a> para ver o suporte em browsers dos argumentos <code>locales</code> e <code>options</code>, e <a href="#Checking_for_support_for_locales_and_options_arguments">Checking for support for <code>locales</code> and <code>options</code> arguments</a> para ver suas features.</p> + +<div>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div> + +<p>O valor default para cada propriedade do componente date-time é {{jsxref("undefined")}}, mas se as propriedades <code>hour</code>, <code>minute</code>, <code>second</code> são todas {{jsxref("undefined")}}, então <code>hour</code>, <code>minute</code>, e <code>second</code> espera-se que seja <code>"numeric"</code>.</p> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string representando uma porção de tempo de uma instância {{jsxref("Global_Objects/Date", "Date")}}, fornecida de acordo com as convenções específicas do idioma.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toLocaleTimeString()">Usando <code>toLocaleTimeString()</code></h3> + +<p>Em um uso simples, sem especificar uma localidade, é retornado uma string formatada de uma localidade default e com opções default.</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0)); + +// toLocaleTimeString() sem argumentos, depende da implementação, +// da localidade padrão, e do fuso horário padrão +console.log(date.toLocaleTimeString()); +// → "7:00:00 PM" se rodar em en-US com o fuso horário de America/Los_Angeles +</pre> + +<h3 id="Verificando_o_suporte_para_os_argumentos_locales_e_options">Verificando o suporte para os argumentos <code>locales</code> e <code>options</code></h3> + +<p>Os argumentos <code>locales</code> e <code>options</code> não são suportados em todos os browsers ainda. Para conferir se uma implementação já os suporta, você pode usar a exigência que tags ilegais de liguagem são rejeitadas com uma exceção {{jsxref("RangeError")}}:</p> + +<pre class="brush: js">function toLocaleTimeStringSupportsLocales() { + try { + new Date().toLocaleTimeString('i'); + } catch (e) { + return e.name === 'RangeError'; + } + return false; +} +</pre> + +<h3 id="Usando_locales">Usando <code>locales</code></h3> + +<p>Este exemplo mostra algumas das variações em um formato de tempo localizado. Para obter o formato do idioma usado na interface do usuário da sua aplicação, tenha certeza de especificar esse idioma (e possivelmente alguns idiomas de retorno) usando o argumento <code>locales</code>:</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// Os formatos abaixo assumem o fuso horário local da região; +// America/Los_Angeles for the US + +// US English usa o formato 12 horas com AM/PM +console.log(date.toLocaleTimeString('en-US')); +// → "7:00:00 PM" + +// British English usa o formato 24 horas sem AM/PM +console.log(date.toLocaleTimeString('en-GB')); +// → "03:00:00" + +// Korean usa o formato 12 horas com AM/PM +console.log(date.toLocaleTimeString('ko-KR')); +// → "오후 12:00:00" + +// Arabic na maiorias dos países que falam árabe usa-se os dígitos arábicos reais +console.log(date.toLocaleTimeString('ar-EG')); +// → "<span dir="rtl">٧:٠٠:٠٠ م</span>" + +// quando solicitar um idioma que talvez não seja suportado, como o +// Balinese, inclua um idioma de fallback, nesse caso Indonesian +console.log(date.toLocaleTimeString(['ban', 'id'])); +// → "11.00.00" +</pre> + +<h3 id="Usando_options">Usando <code>options</code></h3> + +<p>Os resultados fornecidos por <code>toLocaleTimeString()</code> podem ser customizados usando o argumento <code>options</code>:</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// uma aplicação pode querer usar UTC e tornar isso visível +var options = { timeZone: 'UTC', timeZoneName: 'short' }; +console.log(date.toLocaleTimeString('en-US', options)); +// → "3:00:00 AM GMT" + +// ás vezes, até em US precise usar o formato 24 horas +console.log(date.toLocaleTimeString('en-US', { hour12: false })); +// → "19:00:00" +</pre> + +<h2 id="Performance">Performance</h2> + +<p>Quando se formata um grande número de datas, é aconselhável criar um objeto {{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}} e usar a função fornecida pela propriedade dele: {{jsxref("DateTimeFormat.prototype.format", "format")}}.</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial, Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.7', 'Date.prototype.toLocaleTimeString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleTimeString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleTimeString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 1.0', '#sec-13.3.3', 'Date.prototype.toLocaleTimeString')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Define os argumentos <code>locales</code> e <code>options</code>.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-13.3.3', 'Date.prototype.toLocaleTimeString')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleTimeString', 'Date.prototype.toLocaleTimeString')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_em_Browsers">Compatibilidade em Browsers</h2> + +<p class="hidden">A tabela de compatibilidade nessa página é gerada por dados estruturados. Se você deseja contribuir com esses dados, por favor confira <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</p> + +<p>{{Compat("javascript.builtins.Date.toLocaleTimeString")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/date/tosource/index.html new file mode 100644 index 0000000000..62c829b7ec --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/tosource/index.html @@ -0,0 +1,53 @@ +--- +title: Date.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Date/toSource +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/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"><var>dateObj</var>.toSource() +Date.toSource()</pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Uma <em>string </em>representando o código fonte do objeto {{jsxref("Global_Objects/Date", "Date")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Função_nativa">Função nativa</h3> + +<p>Para o objeto {{jsxref("Date")}} embutido, <code>toSource()</code> returna a seguinte <em>string</em> indicando que o código fonte não está disponível:</p> + +<pre class="brush: js notranslate">function Date() { + [native code] +} +</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> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.toSource")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/tostring/index.html new file mode 100644 index 0000000000..f06c2ab6ca --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/tostring/index.html @@ -0,0 +1,114 @@ +--- +title: Date.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toString +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toString +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toString()</code></strong> retorna uma cadeia de caracteres (<em>string</em>) representando o objeto {{jsxref("Date")}} especificado.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-tostring.html","shorter")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>dateObj</var>.toString()</pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Uma <em>string</em> representando a data.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Instâncias de {{jsxref("Date")}} herdam o método <code>toString()</code> de {{jsxref("Date.prototype")}}, não {{jsxref("Object.prototype")}}. <code>Date.prototype.toString()</code> returna uma <em>string</em> com a representação de Date no formato especificado na ECMA-262 que pode ser resumida como:</p> + +<ul> + <li>Dia da semana: 3 letras do nome do dia da semana em Inglês, e.g. "Sat"</li> + <li>espaço</li> + <li>Nome do mês: 3 letras do nome do mês em Inglês, e.g. "Sep"</li> + <li>espaço</li> + <li>Dia: Dia do mês em 2 dígitos, e.g. "01"</li> + <li>espaço</li> + <li>Ano: Ano no formato de 4 dígitos, e.g. "2018"</li> + <li>espaço</li> + <li>Hora: Hora do dia em 2 dígitos, e.g. "14"</li> + <li><span><span>dois-pontos</span></span></li> + <li>Minuto: Minutos da hora em 2 dígitos, e.g. "53"</li> + <li><span><span>dois-pontos</span></span></li> + <li>Segundos: Segundos do minuto em 2 dígitos, e.g. "26"</li> + <li>espaço</li> + <li>A <em>string</em> "GMT"</li> + <li>Sinal do deslocamento do fuso horário, pode ser: + <ul> + <li>"+" para deslocamentos positivos (0 ou maior)</li> + <li>"-" para deslocamentos negativos (menores que 0)</li> + </ul> + </li> + <li>Dois dígitos da hora do deslocamento, e.g. "14"</li> + <li>Dois dígitos dos minutos do deslocamento, e.g. "00"</li> + <li>Opcionalmente, um nome de fuso horário consistindo de: + <ul> + <li>espaço</li> + <li>parênteses esquerdo, i.e. "("</li> + <li>Uma representação de <em>string</em> dependente da implementação do fuso horário, que pode ser uma abreviação ou o nome completo (não há um padrão para nomes ou abreviação de fusos horários), e.g. "Line Islands Time" ou "LINT"</li> + <li>parênteses direito, i.e. ")"</li> + </ul> + </li> +</ul> + +<p>E.g. "Sat Sep 01 2018 14:53:26 GMT+1400 (LINT)"</p> + +<p>Até o ECMAScript 2018 (edição 9), o formato da <em>string</em> retornada pelo <code>Date.prototype.toString</code> era dependente da implementação. Portanto, não se deve confiar que ela está no formato especificado.</p> + +<p>O método <code>toString()</code> é automaticamente chamado quando a data deve ser representada como texto, e.g. <code>console.log(new Date())</code>, ou quando a data é utilizada em uma concatenação de <em>string</em>, como <code>var today = 'Today is ' + new Date()</code>.</p> + +<p><code>toString()</code> é um método genérico, ele não requer que seu <code>this</code> seja uma instância de {{jsxref("Date")}}. Entretanto, ele deve ter uma propriedade interna <code>[[TimeValue]]</code> que não pode ser construída usando JavaScript nativo, então ela é efetivamente limitada a ser usada com instâncias {{jsxref("Date")}}. Se chamado em uma instância que não seja Date, um {{jsxref("TypeError")}} é jogado.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toString">Usando <code>toString()</code></h3> + +<p>O exemplo asseguir atribui o valor de <code>toString()</code> de um objeto {{jsxref("Date")}} para <code>myVar</code>:</p> + +<pre class="brush: js notranslate">var x = new Date(); +var myVar = x.toString(); // atribui uma string em myVar no mesmo formato que este: + // Mon Sep 08 1998 14:36:22 GMT-0700 (PDT) +</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-date.prototype.tostring', 'Date.prototype.toString')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.toString")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> + <li>{{jsxref("Date.prototype.toDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/totimestring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/totimestring/index.html new file mode 100644 index 0000000000..852bf9ec95 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/totimestring/index.html @@ -0,0 +1,72 @@ +--- +title: Date.prototype.toTimeString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toTimeString +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toTimeString +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toTimeString()</code></strong> retorna uma porção de tempo de um objeto {{jsxref("Date")}} de forma legível para um ser humano em Inglês Americano.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-totimestring.html","shorter")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.toTimeString()</code></pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Uma <em>string</em> representando a porção de tempo da data de forma legível para um ser humano em Inglês Americano.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Instâncias de {{jsxref("Date")}} referem-se a um ponto específico no tempo. Chamando {{jsxref("Date.prototype.toString()", "toString()")}} irá retornar uma data formatada de forma legível para um ser humano em Inglês Americano. No <a href="/en-US/docs/SpiderMonkey">SpiderMonkey</a>, isso consiste na porção da data (dia, mês e ano) seguido pela porção de tempo (horas, minutos, segundos e fuso horário). Algumas vezes é desejável obter a <em>string</em> da porção do tempo; tal coisa pode ser atingida utilizando o método <code>toTimeString()</code>.</p> + +<p>O <code>toTimeString()</code> método é especialmente útil por que motores parecidos que implementam a <a href="/en-US/docs/ECMAScript">ECMA-262</a> podem ter <em>string</em><em>s </em>diferentes obtidas de {{jsxref("Date.prototype.toString()", "toString()")}} para objetos {{jsxref("Date")}}, como o formato é dependente de implementação; abordagens de corte simples de <em>string</em><em>s </em>pode não produzir resultados consistentes entre múltiplos motores.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Uso_básico_de_toTimeString">Uso básico de <code>toTimeString()</code></h3> + +<pre class="brush: js notranslate">var d = new Date(1993, 6, 28, 14, 39, 7); + +console.log(d.toString()); // Wed Jul 28 1993 14:39:07 GMT-0600 (PDT) +console.log(d.toTimeString()); // 14:39:07 GMT-0600 (PDT) +</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-date.prototype.totimestring', 'Date.prototype.toTimeString')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.toTimeString")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toDateString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/toutcstring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/toutcstring/index.html new file mode 100644 index 0000000000..470841dc1a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/toutcstring/index.html @@ -0,0 +1,113 @@ +--- +title: Date.prototype.toUTCString() +slug: Web/JavaScript/Reference/Global_Objects/Date/toUTCString +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toUTCString +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toUTCString()</code></strong> converte uma data para uma cadeia de caracteres (<em>string</em>), usando o fuso horário UTC.</p> + +<p>Baseado na <a href="https://tools.ietf.org/html/rfc7231#section-7.1.1.1">RFC7231</a> e modificado de acordo com a <a href="https://www.ecma-international.org/ecma-262/10.0/index.html#sec-date.prototype.toutcstring">ECMA-262 toUTCString</a>, ele pode ter valores negativos na <a href="https://tc39.es/ecma262/#sec-date.prototype.toutcstring">versão de 2021</a>.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-toutcstring.html","shorter")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.toUTCString()</code></pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Uma <em>string</em> representando a data usando o fuso horário UTC.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O valor retornado por <code>toUTCString()</code> é uma <em>string</em> no formato <code><var>Www</var>, <var>dd</var> <var>Mmm</var> <var>yyyy</var> <var>hh</var>:<var>mm</var>:<var>ss</var> GMT</code>, onde:</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Formato da String</th> + <th scope="col">Descrição</th> + </tr> + </thead> + <tbody> + <tr> + <td><code><var>Www</var></code></td> + <td>Dia da semana, em três letras (e.g. Sun, Mon, ...)</td> + </tr> + <tr> + <td><code><var>dd</var></code></td> + <td>Dia do mês, como dois dígitos com zero à esquerda se requisitado</td> + </tr> + <tr> + <td><code><var>Mmm</var></code></td> + <td>Mês, em três letras (e.g. Jan, Feb, ...)</td> + </tr> + <tr> + <td><code><var>yyyy</var></code></td> + <td>Ano, como 4 ou mais dígitos com zeros à esquerda se requisitado</td> + </tr> + <tr> + <td><code><var>hh</var></code></td> + <td>Hora, como dois dígitos com zero à esquerda se requisitado</td> + </tr> + <tr> + <td><code><var>mm</var></code></td> + <td>Minutos, como dois dígitos com zero à esquerda se requisitado</td> + </tr> + <tr> + <td><code><var>ss</var></code></td> + <td>Segundos, como dois dígitos com zero à esquerda se requisitado</td> + </tr> + </tbody> +</table> + +<p>Antes do ECMAScript 2018, o formato do valor de retorno variava de acordo com a plataforma. O valor de retorno mais comum era um carimbo de data formatada na RFC-1123, que é uma versão relativamente atualizada dos carimbos de data da RFC-822.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toUTCString">Usando <code>toUTCString()</code></h3> + +<pre class="brush: js notranslate">let today = new Date('Wed, 14 Jun 2017 00:00:00 PDT'); +let UTCstring = today.toUTCString(); // Wed, 14 Jun 2017 07:00:00 GMT +</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-date.prototype.toutcstring', 'Date.prototype.toUTCString')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.toUTCString")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toDateString()")}}</li> + <li>{{jsxref("Date.prototype.toISOString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/utc/index.html b/files/pt-br/web/javascript/reference/global_objects/date/utc/index.html new file mode 100644 index 0000000000..4684f83afa --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/utc/index.html @@ -0,0 +1,145 @@ +--- +title: Date.UTC() +slug: Web/JavaScript/Reference/Global_Objects/Date/UTC +tags: + - JavaScript + - UTC +translation_of: Web/JavaScript/Reference/Global_Objects/Date/UTC +--- +<p>{{JSRef}}</p> + +<p>O método <strong><code>Date.UTC()</code></strong> aceita os mesmos parâmetros que o construtor mais longo de <strong><code>Date</code></strong> e retorna o total de milisegundos desde 1º de Janeiro de 1970 às 00:00:00 (horário universal). O valor retornado por <strong><code>Date.UTC()</code></strong> pode ser usado como parâmetro para criar uma instância de {{jsxref("Date")}}.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre><code>Date.UTC(<var>ano</var>, <var>mês</var>[, <var>dia</var>[, <var>hora</var>[, <var>minuto</var>[, <var>segundo</var>[, <var>milisegundo</var>]]]]])</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>ano</code></dt> + <dd>Um valor inteiro representando o ano, após 1970.</dd> + <dt><code><var>mês</var></code></dt> + <dd>Um valor inteiro que representa o mês, começando com 0 para Janeiro até 11 para Dezembro.</dd> + <dt><code><var>dia</var></code></dt> + <dd>Opcional. Um valor inteiro entre 1 e 31 representando o dia do mês.</dd> + <dt><code><var>hora</var></code></dt> + <dd>Opcional. Um valor inteiro entre 0 e 23 representando a hora do dia.</dd> + <dt><code>minuto</code></dt> + <dd>Opcional. Um valor entre 0 e 59 representando os minutos.</dd> + <dt><code>segundo</code></dt> + <dd>Opcional. Um valor entre 0 e 59 representando os segundos.</dd> + <dt><code>milisegundo</code></dt> + <dd>Opcional. Um valor entre 0 e 999 representando os milisegundos.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p><strong><code>UTC() </code></strong>recebe argumentos de uma data separados por vírgula e retorna um número representando o total de milisegundos entre o dia 1º de Janeiro de 1970 às 00:00:00 (horário universal) e a data e hora que você especificou.</p> + +<p>Você deve especificar o ano completo para o argumento ano. Por exemplo, 1998. Se o ano fornecido for um valor entre 0 e 99 o método irá converter este valor para o século 20 (1900 + ano); Por exemplo, se você utilizar 95, então o ano 1995 será utilizado.</p> + +<p>O método <code>UTC()<strong> </strong></code>se diferencia do construtor de<font face="Consolas, Liberation Mono, Courier, monospace"> </font>{{jsxref("Date")}} de duas maneiras:</p> + +<ul> + <li><code>Date.UTC()</code> utiliza o horário universal em vez do horário local.</li> + <li><code>Date.UTC() </code>retorna um valor inteiro em vez de uma instância de {{jsxref("Date")}}.</li> +</ul> + +<p>Se você fornecer um argumento fora do intervalo esperado, o método UTC() atualiza os demais argumentos para permitir este valor. Por exemplo, se você utilizar 15 para mês, será adicionado 1 ao argumento ano (ano + 1) e será utilizado 3 para o argumento mês.</p> + +<p><code>UTC() </code>é um método estático, por conta disto você sempre irá chamar <code>Date.UTC()</code> em vez de chamar um método de um objeto {{jsxref("Date")}} que você tenha criado.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Using_Date.UTC" name="Example:_Using_Date.UTC">Utilizando <code>Date.UTC()</code></h3> + +<p>A seguinte expressão cria uma instância de {{jsxref("Date")}} utilizando UTC em vez do horário local:</p> + +<pre>var dataUniversal = new Date(Date.UTC(96, 11, 1, 0, 0, 0)); +</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ário</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.utc', 'Date.UTC')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.4.3', 'Date.UTC')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre 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>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>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Veja Também</h2> + +<ul> + <li>{{jsxref("Date.parse()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/date/valueof/index.html b/files/pt-br/web/javascript/reference/global_objects/date/valueof/index.html new file mode 100644 index 0000000000..a4e807b027 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/date/valueof/index.html @@ -0,0 +1,69 @@ +--- +title: Date.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/Date/valueOf +tags: + - Date + - JavaScript + - Method + - Prototipo + - Prototype + - Referencia + - data + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Date/valueOf +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>valueOf()</code></strong> retorna o valor primitivo do objeto {{jsxref("Date")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/date-valueof.html")}}</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>dateObj</var>.valueOf()</code></pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>valueOf()</code> retorna o valor primitivo do objeto {{jsxref("Date")}} como um tipo de dado numérico, o número de milissegundos desde a meia noite do dia 1 de Janeiro de 1970 UTC.</p> + +<p>Este método é funcionalmente equivalente ao método {{jsxref("Date.prototype.getTime()")}}.</p> + +<p>Este método é geralmente chamado internamente pelo JavaScript e não explícito em código.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_valueOf">Usando <code>valueOf()</code></h3> + +<pre class="brush: js notranslate">var x = new Date(56, 6, 17); +var myVar = x.valueOf(); // atribui -424713600000 to myVar +</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-date.prototype.valueof', 'Date.prototype.valueOf')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Date.valueOf")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> + <li>{{jsxref("Date.prototype.getTime()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/decodeuri/index.html b/files/pt-br/web/javascript/reference/global_objects/decodeuri/index.html new file mode 100644 index 0000000000..46abadbb77 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/decodeuri/index.html @@ -0,0 +1,99 @@ +--- +title: decodeURI() +slug: Web/JavaScript/Reference/Global_Objects/decodeURI +translation_of: Web/JavaScript/Reference/Global_Objects/decodeURI +--- +<div>{{jsSidebar("Objects")}}</div> + +<p><span class="seoSummary">A função <code><strong>decodeURI()</strong></code> decodifica um Uniform Resource Identifier (URI) criado anteriormente por {{jsxref("encodeURI", "encodeURI()")}} ou por uma rotina semelhante.</span></p> + +<div>{{EmbedInteractiveExample("pages/js/globalprops-decodeuri.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>decodeURI(<em>encodedURI</em>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>encodedURI</code></dt> + <dd>Um identificador de recurso uniforme codificado completo.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova string representando a versão não codificada do URI (Uniform Resource Identifier) codificado fornecido.</p> + +<h3 id="Exceções">Exceções</h3> + +<p>Lança uma exceção {{jsxref("URIError")}} ("sequência de URI malformada") quando o <code><em>encodedURI</em></code> contém sequências de caracteres inválidos.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Substitui cada sequência de escape no URI codificado pelo caractere que ele representa, mas não decodifica sequências de escape que não poderiam ter sido introduzidas por {{jsxref("encodeURI")}}. O caractere “<code>#</code>” não é decodificado a partir de sequência de escape.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Decodificando_uma_URL_Cyrillic">Decodificando uma URL Cyrillic</h3> + +<pre class="brush: js">decodeURI('https://developer.mozilla.org/ru/docs/JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B'); +// "https://developer.mozilla.org/ru/docs/JavaScript_шеллы" +</pre> + +<h3 id="Captura_de_erros">Captura de erros</h3> + +<pre>try { + var a = decodeURI('%E0%A4%A'); +} catch(e) { + console.error(e); +} + +// URIError: sequência de URI malformada</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.3.1', 'decodeURI')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-decodeuri-encodeduri', 'decodeURI')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-decodeuri-encodeduri', 'decodeURI')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2> + + + +<p>{{Compat("javascript.builtins.decodeURI")}}</p> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li> + <li>{{jsxref("encodeURI", "encodeURI()")}}</li> + <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/decodeuricomponent/index.html b/files/pt-br/web/javascript/reference/global_objects/decodeuricomponent/index.html new file mode 100644 index 0000000000..71f6fcb6eb --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/decodeuricomponent/index.html @@ -0,0 +1,118 @@ +--- +title: decodeURIComponent() +slug: Web/JavaScript/Reference/Global_Objects/decodeURIComponent +translation_of: Web/JavaScript/Reference/Global_Objects/decodeURIComponent +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>O método <code><strong>decodeURIComponent()</strong></code> decodifica um componente Identificador Uniforme de Recursos (URI) criado anteriormente por um {{jsxref("encodeURIComponent")}} ou por uma rotina semelhante.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>decodeURIComponent(<em>encodedURI</em>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>encodedURI</code></dt> + <dd>Um componente codificado de um Identificador Uniforme de Recursos.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Substitui cada sequência escapada no componente URI codificado com o caractere que a representa.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Decodificando_um_componente_URL_Cirílico">Decodificando um componente URL Cirílico</h3> + +<pre class="brush: js">decodeURIComponent("JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B"); +// "JavaScript_шеллы" +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.3.2', 'decodeURIComponent')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-decodeuricomponent-encodeduricomponent', 'decodeURIComponent')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de 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>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 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> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("decodeURI")}}</li> + <li>{{jsxref("encodeURI")}}</li> + <li>{{jsxref("encodeURIComponent")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/encodeuri/index.html b/files/pt-br/web/javascript/reference/global_objects/encodeuri/index.html new file mode 100644 index 0000000000..362493efd9 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/encodeuri/index.html @@ -0,0 +1,122 @@ +--- +title: encodeURI() +slug: Web/JavaScript/Reference/Global_Objects/encodeURI +tags: + - Codificação + - JavaScript + - Texto + - URI + - URL + - encodeURI + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/encodeURI +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>A função <code><strong>encodeURI()</strong></code> codifica a <a href="/en-US/docs/Glossary/URI">URI</a> substituindo cada instância de certos caracteres por um, dois, três ou quatro sequências de escape representando a codificação <a href="/en-US/docs/Glossary/UTF-8">UTF-8</a> do caracter (será somente quatro sequências de escape para caracteres compostos de dois caracteres substitutos).</p> + +<div>{{EmbedInteractiveExample("pages/js/globalprops-encodeuri.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code>encodeURI(<var>URI</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code><var>URI</var></code></dt> + <dd>Uma URI completa.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Uma nova cadeia de caracteres representando a cadeia de caracteres provida, codificada como uma URI.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>A função <code>encodeURI()</code> não codifica caracteres que possuem significado especial (caracteres reservados) para a URI. O exemplo seguinte mostra todas as partes que o "esquema" da URI pode possivelmente conter. Note como certos caracteres são usados para dar significado especial:</p> + +<pre class="notranslate">http://username:password@www.example.com:80/path/to/file.php?foo=316&bar=this+has+spaces#anchor</pre> + +<p>Consequentemente, <code>encodeURI()</code> <strong>não</strong> codifica caracteres que são necessários para formular uma URI completa. Também, <code>encodeURI()</code> <strong>não</strong> codifica alguns caracteres adicionais, conhecidos como "marcas não reservadas (unreserved marks)", que não tem propósito reservado mas são permitidos na URI "como são". (Veja <a href="https://www.ietf.org/rfc/rfc2396.txt">RFC2396)</a></p> + +<p><code>encodeURI()</code> escapa todos os caracteres <strong>exceto</strong>:</p> + +<pre class="notranslate"><strong>Não escapado</strong>: + + A-Z a-z 0-9 ; , / ? : @ & = + $ - _ . ! ~ * ' ( ) #<code> +</code> +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="encodeURI_vs_encodeURIComponent">encodeURI vs encodeURIComponent</h3> + +<p><code>encodeURI()</code> se difere de {{jsxref("encodeURIComponent", "encodeURIComponent()")}} como a seguir:</p> + +<pre class="brush: js notranslate">var set1 = ";,/?:@&=+$#"; // Caracteres reservados +var set2 = "-_.!~*'()"; // Marcas não reservadas +var set3 = "ABC abc 123"; // Caracteres alfanuméricos + Espaço + +console.log(encodeURI(set1)); // ;,/?:@&=+$# +console.log(encodeURI(set2)); // -_.!~*'() +console.log(encodeURI(set3)); // ABC%20abc%20123 (o espaço é codificado como %20) + +console.log(encodeURIComponent(set1)); // %3B%2C%2F%3F%3A%40%26%3D%2B%24%23 +console.log(encodeURIComponent(set2)); // -_.!~*'() +console.log(encodeURIComponent(set3)); // ABC%20abc%20123 (o espaço é codificado como %20) +</pre> + +<p>Note que <code>encodeURI()</code> por si só não pode formar requisições <a href="/en-US/docs/Web/HTTP/Methods/GET" title="The HTTP GET method requests a representation of the specified resource. Requests using GET should only retrieve data."><code>GET</code></a> e <a href="/en-US/docs/Web/HTTP/Methods/POST" title="The HTTP POST method sends data to the server. The type of the body of the request is indicated by the Content-Type header."><code>POST</code></a>, como para <a href="/en-US/docs/Web/API/XMLHttpRequest" title="Use XMLHttpRequest (XHR) objects to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing."><code>XMLHttpRequest</code></a>, porque <code>"&"</code>, <code>"+"</code>, e <code>"="</code> não são codificados, que são tratados como caracteres especiais em requisições <code>GET</code> e <code>POST</code>. <code>encodeURIComponent()</code>, entretanto, codifica esses caracteres.</p> + +<h3 id="Codificando_um_substituto_solitário_alto_joga">Codificando um substituto solitário alto joga</h3> + +<p>Um {{jsxref("URIError")}} será jogado se uma tentativa de codificar um substituto que não é parte de um par alto-baixo, e.g.,</p> + +<pre class="brush: js notranslate">// par alto-baixo ok +console.log(encodeURI('\uD800\uDFFF')); + +// substituto alto solitário joga "URIError: malformed URI sequence" +console.log(encodeURI('\uD800')); + +// substituto baixo solitário joga "URIError: malformed URI sequence" +console.log(encodeURI('\uDFFF'));</pre> + +<h3 id="Codificando_para_IPv6">Codificando para IPv6</h3> + +<p>Se você deseja seguir a <a href="http://tools.ietf.org/html/rfc3986">RFC3986</a> mais recente para URLs, que faz colchetes ser reservado (para <a href="/en-US/docs/Glossary/IPv6">IPv6</a>) e então não será codificado quando formando algo que possa ser parte da URL (como o host), o seguinte código pode ajudar:</p> + +<pre class="brush: js notranslate">function fixedEncodeURI(str) { + return encodeURI(str).replace(/%5B/g, '[').replace(/%5D/g, ']'); +}</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-encodeuri-uri', 'encodeURI')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.encodeURI")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("decodeURI", "decodeURI()")}}</li> + <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li> + <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/encodeuricomponent/index.html b/files/pt-br/web/javascript/reference/global_objects/encodeuricomponent/index.html new file mode 100644 index 0000000000..9d08433bfa --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/encodeuricomponent/index.html @@ -0,0 +1,159 @@ +--- +title: encodeURIComponent() +slug: Web/JavaScript/Reference/Global_Objects/encodeURIComponent +translation_of: Web/JavaScript/Reference/Global_Objects/encodeURIComponent +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>O método <code><strong>encodeURIComponent()</strong></code> codifica uma URI (Identificador recurso uniforme) substituindo cada ocorrência de determinados caracteres por um, dois, três, ou quatro seqüências de escape que representam a codificação UTF-8 do caractere (só será quatro seqüências de escape para caracteres compostos por dois caracteres "substituto").</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">encodeURIComponent(str);</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>str</code></dt> + <dd>String. Uma sequência URI.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p><code>encodeURIComponent</code> escapa todos os caracteres, exceto: alfabeto, dígitos decimais, <code>- _ . ! ~ * ' ( )</code></p> + +<p>Note-se que um{{jsxref("URIError")}} será gerada se uma tentativas para codificar um substituto que não faz parte de um par de alta-baixa, por exemplo,</p> + +<pre class="brush: js">// high-low par ok +console.log(encodeURIComponent('\uD800\uDFFF')); + +// lone high surrogate throws "URIError: malformed URI sequence" +console.log(encodeURIComponent('\uD800')); + +// lone low surrogate throws "URIError: malformed URI sequence" +console.log(encodeURIComponent('\uDFFF')); +</pre> + +<p>Para previnir requisões inesperadas ao servidor, deve-se chamar <code>encodeURIComponent</code> ou qualquer parâmetro fornecido pelo usuário que será passado como parte da URI. Por exemplo, um usuário poderia digitar "<code>Thyme &time=again</code>" para uma variável <code>commentario</code>. Ao não usar <code>encodeURIComponent</code> nessa variável irá ser obetido <code>commentario=Thyme%20&time=again</code>. Note que o ampersa e o sinal de igual marcam um novo par de chave e valor. Então ao invés de ter um POST com a chave <code>commentario</code> igual a "<code>Thyme &time=again</code>", tem-se chaves em POST, uma igual a "<code>Thyme </code>" e outra (<code>time</code>) igual a <code>again</code>.</p> + +<p>Para <a href="http://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#application/x-www-form-urlencoded-encoding-algorithm"><code>application/x-www-form-urlencoded</code></a>, espaços são substituídos por '+', então pode-se querer seguir um <code>encodeURIComponent</code> substituição com uma substituição adicional de "%20" com "+".</p> + +<p>Para ser mais rigoroso à aderência da <a class="external" href="http://tools.ietf.org/html/rfc3986">RFC 3986</a> (qual reserva !, ', (, ), e *), mesmo que esses caracteres não tenham usos formalizados de delimitação de URI, o seguinte pode ser usado com segurança:</p> + +<pre class="brush: js">function ajustadoEncodeURIComponent (str) { + return encodeURIComponent(str).replace(/[!'()*]/g, function(c) { + return '%' + c.charCodeAt(0).toString(16); + }); +} +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<p>O exemplo seguinte provê o encoding especial requerido pelo UTF-8 nos parâmetros <code>Content-Disposition</code> e <code>Link</code> no cabeçalho de uma Response (e.g., UTF-8 filenames):</p> + +<pre class="brush: js">var fileName = 'my file(2).txt'; +var header = "Content-Disposition: attachment; filename*=UTF-8''" + + encodeRFC5987ValueChars(fileName); + +console.log(header); +// logs "Content-Disposition: attachment; filename*=UTF-8''my%20file%282%29.txt" + + +function encodeRFC5987ValueChars (str) { + return encodeURIComponent(str). + // Note that although RFC3986 reserves "!", RFC5987 does not, + // so we do not need to escape it + replace(/['()]/g, escape). // i.e., %27 %28 %29 + replace(/\*/g, '%2A'). + // The following are not required for percent-encoding per RFC5987, + // so we can allow for a little better readability over the wire: |`^ + replace(/%(?:7C|60|5E)/g, unescape); +} +</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">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição Inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.3.4', 'encodeURIComponent')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-encodeuricomponent-uricomponent', 'encodeURIComponent')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_-_Browser">Compatibilidade - Browser</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="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("decodeURI")}}</li> + <li>{{jsxref("encodeURI")}}</li> + <li>{{jsxref("decodeURIComponent")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/error/index.html b/files/pt-br/web/javascript/reference/global_objects/error/index.html new file mode 100644 index 0000000000..41cc7e5bb8 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/error/index.html @@ -0,0 +1,229 @@ +--- +title: Error +slug: Web/JavaScript/Reference/Global_Objects/Error +tags: + - Custom Error + - Erro + - Error + - JavaScript + - Reference + - Referencia +translation_of: Web/JavaScript/Reference/Global_Objects/Error +--- +<div>{{JSRef}}</div> + +<p>O construtor de <strong><code>Error</code></strong> cria um objeto de erro. Instâncias de objetos <code>Error</code> são lançadas quando erros de tempo de execução ocorrem. O objeto <code>Error</code> também pode ser usado como objeto base para exceções definidas pelo usuário. Veja abaixo tipos de erro padrões embutidos.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox">new Error([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>message</code></dt> + <dd>Opcional. Descrição do erro legível para humanos.</dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Opcional. O valor da propriedade <code>fileName</code> no objeto de erro criado. O padrão é o nome do arquivo contendo o código que chamou o construtor de <code>Error()</code>.</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Opcional. O valor da propriedade <code>lineNumber</code> no objeto de <code>Error</code> criado. O padrão é o número da linha contendo a invocação do construtor <code>Error()</code>.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Erros em tempo de execução resultam em novos objetos <code>Error</code> sendo criados e lançados.</p> + +<p>Esta página documenta o uso do objeto <code>Error</code> em si e seu uso como uma função construtora. Para uma lista de propriedades e métodos herdados por instâncias de <code>Error</code>, veja {{jsxref("Error.prototype")}}.</p> + +<h3 id="Tipos_de_erro">Tipos de erro</h3> + +<p>Além do construtor genérico de <code>Error</code>, existem outros seis construtores principais de erro no JavaScript. Para exceções em <em>client-side</em>, veja <a href="/en-US/docs/Web/JavaScript/Guide/Statements#Exception_Handling_Statements">Excessões na captura de Instruções</a>.</p> + +<dl> + <dt>{{jsxref("EvalError")}}</dt> + <dd>Cria uma instância representando um erro que ocorre na função global. {{jsxref("Global_Objects/eval", "eval()")}}.</dd> + <dt>{{jsxref("InternalError")}} {{non-standard_inline}}</dt> + <dd>Cria uma instância representando um erro que ocorre quando um erro interno na <em>engine</em> do JavaScript é lançado. Ex: "too much recursion".</dd> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Cria uma instância representando um erro que ocorre quando um valor ou parâmetro numérico está fora de seus limites válidos.</dd> + <dt>{{jsxref("ReferenceError")}}</dt> + <dd>Cria uma instância representando um erro que ocorre ao de-referenciar uma referência inválida.</dd> + <dt>{{jsxref("SyntaxError")}}</dt> + <dd>Cria uma instância representando um erro que ocorre ao fazer o <em>parse</em> do código em {{jsxref("Global_Objects/eval", "eval()")}}.</dd> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Cria uma instância representando um erro que ocorre quando uma variável ou parâmetro não é de um tipo válido.</dd> + <dt>{{jsxref("URIError")}}</dt> + <dd>Cria uma instância representando um erro que ocorre quando são passados parâmetros inválidos para {{jsxref("Global_Objects/encodeURI", "encodeURI()")}} ou {{jsxref("Global_Objects/decodeURI", "decodeURI()")}}.</dd> +</dl> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt>{{jsxref("Error.prototype")}}</dt> + <dd>Permite a criação de propriedades para instâncias de <code>Error</code>.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<p>O objeto <code>Error</code> global não contém métodos próprios, entretanto, ele herda alguns métodos através da cadeia de <em>prototypes</em>.</p> + +<h2 id="Instâncias_de_Error"><code>Instâncias de Error</code></h2> + +<div>{{page('pt-BR/docs/JavaScript/Reference/Global_Objects/Error/prototype', 'Description')}}</div> + +<h3 id="Propriedades_2">Propriedades</h3> + +<div>{{page('pt-BR/docs/JavaScript/Reference/Global_Objects/Error/prototype', 'Properties')}}</div> + +<h3 id="Métodos_2">Métodos</h3> + +<div>{{page('pt-BR/docs/JavaScript/Reference/Global_Objects/Error/prototype', 'Methods')}}</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Lançando_um_erro_genérico">Lançando um erro genérico</h3> + +<p>Geralmente você cria um objeto <code>Error</code> com a intenção de lançá-lo usando a palavra-chave {{jsxref("Statements/throw", "throw")}}. Você pode capturar o erro usando uma construção de {{jsxref("Statements/try...catch", "try...catch")}}:</p> + +<pre class="brush: js">try { + throw new Error('Oooops!'); +} catch (e) { + alert(e.name + ': ' + e.message); +} +</pre> + +<h3 id="Capturando_um_erro_específico">Capturando um erro específico</h3> + +<p>Você pode escolher por capturar apenas tipos de erro específicos testando o tipo do erro com a propriedade {{jsxref("Object.prototype.constructor", "constructor")}} de erro ou, se você está escrevendo para <em>engines</em> de JavaScript modernas, a palavra-chave {{jsxref("Operators/instanceof", "instanceof")}}:</p> + +<pre class="brush: js">try { + Objeto.Metodo(); +} catch (e) { + if (e instanceof EvalError) { + alert(e.name + ': ' + e.message); + } else if (e instanceof RangeError) { + alert(e.name + ': ' + e.message); + } + // ... etc +} +</pre> + +<h3 id="Tipos_de_erro_customizados">Tipos de erro customizados</h3> + +<p>Você pode escolher definir seus próprios tipos de erro derivando de <code>Error</code> para conseguir usar <code>throw new MeuErro()</code> e usar <code>instanceof MeuErro </code>para checar o tipo de erro na captura da exceção. A forma comum para isso está demonstrada abaixo</p> + +<div class="warning"> +<p>Note que as instâncias <code>MeuErro</code> lançadas vão reportar valores de <code>lineNumber</code> e <code>fileName</code> incorretos, ao menos no Firefox.</p> +</div> + +<p>Veja também <a href="http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript">"esta discussão no Stackoverflow (em inglês): What's a good way to extend Error in JavaScript?"</a>.</p> + +<pre class="brush: js">// Cria um novo objeto que herda o construtor de Error através do prototype. +function MeuErro(message) { + this.name = 'MeuErro'; + this.message = message || 'Mensagem de erro padrão'; + this.stack = (new Error()).stack; +} +MeuErro.prototype = Object.create(MeuErro.prototype); +MeuErro.prototype.constructor = MeuErro; + +try { + throw new MeuErro(); +} catch (e) { + console.log(e.name); // 'MeuErro' + console.log(e.message); // 'Mensagem de erro padrão' +} + +try { + throw new MeuErro('Mensagem customizada'); +} catch (e) { + console.log(e.name); // 'MeuErro' + console.log(e.message); // 'Mensagem customizada' +}</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementada no JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11', 'Error')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error-objects', 'Error')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_browser">Compatibilidade de browser</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>{{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>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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Error.prototype")}}</li> + <li>{{jsxref("Statements/throw", "throw")}}</li> + <li>{{jsxref("Statements/try...catch", "try...catch")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/error/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/error/tosource/index.html new file mode 100644 index 0000000000..2a6ed43803 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/error/tosource/index.html @@ -0,0 +1,58 @@ +--- +title: Error.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Error/toSource +tags: + - JavaScript + - Não padronizado + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Error/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>O método <code><strong>toSource()</strong></code> retorna código que pode resultar no mesmo erro.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>e</var>.toSource()</pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Uma string contendo o código fonte do erro.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toSource">Usando toSource</h3> + +<p>Chamando método <code>toSource</code> de uma instância {{jsxref("Error")}} (incluindo<em><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types"> NativeErrors</a></em>) irá retornar uma string contendo o código fonte do erro. Essa string pode ser avaliada para criar (aproximadamente) um objeto igual. Naturalmente, a string contendo o fonte segue a estrutura do construtor {{jsxref("Error")}}. Por exemplo:</p> + +<pre class="brush: js notranslate">(new<em>name</em>(<em>message</em> ,<em>fileName</em>,<em>lineNumber</em>)) +</pre> + +<p>onde estes atributos correspondem as respectivas propriedades da instância do erro.</p> + +<div class="note"> +<p><strong>Nota:</strong> Fique alerta que as propriedades usadas pelo método <code>toSource</code> na criação da string são mutáveis e podem não refletir precisamente a função utilizada para criar a instância do erro ou nome de arquivo ou número de linha onde o erro atual ocorreu.</p> +</div> + +<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> + + +<p>{{Compat("javascript.builtins.Error.toSource")}}</p> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Error.prototype.fileName")}}</li> + <li>{{jsxref("Error.prototype.lineNumber")}}</li> + <li>{{jsxref("Error.prototype.message")}}</li> + <li>{{jsxref("Error.prototype.name")}}</li> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/error/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/error/tostring/index.html new file mode 100644 index 0000000000..80aba76e10 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/error/tostring/index.html @@ -0,0 +1,100 @@ +--- +title: Error.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Error/toString +tags: + - JavaScript + - Method + - Prototipo + - Prototype + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Error/toString +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>toString()</strong></code> retorna uma string representando o objeto {{jsxref("Error")}}.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>e</var>.toString()</code></pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>A string representando o objeto {{jsxref("Error")}} especificado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O objeto {{jsxref("Error")}} sobrescreve o método {{jsxref("Object.prototype.toString()")}} herdado por todos os objetos. Sua semântica é a seguinte (assumindo que {{jsxref("Object")}} e {{jsxref("String")}} tem seus valores originais):</p> + +<pre class="brush: js notranslate">Error.prototype.toString = function() { + 'use strict'; + + var obj = Object(this); + if (obj !== this) { + throw new TypeError(); + } + + var name = this.name; + name = (name === undefined) ? 'Error' : String(name); + + var msg = this.message; + msg = (msg === undefined) ? '' : String(msg); + + if (name === '') { + return msg; + } + if (msg === '') { + return name; + } + + return name + ': ' + msg; +}; +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toString">Usando toString()</h3> + +<pre class="brush: js notranslate">var e = new Error('fatal error'); +console.log(e.toString()); // 'Error: fatal error' + +e.name = undefined; +console.log(e.toString()); // 'Error: fatal error' + +e.name = ''; +console.log(e.toString()); // 'fatal error' + +e.message = undefined; +console.log(e.toString()); // '' + +e.name = 'hello'; +console.log(e.toString()); // 'hello' +</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-error.prototype.tostring', 'Error.prototype.toString')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Error.toString")}}</p> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Error.prototype.toSource()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/escape/index.html b/files/pt-br/web/javascript/reference/global_objects/escape/index.html new file mode 100644 index 0000000000..b966913b6d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/escape/index.html @@ -0,0 +1,127 @@ +--- +title: escape() +slug: Web/JavaScript/Reference/Global_Objects/escape +translation_of: Web/JavaScript/Reference/Global_Objects/escape +--- +<div>{{jsSidebar("Objects")}}</div> + +<div>A função obsoleta <code><strong>escape() </strong>retorna uma nova string com</code><span class="short_text" id="result_box" lang="pt"><span> </span><span>certos</span> <span>caracteres</span> <span>substituídos por sua sequência hexadecial. Use </span></span>{{jsxref("encodeURI")}} ou {{jsxref("encodeURIComponent")}} em seu lugar.</div> + +<div> </div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>escape(str)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>str</code></dt> + <dd>Uma string para ser codificada.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>A função <strong><code>escape </code></strong><code>é uma propriedade do </code><em>global object. </em>Caracteres especiais são codificados, com a exceção de: @*_+-./</p> + +<p>O formato hexadecimal de caracteres, que o valor unitário do código é <strong>0xFF or less, </strong>é uma sequência de escape de 2 digitos: %xx. Para caracteres com um código unitário maior, uma sequência de 4 digitos %<strong>u</strong>xxxx é usada.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js">escape("abc123"); // "abc123" +escape("äöü"); // "%E4%F6%FC" +escape("ć"); // "%u0107" + +// Caracteres Especiais +escape("@*_+-./"); // "@*_+-./"</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.1', 'escape')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td><span class="short_text" id="result_box" lang="pt"><span>Definido no </span><span>(informativo</span><span>) de c</span><span>ompatibilidade</span> <span>Anexo</span> <span>B</span></span></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-escape-string', 'escape')}}</td> + <td>{{Spec2('ES6')}}</td> + <td><span id="result_box" lang="pt"><span>Definido no</span> <span>(</span><span>normativo)</span> <span>Anexo</span> <span>B</span> <span>para recursos</span> <span>adicionais do</span> <span>ECMAScript</span> <span>para navegadores da web</span></span></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-escape-string', 'escape')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td><span id="result_box" lang="pt"><span>Definido no</span> <span>(</span><span>normativa)</span> <span>Anexo</span> <span>B</span> <span>para recursos</span> <span>adicionais do</span> <span>ECMAScript</span> <span>para navegadores da web</span></span></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de 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="Veja_Também">Veja Também</h2> + +<ul> + <li>{{jsxref("encodeURI")}}</li> + <li>{{jsxref("encodeURIComponent")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/eval/index.html b/files/pt-br/web/javascript/reference/global_objects/eval/index.html new file mode 100644 index 0000000000..f4e0044f50 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/eval/index.html @@ -0,0 +1,255 @@ +--- +title: eval() +slug: Web/JavaScript/Reference/Global_Objects/eval +translation_of: Web/JavaScript/Reference/Global_Objects/eval +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>A função <code><strong>eval()</strong></code> computa um código JavaScript representado como uma string.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="brush: js"><code>eval(<em>string</em>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>string</code></dt> + <dd>Uma sequência de caracteres que representa uma expressão JavaScript, declaração, ou sequência de declarações. A expressão pode incluir variáveis e propriedades de objetos existentes.</dd> +</dl> + + + +<h3 id="Retorno">Retorno</h3> + +<p>É o valor computado do código passado para a função. Se o valor estiver vazio, retornará {{jsxref("undefined")}}.</p> + + + +<h2 id="Description" name="Description">Descrição</h2> + +<p><code>eval() é uma função de propriedade do objeto global (window)</code>.</p> + +<p>O argumento da função <code>eval()</code> é uma string. Se a string representa uma expressão, <code>eval()</code> avalia a expressão. Se o argumento representa uma ou mais declarações em JavaScript, <code>eval()</code> avalia as declarações. Não chame o <code>eval()</code> para avaliar uma expressão aritmética; JavaScript avalia expressões aritméticas automaticamente.</p> + +<p>Se você construir uma expressão aritmética como uma string, você pode usar <code>eval()</code> para calcular o resultado depois. Por exemplo, suponha que você tenha uma variável x. Você pode adiar a avaliação de uma expressão envolvendo x atribuindo o valor de string da expressão, dizer <code>"3 * x + 2"</code>, a uma variável, e, em seguida, chamando <code>eval()</code> em um ponto posterior no seu script.</p> + +<p>Se o argumento de <code>eval()</code> não é uma string, <code>eval()</code> retorna o argumento inalterado. No exemplo a seguir, o construtor <code>String</code> é especificado, e <code>eval()</code> retorna um objeto <code>String</code> em vez de avaliar a string.</p> + +<pre class="brush:js">eval(new String("2 + 2")); // retorna um objeto String contendo "2 + 2" +eval("2 + 2"); // retorna 4 +</pre> + +<p>Você pode contornar esta limitação de forma genérica usando <code>toString()</code>.</p> + +<pre class="brush:js">var expression = new String("2 + 2"); +eval(expression.toString()); // retorna 4 +</pre> + +<p>Se você usar a função <code>eval</code> <em>indiretamente</em>, invocando-a por outra referência além de <code>eval</code>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-10.4.2">a partir do ECMAScript 5</a> funciona no escopo global ao invés do escopo local. Significa que, por exemplo, aquelas declarações de funções criam funções globais e que o código que está sendo avaliado não tem acesso às variáveis locais dentro do escopo onde está sendo chamada.</p> + +<pre class="brush: js"><code>function test() { + var x = 2, y = 4; + console.log(eval('x + y')); // Chamada direta, usa o escopo local, resulta em 6 + var geval = eval; // equivalente a chamar eval no escopo global + console.log(geval('x + y')); // Chamada indireta, usa o escopo global, lança uma exceção ReferenceError porque `x` não foi declarado + (0, eval)('x + y'); // outro exemplo de chamada indireta +}</code></pre> + +<h2 id="Don.27t_use_eval.21" name="Don.27t_use_eval.21"><a name="dont-use-it">Nunca use <code>eval</code>!</a></h2> + +<p><code>eval()</code> é uma função perigosa, que executa o código passado com os privilégios do caller. Se você executar o <code>eval() </code>com uma sequência de caracteres que podem ser afetados por uma parte maliciosa, você pode acabar executando código malicioso na máquina do usuário com as permissões da sua página/extensão. Mais importante ainda, o código de terceiros pode ver o escopo em que <code>eval()</code> foi chamado, o que pode levar a possíveis ataques como {{jsxref("Global_Objects/Function", "Function")}} não é suscetível.</p> + +<p><code>eval()</code> é geralmente mais lento do que as alternativas, uma vez que tem de invocar o interpretador JS, enquanto muitos outros construtores são otimizados por <em>engines</em> de JS modernos.</p> + +<p>Os interpretadores modernos convertem javascript em código de máquina. Resumindo, o nome das variáveis será desmanchado. Portanto, o uso de <code>eval</code> forçará o navegador a fazer buscas caras para descobrir o endereço e seu valor no código de máquina. Além disso, novos valores podem ser introduzidos em <code>eval</code> como mudanças no tipo da variável, fazendo o navegador recalcular todo o código de máquina gerado anteriormente. Felizmente, existem alternativas mais seguras (e rápidas) ao <code>eval()</code> para usos comuns.</p> + +<h3 id="Accessing_member_properties" name="Accessing_member_properties">Acessando propriedades dos membros</h3> + +<p>Você não deve utilizar <code>eval()</code> para converter nomes de propriedades em propriedades. Considere o seguinte exemplo onde as propriedades do objeto a ser acessado não são conhecidas até o código ser executado. Isso pode ser feito com eval:</p> + +<pre class="brush:js">var obj = { a: 20, b: 30 }; +var propname = getPropName(); //retorna "a" ou "b" + +eval( "var result = obj." + propname ); +</pre> + +<p>No entanto, <code>eval()</code> não é necessário aqui. De fato, sua utilização não é recomendada. Ao invés disso, utilize os <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Member_Operators" title="JavaScript/Reference/Operators/Member_Operators">operadores de acesso</a>, que são mais rápidos e seguros:</p> + +<pre class="brush:js">var obj = { a: 20, b: 30 }; +var propname = getPropName(); //retorna "a" ou "b" +var result = obj[ propname ]; // obj[ "a" ] é o mesmo como obj.a +</pre> + +<h3 id="Use_functions_instead_of_evaluating_snippets_of_code" name="Use_functions_instead_of_evaluating_snippets_of_code">Utilize funções ao invés de avaliar snippets de código</h3> + +<p>JavaScript possui <a class="external" href="http://en.wikipedia.org/wiki/First-class_function" title="http://en.wikipedia.org/wiki/First-class_function">first-class functions</a>, o que significa que você pode passar os argumentos para outras APIs, armazená-los em variáveis e propriedades de objeto, e assim por diante. Muitas APIs de DOM foram desenvolvidas com isso em mente, então você pode (e deve) escrever:</p> + +<pre class="brush: js">// ao invés de setTimeout(" ... ", 1000) use: +setTimeout(function() { ... }, 1000); + +// ao invés de elt.setAttribute("onclick", "...") use: +elt.addEventListener("click", function() { ... } , false); </pre> + +<p><a href="/en-US/docs/Web/JavaScript/Guide/Closures" title="JavaScript/Guide/Closures">Closures</a> são úteis como forma de criar funcções parametrizáveis sem concatenar strings.</p> + +<h3 id="Parsing_JSON_converting_strings_to_JavaScript_objects" name="Parsing_JSON_(converting_strings_to_JavaScript_objects)">Analisando JSON (convertendo string para objetos JavaScript)</h3> + +<p>Se a string para a qual você está chamando o <code>eval() contém dados </code>(por exemplo, um array: <code>"[1, 2, 3]"</code>), ao invés de código, você deve considerar mudar para <a href="/en-US/docs/JSON" title="JSON">JSON</a>, que permite a string usar um subconjunto de sintaxe Javascript para representar dados. Veja também <a href="/en-US/docs/Downloading_JSON_and_JavaScript_in_extensions" title="Downloading_JSON_and_JavaScript_in_extensions">Downloading JSON and JavaScript in extensions</a>.</p> + +<p>Perceba que como a sintaxe JSON é limitada comparada com a sintaxe JavaScript, muitos literais JavaScript válidos não serão analisados como JSON. Por exemplo, trailing commas não são permitidas em JSON, e nomes de propriedades (keys) em literais de objetos devem ser colocados entre aspas. Certifique-se de usar um serializados JSON para gerar strings que serão analisadas como JSON mais tarde.</p> + +<h3 id="Pass_data_instead_of_code" name="Pass_data_instead_of_code">Passar dados em vez de códigos</h3> + +<p>Por exemplo, uma extensão concebida para raspar conteúdos de páginas web pode ter as regras de raspagem definidas no <a href="/en-US/docs/XPath" title="XPath">XPath</a> em vez de código JavaScript.</p> + +<h3 id="Run_code_with_limited_privileges" name="Run_code_with_limited_privileges">Rodando o código com privilégios limitados</h3> + +<p>Se você precisa executar o código, considere executá-lo com privilégios limitados. Esse conselho se aplica principalmente para extensões e aplicações XUL, que podem usar <a href="/en-US/docs/Components.utils.evalInSandbox" title="Components.utils.evalInSandbox">Components.utils.evalInSandbox</a> para obter o resultado.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<p>Os exemplos a seguir mostram o retorno do <a href="/en-US/docs/Web/API/document.write"><code>document.write</code></a>. No JavaScript rodando no server-side, você pode obter o mesmo resultado chamando o método <code>write()ao invés</code> de usar o <code>document.write()</code>.</p> + +<h3 id="Example_Using_eval" name="Example:_Using_eval">Exemplo: Usando <code>eval</code></h3> + +<p>No código a seguir, ambas as declarações contendo <code>eval()</code> retornam 42. A primeira avalia a string "<code>x + y + 1</code>"; a segunda avalia a string "<code>42</code>".</p> + +<pre class="brush:js">var x = 2; +var y = 39; +var z = "42"; +eval("x + y + 1"); // returns 42 +eval(z); // returns 42 +</pre> + +<h3 id="Example_Using_eval_to_evaluate_a_string_of_JavaScript_statements" name="Example:_Using_eval_to_evaluate_a_string_of_JavaScript_statements">Examplo: Using <code>eval</code> to evaluate a string of JavaScript statements</h3> + +<p>O exemplo a seguir usa <code>eval()</code> para avaliar a string <code>str</code>. Essa string consiste de instruções JavaScript que abrem uma caixa de diálogo de alerta e atribuem ao <code>z</code> o valor de 42 se <code>x</code> for cinco, e do contrário, atribui 0 a <code>z</code>. Quando a segunda instrução é executada, <code>eval()</code> fará com que essas instruções sejam executadas e também irá avaliar o conjunto de instruções e retornará o valor atribuído a z.</p> + +<pre class="brush:js">var x = 5; +var str = "if (x == 5) {alert('z is 42'); z = 42;} else z = 0; "; + +document.write("<P>z is ", eval(str));</pre> + +<h3 id="Return_value" name="Return_value">Exemplo: A última expressão é avaliada</h3> + +<p><code>eval()</code> retorna o valor da última expressão avaliada.</p> + +<pre class="brush:js">var str = "if ( a ) { 1+1; } else { 1+2; }"; +var a = true; +var b = eval(str); // returns 2 + +alert("b is : " + b); + +a = false; +b = eval(str); // returns 3 + +alert("b is : " + b);</pre> + +<h3 id="Exemplo_avaliar_uma_string_definindo_a_função_necessária_and_como_prefixo_e_sufixo">Exemplo: avaliar uma string definindo a função necessária "(" and ")" como prefixo e sufixo</h3> + +<pre class="brush:js" style="font-size: 14px;">var fctStr1 = "function a() {}" +var fctStr2 = "(function a() {})" +var fct1 = eval(fctStr1) // return undefined +var fct2 = eval(fctStr2) // return a function +</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>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Definição inicial</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.2.1', 'eval')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-eval-x', 'eval')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p>{{ CompatibilityTable() }}</p> + +<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>{{ 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>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>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h3 id="See_Also" name="See_Also">Gecko-specific notes</h3> + +<ul> + <li>Historicamente <code>eval()</code> tinha um segundo argumento opcional , especificando um objeto em cujo o contexto a validação seria realizada. Esse argumento não era padronizado e foi removido do SpiderMonkey no Gecko 1.9.1 (Firefox 3.5). See {{ bug(442333) }}.</li> +</ul> + +<h2 id="See_Also" name="See_Also">Veja também</h2> + +<ul> + <li>{{jsxref("Global_Objects/uneval", "uneval()")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Member_Operators">Member operators</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/evalerror/index.html b/files/pt-br/web/javascript/reference/global_objects/evalerror/index.html new file mode 100644 index 0000000000..d938b83d8f --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/evalerror/index.html @@ -0,0 +1,163 @@ +--- +title: EvalError +slug: Web/JavaScript/Reference/Global_Objects/EvalError +tags: + - Desenvolvimento Web + - Erro + - EvalError + - JS + - JavaScript + - Referencia + - Web +translation_of: Web/JavaScript/Reference/Global_Objects/EvalError +--- +<div>{{JSRef}}</div> + +<p>O Objeto <strong><code>EvalError</code></strong> indica um erro em relação a função global {{jsxref("Global_Objects/eval", "eval()")}}. Esta exceção não é mais lançada pelo JavaScript, no entanto, o objeto <code>EvalError</code> ainda permanece compatível.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>new EvalError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>message</code></dt> + <dd>Opcional. Descrição do erro legível para humanos</dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Opcional. O nome do arquivo que contém o código que causa a exceção</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Opcional. O número da linha do código que causa a exceção</dd> +</dl> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt>{{jsxref("EvalError.prototype")}}</dt> + <dd>Permite a adição de propriedades para um objeto <code>EvalError</code>.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<p>O global <code>EvalError</code> não contém métodos próprios, no entando, ele irá herdar alguns métodos através da cadeia de protótipos.</p> + +<h2 id="Instâncias_do_EvalError"><code>Instâncias do EvalError</code></h2> + +<h3 id="Propriedades_2">Propriedades</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError/prototype', 'Properties')}}</div> + +<h3 id="Métodos_2">Métodos</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError/prototype', 'Methods')}}</div> + +<h2 id="Exemplos">Exemplos</h2> + +<p><code>EvalError</code> não é usado na especificação ECMAScript e deste modo não será lançado pelo tempo de execução. No entando, o objeto em si permanece para compatibilidade com versões anteriores da especificação.</p> + +<h3 id="Criando_um_EvalError">Criando um <code>EvalError</code></h3> + +<pre class="brush: js">try { + throw new EvalError('Hello', 'someFile.js', 10); +} catch (e) { + console.log(e instanceof EvalError); // true + console.log(e.message); // "Hello" + console.log(e.name); // "EvalError" + console.log(e.fileName); // "someFile.js" + console.log(e.lineNumber); // 10 + console.log(e.columnNumber); // 0 + console.log(e.stack); // "@Scratchpad/2:2:9\n" +} +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.6.1', 'EvalError')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Não utilizada na especificação. Presente para compatibilidade com outras versões.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-evalerror', 'EvalError')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Não utilizada na especificação. Presente para compatibilidade com outras versões.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-evalerror', 'EvalError')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_Navegadores">Compatibilidade dos 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>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 para Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Móvel</th> + <th>Opera Móvel</th> + <th>Safari Móvel</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> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("EvalError.prototype")}}</li> + <li>{{jsxref("Global_Objects/eval", "eval()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/float32array/index.html b/files/pt-br/web/javascript/reference/global_objects/float32array/index.html new file mode 100644 index 0000000000..9bd9a6a33d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/float32array/index.html @@ -0,0 +1,200 @@ +--- +title: Float32Array +slug: Web/JavaScript/Reference/Global_Objects/Float32Array +translation_of: Web/JavaScript/Reference/Global_Objects/Float32Array +--- +<div>{{JSRef}}</div> + +<p>A array tipada <strong><code>Float32Array</code></strong> representa uma array de 32-bits contendo floats (correspondendo ao tipo de dados <code>float</code> em C) na ordem dos bytes da plataforma. Se o controle sobre a ordem dos bytes for precisa, use {{jsxref("DataView")}}. Os conteúdos iniciam em <code>0</code>. Uma vez estabelecido, você pode referenciar os elementos na array usando os métodos do objeto ou usando a síntaxe padrão das arrays (Isto é, usando colchetes)</p> + +<h2 id="Síntaxe">Síntaxe</h2> + +<pre class="syntaxbox">new Float32Array(); // novo no ES2017 +new Float32Array(length); +new Float32Array(typedArray); +new Float32Array(object); +new Float32Array(buffer [, byteOffset [, length]]);</pre> + +<p>Para mais informações sobre a síntaxe de construção e os parâmetros, veja <em><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntax">TypedArray</a></em>.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Float32Array.BYTES_PER_ELEMENT")}}</dt> + <dd>Retorna um número valor do tamanho do elemento. <code>4</code> no caso de uma <code>Float32Array</code>.</dd> + <dt>Float32Array.length</dt> + <dd>Método estático cujo o valor é <code>0</code>. Para o tamanho atual (número de elementos), veja {{jsxref("TypedArray.prototype.length", "Float32Array.prototype.length")}}.</dd> + <dt>{{jsxref("TypedArray.name", "Float32Array.name")}}</dt> + <dd>Retorna o valor em string do nome do constructor. No caso de <code>Float32Array</code> é "Float32Array".</dd> + <dt>{{jsxref("TypedArray.prototype", "Float32Array.prototype")}}</dt> + <dd>Prototype para os objetos <em>TypedArray</em>.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("TypedArray.from", "Float32Array.from()")}}</dt> + <dd>Cria uma nova <code>Float32Array</code> de um array-like ou um objeto iterável. Veja também {{jsxref("Array.from()")}}.</dd> + <dt>{{jsxref("TypedArray.of", "Float32Array.of()")}}</dt> + <dd>Cria uma nova <code>Float32Array</code> with um número variável de argumentos. Veja também {{jsxref("Array.of()")}}.</dd> +</dl> + +<h2 id="Float32Array_prototype"><code>Float32Array</code> prototype</h2> + +<p>Todos os objetos <code>Float32Array</code> herdam de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p> + +<h3 id="Propriedades_2">Propriedades</h3> + +<dl> + <dt><code>Float32Array.prototype.constructor</code></dt> + <dd>Retorna a função cujo criou o protótipo da instância. Este é o construtor padrão da Array <code>Float32Array</code>.</dd> + <dt>{{jsxref("TypedArray.prototype.buffer", "Float32Array.prototype.buffer")}} {{readonlyInline}}</dt> + <dd>Retorna os {{jsxref("ArrayBuffer")}} referenciado pela Array <code>Float32Array</code> fixada na hora de sua construção e é <strong>somente leitura</strong>.</dd> + <dt>{{jsxref("TypedArray.prototype.byteLength", "Float32Array.prototype.byteLength")}} {{readonlyInline}}</dt> + <dd>Retorna o tamanho (em bytes) da Array <code>Float32Array</code> do começo de seu {{jsxref("ArrayBuffer")}}. Fixado na hora de sua construção e é <strong>somente leitura</strong>.</dd> + <dt>{{jsxref("TypedArray.prototype.byteOffset", "Float32Array.prototype.byteOffset")}} {{readonlyInline}}</dt> + <dd>Retorna o deslocamento (em bytes) da Array <code>Float32Array</code> do começo de seu {{jsxref("ArrayBuffer")}}. Fixado na hora de sua construção e é <strong>somente leitura</strong>.</dd> + <dt>{{jsxref("TypedArray.prototype.length", "Float32Array.prototype.length")}} {{readonlyInline}}</dt> + <dd>Retorna o número de elementos na Array <code>Float32Array</code> do começo de seu {{jsxref("ArrayBuffer")}}. Fixado na hora de sua construção e é <strong>somente leitura</strong>.</dd> +</dl> + +<h3 id="Métodos_2">Métodos</h3> + +<dl> + <dt>{{jsxref("TypedArray.copyWithin", "Float32Array.prototype.copyWithin()")}}</dt> + <dd>Copia a sequência dos elementos dentro da Array. Veja também {{jsxref("Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.entries", "Float32Array.prototype.entries()")}}</dt> + <dd>Retorna um novo objeto <code>Array Iterator</code> que contém os pares chave/valor para cada índex na array. Veja também {{jsxref("Array.prototype.entries()")}}.</dd> + <dt>{{jsxref("TypedArray.every", "Float32Array.prototype.every()")}}</dt> + <dd>Testa quando todos os elementos na array passam no teste proveniente de uma função. Veja também {{jsxref("Array.prototype.every()")}}.</dd> + <dt>{{jsxref("TypedArray.fill", "Float32Array.prototype.fill()")}}</dt> + <dd>Preenche todos os elementos de uma array do índex inicial ao índex final com um valor estático. Veja também {{jsxref("Array.prototype.fill()")}}.</dd> + <dt>{{jsxref("TypedArray.filter", "Float32Array.prototype.filter()")}}</dt> + <dd>Cria uma nova array com todos os elementos dessa array para a função de filtragem que retornar <code>true</code>. Veja também {{jsxref("Array.prototype.filter()")}}.</dd> + <dt>{{jsxref("TypedArray.find", "Float32Array.prototype.find()")}}</dt> + <dd>Retorna o valor na array encontrado, se um elemento na array satizfaz o teste proveniente de uma função de teste ou <code>undefined</code> se não for encontrado. Veja também {{jsxref("Array.prototype.find()")}}.</dd> + <dt>{{jsxref("TypedArray.findIndex", "Float32Array.prototype.findIndex()")}}</dt> + <dd>Retorna o index encontrado na array, se um elemento na array satizfaz o teste proveniente de uma função de teste ou -1 se não for encontrado. Veja também {{jsxref("Array.prototype.findIndex()")}}.</dd> + <dt>{{jsxref("TypedArray.forEach", "Float32Array.prototype.forEach()")}}</dt> + <dd>Chama uma função para cada elemento na array. Veja também {{jsxref("Array.prototype.forEach()")}}.</dd> + <dt>{{jsxref("TypedArray.includes", "Float32Array.prototype.includes()")}} {{experimental_inline}}</dt> + <dd>Determina quando a array tipada inclui um certo elemento, retornando <code>true</code> ou <code>false</code> como apropriado. Veja também {{jsxref("Array.prototype.includes()")}}.</dd> + <dt>{{jsxref("TypedArray.indexOf", "Float32Array.prototype.indexOf()")}}</dt> + <dd>Retorna o primeiro (menor) index de um elemento dentro de uma array igual ao valor expecificado, ou -1 se nenhum for encontrado. Veja também {{jsxref("Array.prototype.indexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.join", "Float32Array.prototype.join()")}}</dt> + <dd>Junta todos os elementos de uma array em uma string. Veja também {{jsxref("Array.prototype.join()")}}.</dd> + <dt>{{jsxref("TypedArray.keys", "Float32Array.prototype.keys()")}}</dt> + <dd>Retorna um novo <code>Array Iterator</code> cujo contem as chaves para cada index na array. Veja também {{jsxref("Array.prototype.keys()")}}.</dd> + <dt>{{jsxref("TypedArray.lastIndexOf", "Float32Array.prototype.lastIndexOf()")}}</dt> + <dd>Retorna o último (maior) índex de um elemento dentro da array igual ao valor especificado, ou -1 se nenhum for encontrado. Veja também {{jsxref("Array.prototype.lastIndexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.map", "Float32Array.prototype.map()")}}</dt> + <dd>Cria uma nova array com os resultados da função chamada em cada elemento nesta array. Veja também {{jsxref("Array.prototype.map()")}}.</dd> + <dt>{{jsxref("TypedArray.move", "Float32Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt> + <dd>Versão antiga não padrão de {{jsxref("TypedArray.copyWithin", "Float32Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.reduce", "Float32Array.prototype.reduce()")}}</dt> + <dd>Aplica uma função contra um acumulador e cada valor na array (da esquerda para a direita) com o intuito de reduzí-la a um único valor. Veja também {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reduceRight", "Float32Array.prototype.reduceRight()")}}</dt> + <dd>Aplica uma função contra um acumulador e cada valor na array (da direita para a esquerda) como o intuito de reduzí-la a um único valor. See also {{jsxref("Array.prototype.reduceRight()")}}.</dd> + <dt>{{jsxref("TypedArray.reverse", "Float32Array.prototype.reverse()")}}</dt> + <dd>Reverte a ordem se todos os elementos em uma array - o primeiro se torna o último, e o último de torna o primeiro. Veja também {{jsxref("Array.prototype.reverse()")}}.</dd> + <dt>{{jsxref("TypedArray.set", "Float32Array.prototype.set()")}}</dt> + <dd>Armazena múltiplos valores na array tipada, lendo os valores de entrada de uma array especificada.</dd> + <dt>{{jsxref("TypedArray.slice", "Float32Array.prototype.slice()")}}</dt> + <dd>Extrai uma seção de uma array e retorna uma nova array. Veja também {{jsxref("Array.prototype.slice()")}}.</dd> + <dt>{{jsxref("TypedArray.some", "Float32Array.prototype.some()")}}</dt> + <dd>Retorna true se pelo menos um elemento nesta array satisfazer a função de teste proveniente de uma função de teste. Veja também {{jsxref("Array.prototype.some()")}}.</dd> + <dt>{{jsxref("TypedArray.sort", "Float32Array.prototype.sort()")}}</dt> + <dd>Classifica os elementos de uma array no lugar e retorna a array. Veja também {{jsxref("Array.prototype.sort()")}}.</dd> + <dt>{{jsxref("TypedArray.subarray", "Float32Array.prototype.subarray()")}}</dt> + <dd>Retorna uma nova Array <code>Float32Array</code> a partir de um ponto inicial e um fim pelo índex do elemento.</dd> + <dt>{{jsxref("TypedArray.values", "Float32Array.prototype.values()")}}</dt> + <dd>Retorna um novo objeto <code>Array Iterator</code> que contém os valores para cada índex na Array. Veja também {{jsxref("Array.prototype.values()")}}.</dd> + <dt>{{jsxref("TypedArray.toLocaleString", "Float32Array.prototype.toLocaleString()")}}</dt> + <dd>Retorna uma string localizada representando a array e seus elementos. Veja também {{jsxref("Array.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("TypedArray.toString", "Float32Array.prototype.toString()")}}</dt> + <dd>Retorna uma string representando a array e seus elementos. Veja também {{jsxref("Array.prototype.toString()")}}.</dd> + <dt>{{jsxref("TypedArray.@@iterator", "Float32Array.prototype[@@iterator]()")}}</dt> + <dd>Retorna um novo objeto <code>Array Iterator</code> que contém os valores para cada índex na Array.</dd> +</dl> + +<h2 id="Exemplos">Exemplos</h2> + +<p>Diferentes modos de criar uma Array <code>Float32Array</code>:</p> + +<pre class="brush: js">// Pelo seu tamanho +var float32 = new Float32Array(2); +float32[0] = 42; +console.log(float32[0]); // 42 +console.log(float32.length); // 2 +console.log(float32.BYTES_PER_ELEMENT); // 4 + +// Por uma array +var arr = new Float32Array([21,31]); +console.log(arr[1]); // 31 + +// Por uma outra TypedArray +var x = new Float32Array([21, 31]); +var y = new Float32Array(x); +console.log(y[0]); // 21 + +// Por um ArrayBuffer +var buffer = new ArrayBuffer(16); +var z = new Float32Array(buffer, 0, 4); + +// Por um iterável +var iterable = function*(){ yield* [1,2,3]; }(); +var float32 = new Float32Array(iterable); +// Float32Array[1, 2, 3] +</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">Comment</th> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Suplantada pelo ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#table-49', 'TypedArray constructors')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial no padrão ECMA. Especificado que o <code>new</code> é requerido.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>O ECMAScript 7 mudou o construtor da Array <code>Array32Float</code> para o uso da operação <code>ToIndex</code> e ajudar nos construtores sem argumentos.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2> + +<div class="hidden">A tabela de compatibilidade nesta pagina é gerada por dados estruturados. Se você quiser contribuir com os dados, por favor veja 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> e nos mande um pull request.</div> + +<p>{{Compat("javascript.builtins.Float32Array")}}</p> + +<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2> + +<p>Começando com o ECMAScript 2015, construtores da Array <code>Float32Array</code> requerem o uso do operador {{jsxref("Operators/new", "new")}}. Chamando o construtor da Array <code>Float32Array</code> como uma função, sem o <code>new</code>, irá gerar um erro {{jsxref("TypeError")}} de agora em diante.</p> + +<pre class="brush: js example-bad">var dv = Float32Array([1, 2, 3]); + +// TypeError: chamando o construtor da função interna Float32Array +// sem o new é proibido</pre> + +<pre class="brush: js example-good">var dv = new Float32Array([1, 2, 3]);</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript arrays tipadas</a></li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("DataView")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/float64array/index.html b/files/pt-br/web/javascript/reference/global_objects/float64array/index.html new file mode 100644 index 0000000000..63a7ae3f33 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/float64array/index.html @@ -0,0 +1,160 @@ +--- +title: Float64Array +slug: Web/JavaScript/Reference/Global_Objects/Float64Array +translation_of: Web/JavaScript/Reference/Global_Objects/Float64Array +--- +<div>{{JSRef}}</div> + +<p>The <strong><code>Float64Array</code></strong> typed array represents an array of 64-bit floating point numbers (corresponding to the C <code>double</code> data type) in the platform byte order. If control over byte order is needed, use {{jsxref("DataView")}} instead. The contents are initialized to <code>0</code>. Once established, you can reference elements in the array using the object's methods, or using standard array index syntax (that is, using bracket notation).</p> + +<h2 id="Constructor">Constructor</h2> + +<dl> + <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array/Float64Array"><code>Float64Array()</code></a></dt> + <dd>Cria um novo objeto <code>Float64Array</code></dd> +</dl> + +<h2 id="Static_properties">Static properties</h2> + +<dl> + <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Float64Array.BYTES_PER_ELEMENT")}}</dt> + <dd>Retorna um valor numerico de tamanho . <code>8</code> no caso de um <code>Float64Array</code>.</dd> + <dt>{{jsxref("TypedArray.name", "Float64Array.name")}}</dt> + <dd>Retorna uma string com o nome do contructor. no caso de<code>Float64Array</code> type: "Float64Array".</dd> +</dl> + +<h2 id="Static_methods">Static methods</h2> + +<dl> + <dt>{{jsxref("TypedArray.from", "Float64Array.from()")}}</dt> + <dd>Cria um novo <code>Float64Array</code> a partir de um array-like ou um objeto iteravel . tambem como {{jsxref("Array.from()")}}.</dd> + <dt>{{jsxref("TypedArray.of", "Float64Array.of()")}}</dt> + <dd>Cria um novo <code>Float64Array</code> com um numero variado de argumentos. tambem como {{jsxref("Array.of()")}}.</dd> +</dl> + +<h2 id="Instance_properties">Instance properties</h2> + +<dl> + <dt>{{jsxref("TypedArray.prototype.buffer", "Float64Array.prototype.buffer")}}</dt> + <dd>Returns the {{jsxref("ArrayBuffer")}} referenced by the <code>Float64Array</code> Fixed at construction time and thus <strong>read only</strong>.</dd> + <dt>{{jsxref("TypedArray.prototype.byteLength", "Float64Array.prototype.byteLength")}}</dt> + <dd>Returns the length (in bytes) of the <code>Float64Array</code> from the start of its {{jsxref("ArrayBuffer")}}. Fixed at construction time and thus <strong>read only.</strong></dd> + <dt>{{jsxref("TypedArray.prototype.byteOffset", "Float64Array.prototype.byteOffset")}}</dt> + <dd>Returns the offset (in bytes) of the <code>Float64Array</code> from the start of its {{jsxref("ArrayBuffer")}}. Fixed at construction time and thus <strong>read only.</strong></dd> + <dt>{{jsxref("TypedArray.prototype.length", "Float64Array.prototype.length")}}</dt> + <dd>Returns the number of elements hold in the <code>Float64Array</code>. Fixed at construction time and thus <strong>read only.</strong></dd> +</dl> + +<h2 id="Instance_methods">Instance methods</h2> + +<dl> + <dt>{{jsxref("TypedArray.copyWithin", "Float64Array.prototype.copyWithin()")}}</dt> + <dd>Copies a sequence of array elements within the array. See also {{jsxref("Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.entries", "Float64Array.prototype.entries()")}}</dt> + <dd>Returns a new <code>Array Iterator</code> object that contains the key/value pairs for each index in the array. See also {{jsxref("Array.prototype.entries()")}}.</dd> + <dt>{{jsxref("TypedArray.every", "Float64Array.prototype.every()")}}</dt> + <dd>Tests whether all elements in the array pass the test provided by a function. See also {{jsxref("Array.prototype.every()")}}.</dd> + <dt>{{jsxref("TypedArray.fill", "Float64Array.prototype.fill()")}}</dt> + <dd>Fills all the elements of an array from a start index to an end index with a static value. See also {{jsxref("Array.prototype.fill()")}}.</dd> + <dt>{{jsxref("TypedArray.filter", "Float64Array.prototype.filter()")}}</dt> + <dd>Creates a new array with all of the elements of this array for which the provided filtering function returns true. See also {{jsxref("Array.prototype.filter()")}}.</dd> + <dt>{{jsxref("TypedArray.find", "Float64Array.prototype.find()")}}</dt> + <dd>Returns the found value in the array, if an element in the array satisfies the provided testing function or <code>undefined</code> if not found. See also {{jsxref("Array.prototype.find()")}}.</dd> + <dt>{{jsxref("TypedArray.findIndex", "Float64Array.prototype.findIndex()")}}</dt> + <dd>Returns the found index in the array, if an element in the array satisfies the provided testing function or -1 if not found. See also {{jsxref("Array.prototype.findIndex()")}}.</dd> + <dt>{{jsxref("TypedArray.forEach", "Float64Array.prototype.forEach()")}}</dt> + <dd>Calls a function for each element in the array. See also {{jsxref("Array.prototype.forEach()")}}.</dd> + <dt>{{jsxref("TypedArray.includes", "Float64Array.prototype.includes()")}}</dt> + <dd>Determines whether a typed array includes a certain element, returning <code>true</code> or <code>false</code> as appropriate. See also {{jsxref("Array.prototype.includes()")}}.</dd> + <dt>{{jsxref("TypedArray.indexOf", "Float64Array.prototype.indexOf()")}}</dt> + <dd>Returns the first (least) index of an element within the array equal to the specified value, or -1 if none is found. See also {{jsxref("Array.prototype.indexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.join", "Float64Array.prototype.join()")}}</dt> + <dd>Joins all elements of an array into a string. See also {{jsxref("Array.prototype.join()")}}.</dd> + <dt>{{jsxref("TypedArray.keys", "Float64Array.prototype.keys()")}}</dt> + <dd>Returns a new <code>Array Iterator</code> that contains the keys for each index in the array. See also {{jsxref("Array.prototype.keys()")}}.</dd> + <dt>{{jsxref("TypedArray.lastIndexOf", "Float64Array.prototype.lastIndexOf()")}}</dt> + <dd>Returns the last (greatest) index of an element within the array equal to the specified value, or -1 if none is found. See also {{jsxref("Array.prototype.lastIndexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.map", "Float64Array.prototype.map()")}}</dt> + <dd>Creates a new array with the results of calling a provided function on every element in this array. See also {{jsxref("Array.prototype.map()")}}.</dd> + <dt>{{jsxref("TypedArray.reduce", "Float64Array.prototype.reduce()")}}</dt> + <dd>Apply a function against an accumulator and each value of the array (from left-to-right) as to reduce it to a single value. See also {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reduceRight", "Float64Array.prototype.reduceRight()")}}</dt> + <dd>Apply a function against an accumulator and each value of the array (from right-to-left) as to reduce it to a single value. See also {{jsxref("Array.prototype.reduceRight()")}}.</dd> + <dt>{{jsxref("TypedArray.reverse", "Float64Array.prototype.reverse()")}}</dt> + <dd>Reverses the order of the elements of an array — the first becomes the last, and the last becomes the first. See also {{jsxref("Array.prototype.reverse()")}}.</dd> + <dt>{{jsxref("TypedArray.set", "Float64Array.prototype.set()")}}</dt> + <dd>Stores multiple values in the typed array, reading input values from a specified array.</dd> + <dt>{{jsxref("TypedArray.slice", "Float64Array.prototype.slice()")}}</dt> + <dd>Extracts a section of an array and returns a new array. See also {{jsxref("Array.prototype.slice()")}}.</dd> + <dt>{{jsxref("TypedArray.some", "Float64Array.prototype.some()")}}</dt> + <dd>Returns true if at least one element in this array satisfies the provided testing function. See also {{jsxref("Array.prototype.some()")}}.</dd> + <dt>{{jsxref("TypedArray.sort", "Float64Array.prototype.sort()")}}</dt> + <dd>Sorts the elements of an array in place and returns the array. See also {{jsxref("Array.prototype.sort()")}}.</dd> + <dt>{{jsxref("TypedArray.subarray", "Float64Array.prototype.subarray()")}}</dt> + <dd>Returns a new <code>Float64Array</code> from the given start and end element index.</dd> + <dt>{{jsxref("TypedArray.values", "Float64Array.prototype.values()")}}</dt> + <dd>Returns a new <code>Array Iterator</code> object that contains the values for each index in the array. See also {{jsxref("Array.prototype.values()")}}.</dd> + <dt>{{jsxref("TypedArray.toLocaleString", "Float64Array.prototype.toLocaleString()")}}</dt> + <dd>Returns a localized string representing the array and its elements. See also {{jsxref("Array.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("TypedArray.toString", "Float64Array.prototype.toString()")}}</dt> + <dd>Returns a string representing the array and its elements. See also {{jsxref("Array.prototype.toString()")}}.</dd> + <dt>{{jsxref("TypedArray.@@iterator", "Float64Array.prototype[@@iterator]()")}}</dt> + <dd>Returns a new <code>Array Iterator</code> object that contains the values for each index in the array.</dd> +</dl> + +<h2 id="Examples">Examples</h2> + +<h3 id="Different_ways_to_create_a_Float64Array">Different ways to create a <code>Float64Array</code></h3> + +<pre class="brush: js notranslate">// From a length +var float64 = new Float64Array(2); +float64[0] = 42; +console.log(float64[0]); // 42 +console.log(float64.length); // 2 +console.log(float64.BYTES_PER_ELEMENT); // 8 + +// From an array +var arr = new Float64Array([21,31]); +console.log(arr[1]); // 31 + +// From another TypedArray +var x = new Float64Array([21, 31]); +var y = new Float64Array(x); +console.log(y[0]); // 21 + +// From an ArrayBuffer +var buffer = new ArrayBuffer(32); +var z = new Float64Array(buffer, 0, 4); + +// From an iterable +var iterable = function*(){ yield* [1,2,3]; }(); +var float64 = new Float64Array(iterable); +// Float64Array[1, 2, 3] +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + + + +<p>{{Compat("javascript.builtins.Float64Array")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript typed arrays</a></li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("DataView")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/function/apply/index.html b/files/pt-br/web/javascript/reference/global_objects/function/apply/index.html new file mode 100644 index 0000000000..a51af3db97 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/function/apply/index.html @@ -0,0 +1,249 @@ +--- +title: Function.prototype.apply() +slug: Web/JavaScript/Reference/Global_Objects/Function/apply +tags: + - Funções + - JavaScript + - Métodos +translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>apply()</strong></code> chama uma função com um dado valor <code>this </code>e <code>arguments </code>providos como uma array (ou um objeto parecido com um array).</p> + +<div class="note"> +<p><strong>Nota:</strong> A sintaxe desta função é quase idêntica a essa da {{jsxref("Function.call", "call()")}}, a diferença é que <code>call()</code> aceita uma <strong> lista de </strong><strong style="background-color: rgba(231, 228, 157, 0.247059); color: rgba(0, 0, 0, 0.65098); font-style: italic;">argumentos</strong>, enquanto <code>apply()</code> aceita um<strong> array de argumentos</strong>.</p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>fun</var>.apply(<var>thisArg, </var>[<var>argsArray</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>thisArg</code></dt> + <dd> + <p>O valor de <code>this</code> é fornecido para a chamada de <em>fun. </em>Note que isso talvez não seja o valor real visto pelo método: se um método é uma função em código {{jsxref("Functions/Strict_mode", "non-strict mode", "", 1)}} , {{jsxref("null")}} e {{jsxref("undefined")}} serão substituidos com o objeto global, e os valores primitivos serão embalados.</p> + </dd> + <dt><code>argsArray</code></dt> + <dd>Um objeto parecido com um array (array-like), especificando os argumentos com os quais <em>fun </em>deve ser chamado, ou {{jsxref("null")}} ou {{jsxref("undefined")}} se não houverem argumentos que possam ser passados para a função. Começando com ECMAScript5 esses argumentos podem ser um objeto genérico array-like ao invés de um array. Veja abaixo a informação de {{anch("Browser_compatibility", "compatibilidade de browsers")}}.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Você pode atribuir um objeto <code>this</code><em> </em>diferente quando chamar uma função existente. <code>this</code><em> </em>refere-se ao objeto atual, o objeto da chamada. Com <code>apply</code><em>, </em>você pode escrever um método apenas uma vez e então herdá-lo em outro objeto, sem ter que reescrever o método para o novo objeto.</p> + +<p><code>apply </code>é muito parecido com {{jsxref("Function.call", "call()")}}, exceto pelo tipo de argumentos que ele suporta. Você pode usar um array de argumentos em vez de conjunto de parâmetros nomeados. Com <code>apply, </code>você pode usar um array literal, por exemplo, <code><em>fun</em>.apply(this, ['comer', 'bananas'])</code>, ou um objeto {{jsxref("Array")}}, por exemplo f<code><em>un</em>.apply(this, new Array('comer', 'bananas')).</code></p> + +<p>Você pode também usar {{jsxref("Functions/arguments", "arguments")}} para o parâmetro <code>argsArray.</code> <code>arguments </code>é uma variável local de uma função. Ele pode ser utilizado para todos os argumentos não especificados do objeto chamado. Assim, você não tem que saber os argumentos do objeto chamado quando você usa o método <code>apply</code>. Você pode usar <code>arguments </code>para passar todos os argumentos para o objeto da chamada. O objeto chamado fica então responsável por manipular os argumentos.</p> + +<p>Desde a 5a versão do ECMAScript você pode utilizar qualquer tipo de objeto que é parecido com um array (array-like), então na prática isso significa que ele vai ter uma propriedade <code>length </code>e propriedades inteiras no intervalor (<code>0... length</code>). Como um exemplo, você pode agora usar um {{domxref("NodeList")}} ou um objeto personalizado como <code>{ 'length': 2, '0': 'comer', '1': 'bananas' }</code>.</p> + +<p>{{note("Muitos navegadores, incluindo o Chrome 14 e o Internet Explorer 9, ainda não aceitam objetos parecidos com array e irão lançar uma exceção.")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_apply_para_cadeia_de_construtores">Usando <code>apply</code> para cadeia de construtores</h3> + +<p>Você pode usar <code>apply </code>para encadear {{jsxref("Operators/new", "construtores", "", 1)}} em um objeto, similar ao Java. No exemplo seguinte nós iremos criar um método de {{jsxref("Global_Objects/Function", "Função")}} global chamado <code>construct, </code>que fará você capaz de usar um objeto parecido com um array com um construtor ao invés de uma lista de argumentos</p> + +<pre class="brush: js">Function.prototype.construct = function (aArgs) { + var oNew = Object.create(this.prototype); + this.apply(oNew, aArgs); + return oNew; +}; +</pre> + +<div class="note"> +<p><strong>Note:</strong> O método <code>Object.create()</code> usado acima é relativamente novo. Para um método alternativo utilizando closures, por favor considere a seguinte alternativa.</p> + +<pre class="brush: js">Function.prototype.construct = function(aArgs) { + var fConstructor = this, fNewConstr = function() { fConstructor.apply(this, aArgs); }; + fNewConstr.prototype = fConstructor.prototype; + return new fNewConstr(); +};</pre> +</div> + +<p>Exemplo de uso:</p> + +<pre class="brush: js">function MyConstructor() { + for (var nProp = 0; nProp < arguments.length; nProp++) { + this['property' + nProp] = arguments[nProp]; + } +} + +var myArray = [4, 'Hello world!', false]; +var myInstance = MyConstructor.construct(myArray); + +console.log(myInstance.property1); // logs 'Hello world!' +console.log(myInstance instanceof MyConstructor); // logs 'true' +console.log(myInstance.constructor); // logs 'MyConstructor' +</pre> + +<div class="note"> +<p><strong>Nota:</strong> Este método não nativo <code>Function.construct </code>não irá funcionar com alguns construtores nativos (como {{jsxref("Date")}}, por exemplo). Nestes casos você tem que usar o método {{jsxref("Function.prototype.bind")}} (por exemplo, imagine ter um array como o seguinte, para ser usado com o construtor {{jsxref("Global_Objects/Date", "Date")}}: <code>[2012, 11, 4]</code>; Neste caso você tem que escrever algom como: <code>new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))() - </code>de qualquer maneira essa não é a melhor forma de fazer as coisas e provavelmente não deve ser utilizado em qualquer ambiente de produção</p> +</div> + +<h3 id="Usando_apply_e_funções_embutidas">Usando <code>apply</code> e funções embutidas</h3> + +<p>A forma inteligente com que <code>apply</code> é utilizado permite à você usar funções nativas que de outra forma provavelmente teriam que ser escritas iterando sobre um array de valores. Aqui, como exemplo, iremos utilizar <code>Math.max</code>/<code>Math.min</code> para achar o valor máximo/mínimo value em um array.</p> + +<pre class="brush: js">/* número min/max em um array */ +var numbers = [5, 6, 2, 3, 7]; + +/* utilizando Math.min/Math.max apply */ +var max = Math.max.apply(null, numbers); /* Isso está prestes a ser igual a Math.max(numbers[0], ...) + ou Math.max(5, 6, ...) */ +var min = Math.min.apply(null, numbers); + +/* vs. algoritmo simples baseado em loop */ +max = -Infinity, min = +Infinity; + +for (var i = 0; i < numbers.length; i++) { + if (numbers[i] > max) { + max = numbers[i]; + } + if (numbers[i] < min) { + min = numbers[i]; + } +} +</pre> + +<p>Mas tome cuidado: ao utilizar o <code>apply</code> desta forma, você corre o risco de exceder o limite de argumentos do JavaScript. As consequências de fazer applying em uma função com muitos argumentos (pense em algo como dezenas de centenas de argumentos) varia de acordo com os engines (JavaScriptCore tem um <a class="link-https" href="https://bugs.webkit.org/show_bug.cgi?id=80797">limite de argumentos de 65536</a> hard-coded), visto que o limite (na verdade, até mesmo a natureza de qualquer comportamento de um stack excessivamente grande) não é especificado. Algumas engines irão jogar uma excessão. De uma forma mais incisiva, outras engines irão limitar de forma arbitrária o número de argumentos que poderção ser aplicados à função. (Para ilustrar esse último caso: se uma engine dessas tem um limite de quatro argumentos [obviamente, os limites atuais são significativamente maiores], isso seria como se os argumentos <code>5, 6, 2, 3</code> do exemplo anterior fossem passados ao <code>apply</code>, ao invés do array completo.) Se o valor do seu array puder crescer à casa das dezenas de centenas, use uma estratégia híbrida: aplique suas funções em cada bloco de array por vez:</p> + +<pre class="brush: js">function minOfArray(arr) { + var min = Infinity; + var QUANTUM = 32768; + + for (var i = 0, len = arr.length; i < len; i += QUANTUM) { + var submin = Math.min.apply(null, arr.slice(i, Math.min(i + QUANTUM, len))); + min = Math.min(submin, min); + } + + return min; +} + +var min = minOfArray([5, 6, 2, 3, 7]); +</pre> + +<h3 id="Usando_apply_em_monkey-patching">Usando apply em "monkey-patching"</h3> + +<p>Apply pode ser a melhor forma de monkey-patch uma função nativa do Firefox, ou de bibliotecas em JS. Dada uma função <code>someobject.foo</code>, você poderá modificar a função de uma maneira hackeresca, como por exemplo:</p> + +<pre class="brush: js">var originalfoo = someobject.foo; +someobject.foo = function() { + // Faça coisas antes de chamar a função + console.log(arguments); + // Chama a função como se ela estivesse sido chamada normalmente: + originalfoo.apply(this, arguments); + // Rode as coisas que vem depois, aqui. +} +</pre> + +<p>Esse método é especialmente útil quando você quer fazer debug de eventos, ou interagir com algo que não tem nenhuma API como os diversos eventos <code>.on([event]...</code> events, por exemplo aqueles utilizáveis no <a href="/en-US/docs/Tools/Page_Inspector#Developer_API">Devtools Inspector</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>ECMAScript 3º Edição.</td> + <td>Padrão</td> + <td>Definição inicial, implementado no JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3.4.3', 'Function.prototype.apply')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}}</td> + <td>{{Spec2('ES6')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>ES 5.1 objetos genéricos parecidos com array como {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("2.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Funcionalidade</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> + <tr> + <td>ES 5.1 objetos genéricos parecidos com array como {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("2.0")}}</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>Objeto {{jsxref("Functions/arguments", "arguments")}}</li> + <li>{{jsxref("Function.prototype.bind()")}}</li> + <li>{{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Functions", "Funções e escopo de funções", "", 1)}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/function/arguments/index.html b/files/pt-br/web/javascript/reference/global_objects/function/arguments/index.html new file mode 100644 index 0000000000..6fac474a16 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/function/arguments/index.html @@ -0,0 +1,130 @@ +--- +title: Function.arguments +slug: Web/JavaScript/Reference/Global_Objects/Function/arguments +translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>A propriedade <code><strong><em>function</em>.arguments</strong></code> diz respeito a um objeto tipo array (array-like object) correspondente aos argumentos passados para uma função. Use somente a variável {{jsxref("Functions/arguments", "arguments")}} em vez disso.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>A sintaxe <code><em>function</em>.arguments</code> está obsoleta. A forma recomendada de acessar o objeto {{jsxref("Functions/arguments", "arguments")}} disponível dentro das funções, é simplesmente referenciar a variável {{jsxref("Functions/arguments", "arguments")}}.</p> + +<p>No caso de recursão, ou seja, uma função f aparecer várias vezes na pilha de chamadas, o valor de <code>f.arguments</code> representa os argumentos correspondentes a invocação mais recente da função.</p> + +<p>O valor da propriedade arguments é normalmente nulo (<code>null</code>) se não houver nenhuma invocação pendente da função em andamento (ou seja, a função foi chamada mas ainda não retornou).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js">function f(n) { g(n - 1); } + +function g(n) { + console.log('before: ' + g.arguments[0]); + if (n > 0) { f(n); } + console.log('after: ' + g.arguments[0]); +} + +f(2); + +console.log('returned: ' + g.arguments); + +// Output + +// before: 1 +// before: 0 +// after: 0 +// after: 1 +// returned: null +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definiçao inicial. Implementado em JavaScript 1.0. Obsoleto em favor de {{jsxref("Functions/arguments", "arguments")}} em ES3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-10.6', 'arguments object')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>{{jsxref("Functions/arguments", "arguments")}} object</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-arguments-object', 'arguments object')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>{{jsxref("Functions/arguments", "arguments")}} object</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-arguments-object', 'arguments object')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>{{jsxref("Functions/arguments", "arguments")}} object</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>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="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Functions/arguments", "arguments")}} object</li> + <li>{{jsxref("Functions", "Functions and function scope", "", 1)}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/function/arity/index.html b/files/pt-br/web/javascript/reference/global_objects/function/arity/index.html new file mode 100644 index 0000000000..93e4fb75b5 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/function/arity/index.html @@ -0,0 +1,78 @@ +--- +title: Function.arity +slug: Web/JavaScript/Reference/Global_Objects/Function/arity +tags: + - Função + - JavaScript + - Não implementado + - Obsoleto + - Propriedade +translation_of: Archive/Web/JavaScript/Function.arity +--- +<div>{{JSRef("Global_Objects", "Function")}} {{obsolete_header}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p class="note">A propriedade <code><strong>arity</strong></code> é usada para retornar o número de argumentos esperados por uma função, entretanto, ela não existe mais e foi substituida pela propriedade {{jsxref("Function.prototype.length")}}.</p> + +<h2 id="Especificações">Especificações</h2> + +<p>Implementada no JavaScript 1.2. Depreciada no JavaScript 1.4.</p> + +<h2 id="Compatibilidade_com_navegadores">Compatibilidade com 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>{{CompatNo}}</td> + <td>{{CompatNo}}</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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("Function.prototype.length")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/function/bind/index.html b/files/pt-br/web/javascript/reference/global_objects/function/bind/index.html new file mode 100644 index 0000000000..10f3ea1b8c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/function/bind/index.html @@ -0,0 +1,309 @@ +--- +title: Function.prototype.bind() +slug: Web/JavaScript/Reference/Global_Objects/Function/bind +translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>bind()</strong></code> cria uma nova função que, quando chamada, tem sua palavra-chave <code>this</code> definida com o valor fornecido, com uma sequência determinada de argumentos precedendo quaisquer outros que sejam fornecidos <span id="result_box" lang="pt"><span>quando</span> <span>a nova</span> <span>função é chamada</span></span>.</p> + +<p>{{EmbedInteractiveExample("pages/js/function-bind.html", "taller")}}</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>function</var>.bind(<var>thisArg</var>[, <var>arg1</var>[, <var>arg2</var>[, ...]]])</code></pre> + +<h3 id="Parâmetros"><span class="short_text" id="result_box" lang="es"><span>Parâmetros</span></span></h3> + +<dl> + <dt><code>thisArg</code></dt> + <dd><span id="result_box" lang="pt"><span>O valor a ser</span> <span>passado como </span><span>parâmetro <code>this</code> para</span> <span>a função de destino</span> <span>quando a função</span> <span>vinculada</span> <span>é chamada.</span> <span>O</span> <span>valor é ignorado</span> <span>se a função</span> <span>ligada é</span> <span>construída usando o</span></span> operador {{jsxref("Operators/new", "new")}}.</dd> + <dt><code>arg1, arg2, ...</code></dt> + <dd><span id="result_box" lang="pt"><span>Argumentos que precedem outros</span></span><span lang="pt"> <span>argumentos fornecidos</span> <span>para a função</span> vinculada <span>ao invocar</span> <span>a função de destino</span><span>.</span></span></dd> +</dl> + +<h3 id="Valor_de_retorno"><span lang="pt"><span>Valor de retorno</span></span></h3> + +<p><span lang="pt"><span>Uma cópia da função fornecida com o valor <code>this</code> especificado e argumentos iniciais.</span></span></p> + +<h2 id="Descrição">Descrição</h2> + +<p>A função <code>bind()</code> cria uma nova <strong>função vinculada</strong> (<em>bound function</em>). Uma função vinculada é um <strong>objeto de função exótico</strong> (termo da <strong>ECMAScript 2015</strong>) que encapsula o objeto de função original. Chamar uma função vinculada geralmente resulta na execução de sua <strong>função encapsulada</strong>.</p> + +<p>Uma função vinculada tem as seguintes propriedades internas:</p> + +<ul> + <li><strong>[[BoundTargetFunction]]</strong> - o objeto de função encapsulado;</li> + <li><strong>[[BoundThis]]</strong> - o valor que sempre é passado como <code>this</code> quando se chama a função encapsulada;</li> + <li><strong>[[BoundArguments]]</strong> - uma lista de valores cujos elementos são usados como os primeiros argumentos para qualquer chamada da função encapsulada;</li> + <li><strong>[[Call]]</strong> - executa código associado com este objeto. Invocado através de uma expressão de chamada de função. Os argumentos para o método interno são um valor <code>this</code> e uma lista contendo os argumentos passados para a função por uma expressão de chamada.</li> +</ul> + +<p>Quando a função vinculada é chamada, ela chama seu método interno <strong>[[Call]]</strong> na <strong>[[BoundTargetFunction]],</strong> na forma <code>Call(boundThis, args)</code>, onde <code>boundThis</code> é <strong>[[BoundThis]]</strong> e <code>args</code> é <strong>[[BoundArguments]]</strong> seguido pelos argumentos passados pela chamada de função.</p> + +<p>Uma função vinculada também pode ser construída usando-se o operador {{jsxref("Operators/new", "new")}}; ao fazê-lo, o resultado é o mesmo que seria se a função alvo tivesse sido construída. O valor de <code>this</code> fornecido é ignorado, porém os argumentos precedentes são fornecidos à função emulada.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Criando_uma_função_vinculada">Criando uma função vinculada</h3> + +<p><span id="result_box" lang="pt"><span>O uso</span> <span>mais simples de</span> <code><span>bind()</span></code> <span class="alt-edited">é fazer com que</span> <span>uma função que</span><span>, independentemente da</span><span> chamada,</span> <span>é chamada com</span> <span>um determinado</span> valor <code><span>this</span></code></span>.<span id="result_box" lang="pt"><span> Um erro comum</span> <span>para </span><span>programadores JavaScript</span> novatos <span>é extrair</span> <span>um método</span> <span>de um objeto e</span></span>, <span id="result_box" lang="pt"><span>em seguida, </span> <span>chamar essa função</span> <span>e esperar que ele</span> <span>use</span> <span>o objeto original</span> <span>como</span> o seu <code><span>this</span></code> <span>(por exemplo,</span> <span>usando</span> <span>esse método</span> <span>num código baseado em</span></span> <em>callback</em><span lang="pt"><span>)</span><span>.</span> <span>Sem</span> <span>a devida atenção</span><span>,</span> <span>no entanto</span><span>,</span> <span>o objeto original</span> <span>é normalmente</span> <span>perdido</span><span>.</span> <span>Criar</span> <span>uma função</span> <span class="alt-edited">vinculada</span> <span>a partir da função</span><span>,</span> <span>usando o objeto</span> <span>original,</span> <span>resolve perfeitamente</span> <span>esse</span> <span>problema:</span></span></p> + +<pre class="brush: js">this.x = 9; //this aqui se refere ao objeto global "window" do navegador +var module = { + x: 81, + getX: function() { return this.x; } +}; + +module.getX(); // 81 + +var retrieveX = module.getX; +retrieveX(); +// retorna 9 - a função foi invocada no escopo global + +// Criando uma nova função com 'this' vinculada ao módulo +// Programadores novatos podem confundir a variável x +// global com a propriedade x do módulo +var boundGetX = retrieveX.bind(module); +boundGetX(); // 81 +</pre> + +<h3 id="Funções_parcialmente_aplicadas">Funções parcialmente aplicadas</h3> + +<p>O próximo uso mais simples de <code>bind()</code> é criar uma função com argumentos iniciais pré-especificados. Esses argumentos (caso existam) acompanham o valor <code>this</code> fornecido e então são inseridos no início dos argumentos passados para a função alvo, seguidos pelos argumentos passados para a função vinculada, sempre que a função vinculada é chamada.</p> + +<pre class="brush: js">function list() { + return Array.prototype.slice.call(arguments); +} + +var list1 = list(1, 2, 3); // [1, 2, 3] + +// Cria uma função com um argumento principal predefinido +var leadingThirtysevenList = list.bind(null, 37); + +var list2 = leadingThirtysevenList(); +// [37] + +var list3 = leadingThirtysevenList(1, 2, 3); +// [37, 1, 2, 3] +</pre> + +<h3 id="Com_setTimeout">Com <code>setTimeout</code></h3> + +<p>Por padrão, dentro de {{domxref("window.setTimeout()")}} a palavra-chave <code>this</code> vai ser definida com o objeto {{ domxref("window") }} (ou com o objeto <code>global</code>). Ao trabalhar com métodos de classes que requerem que <code>this</code> se refira à instâncias de classes, você pode vincular <code>this</code> explicitamente à função de <em>callback</em>, de modo a manter a instância.</p> + +<pre class="brush: js">function LateBloomer() { + this.petalCount = Math.ceil(Math.random() * 12) + 1; +} + +// Declarar bloom depois de um intervalo de 1 segundo +LateBloomer.prototype.bloom = function() { + window.setTimeout(this.declare.bind(this), 1000); +}; + +LateBloomer.prototype.declare = function() { + console.log('I am a beautiful flower with ' + + this.petalCount + ' petals!'); +}; + +var flower = new LateBloomer(); +flower.bloom(); +// depois de 1 segundo, ativa o método 'declare'</pre> + +<h3 id="Funções_vinculadas_usadas_como_construtores">Funções vinculadas usadas como construtores</h3> + +<div class="warning"> +<p><strong>Aviso:</strong> Esta seção demonstra capacidades do JavaScript e documenta alguns casos de borda do método <code>bind()</code>. Os métodos mostrados abaixo não são os melhores jeitos de se fazer as coisas e provavelmente não deveriam ser usados em nenhum ambiente produtivo.</p> +</div> + +<p>Funções vinculadas são automaticamente adequadas para uso com o operador {{jsxref("Operators/new", "new")}} para construir novas instâncias criadas pela função alvo. Quando uma função vinculada é usada para construir um valor, o <code>this</code> fornecido é ignorado. Porém, argumentos fornecidos ainda são prefixados à chamada do construtor:</p> + +<pre class="brush: js">function Point(x, y) { + this.x = x; + this.y = y; +} + +Point.prototype.toString = function() { + return this.x + ',' + this.y; +}; + +var p = new Point(1, 2); +p.toString(); // '1,2' + +// não suportado no polyfill abaixo, +// funciona bem com o bind nativo: + +var YAxisPoint = Point.bind(null, 0/*x*/); + +var emptyObj = {}; +var YAxisPoint = Point.bind(emptyObj, 0/*x*/); + +var axisPoint = new YAxisPoint(5); +axisPoint.toString(); // '0,5' + +axisPoint instanceof Point; // true +axisPoint instanceof YAxisPoint; // true +new Point(17, 42) instanceof YAxisPoint; // true +</pre> + +<p>Note que você não precisa fazer nada de especial para criar uma função vinculada para usar com {{jsxref("Operators/new", "new")}}. O corolário é que você não precisa fazer nada de especial para criar uma função vinculada que será chamada de forma clara, mesmo que você preferisse que a função vinculada fosse somente chamada usando-se {{jsxref("Operators/new", "new")}}.</p> + +<pre class="brush: js">// Exemplo pode ser executado diretamente no seu console JavaScript +// ...continuando o exemplo acima + +// Ainda pode ser chamada como uma função normal +// (apesar de que isso geralmente não é desejado) +YAxisPoint(13); + +emptyObj.x + ',' + emptyObj.y; +// > '0,13' +</pre> + +<p>Se você quer suportar o uso de uma função vinculada somente através de {{jsxref("Operators/new", "new")}}, ou somente a chamando, a função alvo deve impor essa restrição.</p> + +<h3 id="Criando_atalhos">Criando atalhos</h3> + +<p><code>bind()</code> itambém é útil em casos onde você quer criar um atalho para uma função que requer um valor específico de <code>this</code>.</p> + +<p>Tome por exemplo {{jsxref("Array.prototype.slice")}}, que você quer usar para converter um objeto <em>array-like</em> em um vetor verdadeiro. Você poderia criar um atalho assim:</p> + +<pre class="brush: js">var slice = Array.prototype.slice; + +// ... + +slice.apply(arguments); +</pre> + +<p>Com <code>bind()</code>, isso pode ser simplificado. No seguinte trecho de código, <code>slice</code> é uma função vinculada à função {{jsxref("Function.prototype.apply()", "apply()")}} de {{jsxref("Function.prototype")}}, com o valor <code>this</code> definido com a função {{jsxref("Array.prototype.slice()", "slice()")}} de {{jsxref("Array.prototype")}}. Isso significa que chamadas adicionais de <code>apply()</code> podem ser eliminadas:</p> + +<pre class="brush: js">// mesmo que "slice" no exemplo anterior +var unboundSlice = Array.prototype.slice; +var slice = Function.prototype.apply.bind(unboundSlice); + +// ... + +slice(arguments); +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>A função <code>bind</code> é uma adição à ECMA-262, 5ª. edição; como tal, pode não estar presente em todos os navegadores. Você pode contornar isso parcialmente inserindo o seguinte código no começo de seus <em>scripts</em>, permitindo o uso de muita parte da funcionalidade de <code>bind()</code> em implementações que não a suportam nativamente.</p> + +<pre class="brush: js">if (!Function.prototype.bind) { + Function.prototype.bind = function(oThis) { + if (typeof this !== 'function') { + // mais próximo possível da função interna + // IsCallable da ECMAScript 5 + throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable'); + } + + var aArgs = Array.prototype.slice.call(arguments, 1), + fToBind = this, + fNOP = function() {}, + fBound = function() { + return fToBind.apply(this instanceof fNOP + ? this + : oThis, + aArgs.concat(Array.prototype.slice.call(arguments))); + }; + + fNOP.prototype = this.prototype; + fBound.prototype = new fNOP(); + + return fBound; + }; +} +</pre> + +<p>Algumas das muitas diferenças (é bem possível que haja outras, já que esta lista não pretende seriamente ser completa) entre este algoritmo e o algoritmo especificado são:</p> + +<ul> + <li>Esta implementação parcial depende dos métodos internos {{jsxref("Array.prototype.slice()")}}, {{jsxref("Array.prototype.concat()")}}, {{jsxref("Function.prototype.call()")}} e {{jsxref("Function.prototype.apply()")}} possuírem seus valores originais.</li> + <li>Esta implementação parcial cria funções que não tem um {{jsxref("Function.caller", "caller")}} imutável como "mecanismo de defesa" e propriedades <code>arguments</code> que lançam um {{jsxref("Global_Objects/TypeError", "TypeError")}} ao usar <em>get</em>, <em>set</em>, ou ao deletar. (Isto pode ser adicionado se a implementação suporta {{jsxref("Object.defineProperty")}}, ou parcialmente implementado sem um comportamento <em>throw-on-delete</em> se a implementação suporta as extensões {{jsxref("Object.defineGetter", "__defineGetter__")}} e {{jsxref("Object.defineSetter", "__defineSetter__")}})</li> + <li>Esta implementação parcial cria funções que tem uma propriedade <code>prototype</code>. (Funções vinculadas apropriadas não a tem.)</li> + <li>Esta implementação parcial cria funções vinculadas cuja propriedade {{jsxref("Function.length", "length")}} não cumpre com a regra da ECMA-262: cria funções com comprimento zero, quando uma implementação completa, dependendo do comprimento da função alvo e do número de argumentos pre-especificados, pode retornar um comprimento não-nulo.</li> +</ul> + +<p>Se você escolher utilizar esta implementação parcial, <strong>você não deve confiar em casos onde o comportamento é diferente da ECMA-262, 5ª. edição!</strong> Porém, com algum cuidado (e talvez com modificação adicional para atender necessidades específicas), esta implementação parcial pode ser uma ponte razoável para quando <code>bind()</code> for amplamente implementada de acordo com a especificação.</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.3.4.5', 'Function.prototype.bind')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definição inicial. Implementada no JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function.prototype.bind', 'Function.prototype.bind')}}</td> + <td>{{Spec2('ES6')}}</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>{{CompatChrome("7")}}</td> + <td>{{CompatGeckoDesktop("2")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("11.60")}}</td> + <td>{{CompatSafari("5.1")}}</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>{{CompatAndroid("4.0")}}</td> + <td>{{CompatChrome("1")}}</td> + <td>{{CompatGeckoMobile("2")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatOperaMobile("11.5")}}</td> + <td>{{CompatSafari("6.0")}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Function.prototype.apply()")}}</li> + <li>{{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Functions", "Functions", "", 1)}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/function/call/index.html b/files/pt-br/web/javascript/reference/global_objects/function/call/index.html new file mode 100644 index 0000000000..a0356bf585 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/function/call/index.html @@ -0,0 +1,194 @@ +--- +title: Function.prototype.call() +slug: Web/JavaScript/Reference/Global_Objects/Function/call +tags: + - Função + - JavaScript + - Método(2) +translation_of: Web/JavaScript/Reference/Global_Objects/Function/call +--- +<div>{{JSRef("Global_Objects", "Function")}}</div> + +<h2 id="Introdução">Introdução</h2> + +<p>O método <code><strong>call()</strong></code> invoca uma função com um dado valor <code>this</code> e argumentos passados individualmente.</p> + +<div class="note"> +<p><strong>Nota:</strong> Apesar de a sintaxe desta função ser quase idêntica à de {{jsxref("Function.prototype.apply", "apply()")}}, a principal diferença é que <code>call()</code> aceita uma <strong>lista de argumentos</strong>, enquanto <code>apply()</code> aceita <strong>um único array de argumentos.</strong></p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>fun</var>.call(<var>thisArg</var>[, <var>arg1</var>[, <var>arg2</var>[, ...]]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>thisArg</code></dt> + <dd>O valor de <code>this</code> proveu a chamada para <em><code>fun</code></em>. Note que <code>this</code> pode não ser o valor atual visto pelo método: se esse método é uma função em {{jsxref("Functions_and_function_scope/Strict_mode", "non-strict mode", "", 1)}} code, {{jsxref("Global_Objects/null", "null")}} e {{jsxref("Global_Objects/undefined", "undefined")}} serão reescritos com o objeto global, e valores primitivos serão encaixados.</dd> + <dt><code>arg1, arg2, ...</code></dt> + <dd>Argumentos para o objeto.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Você pode atribuir um objeto <code>this</code> diferente quando executar uma função existente. <code>this</code> refere-se ao objeto atual, o objeto em execução. Com <code>call</code>, você pode escrever um método uma vez e então herdá-lo em outro objeto, sem ter que reescrever o método para o novo objeto.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Exemplo_Usando_call_para_encadear_construtores_para_um_objeto">Exemplo: Usando <code>call</code> para encadear construtores para um objeto</h3> + +<p>Você pode usar <code>call</code> para encadear construtores para um objeto, similar ao Java. No seguinte exemplo, o construtor do objeto <code>Product</code> é definido com dois parâmetros, <code>name</code> e <code>price</code>. Outras duas funções <code>Food</code> e <code>Toy</code> executam <code>Product</code> passando <code>this,</code> <code>name</code> e <code>price</code>. O Produto inicializa as propriedades <code>name</code> e <code>price</code>, ambos definem o <code>category</code>.</p> + +<pre class="brush: js">function Product(name, price) { + this.name = name; + this.price = price; + + if (price < 0) { + throw RangeError('Cannot create product ' + + this.name + ' with a negative price'); + } + + return this; +} + +function Food(name, price) { + Product.call(this, name, price); + this.category = 'food'; +} + +Food.prototype = Object.create(Product.prototype); + +function Toy(name, price) { + Product.call(this, name, price); + this.category = 'toy'; +} + +Toy.prototype = Object.create(Product.prototype); + +var cheese = new Food('feta', 5); +var fun = new Toy('robot', 40); +</pre> + +<h3 id="Exemplo_Usando_o_call_para_chamar_funções_anônimas">Exemplo: Usando o <code>call</code> para chamar funções anônimas</h3> + +<p>Neste exemplo, criamos uma função anônima que usa o <code>call</code> para executá-lo em todos os objetos em um array(vetor). O principal propósito da função anônima aqui é adicionar uma função print para todo o objeto, que está disponível para imprimir o índice correto do objeto no array. Não foi necessário passar o valor do objeto como <code>this</code> , mas isso foi feito apenas para explicação.</p> + +<pre class="brush: js">var animais = [ + { especie: 'Lion', nome: 'King' }, + { especie: 'Whale', nome: 'Fail' } +]; + +for (var i = 0; i < animais.length; i++) { + (function(i) { + this.print = function() { + console.log('#' + i + ' ' + this.especie + + ': ' + this.nome); + } + this.print(); + }).call(animais[i], i); +} +</pre> + +<h3 id="Usando_call_para_chamar_a_função_e_especificar_o_contexto_de_'this'">Usando <code>call</code> para chamar a função e especificar o contexto de 'this'</h3> + +<p>No exemplo abaixo, quando vamos chamar a apresentação, o valor de this será associado ao objeto i.<br> + </p> + +<pre><code>function apresentacao() { + var resposta = [this.pessoa, 'é um excelente', this.funcao].join(' '); + console.log(resposta); +} + +var i = { + pessoa: 'Douglas Crockford', funcao: 'Desenvolvedor Javascript' +}; + +apresentacao.call(i); // Douglas Crockford é um excelente Desenvolvedor Javascript</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3.4.4', 'Function.prototype.call')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function.prototype.call', 'Function.prototype.call')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</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>{{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>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>{{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("Function.prototype.bind()")}}</li> + <li>{{jsxref("Function.prototype.apply()")}}</li> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript">Introdução à JavaScript Orientado à Objetos</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/function/caller/index.html b/files/pt-br/web/javascript/reference/global_objects/function/caller/index.html new file mode 100644 index 0000000000..c380d89d7f --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/function/caller/index.html @@ -0,0 +1,129 @@ +--- +title: Function.caller +slug: Web/JavaScript/Reference/Global_Objects/Function/caller +tags: + - Função + - JavaScript + - Non-standard + - Propriedades +translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>A propriedade <code><strong><em>function</em>.caller</strong></code> retorna a função que invocou a função especificada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se a função <code>f</code> foi invocada pelo codigo mais alto nível, o valor de <code>f.caller</code> é {{jsxref("null")}}, caso contrario, o valor será a função a qual invocou <code>f</code>.</p> + +<p>Esta propriedade substitui a propriedade obsoleta {{jsxref("Functions/arguments/caller", "arguments.caller")}} do objeto {{jsxref("Functions/arguments", "arguments")}}.</p> + +<p>A propriedade especial <code>__caller__</code>, a qual retornou o objeto de ativação do chamador, permitindo assin reconstruir o stack, foi removido por motivo de segurança.</p> + +<h3 id="Notas">Notas</h3> + +<p>Note que no caso de recurção, você não pode reconstruir o stack de chamadas usando esta propriedade. Considere:</p> + +<pre class="brush: js">function f(n) { g(n - 1); } +function g(n) { if (n > 0) { f(n); } else { stop(); } } +f(2); +</pre> + +<p>No momento em que <code>stop()</code> é chamado o stack será:</p> + +<pre class="brush: js">f(2) -> g(1) -> f(1) -> g(0) -> stop() +</pre> + +<p>O seguinte é true:</p> + +<pre class="brush: js">stop.caller === g && f.caller === g && g.caller === f +</pre> + +<p>então se você tentou recuperar o stack trace na função <code>stop()</code> assim:</p> + +<pre class="brush: js">var f = stop; +var stack = 'Stack trace:'; +while (f) { + stack += '\n' + f.name; + f = f.caller; +} +</pre> + +<p>o loop nunca irá parar.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Verificando_o_valor_da_propriedade_caller_de_uma_função">Verificando o valor da propriedade <code>caller</code> de uma função</h3> + +<p>O código a seguir verifica o valor da propriedade <code>caller</code> de uma função.</p> + +<pre class="brush: js">function myFunc() { + if (myFunc.caller == null) { + return 'The function was called from the top!'; + } else { + return 'This function\'s caller was ' + myFunc.caller; + } +} +</pre> + +<h2 id="Especificações">Especificações</h2> + +<p>Não faz parte de nenhuma especificação. Implementado no JavaScript 1.5.</p> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os 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>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("1.0")}}</td> + <td>8.0</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>{{CompatGeckoMobile("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>Implementation bug for SpiderMonkey {{bug(65683)}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/function/displayname/index.html b/files/pt-br/web/javascript/reference/global_objects/function/displayname/index.html new file mode 100644 index 0000000000..5cf33d8080 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/function/displayname/index.html @@ -0,0 +1,80 @@ +--- +title: Function.displayName +slug: Web/JavaScript/Reference/Global_Objects/Function/displayName +tags: + - Função + - JavaScript + - Non Standard + - Propriedade +translation_of: Web/JavaScript/Reference/Global_Objects/Function/displayName +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>A propriedade <code><strong><em>function</em>.displayName</strong></code> retorna o nome de exibição da função.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Quando definida, a propriedade <code>displayName</code> retorna o nome de exibição da função.</p> + +<pre class="brush: js">function doSomething() {} + +console.log(doSomething.displayName); // "undefined" + +var popup = function(content) { console.log(content); }; + +popup.displayName = 'Show Popup'; + +console.log(popup.displayName); // "Show Popup" +</pre> + +<p>Você pode definir uma função com uma nome de exibição em um {{jsxref("Functions", "function expression", "", 1)}}:</p> + +<pre class="brush: js">var object = { + someMethod: function() {} +}; + +object.someMethod.displayName = 'someMethod'; + +console.log(object.someMethod.displayName); // logs "someMethod" + +try { someMethod } catch(e) { console.log(e); } +// ReferenceError: someMethod is not defined +</pre> + +<p>Você pode mudar dinamicamente o<code>displayName</code> de uma função:</p> + +<pre class="brush: js">var object = { + // anonymous + someMethod: function(value) { + arguments.callee.displayName = 'someMethod (' + value + ')'; + } +}; + +console.log(object.someMethod.displayName); // "undefined" + +object.someMethod('123') +console.log(object.someMethod.displayName); // "someMethod (123)" +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<p>Geralmente, é preferida por consoles e perfis em vez de {{jsxref("Function.name", "func.name")}} mostrar o nome de uma função.</p> + +<p>Entrando com o seguinte em um console, isso deverá mostrar algo como "<code>function My Function()</code>":</p> + +<pre class="brush: js">var a = function() {}; +a.displayName = 'My Function'; + +a; // "function My Function()"</pre> + +<h2 id="Especificações">Especificações</h2> + +<p>Não faz parte de denhuma especificação.</p> + +<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2> + +<div> +<div class="hidden">A tabela de compatibilidade nessa página é gerada de dados estruturados. Se você gostaria de contribuir com os dados, por favor veja <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</div> + +<p>{{Compat("javascript.builtins.Function.displayName")}}</p> +</div> diff --git a/files/pt-br/web/javascript/reference/global_objects/function/index.html b/files/pt-br/web/javascript/reference/global_objects/function/index.html new file mode 100644 index 0000000000..fa6e32e2b1 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/function/index.html @@ -0,0 +1,234 @@ +--- +title: Function +slug: Web/JavaScript/Reference/Global_Objects/Function +tags: + - Constructor + - Function + - JavaScript + - NeedsTranslation + - TopicStub +translation_of: Web/JavaScript/Reference/Global_Objects/Function +--- +<div>{{JSRef("Global_Objects", "Function")}}</div> + +<h2 id="Summary" name="Summary"><span class="short_text" id="result_box" lang="pt"><span class="hps">Resumo</span></span></h2> + +<p>O <strong><code>construtor Function</code></strong> cria um novo objeto <code>Function</code>. Chamar o construtor diretamente pode criar funções dinamicamente, mas sofre com problemas de segurança e desempenho semelhante (mas muito menos significativo) a {{jsxref("eval")}}. No entanto, diferentemente de eval, a Função construtora cria funções que executam somente no escopo global.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code>new Function ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>arg1, arg2, ... arg<em>N</em></code></dt> + <dd>Nomes para serem usandos pela função como nomes formais de argumentos. Cada um deve ser uma string que corresponde para uma válida identidade JavaScript ou uma lista de certas strings separadas com uma <span class="short_text" id="result_box" lang="pt"><span class="hps">vírgula; por exemplo "x", "theValue". our "a,b".</span></span></dd> + <dt><code>functionBody</code></dt> + <dd>Uma string que contém as <span id="result_box" lang="pt"><span class="hps">instruções </span></span>JavaScript que <span id="result_box" lang="pt"><span class="hps">compõem </span></span><span class="short_text" id="result_box" lang="pt"><span class="hps">a definição da função.</span></span></dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Objetos <code>Function</code> criados com o construtor <code>Function</code> são <em>parseados</em> quando a função é criada. Isto é menos eficiente que criar com uma <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/function">expressão de função</a> ou um <a href="/pt-BR/docs/Web/JavaScript/Reference/Statements/function">declaração de função</a> e chamando-a dentro do seu código, porque tais funções são <em>parseadas</em> com o resto do código.</p> + +<p>Todos os argumentos passados para a função são tratados como os nomes dos indetificadores dos parâmetros na função a ser criada, na mesma ordem na qual eles foram passados.</p> + +<div class="note"> +<p><strong>Nota:</strong> Funções criadas com o construtor <code>Function não criam closures</code> para o seu contexto de criação; elas sempre são criadas no escopo global. Quando executadas, elas terão acesso apenas às suas variáveis locais ou globais, não terão acesso às variáveis do escopo na qual o construtor <code>Function</code> foi chamado. Isto é diferente de usar {{jsxref("Global_Objects/eval", "eval")}} com o código de uma expressão de função.</p> +</div> + +<p>Invocar o construtor <code>Function</code> como uma função (sem usar o operador <code>new</code>) tem o mesmo efeito de chamá-la como um construtor.</p> + +<h2 id="Propriedades_e_Métodos_da_Function">Propriedades e Métodos da <code>Function</code></h2> + +<p>O objeto global <code>Function</code> não tem métodos ou propriedades próprias, no entanto, como ela é uma função, ela herda alguns métodos e propriedades através do prototype chain do {{jsxref("Function.prototype")}}.</p> + +<h2 id="Function_prototype_object"><code>Function</code> prototype object</h2> + +<h3 id="Propriedades">Propriedades</h3> + +<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Properties')}}</div> + +<h3 id="Methods" name="Methods">Métodos</h3> + +<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Methods')}}</div> + +<h2 id="Function_instances" name="Function_instances"><code>Function</code> instances</h2> + +<p><code>Function</code> instances inherit methods and properties from {{jsxref("Function.prototype")}}. As with all constructors, you can change the constructor's prototype object to make changes to all <code>Function</code> instances.</p> + +<h2 id="Examples" name="Examples">Exemplos:</h2> + +<h3 id="Example.3A_Specifying_arguments_with_the_Function_constructor" name="Example.3A_Specifying_arguments_with_the_Function_constructor">Exemplos: Especificando argumentos com o construtor <code>Function</code></h3> + +<p>O código a seguir cria um objeto <code>Function</code> que recebe dois argumentos.</p> + +<pre class="brush: js">// O exemplo pode ser executado direto no seu console JavaScript + +// Cria uma função que recebe 2 argumentos e retorna a soma entre os dois: +var adder = new Function('a', 'b', 'return a + b'); + +// Chamada da função +adder(2, 6); +// > 8 +</pre> + +<p>Os argumentos "<code>a</code>" e "<code>b</code>" são os argumentos que serão usados no corpo da função, "<code>return a + b</code>".</p> + +<h3 id="Example_A_recursive_shortcut_to_massively_modify_the_DOM" name="Example:_A_recursive_shortcut_to_massively_modify_the_DOM">Exemplo: Um atalho recursivo para modificar o DOM em massa</h3> + +<p>Creating functions with the <code>Function</code> constructor is one of the ways to dynamically create an indeterminate number of new objects with some executable code into the global scope from a function. The following example (a recursive shortcut to massively modify the DOM) is impossible without the invocation of the <code>Function</code> constructor for each new query if you want to avoid closures.</p> + +<pre class="brush: html"><!doctype html> +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> +<title>MDN Example - a recursive shortcut to massively modify the DOM</title> +<script type="text/javascript"> +var domQuery = (function() { + var aDOMFunc = [ + Element.prototype.removeAttribute, + Element.prototype.setAttribute, + CSSStyleDeclaration.prototype.removeProperty, + CSSStyleDeclaration.prototype.setProperty + ]; + + function setSomething(bStyle, sProp, sVal) { + var bSet = Boolean(sVal), fAction = aDOMFunc[bSet | bStyle << 1], + aArgs = Array.prototype.slice.call(arguments, 1, bSet ? 3 : 2), + aNodeList = bStyle ? this.cssNodes : this.nodes; + + if (bSet && bStyle) { aArgs.push(''); } + for ( + var nItem = 0, nLen = this.nodes.length; + nItem < nLen; + fAction.apply(aNodeList[nItem++], aArgs) + ); + this.follow = setSomething.caller; + return this; + } + + function setStyles(sProp, sVal) { return setSomething.call(this, true, sProp, sVal); } + function setAttribs(sProp, sVal) { return setSomething.call(this, false, sProp, sVal); } + function getSelectors() { return this.selectors; }; + function getNodes() { return this.nodes; }; + + return (function(sSelectors) { + var oQuery = new Function('return arguments.callee.follow.apply(arguments.callee, arguments);'); + oQuery.selectors = sSelectors; + oQuery.nodes = document.querySelectorAll(sSelectors); + oQuery.cssNodes = Array.prototype.map.call(oQuery.nodes, function(oInlineCSS) { return oInlineCSS.style; }); + oQuery.attributes = setAttribs; + oQuery.inlineStyle = setStyles; + oQuery.follow = getNodes; + oQuery.toString = getSelectors; + oQuery.valueOf = getNodes; + return oQuery; + }); +})(); +</script> +</head> + +<body> + +<div class="testClass">Lorem ipsum</div> +<p>Some text</p> +<div class="testClass">dolor sit amet</div> + +<script type="text/javascript"> +domQuery('.testClass') + .attributes('lang', 'en')('title', 'Risus abundat in ore stultorum') + .inlineStyle('background-color', 'black')('color', 'white')('width', '100px')('height', '50px'); +</script> +</body> + +</html> +</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>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3', 'Function')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-objects', 'Function')}}</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">See also</h2> + +<ul> + <li>{{jsxref("Operators/function", "function Expression", "", 1)}}</li> + <li>{{jsxref("Statements/function", "function Statement", "", 1)}}</li> + <li>{{jsxref("Functions_and_function_scope", "Functions and function scope", "", 1)}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/function/isgenerator/index.html b/files/pt-br/web/javascript/reference/global_objects/function/isgenerator/index.html new file mode 100644 index 0000000000..b370305940 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/function/isgenerator/index.html @@ -0,0 +1,55 @@ +--- +title: Function.prototype.isGenerator() +slug: Web/JavaScript/Reference/Global_Objects/Function/isGenerator +tags: + - Função + - Não padronizados + - Obsoleto + - metodo +translation_of: Archive/Web/JavaScript/Function.isGenerator +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>O método não padronizado <code><strong>isGenerator()</strong></code> é usado para determinar se uma função é ou não um <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators.3A_a_better_way_to_build_Iterators">gerador</a>. Ele foi removido do Firefox a partir da versão 58.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>fun</var>.isGenerator()</code></pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Um {{jsxref("Boolean")}} que indica se dada função é ou nao um <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators.3A_a_better_way_to_build_Iterators">gerador</a>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>isGenerator()</code> determina se uma função <em><code>fun</code></em> é ou não um <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators.3A_a_better_way_to_build_Iterators">gerador</a>. Fez parte de uma Proposta Inicial de Harmonia, mas não foi incluído na especificação do ECMAScript 2015.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js">function f() {} + +function* g() { + yield 42; +} + +console.log('f.isGenerator() = ' + f.isGenerator()); // f.isGenerator() = false +console.log('g.isGenerator() = ' + g.isGenerator()); // g.isGenerator() = true +</pre> + +<h2 id="Specificações">Specificações</h2> + +<p>Não faz parte de nenhuma especificação. Implementado no JavaScript 1.8.6.</p> + +<h2 id="Compatibilidade_do_Navegador">Compatibilidade do Navegador</h2> + +<div> +<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estrurados. Se você não quiser contribuir com estes dados, por favor veja <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um pull request.</div> + +<p>{{Compat("javascript.builtins.Function.isGenerator")}}</p> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iteradores e geradores</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/function/length/index.html b/files/pt-br/web/javascript/reference/global_objects/function/length/index.html new file mode 100644 index 0000000000..a116f07892 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/function/length/index.html @@ -0,0 +1,134 @@ +--- +title: Function.length +slug: Web/JavaScript/Reference/Global_Objects/Function/length +translation_of: Web/JavaScript/Reference/Global_Objects/Function/length +--- +<div>{{JSRef}}</div> + +<p>A propriedade <code><strong>length</strong></code> especifica o número de argumentos esperados pela função.</p> + +<div>{{js_property_attributes(0,0,1)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p><code>length é uma propriedade de um objeto função</code>, e indica quantos argumentos a função espera, i.e. o número de parametros formais. Este número não incluí o {{jsxref("rest_parameters", "rest parameter", "", 1)}}. <span class="short_text" id="result_box" lang="pt"><span>Por contraste,</span></span> {{jsxref("Functions_and_function_scope/arguments/length", "arguments.length")}} é local para a função e fornece o número de argumentos que foram realmente passados.</p> + +<h3 id="Propriedade_de_Dados_do_construtor_Function">Propriedade de Dados do construtor <code>Function</code></h3> + +<p>O construtor {{jsxref("Function")}} é propriamente um objeto {{jsxref("Function")}}. A proproedade de dados do seu <code>length</code> tem o valor de 1. Os atributos da propriedade são: Escrita: <code>false</code>, Enumerável: <code>false</code>, Configurável: <code>true</code>.</p> + +<h3 id="Propriedades_do_objeto_prototype_de_Function">Propriedades do objeto prototype de <code>Function</code></h3> + +<p>A propriedade length do objeto prototype {{jsxref("Function")}} tem o valor de 0.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js notranslate">console.log(Function.length); /* 1 */ + +console.log((function() {}).length); /* 0 */ +console.log((function(a) {}).length); /* 1 */ +console.log((function(a, b) {}).length); /* 2 etc. */ +console.log((function(...args) {}).length); /* 0, rest parameter is not counted */ +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3.5.1', 'Function.length')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-instances-length', 'Function.length')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>The <code>configurable</code> attribute of this property is now <code>true</code>.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_o_Navegador">Compatibilidade com o Navegador</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> + <tr> + <td>Configurable: true</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop(37)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</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> + <tr> + <td>Configurable: true</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile(37)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_tambem">Veja tambem</h2> + +<ul> + <li>{{jsxref("Function")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/function/name/index.html b/files/pt-br/web/javascript/reference/global_objects/function/name/index.html new file mode 100644 index 0000000000..2ee74e0779 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/function/name/index.html @@ -0,0 +1,222 @@ +--- +title: Function.name +slug: Web/JavaScript/Reference/Global_Objects/Function/name +translation_of: Web/JavaScript/Reference/Global_Objects/Function/name +--- +<div>{{JSRef}}</div> + +<p><span class="seoSummary">A propriedade somente-leitura <code><strong>name</strong></code> de um objeto {{jsxref("Function")}} indica o nome da função como especificado quando esta foi criada, ou <code>"anonymous"</code> para funções criadas anonimamente.</span></p> + +<div>{{EmbedInteractiveExample("pages/js/function-name.html")}}</div> + +<p class="hidden">O código-fonte deste exemplo interativo está mantido em um repositório do GitHub. Se você gostaria de contribuir com o projeto de exemplos interativos, clone por favor <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um <em>pull request</em>.</p> + +<div>{{js_property_attributes(0,0,1)}}<br> + </div> + +<div class="note"> +<p>Note que em implementações não-standard anteriores à ES2015 o atributo <code>configurable</code> tinha também o valor <code>false</code>.</p> +</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Nome_de_declaração_da_função">Nome de declaração da função</h3> + +<p>A propriedade <code>name</code> retorna o nome de uma declaração de função.</p> + +<pre class="brush: js">function doSomething() {} +doSomething.name; // "doSomething" +</pre> + +<h3 id="Nome_do_construtor_da_função">Nome do construtor da função</h3> + +<p>Funções criadas com a sintaxe <code>new Function(...)</code> ou somente <code>Function(...)</code> criam objetos {{jsxref("Function")}} com o nome "anonymous".</p> + +<pre>(new Function).name; // "anonymous"</pre> + +<h3 id="Nomes_de_função_inferidos">Nomes de função inferidos</h3> + +<p>Variáveis e métodos podem inferir o nome de uma função anônima a partir de sua posição sintática (novo na ECMAScript 2015).</p> + +<pre class="brush: js">var f = function() {}; +var object = { + someMethod: function() {} +}; + +console.log(f.name); // "f" +console.log(object.someMethod.name); // "someMethod" +</pre> + +<p>Você pode definir uma função com um nome numa {{jsxref("Operators/Function", "expressão de função", "", 1)}}:</p> + +<pre class="brush: js">var object = { + someMethod: function object_someMethod() {} +}; +console.log(object.someMethod.name); // grava o log "object_someMethod" + +try { object_someMethod } catch(e) { console.log(e); } +// ReferenceError: object_someMethod is not defined +</pre> + +<p>Você não pode mudar o nome de uma função, pois a propriedade é somente-leitura:</p> + +<div class="hidden"> +<p>O exemplo abaixo contradiz o que é dito no começo desta seção e não funciona como descrito.</p> +</div> + +<pre class="brush: js">var object = { + // anonymous + someMethod: function() {} +}; + +object.someMethod.name = 'otherMethod'; +console.log(object.someMethod.name); // someMethod +</pre> + +<p>Para mudá-lo, você poderia no entanto usar {{jsxref("Object.defineProperty()")}}.</p> + +<h3 id="Nomes_curtos_de_métodos">Nomes curtos de métodos</h3> + +<pre class="brush: js">var o = { + foo(){} +}; +o.foo.name; // "foo";</pre> + +<h3 id="Nomes_de_funções_vinculadas">Nomes de funções vinculadas</h3> + +<p>{{jsxref("Function.bind()")}} produz uma função cujo nome é "bound " seguido do nome da função.</p> + +<pre class="brush: js">function foo() {}; +foo.bind({}).name; // "bound foo" +</pre> + +<h3 id="Nomes_de_função_para_getters_e_setters">Nomes de função para <em>getters</em> e <em>setters</em></h3> + +<p>Ao usar propriedades acessórias <code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/get">get</a></code> e <code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">set</a></code>, "get" ou "set" aparecerão no nome da função.</p> + +<pre class="brush: js">var o = { + get foo(){}, + set foo(x){} +}; + +var descriptor = Object.getOwnPropertyDescriptor(o, "foo"); +descriptor.get.name; // "get foo" +descriptor.set.name; // "set foo";</pre> + +<h3 id="Nomes_de_funções_em_classes">Nomes de funções em classes</h3> + +<p>Você pode usar <code>obj.constructor.name</code> para checar a "classe" de um objeto (porém leia com atenção os avisos abaixo):</p> + +<pre class="brush: js">function Foo() {} // Sintaxe ES2015: class Foo {} + +var fooInstance = new Foo(); +console.log(fooInstance.constructor.name); // grava o log "Foo" +</pre> + +<div class="warning"> +<p><strong>Aviso:</strong> O interpretador vai definir a propriedade interna <code>Function.name</code> somente se uma função não tiver uma propriedade já com o nome <em>name</em> (veja a seção <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-setfunctionname">9.2.11 da ECMAScript2015 Language Specification</a>). Porém, a ES2015 especifica que a palavra-chave <em>static</em> de maneira que métodos estáticos serão definidos como OwnProperty da função construtora de classe (ECMAScript2015, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-runtime-semantics-classdefinitionevaluation">14.5.14.21.b</a> + <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-object-initializer-runtime-semantics-propertydefinitionevaluation">12.2.6.9</a>).</p> +</div> + +<p>Portanto não podemos obter o nome de virtualmente qualquer classe com um método estático <code>name()</code>:</p> + +<pre class="brush: js">class Foo { + constructor() {} + static name() {} +} +</pre> + +<p>Com um método <code>static name()</code>, <code>Foo.name</code> não guarda mais o nome verdadeiro da classe mas uma referência ao objeto de função <code>name()</code>. A definição de classe acima, escrita em sintaxe ES2015, se comportará de maneira similar ao seguinte trecho de código em sintaxe ES5 no Chrome ou no Firefox:</p> + +<pre class="brush: js">function Foo() {} +Object.defineProperty(Foo, 'name', { writable: true }); +Foo.name = function() {}; +</pre> + +<p>Tentar obter a classe de <code>fooInstance</code> via <code>fooInstance.constructor.name</code> não nos dará de maneira alguma o nome da classe, mas sim uma referência ao método estático da classe. Exemplo:</p> + +<pre class="brush: js">var fooInstance = new Foo(); +console.log(fooInstance.constructor.name); // grava o name() da função no log +</pre> + +<p>Você pode ver também, a partir do exemplo de sintaxe ES5, que, no Chrome ou no Firefox, a nossa definição estática de <code>Foo.name</code> se torna <em>writable</em>. A predefinição interna na ausência de uma definição estática customizada é somente-leitura:</p> + +<pre class="brush: js">Foo.name = 'Hello'; +console.log(Foo.name); // logs "Hello" if class Foo has a static name() property but "Foo" if not. +</pre> + +<p>Portanto, você não pode assumir que a propriedade interna <code>Function.name</code> sempre guardará um nome de classe..</p> + +<h3 id="Símbolos_como_nome_de_função">Símbolos como nome de função</h3> + +<p>Se um {{jsxref("Symbol")}} é usado como nome de função e o símbolo tem uma descrição, o nome do método será a descrição entre colchetes.</p> + +<pre>var sym1 = Symbol("foo"); +var sym2 = Symbol(); +var o = { + [sym1]: function(){}, + [sym2]: function(){} +}; + +o[sym1].name; // "[foo]" +o[sym2].name; // ""</pre> + +<h2 id="Compressores_e_minificadores_JavaScript">Compressores e minificadores JavaScript</h2> + +<div class="warning"> +<p><strong>Aviso:</strong> Tenha cuidado ao usar <code>Function.name</code> e transformações de código-fonte, como aquelas executadas por compressores (minificadores) ou obfuscadores de JavaScript. Estas ferramentas são comumente usadas como parte de processos de <em>build </em>de JavaScript para reduzir os tamanhos de programas antes da implementação em produção. Tais transformações frequentemente mudam nomes de função durante o <em>build</em>.</p> +</div> + +<p>Código fonte do tipo:</p> + +<pre class="brush: js">function Foo() {}; +var foo = new Foo(); + +if (foo.constructor.name === 'Foo') { + console.log("'foo' is an instance of 'Foo'"); +} else { + console.log('Oops!'); +} +</pre> + +<p>pode ser comprimido e se tornar:</p> + +<pre class="brush: js">function a() {}; +var b = new a(); +if (b.constructor.name === 'Foo') { + console.log("'foo' is an instance of 'Foo'"); +} else { + console.log('Oops!'); +} +</pre> + +<p>Na versão descomprimida, o programa cai no bloco-verdade e grava o log <em>'foo' is an instance of 'Foo'</em>. Todavia, na versão comprimida ele se comporta diferentemente, e cai no bloco <code>else</code>. Se você depende de <code>Function.name</code>, como no exemplo acima, tenha certeza que seu processo de <em>build</em> não mude nomes de função, ou então não assuma que uma função terá um nome determinado.</p> + +<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-name', 'name')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function-instances-name', 'name')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<div> +<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você gostaria de contribuir com os dados, confira por favor <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie uma <em>pull request</em>.</div> + +<p>{{Compat("javascript.builtins.Function.name")}}</p> +</div> diff --git a/files/pt-br/web/javascript/reference/global_objects/function/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/function/prototype/index.html new file mode 100644 index 0000000000..285bf56281 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/function/prototype/index.html @@ -0,0 +1,94 @@ +--- +title: Function.prototype +slug: Web/JavaScript/Reference/Global_Objects/Function/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Function +--- +<div>{{JSRef}}</div> + +<p>A propriedade <code><strong>Function.prototype</strong></code> representa o objeto <code>prototype</code> de {{jsxref("Function")}}.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Objetos {{jsxref("Function")}} herdam de <code>Function.prototype</code>. <code>Function.prototype</code> não pode ser modificado.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt>{{jsxref("Function.arguments")}} {{deprecated_inline}}</dt> + <dd>Um vetor correspondente aos argumentos passados a uma função. Isto é depreciado como propriedade de {{jsxref("Function")}}. Use em vez disso o objeto {{jsxref("Functions/arguments", "arguments")}} disponível dentro da função.</dd> + <dt><s class="obsoleteElement">{{jsxref("Function.arity")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Usado para especificar o número de argumentos esperados pela função. Foi removido, utilize em vez disso a propriedade {{jsxref("Function.length", "length")}}.</s></dd> + <dt>{{jsxref("Function.caller")}} {{non-standard_inline}}</dt> + <dd>Especifica a função que invocou a função sendo executada.</dd> + <dt>{{jsxref("Function.length")}}</dt> + <dd>Especifica o número de argumentos esperados pela função.</dd> + <dt>{{jsxref("Function.name")}}</dt> + <dd>O nome da função.</dd> + <dt>{{jsxref("Function.displayName")}} {{non-standard_inline}}</dt> + <dd>O nome de exibição da função.</dd> + <dt><code>Function.prototype.constructor</code></dt> + <dd>Especifica a função que cria o <code>prototype</code> do objeto. Veja {{jsxref("Object.prototype.constructor")}} para mais detalhes.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("Function.prototype.apply()")}}</dt> + <dd>Chama uma função e define seu <code>this</code> com o valor fornecido. Argumentos podem ser passados como um objeto {{jsxref("Array")}}.</dd> + <dt>{{jsxref("Function.prototype.bind()")}}</dt> + <dd>Cria uma nova função que, quando chamada, tem seu <code>this</code> definido com o valor fornecido, com uma sequência de argumentos determinada precedendo quaisquer argumentos fornecidos quando a nova função é chamada.</dd> + <dt>{{jsxref("Function.prototype.call()")}}</dt> + <dd>Chama (executa) uma função e define seu <code>this</code> com o valor fornecido. Argumentos podem ser passados como são.</dd> + <dt>{{jsxref("Function.prototype.isGenerator()")}} {{non-standard_inline}}</dt> + <dd>Retorna <code>true</code> se a função é um <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">gerador</a>; se não, retorna <code>false</code>.</dd> + <dt>{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Retorna uma <em>string</em> representando o código-fonte da função. Sobrescreve o método {{jsxref("Object.prototype.toSource")}}.</dd> + <dt>{{jsxref("Function.prototype.toString()")}}</dt> + <dd>Retorna uma <em>string</em> representando o código-fonte da função. Sobrescreve o método {{jsxref("Object.prototype.toString")}}.</dd> +</dl> + +<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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementada no JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3.5.2', 'Function.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-instances-prototype', 'Function.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function-instances-prototype', 'Function.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<div> +<div class="hidden">A tabela de compatibildiade nesta página é gerada a partir de dados estruturados. Se você gostaria de contribuir com os dados, confira por favor <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie uma <em>pull request</em>.</div> + +<p>{{Compat("javascript.builtins.Function.prototype")}}</p> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Function")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/function/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/function/tosource/index.html new file mode 100644 index 0000000000..4fbeaaf1c1 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/function/tosource/index.html @@ -0,0 +1,57 @@ +--- +title: Function.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Function/toSource +tags: + - Função + - JavaScript + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>O método <code><strong>toSource()</strong></code> retorna uma string que representa o código-fonte do objeto.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><var>function</var>.toSource(); +Function.toSource(); +</pre> + +<h3 id="Valor_de_Retorno">Valor de Retorno</h3> + +<p>Uma string representa o código-fonte de um objeto.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método<code>toSource</code> retorna os seguintes valores:</p> + +<ul> + <li>Para objetos nativos {{jsxref("Function")}} , <code>toSource()</code> retorna a seguinte string indicando que o código-fonte não está disponível: + + <pre class="brush: js">function Function() { + [native code] +} +</pre> + </li> + <li>Para funções personalizadas, <code>toSource()</code> retorna a fonte JavaScript que define o objeto como uma string.</li> +</ul> + +<p>Esse método, normalmente é chamado internamente pelo JavaScript e não explicitamente no código. Você pode chamar <code>toSource</code> enquanto depura para examinar o conteúdo de um objeto.</p> + +<h2 id="Especificações">Especificações</h2> + +<p>Não faz parte de nenhum padrão. Implementado no JavaScript 1.3.</p> + +<h2 id="Compatibilidade_em_Navegadores">Compatibilidade em Navegadores</h2> + +<div> +<div class="hidden">A tabela de comaptibilidade nessa página é gerada por dados estruturados. Se você gostaria de contribuir para os dados, por favor, veja <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.Function.toSource")}}</p> +</div> + +<h2 id="Veja_Também">Veja Também</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/function/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/function/tostring/index.html new file mode 100644 index 0000000000..c4d6fbbfb6 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/function/tostring/index.html @@ -0,0 +1,239 @@ +--- +title: Function.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Function/toString +tags: + - Função + - JavaScript + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>toString()</strong></code> retorna uma string representando o código fonte da função.</p> + +<div>{{EmbedInteractiveExample("pages/js/function-tostring.html")}}</div> + +<p class="hidden">A fonte deste exemplo interativo está armazenado no repositório do GitHub. Se você gostaria de contrubuir para este exemplos de projeto interativo, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie um pull request.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>function</var>.toString()</code></pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Uma string representando o código fonte da função.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O objeto da {{jsxref("Function")}} substitui o método {{jsxref("Object.prototype.toString", "toString")}} herdado de {{jsxref("Object")}}; ele não herda {{jsxref("Object.prototype.toString")}}. Para objetos {{jsxref("Function")}} definidos pelo usuário, o método <code>toString</code> retorna uma string contendo o seguimento de texto de origem que foi usado para definir a função</p> + +<p>O JavaScript chama o método <code>toString</code> automaticamente quando uma {{jsxref("Function")}} pode ser representada como um valor de texto. e.x. quando uma função é concatenada com uma string.</p> + +<p>O método <code>toString()</code> lançará uma exceção do tipo {{jsxref("TypeError")}} ("Function.prototype.toString called on incompatible object") se o valor <code>this</code> do objeto não é um objeto do tipo <code>Function.</code></p> + +<pre class="brush: js example-bad notranslate">Function.prototype.toString.call('foo'); // TypeError +</pre> + +<p>Se o método <code>toString()</code> é chamado por objetos de funções embutidas ou por uma função criada por <code>Function.prototype.bind</code>, <code>toString()</code> retorna uma string de uma função nativa que parece</p> + +<pre class="brush: js notranslate">"function () {\n [native code]\n}" +</pre> + +<p>Se o método <code>toString()</code> é chamado por uma função criada pelo contrutor de <code>Function</code>, <code>toString()</code> retorna o código fonte de uma declaração de função sintetizada chamada "anonymous" usando os parâmetros passados e o corpo da função.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Função</th> + <th scope="col">Function.prototype.toString resultado</th> + </tr> + </thead> + <tbody> + <tr> + <td> + <pre class="notranslate"> +function f(){}</pre> + </td> + <td> + <pre class="notranslate"> +"function f(){}"</pre> + </td> + </tr> + <tr> + <td> + <pre class="notranslate"> +class A { a(){} }</pre> + </td> + <td> + <pre class="notranslate"> +"class A { a(){} }"</pre> + </td> + </tr> + <tr> + <td> + <pre class="notranslate"> +function* g(){}</pre> + </td> + <td> + <pre class="notranslate"> +"function* g(){}"</pre> + </td> + </tr> + <tr> + <td> + <pre class="notranslate"> +a => a</pre> + </td> + <td> + <pre class="notranslate"> +"a => a"</pre> + </td> + </tr> + <tr> + <td> + <pre class="notranslate"> +({ a(){} }.a)</pre> + </td> + <td> + <pre class="notranslate"> +"a(){}"</pre> + </td> + </tr> + <tr> + <td> + <pre class="notranslate"> +({ *a(){} }.a)</pre> + </td> + <td> + <pre class="notranslate"> +"*a(){}"</pre> + </td> + </tr> + <tr> + <td> + <pre class="notranslate"> +({ [0](){} }[0])</pre> + </td> + <td> + <pre class="notranslate"> +"[0](){}"</pre> + </td> + </tr> + <tr> + <td> + <pre class="notranslate"> +Object.getOwnPropertyDescriptor({ + get a(){} +}, "a").get</pre> + </td> + <td> + <pre class="notranslate"> +"get a(){}"</pre> + </td> + </tr> + <tr> + <td> + <pre class="notranslate"> +Object.getOwnPropertyDescriptor({ + set a(x){} +}, "a").set</pre> + </td> + <td> + <pre class="notranslate"> +"set a(x){}"</pre> + </td> + </tr> + <tr> + <td> + <pre class="notranslate"> +Function.prototype.toString</pre> + </td> + <td> + <pre class="notranslate"> +"function toString() { [native code] }"</pre> + </td> + </tr> + <tr> + <td> + <pre class="notranslate"> +(function f(){}.bind(0))</pre> + </td> + <td> + <pre class="notranslate"> +"function () { [native code] }"</pre> + </td> + </tr> + <tr> + <td> + <pre class="notranslate"> +Function("a", "b")</pre> + </td> + <td> + <pre class="notranslate"> +"function anonymous(a\n) {\nb\n}"</pre> + </td> + </tr> + </tbody> +</table> + +<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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td> + <p>Definição inicial. Implementado no JavaScript 1.1.</p> + </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> + <p>Mais requisitos específicos foram incluídos para representação de string.</p> + </td> + </tr> + <tr> + <td><a href="https://tc39.github.io/Function-prototype-toString-revision/#sec-introduction"><code>Function.prototype.toString</code> revisions proposal</a></td> + <td>Rascunho</td> + <td> + <p>Padroniza a função de string navida e fins de linha.</p> + </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Function.toString")}}</p> +</div> + +<h2 id="Notas_específicas_do_Firefox">Notas específicas do Firefox</h2> + +<ul> + <li>Desde o Firefox 17 a função <code>Function.prototype.toString()</code> tem sido implementada salvando o fonte da função. O descompilador foi removido o que torna o parâmetro <code>indentation</code> desnecessário. Veja {{bug("761723")}} para mais detalhes.</li> + <li>Do Firefox 38 para o 63 a função <code>Function.prototype.toString()</code> lançava exceções para objetos {{jsxref("Proxy")}} ({{bug(1100936)}} e {{bug(1440468)}}).</li> +</ul> + +<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/generator/index.html b/files/pt-br/web/javascript/reference/global_objects/generator/index.html new file mode 100644 index 0000000000..6bcf4652df --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/generator/index.html @@ -0,0 +1,178 @@ +--- +title: Generator +slug: Web/JavaScript/Reference/Global_Objects/Generator +translation_of: Web/JavaScript/Reference/Global_Objects/Generator +--- +<div>{{JSRef}}</div> + +<p>O objeto <code><strong>Generator</strong></code> é retornado por {{jsxref("Statements/function*", "generator function", "", 1)}} e conforme <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable">iterable protocol</a> e o <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterator">iterator protocol</a>.</p> + +<h2 id="Síntaxe">Síntaxe</h2> + +<pre class="syntaxbox">function* gen() { + yield 1; + yield 2; + yield 3; +} + +var g = gen(); // "Generator { }"</pre> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("Generator.prototype.next()")}}</dt> + <dd>Retorna o valor fornecido pela expressão {{jsxref("Operators/yield", "yield")}}.</dd> + <dt>{{jsxref("Generator.prototype.return()")}}</dt> + <dd>Retorna o valor fornecido a finaliza o generator.</dd> + <dt>{{jsxref("Generator.prototype.throw()")}}</dt> + <dd>Lança um erro no generator.</dd> +</dl> + +<h2 id="Example">Example</h2> + +<h3 id="An_infinite_iterator">An infinite iterator</h3> + +<pre class="brush: js">function* idMaker(){ + var index = 0; + while(true) + yield index++; +} + +var gen = idMaker(); // "Generator { }" + +console.log(gen.next().value); // 0 +console.log(gen.next().value); // 1 +console.log(gen.next().value); // 2 +// ...</pre> + +<h2 id="Objeto_legacy_generator">Objeto legacy generator</h2> + +<p>Firefox (SpiderMonkey) também implementa a versão anterior do generator em <a href="/en-US/docs/Web/JavaScript/New_in_JavaScript/1.7">JavaScript 1.7</a>, onde o asterisco (*) na declaração da função não era necessário (somente era necessário usar a palavra reservada <code>yield</code> no corpo da função). Contudo, legacy generators estão obsoletos. Não os use, eles serão removidos ({{bug(1083482)}}).</p> + +<h3 id="Métodos_legacy_generator">Métodos legacy generator</h3> + +<dl> + <dt><code>Generator.prototype.next() </code>{{non-standard_inline}}</dt> + <dd>Retorna o valor fornecido pela expressão {{jsxref("Operators/yield", "yield")}}. Isto corresponde ao <code>next() </code>do ES6.</dd> + <dt><code>Generator.prototype.close()</code> {{non-standard_inline}}</dt> + <dd>Fecha o generator, então quando chamar <code>next()</code> um erro {{jsxref("StopIteration")}} será lançado. Isto corresponde ao método <code>return()</code> do ES6.</dd> + <dt><code>Generator.prototype.send()</code> {{non-standard_inline}}</dt> + <dd>Usado para enviar um valor para o generator. Este valor é retordo pela expressão {{jsxref("Operators/yield", "yield")}}, e retorna o valor fornecido pelo pelo next {{jsxref("Operators/yield", "yield")}}. <code>send(x)</code> corresponde ao <code>next(x)</code> do ES6.</dd> + <dt><strong><code>Generator.</code></strong><code>prototype.</code><strong><code>throw()</code> </strong> {{non-standard_inline}}</dt> + <dd>Lança um erro no generator. Isto corresponde ao método <code>throw() do ES6.</code></dd> +</dl> + +<h3 id="Exemplo_do_Legacy_generator">Exemplo do Legacy generator</h3> + +<pre class="brush: js">function* fibonacci() { + var a = yield 1; + yield a * 2; +} + +var it = fibonacci(); +console.log(it); // "Generator { }" +console.log(it.next()); // 1 +console.log(it.send(10)); // 20 +console.log(it.close()); // undefined +console.log(it.next()); // throws StopIteration (Como o generator está fechado) +</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('ES6', '#sec-generator-objects', 'Generator objects')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição Inicial</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-generator-objects', 'Generator objects')}}</td> + <td>{{Spec2('ESDraft')}}</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>{{CompatChrome(39.0)}}</td> + <td>{{CompatVersionUnknown}}</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>Android Webview</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(39.0)}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(39.0)}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_Também">Veja Também</h2> + +<h3 id="Legacy_generators">Legacy generators</h3> + +<ul> + <li>{{jsxref("Statements/Legacy_generator_function", "The legacy generator function", "", 1)}}</li> + <li>{{jsxref("Operators/Legacy_generator_function", "The legacy generator function expression", "", 1)}}</li> + <li>{{jsxref("StopIteration")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features/The_legacy_Iterator_protocol">The legacy Iterator protocol</a></li> +</ul> + +<h3 id="ES6_generators">ES6 generators</h3> + +<ul> + <li>{{jsxref("Functions", "Functions", "", 1)}}</li> + <li>{{jsxref("Statements/function", "function")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Statements/function*", "function*")}}</li> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/globalthis/index.html b/files/pt-br/web/javascript/reference/global_objects/globalthis/index.html new file mode 100644 index 0000000000..2fa51a26e2 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/globalthis/index.html @@ -0,0 +1,80 @@ +--- +title: globalThis +slug: Web/JavaScript/Reference/Global_Objects/globalThis +tags: + - JavaScript + - Reference + - global + - globalThis +translation_of: Web/JavaScript/Reference/Global_Objects/globalThis +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>A propriedade global <code><strong>globalThis</strong></code> retorna um objeto global de nível superior.</p> + +<div>{{EmbedInteractiveExample("pages/js/globalprops-globalthis.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>globalThis</code> +</pre> + +<h2 id="Descrição">Descrição</h2> + +<p>Historicamente, o acesso ao escopo global exigiu uma sintaxe diferente em diferentes ambientes JavaScript. Na web você pode usar <code><a href="/en-US/docs/Web/API/Window/window">window</a></code>, <code><a href="/en-US/docs/Web/API/Window/self">self</a></code> ou <code><a href="/en-US/docs/Web/API/Window/frames">frames</a></code> - porém em <a href="/en-US/docs/Web/API/Worker">Web Workers</a> somente <code>self</code> funcionará. Em Node.js nada disso funciona e você deve usar <code>global</code>.<br> + A palavra-chave <code>this</code> poderia ser usada dentro de funções em execução no modo <em>sloppy</em>, mas <code>this</code> será <code>undefined</code> em módulos, e dentro de funções em execução no <em>strict mode</em>.</p> + +<p>A propriedade <code>globalThis</code> fornece uma maneira padrão de acessar o objeto global entre ambientes. Ao contrário de propriedades semelhantes, como <code><a href="/en-US/docs/Web/API/Window/window">window</a></code> e <code><a href="/en-US/docs/Web/API/Window/self">self</a></code>, é garantido que funcione em contextos <em>window</em> e <em>non-window</em>. Dessa forma, você pode acessar o objeto global de maneira consistente sem precisar saber em qual ambiente o código está sendo executado.</p> + +<p>Para ajudá-lo a lembrar o nome, lembre-se que no escopo global, o valor de <code>this</code> é <code>globalThis</code>.</p> + +<h3 id="Nome">Nome</h3> + +<p>Várias outras opções de nomes populares, como <code>self</code> e <code>global</code> foram removidas da discussão devido ao seu potencial em quebrar a compatibilidade com o código existente.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<p>Antes de <code>globalThis</code>, a única maneira confiável de obter o objeto global para um ambiente era <code>Function('return this')()</code>. No entanto, isso causa violações <a href="/en-US/docs/Web/HTTP/CSP">CSP</a> em algumas configurações, então <a href="https://github.com/paulmillr/es6-shim">es6-shim</a> usa uma verificação como essa, por exemplo:</p> + +<pre class="brush: js">var getGlobal = function () { + if (typeof self !== 'undefined') { return self; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + throw new Error('unable to locate global object'); +}; + +var globals = getGlobal(); + +if (typeof globals.setTimeout !== 'function') { + // sem setTimeout neste ambiente! +} +</pre> + +<p>Com <code>globalThis</code> disponível, a busca global adicional entre ambientes não é mais necessária:</p> + +<pre class="brush: js">if (typeof globalThis.setTimeout !== 'function') { + // sem setTimeout neste ambiente! +}</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><a href="https://github.com/tc39/proposal-global">globalThis proposal</a></td> + <td>Stage 3</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2> + +<p>{{Compat("javascript.builtins.globalThis")}}</p> diff --git a/files/pt-br/web/javascript/reference/global_objects/index.html b/files/pt-br/web/javascript/reference/global_objects/index.html new file mode 100644 index 0000000000..cd7eb82608 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/index.html @@ -0,0 +1,174 @@ +--- +title: Objetos Globais +slug: Web/JavaScript/Reference/Global_Objects +tags: + - JavaScript + - Reference + - TopicStub +translation_of: Web/JavaScript/Reference/Global_Objects +--- +<p></p> + +<div>{{jsSidebar("Objects")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>Este capítulo documenta todos os objetos nativos do JavaScript padrão, assim como seus métodos e propriedades.</p> + +<div class="onlyinclude"> +<p>O termo "objetos globais" (ou objetos nativos por padrão) aqui não deve ser confundido com o de <strong>objeto global</strong>. Aqui, objetos globais se referem aos <strong>objetos no escopo global</strong> (somente se o modo estrito/<em>strict mode</em> do ECMAScript 5 não for usado; Nesse caso retorna {{jsxref("undefined")}}). O <strong>objeto global</strong> pode ser acessado usando o operador {{jsxref("Operators/this", "this")}} no escopo global. De fato, o escopo global <strong>consiste em<em> </em></strong>propriedades do objeto global, incluindo propriedades herdadas, se houver.</p> + +<p>Outros objetos no escopo global também são <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Creating_new_objects">criados pelo desenvolvedor</a> ou fornecido pela aplicação <em>host</em>. Os objetos disponíveis no <em>host</em> no contexto do browser são documentados na <a href="https://developer.mozilla.org/en-US/docs/Web/API/Reference">API reference</a>. Para maiores informações sobre as distinções entre <a href="https://developer.mozilla.org/en-US/docs/DOM/DOM_Reference">DOM</a> e core <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript">JavaScript</a>, veja <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/JavaScript_technologies_overview">visão geral das tecnologias JavaScript</a>.</p> + +<h2 id="Objetos_padrão_(por_categoria)">Objetos padrão (por categoria)</h2> + +<h3 id="Propriedades_de_valor">Propriedades de valor</h3> + +<p>Propriedades globais retornam um valor simples; eles não tem propriedades ou métodos.</p> + +<ul> + <li>{{jsxref("Global_Objects/Infinity", "Infinity")}}</li> + <li>{{jsxref("Global_Objects/NaN", "NaN")}}</li> + <li>{{jsxref("Global_Objects/undefined", "undefined")}}</li> + <li>{{jsxref("Global_Objects/null", "null")}} literal</li> +</ul> + +<h3 id="Propriedades_de_função">Propriedades de função</h3> + +<p>Estas funções globais —funções que são chamadas globalmente ao invés de em um objeto—retornam diretamente seus resultados a quem chama.</p> + +<ul> + <li>{{jsxref("Global_Objects/eval", "eval()")}}</li> + <li>{{jsxref("Global_Objects/uneval", "uneval()")}} {{non-standard_inline()}}</li> + <li>{{jsxref("Global_Objects/isFinite", "isFinite()")}}</li> + <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li> + <li>{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</li> + <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li> + <li>{{jsxref("Global_Objects/decodeURI", "decodeURI()")}}</li> + <li>{{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent()")}}</li> + <li>{{jsxref("Global_Objects/encodeURI", "encodeURI()")}}</li> + <li>{{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent()")}}</li> + <li>{{jsxref("Global_Objects/escape", "escape()")}} {{deprecated_inline()}}</li> + <li>{{jsxref("Global_Objects/unescape", "unescape()")}} {{deprecated_inline()}}</li> +</ul> + +<h3 id="Objetos_fundamentais">Objetos fundamentais</h3> + +<p>Estes são objetos básicos e fundamentais nos quais todos os outros objetos são baseados. Isso inclui objetos que representam objetos genéricos, funções e erros.</p> + +<ul> + <li>{{jsxref("Global_Objects/Object", "Object")}}</li> + <li>{{jsxref("Global_Objects/Function", "Function")}}</li> + <li>{{jsxref("Global_Objects/Boolean", "Boolean")}}</li> + <li>{{jsxref("Global_Objects/Symbol", "Symbol")}} {{experimental_inline()}}</li> + <li>{{jsxref("Global_Objects/Error", "Error")}}</li> + <li>{{jsxref("Global_Objects/EvalError", "EvalError")}}</li> + <li>{{jsxref("Global_Objects/InternalError", "InternalError")}}</li> + <li>{{jsxref("Global_Objects/RangeError", "RangeError")}}</li> + <li>{{jsxref("Global_Objects/ReferenceError", "ReferenceError")}}</li> + <li>{{jsxref("Global_Objects/StopIteration", "StopIteration")}}</li> + <li>{{jsxref("Global_Objects/SyntaxError", "SyntaxError")}}</li> + <li>{{jsxref("Global_Objects/TypeError", "TypeError")}}</li> + <li>{{jsxref("Global_Objects/URIError", "URIError")}}</li> +</ul> + +<h3 id="Números_e_datas">Números e datas</h3> + +<p>Estes são objetos base para a representação de números, datas e cálculos matemáticos.</p> + +<ul> + <li>{{jsxref("Global_Objects/Number", "Number")}}</li> + <li>{{jsxref("Global_Objects/Math", "Math")}}</li> + <li>{{jsxref("Global_Objects/Date", "Date")}}</li> +</ul> + +<h3 id="Processamento_de_texto">Processamento de texto</h3> + +<p>Estes objetos representam strings e manipulam as mesmas.</p> + +<ul> + <li>{{jsxref("Global_Objects/String", "String")}}</li> + <li>{{jsxref("Global_Objects/RegExp", "RegExp")}}</li> +</ul> + +<h3 id="Coleções_indexadas">Coleções indexadas</h3> + +<p>Estes objetos representam coleções de dados que são ordenados pelo valor de um índice. Isso inclui arrays (tipados) e arrays baseados em outros construtores, como <code>[]</code>.</p> + +<ul> + <li>{{jsxref("Global_Objects/Array", "Array")}}</li> + <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Float32Array" title="JavaScript_typed_arrays/Float32Array">Float32Array</a></code></li> + <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Float64Array" title="JavaScript_typed_arrays/Float64Array">Float64Array</a></code></li> + <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Int16Array" title="JavaScript_typed_arrays/Int16Array">Int16Array</a></code></li> + <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Int32Array" title="JavaScript_typed_arrays/Int32Array">Int32Array</a></code></li> + <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Int8Array" title="JavaScript_typed_arrays/Int8Array">Int8Array</a></code></li> + <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Uint16Array" title="JavaScript_typed_arrays/int16Array">Uint16Array</a></code></li> + <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Uint32Array" title="JavaScript_typed_arrays/Uint32Array">Uint32Array</a></code></li> + <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Uint8Array" title="JavaScript_typed_arrays/int8Array">Uint8Array</a></code></li> + <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Uint8ClampedArray" title="JavaScript_typed_arrays/Uint8ClampedArray">Uint8ClampedArray</a></code></li> + <li>{{jsxref("Global_Objects/ParallelArray", "ParallelArray")}} {{non-standard_inline()}}</li> +</ul> + +<h3 id="Coleções_chaveadas">Coleções chaveadas</h3> + +<p>Estes objetos representam coleções que usam chaves; estas contém elementos que são iteráveis na ordem de inserção.</p> + +<ul> + <li>{{jsxref("Global_Objects/Map", "Map")}} {{experimental_inline()}}</li> + <li>{{jsxref("Global_Objects/Set", "Set")}} {{experimental_inline()}}</li> + <li>{{jsxref("Global_Objects/WeakMap", "WeakMap")}} {{experimental_inline()}}</li> + <li>{{jsxref("Global_Objects/WeakSet", "WeakSet")}} {{experimental_inline()}}</li> +</ul> + +<h3 id="Dados_estruturados">Dados estruturados</h3> + +<p>Estes objetos representam e interagem com buffers de dados estruturados e dados codificados usando JavaScript Object Notation (JSON).</p> + +<ul> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("JSON")}}</li> +</ul> + +<h3 id="Controle_de_abstrações_de_objetos">Controle de abstrações de objetos</h3> + +<ul> + <li>{{jsxref("Promise")}} {{experimental_inline}}</li> + <li>{{jsxref("Generator")}} {{experimental_inline}}</li> + <li>{{jsxref("GeneratorFunction")}} {{experimental_inline}}</li> +</ul> + +<h3 id="Reflexão_(reflection)">Reflexão (reflection)</h3> + +<ul> + <li>{{jsxref("Reflect")}} {{experimental_inline}}</li> + <li>{{jsxref("Proxy")}} {{experimental_inline}}</li> +</ul> + +<h3 id="Internacionalização">Internacionalização</h3> + +<p>Adições ao core do ECMAScript para funcionalidades sensíveis à linguagem.</p> + +<ul> + <li>{{jsxref("Global_Objects/Intl", "Intl")}}</li> + <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li> + <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("Global_Objects/NumberFormat", "Intl.NumberFormat")}}</li> +</ul> + +<h3 id="Objetos_não-padrão" style="font-size: 1.71428571428571rem;">Objetos não-padrão</h3> + +<ul> + <li>{{jsxref("Iterator")}} {{non-standard_inline}}</li> + <li>{{jsxref("ParallelArray")}} {{non-standard_inline}}</li> + <li>{{jsxref("StopIteration")}} {{non-standard_inline}}</li> +</ul> + +<h3 id="Outros">Outros</h3> + +<ul> + <li><code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/arguments">arguments</a></code></li> +</ul> +</div> + +<p> </p> diff --git a/files/pt-br/web/javascript/reference/global_objects/infinity/index.html b/files/pt-br/web/javascript/reference/global_objects/infinity/index.html new file mode 100644 index 0000000000..71831a3f35 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/infinity/index.html @@ -0,0 +1,114 @@ +--- +title: Infinity +slug: Web/JavaScript/Reference/Global_Objects/Infinity +translation_of: Web/JavaScript/Reference/Global_Objects/Infinity +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>A propriedade global <code><strong>Infinity</strong></code> é um valor numérico que representa infinito.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code>Infinity </code></pre> + +<h2 id="Description" name="Description">Descrição</h2> + +<p><code>Infinity</code> é uma propriedade do <em>objeto global</em>, ou seja, é uma varíavel no escopo global.</p> + +<p>O valor inicial de <code>Infinity</code> é {{jsxref("Number.POSITIVE_INFINITY")}}. O valor <code>Infinity</code> (positivo) é maior do que qualquer outro número. Este valor se comporta matematicamente como infinito; por exemplo, qualquer número positivo multiplicado por <code>Infinity</code> é <code>Infinity</code>, e qualquer coisa dividida por <code>Infinity</code> é 0.</p> + +<p>Pela especificação ECMAScript 5, <code>Infinity</code> é somente leitura (implementado no JavaScript 1.8.5 / Firefox 4).</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 1ª Edição.</td> + <td>Padrão</td> + <td>Definição inicial. Implementado no JavaScript 1.3</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.1.2', 'Infinity')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-value-properties-of-the-global-object-infinity', 'Infinity')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade">Compatibilidade</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 para 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("Number.NEGATIVE_INFINITY")}}</li> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/int16array/index.html b/files/pt-br/web/javascript/reference/global_objects/int16array/index.html new file mode 100644 index 0000000000..a989e5be3e --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/int16array/index.html @@ -0,0 +1,208 @@ +--- +title: Int16Array +slug: Web/JavaScript/Reference/Global_Objects/Int16Array +tags: + - Construtor + - JavaScript + - TypedArray + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/Int16Array +--- +<div>{{JSRef}}</div> + +<p> </p> + +<p>A matriz do tipo <strong><code>Int16Array</code></strong> representa uma matriz de inteiros assinados de 16 bits com dois complementos na ordem de bytes da plataforma. Se o controle sobre a ordem de bytes for necessário, use {{jsxref ("DataView")}}. O conteúdo é inicializado em 0. Uma vez estabelecido, você pode fazer referência a elementos na matriz usando os métodos do objeto ou usando a sintaxe de índice da matriz padrão (ou seja, usando a notação de colchetes).</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox">new Int16Array(); // novo no ES2017 +new Int16Array(length); +new Int16Array(typedArray); +new Int16Array(object); +new Int16Array(buffer [, byteOffset [, length]]);</pre> + +<p> </p> + +<p>Para obter mais informações sobre a sintaxe do construtor e os parâmetros, consulte <em><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntax">TypedArray</a></em>.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Int16Array.BYTES_PER_ELEMENT")}}</dt> + <dd>Retorna um valor numérico do tamanho do elemento. <code>2</code> no caso de um <code>Int16Array</code>.</dd> + <dt>Int16Array.length</dt> + <dd>Propriedade de comprimento estático cujo valor é 0. Para o comprimento real (número de elementos), consulte {{jsxref("TypedArray.prototype.length", "Int16Array.prototype.length")}}.</dd> + <dt>{{jsxref("TypedArray.name", "Int16Array.name")}}</dt> + <dd>Retorna o valor da string do nome do construtor. No caso do tipo <code>Int16Array</code>: "Int16Array".</dd> + <dt>{{jsxref("TypedArray.prototype", "Int16Array.prototype")}}</dt> + <dd>Protótipo para os objetos TypedArray.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("TypedArray.from", "Int16Array.from()")}}</dt> + <dd>Cria um novo <code>Int16Array</code> de um objeto semelhante a uma matriz ou iterável. Veja também {{jsxref("Array.from()")}}.</dd> + <dt>{{jsxref("TypedArray.of", "Int16Array.of()")}}</dt> + <dd>Cria um novo <code>Int16Array</code> com um número variável de argumentos. Veja também {{jsxref("Array.of()")}}.</dd> +</dl> + +<h2 id="Int16Array_prototype"><code>Int16Array</code> prototype</h2> + +<p>Todos <code>Int16Array</code> objetos herdam de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p> + +<h3 id="Propriedades_2">Propriedades</h3> + +<dl> + <dt><code>Int16Array.prototype.constructor</code></dt> + <dd>Retorna a função que criou o protótipo de uma instância. Este é o construtor <code>Int16Array</code> por padrão.</dd> + <dt>{{jsxref("TypedArray.prototype.buffer", "Int16Array.prototype.buffer")}} {{readonlyInline}}</dt> + <dd>Retorna o {{jsxref("ArrayBuffer")}} referenciado pelo <code>Int16Array</code> Fixado em tempo de construção e <strong>apenas leitura</strong>.</dd> + <dt>{{jsxref("TypedArray.prototype.byteLength", "Int16Array.prototype.byteLength")}} {{readonlyInline}}</dt> + <dd>Retorna o tamanho (em bytes) de um <code>Int16Array</code> desde o ínicio {{jsxref("ArrayBuffer")}}. Fixado em tempo de construção e <strong>apenas leitura</strong>.</dd> + <dt>{{jsxref("TypedArray.prototype.byteOffset", "Int16Array.prototype.byteOffset")}} {{readonlyInline}}</dt> + <dd>Retorna o deslocamento (em bytes) de um <code>Int16Array</code> desde o ínicio {{jsxref("ArrayBuffer")}}. Fixado em tempo de construção e <strong>apenas leitura</strong>.</dd> + <dt>{{jsxref("TypedArray.prototype.length", "Int16Array.prototype.length")}} {{readonlyInline}}</dt> + <dd>Retorna o número de elementos em um <code>Int16Array</code>. Fixado em tempo de construção e <strong>apenas leitura</strong>.</dd> +</dl> + +<h3 id="Métodos_2">Métodos</h3> + +<dl> + <dt>{{jsxref("TypedArray.copyWithin", "Int16Array.prototype.copyWithin()")}}</dt> + <dd>Copia uma sequência de elementos da matriz dentro da matriz. Veja também {{jsxref("Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.entries", "Int16Array.prototype.entries()")}}</dt> + <dd>Retorna um novo <code>Array Iterator</code> objeto que contém os pares de chave / valor para cada índice na matriz. Veja também {{jsxref("Array.prototype.entries()")}}.</dd> + <dt>{{jsxref("TypedArray.every", "Int16Array.prototype.every()")}}</dt> + <dd>Testa se todos os elementos na matriz passam no teste fornecido por uma função. Veja também {{jsxref("Array.prototype.every()")}}.</dd> + <dt>{{jsxref("TypedArray.fill", "Int16Array.prototype.fill()")}}</dt> + <dd>Preenche todos os elementos de uma matriz de um índice inicial para um índice final com um valor estático. Veja também {{jsxref("Array.prototype.fill()")}}.</dd> + <dt>{{jsxref("TypedArray.filter", "Int16Array.prototype.filter()")}}</dt> + <dd>Cria uma nova matriz com todos os elementos dessa matriz para os quais a função de filtragem fornecida retorna true. Veja também {{jsxref("Array.prototype.filter()")}}.</dd> + <dt>{{jsxref("TypedArray.find", "Int16Array.prototype.find()")}}</dt> + <dd>Retorna o valor encontrado na matriz, se um elemento na matriz satisfizer a função de teste fornecida ou <code>undefined</code> se não encontrado. Veja também {{jsxref("Array.prototype.find()")}}.</dd> + <dt>{{jsxref("TypedArray.findIndex", "Int16Array.prototype.findIndex()")}}</dt> + <dd>Retorna o índice encontrado na matriz, se um elemento na matriz satisfizer a função de teste fornecida ou -1, se não for encontrado. Veja também {{jsxref("Array.prototype.findIndex()")}}.</dd> + <dt>{{jsxref("TypedArray.forEach", "Int16Array.prototype.forEach()")}}</dt> + <dd>Chama uma função para cada elemento na matriz. Veja também {{jsxref("Array.prototype.forEach()")}}.</dd> + <dt>{{jsxref("TypedArray.includes", "Int16Array.prototype.includes()")}} {{experimental_inline}}</dt> + <dd>Determina se uma matriz tipificada inclui um determinado elemento, retornando <code>true</code> ou <code>false</code>. Veja também {{jsxref("Array.prototype.includes()")}}.</dd> + <dt>{{jsxref("TypedArray.indexOf", "Int16Array.prototype.indexOf()")}}</dt> + <dd>Retorna o primeiro (menos) índice de um elemento dentro da matriz igual ao valor especificado ou -1 se nenhum for encontrado. Veja também {{jsxref("Array.prototype.indexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.join", "Int16Array.prototype.join()")}}</dt> + <dd>Junta todos os elementos de um array em uma string. Veja também {{jsxref("Array.prototype.join()")}}.</dd> + <dt>{{jsxref("TypedArray.keys", "Int16Array.prototype.keys()")}}</dt> + <dd>Retorna um novo <code>Array Iterator</code> que contém uma chave para cada índice no array. Veja também {{jsxref("Array.prototype.keys()")}}.</dd> + <dt>{{jsxref("TypedArray.lastIndexOf", "Int16Array.prototype.lastIndexOf()")}}</dt> + <dd>Retorna o último (maior) índice de um elemento dentro da matriz igual ao valor especificado ou -1 se nenhum for encontrado. Veja também {{jsxref("Array.prototype.lastIndexOf()")}}.</dd> + <dt>{{jsxref("TypedArray.map", "Int16Array.prototype.map()")}}</dt> + <dd>Cria uma nova matriz com os resultados da chamada de uma função fornecida em todos os elementos dessa matriz. Veja também {{jsxref("Array.prototype.map()")}}.</dd> + <dt>{{jsxref("TypedArray.move", "Int16Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt> + <dd>Versão não-padrão anterior de {{jsxref("TypedArray.copyWithin", "Int16Array.prototype.copyWithin()")}}.</dd> + <dt>{{jsxref("TypedArray.reduce", "Int16Array.prototype.reduce()")}}</dt> + <dd>Aplique uma função contra um acumulador e cada valor da matriz (da esquerda para a direita) para reduzi-lo a um único valor. Veja também {{jsxref("Array.prototype.reduce()")}}.</dd> + <dt>{{jsxref("TypedArray.reduceRight", "Int16Array.prototype.reduceRight()")}}</dt> + <dd>Aplique uma função contra um acumulador e cada valor da matriz (da direita para a esquerda) para reduzi-lo a um único valor. Veja também {{jsxref("Array.prototype.reduceRight()")}}.</dd> + <dt>{{jsxref("TypedArray.reverse", "Int16Array.prototype.reverse()")}}</dt> + <dd>Inverte a ordem dos elementos de um array - o primeiro torna-se o último e o último torna-se o primeiro. Veja também {{jsxref("Array.prototype.reverse()")}}.</dd> + <dt>{{jsxref("TypedArray.set", "Int16Array.prototype.set()")}}</dt> + <dd>Armazena vários valores na matriz tipada, lendo valores de entrada de uma matriz especificada.</dd> + <dt>{{jsxref("TypedArray.slice", "Int16Array.prototype.slice()")}}</dt> + <dd>Extrai uma seção de uma matriz e retorna uma nova matriz. Veja também {{jsxref("Array.prototype.slice()")}}.</dd> + <dt>{{jsxref("TypedArray.some", "Int16Array.prototype.some()")}}</dt> + <dd>Retorna true se pelo menos um elemento nessa matriz satisfizer a função de teste fornecida. Veja também {{jsxref("Array.prototype.some()")}}.</dd> + <dt>{{jsxref("TypedArray.sort", "Int16Array.prototype.sort()")}}</dt> + <dd>Classifica os elementos de uma matriz e retorna a matriz. Veja também {{jsxref("Array.prototype.sort()")}}.</dd> + <dt>{{jsxref("TypedArray.subarray", "Int16Array.prototype.subarray()")}}</dt> + <dd>Retorna um novo <code>Int16Array </code>a partir do índice de elemento inicial e final fornecido.</dd> + <dt>{{jsxref("TypedArray.values", "Int16Array.prototype.values()")}}</dt> + <dd>Retorna um novo objeto <code>Array Iterator</code> que contém os valores para cada índice na matriz. Veja também {{jsxref("Array.prototype.values()")}}.</dd> + <dt>{{jsxref("TypedArray.toLocaleString", "Int16Array.prototype.toLocaleString()")}}</dt> + <dd>Retorna uma string localizada representando a matriz e seus elementos. Veja também {{jsxref("Array.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("TypedArray.toString", "Int16Array.prototype.toString()")}}</dt> + <dd>Retorna uma string representando a matriz e seus elementos. Veja também {{jsxref("Array.prototype.toString()")}}.</dd> + <dt>{{jsxref("TypedArray.@@iterator", "Int16Array.prototype[@@iterator]()")}}</dt> + <dd>Retorna um novo objeto <code>Array Iterator</code> que contém os valores para cada índice na lista.</dd> +</dl> + +<h2 id="Exemplos">Exemplos</h2> + +<p>Diferentes opções de criar um <code>Int16Array</code>:</p> + +<pre class="brush: js">// De um tamanho +var int16 = new Int16Array(2); +int16[0] = 42; +console.log(int16[0]); // 42 +console.log(int16.length); // 2 +console.log(int16.BYTES_PER_ELEMENT); // 2 + +// De uma array +var arr = new Int16Array([21,31]); +console.log(arr[1]); // 31 + +// De um outro TypedArray +var x = new Int16Array([21, 31]); +var y = new Int16Array(x); +console.log(y[0]); // 21 + +// De um ArrayBuffer +var buffer = new ArrayBuffer(8); +var z = new Int16Array(buffer, 0, 4); + +// De um interável +var iterable = function*(){ yield* [1,2,3]; }(); +var int16 = new Int16Array(iterable); +// Int16Array[1, 2, 3] +</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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Substituído pelo ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#table-49', 'TypedArray constructors')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial em um padrão ECMA. Especificado <code>new</code> como requerido.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>ECMAScript 2017 mudou o construtor <code>Int16Array</code> para usar a operação <code>ToIndex</code> e permitir construtores sem argumentos.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2> + + + +<p>{{Compat("javascript.builtins.Int16Array")}}</p> + +<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2> + +<p>A partir do ECMAScript 2015, os construtores <code>Int16Array</code> precisam ser construídos com um operador {{jsxref("Operators/new", "new")}}. Chamar um construtor <code>Int16Array</code> como uma função sem o <code>new</code>, irá resultar em {{jsxref("TypeError")}}.</p> + +<pre class="brush: js example-bad">var dv = Int16Array([1, 2, 3]); +// TypeError: calling a builtin Int16Array constructor +// without new is forbidden</pre> + +<pre class="brush: js example-good">var dv = new Int16Array([1, 2, 3]);</pre> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript typed arrays</a></li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("DataView")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/internalerror/index.html b/files/pt-br/web/javascript/reference/global_objects/internalerror/index.html new file mode 100644 index 0000000000..12de103329 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/internalerror/index.html @@ -0,0 +1,92 @@ +--- +title: InternalError +slug: Web/JavaScript/Reference/Global_Objects/InternalError +translation_of: Web/JavaScript/Reference/Global_Objects/InternalError +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>O <strong>objeto</strong> <strong><code>InternalError</code> </strong>indica que um erro ocorreu internamente na engine do JavaScript.</p> + +<p>Isso ocorre quando algo é muito grande, por exemplo:</p> + +<ul> + <li>"too many switch cases",</li> + <li>"too many parentheses in regular expression",</li> + <li>"array initializer too large",</li> + <li>"too much recursion".</li> +</ul> + +<h2 id="Construtor">Construtor</h2> + +<dl> + <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/InternalError/InternalError"><code>InternalError()</code></a></dt> + <dd>Cria um um novo objeto <code>InternalError</code>.</dd> +</dl> + +<h2 id="Instance_properties">Instance properties</h2> + +<dl> + <dt>{{jsxref("Error.prototype.message", "InternalError.prototype.message")}}</dt> + <dd>Error message. Inherited from {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.name", "InternalError.prototype.name")}}</dt> + <dd>Error name. Inherited from {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "InternalError.prototype.fileName")}}</dt> + <dd>Path to file that raised this error. Inherited from {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "InternalError.prototype.lineNumber")}}</dt> + <dd>Line number in file that raised this error. Inherited from {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "InternalError.prototype.columnNumber")}}</dt> + <dd>Column number in line that raised this error. Inherited from {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.stack", "InternalError.prototype.stack")}}</dt> + <dd>Stack trace. Inherited from {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Examples">Examples</h2> + +<h3 id="Too_much_recursion">Too much recursion</h3> + +<p>This recursive function runs 10 times, as per the exit condition.</p> + +<pre class="brush: js notranslate">function loop(x) { + if (x >= 10) // "x >= 10" is the exit condition + return; + // do stuff + loop(x + 1); // the recursive call +} +loop(0);</pre> + +<p>Setting this condition to an extremely high value, won't work:</p> + +<pre class="brush: js example-bad notranslate">function loop(x) { + if (x >= 1000000000000) + return; + // do stuff + loop(x + 1); +} +loop(0); + +// InternalError: too much recursion</pre> + +<p>For more information, see <a href="/en-US/docs/Web/JavaScript/Reference/Errors/Too_much_recursion">InternalError: too much recursion.</a></p> + +<h2 id="Specifications">Specifications</h2> + +<p><span class="pl-s">Not part of any standard.</span></p> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div> +<div> + + +<p>{{Compat("javascript.builtins.InternalError")}}</p> +</div> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li> + <p><a href="/en-US/docs/Web/JavaScript/Reference/Errors/Too_much_recursion">InternalError: too much recursion</a></p> + </li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/intl/datetimeformat/index.html b/files/pt-br/web/javascript/reference/global_objects/intl/datetimeformat/index.html new file mode 100644 index 0000000000..6c060cd838 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/intl/datetimeformat/index.html @@ -0,0 +1,188 @@ +--- +title: Intl.DateTimeFormat +slug: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat +--- +<div>{{JSRef}}</div> + +<p><span class="seoSummary">O objeto Intl.DateTimeFormat é um constructor para objetos que habilita o formato de data e hora no idioma padrão.</span> </p> + +<div>{{EmbedInteractiveExample("pages/js/intl-datetimeformat.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="Constructor">Constructor</h2> + +<dl> + <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/DateTimeFormat">Intl.DateTimeFormat()</a></code></dt> + <dd>Creates a new <code>DateTimeFormat</code> object.</dd> +</dl> + +<h2 id="Static_methods">Static methods</h2> + +<dl> + <dt>{{jsxref("DateTimeFormat.supportedLocalesOf", "Intl.DateTimeFormat.supportedLocalesOf()")}}</dt> + <dd>Returns an array containing those of the provided locales that are supported without having to fall back to the runtime's default locale.</dd> +</dl> + +<h2 id="Instance_methods">Instance methods</h2> + +<dl> + <dt>{{jsxref("DateTimeFormat.format", "Intl.DateTimeFormat.prototype.format()")}}</dt> + <dd>Getter function that formats a date according to the locale and formatting options of this {{jsxref("DateTimeFormat", "DateTimeFormat")}} object.</dd> + <dt>{{jsxref("DateTimeFormat.formatToParts", "Intl.DateTimeFormat.prototype.formatToParts()")}}</dt> + <dd>Returns an {{jsxref("Array")}} of objects representing the date string in parts that can be used for custom locale-aware formatting.</dd> + <dt>{{jsxref("DateTimeFormat.resolvedOptions", "Intl.DateTimeFormat.prototype.resolvedOptions()")}}</dt> + <dd>Returns a new object with properties reflecting the locale and formatting options computed during initialization of the object.</dd> + <dt>{{jsxref("DateTimeFormat.formatRange", "Intl.DateTimeFormat.prototype.formatRange()")}}</dt> + <dd>This method receives two <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/">Dates</a> and formats the date range in the most concise way based on the locale and options provided when instantiating {{jsxref("DateTimeFormat", "DateTimeFormat")}}.</dd> + <dt>{{jsxref("DateTimeFormat.formatRangeToParts", "Intl.DateTimeFormat.prototype.formatRangeToParts()")}}</dt> + <dd>This method receives two <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/">Dates</a> and returns an Array of objects containing the locale-specific tokens representing each part of the formatted date range.</dd> +</dl> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_DateTimeFormat">Using <code>DateTimeFormat</code></h3> + +<p>In basic use without specifying a locale, <code>DateTimeFormat</code> uses the default locale and default options.</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// toLocaleString without arguments depends on the implementation, +// the default locale, and the default time zone +console.log(new Intl.DateTimeFormat().format(date)); +// → "12/19/2012" if run with en-US locale (language) and time zone America/Los_Angeles (UTC-0800) +</pre> + +<h3 id="Using_locales">Using <code>locales</code></h3> + +<p>This example shows some of the variations in localized date and time formats. In order to get the format of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the <code>locales</code> argument:</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +// Results below use the time zone of America/Los_Angeles (UTC-0800, Pacific Standard Time) + +// US English uses month-day-year order +console.log(new Intl.DateTimeFormat('en-US').format(date)); +// → "12/19/2012" + +// British English uses day-month-year order +console.log(new Intl.DateTimeFormat('en-GB').format(date)); +// → "19/12/2012" + +// Korean uses year-month-day order +console.log(new Intl.DateTimeFormat('ko-KR').format(date)); +// → "2012. 12. 19." + +// Arabic in most Arabic speaking countries uses real Arabic digits +console.log(new Intl.DateTimeFormat('ar-EG').format(date)); +// → "١٩<span dir="rtl">/١٢/٢٠١٢</span>" + +// for Japanese, applications may want to use the Japanese calendar, +// where 2012 was the year 24 of the Heisei era +console.log(new Intl.DateTimeFormat('ja-JP-u-ca-japanese').format(date)); +// → "24/12/19" + +// when requesting a language that may not be supported, such as +// Balinese, include a fallback language, in this case Indonesian +console.log(new Intl.DateTimeFormat(['ban', 'id']).format(date)); +// → "19/12/2012" +</pre> + +<h3 id="Using_options">Using <code>options</code></h3> + +<p>The date and time formats can be customized using the <code>options</code> argument:</p> + +<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0, 200)); + +// request a weekday along with a long date +var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' }; +console.log(new Intl.DateTimeFormat('de-DE', options).format(date)); +// → "Donnerstag, 20. Dezember 2012" + +// an application may want to use UTC and make that visible +options.timeZone = 'UTC'; +options.timeZoneName = 'short'; +console.log(new Intl.DateTimeFormat('en-US', options).format(date)); +// → "Thursday, December 20, 2012, GMT" + +// sometimes you want to be more precise +options = { + hour: 'numeric', minute: 'numeric', second: 'numeric', + timeZone: 'Australia/Sydney', + timeZoneName: 'short' +}; +console.log(new Intl.DateTimeFormat('en-AU', options).format(date)); +// → "2:00:00 pm AEDT" + +// sometimes you want to be very precise +options.fractionalSecondDigits = 3; +console.log(new Intl.DateTimeFormat('en-AU', options).format(date)); +// → "2:00:00.200 pm AEDT" + + +// sometimes even the US needs 24-hour time +options = { + year: 'numeric', month: 'numeric', day: 'numeric', + hour: 'numeric', minute: 'numeric', second: 'numeric', + hour12: false, + timeZone: 'America/Los_Angeles' +}; +console.log(new Intl.DateTimeFormat('en-US', options).format(date)); +// → "12/19/2012, 19:00:00" + + +// to specify options but use the browser's default locale, use 'default' +console.log(new Intl.DateTimeFormat('default', options).format(date)); +// → "12/19/2012, 19:00:00" + +// sometimes it's helpful to include the period of the day +options = {hour: "numeric", dayPeriod: "short"}; +console.log(new Intl.DateTimeFormat('en-US', options).format(date)); +// → 10 at night +</pre> + +<p>The used calendar and numbering formats can also be set independently via <code>options</code> arguments:</p> + +<pre class="brush: js">var options = {calendar: 'chinese', numberingSystem: 'arab'}; +var dateFormat = new Intl.DateTimeFormat('default', options); +var usedOptions = dateFormat.resolvedOptions(); + +console.log(usedOptions.calendar); +// → "chinese" + +console.log(usedOptions.numberingSystem); +// → "arab" + +console.log(usedOptions.timeZone); +// → "America/New_York" (the users default timezone) +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES Int Draft', '#datetimeformat-objects', 'Intl.DateTimeFormat')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.DateTimeFormat")}}</p> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl">Intl</a></code></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/intl/index.html b/files/pt-br/web/javascript/reference/global_objects/intl/index.html new file mode 100644 index 0000000000..02e5b8f205 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/intl/index.html @@ -0,0 +1,168 @@ +--- +title: Intl +slug: Web/JavaScript/Reference/Global_Objects/Intl +translation_of: Web/JavaScript/Reference/Global_Objects/Intl +--- +<div>{{JSRef}}</div> + +<p>O objeto <strong><code>Intl</code></strong> é o namespace para a API de Internacionalização do ECMAScript , que fornece comparação de string sensível à línguagem, formatação de números, e formatação de data e hora. Os construtores para os objetos {{jsxref("Collator")}}, {{jsxref("NumberFormat")}}, e {{jsxref("DateTimeFormat")}} são propriedades do objecto <code>Intl</code>. Esta página documenta essas propriedades, bem como funcionalidades comuns aos construtores de internacionalização e outras funções sensíveis de linguagem.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</dt> + <dd>Construtor para <em>collators</em>, objetos que permitem comparação de string sensível a linguagem.</dd> + <dt>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</dt> + <dd>Construtor para objetos que permitem formatação de data e hora sensível a linguagem.</dd> + <dt>{{jsxref("Global_Objects/NumberFormat", "Intl.NumberFormat")}}</dt> + <dd>Construtor para objetos que permitem formatação de número sensível a linguagem.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("Intl.getCanonicalLocales()")}}</dt> + <dd>Retorna os nomes canônicos de local (ex.: en-US, pt-BR).</dd> +</dl> + +<h2 id="Identificação_e_negociação_de_local">Identificação e negociação de local</h2> + +<p>Os construtores de internacionalização, assim como diversos métodos de outros construtores que são sensíveis a idioma (listados em {{anch("See_also", "Veja também")}}) usam um padrão comum para identificar locais e determinar qual será utilizado: todos aceitam argumentos <code>locales</code> e <code>options</code> e negociam o(s) local(is) requisitado entre os locais suportados usando um algoritmo especificado na propriedade <code>options.localeMatcher</code>.</p> + +<h3 id="Argumento_locales">Argumento <code>locales</code></h3> + +<p>O argumento <code>locales</code> deve ser uma string contendo uma <a href="http://tools.ietf.org/html/rfc5646">tag de linguagem BCP 47</a> ou um array dessas tags. Se o argumento <code>locales</code> não for passado ou estiver indefinido, será utilizado o local padrão do runtime.</p> + +<p>Uma tag de linguagem BCP 47 identifica um idioma ou local (a diferença entre ambos neste caso é difusa). Em sua forma mais comum, ela pode conter, nesta ordem: um código de idioma, um código de escrita e um código de país, todos eparados por hífen. Exemplos:</p> + +<ul> + <li><code>"hi"</code>: Hindi.</li> + <li><code>"de-AT"</code>: Alemão como usado na Áustria.</li> + <li><code>"zh-Hans-CN"</code>: Chinês com escrita simplificada como usado na China.</li> +</ul> + +<p>As subtags identificando idiomas, escritas, países (regiões) e (raramente utilizadas) variantes nas tags de linguagem BCP 47 podem ser consultadas no <a href="http://www.iana.org/assignments/language-subtag-registry">Registro de Subtags de Linguagem da IANA</a>.</p> + +<p>BCP 47 também permite extensões, e uma delas é relevante para as funções JavaScript de internacionalização: a extensão <code>"u"</code> (Unicode). Ela pode ser utilizada para requisitar uma customização do comportamento específico local de um objeto {{jsxref("Collator")}}, {{jsxref("NumberFormat")}}, ou {{jsxref("DateTimeFormat")}}. Exemplos:</p> + +<ul> + <li><code>"de-DE-u-co-phonebk"</code>: Use the phonebook variant of the German sort order, which expands umlauted vowels to character pairs: ä → ae, ö → oe, ü → ue.</li> + <li><code>"th-TH-u-nu-thai"</code>: Use Thai digits (๐, ๑, ๒, ๓, ๔, ๕, ๖, ๗, ๘, ๙) in number formatting.</li> + <li><code>"ja-JP-u-ca-japanese"</code>: Use the Japanese calendar in date and time formatting, so that 2013 is expressed as the year 25 of the Heisei period, or 平成25.</li> +</ul> + +<h3 id="Locale_negotiation">Locale negotiation</h3> + +<p>The <code>locales</code> argument, after stripping off all Unicode extensions, is interpreted as a prioritized request from the application. The runtime compares it against the locales it has available and picks the best one available. Two matching algorithms exist: the <code>"lookup"</code> matcher follows the Lookup algorithm specified in <a href="http://tools.ietf.org/html/rfc4647#section-3.4">BCP 47</a>; the <code>"best fit"</code> matcher lets the runtime provide a locale that's at least, but possibly more, suited for the request than the result of the Lookup algorithm. If the application doesn't provide a <code>locales</code> argument, or the runtime doesn't have a locale that matches the request, then the runtime's default locale is used. The matcher can be selected using a property of the <code>options</code> argument (see below).</p> + +<p>If the selected language tag had a Unicode extension substring, that extension is now used to customize the constructed object or the behavior of the function. Each constructor or function supports only a subset of the keys defined for the Unicode extension, and the supported values often depend on the language tag. For example, the <code>"co"</code> key (collation) is only supported by {{jsxref("Collator")}}, and its <code>"phonebk"</code> value is only supported for German.</p> + +<h3 id="options_argument"><code>options</code> argument</h3> + +<p>The <code>options</code> argument must be an object with properties that vary between constructors and functions. If the <code>options</code> argument is not provided or is undefined, default values are used for all properties.</p> + +<p>One property is supported by all language sensitive constructors and functions: The <code>localeMatcher</code> property, whose value must be a string <code>"lookup"</code> or <code>"best fit"</code> and which selects one of the locale matching algorithms described above.</p> + +<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('ES Int 1.0', '#sec-8', 'Intl')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-8', 'Intl')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#intl-object', 'Intl')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td>Added Intl.getCanonicalLocales in the 4th edition.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</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 (WebKit)</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatChrome("24")}}</td> + <td>{{CompatGeckoDesktop("29")}}</td> + <td>{{CompatIE("11")}}</td> + <td>{{CompatOpera("15")}}</td> + <td>{{CompatSafari("10.0")}} [2]</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 Phone</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("26")}}</td> + <td>{{CompatGeckoMobile("54")}} (nightly-only) [1]</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari("10.0")}} [2]</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] Starting with Gecko 44 {{geckoRelease(44)}}, the Intl API is available on <a href="https://people.mozilla.org/~fdesre/b2gdroid/">b2gdroid</a>.<br> + [2] <a href="https://developer.apple.com/library/content/releasenotes/General/WhatsNewInSafari/Articles/Safari_10_0.html">Safari 10.0 Release Notes</a></p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>Introduction: <a href="http://norbertlindenberg.com/2012/12/ecmascript-internationalization-api/index.html">The ECMAScript Internationalization API</a></li> + <li>Constructors + <ul> + <li>{{jsxref("Collator", "Intl.Collator")}}</li> + <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li> + </ul> + </li> + <li>Methods + <ul> + <li>{{jsxref("String.prototype.localeCompare()")}}</li> + <li>{{jsxref("Number.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li> + </ul> + </li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/intl/numberformat/index.html b/files/pt-br/web/javascript/reference/global_objects/intl/numberformat/index.html new file mode 100644 index 0000000000..ac698fd883 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/intl/numberformat/index.html @@ -0,0 +1,242 @@ +--- +title: Intl.NumberFormat +slug: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat +tags: + - Internacionalização + - JavaScript + - NumberFormat +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat +--- +<h5 id="JSRef">{{JSRef}}</h5> + +<p>O objeto <strong><code>Intl.NumberFormat</code></strong> é um construtor para objetos que habilita formatação de número sensível a linguagem.</p> + +<p>{{EmbedInteractiveExample("pages/js/intl-numberformat.html")}}</p> + +<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</a> and send us a pull request.</p> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>new Intl.NumberFormat([<var>locales</var>[, <var>options</var>]]) +Intl.NumberFormat.call(<var>this</var>[, <var>locales</var>[, <var>options</var>]]) +</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>locales</code></dt> + <dd> + <p>Opcional. Uma string com uma tag de linguagem BCP 47 ou uma matriz delas. Para a forma geral e interpretação do argumento <code>locales</code>, veja {{jsxref("Intl", "Intl page", "#Locale_identification_and_negotiation", 1)}}. A seguinte chave extendida Unicode é permitida:</p> + + <dl> + <dt><code>nu</code></dt> + <dd>O sistema de numeração que será usado. Os valores permitidos são: <code>"arab"</code>, <code>"arabext"</code>, <code>"bali"</code>, <code>"beng"</code>, <code>"deva"</code>, <code>"fullwide"</code>, <code>"gujr"</code>, <code>"guru"</code>, <code>"hanidec"</code>, <code>"khmr"</code>, <code>"knda"</code>, <code>"laoo"</code>, <code>"latn"</code>, <code>"limb"</code>, <code>"mlym"</code>, <code>"mong"</code>, <code>"mymr"</code>, <code>"orya"</code>, <code>"tamldec"</code>, <code>"telu"</code>, <code>"thai"</code>, <code>"tibt"</code>.</dd> + </dl> + </dd> + <dt><code>options</code></dt> + <dd> + <p>Opcional. Um objeto com alguns ou todas as seguintes propriedades:</p> + + <dl> + <dt><code>localeMatcher</code></dt> + <dd>O algoritmo de comparação de localização para utilizar. Os valores permitidos são <code>"lookup"</code> e <code>"best fit"</code>; o padrão é <code>"best fit"</code>. Para mais informações sobre esta opção, veja {{jsxref("Global_Objects/Intl", "Intl page", "#Locale_negotiation", 1)}}.</dd> + <dt><code>style</code></dt> + <dd>O estilo do formato a ser utilizado. Os valores permitidos são <code>"decimal"</code> para formato de número simples, <code>"currency"</code> para formato monetário e <code>"percent"</code> para formato percentual; o padrão é <code>"decimal"</code>.</dd> + <dt><code>currency</code></dt> + <dd>A moeda para usar na formatação monetária. Os valores permitidos são os códigos de moedas da ISO 4217, como <code>"USD"</code> para dólar estadunidense, <code>"EUR"</code> para euro, ou <code>"CNY"</code> para RMB chinês — veja a <a href="http://www.currency-iso.org/en/home/tables/table-a1.html">Lista de códigos de moedas e fundos atuais</a>. Não há valor padrão; se o <code>style</code> for <code>"currency"</code>, a propriedade <code>currency</code> deverá ser informada.</dd> + <dt><code>currencyDisplay</code></dt> + <dd>Como será mostrada a moeda na formatação monetária. Os valores permitidos são<code> "symbol"</code> para usar um símbolo de moeda localizado como €, <code>"code"</code> para usar o código de moeda ISO, <code>"name"</code> para usar o nome da moeda localizado como <code>"dollar"</code>; o padrão é <code>"symbol"</code>.</dd> + <dt><code>useGrouping</code></dt> + <dd>Se usar separadores de agrupamento, como separadores de milhares ou milhares/cem mil/dez milhões. Os valores permitidos são <code>true</code> e <code>false</code>; o padrão é <code>true</code>.</dd> + </dl> + + <p>As próximas propriedades se dividem em dois grupos: <code>minimumIntegerDigits</code>, <code>minimumFractionDigits</code>, e <code>maximumFractionDigits</code> no primeiro grupo, <code>minimumSignificantDigits</code> and <code>maximumSignificantDigits</code> em outro. Se pelo menos uma propriedade do segundo grupo for informado, então o primeiro grupo é ignorado.</p> + + <dl> + <dt><code>minimumIntegerDigits</code></dt> + <dd>A quantidade mínima de dígitos inteiros para utilizar. É possível usar valores de 1 a 21; o padrão é 1.</dd> + <dt><code>minimumFractionDigits</code></dt> + <dd>A quantidade mínima de dígitos fracionados para utilizar. É possível usar valores de 0 a 20; o padrão para formatos de números simples e percentuais é 0; o padrão para formatos monetários é a menor unidade de dígitos fornecidos pela <a href="http://www.currency-iso.org/en/home/tables/table-a1.html">lista de códigos de moedas ISO 4217</a> (2 se a lista não fornecer a informação).</dd> + <dt><code>maximumFractionDigits</code></dt> + <dd>O número máximo de dígitos fracionados para utilizar. É possível usar valores de 0 a 20; o padrão para a formatação de número simples é o maior entre <code>minimumFractionDigits</code> e 3; o padrão para formatos monetários é o maior número de dígitos entre <code>minimumFractionDigits</code> e o fornecido pela <a href="http://www.currency-iso.org/en/home/tables/table-a1.html">lista de códigos de moedas ISO 4217</a> (2 se a lista não fornecer a informação); o padrão para a formatação percentual é o maior número entre <code>minimumFractionDigits</code> e 0.</dd> + <dt><code>minimumSignificantDigits</code></dt> + <dd>A quantidade mínima de dígitos significantes para usar. Os valores permitidos são de 1 a 21; o padrão é 1.</dd> + <dt><code>maximumSignificantDigits</code></dt> + <dd>A quantidade máxima de dígitos significantes para usar. Os valores permitidos são de 1 a 21; o padrão é <code>minimumSignificantDigits</code>.</dd> + </dl> + </dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<h3 id="Propriedades">Propriedades</h3> + +<dl> + <dt>{{jsxref("NumberFormat.prototype", "Intl.NumberFormat.prototype")}}</dt> + <dd>Pertime a inclusão de propriedades a todos os objetos.</dd> +</dl> + +<h3 id="Métodos">Métodos</h3> + +<dl> + <dt>{{jsxref("NumberFormat.supportedLocalesOf", "Intl.NumberFormat.supportedLocalesOf()")}}</dt> + <dd>Retorna uma matriz contendo as localizações fornecidas que são suportadas sem retornar a localização padrão em tempo de execução.</dd> +</dl> + +<h2 id="Instâncias_NumberFormat">Instâncias <code>NumberFormat</code></h2> + +<h3 id="Propriedades_2">Propriedades</h3> + +<p>As instâncias de <code>NumberFormat</code> herdam as seguntes propriedades de seu protótipo:</p> + +<div>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype', 'Propriedades')}}</div> + +<h3 id="Methods">Methods</h3> + +<p>As instâncias de <code>NumberFormat</code> herdam os seguintes métodos de seu protótipo:</p> + +<div>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype', 'Métodos')}}</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Uso_básico">Uso básico</h3> + +<p>No uso básico sem a especificação de uma localização, o método retornará uma string formatada com a localização e as opções padrão.</p> + +<pre class="brush: js">var numero = 3500; + +console.log(new Intl.NumberFormat().format(numero)); +// → '3,500' se a localização for U.S. English +</pre> + +<h3 id="Usando_locales">Usando <code>locales</code></h3> + +<p>Este exemplo mostra algumas variações de formatos de números localizados. A fim de obter o formato da linguagem utilizada na interface do usuário da sua aplicação, tenha certeza de especificar a língua (e possivelmente algumas línguas reservas) usando o argumento<code> locales</code>:</p> + +<pre class="brush: js">var numero = 123456.789; + +// O alemão usa vírgula como separador de decimal e ponto para milhares +console.log(new Intl.NumberFormat('de-DE').format(numero)); +// → 123.456,789 + +// O árabe usa dígitos reais árabes em muitos países que falam árabe +console.log(new Intl.NumberFormat('ar-EG').format(numero)); +// → ١٢٣٤٥٦٫٧٨٩ + +// A Índia usa separadores de milhares/cem mil/dez milhões +console.log(new Intl.NumberFormat('en-IN').format(numero)); +// → 1,23,456.789 + +// A chave de extensão nu requer um sistema de numeração, ex. decimal chinês +console.log(new Intl.NumberFormat('zh-Hans-CN-u-nu-hanidec').format(numero)); +// → 一二三,四五六.七八九 + +// Quando informada uma língua sem suporte, como balinês, +// inclua uma língua reseva, neste caso indonésio +console.log(new Intl.NumberFormat(['ban', 'id']).format(numero)); +// → 123.456,789 +</pre> + +<h3 id="Usando_options">Usando <code>options</code></h3> + +<p>Os resultados podem ser personalizados usando o argumento <code>options</code>:</p> + +<pre class="brush: js">var numero = 123456.789; + +// informando um formato de moeda +console.log(new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'EUR' }).format(numero)); +// → 123.456,79 € + +// o yen japonês não tem uma unidade menor +console.log(new Intl.NumberFormat('ja-JP', { style: 'currency', currency: 'JPY' }).format(numero)); +// → ￥123,457 + +// limitando a três dígitos significativos +console.log(new Intl.NumberFormat('en-IN', { maximumSignificantDigits: 3 }).format(numero)); +// → 1,23,000 +</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('ES Int 1.0', '#sec-11.1', 'Intl.NumberFormat')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-11.1', 'Intl.NumberFormat')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#numberformat-objects', 'Intl.NumberFormat')}}</td> + <td>{{Spec2('ES Int Draft')}}</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>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatChrome("24")}}</td> + <td>{{CompatGeckoDesktop("29")}}</td> + <td>{{CompatIE("11")}}</td> + <td>{{CompatOpera("15")}}</td> + <td>{{CompatNo}}</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 Phone</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("26")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<div>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Intl', 'Veja_tambem')}}</div> diff --git a/files/pt-br/web/javascript/reference/global_objects/intl/numberformat/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/intl/numberformat/prototype/index.html new file mode 100644 index 0000000000..badd2d1946 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/intl/numberformat/prototype/index.html @@ -0,0 +1,125 @@ +--- +title: Intl.NumberFormat.prototype +slug: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/prototype +tags: + - Internacionalização + - JavaScript + - NumberFormat + - Property + - Propriedade + - Prototipo + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Intl.NumberFormat.prototype</code></strong> representa o objeto do protótipo do construtor de {{jsxref("NumberFormat", "Intl.NumberFormat")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Veja {{jsxref("NumberFormat")}} para uma descrição sobre instâncias de <code>Intl.NumberFormat</code>.</p> + +<p>As instâncias de {{jsxref("NumberFormat", "Intl.NumberFormat")}} herdam de <code>Intl.NumberFormat.prototype</code>. Modificações ao objeto do protótipo são herdados por todas as instâncias de {{jsxref("NumberFormat", "Intl.NumberFormat")}}.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>Intl.NumberFormat.prototype.constructor</code></dt> + <dd>Uma referência a <code>Intl.NumberFormat</code>.</dd> + <dt>{{jsxref("NumberFormat.format", "Intl.NumberFormat.prototype.format")}}</dt> + <dd>Getter; retorna uma função que formata um número de acordo com a localização e as opçõe de formatação do objeto {{jsxref("NumberFormat")}}.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("NumberFormat.resolvedOptions", "Intl.NumberFormat.prototype.resolvedOptions()")}}</dt> + <dd>Retorna um novo objeto com propriedades refletindo a localização e as opções de agrupamento obtidos durante a inicialização do objeto.</dd> +</dl> + +<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('ES Int 1.0', '#sec-11.2.1', 'Intl.NumberFormat.prototype')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-11.2.1', 'Intl.NumberFormat.prototype')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.prototype', 'Intl.NumberFormat.prototype')}}</td> + <td>{{Spec2('ES Int Draft')}}</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>Características</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatChrome("24")}}</td> + <td>{{CompatGeckoDesktop("29")}}</td> + <td>{{CompatIE("11")}}</td> + <td>{{CompatOpera("15")}}</td> + <td>{{CompatNo}}</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 Phone</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("26")}}</td> + <td>{{CompatNo}}</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("NumberFormat", "Intl.NumberFormat")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/intl/relativetimeformat/index.html b/files/pt-br/web/javascript/reference/global_objects/intl/relativetimeformat/index.html new file mode 100644 index 0000000000..bc6b5c0b22 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/intl/relativetimeformat/index.html @@ -0,0 +1,171 @@ +--- +title: Intl.RelativeTimeFormat +slug: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat +tags: + - Internacionalização + - Intl +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat +--- +<div>{{JSRef}}</div> + +<p>O objeto <strong><code>Intl.RelativeTimeFormat</code></strong> é um construtor de objetos que permitem uma formatação de tempo relativa sensível ao idioma.</p> + +<div>{{EmbedInteractiveExample("pages/js/intl-relativetimeformat.html")}}</div> + +<p class="hidden">A fonte deste exemplo interativo está armazenada num repositório no GitHub. Se você quiser contribuir para o projeto de exemplos interativos, 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><code>new Intl.RelativeTimeFormat([<var>locales</var>[, <var>options</var>]]) +</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>locales</code></dt> + <dd> + <p>Opcional. Uma string com uma tag da linguagem BCP 47, ou um array dessas strings. Para a forma geral e interpretação do argumento <code>locales</code> , acesse: {{jsxref("Global_Objects/Intl", "Página Intl", "#Locale_identification_and_negotiation", 1)}}.</p> + </dd> + <dt><code>options</code></dt> + <dd>Opcional. Um objeto com algumas ou todas as seguintes propriedades: + <ul> + <li><code>localeMatcher</code><br> + O algoritmo para comparação de local a ser usado. Os valores possíveis são <code>"lookup"</code> e <code>"best fit"</code>; o padrão é <code>"best fit"</code>. Para informações sobre esta opção, veja <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation" rel="nofollow"><code>Intl</code></a>.</li> + <li><code>numeric</code><br> + O formato de saída da mensagem. Valores possíveis são: + <ul> + <li><code>"always"</code> (padrão, e.g., <code>há 1 dia</code>),</li> + <li>ou <code>"auto"</code> (e.g., <code>ontem</code>). O valor<code>"auto"</code> permite que não seja sempre necessário o uso de valores númericos na saída.</li> + </ul> + </li> + <li><code>style</code><br> + O comprimento da mensagem internacionalizada. Valores possíveis são: + <ul> + <li><code>"long"</code> (padrão, e.g., <code>in 1 month</code>)</li> + <li><code>"short"</code> (e.g., <code>in 1 mo.</code>),</li> + <li>ou <code>"narrow"</code> (e.g., <code>in 1 mo.</code>). O estilo narrow pode ser similar ao short em alguns locais.</li> + </ul> + </li> + </ul> + </dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<h3 id="Propriedades">Propriedades</h3> + +<dl> + <dt>{{jsxref("RelativeTimeFormat.prototype", "Intl.RelativeTimeFormat.prototype")}}</dt> + <dd>Permite a adição de propriedades para todos os objetos.</dd> +</dl> + +<h3 id="Métodos">Métodos</h3> + +<dl> + <dt>{{jsxref("RelativeTimeFormat.supportedLocalesOf", "Intl.RelativeTimeFormat.supportedLocalesOf()")}}</dt> + <dd>Retorna um array contendo os valores disponíveis dentre os que foram passados como parâmetro sem ter de recorrer ao local padrão do ambiente.</dd> +</dl> + +<h2 id="Instâncias_RelativeTimeFormat">Instâncias <code>RelativeTimeFormat</code> </h2> + +<h3 id="Propriedades_2">Propriedades</h3> + +<p>Instâncias <code>RelativeTimeFormat</code> herdam as seguintes propriedades do seu protótipo:</p> + +<p>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/RelativeTimeFormat/prototype', 'Properties')}}</p> + +<h3 id="Métodos_2">Métodos</h3> + +<p>Instâncias <code>RelativeTimeFormat</code> herdam as seguintes propriedades do seu protótipo:</p> + +<p>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/RelativeTimeFormat/prototype', 'Methods')}}</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Uso_básico_do_format">Uso básico do <code>format</code></h3> + +<p>O exemplo a seguir mostra como criar um formatador de tempo relativo usando a língua portuguesa.</p> + +<pre class="brush: js">// Crie um formatador de tempo relativo no seu local +// com os valores padrão sendo passados explicitamente. +const rtf = new Intl.RelativeTimeFormat("pt", { + localeMatcher: "best fit", // outros valores: "lookup" + numeric: "always", // outros valores: "auto" + style: "long", // outros valores: "short" ou "narrow" +}); + +// Formatação de tempo relativa usando valor negativo (-1). +rtf.format(-1, "day"); +// > "há 1 dia" + +// Formatação de tempo relativa usando valor positivo (1). +rtf.format(1, "day"); +// > "em 1 dia"</pre> + +<h3 id="Usando_a_opção_auto">Usando a opção <code>auto</code></h3> + +<p>Se a opção <code>numeric:auto</code> é passada, serão produzidas as strings <code>ontem</code> ou <code>amanhã</code> ao invés de <code>há 1 dia</code> ou <code>em 1 dia</code>. Isso permite que não seja necessário sempre utilizar valores numéricos na saída.</p> + +<pre class="brush: js">// Crie um formatador de tempo relativo no seu local +// com o valor "auto" passado para a propriedade numeric. +const rtf = new Intl.RelativeTimeFormat("pt", { numeric: "auto" }); + +// Formatação de tempo relativa usando valor negativo (-1). +rtf.format(-1, "day"); +// > "ontem" + +// Formatação de tempo relativa usando valor positivo (1). +rtf.format(1, "day"); +// > "amanhã" +</pre> + +<h3 id="Usando_formatToParts">Usando <code>formatToParts</code></h3> + +<p>O exemplo a seguir mostra como criar um formatador de tempo relativo que retorna partes formatadas</p> + +<pre class="brush: js">const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" }); + +// Formatação de tempo relativa usando a unidade day. +rtf.formatToParts(-1, "day"); +// > [{type: "literal", value: "ontem"}] + +rtf.formatToParts(100, "day"); +// > [{type: "literal", value: "em "}, +// > { type: "integer", value: "100", unit: "day" }, +// > {type: "literal", value: " dias"] +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Estágio</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td><a href="https://tc39.github.io/proposal-intl-relative-time/#sec-intl-relativetimeformat-constructor">Intl.RelativeTime proposal</a></td> + <td>Stage 3</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_Browsers">Compatibilidade com Browsers</h2> + +<div> + + +<p>{{Compat("javascript.builtins.Intl.RelativeTimeFormat")}}</p> + +<p> </p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="https://developers.google.com/web/updates/2018/10/intl-relativetimeformat">The Intl.RelativeTimeFormat API</a></li> +</ul> + +<p> </p> +</div> diff --git a/files/pt-br/web/javascript/reference/global_objects/isfinite/index.html b/files/pt-br/web/javascript/reference/global_objects/isfinite/index.html new file mode 100644 index 0000000000..962bbca928 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/isfinite/index.html @@ -0,0 +1,128 @@ +--- +title: isFinite() +slug: Web/JavaScript/Reference/Global_Objects/isFinite +translation_of: Web/JavaScript/Reference/Global_Objects/isFinite +--- +<div>{{jsSidebar("Objects")}}</div> + +<p><code><font face="Open Sans, Arial, sans-serif">A função global </font><strong>isFinite()</strong></code> determina se o valor transmitido é um número finito. Se necessário, o parâmetro é primeiro convertido a um número.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox">isFinite(<em>testValue</em>)</pre> + +<h3 id="Parametros">Parametros</h3> + +<dl> + <dt><code>testValue</code></dt> + <dd>O valor a ser testado para a finitude</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p><code>isFinite</code> é uma função de nível superior é não é associada com qualquer objeto.</p> + +<p>Você pode usar esta função para determinar se um número é um número finito. <code>A função isFinite</code> examina o número em seu argumento. Se o argumento é <code>NaN</code>, positivo infinito, ou negativo infinito, este método retorna <code>false</code>; de outra forma , ele retorna <code>true</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js">isFinite(Infinity); // false +isFinite(NaN); // false +isFinite(-Infinity); // false + +isFinite(0); // true +isFinite(2e64); // true +isFinite(null); // true + + +isFinite("0"); // true, teria sido false com o + // mais robusto Number.isFinite("0") +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.2.5', 'isFinite')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-isfinite-number', 'isFinite')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibilidade">Browser compatibilidade</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>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> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Number.NaN()")}}</li> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> + <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/isnan/index.html b/files/pt-br/web/javascript/reference/global_objects/isnan/index.html new file mode 100644 index 0000000000..5e36f9da27 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/isnan/index.html @@ -0,0 +1,109 @@ +--- +title: isNaN() +slug: Web/JavaScript/Reference/Global_Objects/isNaN +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/isNaN +--- +<div>{{jsSidebar("Objects")}}</div> + +<p>A função <strong><code>isNAN()</code></strong> determina se o valor é {{jsxref("Global_Objects/NaN", "NaN")}} ou não. Tenha cuidado, o <code>cast</code> em <code>isNaN</code> tem regras para serem observadas. Você pode ficar interessado no {{jsxref("Number.isNaN()")}} que foi definido no ECMAScript 6 ou você pode usar <code>typeof</code> para determinar se o valor é Not-A-Number, <code>NaN</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/globalprops-isnan.html")}}</div> + +<h2 id="Syntax" name="Syntax">Syntaxe</h2> + +<pre class="syntaxbox notranslate"><code>isNaN(<em>value</em>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>value</code></dt> + <dd>O valor a ser testado.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p><strong><code>true</code></strong> se o valor for {{jsxref("NaN")}}; otherwise, <strong><code>false</code></strong>.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<h3 id="The_necessity_of_an_isNaN_function" name="The_necessity_of_an_isNaN_function">A necessidade da função <code>isNaN</code></h3> + +<p>Ao contrário de todas as outras possibilidades de valores no JavaScript, não é possivel confiar nos operadores de igualdade <code>(== e ===)</code> para determina se o valor é {{jsxref("Global_Objects/NaN", "NaN")}} ou não, porque ambos, <code>NaN == NaN e NaN === NaN</code>, terá como valor de retorno:<code> false</code>. Daí a necessidade da funçao <code>isNAN</code>.</p> + +<h3 id="Origin_of_NaN_values" name="Origin_of_NaN_values">Origem dos valores <code>NaN</code></h3> + +<p>Os valores <code>NaN</code> são gerados quando operações aritiméticas tem como valores: <em>undefined</em> ou<em> unrepresentable</em>. Como valores, não fazem necessariamente condições de estouro. <code>NaN</code> também resulta da tentativa de coerção para valores numéricos, de valores não numéricos, para que o valor numérico primitivo seja disponível.</p> + +<p>Por exemplo, divida zero por zero e o resultado será <code>NaN</code> , mas se dividir outros números por zero ele não será.</p> + +<h3 id="Comportamento_confuso_do_caso_especial">Comportamento confuso do caso especial</h3> + +<p><span id="result_box" lang="pt"><span title="Since the very earliest versions of the isNaN function specification, its behavior for non-numeric arguments has been confusing.">Desde as primeiras versões da especificação da função isNaN , o seu comportamento para argumentos não numéricos tem sido confuso. </span><span title="When the argument to the isNaN function is not of type Number, the value is first coerced to a Number.">Quando o argumento para a função <code>isNaN</code> não é do tipo<em> </em></span></span><em><span id="result_box" lang="pt"><span title="When the argument to the isNaN function is not of type Number, the value is first coerced to a Number.">Numbe</span></span></em><span id="result_box" lang="pt"><span title="When the argument to the isNaN function is not of type Number, the value is first coerced to a Number."><em>r</em>, o valor é primeiro convertido para um número. </span><span title='The resulting value is then tested to determine whether it is {{jsxref("Global_Objects/NaN", "NaN")}}.'>O valor resultante é em seguida testado para determinar se se trata de</span></span><span lang="pt"><span title='The resulting value is then tested to determine whether it is {{jsxref("Global_Objects/NaN", "NaN")}}.'> </span></span>{{jsxref("Number.isNaN()")}}. <span lang="pt"><span title='Thus for non-numbers that when coerced to numeric type result in a valid non-NaN numeric value (notably the empty string and boolean primitives, which when coerced give numeric values zero or one), the "false" returned value may be unexpected;'>Assim, para os não-números que quando forçados ao tipo numérico resultado em um valor numérico não-<code>NaN</code> válido (particularmente strings vazias e primitivas booleanas, que quando submetidas ao <code>cast</code> dão valores numéricos zero ou um), o "falso" valor retornado pode ser inesperado; </span><span title='the empty string, for example, is surely "not a number."'>a cadeia vazia , por exemplo, é certamente "not-a-number" </span><span title='The confusion stems from the fact that the term, "not a number", has a specific meaning for numbers represented as IEEE-794 floating-point values.'>A confusão decorre do fato de que o termo, " não é um número " , tem um significado específico para os números representados como valores de ponto flutuante IEEE- 794 . </span><span title="The function should be interpreted as answering the question, "is this value, when coerced to a numeric value, an IEEE-794 'Not A Number' value?"">A função deve ser interpretada como respondendo à pergunta: "este valor, quando convertido para um valor numérico, um valor IEEE -794 ' not-a-number"?</span></span></p> + +<p>A ultima versão do ECMAScript (ES6) contém A função {{jsxref("Number.isNaN()")}}. <code>Number.isNaN(x)</code> será a real forma para testar se x é NaN ou não. Mesmo com <code>Number.isNaN</code>, porém, o significado de NaN continua ser a precisão numérica, e não simplesmente, "não é um número = <code>NaN</code>, <em>not a number</em>". Paralelamente , na expressão <code>Number.isNaN</code>, a expressão<code> (x != x)</code> é a forma mais confiável para testar se a variável <code>x </code>é<code> NaN</code> ou não, assim o resultado não é sujeito ao falso positivo que faz <code>isNaN</code> não ser confiável.</p> + +<p>A polyfill for <code>isNaN</code> would be (the polyfill leverages the unique never-equal-to-itself characteristic of <code>NaN</code>):</p> + +<pre class="brush: js notranslate">var isNaN = function(value) { + var n = Number(value); + return n !== n; +};</pre> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<pre class="brush: js notranslate">isNaN(NaN); // true +isNaN(undefined); // true +isNaN({}); // true + +isNaN(true); // false +isNaN(null); // false +isNaN(37); // false + +// strings +isNaN("37"); // false: "37" is converted to the number 37 which is not NaN +isNaN("37.37"); // false: "37.37" is converted to the number 37.37 which is not NaN +isNaN(""); // false: the empty string is converted to 0 which is not NaN +isNaN(" "); // false: a string with spaces is converted to 0 which is not NaN + +// dates +isNaN(new Date()); // false +isNaN(new Date().toString()); // true + +// Esse é um falso positivo e é a razão para isNaN não seja totalmente confiável. +isNaN("blabla") // true: "blabla" é convertido para número. + // A análise desse número falha e retorna NaN como resultado. +</pre> + +<h3 id="Useful_special-case_behavior">Useful special-case behavior</h3> + +<p>There is a more usage oriented way to think of <code>isNaN()</code>: If <code>isNaN(x)</code> returns <code>false</code>, you can use <code>x</code> in an arithmetic expression not making the expression return <code>NaN</code>. If it returns <code>true</code>, <code>x</code> will make every arithmetic expression return <code>NaN</code>. This means that in JavaScript, <code>isNaN(x) == true</code> is equivalent to <code>x - 0</code> returning <code>NaN</code> (though in JavaScript <code>x - 0 == NaN</code> always returns false, so you can't test for it). Actually, <code>isNaN(x)</code>, <code>isNaN(x - 0)</code>, <code>isNaN(Number(x))</code>, <code>Number.isNaN(x - 0)</code>, and <code>Number.isNaN(Number(x))</code> always return the same and in JavaScript <code>isNaN(x)</code> is just the shortest possible form to express each of these terms.</p> + +<p>You can use this, for example, to test whether an argument to a function is arithmetically processable (usable "like" a number), or if it's not and you have to provide a default value or something else. This way you can have a function that makes use of the full versatility JavaScript provides by implicitly converting values depending on context.</p> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-isnan-number', 'isNaN')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + + + +<p>{{Compat("javascript.builtins.isNaN")}}</p> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("NaN")}}</li> + <li>{{jsxref("Number.isNaN()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/iterador/index.html b/files/pt-br/web/javascript/reference/global_objects/iterador/index.html new file mode 100644 index 0000000000..1d00706e61 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/iterador/index.html @@ -0,0 +1,184 @@ +--- +title: Iterator +slug: Web/JavaScript/Reference/Global_Objects/Iterador +translation_of: Archive/Web/Iterator +--- +<div>{{jsSidebar("Objects")}}</div> + +<div class="warning"><strong>Non-standard.</strong> The <code><strong>Iterator</strong></code> function is a SpiderMonkey-specific feature, and will be removed at some point. For future-facing usages, consider using <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of" title="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for..of</a> loops and the <a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">iterator protocol</a>.</div> + +<p>A função <code><strong>Iterator</strong></code> retorna um objeto que implementa o protocolo legado do iterador e itera sobre propriedades enumeraveis do objeto.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">Iterator(<var>object</var>, [keyOnly])</pre> + +<h3 id="Parametros">Parametros</h3> + +<dl> + <dt><code>Objeto</code></dt> + <dd><span style="background-color: #ffffff; font-size: 1rem; font-style: inherit; font-weight: inherit; letter-spacing: -0.00278rem;">Objeto que itera sobre as propriedades</span></dd> + <dd>Se <code>keyOnly</code> for um valor verdadeiro, <code>Iterator.prototype.next</code> retorna somente o <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">nome_da_propriedade</span></font>.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>Returns <code>Iterator</code> instance that iterates over <code>object</code>. <code>Iterator</code> instance returns <code>[property_name, property_value]</code> array for each iteration if <code>keyOnly</code> is falsy, otherwise, if <code>keyOnly</code> is truthy, it returns <code>property_name</code> for each iteration. If <code>object</code> is the <code>Iterator</code> instance or {{jsxref("Generator")}} instance, it returns <code>object</code> itself.</p> + +<h2 id="Properties">Properties</h2> + +<dl> + <dt><code><strong>Iterator.prototype[@@iterator]</strong></code></dt> + <dd>Returns a function that returns iterator object, that conforms to {{jsxref("Iteration_protocols", "iterator protocol", "", 1)}}.</dd> +</dl> + +<h2 id="Methods">Methods</h2> + +<dl> + <dt><code><strong>Iterator.prototype.next</strong></code></dt> + <dd>Returns next item in the <code>[property_name, property_value]</code> format or <code>property_name</code> only. It throws <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/StopIteration">StopIteration</a></code> if there are no more items.</dd> +</dl> + +<h2 id="Examples">Examples</h2> + +<h3 id="Iterating_over_properties_of_an_object">Iterating over properties of an object</h3> + +<pre class="brush: js">var a = { + x: 10, + y: 20, +}; +var iter = Iterator(a); +console.log(iter.next()); // ["x", 10] +console.log(iter.next()); // ["y", 20] +console.log(iter.next()); // throws StopIteration +</pre> + +<h3 id="Iterating_over_properties_of_an_object_with_legacy_destructuring_for-in_statement">Iterating over properties of an object with legacy destructuring <code>for-in</code> statement</h3> + +<pre class="brush: js">var a = { + x: 10, + y: 20, +}; + +for (var [name, value] in Iterator(a)) { + console.log(name, value); // x 10 + // y 20 +} +</pre> + +<h3 id="Iterating_with_for-of">Iterating with <code>for-of</code></h3> + +<pre class="brush: js">var a = { + x: 10, + y: 20, +}; + +for (var [name, value] of Iterator(a)) { // @@iterator is used + console.log(name, value); // x 10 + // y 20 +} +</pre> + +<h3 id="Iterates_over_property_name">Iterates over property name</h3> + +<pre class="brush: js">var a = { + x: 10, + y: 20, +}; + +for (var name in Iterator(a, true)) { + console.log(name); // x + // y +} +</pre> + +<h3 id="Passing_Generator_instance">Passing Generator instance</h3> + +<pre class="brush: js">function f() { + yield "a"; + yield "b"; +} +var g = f(); + +console.log(g == Iterator(g)); // true + +for (var v in Iterator(g)) { + console.log(v); // a + // b +} +</pre> + +<h3 id="Passing_Iterator_instance">Passing Iterator instance</h3> + +<pre class="brush: js">var a = { + x: 10, + y: 20, +}; + +var i = Iterator(a); + +console.log(i == Iterator(i)); // true +</pre> + +<h2 id="Specifications">Specifications</h2> + +<p>Non-standard. Not part of any current standards document.</p> + +<h2 id="Browser_compatibility">Browser compatibility</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>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/JavaScript/Guide/Iterators_and_Generators" title="/en-US/docs/JavaScript/Guide/Iterators_and_Generators">Iterators and Generators</a></li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/StopIteration">StopIteration</a></code></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/json/index.html b/files/pt-br/web/javascript/reference/global_objects/json/index.html new file mode 100644 index 0000000000..52b1fa0a7f --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/json/index.html @@ -0,0 +1,241 @@ +--- +title: JSON +slug: Web/JavaScript/Reference/Global_Objects/JSON +tags: + - JSON + - JavaScript + - NeedsTranslation + - Object + - Reference + - Référence(2) + - TopicStub + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/JSON +--- +<div>{{JSRef("Global_Objects", "JSON")}}</div> + +<h2 id="Summary" name="Summary"><span class="short_text" id="result_box" lang="pt"><span class="hps">Resumo</span></span></h2> + +<p>O Objeto <strong><code>JSON</code></strong> contém métodos para parsing <a class="external" href="http://json.org/">JavaScript Object Notation</a> ({{glossary("JSON")}}) e conversão de valores para JSON. Ele não pode ser chamado ou construído e, além de suas propriedades de dois métodos, ele não possui uma funcionalidade interessante.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<h3 id="JavaScript_Object_Notation" name="JavaScript_Object_Notation">JavaScript Object Notation</h3> + +<p>JSON é uma sintaxe para serialização de objetos, matrizes, números, strings, booleanos, e {{jsxref ("null")}}. Baseia-se em sintaxe Javascript, mas é distinta desta: alguns Javascript não são JSON, e alguns JSON não são Javascript. </p> + +<table> + <caption>JavaScript e JSON diferenças</caption> + <thead> + <tr> + <th scope="col">JavaScript tipo</th> + <th scope="col">JSON diferenças</th> + </tr> + </thead> + <tbody> + <tr> + <td>Objetos e Arrays</td> + <td>Os nomes das propriedades devem ser strings com aspas duplas; as vírgulas à direita são proibidas.</td> + </tr> + <tr> + <td>Números</td> + <td>Zeros à esquerda são proibidos; um ponto decimal deve ser seguido por pelo menos um dígito.</td> + </tr> + <tr> + <td>Strings</td> + <td> + <p>Apenas um conjunto limitado de caracteres pode ser escapado; certos caracteres de controle são proibidos; o separador de linha Unicode (<a href="http://unicode-table.com/en/2028/">U+2028</a>) e o separador de parágrafo (<a href="http://unicode-table.com/en/2029/">U+2029</a>) caracteres são permitidos; strings devem ter aspas duplas.Veja o exemplo a seguir, onde {{jsxref("JSON.parse()")}} funciona bem e um {{jsxref("SyntaxError")}} é lançado ao avaliar o código como JavaScript: var code = '"\u2028\u2029"'; JSON.parse(code); // works fine eval(code); // fails</p> + </td> + </tr> + </tbody> +</table> + +<p>A sintaxe completa do JSON é a seguinte:</p> + +<pre><var>JSON</var> = <strong>null</strong> + <em>or</em> <strong>true</strong> <em>or</em> <strong>false</strong> + <em>or</em> <var>JSONNumber</var> + <em>or</em> <var>JSONString</var> + <em>or</em> <var>JSONObject</var> + <em>or</em> <var>JSONArray</var> + +<var>JSONNumber</var> = <strong>-</strong> <var>PositiveNumber</var> + <em>or</em> <var>PositiveNumber</var> +<var>PositiveNumber</var> = DecimalNumber + <em>or</em> <var>DecimalNumber</var> <strong>.</strong> <var>Digits</var> + <em>or</em> <var>DecimalNumber</var> <strong>.</strong> <var>Digits</var> <var>ExponentPart</var> + <em>or</em> <var>DecimalNumber</var> <var>ExponentPart</var> +<var>DecimalNumber</var> = <strong>0</strong> + <em>or</em> <var>OneToNine</var> <var>Digits</var> +<var>ExponentPart</var> = <strong>e</strong> <var>Exponent</var> + <em>or</em> <strong>E</strong> <var>Exponent</var> +<var>Exponent</var> = <var>Digits</var> + <em>or</em> <strong>+</strong> <var>Digits</var> + <em>or</em> <strong>-</strong> <var>Digits</var> +<var>Digits</var> = <var>Digit</var> + <em>or</em> <var>Digits</var> <var>Digit</var> +<var>Digit</var> = <strong>0</strong> through <strong>9</strong> +<var>OneToNine</var> = <strong>1</strong> through <strong>9</strong> + +<var>JSONString</var> = <strong>""</strong> + <em>or</em> <strong>"</strong> <var>StringCharacters</var> <strong>"</strong> +<var>StringCharacters</var> = <var>StringCharacter</var> + <em>or</em> <var>StringCharacters</var> <var>StringCharacter</var> +<var>StringCharacter</var> = any character + <em>except</em> <strong>"</strong> <em>or</em> <strong>\</strong> <em>or</em> U+0000 through U+001F + <em>or</em> <var>EscapeSequence</var> +<var>EscapeSequence</var> = <strong>\"</strong> <em>or</em> <strong>\/</strong> <em>or</em> <strong>\\</strong> <em>or</em> <strong>\b</strong> <em>or</em> <strong>\f</strong> <em>or</em> <strong>\n</strong> <em>or</em> <strong>\r</strong> <em>or</em> <strong>\t</strong> + <em>or</em> <strong>\u</strong> <var>HexDigit</var> <var>HexDigit</var> <var>HexDigit</var> <var>HexDigit</var> +<var>HexDigit</var> = <strong>0</strong> through <strong>9</strong> + <em>or</em> <strong>A</strong> through <strong>F</strong> + <em>or</em> <strong>a</strong> through <strong>f</strong> + +<var>JSONObject</var> = <strong>{</strong> <strong>}</strong> + <em>or</em> <strong>{</strong> <var>Members</var> <strong>}</strong> +<var>Members</var> = <var>JSONString</var> <strong>:</strong> <var>JSON</var> + <em>or</em> <var>Members</var> <strong>,</strong> <var>JSONString</var> <strong>:</strong> <var>JSON</var> + +<var>JSONArray</var> = <strong>[</strong> <strong>]</strong> + <em>or</em> <strong>[</strong> <var>ArrayElements</var> <strong>]</strong> +<var>ArrayElements</var> = <var>JSON</var> + <em>or</em> <var>ArrayElements</var> <strong>,</strong> <var>JSON</var> +</pre> + +<p>Espaços em branco podem estar presentes em qualquer lugar, exceto dentro de um JSONNumber (números não devem conter espaço em branco) ou JSONString (onde ele é interpretado como o caractere correspondente na string, ou causaria um erro). O caractere de tabulação (U+0009), retorno de carro (U+000D), retorno de linha (U+000A), e espaço (U+0020) são os únicos caracteres em branco válidos.</p> + +<h2 id="Methods" name="Methods">Métodos</h2> + +<dl> + <dt>{{jsxref("JSON.parse()")}}</dt> + <dd><span id="result_box" lang="pt"><span class="hps">Analisar uma seqüência</span> <span class="hps">como</span> <span class="hps">JSON,</span> <span class="hps">opcionalmente</span> <span class="hps">transformar o valor</span> <span class="hps">produzido e</span> <span class="hps">suas propriedades</span><span>,</span> <span class="hps">e retornar o valor</span><span>.</span></span></dd> + <dt>{{jsxref("JSON.stringify()")}}</dt> + <dd><span id="result_box" lang="pt"><span class="hps">Retorna uma string</span> <span class="hps">JSON</span> <span class="hps">correspondente ao valor</span> <span class="hps">especificado, opcionalmente</span><span>, pode incluir</span> <span class="hps">apenas determinados</span> <span class="hps">propriedades</span> <span class="hps">ou substituir</span> <span class="hps">valores de propriedade</span> <span class="hps">de acordo com a definição feita pelo usuário</span><span class="hps">.</span></span></dd> +</dl> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p><span id="result_box" lang="pt"><span class="hps">O objeto</span> <span class="hps">JSON</span> <span class="hps">não é suportado</span> <span class="hps">em navegadores mais antigos</span><span>.</span> <span class="hps">Você pode contornar este problema</span> <span class="hps">inserindo o seguinte código</span> <span class="hps">no início de</span> <span class="hps">seus scripts,</span> <span class="hps">permitindo o uso de</span> <span class="hps">JSON</span> e navegadores sem suporte<span> (como</span> <span class="hps">Internet</span> <span class="hps">Explorer 6</span><span>)</span><span>.</span></span></p> + +<p><span id="result_box" lang="pt"><span class="hps">O algoritmo a seguir</span> <span class="hps">é</span> <span class="hps">uma imitação do</span> <span class="hps">objeto nativo</span> <span class="hps">JSON</span><span>:</span></span></p> + +<pre class="brush: js">if (!window.JSON) { + window.JSON = { + parse: function(sJSON) { return eval('(' + sJSON + ')'); }, + stringify: (function () { + var toString = Object.prototype.toString; + var isArray = Array.isArray || function (a) { return toString.call(a) === '[object Array]'; }; + var escMap = {'"': '\\"', '\\': '\\\\', '\b': '\\b', '\f': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t'}; + var escFunc = function (m) { return escMap[m] || '\\u' + (m.charCodeAt(0) + 0x10000).toString(16).substr(1); }; + var escRE = /[\\"\u0000-\u001F\u2028\u2029]/g; + return function stringify(value) { + if (value == null) { + return 'null'; + } else if (typeof value === 'number') { + return isFinite(value) ? value.toString() : 'null'; + } else if (typeof value === 'boolean') { + return value.toString(); + } else if (typeof value === 'object') { + if (typeof value.toJSON === 'function') { + return stringify(value.toJSON()); + } else if (isArray(value)) { + var res = '['; + for (var i = 0; i < value.length; i++) + res += (i ? ', ' : '') + stringify(value[i]); + return res + ']'; + } else if (toString.call(value) === '[object Object]') { + var tmp = []; + for (var k in value) { + if (value.hasOwnProperty(k)) + tmp.push(stringify(k) + ': ' + stringify(value[k])); + } + return '{' + tmp.join(', ') + '}'; + } + } + return '"' + value.toString().replace(escRE, escFunc) + '"'; + }; + })() + }; +} +</pre> + +<h2 id="Specifications" name="Specifications"><span class="short_text" id="result_box" lang="pt"><span class="hps">Especificações</span></span></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.12', 'JSON')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-json-object', 'JSON')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Navegador compatível</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>{{CompatGeckoDesktop("1.9.1")}}</td> + <td>{{CompatIE("8.0")}}</td> + <td>{{CompatOpera("10.5")}}</td> + <td>{{CompatSafari("4.0")}}</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>{{CompatGeckoMobile("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<p>Baseado em <a class="external" href="http://kangax.github.com/es5-compat-table/">Kangax's compat table</a>.</p> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("Date.prototype.toJSON()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/json/parse/index.html b/files/pt-br/web/javascript/reference/global_objects/json/parse/index.html new file mode 100644 index 0000000000..ab6f8a8076 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/json/parse/index.html @@ -0,0 +1,123 @@ +--- +title: JSON.parse() +slug: Web/JavaScript/Reference/Global_Objects/JSON/parse +tags: + - JSON + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/JSON/parse +--- +<div>{{JSRef}}</div> + +<p><span class="seoSummary">O método <strong><code>JSON.parse()</code></strong> analisa uma string JSON, construindo o valor ou um objeto JavaScript descrito pela string. Uma função <strong>reviver</strong> opcional pode ser fornecida para executar uma transformação no objeto resultante antes de ser retornada.</span></p> + +<div>{{EmbedInteractiveExample("pages/js/json-parse.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox">JSON.parse(<var>text</var>[, <var>reviver</var>])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>text</code></dt> + <dd>A string para analisar como JSON. Veja o objeto {{jsxref("JSON")}} para uma descrição da sintaxe JSON.</dd> + <dt><code>reviver</code> {{optional_inline}}</dt> + <dd>Se for uma função, isso prescreve como o valor originalmente produzido pela análise é transformado antes de ser retornado.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O {{jsxref("Object")}} correspondente ao <code>text</code> JSON fornecido.</p> + +<h3 id="Exceções">Exceções</h3> + +<p>Lança uma exceção {{jsxref("SyntaxError")}} se a string a ser analisada não for um JSON válido.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_JSON.parse()">Usando <code>JSON.parse()</code></h3> + +<pre class="brush: js">JSON.parse('{}'); // {} +JSON.parse('true'); // true +JSON.parse('"foo"'); // "foo" +JSON.parse('[1, 5, "false"]'); // [1, 5, "false"] +JSON.parse('null'); // null +</pre> + +<h3 id="Usando_o_parâmetro_reviver">Usando o parâmetro <code>reviver</code></h3> + +<p>Se um <code>reviver</code> for especificado, o valor calculado pela análise será <em>transformado</em> antes de ser retornado. Especificamente, o valor computado e todas as suas propriedades (começando com as propriedades mais aninhadas e prosseguindo para o próprio valor original) são executadas individualmente através do <code>reviver</code>. Em seguida, ele é chamado, com o objeto contendo a propriedade sendo processada como <code>this</code>, e com o nome da propriedade como uma string, e o valor da propriedade como argumentos. Se a função <code>reviver</code> retornar {{jsxref("undefined")}} (ou não retornar nenhum valor, por exemplo, se a execução cair no final da função), a propriedade será excluída do objeto. Caso contrário, a propriedade é redefinida para ser o valor de retorno.</p> + +<p>Se o <code>reviver</code> apenas transformar alguns valores e não outros, certifique-se de retornar todos os valores não transformados como estão, caso contrário, eles serão excluídos do objeto resultante.</p> + +<pre class="brush: js">JSON.parse('{"p": 5}', (key, value) => + typeof value === 'number' + ? value * 2 // retorna o valor * 2 para números + : value // retorna tudo sem alteração +); + +// { p: 10 } + +JSON.parse('{"1": 1, "2": 2, "3": {"4": 4, "5": {"6": 6}}}', (key, value) => { + console.log(key); // mostra o nome da propriedade atual, o último é "". + return value; // retorna o valor da propriedade inalterada. +}); + +// 1 +// 2 +// 4 +// 6 +// 5 +// 3 +// "" +</pre> + +<h3 id="JSON.parse()_não_é_permitido_vírgulas_à_direta"><code>JSON.parse()</code> não é permitido vírgulas à direta</h3> + +<pre class="example-bad brush: js example-bad">// ambos retornarão um SyntaxError +JSON.parse('[1, 2, 3, 4, ]'); +JSON.parse('{"foo" : 1, }'); +</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.12.2', 'JSON.parse')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.7.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-json.parse', 'JSON.parse')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-json.parse', 'JSON.parse')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2> + +<div> + + +<p>{{Compat("javascript.builtins.JSON.parse")}}</p> +</div> + +<h2 id="Veja_Também">Veja Também</h2> + +<ul> + <li>{{jsxref("JSON.stringify()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/json/stringify/index.html b/files/pt-br/web/javascript/reference/global_objects/json/stringify/index.html new file mode 100644 index 0000000000..ca3138e1bf --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/json/stringify/index.html @@ -0,0 +1,253 @@ +--- +title: JSON.stringify() +slug: Web/JavaScript/Reference/Global_Objects/JSON/stringify +translation_of: Web/JavaScript/Reference/Global_Objects/JSON/stringify +--- +<div>{{JSRef("Global_Objects", "JSON")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <strong><code>JSON.stringify()</code></strong> converte valores em javascript para uma String JSON. Esses valores podem ser substituidos especificando a função <em>replacer</em>, ou incluindo somente as propriedades específicas, quando o array do replacer for especificado.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code>JSON.stringify(<var>valor</var>[, <var>replacer</var>[, espaço]])</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>valor</code></dt> + <dd>O valor a ser convertido para uma string JSON.</dd> + <dt><code>replacer</code> {{optional_inline}}</dt> + <dd>Uma função que altera o comportamento do processo de transformação em string, ou um array de objetos {{jsxref("String")}} e {{jsxref("Number")}} que servem como uma lista branca para selecionar as propriedades do objeto valor a ser incluído na string JSON. Se este valor for nulo ou não fornecido, todas as propriedades do objeto são incluídas na string JSON resultante.</dd> + <dt><code>espaço</code> {{optional_inline}}</dt> + <dd>Um objeto {{jsxref("String")}} ou {{jsxref("Number")}} que é usado para inserir espaço em branco na saída da string JSON para propósito de legibilidade. Se isto for um <code>Number</code>, indica o número de caracteres espaço para usar como espaço em branco; este número é limitado em 10 se for maior que isso. Valores menores que 1 indicam que nenhum espaço deve ser usado. Se isto for uma <code>String</code>, a string (ou os primeiros 10 caracteres da string, se for maior que isso) é usado como espaço em branco. Se esse parâmetro não for fornecido (ou for null), nenhum espaço em branco é usado.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p><code>JSON.stringify()</code> converte um valor para uma notação JSON que o representa:</p> + +<ul> + <li>Se o valor tiver um método <code>toJSON()</code>, é responsável por definir quais dados serão serializados.</li> + <li>{{jsxref("Boolean")}}, {{jsxref("Number")}}, and {{jsxref("String")}} os objetos são convertidos para os valores primitivos correspondentes durante a stringificação, de acordo com a semântica de conversão.</li> + <li>Se {{jsxref("undefined")}}, uma função, ou um symbol é encontrado durante a conversão é omitido (quando é encontrado em um objeto) ou censurado para {{jsxref("null")}} (quando é encontrado em um Array). <code>JSON.stringify</code> pode também somente retornar <code>undefined</code> ao passar valores puros como <code>JSON.stringify(function(){})</code> ou <code>JSON.stringify(undefined)</code>.</li> + <li>Todas as propriedades com chave de símbolo serão completamente ignoradas, mesmo quando usar a função <code>replacer</code>.</li> + <li>Propriedades não enumeráveis serão ignoradas.</li> +</ul> + +<pre class="brush: js notranslate">JSON.stringify({}); // '{}' +JSON.stringify(true); // 'true' +JSON.stringify('foo'); // '"foo"' +JSON.stringify([1, 'false', false]); // '[1,"false",false]' +JSON.stringify({ x: 5 }); // '{"x":5}' + +JSON.stringify({ x: 5, y: 6 }); +// '{"x":5,"y":6}' or '{"y":6,"x":5}' +JSON.stringify([new Number(1), new String('false'), new Boolean(false)]); +// '[1,"false",false]' + +// Symbols: +JSON.stringify({ x: undefined, y: Object, z: Symbol('') }); +// '{}' +JSON.stringify({ [Symbol('foo')]: 'foo' }); +// '{}' +JSON.stringify({ [Symbol.for('foo')]: 'foo' }, [Symbol.for('foo')]); +// '{}' +JSON.stringify({ [Symbol.for('foo')]: 'foo' }, function(k, v) { + if (typeof k === 'symbol') { + return 'a symbol'; + } +}); +// '{}' +</pre> + +<h3 id="O_parâmetro_replacer_parameter">O parâmetro <code>replacer</code> parameter</h3> + +<p dir="ltr" id="tw-target-text">O parâmetro <kbd>replacer</kbd> pode ser uma função ou uma matriz. Como função, são necessários dois parâmetros, a <kbd>chave</kbd> e os valores que estão sendo especificados. O objeto no qual a <kbd>chave</kbd> foi encontrada é fornecido como substituto desse parâmetro. Inicialmente, ele é chamado com uma chave vazia que representa o objeto que está sendo codificado e, em seguida, é chamado para cada propriedade no <kbd>objeto</kbd> ou matriz que está sendo codificada. Ele deve retornar o valor que deve ser adicionado à cadeia JSON, da seguinte maneira:</p> + +<ul> + <li>Se você retornar um {{jsxref("Number")}}, a string correspondente a esse número é usada como o valor da propriedade quando adicionada à sequência JSON.</li> + <li>If you return a {{jsxref("String")}}, that string is used as the property's value when adding it to the JSON string.</li> + <li>If you return a {{jsxref("Boolean")}}, "true" or "false" is used as the property's value, as appropriate, when adding it to the JSON string.</li> + <li>If you return any other object, the object is recursively stringified into the JSON string, calling the <code>replacer</code> function on each property, unless the object is a function, in which case nothing is added to the JSON string.</li> + <li>If you return <code>undefined</code>, the property is not included in the output JSON string. </li> +</ul> + +<div class="blockIndicator note"> +<p><strong>Nota: </strong>Você não pode usar a função <code>replacer</code> para remover valoeres em uma <code>array</code>. Se você retornar <code>undefined</code>, <code>null</code> será usado no lugar.</p> +</div> + +<h4 id="Exemplo_de_uma_função">Exemplo de uma função</h4> + +<pre class="brush: js notranslate">function <span style="font-size: 1rem;">replacer</span><span style="font-size: 1rem;">(key, value) {</span> + if (typeof value === "string") { + return undefined; + } + return value; +} + +var foo = {fundação: "Mozilla", modelo: "caixa", semana: 45, transporte: "carro", mês: 7}; +var jsonString = JSON.stringify(foo, replacer); +</pre> + +<p>O resultado do JSON é: <code>{"semana":45,"mês":7}</code>.</p> + +<h4 id="Example_of_using_replacer_parameter" name="Example_of_using_replacer_parameter">Exemplo em uma array</h4> + +<p>Se <code>replacer</code> é usado em uma array, os valores da array indicam os nomes das propriedades no objeto, que devem ser incluídas na sequência JSON resultante.</p> + +<pre class="brush: js notranslate">JSON.stringify(foo, ['week', 'month']); +// '{"week":45,"month":7}', only keep "week" and "month" properties +</pre> + +<h3 id="space_argument" name="space_argument">O argumento <code>space</code> </h3> + +<p>O argumento <code>space</code> O argumento pode ser usado para controlar o espaçamento na sequência final. Se for um número, os níveis sucessivos na stringficação serão recuados por esse número de caracteres de espaço (até 10). Se for uma sequência, os níveis sucessivos serão recuados por essa sequência (ou pelos dez primeiros caracteres).</p> + +<pre class="brush: js notranslate">JSON.stringify({ a: 2 }, null, ' '); +// '{ +// "a": 2 +// }' +</pre> + +<p>O uso de um caractere de tabulação imita a aparência padrão de impressão pretty-print.</p> + +<pre class="brush: js notranslate">JSON.stringify({ uno: 1, dos: 2 }, null, '\t'); +// r: +// '{ +// "uno": 1, +// "dos": 2 +// }' +</pre> + +<h3 id="toJSON_behavior" name="toJSON_behavior">Comportamento de <code>toJSON()</code></h3> + +<p>Se um objeto sendo stringificado tiver uma propriedade denominada <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">toJSON()</span></font> cujo valor é uma função, o método <code>toJSON()</code> personaliza o comportamento da stringificação JSON, em vez de o objeto ser serializado, o valor retornado pelo método <code>toJSON()</code> quando chamado será serializado. Por exemplo:</p> + +<pre class="brush: js notranslate">var obj = { + foo: 'foo', + toJSON: function() { + return 'bar'; + } +}; +JSON.stringify(obj); // '"bar"' +JSON.stringify({ x: obj }); // '{"x":"bar"}' +</pre> + +<h3 id="Example_of_using_JSON.stringify_with_localStorage" name="Example_of_using_JSON.stringify_with_localStorage">Examplo de uso de <code>JSON.stringify()</code> com <code>localStorage</code></h3> + +<p>No caso em que você deseja armazenar um objeto criado por seu usuário e permitir que ele seja restaurado mesmo após o fechamento do navegador, o exemplo a seguir é um modelo para a aplicabilidade de <code>JSON.stringify()</code>:</p> + +<div class="warning"> +<p>As funções não são um tipo de dados JSON válido, portanto, elas não funcionarão. Também alguns objetos como {{jsxref("Date")}} será uma string depois {{jsxref("JSON.parse()")}}.</p> +</div> + +<pre class="brush: js notranslate">// Criando um exemplo em JSON +var seção = { + 'telas': [], + 'estado': true +}; +session.screens.push({ 'nome': 'telaA', 'largura': 450, 'altura': 250 }); +session.screens.push({ 'nome': 'telaB', 'largura': 650, 'altura': 350 }); +session.screens.push({ 'nome': 'telaC', 'largura': 750, 'altura': 120 }); +session.screens.push({ 'nome': 'telaD', 'largura': 250, 'altura': 60 }); +session.screens.push({ 'nome': 'telaE', 'largura': 390, 'altura': 120 }); +session.screens.push({ 'nome': 'telaF', 'largura': 1240, 'altura': 650 }); + +// Convertendo a string JSON em JSON.stringify() +// Salvando com localStorage no nome da sessão +localStorage.setItem('seção', JSON.stringify(seção)); + +// Exemplo de como transformar a String gerada por meio de: +// JSON.stringify() e salva em localStorage no objeto JSON novamente +var seçãoRestaurada = JSON.parse(localStorage.getItem('seção')); + +// Agora, a variável seçãoRestaurada contém o objeto que foi salvo +// no localStorage +console.log(seçãoRestaurada); +</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>{{SpecName('ES5.1', '#sec-15.12.3', 'JSON.stringify')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> + <p dir="ltr" id="tw-target-text">Definição inicial. Implementado em JavaScript 1.7.</p> + </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-json.stringify', 'JSON.stringify')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade em navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Navegador</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>{{CompatGeckoDesktop("1.9.1")}}</td> + <td>{{CompatIE("8.0")}}</td> + <td>{{CompatOpera("10.5")}}</td> + <td>{{CompatSafari("4.0")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</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>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<p>Baseado na <a class="external" href="http://kangax.github.com/es5-compat-table/">Kangax's compat table</a>.</p> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("JSON.parse()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/map/clear/index.html b/files/pt-br/web/javascript/reference/global_objects/map/clear/index.html new file mode 100644 index 0000000000..19482e19c8 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/map/clear/index.html @@ -0,0 +1,119 @@ +--- +title: Map.prototype.clear() +slug: Web/JavaScript/Reference/Global_Objects/Map/clear +tags: + - ECMAScript 2015 + - JavaScript + - Mapa + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Map/clear +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>clear()</strong></code> remove todos os elementos de um objeto <code>Map</code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>meuMapa</em>.clear();</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_método_clear">Usando o método <code>clear</code></h3> + +<pre class="brush: js">var meuMapa = new Map(); +meuMapa.set('bar', 'baz'); +meuMapa.set(1, 'foo'); + +meuMapa.size; // 2 +meuMapa.has('bar'); // true + +meuMapa.clear(); + +meuMapa.size; // 0 +meuMapa.has('bar') // false +</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('ES2015', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os 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>38</td> + <td>{{CompatGeckoDesktop("19.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</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>38</td> + <td>{{CompatGeckoMobile("19.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/map/delete/index.html b/files/pt-br/web/javascript/reference/global_objects/map/delete/index.html new file mode 100644 index 0000000000..f4b0ae0786 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/map/delete/index.html @@ -0,0 +1,120 @@ +--- +title: Map.prototype.delete() +slug: Web/JavaScript/Reference/Global_Objects/Map/delete +tags: + - ECMAScript 2015 + - JavaScript + - Mapa + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Map/delete +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>delete()</strong></code> remove o elemento especificado de um objeto <code>Map</code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="brush: js">meuMapa.delete(chave);</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt>key</dt> + <dd>Obrigatório. A chave do elemento a ser removido do objeto <code>Map</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Retorna <code>true</code> se um elemento existia no objeto <code>Map</code> e foi removido, ou <code>false</code> se o elemento não existia.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_método_delete">Usando o método <code>delete</code></h3> + +<pre class="brush: js">var meuMapa = new Map(); +meuMapa.set('bar', 'foo'); + +meuMapa.delete('bar'); // Retorna true. Removido com sucesso. +meuMapa.has('bar'); // Retorna false. O elemento com valor "bar" já não existe mais no mapa. +</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('ES2015', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os 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>38</td> + <td>{{CompatGeckoDesktop("13.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</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>38</td> + <td>{{CompatGeckoMobile("13.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/map/entries/index.html b/files/pt-br/web/javascript/reference/global_objects/map/entries/index.html new file mode 100644 index 0000000000..cdea688bf2 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/map/entries/index.html @@ -0,0 +1,120 @@ +--- +title: Map.prototype.entries() +slug: Web/JavaScript/Reference/Global_Objects/Map/entries +tags: + - ECMAScript 2015 + - Iterador + - JavaScript + - Mapa + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Map/entries +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>entries()</strong></code> retorna um novo objeto <strong><a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterador</a></strong> que contém os pares <code>[chave, valor]</code> para cada elemento no objeto <code>Map</code> pela ordem de inserção.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>meuMapa</em>.entries()</code></pre> + +<h3 id="Retorna_o_valor">Retorna o valor</h3> + +<p>Um novo objeto iterador de {{jsxref("Map")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_entries()">Usando <code>entries()</code></h3> + +<pre class="brush:js">var meuMap = new Map(); +meuMap.set('0', 'foo'); +meuMap.set(1, 'bar'); +meuMap.set({}, 'baz'); + +var mapIter = myMap.entries(); + +console.log(mapIter.next().value); // ["0", "foo"] +console.log(mapIter.next().value); // [1, "bar"] +console.log(mapIter.next().value); // [Object, "baz"] +</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('ES2015', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os 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>38</td> + <td>{{ CompatGeckoDesktop("20") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</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>38</td> + <td>{{CompatGeckoMobile("20")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Map.prototype.keys()")}}</li> + <li>{{jsxref("Map.prototype.values()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/map/foreach/index.html b/files/pt-br/web/javascript/reference/global_objects/map/foreach/index.html new file mode 100644 index 0000000000..1aed37b31c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/map/foreach/index.html @@ -0,0 +1,146 @@ +--- +title: Map.prototype.forEach() +slug: Web/JavaScript/Reference/Global_Objects/Map/forEach +tags: + - ECMAScript 2015 + - JavaScript + - Mapa + - Prototipo + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Map/forEach +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>forEach()</strong></code> executa uma função fornecida uma vez para cada par de chave/valor no objeto <code>Map</code>, pela ordem de inserção.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>meuMapa</em>.forEach(<em>callback</em>[, <em>thisArg</em>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Função a ser executada para cada elemento.</dd> + <dt><code>thisArg</code></dt> + <dd>Valor a utilizar como o <code>this</code> quando estiver executando o <code>callback</code>.</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>forEach</code> executa o <code>callback</code> fornecido uma vez para cada chave existente no mapa. Ele não é invocado para as chaves que foram removidas. No entanto, ele é executado para ítens que estão presentes mesmo com o valor <code>undefined</code>.</p> + +<p><code>callback</code> é invocado com <strong>três argumentos</strong>:</p> + +<ul> + <li>o <strong>valor do elemento</strong></li> + <li>a <strong>chave do elemento</strong></li> + <li>o <strong><code>Objeto Map</code> que está sendo atravessado</strong></li> +</ul> + +<p>Se um parâmetro <code>thisArg</code> for fornecido ao <code>forEach</code>, ele será passado ao <code>callback</code> quando invocado, e será utilizado como o valor de seu <code>this</code>. De outra forma, o valor <code>undefined</code> será passado como o valor de seu <code>this</code>. O valor <code>this</code> observável em última instância por callback é determinado de acordo com <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">as regras comuns para determinar o <code>this</code> sendo visto por uma função</a>.</p> + +<p>Cada valor é visitado uma vez, exceto para o caso em que ele foi removido e re-adicionado antes do <code>forEach</code> ter acabado de ser executado. o <code>callback</code> não é invocado para valores removidos antes de serem visitados. Novos valores adicionados antes do <code>forEach</code> ter acabado serão visitados.</p> + +<p><code>forEach</code> executa a função de <code>callback</code> uma vez para cada elemento no objeto <code>Map</code>; ele não retorna um valor.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Imprimindo_o_conteúdo_de_um_objeto_Map">Imprimindo o conteúdo de um objeto <code>Map</code></h3> + +<p>O código a seguir registra uma linha de log para cada elemento no objeto <code>Map</code>:</p> + +<pre class="brush:js">function registrarElementosDoMapa(valor, chave, mapa) { + console.log(`m[${chave}] = ${valor}`); +} +new Map([['foo', 3], ['bar', {}], ['baz', undefined]]).forEach(registrarElementosDoMapa); +// logs: +// "m[foo] = 3" +// "m[bar] = [object Object]" +// "m[baz] = undefined" +</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('ES2015', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os 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>38</td> + <td>{{CompatGeckoDesktop("25.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</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>38</td> + <td>{{CompatGeckoMobile("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Set.prototype.forEach()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/map/get/index.html b/files/pt-br/web/javascript/reference/global_objects/map/get/index.html new file mode 100644 index 0000000000..9a4fde282c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/map/get/index.html @@ -0,0 +1,76 @@ +--- +title: Map.prototype.get() +slug: Web/JavaScript/Reference/Global_Objects/Map/get +tags: + - ECMAScript 2015 + - JavaScript + - Map + - Prototype + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Map/get +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>get()</strong></code> retorna um elemento específico de um objeto de <code>Map</code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.get(chave);</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt>chave</dt> + <dd>Obrigatório. A chave do elemento para retornar do objeto de <code>Map</code>.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Retorna o elemento associado com a chave específica ou <code>undefined</code> se a chave não puder ser encontrada no objeto de <code>Map</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_métodoget">Usando o método<code>get</code></h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set('bar', 'foo'); + +myMap.get('bar'); // Retorna "foo". +myMap.get('baz'); // Retorna undefined. +</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('ES2015', '#sec-map.prototype.get', 'Map.prototype.get')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.get', 'Map.prototype.get')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<div class="hidden">A tabela de compatibilidade desta página é gerada a partir de dados estruturados. Se você gostaria de contribuir, por favor, dê uma olhada em <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</div> + +<p>{{Compat("javascript.builtins.Map.get")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.set()")}}</li> + <li>{{jsxref("Map.prototype.has()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/map/has/index.html b/files/pt-br/web/javascript/reference/global_objects/map/has/index.html new file mode 100644 index 0000000000..88a5c18aff --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/map/has/index.html @@ -0,0 +1,78 @@ +--- +title: Map.prototype.has() +slug: Web/JavaScript/Reference/Global_Objects/Map/has +translation_of: Web/JavaScript/Reference/Global_Objects/Map/has +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>has()</code></strong> retorna um valor booleano indicando quando um elemento com a chave especificada existe ou não</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-has.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.has(key);</code></pre> + +<h3 id="Parametros">Parametros</h3> + +<dl> + <dt>key</dt> + <dd>Necessário. A chave para verificar a presença do elemento no objeto <code>Map</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<dl> + <dt>Booleano</dt> + <dd>Retorna <code>true</code> se um elemento com a chave especificada existe no objeto <code>Map</code>; caso contrário: <code>false</code>.</dd> +</dl> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_método_has">Usando o método <code>has</code></h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set('bar', "foo"); + +myMap.has('bar'); // retorna true +myMap.has('foo'); // retorna false +myMap.has('barz'); // retorna false +</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('ES2015', '#sec-map.prototype.has', 'Map.prototype.has')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.has', 'Map.prototype.has')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2> + + + +<p>{{Compat("javascript.builtins.Map.has")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.set()")}}</li> + <li>{{jsxref("Map.prototype.get()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/map/index.html b/files/pt-br/web/javascript/reference/global_objects/map/index.html new file mode 100644 index 0000000000..80ec04af62 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/map/index.html @@ -0,0 +1,225 @@ +--- +title: Map +slug: Web/JavaScript/Reference/Global_Objects/Map +tags: + - ECMAScript 2015 + - JavaScript + - Map + - Mapa +translation_of: Web/JavaScript/Reference/Global_Objects/Map +--- +<div>{{JSRef}}</div> + +<p>O objeto <strong><code>Map</code></strong> é um mapa simples de chave/valor. Qualquer valor (objeto e {{Glossary("Primitive", "valores primitivos")}}) pode ser usado como uma chave ou um valor.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code>new Map([iterable]) +</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>iterable</code></dt> + <dd> + <p><code>Iterable</code> é um Array ou outro objeto iterável cujos elementos são pares de chave-valor (2-element Arrays). Cada par de chave-valor é adicionado ao novo Map. <code>null</code> é tratado como <code>undefined</code>.</p> + </dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Um objeto Map itera seus elementos em ordem de inserção — um loop {{jsxref("Statements/for...of", "for...of")}} retorna um array de <code>[chave, valor]</code> para cada iteração.</p> + +<p>Deve-se notar que um Map que é um mapa de um objeto, especialmente, um dicionário de dicionários somente irá mapear apenas para a ordem de inserção -- que é aleatória e não ordenada.</p> + +<h3 id="Igualidade_de_valores">Igualidade de valores</h3> + +<p>A igualdade das chaves é baseada no algoritmo "SameValueZero" (mesmo valor): <code>NaN</code> é considerado igual à <code>NaN</code> (mesmo que <code>NaN !== NaN</code>) e todos os outros valores são considerados iguals de acordo com a semantica do operador ===. Em versões anteriores do rascunho ECMAScript 2015 draft <code>-0</code> and <code>+0</code> eram considerados diferentes (mesmo que <code>-0 === +0</code>), isto foi trocado em versões posteriores e foi aplicado no Gecko 29 {{geckoRelease("29")}} ({{bug("952870")}}) e em uma<a href="https://code.google.com/p/v8/issues/detail?id=3069"> build recente nightly do Chrome</a>.</p> + +<h3 id="Objetos_e_mapas_comparados">Objetos e mapas comparados</h3> + +<p>{{jsxref("Object", "Objects")}} são similares a Maps onde ambos deixam adicionar chaves para valores, recuperar estes valores, apagar chaves, e detectar quando algo foi adicionado em uma chave. Por causa disso (e porque não existem alternativas pré-construidas), <code>Objects</code> historicamente foram usados como <code>Maps</code>; no entanto, existem diferenças importantes entre <code>Objects</code> e <code>Maps</code> que fazem o uso do Map melhor:</p> + +<ul> + <li>Um <code>Object</code> tem um prototype, então existem chaves padrão no mapa. Isto pode ser evitado usando um Map<code> = Object.create(null)</code> desde ES5, mas raramente é feito.</li> + <li>As chaves de um <code>Object</code> são {{jsxref("String", "Strings")}} e {{jsxref("Symbol", "Symbols")}}, porém elas podem ser qualquer valor em um <code>Map</code>.</li> + <li>Você pode obter o tamanho de um <code>Map</code> facilmente enquanto em um <code>Object </code>é necessário ter este controle manualmente.</li> +</ul> + +<p>Isto não significa que você deve usar <code>Map</code>s em todo lugar, objetos ainda serão usados na maioria dos casos. Instancias de <code>Map</code> são úteis somente para coleções, e você deve considerar adaptar seu codigo onde você usou objetos para isto anteriormente. Objects devem ser usados como registros, com campos e métodos.<br> + Se você não tem certeza qual usar, pergunte-se as seguintes questões:</p> + +<ul> + <li>As keys são desconhecidas até o tempo de execução, você precisa procurá-las dinamicamente?</li> + <li>Todos os valores sempre serão do mesmo tipo, e podem ser usados de forma intercambiável?</li> + <li>Você precisa de keys que não são strings?</li> + <li>Os pares key-value são adicionados ou removidos frequentemente?</li> + <li>Você tem uma quantidade de pares key-value arbitrária (de troca fácil) ?</li> + <li>A coleção é iterada?</li> +</ul> + +<p>Se você respondeu "sim" em qualquer uma dessas questões, é um sinal de que você quer utilizar um <code>Map</code>. Se ao invés disto você tem um numero fixo de keys, trabalhe eles individualmente, e faça diferenciação entre o uso deles, você quer um objeto.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>Map.length</code></dt> + <dd>O tamanho do mapa é 0.</dd> + <dt>{{jsxref("Map.@@species", "get Map[@@species]")}}</dt> + <dd>A função construtora que é usada para criar objetos derivados.</dd> + <dt>{{jsxref("Map.prototype")}}</dt> + <dd>Representa o prototype para o construtor de <code>Map</code>. Permite a adição de propriedades para todos os objetos <code>Map</code>.</dd> +</dl> + +<h2 id="Instâncias_de_Map">Instâncias de <code>Map</code></h2> + +<p>Todas as instancias de <code>Map</code> herdam de {{jsxref("Map.prototype")}}.</p> + +<h3 id="Propriedades_2">Propriedades</h3> + +<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/Map/prototype','Properties')}}</p> + +<h3 id="Métodos">Métodos</h3> + +<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/Map/prototype','Methods')}}</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_objeto_Map">Usando o objeto <code>Map</code></h3> + +<pre class="brush: js notranslate">var myMap = new Map(); + +var keyString = "uma string", + keyObj = {}, + keyFunc = function () {}; + +// configurando os valores +myMap.set(keyString, "valor associado com 'uma string'"); +myMap.set(keyObj, "valor associado com keyObj"); +myMap.set(keyFunc, "valor associado com keyFunc"); + +myMap.size; // 3 + +// obtendo os valores +myMap.get(keyString); // "valor associado com 'uma string'" +myMap.get(keyObj); // "valor associado com keyObj" +myMap.get(keyFunc); // "valor associado com keyFunc" + +myMap.get("uma string"); // "valor associado com 'uma string'" + // pois keyString === 'uma string' +myMap.get({}); // undefined, pois keyObj !== {} +myMap.get(function() {}) // undefined, pois keyFunc !== function () {} +</pre> + +<h3 id="Usando_NaN_como_Map_keys">Usando <code>NaN</code> como <code>Map</code> keys</h3> + +<p><code>NaN</code> pode também ser usado como key. Mesmo que <code>NaN</code> não seja igual a ele mesmo (<code>NaN !== NaN</code>) é true, o seguinte exemplo funciona, porquê <code>NaN</code>s são indistinguíveis uma para o outro:</p> + +<pre class="brush: js notranslate">var myMap = new Map(); +myMap.set(NaN, "not a number"); + +myMap.get(NaN); // "not a number" + +var otherNaN = Number("foo"); +myMap.get(otherNaN); // "not a number" +</pre> + +<h3 id="Iterando_Maps_com_for..of">Iterando <code>Maps</code> com <code>for..of</code></h3> + +<p>Maps podem ser iterados usando um <code>for..of</code> :</p> + +<pre class="brush: js notranslate">var myMap = new Map(); +myMap.set(0, "zero"); +myMap.set(1, "um"); +for (var [key, value] of myMap) { + console.log(key + " = " + value); +} +// 0 = zero +// 1 = um + +for (var key of myMap.keys()) { + console.log(key); +} +// 0 +// 1 + +for (var value of myMap.values()) { + console.log(value); +} +// zero +// um + +for (var [key, value] of myMap.entries()) { + console.log(key + " = " + value); +} +// 0 = zero +// 1 = um +</pre> + +<h3 id="Iterando_Maps_com_forEach">Iterando <code>Maps</code> com <code>forEach()</code></h3> + +<p>Maps podem ser iterados usando um <code>forEach()</code>:</p> + +<pre class="brush: js notranslate">myMap.forEach(function(value, key) { + console.log(key + " = " + value); +}, myMap) +// Mostrará 2 logs; o primeiro com "0 = zero" e o segundo com "1 = um" +</pre> + +<h3 id="Relação_com_objetos_Array">Relação com objetos <code>Array</code></h3> + +<pre class="brush: js notranslate">var kvArray = [["key1", "value1"], ["key2", "value2"]]; + +// Utiliza o construtor padrão de Map para converter um Array de 2 dimensões de chave-valor Array em um mapa +var myMap = new Map(kvArray); + +myMap.get("key1"); // retorna "value1" + +// Utiliza Array.from para converter um mapa em um Array de 2 dimensões de chave-valor +console.log(Array.from(myMap)) // Mostrará exatamente o mesmo Array que kvArray + +// Uma forma mais sucinta de realizar a mesma conversão com o operador spread +console.log([...myMap]); + +// Ou usa o operador spread nas chaves ou valores para o iterador pegar +// um array com somente as chaves ou valores +console.log([...myMap.keys()]); // Mostrará ["key1", "key2"] +</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-map-objects', 'Map')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map-objects', 'Map')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2> + +<p>{{Compat("javascript.builtins.Map")}}</p> + +<p>[1] Começando com Chrome 31, a feature ficou disponível sob modificação de configurações. Em <code>chrome://flags</code>, ative a entrada activate “Enable Experimental JavaScript”.</p> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li><a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=697479">Map and Set bug at Mozilla</a></li> + <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets">ECMAScript Harmony proposal</a></li> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/map/keys/index.html b/files/pt-br/web/javascript/reference/global_objects/map/keys/index.html new file mode 100644 index 0000000000..40637e641d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/map/keys/index.html @@ -0,0 +1,115 @@ +--- +title: Map.prototype.keys() +slug: Web/JavaScript/Reference/Global_Objects/Map/keys +translation_of: Web/JavaScript/Reference/Global_Objects/Map/keys +--- +<div>{{JSRef}}</div> + +<div>O método <code><strong>keys()</strong></code> retorna um novo objeto do tipo <code><strong>Iterator</strong></code> que contem uma chave para cada elemento dentro do objeto <code>Map </code>na ordem que foram inseridos.</div> + +<p> </p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.keys()</code></pre> + +<h3 id="Tipo_de_Retorno">Tipo de Retorno</h3> + +<p>Um novo objeto {{jsxref("Map")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_keys()">Usando <code>keys()</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set("0", "foo"); +myMap.set(1, "bar"); +myMap.set({}, "baz"); + +var mapIter = myMap.keys(); + +console.log(mapIter.next().value); // "0" +console.log(mapIter.next().value); // 1 +console.log(mapIter.next().value); // Object +</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-map.prototype.keys', 'Map.prototype.keys')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.keys', 'Map.prototype.keys')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_navegadores">Compatibilidade 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>38</td> + <td>{{CompatGeckoDesktop("20")}}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</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>38</td> + <td>{{CompatGeckoMobile("20") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Map.prototype.entries()")}}</li> + <li>{{jsxref("Map.prototype.values()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/map/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/map/prototype/index.html new file mode 100644 index 0000000000..7ff81b758a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/map/prototype/index.html @@ -0,0 +1,135 @@ +--- +title: Map.prototype +slug: Web/JavaScript/Reference/Global_Objects/Map/prototype +tags: + - ECMAScript 2015 + - JavaScript + - Mapa + - Propriedade +translation_of: Web/JavaScript/Reference/Global_Objects/Map +--- +<div>{{JSRef}}</div> + +<p>A propriedade <code><strong>Map</strong></code><strong><code>.prototype</code></strong> representa o protótipo para o construtor {{jsxref("Map")}}.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Instâncias de {{jsxref("Map")}} herdam de {{jsxref("Map.prototype")}}. Você pode utilizar o objeto protótipo do construtor para adicionar propriedades ou métodos para todas as instâncias de <code>Map</code>.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>Map.prototype.constructor</code></dt> + <dd>Retorna a função que criou um protótipo da instância. Isso é a funçao de {{jsxref("Map")}} por padrão.</dd> + <dt>{{jsxref("Map.prototype.size")}}</dt> + <dd>Retorna o número de pares chave/valor no objeto <code>Map</code>.</dd> +</dl> + +<h2 id="Metódos">Metódos</h2> + +<dl> + <dt>{{jsxref("Map.prototype.clear()")}}</dt> + <dd>Remove todas os pares chave/valor do objeto <code>Map</code>.</dd> + <dt>{{jsxref("Map.delete", "Map.prototype.delete(chave)")}}</dt> + <dd>Remove qualquer valor associado à chave passada e retorna o valor que <code>Map.prototype.has(chave)</code> deveria retornar anteriormente. <code>Map.prototype.has(chave)</code> irá retornar <code>false</code> após tal remoção ser feita.</dd> + <dt>{{jsxref("Map.prototype.entries()")}}</dt> + <dd>Retorna um novo objeto <code>Iterador</code> que contem<strong> um array de <code>[chave, valor]</code></strong> para cada elemento no objeto <code>Map</code> pela ordem de inserção.</dd> + <dt>{{jsxref("Map.forEach", "Map.prototype.forEach(callbackFn[, thisArg])")}}</dt> + <dd>Chama callbackFn uma vez para cada par chave/valor presente no objeto <code>Map</code>, pela ordem de inserção. Se um parâmetro thisArg for fornecido para o forEach, ele será utilizado como o valor this para cada callback.</dd> + <dt>{{jsxref("Map.get", "Map.prototype.get(chave)")}}</dt> + <dd>Retorna o valor associado para a <code>chave</code>, ou <code>undefined</code> se esta não existir no objeto <code>Map</code>.</dd> + <dt>{{jsxref("Map.has", "Map.prototype.has(key)")}}</dt> + <dd>Retorna um valor booleano caso um valor tenha sido associado à <code>chave</code> no objeto <code>Map</code> ou não.</dd> + <dt>{{jsxref("Map.prototype.keys()")}}</dt> + <dd>Retorna um novo objeto <code>Iterador</code> que contem as <strong>chaves</strong> para cada elemento no objeto <code>Map</code> object pela ordem de inserção.</dd> + <dt>{{jsxref("Map.set", "Map.prototype.set(key, value)")}}</dt> + <dd>Configura o valor par a <code>chave</code> no objeto <code>Map</code>. Retorna o objeto <code>Map</code>.</dd> + <dt>{{jsxref("Map.prototype.values()")}}</dt> + <dd>Retorna um novo objeto <code>Iterador</code> que contém os <strong>valores</strong> para cada elemento no objeto <code>Map</code> pela ordem de inserção.</dd> + <dt>{{jsxref("Map.@@iterator", "Map.prototype[@@iterator]()")}}</dt> + <dd>Retorna um novo objeto <code>Iterator</code> que contém<strong> um array de <code>[chave, valor]</code></strong> para cada elemento no objeto <code>Map</code> pela ordem de inserção.</dd> +</dl> + +<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-map.prototype', 'Map.prototype')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype', 'Map.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os 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>38</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>11</td> + <td>25</td> + <td>7.1</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>38</td> + <td>{{CompatGeckoMobile("13")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td> + <p>8</p> + </td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Set.prototype")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/map/set/index.html b/files/pt-br/web/javascript/reference/global_objects/map/set/index.html new file mode 100644 index 0000000000..e161bb2926 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/map/set/index.html @@ -0,0 +1,137 @@ +--- +title: Map.prototype.set() +slug: Web/JavaScript/Reference/Global_Objects/Map/set +tags: + - ECMAScript 2015 + - JavaScript + - Map + - Prototype + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Map/set +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>set()</strong></code> adiciona ou atualiza um elemento com uma <code>chave</code> e <code>valor</code> específicos a um objeto de <code>Map.</code></p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.set(chave, valor);</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt>chave</dt> + <dd>Obrigatório. A chave do elemento para adicionar ao objeto de <code>Map</code>.</dd> + <dt>valor</dt> + <dd>Obrigatório. O valor do elemento para adicionar ao objeto de <code>Map</code>.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O objeto de <code>Map</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_método_set">Usando o método <code>set</code> </h3> + +<pre class="brush: js">var myMap = new Map(); + +// adiciona novos elementos ao map +myMap.set('bar', 'foo'); +myMap.set(1, 'foobar'); + +// Atualiza um elemento no map +myMap.set('bar', 'baz'); +</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('ES2015', '#sec-map.prototype.set', 'Map.prototype.set')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td><span style="display: none;"> </span>Definição inicial.</td> + </tr> + <tr> + <td><span style="display: none;"> </span>{{SpecName('ESDraft', '#sec-map.prototype.set', 'Map.prototype.set')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</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>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("13.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</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>Edge</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>38</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("13.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notas_sobre_compatibilidade">Notas sobre compatibilidade</h2> + +<ul> + <li>Antes do Firefox 33 {{geckoRelease("33")}}, <code>Map.prototype.set</code> retornava <code>undefined</code> e não era encadeável. Isso foi corrigido ({{bug(1031632)}}). O comportamento também pode ser encontrado no Chrome/v8 (<a href="https://code.google.com/p/v8/issues/detail?id=3410">issue</a>) e IE11.</li> +</ul> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.get()")}}</li> + <li>{{jsxref("Map.prototype.has()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/map/size/index.html b/files/pt-br/web/javascript/reference/global_objects/map/size/index.html new file mode 100644 index 0000000000..6ce3b4ff7a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/map/size/index.html @@ -0,0 +1,110 @@ +--- +title: Map.prototype.size +slug: Web/JavaScript/Reference/Global_Objects/Map/size +translation_of: Web/JavaScript/Reference/Global_Objects/Map/size +--- +<div>{{JSRef}}</div> + +<p>A propriedade de acesso <code><strong>size</strong></code> retorna o número de elementos em um objeto {{jsxref("Map")}}.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O valor de <code>size</code> é um integer representando quantas entradas o objeto <code>Map</code> tem. Uma function set de acesso ao size é <code>undefined</code>; você não pode trocar esta propriedade.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_size">Usando <code>size</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set("a", "alpha"); +myMap.set("b", "beta"); +myMap.set("g", "gamma"); + +myMap.size // 3 +</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-get-map.prototype.size', 'Map.prototype.size')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição Inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-map.prototype.size', 'Map.prototype.size')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os 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>38</td> + <td>{{ CompatGeckoDesktop("19") }}</td> + <td>{{ CompatIE("11") }}</td> + <td>25</td> + <td>7.1</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>38</td> + <td>{{CompatGeckoMobile("19")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Gecko_-_Notas_específicas">Gecko - Notas específicas</h2> + +<ul> + <li>Do Gecko 13 {{geckoRelease("13")}} ao Gecko 18 {{geckoRelease("18")}} a propriedade size foi implementada como um metodo <strong><code>Map.prototype.size()</code></strong>, isto foi trocado para uma propriedade em versões posteriores conforme a especificação ECMAScript 6 ({{bug("807001")}}).</li> +</ul> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/map/values/index.html b/files/pt-br/web/javascript/reference/global_objects/map/values/index.html new file mode 100644 index 0000000000..8bb1e96bca --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/map/values/index.html @@ -0,0 +1,74 @@ +--- +title: Map.prototype.values() +slug: Web/JavaScript/Reference/Global_Objects/Map/values +tags: + - Iterador + - Mapa + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Map/values +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>values()</strong></code> retorna um novo objeto <strong><a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a></strong> que contém os valores de cada elemento do objeto <code>Map</code> em ordem de inserção.</p> + +<div>{{EmbedInteractiveExample("pages/js/map-prototype-values.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>meuMap</em>.values()</code></pre> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Um novo objeto iterador do {{jsxref("Map")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_values()">Usando o <code>values()</code></h3> + +<pre class="brush:js">var meuMap = new Map(); +meuMap.set('0', 'foo'); +meuMap.set(1, 'bar'); +meuMap.set({}, 'baz'); + +var mapIter = myMap.values(); + +console.log(mapIter.next().value); // "foo" +console.log(mapIter.next().value); // "bar" +console.log(mapIter.next().value); // "baz"</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('ES2015', '#sec-map.prototype.values', 'Map.prototype.values')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.values', 'Map.prototype.values')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + + + +<p>{{Compat("javascript.builtins.Map.values")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Map.prototype.entries()")}}</li> + <li>{{jsxref("Map.prototype.keys()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/abs/index.html b/files/pt-br/web/javascript/reference/global_objects/math/abs/index.html new file mode 100644 index 0000000000..1a3658a719 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/abs/index.html @@ -0,0 +1,142 @@ +--- +title: Math.abs() +slug: Web/JavaScript/Reference/Global_Objects/Math/abs +translation_of: Web/JavaScript/Reference/Global_Objects/Math/abs +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>A função <code><strong>Math.abs(x)</strong></code> retorna o valor absoluto de um número "x", tal qual:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.abs</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mrow><mo stretchy="false">|</mo><mi>x</mi><mo stretchy="false">|</mo></mrow><mo>=</mo><mrow><mo>{</mo><mtable columnalign="left left"><mtr><mtd><mi>x</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>></mo><mn>0</mn></mtd></mtr><mtr><mtd><mi>0</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>=</mo><mn>0</mn></mtd></mtr><mtr><mtd><mo>-</mo><mi>x</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo><</mo><mn>0</mn></mtd></mtr></mtable></mrow></mrow><annotation encoding="TeX">{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x & \text{if} \quad x \geq 0 \\ -x & \text{if} \quad x < 0 \end{cases} </annotation></semantics></math></p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox">var abs = Math.abs(<em>x</em>);</pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Valor_de_Retorno">Valor de Retorno</h3> + +<p>O valor absoluto do número passado</p> + +<h2 id="Description" name="Description">Descrição.</h2> + +<p>Por <code>abs</code> ser um método estático de <code>Math</code>, você sempre o usará como <code>Math.abs() </code>ao ínves de usar como método de um objeto <code>Math</code> criado por você. (<code>Math</code> não é um construtor);</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Math.abs_behavior" name="Example:_Math.abs_behavior">Comportamento de <code>Math.abs()</code></h3> + +<p>Passando um string não-numérica ou variável indefinida/vazia retorna <code>NaN</code>. Passando null retorna 0.</p> + +<pre class="brush: js">Math.abs('-1'); // 1 +Math.abs(-2); // 2 +Math.abs(null); // 0 +Math.abs(''); // 0 +Math.abs([]); // 0 +Math.abs([2]); // 2 +Math.abs([1,2]); // NaN +Math.abs({}); // NaN +Math.abs('string'); // NaN +Math.abs(); // NaN</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.1', 'Math.abs')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.abs', 'Math.abs')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.abs', 'Math.abs')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de 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>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}}</li> + <li>{{jsxref("Math.trunc()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/acos/index.html b/files/pt-br/web/javascript/reference/global_objects/math/acos/index.html new file mode 100644 index 0000000000..beea711e08 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/acos/index.html @@ -0,0 +1,139 @@ +--- +title: Math.acos() +slug: Web/JavaScript/Reference/Global_Objects/Math/acos +translation_of: Web/JavaScript/Reference/Global_Objects/Math/acos +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.acos()</code></strong> retorna o arco cosseno (em radianos de um numero, sendo esse</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arccos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mo stretchy="false">[</mo><mn>0</mn><mo>;</mo><mi>π</mi><mo stretchy="false">]</mo><mspace width="thinmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cos</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ O unico } \; y \in [0; \pi] \, \text{such that} \; \cos(y) = x</annotation></semantics></math></p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.acos(<var>x</var>)</code></pre> + +<h3 id="Parâmetros"><strong>Parâmetros</strong> </h3> + +<dl> + <dd>Um numero.</dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>O arco cosseno(em radianos) se o valor passado como parâmetro for entre -1 e 1; caso contrario retornará {{jsxref("NaN")}}.</p> + +<h2 id="Description">Description</h2> + +<p>O <code>Math.acos()</code> metodo retorna um numero entre 0 e π radians para valores passado como parâmetros entre -1 e 1. Se o valor estiver fora dessa variação será returnado {{jsxref("NaN")}}.</p> + +<p>Porque <code>acos() é um metodo estático</code>, você sempre usará <code>Math.acos() ao invés de criar um Objecto Math(Math não é um construtor).</code></p> + +<h2 id="Examplos">Examplos</h2> + +<h3 id="Usando_Math.acos()">Usando <code>Math.acos()</code></h3> + +<pre class="brush: js">Math.acos(-2); // NaN +Math.acos(-1); // 3.141592653589793 +Math.acos(0); // 1.5707963267948966 +Math.acos(0.5); // 1.0471975511965979 +Math.acos(1); // 0 +Math.acos(2); // NaN +</pre> + +<p>Para valores menores que -1 ou maiores que than 1, <code>Math.acos()</code> o método retornrá {{jsxref("NaN")}}.</p> + +<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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.2', 'Math.acos')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.acos', 'Math.acos')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.acos', 'Math.acos')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre 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>{{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="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/acosh/index.html b/files/pt-br/web/javascript/reference/global_objects/math/acosh/index.html new file mode 100644 index 0000000000..d80acedc5d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/acosh/index.html @@ -0,0 +1,100 @@ +--- +title: Math.acosh() +slug: Web/JavaScript/Reference/Global_Objects/Math/acosh +tags: + - JavaScript + - Math + - Method + - Reference + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Math/acosh +--- +<div>{{JSRef}}</div> + +<p>A função Math.acosh() retorna o arco cosseno hiperbólico de um número, onde</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cosh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 1, \mathtt{\operatorname{Math.acosh}(x)} = \operatorname{arcosh}(x) = \text{ the unique } \; y \geq 0 \; \text{such that} \; \cosh(y) = x</annotation></semantics></math></p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.acosh(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>The hyperbolic arc-cosine of the given number. If the number is less than <strong>1</strong>, {{jsxref("NaN")}}.</p> + +<p>O arco cosseno hiperbólico do número recebido. Se o número for menor que 1, {{jsxref("NaN")}} é retornado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Por <code>acosh()</code> ser um método estático de <code>Math</code>, deve-se sempre usá-lo como <code>Math.acosh()</code>, e não como um método de um objeto <code>Math</code> que você criou.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.acosh()">Usando <code>Math.acosh()</code></h3> + +<pre class="brush: js">Math.acosh(-1); // NaN +Math.acosh(0); // NaN +Math.acosh(0.5); // NaN +Math.acosh(1); // 0 +Math.acosh(2); // 1.3169578969248166 +</pre> + +<p>For values less than 1 <code>Math.acosh()</code> returns {{jsxref("NaN")}}.</p> + +<p>Para valores menores que 1, <code>Math.acosh()</code> retornará {{jsxref("NaN")}}.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Para todo <math><semantics><mrow><mi>x</mi><mo>≥</mo><mn>1</mn></mrow><annotation encoding="TeX">x \geq 1</annotation></semantics></math>, temos <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><msqrt><mrow><msup><mi>x</mi><mn>2</mn></msup><mo>-</mo><mn>1</mn></mrow></msqrt></mrow><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {arcosh} (x) = \ln \left(x + \sqrt{x^{2} - 1} \right)</annotation></semantics></math>. Dessa maneira, este comportamento pode ser emulado da seguinte maneira:</p> + +<pre class="brush: js">Math.acosh = Math.acosh || function(x) { + return Math.log(x + Math.sqrt(x * x - 1)); +}; +</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-math.acosh', 'Math.acosh')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.acosh', 'Math.acosh')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.acosh")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Math.asinh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.cosh()")}}</li> + <li>{{jsxref("Math.sinh()")}}</li> + <li>{{jsxref("Math.tanh()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/asin/index.html b/files/pt-br/web/javascript/reference/global_objects/math/asin/index.html new file mode 100644 index 0000000000..7738c1e819 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/asin/index.html @@ -0,0 +1,103 @@ +--- +title: Math.asin() +slug: Web/JavaScript/Reference/Global_Objects/Math/asin +tags: + - JavaScript + - Math + - Method + - Método(2) + - Reference + - Referência(2) +translation_of: Web/JavaScript/Reference/Global_Objects/Math/asin +--- +<div>{{JSRef}}</div> + +<p> </p> + +<p>A função Math.asin() retorna o arco seno (em radianos) de um número, onde</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arcsin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=o único valor</mo><mtext> </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tal que sin</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \sin(y) = x</annotation></semantics></math></p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.asin(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O arco seno (em radianos) do parâmetro recebido se o parâmetro estiver entre <strong>-1</strong> e <strong>1</strong>; senão, {{jsxref("NaN")}}.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>Math.asin()</code> retorna um valor numérico entre <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> e <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> radianos para todo <code>x</code> entre -1 e 1. Se o valor de <code>x</code> estiver fora deste intervalo {{jsxref("NaN")}} é retornado.</p> + +<p>Por <code>asin()</code> ser um método estático de <code>Math</code>, deve-se sempre usá-lo como <code>Math.asin()</code>, e não como um método de um objeto <code>Math</code> que você criou.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.asin()">Usando <code>Math.asin()</code></h3> + +<pre class="brush: js">Math.asin(-2); // NaN +Math.asin(-1); // -1.5707963267948966 (-pi/2) +Math.asin(0); // 0 +Math.asin(0.5); // 0.5235987755982989 +Math.asin(1); // 1.5707963267948966 (pi/2) +Math.asin(2); // NaN +</pre> + +<p>Para valores menores que -1 ou maiores que 1, <code>Math.asin()</code> retorna {{jsxref("NaN")}}.</p> + +<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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.3', 'Math.asin')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.asin', 'Math.asin')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.asin', 'Math.asin')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.asin")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/asinh/index.html b/files/pt-br/web/javascript/reference/global_objects/math/asinh/index.html new file mode 100644 index 0000000000..56c7d8a684 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/asinh/index.html @@ -0,0 +1,97 @@ +--- +title: Math.asinh() +slug: Web/JavaScript/Reference/Global_Objects/Math/asinh +tags: + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Math/asinh +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.asinh()</code></strong> retorna o arco-seno hiperbólico de um número, isto é:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arsinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sinh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{o} \; y \; \text{único tal que} \; \sinh(y) = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-asinh.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.asinh(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O arco-seno hiperbólico de um dado número.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Como <code>asinh()</code> é um métodos estático de <code>Math</code>, você deve sempre chamá-lo como <code>Math.asinh()</code>, ao invés de um método de um objeto <code>Math</code> que você criou (<code>Math</code> não é um construtor).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.asinh()">Usando <code>Math.asinh()</code></h3> + +<pre class="brush: js">Math.asinh(1); // 0.881373587019543 +Math.asinh(0); // 0 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Como uma solução simples a expressçao<math><semantics><annotation encoding="TeX">\operatorname {arsinh} (x) = \ln \left(x + \sqrt{x^{2} + 1} \right)</annotation></semantics></math> pode ser usada diretamente para uma emulação grosseira pela seguinte função:</p> + +<pre class="brush: js">Math.asinh = Math.asinh || function(x) { + if (x === -Infinity) { + return x; + } else { + return Math.log(x + Math.sqrt(x * x + 1)); + } +}; +</pre> + +<p>Apesar de formalmente correta, ela sofre de algumas problemas relacionadas à computação de ponto flutuante. Resultados precisos precisam de tratamento especial de positivos/negativos e argumentos pequenos/grandes como feitos por exemplo em em <a href="https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/ieee754/dbl-64/s_asinh.c">glibc</a> ou<a href="http://git.savannah.gnu.org/cgit/gsl.git/tree/sys/invhyp.c">GNU Scientific Library</a>.</p> + +<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-math.asinh', 'Math.asinh')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.asinh', 'Math.asinh')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitade_de_navegadores">Compatibilitade de navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.asinh")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.cosh()")}}</li> + <li>{{jsxref("Math.sinh()")}}</li> + <li>{{jsxref("Math.tanh()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/atan/index.html b/files/pt-br/web/javascript/reference/global_objects/math/atan/index.html new file mode 100644 index 0000000000..91e5b4f52a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/atan/index.html @@ -0,0 +1,104 @@ +--- +title: Math.atan() +slug: Web/JavaScript/Reference/Global_Objects/Math/atan +tags: + - JavaScript + - Math + - Method + - Reference + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.atan()</code></strong> retorna a arco tangente (em radianos) de um número, onde</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arctan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tan</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \tan(y) = x</annotation></semantics></math></p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.atan(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O arco tangente (em radianos) do parâmetro recebido.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>Math.atan()</code> retorna um valor numérico entre <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> e <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> radianos.</p> + +<p>Por <code>atan()</code> ser um método estático de <code>Math</code>, deve-se sempre usá-lo como <code>Math.atan()</code>, e não como um método de um objeto <code>Math</code> que você criou.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.atan()">Usando <code>Math.atan()</code></h3> + +<pre class="brush: js">Math.atan(1); // 0.7853981633974483 +Math.atan(0); // 0 +Math.atan(-0); // -0 + +Math.atan(Infinity); <span class="objectBox objectBox-number"> // 1.5707963267948966 +Math.atan(-Infinity); // -1.5707963267948966 + +</span>// The angle that the line [(0,0);(x,y)] forms with the x-axis in a Cartesian coordinate system +Math.atan(y / x); +</pre> + +<p>Talvez você queira evitar usar <strong>±</strong><code>Infinity</code> por motivos estéticos. Nesse caso, {{jsxref("Math.atan2()")}} com <code>0</code> como segundo parâmentro pode ser uma solução melhor.</p> + +<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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado em JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.4', 'Math.atan')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.atan', 'Math.atan')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.atan', 'Math.atan')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.atan")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/atan2/index.html b/files/pt-br/web/javascript/reference/global_objects/math/atan2/index.html new file mode 100644 index 0000000000..0c3b534c88 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/atan2/index.html @@ -0,0 +1,150 @@ +--- +title: Math.atan2() +slug: Web/JavaScript/Reference/Global_Objects/Math/atan2 +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan2 +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.atan2()</code></strong> retorna o arco tangente do coeficiente dos argumentos passado.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.atan2(<var>y</var>, <var>x</var>)</code></pre> + +<h3 id="Parâmentros">Parâmentros</h3> + +<dl> + <dt><code>y</code></dt> + <dd>Primeiro numero.</dd> + <dt><code>x</code></dt> + <dd>Segundo numero.</dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>O arco tagente do coegiente dos parâmetros</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O <code>Math.atan2()</code> método retorna um valor numérico entre -π e π representando o ângulo teta entre (x, y). Assim indo no sentido anti-horario ao ângulo, medido em radianos, entre o eixo X positivo, e o ponto<code>(x, y)</code>.Nota os argumentos para essa função: primeiro o eixo Y(ordenadas) e o eixo X(absissas) como segundo parâmetro.</p> + +<p><img alt="A simple diagram showing the angle returned by atan2(y, x)" src="https://mdn.mozillademos.org/files/11557/atan2.png" style="height: 300px; width: 300px;"></p> + +<p><code>Math.atan2()os argumentos são passados separados x e y enquanto no Math.atan() é passado a razão entre esses argumentos.</code></p> + +<p>Porque <code>atan2()</code> é um método estático de <code>Math</code>, você sempre usará <code>Math.atan2()</code>, ao inves de um objeto Math criado (<code>Math</code> não é um construtor).</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_Math.atan2()">Using <code>Math.atan2()</code></h3> + +<pre class="brush: js">Math.atan2(90, 15); // 1.4056476493802699 +Math.atan2(15, 90); // 0.16514867741462683 + +Math.atan2(±0, -0); // ±PI. +Math.atan2(±0, +0); // ±0. +Math.atan2(±0, -x); // ±PI for x > 0. +Math.atan2(±0, x); // ±0 for x > 0. +Math.atan2(-y, ±0); // -PI/2 for y > 0. +Math.atan2(y, ±0); // PI/2 for y > 0. +Math.atan2(±y, -Infinity); // ±PI for finite y > 0. +Math.atan2(±y, +Infinity); // ±0 for finite y > 0. +Math.atan2(±Infinity, x); // ±PI/2 for finite x. +Math.atan2(±Infinity, -Infinity); // ±3*PI/4. +Math.atan2(±Infinity, +Infinity); // ±PI/4. +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.5', 'Math.atan2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.atan2', 'Math.atan2')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.atan2', 'Math.atan2')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</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="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/atanh/index.html b/files/pt-br/web/javascript/reference/global_objects/math/atanh/index.html new file mode 100644 index 0000000000..0ccb86d421 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/atanh/index.html @@ -0,0 +1,99 @@ +--- +title: Math.atanh() +slug: Web/JavaScript/Reference/Global_Objects/Math/atanh +tags: + - JavaScript + - Math + - Method + - Reference + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atanh +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.atanh()</code></strong> retorna o arco tangente hiperbólico de um número, onde</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mrow><mo>(</mo><mrow><mo>-</mo><mn>1</mn><mo>,</mo><mn>1</mn></mrow><mo>)</mo></mrow><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arctanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tanh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in \left( -1, 1 \right), \mathtt{\operatorname{Math.atanh}(x)} = \operatorname{arctanh}(x) = \text{ the unique } \; y \; \text{such that} \; \tanh(y) = x</annotation></semantics></math></p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.atanh(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>O número.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O arco tangente hiperbólico do parâmetro recebido.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Por <code>atanh()</code> ser um método estático de <code>Math</code>, deve-se sempre usá-lo como <code>Math.atanh()</code>, e não como um método de um objeto <code>Math</code> que você criou.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.atanh()">Usando <code>Math.atanh()</code></h3> + +<pre class="brush: js">Math.atanh(-2); // NaN +Math.atanh(-1); // -Infinity +Math.atanh(0); // 0 +Math.atanh(0.5); // 0.5493061443340548 +Math.atanh(1); // Infinity +Math.atanh(2); // NaN +</pre> + +<p>For values greater than 1 or less than -1, {{jsxref("NaN")}} is returned.</p> + +<p>Para valores menores que -1 ou maiores que 1, {{jsxref("NaN")}} é retornado.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Para <math><semantics><mrow><mrow><mo>|</mo><mi>x</mi><mo>|</mo></mrow><mo><</mo><mn>1</mn></mrow><annotation encoding="TeX">\left|x\right| < 1</annotation></semantics></math>, temos <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">artanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mfrac><mn>1</mn><mn>2</mn></mfrac><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mfrac><mrow><mn>1</mn><mo>+</mo><mi>x</mi></mrow><mrow><mn>1</mn><mo>-</mo><mi>x</mi></mrow></mfrac><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {artanh} (x) = \frac{1}{2}\ln \left( \frac{1 + x}{1 - x} \right)</annotation></semantics></math>, esse comportamento pode ser emulado com a seguinte função:</p> + +<pre class="brush: js">Math.atanh = Math.atanh || function(x) { + return Math.log((1+x)/(1-x)) / 2; +}; +</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-math.atanh', 'Math.atanh')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.atanh', 'Math.atanh')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_no_navegadores">Compatibilidade no navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.atanh")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}}</li> + <li>{{jsxref("Math.asinh()")}}</li> + <li>{{jsxref("Math.cosh()")}}</li> + <li>{{jsxref("Math.sinh()")}}</li> + <li>{{jsxref("Math.tanh()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/cbrt/index.html b/files/pt-br/web/javascript/reference/global_objects/math/cbrt/index.html new file mode 100644 index 0000000000..6c7ffcdf42 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/cbrt/index.html @@ -0,0 +1,97 @@ +--- +title: Math.cbrt() +slug: Web/JavaScript/Reference/Global_Objects/Math/cbrt +tags: + - JavaScript + - Math + - Raiz Cúbica + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cbrt +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.cbrt()</code></strong> retorna a raiz cúbica de um número, isto é</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>c</mi><mi>b</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mroot><mi>x</mi><mn>3</mn></mroot><mo> =</mo><mtext> y, tal que</mtext><mspace width="thickmathspace"></mspace><mtext></mtext><msup><mi>y</mi><mn>3</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{the unique} \; y \; \text{such that} \; y^3 = x</annotation></semantics></math></p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.cbrt(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>A raiz cúbica do número fornecido.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Porque <code>cbrt()</code> é um método estático de <code>Math</code>, você sempre irá utilizar como <code>Math.cbrt()</code>, ao invés de um método de um objeto <code>Math</code> que você tenha criado (<code>Math</code> não é um construtor).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Utilizando_Math.cbrt()">Utilizando <code>Math.cbrt()</code></h3> + +<pre class="brush: js">Math.cbrt(NaN); // NaN +Math.cbrt(-1); // -1 +Math.cbrt(-0); // -0 +Math.cbrt(-Infinity); // -Infinity +Math.cbrt(0); // 0 +Math.cbrt(1); // 1 +Math.cbrt(Infinity); // Infinity +Math.cbrt(null); // 0 +Math.cbrt(2); // 1.2599210498948734 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Para todo <math><semantics><mrow><mi>x</mi><mo>≥</mo><mn>0</mn></mrow><annotation encoding="TeX">x \geq 0</annotation></semantics></math>, temos <math><semantics><mrow><mroot><mi>x</mi><mn>3</mn></mroot><mo>=</mo><msup><mi>x</mi><mrow><mn>1</mn><mo>/</mo><mn>3</mn></mrow></msup></mrow><annotation encoding="TeX">\sqrt[3]{x} = x^{1/3}</annotation></semantics></math>, então isto pode ser simulado pela seguinte função:</p> + +<pre class="brush: js">if (!Math.cbrt) { + Math.cbrt = function(x) { + var y = Math.pow(Math.abs(x), 1/3); + return x < 0 ? -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-math.cbrt', 'Math.cbrt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.cbrt', 'Math.cbrt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade">Compatibilidade</h2> + +<p class="hidden">A tabela de compatibilidade nesta página é gerada de dados estruturados. Se você quiser contribuir para tais dados, por favor verifique em <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data </a>e nos envie um pull request.</p> + +<p>{{Compat("javascript.builtins.Math.cbrt")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/ceil/index.html b/files/pt-br/web/javascript/reference/global_objects/math/ceil/index.html new file mode 100644 index 0000000000..68e48daa87 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/ceil/index.html @@ -0,0 +1,210 @@ +--- +title: Math.ceil() +slug: Web/JavaScript/Reference/Global_Objects/Math/ceil +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/ceil +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p><code><font face="Open Sans, sans-serif">A função </font><strong>Math.ceil(x)</strong></code> retorna o menor número inteiro maior ou igual a "x".</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox">Math.ceil(<em>x</em>) </pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O menor inteiro maior ou igual ao número fornecido.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Por <code>ceil</code> ser um método estático de <code>Math</code>, você sempre usará como <code>Math.ceil()</code>, e não como um método do objeto <code>Math</code> que você criou.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Using_Math.ceil" name="Example:_Using_Math.ceil">Usando <code>Math.ceil()</code></h3> + +<p>O exemplo a seguir mostra um exemplo de uso de <code>Math.ceil()</code>.</p> + +<pre class="brush:js;"><code>Math.ceil(.95); // 1 +Math.ceil(4); // 4 +Math.ceil(7.004); // 8 +Math.ceil(-0.95); // -0 +Math.ceil(-4); // -4 +Math.ceil(-7.004); // -7</code></pre> + +<h3 id="Example_Decimal_adjustment" name="Example:_Decimal_adjustment">Ajuste decimal</h3> + +<pre class="brush:js">// Closure +(function(){ + + /** + * Decimal adjustment of a number. + * + * @param {String} type The type of adjustment. + * @param {Number} value The number. + * @param {Integer} exp The exponent (the 10 logarithm of the adjustment base). + * @returns {Number} The adjusted value. + */ + function decimalAdjust(type, value, exp) { + // If the exp is undefined or zero... + if (typeof exp === 'undefined' || +exp === 0) { + return Math[type](value); + } + value = +value; + exp = +exp; + // If the value is not a number or the exp is not an integer... + if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) { + return NaN; + } + // Shift + value = value.toString().split('e'); + value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp))); + // Shift back + value = value.toString().split('e'); + return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)); + } + + // Decimal round + if (!Math.round10) { + Math.round10 = function(value, exp) { + return decimalAdjust('round', value, exp); + }; + } + // Decimal floor + if (!Math.floor10) { + Math.floor10 = function(value, exp) { + return decimalAdjust('floor', value, exp); + }; + } + // Decimal ceil + if (!Math.ceil10) { + Math.ceil10 = function(value, exp) { + return decimalAdjust('ceil', value, exp); + }; + } + +})(); + +// Round +Math.round10(55.55, -1); // 55.6 +Math.round10(55.549, -1); // 55.5 +Math.round10(55, 1); // 60 +Math.round10(54.9, 1); // 50 +Math.round10(-55.55, -1); // -55.5 +Math.round10(-55.551, -1); // -55.6 +Math.round10(-55, 1); // -50 +Math.round10(-55.1, 1); // -60 +// Floor +Math.floor10(55.59, -1); // 55.5 +Math.floor10(59, 1); // 50 +Math.floor10(-55.51, -1); // -55.6 +Math.floor10(-51, 1); // -60 +// Ceil +Math.ceil10(55.51, -1); // 55.6 +Math.ceil10(51, 1); // 60 +Math.ceil10(-55.59, -1); // -55.5 +Math.ceil10(-59, 1); // -50 +</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>ECMAScript 1st Edition. implementado em JavaScript 1.0</td> + <td>Padrão</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.6', 'Math.ceil')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.ceil', 'Math.ceil')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_Browsers">Compatibilidade dos Browsers</h2> + +<p>{{ CompatibilityTable() }}</p> + +<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>{{ 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>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>{{ 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>O objeto {{jsxref("Global_Objects/Math", "Math")}} pertence a.</li> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}}</li> + <li>{{jsxref("Math.trunc()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/clz32/index.html b/files/pt-br/web/javascript/reference/global_objects/math/clz32/index.html new file mode 100644 index 0000000000..c997e014ec --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/clz32/index.html @@ -0,0 +1,179 @@ +--- +title: Math.clz32() +slug: Web/JavaScript/Reference/Global_Objects/Math/clz32 +tags: + - JavaScript + - Math + - sintaxe Math.clz32() +translation_of: Web/JavaScript/Reference/Global_Objects/Math/clz32 +--- +<div>{{JSRef}}</div> + +<p>A função Math.clz32 () retorna o número de zero bit inicial na representação binária de 32 bits de um número.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-clz32.html")}}</div> + +<p class="hidden">A fonte para esse exemplo interativo está armazenado em um GitHub repositório. Se você desejar 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 nos enie um pull request.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code>Math.clz32(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><var>x</var></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O número de zero bits à esquerda na representação binária de 32 bits do número fornecido.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>"<code>clz32</code>" é short para<code>CountLeadingZeroes32</code>.</p> + +<p>Se x não for um número, ele será convertido em um número primeiro e depois convertido em um número inteiro não assinado de 32 bits.</p> + +<p>Se o número inteiro não assinado de 32 bits convertido for 0, retorne 32, porque todos os bits são 0.</p> + +<p>Essa função é particularmente útil para sistemas que são compilados para JS, como o Emscripten.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.clz32">Usando <code>Math.clz32()</code></h3> + +<pre class="brush: js notranslate">Math.clz32(1); // 31 +Math.clz32(1000); // 22 +Math.clz32(); // 32 + +var stuff = [NaN, Infinity, -Infinity, 0, -0, null, undefined, 'foo', {}, []]; +stuff.every(n => Math.clz32(n) == 32); // true + +Math.clz32(true); // 31 +Math.clz32(3.5); // 30</pre> + +<h2 id="Contagem_dos_principais_e_mais_além">Contagem dos principais e mais além</h2> + +<p>No momento, não há Math.clon para "Count Leading Ones" (chamado "clon", não "clo", porque "clo" e "clz" são muito semelhantes, especialmente para pessoas que não falam inglês). No entanto, uma função clon pode ser criada facilmente, invertendo os bits de um número e passando o resultado para Math.clz32. Fazer isso funcionará porque o inverso de 1 é 0 e vice-versa. Assim, a inversão dos bits inverterá a quantidade medida de 0s (de Math.clz32), fazendo com que Math.clz32 conte o número de unidades em vez de contar o número de zeros.</p> + +<p>Considere a seguinte palavra de 32 bits:</p> + +<pre class="brush: js notranslate">var a = 32776; // 00000000000000001000000000001000 (16 zeros à esquerda) +Math.clz32(a); // 16 + +var b = ~32776; // 11111111111111110111111111110111 (32776 inverso, 0 zeros à esquerda) +Math.clz32(b); // 0 (isso é igual a quantos líderes existem em um)</pre> + +<p>Usando essa lógica, uma função clon pode ser criada da seguinte maneira:</p> + +<pre class="brush: js notranslate">var clz = Math.clz32; +function clon(integer){ + return clz(~integer); +} +</pre> + +<p>Além disso, essa técnica pode ser estendida para criar funções inumeráveis "Contagem de zeros à direita" e funções de contagem de zeros, como mostrado abaixo. A função ctrz abaixo preenche todos os bits altos com o bit mais baixo preenchido e depois os anula para apagar todos os bits mais altos definidos, de modo que o clz possa ser usado.</p> + +<pre class="brush: js notranslate">var clz = Math.clz32; +function ctrz(integer){ // contar zeros à direita + // 1. preencha todos os bits mais altos após o primeiro + integer |= integer << 16; + integer |= integer << 8; + integer |= integer << 4; + integer |= integer << 2; + integer |= integer << 1; +// 2. Agora, a inversão dos bits revela os bits mais baixos + return 32 - clz(~integer) |0; // `|0`garante coerção inteira +} +function ctron(integer){ // conta os que estão à direita + // Nenhum operador shift-fill-in-with-ones está disponível em + // JavaScript, portanto, o código abaixo é o mais rápido + return ctrz(~integer); +/ * Implementação alternativa para fins demonstrativos: + // 1. apaga todos os bits mais altos após o primeiro zero + integer &= (integer << 16) | 0xffff; + integer &= (integer << 8 ) | 0x00ff; + integer &= (integer << 4 ) | 0x000f; + integer &= (integer << 2 ) | 0x0003; + integer &= (integer << 1 ) | 0x0001; + // 2. Agora, reverter os bits revela os zeros mais baixos + return 32 - clon(~integer) |0; + */ +} +</pre> + +<p>Transforme essas funções auxiliares no módulo ASM.JS; então, você tem uma verdadeira obra-prima de desempenho. Situações como essas são exatamente para o que o ASM.JS foi projetado.</p> + +<pre class="brush: js notranslate">var countTrailsMethods = (function(stdlib, foreign, heap) { + "use asm"; + var clz = stdlib.Math.clz32; + function ctrz(integer) { // count trailing zeros + integer = integer | 0; // coerce to an integer +// 1. preencha todos os bits mais altos após o primeiro +// ASM js, por algum motivo, não permite ^ =, & = ou | = + integer = integer | (integer << 16); + integer = integer | (integer << 8); + integer = integer | (integer << 4); + integer = integer | (integer << 2); + integer = integer | (integer << 1); + // 2. Agora, a inversão dos bits revela os bits mais baixos + return 32 - clz(~integer) |0; + } + function ctron(integer) { //contar os últimos + integer = integer | 0; // coagir a um número inteiro + return ctrz(~integer) |0; + } +// infelizmente, o ASM.JS exige objetos compactos lentos: + return {a: ctrz, b: ctron}; +})(window, null, null); +var ctrz = countTrailsMethods.a; +var ctron = countTrailsMethods.b;</pre> + +<h2 id="Polyfill-Trecho_de_código">Polyfill-"Trecho de código"</h2> + +<p>O seguinte polyfill é o mais eficiente.</p> + +<pre class="brush: js notranslate">if (!Math.clz32) Math.clz32 = (function(log, LN2){ + return function(x) { + // Seja n ToUint32 (x). + // Seja p o número de zero bits iniciais em + // a representação binária de 32 bits de n. + // Retornar p. + var asUint = x >>> 0; + if (asUint === 0) { + return 32; + } + return 31 - (log(asUint) / LN2 | 0) |0; // the "| 0" acts like math.floor + }; +})(Math.log, Math.LN2); +</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-math.clz32', 'Math.clz32')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2> + +<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você deseja contribuir com os dados, consulte https://github.com/mdn/browser-compat-data e envie-nos uma solicitação de recebimento.</div> + +<p>{{Compat("javascript.builtins.Math.clz32")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math")}}</li> + <li>{{jsxref("Math.imul")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/cos/index.html b/files/pt-br/web/javascript/reference/global_objects/math/cos/index.html new file mode 100644 index 0000000000..c0b0662477 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/cos/index.html @@ -0,0 +1,102 @@ +--- +title: Math.cos() +slug: Web/JavaScript/Reference/Global_Objects/Math/cos +tags: + - Geometria + - JavaScript + - Matemática + - Math + - Trigonometría + - cos + - cosseno + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cos +--- +<div>{{JSRef}}</div> + +<p><span style="display: none;"> </span><span class="seoSummary">A função <strong><code>Math.cos()</code></strong> ,que é estatica, retorna o {{interwiki("wikipedia", "cosseno")}} de um ângulo, que deve estar em {{interwiki("wikipedia", "radianos")}}. A expressão é </span><math style="display: inline;"> <mstyle displaystyle="true"> <mfrac> <msub> <mrow> <mtext>length</mtext> </mrow> <mrow> <mrow> <mtext>adjacent</mtext> </mrow> </mrow> </msub> <msub> <mrow> <mtext>length</mtext> </mrow> <mrow> <mrow> <mtext>hypotenuse</mtext> </mrow> </mrow> </msub> </mfrac> </mstyle> </math>.<span style="display: none;"> </span></p> + +<div>{{EmbedInteractiveExample("pages/js/math-cos.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.cos(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Ângulo em radianos</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O cosseno do número: x</p> + +<h2 id="Descrição">Descrição</h2> + +<p><code>Math.cos()</code> é um método que retorna um número entre -1 e 1, que representa o cosseno de um ângulo.</p> + +<p>Já que <code>cos()</code> é um método estático de <code>Math</code>, você sempre deve usar <code>Math.cos()</code>, ao invez de criar um objeto de <code>Math</code> (<code>Math</code> não tem construtor).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.cos()">Usando <code>Math.cos()</code></h3> + +<pre class="brush: js">Math.cos(0); // 1 +Math.cos(1); // 0.5403023058681398 + +Math.cos(Math.PI); // -1 +Math.cos(2 * Math.PI); // 1 +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.7', 'Math.cos')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.cos', 'Math.cos')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.cos', 'Math.cos')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_Browsers">Compatibilidade dos Browsers</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.cos")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/cosh/index.html b/files/pt-br/web/javascript/reference/global_objects/math/cosh/index.html new file mode 100644 index 0000000000..f6e0671abd --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/cosh/index.html @@ -0,0 +1,88 @@ +--- +title: Math.cosh() +slug: Web/JavaScript/Reference/Global_Objects/Math/cosh +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cosh +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.cosh()</code></strong> retorna o cosseno hiperbólico de um número, que pode ser expressada usando {{jsxref("Math.E", "constante e", "", 1)}}:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.cosh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.cosh(x)}} = \frac{e^x + e^{-x}}{2}</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-cosh.html")}}</div> + +<p class="hidden">A fonte para este exemplo interativo está armazenada em um repositório do GitHub. Se você gostaria de 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 nos envie um pull request.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.cosh(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dd><strong><code>x</code></strong></dd> + <dd> Um número.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O cosseno hiperbólico do número dado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Por <code>cosh()</code> ser um método estático de <code>Math</code>, sempre utilize como <code>Math.cosh()</code>, ao invés de como um método de um objeto <code>Math</code> que você criou (<code>Math</code> não é um construtor).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.cosh">Usando <code>Math.cosh()</code></h3> + +<pre class="brush: js">Math.cosh(0); // 1 +Math.cosh(1); // 1.5430806348152437 +Math.cosh(-1); // 1.5430806348152437 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Isto pode ser emulado com a ajuda da função {{jsxref("Math.exp()")}}:</p> + +<pre class="brush: js">Math.cosh = Math.cosh || function(x) { + return (Math.exp(x) + Math.exp(-x)) / 2; +} +</pre> + +<p>ou usando apenas uma chamada da função {{jsxref("Math.exp()")}}:</p> + +<pre class="brush: js">Math.cosh = Math.cosh || function(x) { + var y = Math.exp(x); + return (y + 1 / y) / 2; +}; +</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-math.cosh', 'Math.cosh')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2> + +<p class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você gostaria de contribuir com as informações, por favor faça um check out de <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</p> + +<p>{{Compat("javascript.builtins.Math.cosh")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}}</li> + <li>{{jsxref("Math.asinh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.sinh()")}}</li> + <li>{{jsxref("Math.tanh()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/e/index.html b/files/pt-br/web/javascript/reference/global_objects/math/e/index.html new file mode 100644 index 0000000000..36b01b0430 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/e/index.html @@ -0,0 +1,86 @@ +--- +title: Math.E +slug: Web/JavaScript/Reference/Global_Objects/Math/E +tags: + - JavaScript + - Math + - Propriedade + - Referencia +translation_of: Web/JavaScript/Reference/Global_Objects/Math/E +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Math.E</code></strong> representa a base dos logarítmos naturais, aproximadamente 2.718.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.E</mi></mstyle><mo>=</mo><mi>e</mi><mo>≈</mo><mn>2.718</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.E}} = e \approx 2.718</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-e.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> + +<div> </div> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Como <code>E</code> é uma propriedade estática de <code>Math</code>, sempre use-a como <code>Math.E</code>, ao invés de uma propriedade de um objeto <code>Math</code> que você criou (<code>Math</code> não é um construtor).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.E">Usando <code>Math.E</code></h3> + +<p>A seguinte função retorna o valor de <em>e</em>:</p> + +<pre class="brush: js">function getNapier() { + return Math.E; +} + +getNapier(); // 2.718281828459045 +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.1', 'Math.E')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.e', 'Math.E')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.e', 'Math.E')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + + + +<p>{{Compat("javascript.builtins.Math.E")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/exp/index.html b/files/pt-br/web/javascript/reference/global_objects/math/exp/index.html new file mode 100644 index 0000000000..279cb1b60b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/exp/index.html @@ -0,0 +1,109 @@ +--- +title: Math.exp() +slug: Web/JavaScript/Reference/Global_Objects/Math/exp +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/exp +--- +<div> + {{JSRef("Global_Objects", "Math")}}</div> +<h2 id="Summary" name="Summary">Sumário</h2> +<p>A função <code><strong>Math.exp()</strong></code> retorna <code>e<sup>x</sup></code>, onde <code>x</code> é o argumento, e <code>e</code> é a <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/E">Constante de Euler</a>, a base dos logaritmos naturais</p> +<h2 id="Syntax" name="Syntax">Síntaxe</h2> +<pre class="brush:js">Math.exp(x)</pre> +<h3 id="Parameters" name="Parameters">Parâmetros</h3> +<dl> + <dt> + <code>x</code></dt> + <dd> + Um número.</dd> +</dl> +<h2 id="Description" name="Description">Descrição</h2> +<p>Pelo fato de <code>exp</code> ser um método estático de <code>Math</code>, você sempre utiliza-o como <code>Math.exp()</code>, não como um método do objeto <code>Math</code> que você criou.</p> +<h2 id="Examples" name="Examples">Exemplos</h2> +<h3 id="Example:_Using_Math.exp" name="Example:_Using_Math.exp">Exemplo: Usando <code>Math.exp</code></h3> +<pre class="brush:js">Math.exp(-1); // 0.36787944117144233 +Math.exp(0); // 1 +Math.exp(1); // 2.718281828459045</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>1ª Edição ECMAScript 1st Edition. Implementado em JavaScript 1.0</td> + <td>Padrão</td> + <td>Definição Inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.8', 'Math.exp')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.exp', 'Math.exp')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> +<p>{{ CompatibilityTable() }}</p> +<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>{{ 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>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>{{ 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>O objeto {{jsxref("Global_Objects/Math", "Math")}} ao qual ele pertence.</li> + <li>{{jsxref("Math.E")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/expm1/index.html b/files/pt-br/web/javascript/reference/global_objects/math/expm1/index.html new file mode 100644 index 0000000000..0dfe3aab94 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/expm1/index.html @@ -0,0 +1,80 @@ +--- +title: Math.expm1() +slug: Web/JavaScript/Reference/Global_Objects/Math/expm1 +translation_of: Web/JavaScript/Reference/Global_Objects/Math/expm1 +--- +<div>{{JSRef}}</div> + +<p>The <strong><code>Math.expm1()</code></strong> function returns <code>e<sup>x</sup> - 1</code>, where <code>x</code> is the argument, and {{jsxref("Math.E", "e", "", 1)}} the base of the natural logarithms.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-expm1.html")}}</div> + + + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><code>Math.expm1(<var>x</var>)</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>Um número representando <code>e<sup>x</sup> - 1</code>, onde <code>e</code> é {{jsxref("Math.E", "Euler's number", "", 1)}} e <code>x</code> ié o argumento.</p> + +<h2 id="Description">Description</h2> + +<p>Porque <code>expm1()</code> é um método estático de is <code>Math</code>, você sempre o usurá como <code>Math.expm1()</code>, do que como um método de um objeto <code>Math</code> que você criou (<code>Math</code> não é um contrutor).</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>This can be emulated with the help of the {{jsxref("Math.exp()")}} function:</p> + +<pre class="brush: js notranslate">Math.expm1 = Math.expm1 || function(x) { + return Math.exp(x) - 1; +}; +</pre> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_Math.expm1">Using <code>Math.expm1()</code></h3> + +<pre class="brush: js notranslate">Math.expm1(-1); // -0.6321205588285577 +Math.expm1(0); // 0 +Math.expm1(1); // 1.718281828459045 +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.expm1', 'Math.expm1')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.expm1")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Math.E")}}</li> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/floor/index.html b/files/pt-br/web/javascript/reference/global_objects/math/floor/index.html new file mode 100644 index 0000000000..13dc5a0638 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/floor/index.html @@ -0,0 +1,199 @@ +--- +title: Math.floor() +slug: Web/JavaScript/Reference/Global_Objects/Math/floor +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>A função <code><strong>Math.floor(x)</strong></code> retorna o menor número inteiro dentre o número "x".</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.floor(<em>x</em>) </code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Por <code>floor</code> ser um método estático de <code>Math</code>, você sempre irá usar como <code>Math.floor()</code>,e não como método do objeto <code>Math que você criou</code>.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Using_Math.floor" name="Example:_Using_Math.floor">Exemplo: Usando <code>Math.floor</code></h3> + +<pre class="brush:js">Math.floor( 45.95); // 45 +Math.floor(-45.95); // -46 +</pre> + +<h3 id="Example:_Decimal_adjustment" name="Example:_Decimal_adjustment">Exemplo: Ajuste Decimal</h3> + +<pre class="brush:js">// Closure +(function(){ + + /** + * Decimal adjustment of a number. + * + * @param {String} type The type of adjustment. + * @param {Number} value The number. + * @param {Integer} exp The exponent (the 10 logarithm of the adjustment base). + * @returns {Number} The adjusted value. + */ + function decimalAdjust(type, value, exp) { + // If the exp is undefined or zero... + if (typeof exp === 'undefined' || +exp === 0) { + return Math[type](value); + } + value = +value; + exp = +exp; + // If the value is not a number or the exp is not an integer... + if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) { + return NaN; + } + // Shift + value = value.toString().split('e'); + value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp))); + // Shift back + value = value.toString().split('e'); + return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)); + } + + // Decimal round + if (!Math.round10) { + Math.round10 = function(value, exp) { + return decimalAdjust('round', value, exp); + }; + } + // Decimal floor + if (!Math.floor10) { + Math.floor10 = function(value, exp) { + return decimalAdjust('floor', value, exp); + }; + } + // Decimal ceil + if (!Math.ceil10) { + Math.ceil10 = function(value, exp) { + return decimalAdjust('ceil', value, exp); + }; + } + +})(); + +// Round +Math.round10(55.55, -1); // 55.6 +Math.round10(55.549, -1); // 55.5 +Math.round10(55, 1); // 60 +Math.round10(54.9, 1); // 50 +Math.round10(-55.55, -1); // -55.5 +Math.round10(-55.551, -1); // -55.6 +Math.round10(-55, 1); // -50 +Math.round10(-55.1, 1); // -60 +// Floor +Math.floor10(55.59, -1); // 55.5 +Math.floor10(59, 1); // 50 +Math.floor10(-55.51, -1); // -55.6 +Math.floor10(-51, 1); // -60 +// Ceil +Math.ceil10(55.51, -1); // 55.6 +Math.ceil10(51, 1); // 60 +Math.ceil10(-55.59, -1); // -55.5 +Math.ceil10(-59, 1); // -50 +</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. Implemented in JavaScript 1.0</td> + <td>Standard</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.9', 'Math.floor')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.floor', 'Math.floor')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_Browsers">Compatibilidade dos Browsers</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>The {{jsxref("Global_Objects/Math", "Math")}} object it belongs to.</li> + <li>{{jsxref("Math.abs")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.round()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/hypot/index.html b/files/pt-br/web/javascript/reference/global_objects/math/hypot/index.html new file mode 100644 index 0000000000..b83197c861 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/hypot/index.html @@ -0,0 +1,115 @@ +--- +title: Math.hypot() +slug: Web/JavaScript/Reference/Global_Objects/Math/hypot +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/hypot +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.hypot()</code></strong> retorna a raiz quadrada do somátorio do quadrado de seus parâmetros, ou seja</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.hypot</mo><mo stretchy="false">(</mo><msub><mi>v</mi><mn>1</mn></msub><mo>,</mo><msub><mi>v</mi><mn>2</mn></msub><mo>,</mo><mo>…</mo><mo>,</mo><msub><mi>v</mi><mi>n</mi></msub><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mrow><munderover><mo>∑</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><mi>n</mi></munderover><msubsup><mi>v</mi><mi>i</mi><mn>2</mn></msubsup></mrow></msqrt><mo>=</mo><msqrt><mrow><msubsup><mi>v</mi><mn>1</mn><mn>2</mn></msubsup><mo>+</mo><msubsup><mi>v</mi><mn>2</mn><mn>2</mn></msubsup><mo>+</mo><mo>…</mo><mo>+</mo><msubsup><mi>v</mi><mi>n</mi><mn>2</mn></msubsup></mrow></msqrt></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.hypot}(v_1, v_2, \dots, v_n)} = \sqrt{\sum_{i=1}^n v_i^2} = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2}</annotation></semantics></math></p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.hypot([<var>value1</var>[, <var>value2</var>[, ...]]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>value1, value2, ...</code></dt> + <dd>Números.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>A raiz quadrada do somátorio do quadrado dos parâmetros recebidos. Se um ou mais argumentos não puderem ser convertidos para um número, {{jsxref("NaN")}} é retornado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Para calcular a hipotenusa de um triângulo retângulo, ou o módulo de um número complexo, é usada a fórmula <code>Math.sqrt(v1*v1 + v2*v2)</code> (<math><semantics><msqrt><mrow><mi>v</mi><msup><mn>1</mn><mn>2</mn></msup><mo>+</mo><mi>v</mi><msup><mn>2</mn><mn>2</mn></msup></mrow></msqrt><annotation encoding="TeX">\sqrt{v1^2 + v2^2}</annotation></semantics></math>) onde v1 e v2 são, ou os lados de um triângulo, ou a parte real e a imaginário de um número complexo. Para calcular a distância entre duas ou mais dimensões, basta adicionar mais exponenciações dentro da raiz quadrada, por exemplo <code>Math.sqrt(v1*v1 + v2*v2 + v3*v3 + v4*v4)</code> (<math><semantics><msqrt><mrow><mi>v</mi><msup><mn>1</mn><mn>2</mn></msup><mo>+</mo><mi>v</mi><msup><mn>2</mn><mn>2</mn></msup><mo>+</mo><mi>v</mi><msup><mn>3</mn><mn>2</mn></msup><mo>+</mo><mi>v</mi><msup><mn>4</mn><mn>2</mn></msup></mrow></msqrt><annotation encoding="TeX">\sqrt{v1^2 + v2^2 + v3^2 + v4^2}</annotation></semantics></math>).</p> + +<p>A função Math.hypot() torna esta tarefa mais rápida e mais fácil, basta executar <code>Math.hypot(v1, v2)</code> , or <code>Math.hypot(v1, v2, v3, v4, ...)</code> .</p> + +<p>Dessa maneira também se evita problemas se a magnitude dos seus número for muito grande. O maio número que se pode representar em um <em>double float</em> em JavasScript é <code>Number.MAX_VALUE</code> = <span style="line-height: 1.5;">1.797...e+308</span>. Se os seu números são maior que 1e154, calcular o quadrado deles resultará em <code>Infinity</code>, estragando os seus resultados. Por exemplo, <span style="line-height: 1.5;"><code>Math.sqrt(1e200*1e200 + 1e200*1e200) = Infinity</code>. Se você usar a função <code>Math.hypot()</code>, você receberá uma resposta aceitável: <code>Math.hypot(1e200, 1e200) = 1.4142...e+200</code>.</span> Isto também é verdade para número muito pequenos. <span style="line-height: 1.5;"><code>Math.sqrt(1e-200*1e-200 + 1e-200*1e-200) = 0</code>, mas </span><code><span style="line-height: 1.5;">Math.hypot(1e-200, 1e-200) = </span></code><span style="line-height: 1.5;"><code>1.4142...e-200</code> é uma boa resposta.</span></p> + +<div class="note"> +<p>Por <code>hypot()</code> ser um método estático de <code>Math</code>, deve-se sempre usá-lo como <code>Math.hypot()</code>, e não como um método de um objeto <code>Math</code> que você criou.</p> +</div> + +<p>Se nenhum parâmetro for passado, o resultado é +0.</p> + +<p>Se um ou mais parâmetros não puderem ser convertidos para um número, o resultado será {{jsxref("NaN")}}.</p> + +<p>Com apenas um parâmetro, <code>Math.hypot()</code> se comporta como <code>Math.abs()</code>.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Usando_Math.hypot()">Usando <code>Math.hypot()</code></h3> + +<pre class="brush: js">Math.hypot(3, 4); // 5 +Math.hypot(3, 4, 5); // 7.0710678118654755 +Math.hypot(); // 0 +Math.hypot(NaN); // NaN +Math.hypot(3, 4, 'foo'); // NaN, +'foo' => NaN +Math.hypot(3, 4, '5'); // 7.0710678118654755, +'5' => 5 +Math.hypot(-3); // 3, the same as Math.abs(-3) +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>O comportamento de <code>Math.hypot()</code> pode ser emulado com a seguinte função:</p> + +<pre class="brush: js">Math.hypot = Math.hypot || function() { + var y = 0; + var length = arguments.length; + + for (var i = 0; i < length; i++) { + if (arguments[i] === Infinity || arguments[i] === -Infinity) { + return Infinity; + } + y += arguments[i] * arguments[i]; + } + return Math.sqrt(y); +}; +</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-math.hypot', 'Math.hypot')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.hypot', 'Math.hypot')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_no_navegador">Compatibilidade no navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.hypot")}}</p> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/index.html b/files/pt-br/web/javascript/reference/global_objects/math/index.html new file mode 100644 index 0000000000..47bbf2f3cb --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/index.html @@ -0,0 +1,208 @@ +--- +title: Math +slug: Web/JavaScript/Reference/Global_Objects/Math +tags: + - JavaScript + - Math + - NeedsTranslation + - TopicStub +translation_of: Web/JavaScript/Reference/Global_Objects/Math +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<p><strong>Math</strong> é um objeto embutido que tem propriedades e métodos para constantes e funções matemáticas. Não é um objeto de função.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Ao contrário de outros objetos globais, <code>Math</code> não é um construtor. Todas as propriedades e métodos de <code>Math</code> são estáticos. Você pode referenciar a constante PI como <code>Math.PI</code> e você pode chamar a função de seno como <code>Math.sin(x)</code>, onde <code>x</code> é o argumento do método. Constantes são definidas com a precisão total de números reais em JavaScript.</p> + +<h2 id="Properties" name="Properties">Propriedades</h2> + +<dl> + <dt>{{jsxref("Math.E")}}</dt> + <dd>Constante de Euler e base dos logaritmos naturais, aproximadamente 2.718.</dd> + <dt>{{jsxref("Math.LN2")}}</dt> + <dd>Logaritmo natural de 2, aproximadamente 0.693.</dd> + <dt>{{jsxref("Math.LN10")}}</dt> + <dd>Logaritmo natural de 10, aproximadamente 2.303.</dd> + <dt>{{jsxref("Math.LOG2E")}}</dt> + <dd>Logaritmo de E na base 2, aproximadamente 1.443.</dd> + <dt>{{jsxref("Math.LOG10E")}}</dt> + <dd>Logaritmo de E na base 10, aproximadamente 0.434.</dd> + <dt>{{jsxref("Math.PI")}}</dt> + <dd>Relação entre a circunferência de um círculo e o seu diâmetro, aproximadamente 3.14159.</dd> + <dt>{{jsxref("Math.SQRT1_2")}}</dt> + <dd>Raiz quadrada de 1/2; Equivale a 1 dividido pela raiz quadrada de 2, aproximadamente 0.707.</dd> + <dt>{{jsxref("Math.SQRT2")}}</dt> + <dd>Raiz quadrada de 2, aproximadamente 1.414.</dd> +</dl> + +<div>{{ jsOverrides("Object", "properties", "E", "LN2", "LN10", "LOG2E", "LOG10E", "PI", "SQRT1_2", "SQRT") }}</div> + +<h2 id="Methods" name="Methods">Métodos</h2> + +<div class="note">Note que as funções trigonométricas (sin(), cos(), tan(), asin(), acos(), atan(), atan2()) recebem ou retornam ângulos em radianos. Divida por (<code>Math.PI/180</code>) para converter radianos em graus, ou multiplique por esse valor para fazer a conversão inversa.</div> + +<dl> + <dt>{{jsxref("Global_Objects/Math/abs", "Math.abs(x)")}}</dt> + <dd>Retorna o módulo, ou valor absoluto, de um número (<math><semantics><mrow><mo stretchy="false">|</mo><mi>x</mi><mo stretchy="false">|</mo></mrow><annotation encoding="TeX">|x|</annotation></semantics></math>).</dd> + <dt>{{jsxref("Global_Objects/Math/acos", "Math.acos(x)")}}</dt> + <dd>Retorna o arco-coseno de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">arccos</mo><mi>x</mi></mrow><annotation encoding="TeX">\arccos{x}</annotation></semantics></math>).</dd> + <dt>{{jsxref("Global_Objects/Math/acosh", "Math.acosh(x)")}} {{experimental_inline}}</dt> + <dd>Retorna o arco-coseno hiperbólico de um número.</dd> + <dt>{{jsxref("Global_Objects/Math/asin", "Math.asin(x)")}}</dt> + <dd>Retorna o arco-seno de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">arcsin</mo><mi>x</mi></mrow><annotation encoding="TeX">\arcsin{x}</annotation></semantics></math>).</dd> + <dt>{{jsxref("Global_Objects/Math/asinh", "Math.asinh(x)")}} {{experimental_inline}}</dt> + <dd>Retorna o arco-seno hiperbólico de um número.</dd> + <dt>{{jsxref("Global_Objects/Math/atan", "Math.atan(x)")}}</dt> + <dd>Retorna o arco-tangente de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">arctan</mo><mi>x</mi></mrow><annotation encoding="TeX">\arctan{x}</annotation></semantics></math>).</dd> + <dt>{{jsxref("Global_Objects/Math/atanh", "Math.atanh(x)")}} {{experimental_inline}}</dt> + <dd>Retorna o arco-tangente hiperbólico de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">arctan</mo><mi>x</mi></mrow><annotation encoding="TeX">\arctan{x}</annotation></semantics></math>).</dd> + <dt>{{jsxref("Global_Objects/Math/atan2", "Math.atan2(x, y)")}}</dt> + <dd>Retorna o arco-tangente do quociente de seus argumentos.</dd> + <dt>{{jsxref("Global_Objects/Math/cbrt", "Math.cbrt(x)")}} {{experimental_inline}}</dt> + <dd>Retorna a raiz cúbica de um número (<math><semantics><mroot><mi>x</mi><mn>3</mn></mroot><annotation encoding="TeX">\root{3}{x}</annotation></semantics></math>).</dd> + <dt>{{jsxref("Global_Objects/Math/ceil", "Math.ceil(x)")}}</dt> + <dd>Retorna o menor inteiro que é maior ou igual a um número.</dd> + <dt>{{jsxref("Global_Objects/Math/cos", "Math.cos(x)")}}</dt> + <dd>Retorna o coseno de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">cos</mo><mi>x</mi></mrow><annotation encoding="TeX">\cos{x}</annotation></semantics></math>).</dd> + <dt>{{jsxref("Global_Objects/Math/cosh", "Math.cosh(x)")}} {{experimental_inline}}</dt> + <dd>Retorna o coseno hiperbólico de um número .</dd> + <dt>{{jsxref("Global_Objects/Math/exp", "Math.exp(x)")}}</dt> + <dd>Retorna <math><semantics><msup><mi>e</mi><mi>x</mi></msup><annotation encoding="TeX">e^x</annotation></semantics></math>, onde <var>x</var> é o argumento, e <math><semantics><mi>e</mi><annotation encoding="TeX">e</annotation></semantics></math> é a constante de Euler (2.718...), a base do logaritmo natural.</dd> + <dt>{{jsxref("Global_Objects/Math/expm1", "Math.expm1(x)")}} {{experimental_inline}}</dt> + <dd>Retorna <math><semantics><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><mn>1</mn></mrow><annotation encoding="TeX">e^x-1</annotation></semantics></math>.</dd> + <dt>{{jsxref("Global_Objects/Math/floor", "Math.floor(x)")}}</dt> + <dd>Retorna o maior inteiro que é menor ou igual a um número.</dd> + <dt>{{jsxref("Global_Objects/Math/fround", "Math.fround(x)")}} {{experimental_inline}}</dt> + <dd>Retorna a mais próxima representação de ponto flutuante de <a href="http://en.wikipedia.org/wiki/Single_precision" title="link to the wikipedia page on single precision">precisão-única</a> de um número.</dd> + <dt>{{jsxref("Global_Objects/Math/hypot", "Math.hypot([x[,y[,…]]])")}} {{experimental_inline}}</dt> + <dd>Retorna a raiz quadrada da soma dos quadrados dos argumentos (<math><semantics><msqrt><mrow><msup><mi>x</mi><mn>2</mn></msup><mo>+</mo><msup><mi>y</mi><mn>2</mn></msup><mo>+</mo><mo>…</mo></mrow></msqrt><annotation encoding="TeX">\sqrt{x^2 + y^2 + \dots}</annotation></semantics></math>).</dd> + <dt>{{jsxref("Global_Objects/Math/imul", "Math.imul(x)")}} {{experimental_inline}}</dt> + <dd>Retorna o resultado de uma multiplicação de inteiro de 32-bit.</dd> + <dt>{{jsxref("Global_Objects/Math/log", "Math.log(x)")}}</dt> + <dd>Retorna o logaritmo natural (<math><semantics><mrow><msub><mo lspace="0em" rspace="0em">log</mo><mi>e</mi></msub><mi>x</mi></mrow><annotation encoding="TeX">\log_ex</annotation></semantics></math> ou <math><semantics><mrow><mo lspace="0em" rspace="0em">ln</mo><mi>x</mi></mrow><annotation encoding="TeX">\ln{x}</annotation></semantics></math>) de um número.</dd> + <dt>{{jsxref("Global_Objects/Math/log1p", "Math.log1p(x)")}} {{experimental_inline}}</dt> + <dd>Retorna o logaritmo natural de 1 + x (<math><semantics><mrow><msub><mo lspace="0em" rspace="0em">log</mo><mi>e</mi></msub><mo stretchy="false">(</mo><mn>1</mn><mo>+</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="TeX">\log_e(1+x)</annotation></semantics></math> ou <math><semantics><mrow><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>1</mn><mo>+</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="TeX">\ln(1+x)</annotation></semantics></math>) de um número.</dd> + <dt>{{jsxref("Global_Objects/Math/log10", "Math.log10(x)")}} {{experimental_inline}}</dt> + <dd>Retorna o logaritmo de x na base 10 (<math><semantics><mrow><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mi>x</mi></mrow><annotation encoding="TeX">\log_{10}x</annotation></semantics></math>).</dd> + <dt>{{jsxref("Global_Objects/Math/log2", "Math.log2(x)")}} {{experimental_inline}}</dt> + <dd>Retorna o logaritmo de x na base 2 (<math><semantics><mrow><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mi>x</mi></mrow><annotation encoding="TeX">\log_2 x</annotation></semantics></math>).</dd> + <dt>{{jsxref("Global_Objects/Math/max", "Math.max([x[,y[,…]]])")}}</dt> + <dd>Retorna o maior dentre os parâmetros recebidos.</dd> + <dt>{{jsxref("Global_Objects/Math/min", "Math.min([x[,y[,…]]])")}}</dt> + <dd>Retorna o menor dentre os parâmetros recebidos.</dd> + <dt>{{jsxref("Global_Objects/Math/pow", "Math.pow(x,y)")}}</dt> + <dd>Retorna a base <code>x</code> elevada à potência <code>y</code> do expoente, ou seja, <math><semantics><msup><mi>x</mi><mi>y</mi></msup><annotation encoding="TeX">x^y</annotation></semantics></math>.</dd> + <dt>{{jsxref("Global_Objects/Math/random", "Math.random()")}}</dt> + <dd>Retorna um número pseudo-aleatório entre 0 e 1.</dd> + <dt>{{jsxref("Global_Objects/Math/round", "Math.round(x)")}}</dt> + <dd>Retorna o valor arrendodado de <code>x</code>, para o valor inteiro mais próximo.</dd> + <dt>{{jsxref("Global_Objects/Math/sign", "Math.sign(x)")}} {{experimental_inline}}</dt> + <dd>Retorna o sinal de <code>x</code>, indicando se é positivo, negativo ou zero.</dd> + <dt>{{jsxref("Global_Objects/Math/sin", "Math.sin(x)")}}</dt> + <dd>Retorna o seno de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">sin</mo><mi>x</mi></mrow><annotation encoding="TeX">\sin x</annotation></semantics></math>).</dd> + <dt>{{jsxref("Global_Objects/Math/sinh", "Math.sinh(x)")}} {{experimental_inline}}</dt> + <dd>Retorna o seno hiperbólico de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">sinh</mo><mi>x</mi></mrow><annotation encoding="TeX">\sinh x</annotation></semantics></math>).</dd> + <dt>{{jsxref("Global_Objects/Math/sqrt", "Math.sqrt(x)")}}</dt> + <dd>Retorna a raiz quadrada positiva de um número (<math><semantics><msqrt><mi>x</mi></msqrt><annotation encoding="TeX">\sqrt x</annotation></semantics></math>).</dd> + <dt>{{jsxref("Global_Objects/Math/tan", "Math.tan(x)")}}</dt> + <dd>Retorna a tangente de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">tan</mo><mi>x</mi></mrow><annotation encoding="TeX">\tan x</annotation></semantics></math>).</dd> + <dt>{{jsxref("Global_Objects/Math/tanh", "Math.tanh(x)")}} {{experimental_inline}}</dt> + <dd>Retorna a tangente hiperbólica de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">tanh</mo><mi>x</mi></mrow><annotation encoding="TeX">\tanh x</annotation></semantics></math>).</dd> + <dt><code>Math.toSource()</code> {{Non-standard_inline() }}</dt> + <dd>Retorna a string <code>"Math"</code>.</dd> + <dt>{{jsxref("Global_Objects/Math/trunc", "Math.trunc(x)")}} {{experimental_inline}}</dt> + <dd>Retorna a parte inteira de <code>x</code>, removendo quaisquer dígitos fracionários.</dd> +</dl> + +<div>{{ jsOverrides("Object", "Methods") }}</div> + +<div> +<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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial, implementado no JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8', 'Math')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math-object', 'Math')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Novos métodos adicionados: {{jsxref("Math.log10()", "log10()")}}, {{jsxref("Math.log2()", "log2()")}}, {{jsxref("Math.log1p()", "log1p()")}}, {{jsxref("Math.expm1()", "expm1()")}}, {{jsxref("Math.cosh()", "cosh()")}}, {{jsxref("Math.sinh()", "sinh()")}}, {{jsxref("Math.tanh()", "tanh()")}}, {{jsxref("Math.acosh()", "acosh()")}}, {{jsxref("Math.asinh()", "asinh()")}}, {{jsxref("Math.atanh()", "atanh()")}}, {{jsxref("Math.hypot()", "hypot()")}}, {{jsxref("Math.trunc()", "trunc()")}}, {{jsxref("Math.sign()", "sign()")}}, {{jsxref("Math.imul()", "imul()")}}, {{jsxref("Math.fround()", "fround()")}}, {{jsxref("Math.cbrt()", "cbrt()")}} e {{jsxref("Math.clz32()", "clz32()")}}</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>Conteúdo</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>Conteúdo</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> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("Number")}}</li> +</ul> +</div> + +<p> </p> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/ln10/index.html b/files/pt-br/web/javascript/reference/global_objects/math/ln10/index.html new file mode 100644 index 0000000000..a5df5d4e52 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/ln10/index.html @@ -0,0 +1,121 @@ +--- +title: Math.LN10 +slug: Web/JavaScript/Reference/Global_Objects/Math/LN10 +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN10 +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Math.LN10</code></strong> representa o logaritmo natural de 10, aproximadamente 2.302:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN10</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>10</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>2.302</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Como <code>LN10</code> é uma propriedade estática de <code>Math</code>, você sempre deve usa-lo como <code>Math.LN10</code>, ao invés de uma propriedade do objeto <code>Math</code> que você tenha criado (<code>Math</code> não é um construtor).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.LN10">Usando <code>Math.LN10</code></h3> + +<p>A seguinte função retorna o log natural de 10:</p> + +<pre class="brush:js">function getNatLog10() { + return Math.LN10; +} + +getNatLog10(); // 2.302585092994046 +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado em JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.2', 'Math.LN10')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.ln10', 'Math.LN10')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.ln10', 'Math.LN10')}}</td> + <td>{{Spec2('ESDraft')}}</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>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>{{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> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/ln2/index.html b/files/pt-br/web/javascript/reference/global_objects/math/ln2/index.html new file mode 100644 index 0000000000..dd6282bae3 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/ln2/index.html @@ -0,0 +1,80 @@ +--- +title: Math.LN2 +slug: Web/JavaScript/Reference/Global_Objects/Math/LN2 +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN2 +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Math.LN2</code></strong> representa o logaritmo natural (também conhecido como logaritmo neperiano) de 2, que é aproximadamente 0.693:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN2</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>2</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>0.693</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Por <code>LN2</code> ser uma propriedade estática de <code>Math</code>, deve-se sempre usá-la como <code>Math.LN2</code>, e não como uma propriedade de um objeto <code>Math</code> que você criou.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.LN2">Usando <code>Math.LN2</code></h3> + +<p>A função a seguir retorna o logaritmo natural de 2:</p> + +<pre class="brush:js">function getNatLog2() { + return Math.LN2; +} + +getNatLog2(); // 0.6931471805599453 +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.3', 'Math.LN2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.ln2', 'Math.LN2')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.ln2', 'Math.LN2')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.LN2")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/log/index.html b/files/pt-br/web/javascript/reference/global_objects/math/log/index.html new file mode 100644 index 0000000000..21c9e18e78 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/log/index.html @@ -0,0 +1,148 @@ +--- +title: Math.log() +slug: Web/JavaScript/Reference/Global_Objects/Math/log +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.log()</code></strong> retorna o logaritmo natural(base {{jsxref("Math.E", "e")}}) de um número, que é:</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>the unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><msup><mi>e</mi><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} \; y \; \text{such that} \; e^y = x</annotation></semantics></math></p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.log(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>O logaritmo natural (base {{jsxref("Math.E", "e")}}) de um número dado. Se o número é negativo, {{jsxref("NaN")}} é retornado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se o valor de <code>x</code> é negativo, o retorno será sempre {{jsxref("NaN")}}.</p> + +<p>Por <code>log()</code> ser um método estático de <code>Math</code>, você sempre o usará como <code>Math.log()</code>, ao invés de um método de um objeto de <code> Math</code> que você criou(<code>Math</code> não é um construtor).</p> + +<p>Caso você precise do logaritmo natural de 2 ou 10, use as constantes {{jsxref("Math.LN2")}} ou {{jsxref("Math.LN10")}} . Caso você precise de um logaritmo de base 2 ou 10, use {{jsxref("Math.log2()")}} ou {{jsxref("Math.log10()")}} . Caso você precise utilizar logaritmo de outras bases, use Math.log(x) / Math.log(outraBase) como no exemplo abaixo; talvez você queira pré-calcular 1 / Math.log(outraBase) .</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.log()">Usando <code>Math.log()</code></h3> + +<pre class="brush: js">Math.log(-1); // NaN, out of range +Math.log(0); // -Infinity +Math.log(1); // 0 +Math.log(10); // 2.302585092994046 +</pre> + +<h3 id="Usando_Math.log()_como_uma_base_diferente">Usando <code>Math.log()</code> como uma base diferente</h3> + +<p>As funções a seguir retornam o logaritmo de <code>y</code> na base <code>x</code> (ie. <math><semantics><mrow><msub><mo>log</mo><mi>x</mi></msub><mi>y</mi></mrow><annotation encoding="TeX">\log_x y</annotation></semantics></math>):</p> + +<pre class="brush: js">function getBaseLog(x, y) { + return Math.log(y) / Math.log(x); +} +</pre> + +<p>Caso você execute <code>getBaseLog(10, 1000)</code> será retornado <code>2.9999999999999996</code> devido ao arredondamento de ponto-flutuante, o qual é bem próximo do retorno exato de 3.</p> + +<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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.10', 'Math.log')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.log', 'Math.log')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log', 'Math.log')}}</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>{{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="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/log10/index.html b/files/pt-br/web/javascript/reference/global_objects/math/log10/index.html new file mode 100644 index 0000000000..560322b5d0 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/log10/index.html @@ -0,0 +1,137 @@ +--- +title: Math.log10() +slug: Web/JavaScript/Reference/Global_Objects/Math/log10 +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log10 +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.log10()</code></strong> retorna o logaritmo de base 10 de um número, que é</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log10</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>the unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><msup><mn>10</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log10}(x)} = \log_10(x) = \text{the unique} \; y \; \text{such that} \; 10^y = x</annotation></semantics></math></p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox">Math.log10(<var>x</var>)</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>O logaritmo de base 10 de um número. Caso o número seja negativo, {{jsxref("NaN")}} é retornado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Caso o valor de <code>x</code> seja menor que 0, então o retorno será sempre {{jsxref("NaN")}}.</p> + +<p>Por <code>log10()</code> ser um método estático de <code>Math</code>, você sempre o usará como <code>Math.log10()</code>, ao invés de usá-lo como método de um objeto <code>Math</code> criado (<code>Math</code> não é um construtor).</p> + +<p>Esta função é equivalente a Math.log(x) / Math.log(10). Para log10(e) use a constante {{jsxref("Math.LOG10E")}} que é 1 / {{jsxref("Math.LN10")}}. </p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.log10()">Usando <code>Math.log10()</code></h3> + +<pre class="brush: js">Math.log10(2); // 0.3010299956639812 +Math.log10(1); // 0 +Math.log10(0); // -Infinity +Math.log10(-2); // NaN +Math.log10(100000); // 5 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Isso pode ser simulado a partir da seguinte função:</p> + +<pre class="brush: js">Math.log10 = Math.log10 || function(x) { + return Math.log(x) * Math.LOG10E; +}; +</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-math.log10', 'Math.log10')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log10', 'Math.log10')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("25")}}</td> + <td>{{CompatSafari("7.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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/log10e/index.html b/files/pt-br/web/javascript/reference/global_objects/math/log10e/index.html new file mode 100644 index 0000000000..1c2f57c178 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/log10e/index.html @@ -0,0 +1,82 @@ +--- +title: Math.LOG10E +slug: Web/JavaScript/Reference/Global_Objects/Math/LOG10E +tags: + - JavaScript + - Math + - Property + - Propriedade + - Referece + - Referência(2) +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG10E +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Math.LOG10E</code></strong> representa o logaritmo com base 10 de <code>e</code>, aproximadamente 0.434:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG10E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>0.434</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0.434</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Por <code>LOG10E</code> ser uma propriedade estática de <code>Math</code>, deve-se sempre usá-la como <code>Math.LOG10E</code>, e não como propriedade de um objeto <code>Math</code> criado por você (<code>Math</code> não é um construtor).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.LOG10E">Usando <code>Math.LOG10E</code></h3> + +<p>A função a seguir retorna o logaritmo com base 10 de <code>e</code>:</p> + +<pre class="brush:js">function getLog10e() { + return Math.LOG10E; +} + +getLog10e(); // 0.4342944819032518 +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.5', 'Math.LOG10E')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.log10e', 'Math.LOG10E')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log10e', 'Math.LOG10E')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_no_navegadores">Compatibilidade no navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.LOG10E")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/log1p/index.html b/files/pt-br/web/javascript/reference/global_objects/math/log1p/index.html new file mode 100644 index 0000000000..b36c74ff62 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/log1p/index.html @@ -0,0 +1,105 @@ +--- +title: Math.log1p() +slug: Web/JavaScript/Reference/Global_Objects/Math/log1p +tags: + - ECMAScript 2015 + - JavaScript + - Logaritmo Natural + - Math + - Math.log1p + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log1p +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.log1p()</code></strong> returna o logaritmo natural (base {{jsxref("Math.E", "e")}}) de 1 + um número, isto é</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mo>-</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log1p</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>1</mn><mo>+</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="TeX">\forall x > -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x)</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-log1p.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.log1p(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O logaritmo natural (base {{jsxref("Math.E", "e")}}) de <strong>1</strong> mais o número fornecido. Se o número for menor que <strong>-1</strong>, {{jsxref("NaN")}} será retornado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Para valores muito pequenos de <em>x</em>, adicionando 1 pode reduzir ou eliminar precisão. Valores double floats costuman te dar em torno de 15 digitos de precisão no JavaScript. 1 + 1e-15 = 1.000000000000001, porém, 1 + 1e-16 = 1.000000000000000 e portanto, exatamente 1.0 naquele resultado, porque os números que passam de 15 digitos são arredondados.</p> + +<p>Quando você calcula log(1 + x), você obterá um resultado muito perto de x, se x for um valor pequeno (isto é, porque eles são chamados logaritmos 'naturais'). Se você calcular Math.log(1 + 1.1111111111e-15) você obterá uma resposta perto de1.1111111111e-15. Ao invés, você vai acabar obtendo o logaritmo de<span style="line-height: 1.5;"> </span><span style="line-height: 1.5;">1.00000000000000111022 (o arrendondamento é feito em binário, portanto, as vezes isso pode parecer estranho)</span><span style="line-height: 1.5;">, então você obterá o resultado</span><span style="line-height: 1.5;"> 1.11022...e-15, com somente 3 digitos corretos. Se, ao invés, você calcular Math.log1p(</span>1.1111111111e-15<span style="line-height: 1.5;">) você terá um retorno mais preciso de 1.1111111110999995e-15 com 15 digitos corretos de precisão (na verdade 16 nesse caso).</span></p> + +<p>Se o valor de <code>x</code> for menor que -1, o valor retornado será sempre {{jsxref("NaN")}}.</p> + +<p>Por conta do <code>log1p()</code> ser um metódo estático de <code>Math</code>, você sempre chamará como <code>Math.log1p()</code>, ao invés de chamar como um método de um objeto <code>Math</code> que você tenha criado (<code>Math</code> não é um construtor).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.log1p()">Usando <code>Math.log1p()</code></h3> + +<pre class="brush: js">Math.log1p(1); // 0.6931471805599453 +Math.log1p(0); // 0 +Math.log1p(-1); // -Infinity +Math.log1p(-2); // NaN +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Isto pode ser implementado com a seguinte função:</p> + +<pre class="brush: js">Math.log1p = Math.log1p || function(x) { + return Math.log(1 + x); +}; +</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('ES2015', '#sec-math.log1p', 'Math.log1p')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log1p', 'Math.log1p')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.log1p")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.expm1()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/log2/index.html b/files/pt-br/web/javascript/reference/global_objects/math/log2/index.html new file mode 100644 index 0000000000..1e15ab3f00 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/log2/index.html @@ -0,0 +1,91 @@ +--- +title: Math.log2() +slug: Web/JavaScript/Reference/Global_Objects/Math/log2 +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log2 +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.log2()</code></strong> retorna o logaritmo de base 2 de um número, que é</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log2</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>the unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><msup><mn>2</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log2}(x)} = \log_2(x) = \text{the unique} \; y \; \text{such that} \; 2^y = x</annotation></semantics></math></p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.log2(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code> Um número.</dt> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>O logaritmo de base 2 de um número. Caso o número seja negativo, {{jsxref("NaN")}} é retornado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Caso o valor de <code>x</code> seja menor que 0, então o retorno será sempre {{jsxref("NaN")}}.</p> + +<p>Por <code>log2()</code> ser um método estático de <code>Math</code>, você sempre o usará como <code>Math.log2()</code>, ao invés de usá-lo como método de um objeto <code>Math</code> criado (<code>Math</code> não é um construtor).</p> + +<p>Esta função é equivalente a <code>Math.log(x)/Math.log(2)</code>. Para log2(e) use a constante {{jsxref("Math.LOG2E")}} que é 1 / {{jsxref("Math.LN2")}}. </p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.log2()">Usando <code>Math.log2()</code></h3> + +<pre class="brush: js">Math.log2(3); // 1.584962500721156 +Math.log2(2); // 1 +Math.log2(1); // 0 +Math.log2(0); // -Infinity +Math.log2(-2); // NaN +Math.log2(1024); // 10 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Este Polyfill simula a função <code>Math.log2</code>. Note que é retornado um valor não prcesiso Observe que é retornado valores imprecisos em algumas entradas (like 1 << 29), envolva em {{jsxref("Math.round()")}} se estiver trabalhando com máscaras de bits.</p> + +<pre class="brush: js">Math.log2 = Math.log2 || function(x) { + return Math.log(x) * Math.LOG2E; +}; +</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('ES2015', '#sec-math.log2', 'Math.log2')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log2', 'Math.log2')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.log2")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/log2e/index.html b/files/pt-br/web/javascript/reference/global_objects/math/log2e/index.html new file mode 100644 index 0000000000..26669a3b45 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/log2e/index.html @@ -0,0 +1,82 @@ +--- +title: Math.LOG2E +slug: Web/JavaScript/Reference/Global_Objects/Math/LOG2E +tags: + - JavaScript + - Math + - Property + - Propriedade + - Reference + - Referência(2) +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG2E +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Math.LOG2E</code></strong> representa o logaritmo com base 2 de <code>e</code>, aproximadamente 1.442:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG2E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>1.442</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1.442</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Por <code>LOG2E</code> ser uma propriedade estática de <code>Math</code>, deve-se sempre usá-la como <code>Math.LOG2E</code>, e não como propriedade de um objeto <code>Math</code> criado por você (<code>Math</code> não é um construtor).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.LOG2E">Usando <code>Math.LOG2E</code></h3> + +<p>A função a seguir retorna o logaritmo com base 2 de <code>e</code>:</p> + +<pre class="brush: js">function getLog2e() { + return Math.LOG2E; +} + +getLog2e(); // 1.4426950408889634 +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.4', 'Math.LOG2E')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.log2e', 'Math.LOG2E')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log2e', 'Math.LOG2E')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.LOG2E")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/max/index.html b/files/pt-br/web/javascript/reference/global_objects/math/max/index.html new file mode 100644 index 0000000000..d59b1fb583 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/max/index.html @@ -0,0 +1,155 @@ +--- +title: Math.max() +slug: Web/JavaScript/Reference/Global_Objects/Math/max +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/max +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>A função <code><strong>Math.max()</strong></code> retorna o maior de um ou mais números.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.max([<em>valor1</em>[,<em>valor2</em>, ...]]) </code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>valor1, valor2, ...</code></dt> + <dd>Números.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O maior dos números passados como argumentos. Se pelo menos um dos argumentos não puder ser convertido para um número {{jsxref("NaN")}} é retornado.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Por <code>max</code> ser um método estático em <code>Math</code>, você sempre irá usá-lo da seguinte maneira <code>Math.max()</code>, e não como um método da classe <code>Math</code> que você tenha instanciado.</p> + +<p>Se nenhum argumento for passado o resultado sempre será - {{jsxref("Global_Objects/Infinity", "Infinity")}}.</p> + +<p>Se um dos argumentos não puder ser convertido em um número, o resultado será {{jsxref("Global_Objects/NaN", "NaN")}}.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Using_Math.max" name="Example:_Using_Math.max">Usando <code>Math.max</code></h3> + +<pre class="brush: js">Math.max(10, 20); // 20 +Math.max(-10, -20); // -10 +Math.max(-10, 20); // 20 +</pre> + +<h3 id="Retornando_o_maior_elemento_de_um_array">Retornando o maior elemento de um array</h3> + +<p>{{jsxref("Array.prototype.reduce", "Array.reduce()")}} pode ser usada para encontrar o maior elemento em um vetor numérico, comparando cada valor:</p> + +<pre class="brush: js">var arr = [1, 2, 3]; +var max = arr.reduce(function(a, b) { + return Math.max(a, b); +});</pre> + +<p>A função a seguir utiliza {{jsxref("Function.prototype.apply()")}} para encontrar o elemento de maior valor dentro do array. <code>getMaxOfArray([1,2,3])</code> é equivalente a <code>Math.max(1, 2, 3)</code>, mas você pode usar <code>getMaxOfArray</code> em arrays construídos programaticamente e o ideal é utilizá-la somente em arrays com relativamente poucos elementos.</p> + +<pre class="brush:js">function getMaxOfArray(numArray) { + return Math.max.apply(null, numArray); +}</pre> + +<p>O novo <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Spread_operator">operador spread</a> é um modo curto de se escrever a solução com <code>apply</code> para retornar o maior valor de um array.</p> + +<pre class="brush: js">var arr = [1, 2, 3]; +var max = Math.max(...arr); +// max: 3</pre> + +<p>Entretanto, tanto spread(<code>...</code>) quanto <code>apply</code> irão ou falhar ou retornar o resultado errado caso o array tenha muitos elementos, porque eles tentam passar o array de elementos como parâmetros de funções. Veja <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Function/apply#Usando_apply_e_funções_embutidas">usando apply e funções embutidas</a> para mais detalhes. A solução com <code>reduce</code> não apresenta esse problema.</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 1st Edition. Implemented in JavaScript 1.0</td> + <td>Standard</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-15.8.2.11', 'Math.max')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.max', 'Math.max')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de 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>O objeto {{jsxref("Global_Objects/Math", "Math")}} pertence a.</li> + <li>{{jsxref("Math.min()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/min/index.html b/files/pt-br/web/javascript/reference/global_objects/math/min/index.html new file mode 100644 index 0000000000..ee97e97ddf --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/min/index.html @@ -0,0 +1,147 @@ +--- +title: Math.min() +slug: Web/JavaScript/Reference/Global_Objects/Math/min +translation_of: Web/JavaScript/Reference/Global_Objects/Math/min +--- +<div> +<p>{{JSRef}}</p> + +<p>A função <strong><code>Math.min()</code></strong> retorna o menor valor passado como parâmetro, ou <span class="seoSummary">{{jsxref("NaN")}}</span> se o parâmetro não é ou não pode ser convertido para um número.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre><code>Math.min([<var>valor1</var>[, <var>valor2</var>[, ...]]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>valor1, valor2, ...</code></dt> + <dd>Números.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Por que <code>min()</code> é um método estático de <code>Math</code>, você sempre usa como <code>Math.min()</code>, e não como um método de um objeto <code>Math</code> que você criou (<code>Math</code> não é um construtor).</p> + +<p>Se nenhum argumento for dado, o resultado é {{jsxref("Infinity")}}.</p> + +<p>Se pelo menos um dos argumentos não pode ser convertido para um número, o resultado é {{jsxref("NaN")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.min()">Usando <code>Math.min()</code></h3> + +<p><font><font>Este encontra o min de </font></font><code><font><font>x</font></font></code><font><font> e </font></font><code><font><font>y</font></font></code><font><font> e atribui a </font></font><code><font><font>z</font></font></code><font><font> </font></font>:</p> + +<pre>var x = 10, y = -20; +var z = Math.min(x, y); +</pre> + +<h3 id="Cortando_um_valor_com_Math.min()">Cortando um valor com <code>Math.min()</code></h3> + +<p><code>Math.min()</code> é muitas vezes usado para cortar um valor <font>sempre menor do que ou igual a um limite. </font><font>Por exemplo, este.</font></p> + +<pre>var x = f(foo); + +if (x > boundary) { + x = boundary; +} +</pre> + +<p>pode ser escrita como este</p> + +<pre>var x = Math.min(f(foo), boundary); +</pre> + +<p>{{jsxref("Math.max()")}} pode ser usado de uma maneira semelhante ao corte de um valor na outra extremidade.</p> + +<h2 id="Especificações">Especificações</h2> + +<table> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Estato</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.8.2.12', 'Math.min')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.min', 'Math.min')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.min', 'Math.min')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_do_navegador"><font><font>Compatibilidade do navegador</font></font> </h2> + +<p>{{CompatibilityTable}}</p> + +<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> + <p>Suporte</p> + + <p>básico</p> + </td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> + +<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> + +<h2 id="Veja_Também">Veja Também</h2> + +<ul> + <li>{{jsxref("Math.max()")}}</li> +</ul> +</div> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/pi/index.html b/files/pt-br/web/javascript/reference/global_objects/math/pi/index.html new file mode 100644 index 0000000000..22d97c22e9 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/pi/index.html @@ -0,0 +1,82 @@ +--- +title: Math.PI +slug: Web/JavaScript/Reference/Global_Objects/Math/PI +tags: + - JavaScript + - Math + - PI + - Propriedade +translation_of: Web/JavaScript/Reference/Global_Objects/Math/PI +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Math.PI</code></strong> representa a proporção entre circunferência de um círculo com o seu diâmetro, aproximadamente 3.14159:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.PI</mi></mstyle><mo>=</mo><mi>π</mi><mo>≈</mo><mn>3.14159</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.PI}} = \pi \approx 3.14159</annotation></semantics></math></p> + +<p>{{EmbedInteractiveExample("pages/js/math-pi.html")}}</p> + +<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> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Como <code>PI</code> é uma propriedade estática de <code>Math</code>, sempre use-a como <code>Math.PI</code>, ao invés de uma propriedade de um objeto <code>Math</code> que você criou (<code>Math</code> não é um construtor).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.PI">Usando <code>Math.PI</code></h3> + +<p>A seguinte função usa <code>Math.PI</code> para calcular a circunferência de um círculo com um dado raio.</p> + +<pre class="brush: js">function calcularCircunferencia(raio) { + return 2 * Math.PI * raio; +} + +calcularCircunferencia(1); // 6.283185307179586 +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definiçao inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.6', 'Math.PI')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.pi', 'Math.PI')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.pi', 'Math.PI')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + + + +<p>{{Compat("javascript.builtins.Math.PI")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/pow/index.html b/files/pt-br/web/javascript/reference/global_objects/math/pow/index.html new file mode 100644 index 0000000000..0a478feb5a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/pow/index.html @@ -0,0 +1,147 @@ +--- +title: Math.pow() +slug: Web/JavaScript/Reference/Global_Objects/Math/pow +tags: + - Função + - JavaScript + - Método(2) + - Referência(2) + - expoente + - potência +translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.pow()</code></strong> retorna a <em>base </em>elevada ao expoente <em>power</em>, ou seja, <code>base<sup>expoente</sup></code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.pow(<var>base</var>, <var>expoente</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>base</code></dt> + <dd>O número da base.</dd> + <dt><code>expoente</code></dt> + <dd>O expoente usado para elevar a <code>base</code>.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Como <code>pow()</code> é um método estático de <code>Math</code>, você sempre irá usá-lo como <code>Math.pow()</code>, ao invés de usá-lo como um método de um objeto do tipo <code>Math</code> que você tenha criado (<code>Math</code> não é um construtor).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.pow()">Usando <code>Math.pow()</code></h3> + +<pre class="brush: js">// simples +Math.pow(7, 2); // 49 +Math.pow(7, 3); // 343 +Math.pow(2, 10); // 1024 +// expoentes fracionários +Math.pow(4, 0.5); // 2 (raiz quadrada de 4) +Math.pow(8, 1/3); // 2 (raiz cúbica de 8) +Math.pow(2, 0.5); // 1.4142135623730951 (raiz quadrada de 2) +Math.pow(2, 1/3); // 1.2599210498948732 (raiz cúbica de 2) +// expoentes com sinais +Math.pow(7, -2); // 0.02040816326530612 == (1/7)<sup>2 </sup>== (1/49) +Math.pow(8, -1/3); // 0.5 == (1/8)<sup>1/3</sup> == 1/2 +// bases com sinal +Math.pow(-7, 2); // 49 (quadrados sempre são positivos) +Math.pow(-7, 3); // -343 (cubos podem ser negativos conforme a base) +Math.pow(-7, 0.5); // NaN (números negativos não tem uma raiz quadrada real) +// devido ao fato que raízes "par" e "ímpar" são próximas, +// e limitam a precisão de ponto flutuante, +// bases negativas com expoentes fracionários sempre retornam NaN +Math.pow(-7, 1/3); // NaN +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição Inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.13', 'Math.pow')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.pow', 'Math.pow')}}</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>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>{{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>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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.cbrt()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Exponentiation" title="Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value. The standard arithmetic operators are addition (+), subtraction (-), multiplication (*), and division (/).">Operador Exponencial</a> {{experimental_inline}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/random/index.html b/files/pt-br/web/javascript/reference/global_objects/math/random/index.html new file mode 100644 index 0000000000..c3133554a8 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/random/index.html @@ -0,0 +1,102 @@ +--- +title: Math.random() +slug: Web/JavaScript/Reference/Global_Objects/Math/random +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/random +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>A função <code><strong>Math.random()</strong></code> retorna um número pseudo-aleatório no intervalo <code>[0, 1[</code>, ou seja, de 0 (inclusivo) até, mas não incluindo, 1 (exclusivo), que depois você pode dimensionar para um intervalo desejado. A implementação seleciona uma semente para o algoritmo de geração de números aleatórios; esta semente não pode ser escolhida ou reatribuída.</p> + +<div class="note"> +<p><code><strong>Math.random()</strong></code> não gera números criptograficamente seguros. Não a use para nada relacionado a segurança. Use a API Web Crypto, mais precisamente o método {{domxref("RandomSource.getRandomValues()", "window.crypto.getRandomValues()")}}.</p> +</div> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.random()</code></pre> + +<h3 id="Parameters" name="Parameters">Valor retornado</h3> + +<p>Um número pseudo-aleatório entre 0 (inclusivo) e 1 (exclusivo).</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<p>Note que os números em JavaScript são pontos flutuantes que seguem o padrão IEEE 754 com comportamento <em>arredondar-para-o-par-mais-próximo</em>, os intervalos que serão citados nos exemplos a seguir (exceto o exemplo do <code>Math.random()</code>), não são exatas. Se limites extremamente grandes forem escolhidos (2<sup>53</sup> ou maior), em raros casos é possível que o limite superior (que seria exclusivo) seja retornado.</p> + +<h3 id="Gerando_um_número_aleatório_entre_0_(inclusivo)_e_1_(exclusivo)">Gerando um número aleatório entre 0 (inclusivo) e 1 (exclusivo)</h3> + +<pre class="brush: js">function getRandom() { + return Math.random(); +}</pre> + +<h3 id="Gerando_um_número_aleatório_entre_dois_valores">Gerando um número aleatório entre dois valores</h3> + +<p>Este exemplo retorna um número entre dois valores definidos. O valor retornado será maior ou igual a <code>min,</code> e menor que <code>max</code>.</p> + +<pre class="brush: js">function getRandomArbitrary(min, max) { + return Math.random() * (max - min) + min; +}</pre> + +<h3 id="Gerando_um_número_inteiro_aleatório_entre_dois_valores">Gerando um número inteiro aleatório entre dois valores</h3> + +<p>Este exemplo retorna um número <em>inteiro</em> entre dois valores definidos. O valor não poderá ser menor que <code>min</code> (ou do próximo inteiro maior que <code>min,</code> caso <code>min</code> não seja inteiro), e será menor (mas não igual) a <code>max</code>.</p> + +<pre class="brush: js">function getRandomInt(min, max) { + min = Math.ceil(min); + max = Math.floor(max); + return Math.floor(Math.random() * (max - min)) + min; +}</pre> + +<p></p> + +<div class="note"> +<p>Pode ser tentandor usar <code>Math.round()</code> para arredondar <code>min</code> e <code>max,</code> mas dessa maneira a aleatoriedade dos números seguiria uma distribuição não-uniforme, que talvez não seja o que você precisa.</p> +</div> + +<h3 id="Gerando_um_número_inteiro_aleatório_entre_dois_valores_inclusive">Gerando um número inteiro aleatório entre dois valores, inclusive</h3> + +<p>A função <code>getRandomInt()</code> acima tem intervalo com o valor mínimo incluído e o máximo excluído. Mas se você precisar que a função inclua, tanto o mínimo quanto o máximo, em seus resultados? A função <code>getRandomIntInclusive()</code> abaixo faz isso.</p> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">function</span> <span class="function token">getRandomIntInclusive</span><span class="punctuation token">(</span>min<span class="punctuation token">,</span> max<span class="punctuation token">)</span> <span class="punctuation token">{</span> + min <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">ceil</span><span class="punctuation token">(</span>min<span class="punctuation token">)</span><span class="punctuation token">;</span> + max <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>max<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">return</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>Math<span class="punctuation token">.</span><span class="function token">random</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">*</span> <span class="punctuation token">(</span>max <span class="operator token">-</span> min <span class="operator token">+</span> <span class="number token">1</span><span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="operator token">+</span> min<span class="punctuation token">;</span> +<span class="punctuation token">}</span></code></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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. JavaScript 1.0 (UNIX Only) / JavaScript 1.1 (Todas plataformas).</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.14', 'Math.random')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.random', 'Math.random')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2> + +<p>{{Compat("javascript.builtins.Math.random")}}</p> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/round/index.html b/files/pt-br/web/javascript/reference/global_objects/math/round/index.html new file mode 100644 index 0000000000..5473ab29aa --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/round/index.html @@ -0,0 +1,234 @@ +--- +title: Math.round() +slug: Web/JavaScript/Reference/Global_Objects/Math/round +tags: + - JavaScript + - Math + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Math/round +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Resumo">Resumo</h2> + +<p>A função <code><strong>Math.round()</strong></code> retorna o valor de um número arredondado para o inteiro mais proximo.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code> Math.round(<em>x</em>) </code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>O valor de um número dado aproximado para o inteiro mais próximo</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se a parte fracionária do <font face="Courier New, Andale Mono, monospace">número</font> for maior ou igual a 0.5, o argumento x é arredondado para o próximo número inteiro acima, entretanto se a parte fracionária do <code>número</code> for menor que 0.5, então o valor de x é arredondado para o próximo número inteiro abaixo. Se a parte fracionária for exatamente igual a 0.5, o número é arredondado para o próximo inteiro na direção de +∞.</p> + +<p>Por <code>round</code> ser um método estático de <code>Math</code>, você sempre irá usá-lo como <code>Math.round()</code>, ao invés de usá-lo como um método da instância do objeto <code>Math</code> que você criou.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Exemplo_Uso_de_Math.round">Exemplo: Uso de <code>Math.round</code></h3> + +<pre class="brush:js">// Retorna o valor 20 +x = Math.round(20.49); + +// Retorna o valor 21 +x = Math.round(20.5); + +// Retorna o valor -20 +x = Math.round(-20.5); + +// Retorna o valor -21 +x = Math.round(-20.51); + +// Retorna 1 (!) +// Note o erro de arredondamento por causa da inacurácia de aritmética de ponto flutuante +// Compare o exemplo abaixo com Math.round10(1.005, -2) +x = Math.round(1.005*100)/100; +</pre> + +<h3 id="Exemplo_Arredondamento_decimal.">Exemplo: Arredondamento decimal.</h3> + +<pre class="brush:js">// Closure +(function(){ + + /** + * Ajuste decimal de um número. + * + * @param {String} type O tipo de arredondamento. + * @param {Number} value O número a arredondar. + * @param {Integer} exp O expoente (o logaritmo decimal da base pretendida). + * @returns {Number} O valor depois de ajustado. + */ + function decimalAdjust(type, value, exp) { + // Se exp é indefinido ou zero... + if (typeof exp === 'undefined' || +exp === 0) { + return Math[type](value); + } + value = +value; + exp = +exp; + // Se o valor não é um número ou o exp não é inteiro... + if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) { + return NaN; + } + // Transformando para string + value = value.toString().split('e'); + value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp))); + // Transformando de volta + value = value.toString().split('e'); + return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)); + } + + // Arredondamento decimal + if (!Math.round10) { + Math.round10 = function(value, exp) { + return decimalAdjust('round', value, exp); + }; + } + // Decimal arredondado para baixo + if (!Math.floor10) { + Math.floor10 = function(value, exp) { + return decimalAdjust('floor', value, exp); + }; + } + // Decimal arredondado para cima + if (!Math.ceil10) { + Math.ceil10 = function(value, exp) { + return decimalAdjust('ceil', value, exp); + }; + } + +})(); + +// Round (arredondamento) +Math.round10(55.55, -1); // 55.6 +Math.round10(55.549, -1); // 55.5 +Math.round10(55, 1); // 60 +Math.round10(54.9, 1); // 50 +Math.round10(-55.55, -1); // -55.5 +Math.round10(-55.551, -1); // -55.6 +Math.round10(-55, 1); // -50 +Math.round10(-55.1, 1); // -60 +Math.round10(1.005, -2); // 1.01 -- compare este resultado com Math.round(1.005*100)/100 no exemplo acima +// Floor (para baixo) +Math.floor10(55.59, -1); // 55.5 +Math.floor10(59, 1); // 50 +Math.floor10(-55.51, -1); // -55.6 +Math.floor10(-51, 1); // -60 +// Ceil (para cima) +Math.ceil10(55.51, -1); // 55.6 +Math.ceil10(51, 1); // 60 +Math.ceil10(-55.59, -1); // -55.5 +Math.ceil10(-59, 1); // -50 +</pre> + +<h3 id="Método_de_arredondamento_PHP">Método de arredondamento PHP</h3> + +<p>O código abaixo pode ser utilizado para adicionar sua própria versão do Math.round ao seu namespace no qual tenha um parâmetro de precisão. Diferentemente do arredondamento decimal do exemplo acima, esse método não realiza conversão de e para strings, e o parâmetro de precisão funciona da mesma maneira que PHP e Excel onde um positivo 1 seria arredondado para 1 casa decimal e -1 seria arredondado para os decimais.</p> + +<pre><code>var myNamespace = {}; + +myNamespace.round = function(number, precision) { + var factor = Math.pow(10, precision); + var tempNumber = number * factor; + var roundedTempNumber = Math.round(tempNumber); + return roundedTempNumber / factor; +}; + +myNamespace.round(1234.5678, 1); // 1234.6 +myNamespace.round(1234.5678, -1); // 1230</code> +</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>ECMAScript 1ª Edição. Implementado em JavaScript 1.0.</td> + <td>Padrão</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.15', 'Math.round')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.round', 'Math.round')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Browser">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 (WebKit)</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>Firefox Mobile (Gecko)</th> + <th>IE Phone</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> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/sign/index.html b/files/pt-br/web/javascript/reference/global_objects/math/sign/index.html new file mode 100644 index 0000000000..03f8eed812 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/sign/index.html @@ -0,0 +1,117 @@ +--- +title: Math.sign() +slug: Web/JavaScript/Reference/Global_Objects/Math/sign +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sign +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.sign()</code></strong> retorna o sinal de um número, indicando se o número é positivo, negativo ou zero.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.sign(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Se o parametro passado ao for numerico, a função irá converter o parametro em Um número.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um número representando o sinal do argumento fornecido.</p> + +<p>Se o argumento é um número positivo, o retorno será 1;</p> + +<p>Se o numero passado for negativo, o retorno será -1</p> + +<p>Se o argumento for um zero positivo , o retorno será +0</p> + +<p>Se o argumento for 0 negativo , o retorno será -0</p> + +<p>. Qualquer outro valor que não seja numérico (string transformada em numero por ex.), o retorno será {{jsxref("NaN")}} </p> + +<h2 id="Descrição">Descrição</h2> + +<p>Pela razão de <code>sign()</code> ser um método estático de <code>Math</code>, você sempre deve usá-lo como <code>Math.sign()</code>, e não como um método do objeto <code>Math</code> que você criou (<code>Math</code> não é um construtor).</p> + +<p>Esta função possui 5 tipos de valores retornados, <code>1</code>, <code>-1</code>, <code>0</code>, <code>-0</code>, <code>NaN</code>, que representam "número positivo", "número negativo", "zero positivo", "zero negativo" e {{jsxref("NaN")}}, respectivamente.</p> + +<p>O argumento passado para esta função será implicitamente convertido para o tipo <code>numérico</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.sign">Usando <code>Math.sign()</code></h3> + +<pre class="brush: js">Math.sign(3); // 1 +Math.sign(-3); // -1 +Math.sign('-3'); // -1 +Math.sign(0); // 0 +Math.sign(-0); // -0 +Math.sign(NaN); // NaN +Math.sign('foo'); // NaN +Math.sign(); // NaN +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (!Math.sign) { + Math.sign = function(x) { + // Se x é NaN, o resultado é NaN. + // Se x é -0, o resultado é -0. + // Se x é +0, o resultado é +0. + // Se x é negativo e não -0, o resultado é -1. + // Se x é positivo e não +0, o resultado é +1. + return ((x > 0) - (x < 0)) || +x; + // Uma representação mais estética é mostrada abaixo + // + // ( (x > 0) ? 1 : 0 ) // se x é positivo então mais um + // + // senão (porque não poder ser - e +) + // ( (x < 0) ? -1 : 0 ) // se x é negativo então menos um + // || // se x é 0, -0, NaN, ou não é um número, + // +x // Então o resultado será x, (ou) se x não é + // // um número, então converte x para número + }; +} +</pre> + +<p>No polyfill acima, nenhuma coerção de tipo extra é necessária para tornar numéricos as expressões <code>(x > 0) ou (x < 0)</code> , porque subtraindo-as um do outro força uma conversão de tipo de booleano para numérico.</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('ES6', '#sec-math.sign', 'Math.sign')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sign', 'Math.sign')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2> + +<p class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, por favor baixe-os do repositório <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e encaminhe-nos uma requisição de pull.</p> + +<p>{{Compat("javascript.builtins.Math.sign")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.trunc()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/sin/index.html b/files/pt-br/web/javascript/reference/global_objects/math/sin/index.html new file mode 100644 index 0000000000..3e5cdea187 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/sin/index.html @@ -0,0 +1,92 @@ +--- +title: Math.sin() +slug: Web/JavaScript/Reference/Global_Objects/Math/sin +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.sin()</code></strong> retorna o seno de um número.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-sin.html")}}</div> + +<p class="hidden">A fonte deste exemplo interativo esta em um reposi. Se você tiver interesse em 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 nos envie um pull request</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.sin(<var>x</var>)</code></pre> + +<h3 id="Paramêtros">Paramêtros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número (dado em radianos)</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O seno de um número dado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>Math.sin()</code> retorna um valor numérico entre -1 e 1, que representa o seno de um angulo dado em radianos.</p> + +<p>Como <code>sin()</code> é um método estático de <code>Math</code>, você sempre o usa como <code>Math.sin()</code>, ao invés de um método de um objeto Math que você criou (<code>Math</code> não é um construtor).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.sin()">Usando <code>Math.sin()</code></h3> + +<pre class="brush: js">Math.sin(0); // 0 +Math.sin(1); // 0.8414709848078965 + +Math.sin(Math.PI / 2); // 1 +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.16', 'Math.sin')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sin', 'Math.sin')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sin', 'Math.sin')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.sin")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/sinh/index.html b/files/pt-br/web/javascript/reference/global_objects/math/sinh/index.html new file mode 100644 index 0000000000..68f6aeb977 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/sinh/index.html @@ -0,0 +1,96 @@ +--- +title: Math.sinh() +slug: Web/JavaScript/Reference/Global_Objects/Math/sinh +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sinh +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.sinh()</code></strong> retorna o seno hiperbólico de um número, que pode ser expresso usando a {{jsxref("Math.E", "constante e", "", 1)}}:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.sinh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.sinh(x)}} = \frac{e^x - e^{-x}}{2}</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-sinh.html")}}</div> + + + +<h2 id="Sintáxe">Sintáxe</h2> + +<pre class="syntaxbox"><code>Math.sinh(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O seno hiperbólico do número dado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Como <code>sinh()</code> é um método estático de <code>Math</code>, você sempre deve usar como <code>Math.sinh()</code>, ao invés de um novo objeto instanciado <code>Math</code> (<code>Math</code> não é um construtor).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.sinh()">Usando <code>Math.sinh()</code></h3> + +<pre class="brush: js">Math.sinh(0); // 0 +Math.sinh(1); // 1.1752011936438014 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Isso pode ser emulado com a ajuda da função {{jsxref("Math.exp()")}}:</p> + +<pre class="brush: js">Math.sinh = Math.sinh || function(x) { + return (Math.exp(x) - Math.exp(-x)) / 2; +} +</pre> + +<p>ou usando apenas uma chamada para a função {{jsxref("Math.exp()")}}:</p> + +<pre class="brush: js">Math.sinh = Math.sinh || function(x) { + var y = Math.exp(x); + return (y - 1 / y) / 2; +} +</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('ES2015', '#sec-math.sinh', 'Math.sinh')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sinh', 'Math.sinh')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.sinh")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}}</li> + <li>{{jsxref("Math.asinh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.cosh()")}}</li> + <li>{{jsxref("Math.tanh()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/sqrt/index.html b/files/pt-br/web/javascript/reference/global_objects/math/sqrt/index.html new file mode 100644 index 0000000000..17c9f65bb4 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/sqrt/index.html @@ -0,0 +1,87 @@ +--- +title: Math.sqrt() +slug: Web/JavaScript/Reference/Global_Objects/Math/sqrt +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sqrt +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>A função <strong>Math.sqrt()</strong> retorna a raiz quadrada <span style="color: #4d4e53; line-height: 1.5;">de um número (</span><math><semantics><msqrt><mi>x</mi></msqrt><annotation encoding="TeX">\sqrt{x}</annotation></semantics></math><span style="color: #4d4e53; line-height: 1.5;">) .</span></p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.sqrt(<em>x</em>) </code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>A raiz quadrada do número recebido. Se o número for negativo, a função retornará {{jsxref("NaN")}}.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Se o valor de <code>x</code> for negativo, <code>Math.sqrt()</code> retorna {{jsxref("NaN")}}.</p> + +<p>Por <code>sqrt</code> ser um método estático de <code>Math</code>, deve-se sempre usá-lo como <code>Math.sqrt()</code>, e não como um método de um objeto <code>Math</code> que você criou.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Using_Math.sqrt" name="Example:_Using_Math.sqrt">Exemplo: Usando <code>Math.sqrt</code></h3> + +<pre class="brush:js">Math.sqrt(9); // 3 +Math.sqrt(2); // 1.414213562373095 + +Math.sqrt(1); // 1 +Math.sqrt(0); // 0 +Math.sqrt(-1); // NaN</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.17', 'Math.sqrt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sqrt', 'Math.sqrt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2> + +<p>{{Compat("javascript.builtins.Math.sqrt")}}</p> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("Math.cbrt()")}}</li> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/sqrt1_2/index.html b/files/pt-br/web/javascript/reference/global_objects/math/sqrt1_2/index.html new file mode 100644 index 0000000000..5c2aa35e4a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/sqrt1_2/index.html @@ -0,0 +1,81 @@ +--- +title: Math.SQRT1_2 +slug: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2 +tags: + - JavaScript + - Math + - Property + - Propriedade + - Reference + - Referencia +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2 +--- +<div>{{JSRef}}</div> + +<p>A propriedade <code>Math.SQRT1_2</code> representa a raiz quadrada de <math><semantics><mfrac><mn>1</mn><mn>2</mn></mfrac><annotation encoding="TeX">\frac{1}{2}</annotation></semantics></math>, que é aproximadamente 0.707:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT1_2</mi></mstyle><mo>=</mo><msqrt><mfrac><mn>1</mn><mn>2</mn></mfrac></msqrt><mo>=</mo><mfrac><mn>1</mn><msqrt><mn>2</mn></msqrt></mfrac><mo>≈</mo><mn>0.707</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0.707</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Por <code>SQRT1_2</code> ser um método estático de <code>Math</code>, deve-se sempre usá-lo como <code>Math.SQRT1_2()</code>, e não como um método de um objeto <code>Math</code> que você criou.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.SQRT1_2">Usando <code>Math.SQRT1_2</code></h3> + +<p>A função a seguir retorna 1 sobre a raiz quadrada de 2:</p> + +<pre class="brush:js">function getRoot1_2() { + return Math.SQRT1_2; +} + +getRoot1_2(); // 0.7071067811865476 +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.7', 'Math.SQRT1_2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.SQRT1_2")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/sqrt2/index.html b/files/pt-br/web/javascript/reference/global_objects/math/sqrt2/index.html new file mode 100644 index 0000000000..7c8ceeaa5d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/sqrt2/index.html @@ -0,0 +1,81 @@ +--- +title: Math.SQRT2 +slug: Web/JavaScript/Reference/Global_Objects/Math/SQRT2 +tags: + - JavaScript + - Math + - Property + - Propriedade + - Reference + - Referência(2) +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT2 +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Math.SQRT2</code></strong> representa a raiz quadrada de 2, que é aproximadamente 1.414:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT2</mi></mstyle><mo>=</mo><msqrt><mn>2</mn></msqrt><mo>≈</mo><mn>1.414</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1.414</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Por <code>SQRT2</code> ser uma propriedade estática de <code>Math</code>, deve-se sempre usá-la como <code>Math.SQRT2</code>, e não como propriedade de um objeto <code>Math</code> criado por você (<code>Math</code> não é um construtor).</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Usando_Math.SQRT2">Usando <code>Math.SQRT2</code></h3> + +<p>A função a seguir retorna a raiz quadrada de 2:</p> + +<pre class="brush: js">function getRoot2() { + return Math.SQRT2; +} + +getRoot2(); // 1.4142135623730951 +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.8', 'Math.SQRT2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sqrt2', 'Math.SQRT2')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sqrt2', 'Math.SQRT2')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.SQRT2")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/tan/index.html b/files/pt-br/web/javascript/reference/global_objects/math/tan/index.html new file mode 100644 index 0000000000..0b0897490a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/tan/index.html @@ -0,0 +1,111 @@ +--- +title: Math.tan() +slug: Web/JavaScript/Reference/Global_Objects/Math/tan +tags: + - JavaScript + - Matemática + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan +--- +<div> + {{JSRef("Global_Objects", "Math")}}</div> +<h2 id="Summary" name="Summary">Resumo</h2> +<p>A função <code><strong>Math.tan()</strong></code> retorna a tangente de um número.</p> +<h2 id="Syntax" name="Syntax">Sintaxe</h2> +<pre class="syntaxbox">Math.tan(<em>x</em>)</pre> +<h3 id="Parameters" name="Parameters">Parâmetros</h3> +<dl> + <dt> + <code>x</code></dt> + <dd> + Um número representando um ângulo em radianos.</dd> +</dl> +<h2 id="Description" name="Description">Descrição</h2> +<p>O método <code>tan</code> retorna um valor numérico que representa a tangente do ângulo.</p> +<p>Como <code>tan</code> é um método estático de <code>Math</code>, use sempre <code>Math.tan()</code>, ao invés de um método de um objeto <code>Math</code> que você tenha criado.</p> +<h2 id="Examples" name="Examples">Exemplos</h2> +<h3 id="Example:_Using_Math.tan" name="Example:_Using_Math.tan">Exemplo: Usando <code>Math.tan</code></h3> +<p>A seguinte função retorna a tangente da variável <code>x</code>:</p> +<pre class="brush:js">function getTan(x) { + return Math.tan(x); +}</pre> +<p>Como a função <code>Math.tan()</code> trabalha com radianos, mas normalment epe mais fácil trabalhar em graus, a seguinte função aceita um valor em graus, converte-o para radianos e retorna a tangente.</p> +<pre class="brush:js">function getTanDeg(deg) { + var rad = deg * Math.PI/180; + return Math.tan(rad); +} +</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>ECMAScript 1st Edition. Implementado em JavaScript 1.0</td> + <td>Padrão</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.18', 'Math.tan')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.tan', 'Math.tan')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> +<p>{{ CompatibilityTable() }}</p> +<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>{{ 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>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>{{ 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/math/tanh/index.html b/files/pt-br/web/javascript/reference/global_objects/math/tanh/index.html new file mode 100644 index 0000000000..1122f98d69 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/tanh/index.html @@ -0,0 +1,88 @@ +--- +title: Math.tanh() +slug: Web/JavaScript/Reference/Global_Objects/Math/tanh +translation_of: Web/JavaScript/Reference/Global_Objects/Math/tanh +--- +<div>{{JSRef}}</div> + +<p>A função <strong><code>Math.tanh()</code></strong> retorna a tangente hiperbólica de um número, que é:</p> + +<p><math display="block"><semantics><mrow><mo lspace="0em" rspace="0em">tanh</mo><mi>x</mi><mo>=</mo><mfrac><mrow><mo lspace="0em" rspace="0em">sinh</mo><mi>x</mi></mrow><mrow><mo lspace="0em" rspace="0em">cosh</mo><mi>x</mi></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>-</mo><mn>1</mn></mrow><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>+</mo><mn>1</mn></mrow></mfrac></mrow><annotation encoding="TeX">\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-tanh.html")}}</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>Math.tanh(<var>x</var>)</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>Uma tangente hiperbólica de um número dado.</p> + +<h2 id="Description">Description</h2> + +<p>Because <code>tanh()</code> is a static method of <code>Math</code>, you always use it as <code>Math.tanh()</code>, rather than as a method of a <code>Math</code> object you created (<code>Math</code> is not a constructor).</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_Math.tanh()">Using <code>Math.tanh()</code></h3> + +<pre class="brush: js">Math.tanh(0); // 0 +Math.tanh(Infinity); // 1 +Math.tanh(1); // 0.7615941559557649 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>This can be emulated with the help of the {{jsxref("Math.exp()")}} function:</p> + +<pre class="brush: js">Math.tanh = Math.tanh || function(x){ + var a = Math.exp(+x), b = Math.exp(-x); + return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (a + b); +} +</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-math.tanh', 'Math.tanh')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.tanh', 'Math.tanh')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Math.tanh")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}}</li> + <li>{{jsxref("Math.asinh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.cosh()")}}</li> + <li>{{jsxref("Math.sinh()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/math/trunc/index.html b/files/pt-br/web/javascript/reference/global_objects/math/trunc/index.html new file mode 100644 index 0000000000..cba3259de7 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/math/trunc/index.html @@ -0,0 +1,144 @@ +--- +title: Math.trunc() +slug: Web/JavaScript/Reference/Global_Objects/Math/trunc +tags: + - Math + - Trunc +translation_of: Web/JavaScript/Reference/Global_Objects/Math/trunc +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>Math.trunc()</code></strong> retorna a parte inteira de um número, descartando suas casas decimais.</p> + +<p>{{EmbedInteractiveExample("pages/js/math-trunc.html")}}</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Math.trunc(<var>x</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Um número.</dd> +</dl> + +<p> </p> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>A parte inteira de um dado número.</p> + +<p> </p> + +<h2 id="Descrição">Descrição</h2> + +<p>Diferente dos demais métodos em Math: {{jsxref("Math.floor()")}}, {{jsxref("Math.ceil()")}} e {{jsxref("Math.round()")}}, o retorno esperado da função <code>Math.trunc()</code> é simples e direto, ela apenas trunca o número passado a ela como parâmetro, removendo todas as casas decimais dele, não importando se o número é positivo ou negativo.</p> + +<p>Portanto, se o argumento passado for um número positivo, <code>Math.trunc()</code> será equivalente a <code>Math.floor(), <font face="Open Sans, Arial, sans-serif">caso contrário </font></code><code>Math.trunc()</code> será equivalente a <code>Math.ceil()</code>.</p> + +<p>O argumento passado a esse método será convertido a um tipo numérico implicitamente.</p> + +<p>Já que <code>trunc()</code> é um método estático em <code>Math</code>, sempre utilize <code>Math.trunc()</code>, ao invés de um método existente no objeto que você criou (<code>Math</code> não é um construtor).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Math.trunc()">Usando <code>Math.trunc()</code></h3> + +<pre class="brush: js">Math.trunc(13.37); // 13 +Math.trunc(42.84); // 42 +Math.trunc(0.123); // 0 +Math.trunc(-0.123); // -0 +Math.trunc('-1.123'); // -1 +Math.trunc(NaN); // NaN +Math.trunc('foo'); // NaN +Math.trunc(); // NaN +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>(um<em>Polyfill</em> é um pedaço de código que o desenvolvedor pode colocar na sua página para garantir compatilibilidade do método. No exemplo abaixo, caso o navegador não tiver o método <code>trunc </code>na classe <code>Math</code>, ele será criado);</p> + +<pre class="brush: js">Math.trunc = Math.trunc || function(x) { + return x < 0 ? Math.ceil(x) : Math.floor(x); +} +</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-math.trunc', 'Math.trunc')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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>{{CompatChrome("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("25")}}</td> + <td>{{CompatSafari("7.1")}}</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("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/nan/index.html b/files/pt-br/web/javascript/reference/global_objects/nan/index.html new file mode 100644 index 0000000000..ff9bb79c7b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/nan/index.html @@ -0,0 +1,125 @@ +--- +title: NaN +slug: Web/JavaScript/Reference/Global_Objects/NaN +translation_of: Web/JavaScript/Reference/Global_Objects/NaN +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Resumo">Resumo</h2> + +<p>A propriedade global <code><strong>NaN</strong></code> é um valor especial que significa <em>Not-A-Number</em> (não é um número).</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>NaN</code></pre> + +<h2 id="Description" name="Description">Descrição</h2> + +<p><code>NaN</code> é uma propriedade do <em>objeto global</em>.</p> + +<p>O valor inicial de <code>NaN</code> é Not-A-Number - o mesmo valor de <code>Number.NaN</code>. Nos navegadores modernos, o <code>NaN</code> é uma propriedade somente leitura e não configurável. Mesmo quando não for este o caso, evite sobrescrevê-lo.</p> + +<p>Não é usual a utilização do <code>NaN</code>. Ele é retornado quando uma operação matemática falha (Math.sqrt(-1)) ou quando uma função tenta transformar uma string em inteiro (parseInt("blabla")).</p> + +<h3 id="Testando_um_valor_NaN">Testando um valor <code>NaN</code></h3> + +<p>Os operadores de igualdade (<code>==</code> e <code>===</code>) não podem ser usados para testar um valor NaN. Ao invés disso, utilize {{jsxref("Number.isNaN()")}} ou {{jsxref("Global_Objects/isNaN", "isNaN()")}}.</p> + +<pre class="brush: js">NaN === NaN; // falso +Number.NaN === NaN; // falso +isNaN(NaN); // verdadeiro +isNaN(Number.NaN); // verdadeiro +</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>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Definição inicial. Implementado no JavaScript 1.3</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.1.1', 'NaN')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-value-properties-of-the-global-object-nan', 'NaN')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</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>{{jsxref("Number.NaN")}}</li> + <li>{{jsxref("Number.isNaN()")}}</li> + <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/null/index.html b/files/pt-br/web/javascript/reference/global_objects/null/index.html new file mode 100644 index 0000000000..8118dddc36 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/null/index.html @@ -0,0 +1,125 @@ +--- +title: 'null' +slug: Web/JavaScript/Reference/Global_Objects/null +translation_of: Web/JavaScript/Reference/Global_Objects/null +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Resumo">Resumo</h2> + +<p>O valor <code>null</code> é um literal em JavaScript que representa um valor nulo ou "vazio" (p/ex: que aponta para um objeto inexistente). É um dos {{Glossary("Primitivo", "valores primitivos")}} do JavaScript.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code>null </code></pre> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>O valor <code>null</code> é um literal, e não uma propriedade do objeto global (como o <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined" title="/en-US/docs/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a> pode ser). O desenhos das APIs, o null as vezes é devolvido no lugar de um objeto que era esperado. Quando fizer a checagem de um valor para <code>null</code> ou <code>undefined</code>, esteja ciente das <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">diferenças entre o operador de igualdade (==) e o de igualdade estrita (===)</a> (em inglês). Uma conversão de tipos é realizada na operação de igualdade.</p> + +<pre class="brush: js">// foo não existe, não foi definido e jamais foi inicializado: +> foo +"ReferenceError: foo is not defined" + +// foo é conhecido e existe, mas não aponta para nenhum tipo ou valor: +> var foo = null; foo +"null" +</pre> + +<h3 id="Diferenças_entre_null_e_undefined">Diferenças entre <code>null</code> e <code>undefined</code></h3> + +<pre class="brush: js">typeof null // object (bug no ECMAScript, deveria ser null - <a href="#">http://2ality.com/2013/10/typeof-null.html</a>) +typeof undefined // undefined +null === undefined // falso +null == undefined // verdadeiro +</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>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Definição inicial</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-4.3.11', 'null value')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-null-value', 'null value')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre 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>{{jsxref("Global_Objects/undefined", "undefined")}}</li> + <li>{{jsxref("Global_Objects/NaN", "NaN")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/epsilon/index.html b/files/pt-br/web/javascript/reference/global_objects/number/epsilon/index.html new file mode 100644 index 0000000000..bc10fb3285 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/epsilon/index.html @@ -0,0 +1,69 @@ +--- +title: Number.EPSILON +slug: Web/JavaScript/Reference/Global_Objects/Number/EPSILON +tags: + - ECMAScript 2015 + - JavaScript + - Number + - Número + - Property + - Propriedade +translation_of: Web/JavaScript/Reference/Global_Objects/Number/EPSILON +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Number.EPSILON</code></strong> representa a diferença entre 1 e o menor ponto flutuante maior que 1.</p> + +<p>Você não tem que criar um objeto {{jsxref("Number")}} para acessar esta propriedade estática (use <code>Number.EPSILON</code>).</p> + +<div>{{EmbedInteractiveExample("pages/js/number-epsilon.html")}}</div> + + + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>A propriedade <code>EPSILON</code> tem o valor de aproximadamente <code>2.2204460492503130808472633361816E-16</code>, ou <code>2<sup>-52</sup></code>.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js notranslate">if (Number.EPSILON === undefined) { + Number.EPSILON = Math.pow(2, -52); +} +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Testando_igualdade">Testando igualdade</h3> + +<pre class="brush: js notranslate">x = 0.2; +y = 0.3; +z = 0.1; +equal = (Math.abs(x - y + z) < Number.EPSILON); +</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-number.epsilon', 'Number.EPSILON')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Number.EPSILON")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>O objeto {{jsxref("Number")}} que esta propriedade pertence.</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/index.html b/files/pt-br/web/javascript/reference/global_objects/number/index.html new file mode 100644 index 0000000000..a21a4264af --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/index.html @@ -0,0 +1,221 @@ +--- +title: Número +slug: Web/JavaScript/Reference/Global_Objects/Number +tags: + - JavaScript + - Número + - Referência(2) +translation_of: Web/JavaScript/Reference/Global_Objects/Number +--- +<div>{{JSRef("Global_Objects", "Number")}} </div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>O objeto JavaScript <strong><code>Number</code></strong> é um objeto encapsulado que permite você trabalhar com valores numéricos. Um objeto <code>Number</code> é criado utilizando o construtor <code>Number()</code>.</p> + +<h2 id="Syntax" name="Syntax">Construtor</h2> + +<pre class="syntaxbox">new Number(value);</pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>value</code></dt> + <dd>O valor numérico do objeto sendo criado.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Os principais usos para o objeto <code>Number</code> são:</p> + +<ul> + <li>Se o objeto não pode ser convertido para um número, é retornado <code>NaN</code>.</li> + <li>Fora do contexo de um construtor (Ex., Sem o operador {{jsxref("Operators/new", "new")}}, <code>Number</code> pode ser utilizador para realizar uma conversão de tipo.</li> +</ul> + +<h2 id="Properties" name="Properties">Propriedades</h2> + +<dl> + <dt>{{jsxref("Number.EPSILON")}} {{experimental_inline}}</dt> + <dd>O menor intervalo entre dois números representáveis.</dd> + <dt>{{jsxref("Number.MAX_SAFE_INTEGER")}} {{experimental_inline}}</dt> + <dd>O inteiro máximo seguro em JavaScript (2<sup>53</sup> -1).</dd> + <dt>{{jsxref("Number.MAX_VALUE")}}</dt> + <dd>O maior número representável positivo.</dd> + <dt>{{jsxref("Number.MIN_SAFE_INTEGER")}} {{experimental_inline}}</dt> + <dd>O inteiro mínimo seguro em JavaScript (-(2<sup>53</sup> -1)).</dd> + <dt>{{jsxref("Number.MIN_VALUE")}}</dt> + <dd>O número mínimo representável positivo - isto é, o número positivo mais próximo de zero (sem ser zero na verdade).</dd> + <dt>{{jsxref("Number.NaN")}}</dt> + <dd>Valor especial que não é número.</dd> + <dt>{{jsxref("Number.NEGATIVE_INFINITY")}}</dt> + <dd>Valor especial representando infinito negativo; retornado no "overflow".</dd> + <dt>{{jsxref("Number.POSITIVE_INFINITY")}}</dt> + <dd> Valor especial representando infinito; retornado no "overflow".</dd> + <dt>{{jsxref("Number.prototype")}}</dt> + <dd>Permite a adição de propriedades a um objeto Number.</dd> +</dl> + +<div>{{jsOverrides("Function", "properties", "MAX_VALUE", "MIN_VALUE", "NaN", "NEGATIVE_INFINITY", "POSITIVE_INFINITY", "protoype")}}</div> + +<h2 id="Methods" name="Methods">Methods</h2> + +<dl> + <dt>{{jsxref("Number.isNaN()")}} {{experimental_inline}}</dt> + <dd>Determina se o valor passado é NaN.</dd> + <dt>{{jsxref("Number.isFinite()")}} {{experimental_inline}}</dt> + <dd>Determina se o tipo e o valor passado é um número finito.</dd> + <dt>{{jsxref("Number.isInteger()")}} {{experimental_inline}}</dt> + <dd>Determina se o tipo do valor passado é inteiro.</dd> + <dt>{{jsxref("Number.isSafeInteger()")}} {{experimental_inline}}</dt> + <dd>Determina se o tipo do valor passado é um inteiro seguro (número entre -(2<sup>53</sup> -1) e 2<sup>53</sup> -1).</dd> + <dt><s class="obsoleteElement">{{jsxref("Number.toInteger()")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Usado para avaliar o valor passado e convertê-lo a um inteiro (ou infinito), mas foi removido.</s></dd> + <dt>{{jsxref("Number.parseFloat()")}} {{experimental_inline}}</dt> + <dd>O valor é o mesmo que {{jsxref("Global_Objects/parseFloat", "parseFloat")}} do objeto global.</dd> + <dt>{{jsxref("Number.parseInt()")}} {{experimental_inline}}</dt> + <dd>O valor é o mesmo que {{jsxref("Global_Objects/parseInt", "parseInt")}} do objeto global.</dd> +</dl> + +<div>{{jsOverrides("Function", "methods", "isNaN")}}</div> + +<h2 id="Number_instances" name="Number_instances">Instâncias<code> Number</code> </h2> + +<p>Toda instância <code>Number</code> herdam de {{jsxref("Number.prototype")}}. O objeto 'prototype' do construtor <code>Number</code> pode ser modificado para afetar todas as instâncias <code>Number</code>.</p> + +<h3 id="Methods_of_number_instance" name="Methods_of_number_instance">Métodos</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/prototype', 'Methods')}}</div> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Using_the_Number_object_to_assign_values_to_numeric_variables" name="Example:_Using_the_Number_object_to_assign_values_to_numeric_variables">Exemplo: Usando o objeto <code>Number</code> para atribuir valores a variáveis numéricas</h3> + +<p>O seguinte exemplo usa as propriedades do objeto <code>Number</code> para atribuir valores a várias variáveis numéricas:</p> + +<pre class="brush: js">var biggestNum = Number.MAX_VALUE; +var smallestNum = Number.MIN_VALUE; +var infiniteNum = Number.POSITIVE_INFINITY; +var negInfiniteNum = Number.NEGATIVE_INFINITY; +var notANum = Number.NaN; +</pre> + +<h3 id="Example:_Using_Number_to_convert_a_Date_object" name="Example:_Using_Number_to_convert_a_Date_object">Exemplo: Intervalo inteiro para <code>Number</code></h3> + +<p>O seguinte exemplo mostra os valores inteiros mínimo e máximo que podem ser representados como objeto <code>Number</code> (para mais detalhes, referir-se ao padrão EcmaScript standard (EcmaScript standard), capítulo <em>8.5 O tipo de número (The Number Type</em>):</p> + +<pre class="brush: js">var maxInt = 9007199254740992; +var minInt = -9007199254740992; +</pre> + +<p>Ao analisar dados que foram serializados para JSON, valores inteiros que caem fora desse intervalo podem ser corrompidos quando o analisador JSON os converte ao tipo <code>Number</code>. Usando <code>String </code>em vez disso é uma possível alternativa para se evitar um resultado indesejado.</p> + +<h3 id="Example:_Using_Number_to_convert_a_Date_object" name="Example:_Using_Number_to_convert_a_Date_object"><span style="display: none;"> </span>Exemplo: Usando <code>Number para converter um objeto</code> <code>Date</code></h3> + +<p>O exemplo a seguir converte o objeto <code>Date</code> para um valor numérico usando <code>Number como uma função</code>:</p> + +<pre class="brush: js">var d = new Date("December 17, 1995 03:24:00"); +print(Number(d)); +</pre> + +<p>Isto resulta em "819199440000".</p> + +<h3 id="Converte_'string'_numérica_em_números">Converte 'string' numérica em números</h3> + +<pre class="brush: js">Number('123') // 123 +Number('12.3') // 12.3 +Number('') // 0 +Number('0x11') // 17 +Number('0b11') // 3 +Number('0o11') // 9 +Number('foo') // NaN +Number('100a') // NaN +</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>Primeiro edição ECMAScript. Implementado em JavaScript 1.1</td> + <td>Padrão</td> + <td>definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7', 'Number')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number-objects', 'Number')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Novos métodos e propriedades adicionadas (EPSILON, isFinite, isInteger, isNaN, parseFloat, parseInt)</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<p>{{ CompatibilityTable() }}</p> + +<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>{{ 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>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>{{ 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("Global_Objects/NaN", "NaN")}}</li> + <li>O objeto global {{jsxref("Global_Objects/Math", "Math")}}</li> +</ul> + +<div id="cke_pastebin" style="position: absolute; top: 2173.92px; width: 1px; height: 1px; overflow: hidden; left: -1000px;"> </div> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/isfinite/index.html b/files/pt-br/web/javascript/reference/global_objects/number/isfinite/index.html new file mode 100644 index 0000000000..d4a86d3531 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/isfinite/index.html @@ -0,0 +1,86 @@ +--- +title: Number.isFinite() +slug: Web/JavaScript/Reference/Global_Objects/Number/isFinite +tags: + - JavaScript + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isFinite +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>Number.isFinite()</code></strong> determina se o valor passado é um número finito.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox">Number.isFinite(v<var>alor</var>)</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>valor</code></dt> + <dd>O valor a ser testado.</dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>Um {{jsxref("Boolean")}} indicando se o valor passado é ou não um número finito.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Em comparação com a função global {{jsxref("isFinite", "isFinite()")}}, esse método não força a conversão do parâmetro para número. Isso significa que só valores do tipo número, que são também finitos, retornam <code>true</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js">Number.isFinite(Infinity); // false +Number.isFinite(NaN); // false +Number.isFinite(-Infinity); // false + +Number.isFinite(0); // true +Number.isFinite(2e64); // true + +Number.isFinite('0'); // false, teria sido true com a função + // global isFinite('0') +Number.isFinite(null); // false, teria sido true com a função + // global isFinite(null) +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Number.isFinite = Number.isFinite || function(value) { + return typeof value === 'number' && isFinite(value); +} +</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-number.isfinite', 'Number.isInteger')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.isfinite', 'Number.isInteger')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Number.isFinite")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>O objeto {{jsxref("Number")}} ao qual pertence.</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/isinteger/index.html b/files/pt-br/web/javascript/reference/global_objects/number/isinteger/index.html new file mode 100644 index 0000000000..fce6b5f19c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/isinteger/index.html @@ -0,0 +1,136 @@ +--- +title: Number.isInteger() +slug: Web/JavaScript/Reference/Global_Objects/Number/isInteger +tags: + - Numérico + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isInteger +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>Number.isInteger()</code></strong> determina se o valor passado é um inteiro.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Number.isInteger(v<var>alue</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>value</code></dt> + <dd>O valor a testar se é um inteiro.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um {{jsxref("Boolean")}} indicando se o valor é inteiro ou não.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se o alvo for um inteiro, returna <code>true</code>, senão returna <code>false</code>. Se o valor é {{jsxref("NaN")}} ou infinito, returna <code>false</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js">Number.isInteger(0); // true +Number.isInteger(1); // true +Number.isInteger(-100000); // true + +Number.isInteger(0.1); // false +Number.isInteger(Math.PI); // false + +Number.isInteger(Infinity); // false +Number.isInteger(-Infinity); // false +Number.isInteger("10"); // false +Number.isInteger(true); // false +Number.isInteger(false); // false +Number.isInteger([1]); // false +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Number.isInteger = Number.isInteger || function(value) { + return typeof value === "number" && + isFinite(value) && + Math.floor(value) === value; +}; +</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-number.isinteger', 'Number.isInteger')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.isinteger', 'Number.isInteger')}}</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>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>{{CompatGeckoDesktop("16")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</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>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("16")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Ver_tabém">Ver tabém</h2> + +<ul> + <li>O objeto {{jsxref("Number")}} a qual este método pertence.</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/isnan/index.html b/files/pt-br/web/javascript/reference/global_objects/number/isnan/index.html new file mode 100644 index 0000000000..9652d6628c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/isnan/index.html @@ -0,0 +1,131 @@ +--- +title: Number.isNaN() +slug: Web/JavaScript/Reference/Global_Objects/Number/isNaN +tags: + - Experimental + - Expérimental(2) + - JavaScript + - Method + - Number +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isNaN +--- +<div>{{JSRef("Global_Objects", "Number")}}</div> + +<h2 id="Resumo">Resumo</h2> + +<p>O método <strong><code>Number.isNaN()</code></strong> determina se o valor passado é {{jsxref("Global_Objects/NaN", "NaN")}}. Versão mais robusta do original global {{jsxref("Global_Objects/isNaN", "isNaN")}}.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code>Number.isNaN(test<em>Value</em>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>test<em>Value</em></code></dt> + <dd>O valor a ser testado por {{jsxref("Global_Objects/NaN", "NaN")}}.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Devido a ambos os operadores de igualdade, == and ===, avaliar a <code>false</code> quando está verificando se {{jsxref("Global_Objects/NaN", "NaN")}} <em>é</em> NaN, a função <code>Number.isNaN</code> se torna necessária. Esta situação é diferente de todas as outras comparações de valor possível em JavaScript.</p> + +<p>Em comparação a função global {{jsxref("Global_Objects/isNaN", "isNaN")}}, Number.isNaN não sofre do problema de forçar a conversão do parâmetro para um número. Isso significa que ele é seguro para passar valores que, normalmente, se convertem em NaN, mas na verdade não são o mesmo valor que NaN. Isto também significa que apenas os valores do número do tipo, que são também NaN, retorna <code>true</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush:js;">Number.isNaN(NaN); // true +Number.isNaN(Number.NaN); // true +Number.isNaN(0 / 0) // true + +// everything else: false +Number.isNaN(undefined); +Number.isNaN({}); + +Number.isNaN(true); +Number.isNaN(null); +Number.isNaN(37); + +Number.isNaN("37"); +Number.isNaN("37.37"); +Number.isNaN(""); +Number.isNaN(" "); +Number.isNaN("NaN"); +Number.isNaN("blabla"); // e.g. este teria sido true com isNaN</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> + <p>{{SpecName('ES6', '#sec-number.isnan', 'Number.isnan')}}</p> + </td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<p>{{ CompatibilityTable() }}</p> + +<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>25.0</td> + <td>{{CompatGeckoDesktop("15")}}</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><span style="font-size: 15.5555562973022px;">Característica</span></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><span style="font-size: 12.222222328186px;">Suporte básico</span></td> + <td>{{CompatNo}}</td> + <td>{{ CompatUnknown() }}</td> + <td>{{CompatGeckoMobile("15")}}</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>O {{jsxref("Global_Objects/Number", "Number")}} objeto pertence a.</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/issafeinteger/index.html b/files/pt-br/web/javascript/reference/global_objects/number/issafeinteger/index.html new file mode 100644 index 0000000000..b6b9d823bc --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/issafeinteger/index.html @@ -0,0 +1,104 @@ +--- +title: Number.isSafeInteger() +slug: Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger +tags: + - JavaScript + - Número + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>Number.isSafeInteger()</code></strong> determina se o valor fornecido é seja um número seguro.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-issafeinteger.html")}}</div> + + + +<p>Um inteiro seguro é um inteiro que:</p> + +<ul> + <li>pode ser representando exatamente como um número IEEE-754 de dupla precisão e</li> + <li>pode ser representando exatamente como um número IEEE-754<br> + de precisão dupla e</li> + <li>cuja representação IEEE-754 não pode ser o resultado do arrendodamento de qualquer outro número inteiro para se ajustar ao IEEE-754.</li> +</ul> + +<p>Exemplo, <code>2<sup>53</sup> - 1</code> é um inteiro seguro: pode ser exatamente representado, e nenhum outro numero arredondado existe para ele na represetanção IEEE-754. Em contexto, <code>2<sup>53</sup></code> <em>não</em> é um inteiro seguro: pode ser representado em IEEE-754, mas um inteiro <code>2<sup>53</sup> + 1</code> não pode ser diretamente representado em IEEE-754 mas instanciado do arrendamento de <code>2<sup>53</sup></code> sob arrendamento para o mais próximo e do arrendamento de zero a zero. Os inteiros seguros consistem em todos os inteiros de <code>-(2<sup>53</sup> - 1)</code> inclusive para <code>2<sup>53</sup> - 1</code> (sendo ± <code>9007199254740991</code> ou ± 9,007,199,254,740,991). </p> + +<p>A manipulação de valores entre ~9 quadrilhões com precisão total requer o uso de <a href="https://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic">arbitrary precision arithmetic library</a> (biblioteca aritmética de precisão arbitrária). Veja <a href="http://floating-point-gui.de/">What Every Programmer Needs to Know about Floating Point Arithmetic</a> (o que todo programador precisa saber sobre aritmética de ponto flutuante) para mais informações sobre represetanções de número de ponto flutuante.</p> + +<p>Para números inteiros maiores, considere o uso do tipo {{jsxref("BigInt")}}.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>Number.isSafeInteger(valorTest)</code> +</pre> + +<h3 id="Parâmetros"><strong>Parâmetros</strong></h3> + +<dl> + <dt><code>valorTest</code></dt> + <dd>O valor a ser testado pode ser um número inteiro seguro.</dd> + <dd></dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>Um {{jsxref("Boolean")}} indica se o valor fornecido é um número seguro ou não.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js">Number.isSafeInteger(3); // true +Number.isSafeInteger(Math.pow(2, 53)); // false +Number.isSafeInteger(Math.pow(2, 53) - 1); // true +Number.isSafeInteger(NaN); // false +Number.isSafeInteger(Infinity); // false +Number.isSafeInteger('3'); // false +Number.isSafeInteger(3.1); // false +Number.isSafeInteger(3.0); // true +</pre> + +<h2 id="Polyfill_caso_não_exista_suporte">Polyfill (caso não exista suporte)</h2> + +<pre class="brush: js">Number.isSafeInteger = Number.isSafeInteger || function (value) { + return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER; +}; +</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">Coméntario</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-number.issafeinteger', 'Number.isSafeInteger')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.issafeinteger', 'Number.isSafeInteger')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade">Compatibilidade</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Number.isSafeInteger")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>O objeto pertence a {{jsxref("Number")}}</li> + <li>{{jsxref("Number.MIN_SAFE_INTEGER")}}</li> + <li>{{jsxref("Number.MAX_SAFE_INTEGER")}}</li> + <li>{{jsxref("BigInt")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/max_safe_integer/index.html b/files/pt-br/web/javascript/reference/global_objects/number/max_safe_integer/index.html new file mode 100644 index 0000000000..bae4c758f3 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/max_safe_integer/index.html @@ -0,0 +1,83 @@ +--- +title: Number.MAX_SAFE_INTEGER +slug: Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER +tags: + - ECMAScript 2015 + - JavaScript + - Number + - Número + - Property + - Propriedade +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER +--- +<div>{{JSRef}}</div> + +<p>A constante <strong><code>Number.MAX_SAFE_INTEGER</code></strong> representa o maior inteiro seguro no JavaScript (<code>2<sup>53</sup> - 1</code>).</p> + +<p>Para inteiros maiores, considere usar {{jsxref("BigInt")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-maxsafeinteger.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> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>A constante <code>MAX_SAFE_INTEGER</code> tem o valor de <code>9007199254740991</code> (9,007,199,254,740,991 ou ~9 quadrilhões). A razão por trás deste número é que o JavaScript usa o <a href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format">formato de número de ponto-flutuante de precisão-dupla</a> como especificado na <a href="http://en.wikipedia.org/wiki/IEEE_floating_point">IEEE 754</a> e pode seguramente representar número entre <code>-(2<sup>53</sup> - 1)</code> e <code>2<sup>53</sup> - 1</code>.</p> + +<p>Seguro neste contexto se refere a habilidade de representar inteiros exatamente e corretamente compará-los. Por exemplo, <code>Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2</code> será avaliado para verdadeiro, que é matematicamente incorreto. Veja {{jsxref("Number.isSafeInteger()")}} para mais informação.</p> + +<p>Este campo não existe em navegadores antigos. Usando ele sem checar sua existência, como <code>Math.max(Number.MAX_SAFE_INTEGER, 2)</code>, irá gerar resultados indesejados como NaN.</p> + +<p>Por <code>MAX_SAFE_INTEGER</code> ser uma propriedade estática de {{jsxref("Number")}}, você sempre deve usar como <code>Number.MAX_SAFE_INTEGER</code>, ao invés de uma propriedade do objeto {{jsxref("Number")}} que você criou.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js notranslate">if (!Number.MAX_SAFE_INTEGER) { + Number.MAX_SAFE_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1; +} +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Retorno_do_valor_de_MAX_SAFE_INTEGER">Retorno do valor de MAX_SAFE_INTEGER</h3> + +<pre class="brush: js notranslate">Number.MAX_SAFE_INTEGER; // 9007199254740991 +</pre> + +<h3 id="Números_maiores_que_o_inteiro_seguro">Números maiores que o inteiro seguro</h3> + +<p>Isso retorna 2 por quê em pontos flutuantes, o valor é na verdade o final decimal "1" exceto em casos subnormais de precisão como zero.</p> + +<pre class="brush: js notranslate">Number.MAX_SAFE_INTEGER * Number.EPSILON; // 2 +</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-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Number.MAX_SAFE_INTEGER")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Number.MIN_SAFE_INTEGER")}}</li> + <li>{{jsxref("Number.isSafeInteger()")}}</li> + <li>{{jsxref("BigInt")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/max_value/index.html b/files/pt-br/web/javascript/reference/global_objects/number/max_value/index.html new file mode 100644 index 0000000000..2a308f13ed --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/max_value/index.html @@ -0,0 +1,65 @@ +--- +title: Number.MAX_VALUE +slug: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE +tags: + - JavaScript + - Number + - Property + - Propriedade + - Referencia +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Number.MAX_VALUE</code></strong> representa o maior valor numérico representável em JavaScript.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-maxvalue.html")}}</div> + + + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>A propriedade <code>MAX_VALUE</code> tem o valor de aproximadamente <code>1.79E+308</code>, ou 2<sup>1024</sup>. Valores maiores que <code>MAX_VALUE</code> são representados como {{jsxref("Infinity")}}.</p> + +<p>Por <code>MAX_VALUE</code> ser uma propriedade estática de {{jsxref("Number")}}, você sempre deve usar como <code>Number.MAX_VALUE</code>, ao invés de uma propriedade do objeto {{jsxref("Number")}} que você criou. </p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_MAX_VALUE">Usando <code>MAX_VALUE</code></h3> + +<p>O código a seguir multiplica dois valores numéricos. Se o resultado é menor ou igual a <code>MAX_VALUE</code>, a função <code>func1</code> é chamada; caso contrário, a função <code>func2</code> é chamada.</p> + +<pre class="brush: js notranslate">if (num1 * num2 <= Number.MAX_VALUE) { + func1(); +} else { + func2(); +} +</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-number.max_value', 'Number.MAX_VALUE')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Number.MAX_VALUE")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Number.MIN_VALUE")}}</li> + <li>O objeto {{jsxref("Number")}} a qual ela pertence</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/min_safe_integer/index.html b/files/pt-br/web/javascript/reference/global_objects/number/min_safe_integer/index.html new file mode 100644 index 0000000000..ab952dcadb --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/min_safe_integer/index.html @@ -0,0 +1,66 @@ +--- +title: Number.MIN_SAFE_INTEGER +slug: Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER +tags: + - ECMAScript 2015 + - JavaScript + - Number + - Número + - Property + - Propriedade +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER +--- +<div>{{JSRef}}</div> + +<p>A constante <strong><code>Number.MIN_SAFE_INTEGER</code></strong> representa o menor inteiro seguro no JavaScript (<code>-(2<sup>53</sup> - 1)</code>).</p> + +<p>Para representar inteiros menores do que isso, considere usar {{jsxref("BigInt")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-min-safe-integer.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> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>A constante <code>MIN_SAFE_INTEGER</code> tem o valor de <code>-9007199254740991</code> (-9,007,199,254,740,991 ou -9 quadrilhões). A razão por trás deste número é que o JavaScript usa o <a class="external external-icon" href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format" rel="noopener">formato de número de ponto-flutuante de precisão-dupla</a> como especificado na <a class="external external-icon" href="http://en.wikipedia.org/wiki/IEEE_floating_point" rel="noopener">IEEE 754</a> e pode seguramente representar número entre <code>-(2<sup>53</sup> - 1)</code> e <code>2<sup>53</sup> - 1</code>. Veja {{jsxref("Number.isSafeInteger()")}} para mais informações.</p> + +<p>Por <code>MIN_SAFE_INTEGER</code> ser uma propriedade estática de {{jsxref("Number")}}, você sempre deve usar como <code>Number.MIN_SAFE_INTEGER</code>, ao invés de uma propriedade do objeto {{jsxref("Number")}} que você criou.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_MIN_SAFE_INTEGER">Usando MIN_SAFE_INTEGER</h3> + +<pre class="brush: js notranslate">Number.MIN_SAFE_INTEGER // -9007199254740991 +-(Math.pow(2, 53) - 1) // -9007199254740991 +</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-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Number.MIN_SAFE_INTEGER")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Number.MAX_SAFE_INTEGER")}}</li> + <li>{{jsxref("Number.isSafeInteger()")}}</li> + <li>{{jsxref("BigInt")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/min_value/index.html b/files/pt-br/web/javascript/reference/global_objects/number/min_value/index.html new file mode 100644 index 0000000000..6c6738f96f --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/min_value/index.html @@ -0,0 +1,69 @@ +--- +title: Number.MIN_VALUE +slug: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE +tags: + - JavaScript + - Number + - Número + - Property + - Propriedade + - Referencia +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Number.MIN_VALUE</code></strong> representa o menor valor positivo numérico representável em JavaScript.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-min-value.html")}}</div> + + + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>A propriedade <code>MIN_VALUE</code> é o número mais próximo de 0, não o número mais negativo, que o JavaScript pode representar.</p> + +<p><code>MIN_VALUE</code> tem o valor de aproximadamente <code>5e-324</code>. Valores menores que <code>MIN_VALUE</code> ("valores de underflow") são convertidos para 0.</p> + +<p>Por <code>MIN_VALUE</code> ser uma propriedade estática de {{jsxref("Number")}}, você sempre deve usar como <code>Number.MIN_VALUE</code>, ao invés de uma propriedade do objeto {{jsxref("Number")}} que você criou.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_MIN_VALUE">Usando <code>MIN_VALUE</code></h3> + +<p>O seguinte código divide dois valores numéricos. Se o resultado é maior ou igual a <code>MIN_VALUE</code>, a função <code>func1</code> é chamada; caso contrário, a função <code>func2</code> é chamada.</p> + +<pre class="brush: js notranslate">if (num1 / num2 >= Number.MIN_VALUE) { + func1(); +} else { + func2(); +} +</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-number.min_value', 'Number.MIN_VALUE')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Number.MIN_VALUE")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Number.MAX_VALUE")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/nan/index.html b/files/pt-br/web/javascript/reference/global_objects/number/nan/index.html new file mode 100644 index 0000000000..d2c49dee98 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/nan/index.html @@ -0,0 +1,105 @@ +--- +title: Number.NaN +slug: Web/JavaScript/Reference/Global_Objects/Number/NaN +translation_of: Web/JavaScript/Reference/Global_Objects/Number/NaN +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Number.NaN</code></strong> representa Not-A-Number (Não-Número). Equivalente a {{jsxref("NaN")}}.</p> + +<p>Você não precisa criar um objeto {{jsxref("Number")}} para acessar esta propriedade estática (use <code>Number.NaN</code>).</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<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">Detalhes</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição Inicial. Implementado no JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.4', 'Number.NaN')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.nan', 'Number.NaN')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.nan', 'Number.NaN')}}</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>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> + +<h2 id="sect1"> </h2> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>O objeto global {{jsxref("NaN")}}.</li> + <li>O objeto {{jsxref("Number")}} ao qual ele pertence.</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/negative_infinity/index.html b/files/pt-br/web/javascript/reference/global_objects/number/negative_infinity/index.html new file mode 100644 index 0000000000..ca9531f930 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/negative_infinity/index.html @@ -0,0 +1,84 @@ +--- +title: Number.NEGATIVE_INFINITY +slug: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY +tags: + - JavaScript + - Number + - Número + - Property + - Propriedade + - Referencia +translation_of: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Number.NEGATIVE_INFINITY</code></strong> representa o valor Infinito negativo.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-negative-infinity.html")}}</div> + + + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>O valor de <code>Number.NEGATIVE_INFINITY</code> é o mesmo que o valor negativo da propriedade do objeto global {{jsxref("Infinity")}}.</p> + +<p>O valor se comporta um pouco diferente do que o infinito matemático:</p> + +<ul> + <li>Qualquer valor positivo, incluindo {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, mutiplicado por <code>NEGATIVE_INFINITY</code> é <code>NEGATIVE_INFINITY</code>.</li> + <li>Qualquer valor negativo, incluindo <code>NEGATIVE_INFINITY</code>, multiplicado por <code>NEGATIVE_INFINITY</code> é {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li> + <li>Qualquer valor positivo dividido por <code>NEGATIVE_INFINITY</code> é zero negativo.</li> + <li>Qualquer valor negativo dividido por <code>NEGATIVE_INFINITY</code> é zero positivo.</li> + <li>Zero multiplicado por <code>NEGATIVE_INFINITY</code> é {{jsxref("NaN")}}.</li> + <li>{{jsxref("NaN")}} multiplicado por <code>NEGATIVE_INFINITY</code> é {{jsxref("NaN")}}.</li> + <li><code>NEGATIVE_INFINITY</code>, dividido por qualquer valor negativo exceto <code>NEGATIVE_INFINITY</code>, é {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li> + <li><code>NEGATIVE_INFINITY</code>, divido por qualquer valor positivo exceto {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, é <code>NEGATIVE_INFINITY</code>.</li> + <li><code>NEGATIVE_INFINITY</code>, divido por ou <code>NEGATIVE_INFINITY</code> ou {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, é {{jsxref("NaN")}}.</li> +</ul> + +<p>Você pode usar a propriedade <code>Number.NEGATIVE_INFINITY</code> para indicar uma condição de erro que retorna um número finito em caso de sucesso. Nota que, usar {{jsxref("isFinite")}} seria mais apropriado neste caso.</p> + +<p>Por <code>NEGATIVE_INFINITY</code> ser uma propriedade estática de {{jsxref("Number")}}, você sempre a usa como <code>Number.NEGATIVE_INFINITY</code>, ao invés de ser uma propriedade do objeto {{jsxref("Number")}} que você criou.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_NEGATIVE_INFINITY">Usando <code>NEGATIVE_INFINITY</code></h3> + +<p>No seguinte exemplo, a variável <code>smallNumber</code> é atribuída um valor que é menor que o valor mínimo. Quando o {{jsxref("Statements/if...else", "if")}} executa, <code>smallNumber</code> tem o valor <code>-Infinity</code>, então é colocado em <code>smallNumber</code> um valor mais manejável antes de continuar.</p> + +<pre class="brush: js notranslate">var smallNumber = (-Number.MAX_VALUE) * 2; + +if (smallNumber === Number.NEGATIVE_INFINITY) { + smallNumber = returnFinite(); +} +</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-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Number.NEGATIVE_INFINITY")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Global_Objects/Infinity", "Infinity")}}</li> + <li>{{jsxref("Global_Objects/isFinite", "isFinite()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/parsefloat/index.html b/files/pt-br/web/javascript/reference/global_objects/number/parsefloat/index.html new file mode 100644 index 0000000000..85994f5ca6 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/parsefloat/index.html @@ -0,0 +1,116 @@ +--- +title: Number.parseFloat() +slug: Web/JavaScript/Reference/Global_Objects/Number/parseFloat +translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseFloat +--- +<div>{{JSRef("Global_Objects", "Number")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <strong>Number.parseFloat()</strong> converte a string recebida como argumento e a retorna como um número de ponto flutuante. Este método se comporta de maneira idêntica a da função global {{jsxref("Global_Objects/parseFloat", "parseFloat")}} e é parte da especificação ECMAScript 6 (seu propósito é a modularização dos objetos globais).</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code>Number.parseFloat(<var>string</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code><var>string</var></code></dt> + <dd>Uma string que represente o valor que se deseja converter.<br> + </dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<dl> + <dt><code><var>string</var></code></dt> + <dd>Um número de ponto flutuante a partir da string dada. Se a string não puder ser convertida em para um número, {{jsxref("Global_Objects/NaN","NaN")}} é retornado.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Este método tem a mesma funcionalidade do método global: {{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</p> + +<pre>Number.parseFloat === parseFloat; // true +</pre> + +<p>Por favor veja {{jsxref("parseFloat", "parseFloat()")}} para mais detalhes e exemplos.</p> + +<h2 id="Especificação">Especificação</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Situação</th> + <th scope="col">Comentários</th> + </tr> + <tr> + <td> + <p>{{SpecName('ES6', '#sec-number.parsefloat', 'Number.parseFloat')}}</p> + </td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade dos Navegadores</h2> + +<p>{{ CompatibilityTable() }}</p> + +<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>{{CompatNo}}</td> + <td>{{CompatGeckoDesktop("25")}}</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>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>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>O objeto {{jsxref("Global_Objects/Number", "Number")}} ao qual o método parseFloat pertence.</li> + <li>O método global {{jsxref("Global_Objects/parseFloat", "parseFloat()")}}.</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/parseint/index.html b/files/pt-br/web/javascript/reference/global_objects/number/parseint/index.html new file mode 100644 index 0000000000..88c3c6735b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/parseint/index.html @@ -0,0 +1,85 @@ +--- +title: Number.parseInt() +slug: Web/JavaScript/Reference/Global_Objects/Number/parseInt +tags: + - ECMAScript 2015 + - JavaScript + - Method + - Number + - Número + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseInt +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>Number.parseInt()</code></strong> converte um argumento de <em>string</em> e retorna um inteiro da raiz ou base específica.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-parseint.html", "taller")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate">Number.parseInt(<var>string,</var>[ <var>radix</var>])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<div> +<dl> + <dt><code><var>string</var></code></dt> + <dd>O valor a ser convertido. Se este argumento não for uma <em>string</em>, então ele é convertido a um usando a operação abstrata <code><a href="https://tc39.es/ecma262/#sec-tostring">ToString</a></code>. O espaço em branco inicial neste argumento é ignorado.</dd> + <dt><code><var>radix</var></code><var> {{optional_inline}}</var></dt> + <dd>Um inteiro entre <code>2</code> e <code>36</code> que representa a <em>raiz</em> (a base no sistema numérico matemático) de uma <code><var>string</var></code>. Tome cuidado—o padrão <em><strong>não</strong></em> é <code>10</code>!</dd> +</dl> +</div> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Um inteiro convertido de uma dada <code><var>string</var></code>.</p> + +<p>Se a <code><var>radix</var></code> é menor que <code>2</code> ou maior que <code>36</code>, e o primeiro caracter que não é um espaço em branco não puder ser convertido para um número, {{jsxref("NaN")}} é retornado.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js notranslate">if (Number.parseInt === undefined) { + Number.parseInt = window.parseInt +} +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Number.parseInt_vs_parseInt">Number.parseInt vs parseInt</h3> + +<p>Este método tem a mesma funcionalidade que o método global {{jsxref("parseInt", "parseInt()")}}:</p> + +<pre class="brush: js notranslate">Number.parseInt === parseInt // true</pre> + +<p>e é parte do ECMAScript 2015 (sua proposta é a modularização dos globais). Por favor veja {{jsxref("parseInt", "parseInt()")}} para mais detalhes e exemplos.</p> + +<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-number.parseint', 'Number.parseInt')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Number.parseInt")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>O objeto {{jsxref("Number")}} a qual ela pertence.</li> + <li>O método global {{jsxref("parseInt", "parseInt()")}}.</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/positive_infinity/index.html b/files/pt-br/web/javascript/reference/global_objects/number/positive_infinity/index.html new file mode 100644 index 0000000000..b6ac31f1ec --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/positive_infinity/index.html @@ -0,0 +1,92 @@ +--- +title: Number.POSITIVE_INFINITY +slug: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY +translation_of: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Number.POSITIVE_INFINITY</code></strong> representa o valor positivo infinito.</p> + +<p>Você não precisa criar um objeto {{jsxref("Number")}} para utilizar a propriedade estática (use <code>Number.POSITIVE_INFINITY</code>).</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>O valor de <code>Number.POSITIVE_INFINITY</code> é o mesmo valor da propriedade {{jsxref("Infinity")}} do objeto global.</p> + +<p>Esse valor se comporta ligeiramente diferente do infinito matemático:</p> + +<ul> + <li>Qualquer valor positivo, incluindo <code>POSITIVE_INFINITY</code>, multiplicado por <code>POSITIVE_INFINITY</code> é <code>POSITIVE_INFINITY</code>.</li> + <li>Qualquer valor negativo, incluindo, {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}, multiplicado por <code>POSITIVE_INFINITY</code> é {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}.</li> + <li>Qualquer número positivo dividido por <code>POSITIVE_INFINITY</code> é Zero positivo.</li> + <li>Qualquer número negativo dividido por <code>POSITIVE_INFINITY</code> é Zero negativo.</li> + <li>Zero multiplicado por <code>POSITIVE_INFINITY</code> é {{jsxref("NaN")}}.</li> + <li>{{jsxref("Global_Objects/NaN", "NaN")}} multiplicado por <code>POSITIVE_INFINITY</code> é {{jsxref("NaN")}}.</li> + <li><code>POSITIVE_INFINITY</code>, dividido por qualquer valor negativo exceto {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}, é {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}.</li> + <li><code>POSITIVE_INFINITY</code>, dividido por qualquer valor positivo exceto <code>POSITIVE_INFINITY</code>, é <code>POSITIVE_INFINITY</code>.</li> + <li><code>POSITIVE_INFINITY</code>, dividido por {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}} ou <code>POSITIVE_INFINITY</code>, é {{jsxref("NaN")}}.</li> +</ul> + +<p>Você pode usar a propriedade <code>Number.POSITIVE_INFINITY</code> para indicar uma condição de erro que retorna um número finito no caso de sucesso. Sobretudo, {{jsxref("isFinite")}} seria mais apropriado nesse caso.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_POSITIVE_INFINITY">Usando <code>POSITIVE_INFINITY</code></h3> + +<p>No exemplo a seguir, a variável <code>bigNumber</code> recebe um valor maior que o valor máximo. Quando as declarações {{jsxref("Statements/if...else", "if")}} executam, <code>bigNumber</code> tem o valor <code>Infinity</code>, então <code>bigNumber</code> recebe um valor mais gerenciável antes de continuar.</p> + +<pre class="brush: js">var bigNumber = Number.MAX_VALUE * 2; + +if (bigNumber == Number.POSITIVE_INFINITY) { + bigNumber = returnFinite(); +} +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.6', 'Number.POSITIVE_INFINITY')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Number.POSITIVE_INFINITY")}}</p> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Infinity")}}</li> + <li>{{jsxref("isFinite", "isFinite()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/number/prototype/index.html new file mode 100644 index 0000000000..01b988c542 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/prototype/index.html @@ -0,0 +1,139 @@ +--- +title: Number.prototype +slug: Web/JavaScript/Reference/Global_Objects/Number/prototype +tags: + - JavaScript + - Número + - Propriedade + - Prototipo +translation_of: Web/JavaScript/Reference/Global_Objects/Number +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>Number.prototype</code></strong> representa o protótipo para o construtor {{jsxref("Number")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Todas instâncias {{jsxref("Number")}} herdam de <code>Number.prototype</code>. O objeto 'prototype' do construtor {{jsxref("Number")}} pode ser modificado para afetar todas instâncias {{jsxref( "Number")}}.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>Number.prototype.constructor</code></dt> + <dd>Retorna a função que criou esta instância do objeto. Por padrão, este é o objeto {{jsxref("Number")}}.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("Number.prototype.toExponential()")}}</dt> + <dd>Retorna uma 'string' representando o número em notação exponencial.</dd> + <dt>{{jsxref("Number.prototype.toFixed()")}}</dt> + <dd>Retorna uma 'string' representando o número em notação em ponto fixo.</dd> + <dt>{{jsxref("Number.prototype.toLocaleString()")}}</dt> + <dd>Retorna uma 'string' com uma representação sensível ao idioma deste número. Substitui o método {{jsxref("Object.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("Number.prototype.toPrecision()")}}</dt> + <dd>Retorna uma 'string' representando o número para uma precisão específica em notação ponto fixo ou exponencial.</dd> + <dt>{{jsxref("Number.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Retorna uma objeto literal representando um objeto específicado {{jsxref("Number")}}; você pode usar este valor para criar um novo objeto. Substitui o método {{jsxref("Object.prototype.toSource()")}}.</dd> + <dt>{{jsxref("Number.prototype.toString()")}}</dt> + <dd>Retorna uma 'string' representando o objeto especificado na raiz especificada (base). Substitui o método {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("Number.prototype.valueOf()")}}</dt> + <dd>Retorna o valor primitivo do objeto especificado. Substitui o método {{jsxref("Object.prototype.valueOf()")}}.</dd> +</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ários</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado em JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4', 'Number')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-the-number-prototype-object', 'Number')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-properties-of-the-number-prototype-object', 'Number')}}</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>Configuração</th> + <th>Chrome</th> + <th>Edge</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> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Configuração</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</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> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Number")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/toexponential/index.html b/files/pt-br/web/javascript/reference/global_objects/number/toexponential/index.html new file mode 100644 index 0000000000..743a4b32b0 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/toexponential/index.html @@ -0,0 +1,149 @@ +--- +title: Number.prototype.toExponential() +slug: Web/JavaScript/Reference/Global_Objects/Number/toExponential +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toExponential()</code></strong> retorna uma string representando o objeto {{jsxref("Global_Objects/Number", "Number")}} por meio de notação exponencial.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toExponential([<var>fractionDigits</var>])</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>fractionDigits</code></dt> + <dd>Optional. An integer specifying the number of digits after the decimal point. Defaults to as many digits as necessary to specify the number.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>A string representing the given {{jsxref("Number")}} object in exponential notation with one digit before the decimal point, rounded to <code>fractionDigits</code> digits after the decimal point.</p> + +<h3 id="Exceptions">Exceptions</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>If <code>fractionDigits</code> is too small or too large. Values between 0 and 20, inclusive, will not cause a {{jsxref("RangeError")}}. Implementations are allowed to support larger and smaller values as well.</dd> + <dt>{{jsxref("TypeError")}}</dt> + <dd>If this method is invoked on an object that is not a {{jsxref("Number")}}.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>If the <code>fractionDigits</code> argument is omitted, the number of digits after the decimal point defaults to the number of digits necessary to represent the value uniquely.</p> + +<p>If you use the <code>toExponential()</code> method for a numeric literal and the numeric literal has no exponent and no decimal point, leave whitespace(s) before the dot that precedes the method call to prevent the dot from being interpreted as a decimal point.</p> + +<p>If a number has more digits than requested by the <code>fractionDigits</code> parameter, the number is rounded to the nearest number represented by <code>fractionDigits</code> digits. See the discussion of rounding in the description of the {{jsxref("Number.prototype.toFixed", "toFixed()")}} method, which also applies to <code>toExponential()</code>.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_toExponential">Using <code>toExponential</code></h3> + +<pre class="brush: js">var numObj = 77.1234; + +console.log(numObj.toExponential()); // logs 7.71234e+1 +console.log(numObj.toExponential(4)); // logs 7.7123e+1 +console.log(numObj.toExponential(2)); // logs 7.71e+1 +console.log(77.1234.toExponential()); // logs 7.71234e+1 +console.log(77 .toExponential()); // logs 7.7e+1 +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition. Implemented in JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.6', 'Number.prototype.toExponential')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<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>{{CompatVersionUnknown}}</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>Edge</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> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/tofixed/index.html b/files/pt-br/web/javascript/reference/global_objects/number/tofixed/index.html new file mode 100644 index 0000000000..1b64e75c82 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/tofixed/index.html @@ -0,0 +1,99 @@ +--- +title: Number.prototype.toFixed() +slug: Web/JavaScript/Reference/Global_Objects/Number/toFixed +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toFixed +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toFixed()</code></strong> formata um número utilizando notação de ponto fixo.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toFixed([<var>dígitos</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>dígitos</code></dt> + <dd>Opcional. O número de dígitos que aparecem depois do ponto decimal; este pode ser um valor entre 0 e 20, inclusive, e algumas implementacões podem suportar uma variação de números maiores. Se este argumento for omitido, será tratado como 0. </dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>Uma string representando o número usando notação em ponto fixo.</p> + +<h3 id="Throws">Throws</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Se <code>dígitos</code> for muito pequeno ou muito grande. Valores entre 0 e 20, inclusive, não irão causar o {{jsxref("RangeError")}}. É permitido às implementações suportar valores maiores e menores.</dd> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Se este método for chamado em um objeto que não é {{jsxref( "Number")}}.</dd> +</dl> + + +<h2 id="Descrição">Descrição</h2> +<p>Uma string representando <code>numObj</code> que não usa notação exponencial e tem exatamente <code>dígitos</code> dígitos depois da casa decimal. O número será arredondado se necessário, e será adicionado zeros a parte após a virgula para que este tenha o tamanho que foi especificado. Se o <code>numObj</code> for maior que <code>1e+21</code>, entao será invocado o método {{jsxref("Number.prototype.toString()")}} e será retornado uma string em notação exponencial.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Utilizando_toFixed">Utilizando <code>toFixed</code></h3> + +<pre class="brush: js">var numObj = 12345.6789; + +numObj.toFixed(); // Retorna '12346': note o arredondamento, não possui nenhuma parte fracionária +numObj.toFixed(1); // Retorna '12345.7': note o arredondamento +numObj.toFixed(6); // Retorna '12345.678900': note que adicionou zeros +(1.23e+20).toFixed(2); // Retorna '123000000000000000000.00' +(1.23e-10).toFixed(2); // Retorna '0.00' +2.34.toFixed(1); // Retorna '2.3' +2.35.toFixed(1); // Retorna '2.4'. Note que arredonda para cima neste caso. +-2.34.toFixed(1); // Retorna -2.3 (devido à precedência do operador, literais de números negativos não retornam uma string...) +(-2.34).toFixed(1); // Retorna '-2.3' (...a menos que se utilize parênteses) +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição incial. Implementada no JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.5', 'Number.prototype.toFixed')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +{{Compat("javascript.builtins.Number.toFixed")}} + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/tolocalestring/index.html b/files/pt-br/web/javascript/reference/global_objects/number/tolocalestring/index.html new file mode 100644 index 0000000000..d4ced2ffff --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/tolocalestring/index.html @@ -0,0 +1,176 @@ +--- +title: Number.prototype.toLocaleString() +slug: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString +tags: + - Internacionalização + - JavaScript + - Método(2) + - Number + - Número + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toLocaleString()</code></strong> retorna uma string com uma representação sensível a linguagem deste número.</p> + +<p>Os novos argumentos <code>locales</code> e <code>options</code> permitem às aplicações especificar a linguagem cujas convenções de formatações serão utilizadas e personalizar o comportamento da função. Nas implementações anteriores, que ignorava os argumentos <code>locales</code> e <code>options</code> arguments, a localização utilizada e a forma de retornar a string erão totalmente dependente da implementação.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>numObj</em>.toLocaleString(</code><code>[locales [, options]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<p>Dê uma olhada na seção <a href="#Browser_compatibility">Compatibilidade do Navegador</a> para verificar quais navegadores suportam os argumentos <code>locales</code> e <code>options</code>, e o <a href="#">Exemplo: Verificando o suporte dos argumentos <code>locales</code> e <code>options</code></a> para detecção desta característica.</p> + +<div class="note"> +<p><strong>Nota:</strong> ECMAScript Internationalization API, implementada com o Firefox 29, incluiu o argumento <code>locales</code> ao método <code>Number.toLocaleString()</code>. Se o argumento for {{jsxref("undefined")}}, este método retorna os dígitos de localização especificados pelo SO, enquanto que as versões anteriores doFirefox retornavam os dígitos<a href="https://en.wikipedia.org/wiki/Arabic_numerals"> Árabe Ocidental</a>. Esta mudança foi relatada como uma regressão que afeta a retrocompatibilidade que será corrigida em breve. ({{bug(999003)}})</p> +</div> + +<div>{{page('pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat', 'Parâmetros')}}</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toLocaleString">Usando <code>toLocaleString</code></h3> + +<p>No uso básico sem a especificação de uma localização, o método retornará uma string formatada com a localização e as opções padrão.</p> + +<pre class="brush: js">var numero = 3500; + +console.log(numero.toLocaleString()); // Mostra "3,500" se a localização for U.S. English +</pre> + +<h3 id="Verificando_o_suporte_dos_argumentos_locales_e_options">Verificando o suporte dos argumentos <code>locales</code> e <code>options</code></h3> + +<p>Os argumentos <code>locales</code> e <code>options</code> não são suportados por todos os navegadores ainda. Para verificar pelo suporte das implementações do ES5.1 e posteriores, a requisição de tags de linguagem ilegais são rejeitadas com uma exceção {{jsxref("Global_Objects/RangeError", "RangeError")}} pode ser usada da seguinte forma:</p> + +<pre class="brush: js">function toLocaleStringSupportsLocales() { + var numero = 0; + try { + numero.toLocaleString('i'); + } catch (e) { + return e.name === 'RangeError'; + } + return false; +} +</pre> + +<p>Antes da ES5.1, implementações que não exigiam um tratamento de erro se <code>toLocaleString</code> fosse chamada com argumentos.</p> + +<p>Uma verificação que funciona em todos os casos, incluindo aqueles que suportam ECMA-262 antes da edição 5.1, é testar pelas especificações de característicadas da ECMA-402 que exigem suporte de opções regionais para <code>Number.prototype.toLocaleString</code> diretamente:</p> + +<pre class="brush: js">function toLocaleStringSupportsOptions() { + return !!(typeof Intl == 'object' && Intl && typeof Intl.NumberFormat == 'function'); +} +</pre> + +<p>Estes testes para um objeto <code>Intl</code> global, verifica se ele não é <code>null</code> e se uma propriedade <code>NumberFormat</code> é uma função.</p> + +<h3 id="Usando_locales">Usando <code>locales</code></h3> + +<p>Este exemplo mostra algumas variações de formatos de números localizados. A fim de obter o formato da linguagem utilizada na interface do usuário da sua aplicação, tenha certeza de especificar a língua (e possivelmente algumas línguas reservas) usando o argumento<code> locales</code>:</p> + +<pre class="brush: js">var numero = 123456.789; + +// O alemão usa vírgula como separador de decimal e ponto para milhares +console.log(numero.toLocaleString('de-DE')); +// → 123.456,789 + +// O árabe usa dígitos <a href="https://en.wikipedia.org/wiki/Eastern_Arabic_numerals">Árabes Orientais</a> em muitos países que falam árabe +console.log(numero.toLocaleString('ar-EG')); +// → ١٢٣٤٥٦٫٧٨٩ + +// A Índia usa separadores de milhares/cem mil/dez milhões +console.log(numero.toLocaleString('en-IN')); +// → 1,23,456.789 + +// A chave de extensão nu requer um sistema de numeração, ex. decimal chinês +console.log(numero.toLocaleString('zh-Hans-CN-u-nu-hanidec')); +// → 一二三,四五六.七八九 + +// Quando informada uma língua sem suporte, como balinês, +// inclua uma língua reseva, neste caso indonésio +console.log(numero.toLocaleString(['ban', 'id'])); +// → 123.456,789 +</pre> + +<h3 id="Usando_options">Usando <code>options</code></h3> + +<p>Os resultados obtidos por <code>toLocaleString</code> pode ser personalizado usando o argumento<code> options</code>:</p> + +<pre class="brush: js">var numero = 123456.789; + +// informando um formato de moeda +console.log(numero.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' })); +// → 123.456,79 € + +// o yen japonês não tem uma unidade menor +console.log(numero.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' })) +// → ￥123,457 + +// limitando a três dígitos significativos +console.log(numero.toLocaleString('en-IN', { maximumSignificantDigits: 3 })); +// → 1,23,000 +</pre> + +<h2 id="Desempenho">Desempenho</h2> + +<p>Quando formatar uma grande quantidade de números, é melhor criar um objeto {{jsxref("NumberFormat")}} e usar a função fornecida pela propriedade {{jsxref("NumberFormat.format")}}.</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.3', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 1.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int 1.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int 2.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int 2.0')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sec-Number.prototype.toLocaleString', 'Number.prototype.toLocaleString')}}</td> + <td>{{Spec2('ES Int Draft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2> + +<p>{{Compat("javascript.builtins.Number.toLocaleString")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/toprecision/index.html b/files/pt-br/web/javascript/reference/global_objects/number/toprecision/index.html new file mode 100644 index 0000000000..643a0b9a08 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/toprecision/index.html @@ -0,0 +1,104 @@ +--- +title: Number.prototype.toPrecision() +slug: Web/JavaScript/Reference/Global_Objects/Number/toPrecision +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toPrecision +--- +<div>{{JSRef}}</div> + +<div></div> + +<p>O método <strong><code>toPrecision()</code></strong> retorna uma string que representa o valor do objeto {{jsxref("Number")}} com uma precisão específica.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-toprecision.html")}}</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><var>numObj</var>.toPrecision([<var>precisão</var>])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>precisão</code></dt> + <dd>Opcional. Um inteiro especificando o número de algarismos significativos.</dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>Uma string representando um objeto {{jsxref("Number")}} em notação de ponto fixo ou exponencial arredondada segundo o parâmetro <code>precisão</code>. Veja a discussão sobre arredondamento feita na documentação do método {{jsxref("Number.prototype.toFixed()")}}, que também se aplica ao método <code>toPrecision()</code>.</p> + +<p>Se o parâmetro <code>precisão</code> for omitido, este método terá o mesmo comportamento de {{jsxref("Number.prototype.toString()")}}. Se o parâmetro <code>precisão</code> for um valor não inteiro, ele será arredondado para a sua representação mais próxima em inteiro.</p> + +<h3 id="Exceções">Exceções</h3> + +<dl> + <dt>{{jsxref("Global_Objects/RangeError", "RangeError")}}</dt> + <dd>Se o valor de <code>precisão</code> não estiver compreendido entre 1 e 100 (inclusive), um {{jsxref("RangeError")}} será lançado. É permitido às implementações suportar valores menores e maiores que esses, sendo um requisito do ECMA-262 que seja dado suporte a uma precisão de até 21 algarismos significativos.</dd> +</dl> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Utilizando_toPrecision">Utilizando <code>toPrecision</code></h3> + +<pre class="brush: js">var numObj = 5.123456; + +console.log(numObj.toPrecision()); // logs '5.123456' +console.log(numObj.toPrecision(5)); // logs '5.1235' +console.log(numObj.toPrecision(2)); // logs '5.1' +console.log(numObj.toPrecision(1)); // logs '5' + +numObj = 0.000123 + +console.log(numObj.toPrecision()); // logs '0.000123' +console.log(numObj.toPrecision(5)); // logs '0.00012300' +console.log(numObj.toPrecision(2)); // logs '0.00012' +console.log(numObj.toPrecision(1)); // logs '0.0001' + +// observe que a notação exponencial pode ser retornado em alguns casos +console.log((1234.5).toPrecision(2)); // logs '1.2e+3' +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial. Implementada no JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.7', 'Number.prototype.toPrecision')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.toprecision', 'Number.prototype.toPrecision')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.toprecision', 'Number.prototype.toPrecision')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2> + +<p class="hidden">A tabela de compatibilidade nesta página foi gerada a partir de dados estruturados. Se você quiser contribuir para a base de 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 envie-nos sua requisição.</p> + +<p>{{Compat("javascript.builtins.Number.toPrecision")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/number/tosource/index.html new file mode 100644 index 0000000000..8d10118b0a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/tosource/index.html @@ -0,0 +1,48 @@ +--- +title: Number.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Number/toSource +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>O método <strong><code>toSource()</code></strong> retorna uma string contendo o código fonte do objeto.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>numObj</var>.toSource() +Number.toSource()</pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo 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> + +<p>Para o objeto built-in {{jsxref("Number")}}, o método <code>toSource()</code> retorna a seguinte string indicando que o código fonte do objeto não está disponível:</p> + +<pre class="brush: js">function Number() { + [native code] +} +</pre> + +<p>Para instâncias do objeto {{jsxref("Number")}}, <code>toSource()</code> retorna uma string contendo o código fonte.</p> + +<p>Este método normalmente é invocado internamente pelo JavaScript e não explicitamente em um código web.</p> + +<h2 id="Especificações">Especificações</h2> + +<p>Não é parte de nenhuma especificação padrão. Implementado no JavaScript 1.3.</p> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Number.toSource")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/number/tostring/index.html new file mode 100644 index 0000000000..6ebd43e978 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/tostring/index.html @@ -0,0 +1,143 @@ +--- +title: Number.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Number/toString +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toString +--- +<div>{{JSRef("Global_Objects", "Number")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <strong><code>toString()</code></strong> retorna uma string representando o objeto {{jsxref("Global_Objects/Number", "Number")}} especificado.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toString([<var>radix</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>radix</code></dt> + <dd>Opcional. Um inteiro entre 2 e 36 especificando a base utilizada para representar os valores numéricos.</dd> +</dl> + +<h3 id="Throws" name="Throws">Exceções</h3> + +<dl> + <dt>{{jsxref("Global_Objects/RangeError", "RangeError")}}</dt> + <dd>se <code>toString()</code> receber um valor de radix fora do intervalo entre 2 e 36, uma exceção {{jsxref("Global_Objects/RangeError", "RangeError")}} é lançada.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>O objeto {{jsxref("Global_Objects/Number", "Number")}} sobrescreve o método <code>toString()</code> do objeto {{jsxref("Global_Objects/Object", "Object")}}; ele não herda de {{jsxref("Object.prototype.toString()")}}. Para objetos {{jsxref("Global_Objects/Number", "Number")}}, o método <code>toString()</code> retorna uma representação string do objeto na base especificada.</p> + +<p>O método <code>toString()</code> analisa seu primeiro argumento e tenta retornar uma representação string na raiz (base) especificada. Para raizes maiores que 10, as letras do alfabeto indicam valores maiores que 9. Por exemplo, para números hexadecimais (base 16), letras entre <code>a</code> e <code>f</code> são utilizadas.</p> + +<p>Se o <code>radix</code> não for especificado, a raiz assumida como preferencial é a 10.</p> + +<p>Se o <code>numObj</code> for negativo, o sinal é preservado. Isto acontece mesmo se a raiz for 2; a string retornada é a representação binária positiva de <code>numObj</code> precedida por um sinal <code>- e</code> <strong>não</strong> o complemento de dois do <code>numObj</code>.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Using_toString" name="Example:_Using_toString">Exemplo: Usando <code>toString</code></h3> + +<pre class="brush: js">var count = 10; + +console.log(count.toString()); // displays '10' +console.log((17).toString()); // displays '17' + +var x = 6; + +console.log(x.toString(2)); // displays '110' +console.log((254).toString(16)); // displays 'fe' + +console.log((-10).toString(2)); // displays '-1010' +console.log((-0xff).toString(2)); // displays '-11111111' +</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>ECMAScript 1ª edição.</td> + <td>Standard</td> + <td>Definição inicial. Implementado no JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.2', 'Number.prototype.tostring')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.tostring', 'Number.prototype.tostring')}}</td> + <td>{{Spec2('ES6')}}</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>{{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("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/number/valueof/index.html b/files/pt-br/web/javascript/reference/global_objects/number/valueof/index.html new file mode 100644 index 0000000000..7406994df7 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/number/valueof/index.html @@ -0,0 +1,80 @@ +--- +title: Number.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/Number/valueOf +translation_of: Web/JavaScript/Reference/Global_Objects/Number/valueOf +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>valueOf()</code></strong> retorna o valor primitivo contido no objeto {{jsxref("Number")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/number-valueof.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><var>numObj</var>.valueOf()</pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um número representando o valor primitivo do objeto {{jsxref("Number")}}.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Este método normalmente é invocado internamente pelo JavaScript e não explicitamente em um código web.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Utilizando_valueOf">Utilizando <code>valueOf</code></h3> + +<pre class="brush: js">var numObj = new Number(10); +console.log(typeof numObj); // object + +var num = numObj.valueOf(); +console.log(num); // 10 +console.log(typeof num); // number +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementada no JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.4', 'Number.prototype.valueOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.valueof', 'Number.prototype.valueOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-number.prototype.valueof', 'Number.prototype.valueOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Number.valueOf")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Number.prototype.toSource()")}}</li> +</ul> 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() > 0.5 ? 'foo' : 'bar'; + } +}; + + +// Non-standard and deprecated way +obj.__lookupGetter__('foo'); +// (function() { return Math.random() > 0.5 ? 'foo' : 'bar'; }) + + +// Standard-compliant way +Object.getOwnPropertyDescriptor(obj, "foo").get; +// (function() { return Math.random() > 0.5 ? 'foo' : 'bar'; }) +</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 => { + Object.defineProperties(target, Object.keys(source).reduce((descriptors, key) => { + descriptors[key] = Object.getOwnPropertyDescriptor(source, key); + return descriptors; + }, {})); + }); + return target; +} + +var copy = myAssign({}, obj); +console.log(copy); +// { foo:1, get bar() { return 2 } } +</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 < arguments.length; i++) { + var nextSource = arguments[i]; + if (nextSource === undefined || nextSource === null) { + continue; + } + nextSource = Object(nextSource); + + var keysArray = Object.keys(Object(nextSource)); + for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) { + var nextKey = keysArray[nextIndex]; + var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey); + if (desc !== undefined && desc.enumerable) { + to[nextKey] = nextSource[nextKey]; + } + } + } + return to; + } + }); +} +</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 < 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 > 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) && typeof g !== 'undefined') + throw new TypeError('bad get'); + d.get = g; + } + if (hasProperty(desc, 'set')) { + var s = desc.set; + if (!isCallable(s) && typeof s !== 'undefined') + throw new TypeError('bad set'); + d.set = s; + } + + if (('get' in d || 'set' in d) && ('value' in d || 'writable' in d)) + throw new TypeError('identity-confused descriptor'); + + return d; + } + + if (typeof obj !== 'object' || obj === null) + throw new TypeError('bad obj'); + + properties = Object(properties); + + var keys = Object.keys(properties); + var descs = []; + + for (var i = 0; i < keys.length; i++) + descs.push([keys[i], convertToDescriptor(properties[keys[i]])]); + + for (var i = 0; i < descs.length; i++) + Object.defineProperty(obj, descs[i][0], descs[i][1]); + + return obj; +} +</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]) => { + 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' && 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">> Object.freeze(1) +TypeError: 1 is not an object // ES5 code + +> 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 ]) => [ 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 + ' -> ' + obj[val]); +}); +// logs +// 0 -> a +// 1 -> b +// 2 -> c + +// non-enumerable property +var my_obj = Object.create({}, { + getFoo: { + value: function() { return this.foo; }, + enumerable: false + } +}); +my_obj.foo = 1; + +console.log(Object.getOwnPropertyNames(my_obj).sort()); +// logs ["foo", "getFoo"] +</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 && 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' && (typeof obj !== 'function' || obj === null)) { + throw new TypeError('Object.keys chamado de non-object'); + } + + var result = [], prop, i; + + for (prop in obj) { + if (hasOwnProperty.call(obj, prop)) { + result.push(prop); + } + } + + if (hasDontEnumBug) { + for (i = 0; i < dontEnumsLength; i++) { + if (hasOwnProperty.call(obj, dontEnums[i])) { + result.push(dontEnums[i]); + } + } + } + return result; + }; + }()); +} +</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: <obj>, type: 'add'}] + +obj.foo = 'hello'; +// [{name: 'foo', object: <obj>, type: 'update', oldValue: 0}] + +delete obj.baz; +// [{name: 'baz', object: <obj>, 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> & 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 < 2) { + throw new TypeError('Object.appendChain - Argumentos insuficientes'); + } + if (typeof oProto !== 'object' && 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 && 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()); // ---> 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> diff --git a/files/pt-br/web/javascript/reference/global_objects/parsefloat/index.html b/files/pt-br/web/javascript/reference/global_objects/parsefloat/index.html new file mode 100644 index 0000000000..a2d1ea3c8b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/parsefloat/index.html @@ -0,0 +1,171 @@ +--- +title: parseFloat() +slug: Web/JavaScript/Reference/Global_Objects/parseFloat +translation_of: Web/JavaScript/Reference/Global_Objects/parseFloat +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<p>A função <code><strong>parseFloat()</strong></code><strong> </strong>analisa um argumento string e retorna um número de ponto flutuante.</p> + +<h2 id="Síntaxe">Síntaxe</h2> + +<pre class="syntaxbox">parseFloat(<em>string</em>)</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>string</code></dt> + <dd>Uma string que representa o valor a ser analisado.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p><code>parseFloat</code> é uma função top-level e não está associada a nenhum objeto.</p> + +<p><code>parseFloat</code> analisa um argumento string, e retorna um numero de ponto flutuante. Se ele encontrar <span id="result_box" lang="pt"><span>um carácter diferente de</span> <span>um sinal</span> <span>(</span><span>+</span> <span>ou -)</span></span>, numeral (0-9), um ponto decimal, ou um expoente, e<span id="result_box" lang="pt"><span>le retorna</span> <span>o valor</span> <span>até esse ponto</span> <span>e ignora</span> <span>esse caractere e</span> <span>todos os caracteres</span> <span>seguintes. Espaços a direita e a esquerda s</span></span>ão permitidos.</p> + +<p>Se o primeiro carácter não puder ser convertido para um número, <code>parseFloat</code> retorna <code>NaN</code>.</p> + +<p>Para propósitos aritméticos, o valor <code>NaN</code> não é um número de qualquer raiz. Você pode chamar a função {{jsxref("isNaN")}} para determinar se o resultado do <code>parseFloat</code> é <code>NaN</code>. Se <code>NaN</code> for passado em operações aritméticas, a operação também retornará <code>NaN</code>.</p> + +<p><code>parseFloat</code> também pode analisar e retornar o valor <code>Infinity</code>. Você pode usar a função {{jsxref("isFinite")}} para determinar se a função é um número finito (not <code>Infinity</code>, <code>-Infinity</code>, ou <code>NaN</code>).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="parseFloat_retornando_um_número"><code>parseFloat</code> retornando um número</h3> + +<p>O exemplo a seguir sempre retorna <strong>3.14</strong></p> + +<pre class="brush:js">parseFloat("3.14"); +parseFloat("314e-2"); +parseFloat("0.0314E+2"); +parseFloat("3.14more non-digit characters"); +</pre> + +<h3 id="parseFloat_retornando_NaN"><code>parseFloat</code> retornando NaN</h3> + +<p>O exemplo a seguir retorna <code>NaN</code></p> + +<pre class="brush: js">parseFloat("FF2"); +</pre> + +<h3 id="A_função_stricter_parse">A função stricter parse</h3> + +<p><span id="result_box" lang="pt"><span>As vezes é útil</span> <span>ter uma maneira</span> <span>mais rigorosa</span> <span>para analisar</span> <span>valores float</span><span>,</span> <span>expressões regulares podem</span> <span>ajudar:</span></span></p> + +<pre class="brush: js">var filterFloat = function (value) { + if(/^(\-|\+)?([0-9]+(\.[0-9]+)?|Infinity)$/ + .test(value)) + return Number(value); + return NaN; +} + +console.log(filterFloat('421')); // 421 +console.log(filterFloat('-421')); // -421 +console.log(filterFloat('+421')); // 421 +console.log(filterFloat('Infinity')); // Infinity +console.log(filterFloat('1.61803398875')); // 1.61803398875 +console.log(filterFloat('421e+0')); // NaN +console.log(filterFloat('421hop')); // NaN +console.log(filterFloat('hop1.61803398875')); // NaN + +</pre> + +<p>Observe que este código é somente um exemplo; ele<span id="result_box" lang="pt"> <span>não aceita</span> <span>números válidos</span><span>, tais como</span> <span>1.</span> <span>ou</span> <span>0,5</span><span>.</span></span></p> + +<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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.2.3', 'parseFloat')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-parsefloat-string', 'parseFloat')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-parsefloat-string', 'parseFloat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compátibilidade_nos_navegadores">Compátibilidade 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="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li> + <li>{{jsxref("Number.parseFloat()")}}</li> + <li>{{jsxref("Number.parseInt()")}}</li> + <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/parseint/index.html b/files/pt-br/web/javascript/reference/global_objects/parseint/index.html new file mode 100644 index 0000000000..ba7d40aa86 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/parseint/index.html @@ -0,0 +1,224 @@ +--- +title: parseInt() +slug: Web/JavaScript/Reference/Global_Objects/parseInt +translation_of: Web/JavaScript/Reference/Global_Objects/parseInt +--- +<div>{{jsSidebar("Objects")}}</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>A função <code><strong>parseInt()</strong></code> analisa um argumento <code>string</code> e retorna um inteiro na <code>base</code> especificada.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox">parseInt(<em>string</em>, <em>base</em>);</pre> + +<h2 id="Parameters" name="Parameters">Parâmetros</h2> + +<dl> + <dt><code>string</code></dt> + <dd> + <p>O valor a analisar. Se o argumento <code>string</code> não for uma string, então o valor é convertido para uma string (utilizando a operação abstrata <code><a href="http://www.ecma-international.org/ecma-262/6.0/#sec-tostring">ToString</a></code>). Os espaços em branco na <code>string</code> são ignorados.</p> + </dd> +</dl> + +<dl> + <dt><code>base</code></dt> + <dd>Um inteiro entre 2 e 36 que representa a <em>base</em> da <code>string (</code>sistemas numéricos matemáticos<code>) </code>mencionada no parâmetro anterior. Especifique <code>10</code> para o sistema numérico decimal comumente usado por humanos. <strong>Sempre especifique este parâmetro</strong> para eliminar confusão do leitor e para garantir o comportamento esperado. Implementações diferentes produzem resultados diferentes quando <code>base</code> não é especificado, normalmente assumindo o valor como 10.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Um número inteiro analisado a partir da string fornecida. Se o primeiro caracter não puder ser convertido para um número, {{jsxref("NaN")}} é retornado.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>A função <code>parseInt</code> converte seu primeiro argumento para uma string, analisa, e retorna um inteiro ou <code>NaN</code>. Se não <code>NaN</code>, o valor retornado será a representação decimal inteira do primeiro argumento obtido como um número na base especificada. Por exemplo, uma<em>base</em> 10 indica para converter de um número decimal, 8 octal, 16 hexadecimal, e assim por diante. Para bases acima de <code>10</code>, as letras do alfabeto indicam numerais maiores que <code>9</code>. Por exemplo, para números hexadecimais (base 16), <code>A</code> até <code>F</code> são usados.</p> + +<p>Se <code>parseInt</code> encontrar um caracter que não seja um numeral na base especificada, ele o ignora e a todos os caracteres subsequentes e retorna o valor inteiro analisado até aquele ponto. <code>parseInt</code> trunca números para valores inteiros. Espaços no início e fim são permitidos.</p> + +<p>Se <var>base</var> é <code>undefined</code> ou 0 (ou ausente), JavaScript assume o seguinte:</p> + +<ul> + <li>Se a <code>string</code> de entrada começa com "0x" ou "0X", a <var>base</var> é 16 (hexadecimal) e o restante da string é analisado.</li> + <li>Se a <code>string</code> de entrada começa com "0", a <var>base</var> é oito (octal) ou 10 (decimal). Exatamente qual base é escolhida é dependente da implementação. O ECMAScript 5 especifica que 10 (decimal) seja utilizado, mas nem todos os browsers suportam isso ainda. Por essa razão <strong>sempre especifique uma base quando estiver usando <code>parseInt</code></strong>.</li> + <li>Se a <code>string</code> de entrada começa com qualquer outro valor, a base é 10 (decimal).</li> +</ul> + +<p>Se o primeiro caracter não puder ser convertido para um número, <code>parseInt</code> retorna <code>NaN</code>.</p> + +<p>Para propósitos aritméticos, o valor <code>NaN</code> não é um número em qualquer base. Você pode chamar a função {{jsxref("Global_Objects/isNaN", "isNaN")}} para determinar se o resultado de <code>parseInt</code> é <code>NaN</code>. Se <code>NaN</code> for passado em operações aritméticas, o resultado da operação também será <code>NaN</code>.</p> + +<p>Para converter um número para seu literal string em uma base específica use <code>intValue.toString(base)</code>.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example:_Using_parseInt" name="Example:_Using_parseInt">Exemplo: Usando <code>parseInt</code></h3> + +<p>Os seguintes exemplos sempre retornam <strong><code>15</code></strong>:</p> + +<pre>parseInt(" 0xF", 16); +parseInt(" F", 16); +parseInt("17", 8); +parseInt(021, 8); +parseInt("015", 10); +parseInt(15.99, 10); +parseInt("FXX123", 16); +parseInt("1111", 2); +parseInt("15*3", 10); +parseInt("15e2", 10); +parseInt("15px", 10); +parseInt("12", 13); +</pre> + +<p>Os seguintes exemplos sempre retornam <strong><code>NaN</code></strong>:</p> + +<pre>parseInt("Hello", 8); // Não é realmente um número +parseInt("546", 2); // Dígitos não são válidos para representações binárias +</pre> + +<p>Os seguintes exemplos sempre retornam <strong><code>-15</code></strong>:</p> + +<pre>parseInt("-F", 16); +parseInt("-0F", 16); +parseInt("-0XF", 16); +parseInt(-15.1, 10) +parseInt(" -17", 8); +parseInt(" -15", 10); +parseInt("-1111", 2); +parseInt("-15e1", 10); +parseInt("-12", 13); +</pre> + +<p>O seguinte exemplo retorna <strong><code>224</code></strong>:</p> + +<pre>parseInt("0e0", 16); +</pre> + +<h2 id="Interpretação_octal_sem_informar_a_base">Interpretação octal sem informar a base</h2> + +<p>Embora desencorajado pelo ECMAScript 3 e proibido pelo ECMAScript 5, muitas implementações interpretam uma string numérica começando com um <code>0</code> como octal. O exemplo abaixo pode ter um resultado octal, ou ele pode ter um resultado decimal. <strong>Sempre especifique uma base para evitar este comportamento não confiável.</strong></p> + +<pre>parseInt("0e0"); // 0 +parseInt("08"); // 0, '8' não é um dígito octal. +</pre> + +<h3 id="O_ECMAScript_5_remove_a_interpretação_octal">O ECMAScript 5 remove a interpretação octal</h3> + +<p>A especificação ECMAScript 5 da funcão <code>parseInt</code> não permite mais que as implementações tratem Strings começando com o caracter 0 como um valor octal. O ECMAScript 5 declara:</p> + +<p>A função <code>parseInt</code> produz um valor inteiro ditado pela interpretação do conteúdo de uma argumento string de acordo com uma base específicada. Espaços em branco no início da string são ignorados. Se a base for undefined ou <code>0</code>, ela é assumida como <code>10</code> exceto quando o número começa com os pares de caracter <code>0x</code> or <code>0X</code>, e neste caso a base 16 é assumida. Se a base é <code>16</code>, o número pode também opcionalmente começar com os pares de caracter <code>0x</code> or <code>0X</code>.</p> + +<p>Isto difere do ECMAScript 3, que desencoraja mas permite a interpretação octal.</p> + +<p>Muitas implementações não adotaram este comportamento a partir de 2013, e porque browser antigos devem ser suportados, <strong>sempre especifique uma base</strong>.</p> + +<h2 id="Uma_função_de_análise_mais_rigorosa">Uma função de análise mais rigorosa</h2> + +<p><span id="result_box" lang="pt"><span class="hps">É</span> <span class="hps">útil</span> <span class="hps">em algum momento</span> <span class="hps">ter uma maneira</span> <span class="hps">mais rigorosa</span> <span class="hps">para analisar</span> <span class="hps">valores inteiros</span><span>.</span> <span class="hps">Expressões regulares podem</span> <span class="hps">ajudar:</span></span></p> + +<pre class="brush: js">filterInt = function (value) { + if(/^(\-|\+)?([0-9]+|Infinity)$/.test(value)) + return Number(value); + return NaN; +} + +console.log(filterInt('421')); // 421 +console.log(filterInt('-421')); // -421 +console.log(filterInt('+421')); // 421 +console.log(filterInt('Infinity')); // Infinity +console.log(filterInt('421e+0')); // NaN +console.log(filterInt('421hop')); // NaN +console.log(filterInt('hop1.61803398875')); // NaN +console.log(filterInt('1.61803398875')); // NaN +</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>ECMAScript 1st Edition.</td> + <td>Padrão</td> + <td>Definição inicial</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.2.2', 'parseInt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-parseint-string-radix', 'parseInt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p>{{ CompatibilityTable() }}</p> + +<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>{{ 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>Característica</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> + +<h2 id="See_Also" name="See_Also">Veja também</h2> + +<ul> + <li>{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</li> + <li>{{jsxref("Number.parseFloat()")}}</li> + <li>{{jsxref("Number.parseInt()")}}</li> + <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li> + <li>{{jsxref("Number.toString()")}}</li> + <li>{{jsxref("Object.valueOf")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/all/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/all/index.html new file mode 100644 index 0000000000..eec13d056a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/promise/all/index.html @@ -0,0 +1,245 @@ +--- +title: Promise.all() +slug: Web/JavaScript/Reference/Global_Objects/Promise/all +tags: + - ECMAScript 2015 + - ECMAScript6 + - JavaScript + - Method + - Promise +translation_of: Web/JavaScript/Reference/Global_Objects/Promise/all +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>Promise.all(iterable)</strong></code> retorna uma única {{jsxref("Promise")}} que resolve quando todas as promises no argumento iterável forem resolvidas ou quando o iterável passado como argumento não contém promises. É rejeitado com o motivo da primeira promise que foi rejeitada.</p> + +<p>{{EmbedInteractiveExample("pages/js/promise-all.html")}}</p> + +<div class="hidden"> +<p>A fonte para essa demonstração interativa está em um repositório no GitHub. Se você quiser contribuir para esse projeto de demonstrações iterativas, por favor, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envienos um pull request.</p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>Promise.all(iterable)</var>;</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt>iterable</dt> + <dd>Um objeto <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Iteration_protocols">iterável</a>, como um {{jsxref("Array")}} ou {{jsxref("String")}}.</dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<ul> + <li>Uma {{jsxref("Promise")}}<strong> já resolvida</strong> se o iterável passado for vazio.</li> + <li>Uma {{jsxref("Promise")}} <strong>resolvida assíncronamente</strong> se o iterável passado não conter promises. Nota, Google Chrome 58 retorna uma promise <strong>já resolvida</strong> nesse caso.</li> + <li>Uma {{jsxref("Promise")}} <strong>pendente</strong> em todos os outros casos. Essa promise retornada é então resolvida/rejeitada <strong>assíncronamente</strong> (tão logo a pilha esteja vazia) quando todas as promises no dado iterável forem resolvidas, ou se alguma das promises for rejeitada. Veja o exemplo sobre "Assincronia ou sincronia da Promise.all" abaixo. Os valores retornados estarão na ordem em que as promises foram passadas. independentemente da ordem em que forem concluídas.</li> +</ul> + +<h2 id="Descrição">Descrição</h2> + +<p>Esse método pode ser usado para agregar resultados de várias promises.</p> + +<h3 id="Resolução">Resolução</h3> + +<p>A promise retornada é resolvida com um array contendo <strong>todos</strong> os valores dos iteráveis passados como argumento (como valores que não são promises).</p> + +<ul> + <li>Se um iterável vazio é passado, então esse método retorna (sincronamente) uma promise já resolvida.</li> + <li>Se todas as promises passadas forem resolvidas, ou não forem promises, a promise retornada por <code>Promise.all</code> é resolvida assincronamente.</li> +</ul> + +<h3 id="Rejeição">Rejeição</h3> + +<p>Se qualquer uma das promises passadas for rejeitada, <code>Promise.all</code> assíncronamente é rejeitada com o valor da promise rejeitada, independentemente se outras promises foram resolvidas.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Utilizando_Promise.all">Utilizando Promise.all </h3> + +<p><code>Promise.all</code> espera que todas as promises sejam resolvidas (ou a primeira rejeição).</p> + +<pre class="notranslate"><code class="language-js">var p1 = Promise.resolve(3); +var p2 = 1337; +var p3 = new Promise((resolve, reject) => { + setTimeout(() => { + resolve("foo"); + }, 100); +}); + +Promise.all([p1, p2, p3]).then(valores=> { + console.log(valores); // [3, 1337, "foo"] +});</code> +</pre> + +<p>Se o iterável conter valores que não são promises, eles serão ignorados, mas ainda serão contados no array da promise retornada (se a promise for resolvida):</p> + +<pre class="notranslate"><code class="language-js">// Essa será considerada como se o iterável passado fosse vazio, logo ela será resolvido +var p = Promise.all([1,2,3]); +// Essa será considerada como se o iterável passado contém apenas a promise resolvida com o valor "444", logo ela é resolvida +var p2 = Promise.all([1,2,3, Promise.resolve(444)]); +// Esse será considerada como se o iterável passado contém apenas o valor de rejeição "555" da promise, logo ela é rejeitada +var p3 = Promise.all([1,2,3, Promise.reject(555)]); + +// Utilizando setTimeout para executar código depois que a pilha estiver vazia +setTimeout(function() { + console.log(p); + console.log(p2); + console.log(p3); +}); + +// logs +// Promise { <estado>: "resolvida", <valor>: Array[3] } +// Promise { <estado>: "resolvida", <valor>: Array[4] } +// Promise { <estado>: "rejeitada", <razão>: 555 }</code> +</pre> + +<h3 id="Assincronia_ou_sincronia_da_Promise.all">Assincronia ou sincronia da Promise.all</h3> + +<p>O exemplo a seguir demonstra a assincronia (ou sincronia, se o iterável passado for fazio) de <code>Promise.all</code>:</p> + +<pre class="notranslate"><code class="language-js">// Passamos o argumento como um array de promises que já estão resolvidas para disparar Promise.all a mais rápido possível +var arrayPromisesResolvidas = [Promise.resolve(33), Promise.resolve(44)]; + +var p = Promise.all(arrayPromisesResolvidas); +// Logando imediatamente o valor de p +console.log(p); + +// Utilizando setTimeout para executar código depois que a pilha estiver vazia +setTimeout(function() { + console.log('a pilha está vazia agora'); + console.log(p); +}); + +// logs, em ordem: +// Promise { <estado>: "pendente" } +// a pilha está vazia agora +// Promise { <estado>: "resolvida", <valor>: Array[2] }</code> +</pre> + +<p>A mesma coisa acontece se <code>Promise.all</code> for rejeitada:</p> + +<pre class="notranslate"><code class="language-js">var arrayPromisesMisturadas = [Promise.resolve(33), Promise.reject(44)]; +var p = Promise.all(arrayPromisesMisturadas); +console.log(p); +setTimeout(function() { + console.log('a pilha está vazia agora'); + console.log(p); +}); + +// logs +// Promise { <estado>: "pendente" } +// a pilha está vazia agora +// Promise { <estado>: "rejeitada", <razão>: 44 }</code> +</pre> + +<p>Mas, <code>Promise.all</code> resolve sincromamente <strong>se e somente se</strong> o iterável passado for vazio:</p> + +<pre class="notranslate"><code class="language-js">var p = Promise.all([]); // será resolvida imediatamente +var p2 = Promise.all([1337, "oi"]); // um valor que não é uma promise será ignorado, mas a avaliação será feita assíncronamente +console.log(p); +console.log(p2) +setTimeout(function() { + console.log('a pilha está vazia agora'); + console.log(p2); +}); + +// logs +// Promise { <estado>: "resolvida", <valor>: Array[0] } +// Promise { <estado>: "pendente" } +// a pilha está vazia agora +// Promise { <estado>: "resolvida", <valor>: Array[2] }</code> +</pre> + +<h3 id="Comportamente_de_falhar_rapidamente_de_Promise.all">Comportamente de falhar rapidamente de Promise.all</h3> + +<p><code>Promise.all</code> é rejeitada se qualquer um dos elementos for rejeitado. Por exemplo, se você passar quartro promises que resolvem após um intervalo de tempo e uma promise que rejeita imediatamente, então <code>Promise.all</code> será rejeitada imediatamente.</p> + +<pre class="notranslate"><code class="language-js">var p1 = new Promise((resolve, reject) => { + setTimeout(() => resolve('um'), 1000); +}); +var p2 = new Promise((resolve, reject) => { + setTimeout(() => resolve('dois'), 2000); +}); +var p3 = new Promise((resolve, reject) => { + setTimeout(() => resolve('três'), 3000); +}); +var p4 = new Promise((resolve, reject) => { + setTimeout(() => resolve('quatro'), 4000); +}); +var p5 = new Promise((resolve, reject) => { + reject(new Error('rejeitada')); +}); + + +// Usando .catch: +Promise.all([p1, p2, p3, p4, p5]) +.then(valores => { + console.log(valores); +}) +.catch(erro => { + console.log(erro.message) +}); + +// No console: +// "rejeitada"</code> +</pre> + +<p>É possível mudar esse comportamente lidando com possíveis rejeições:</p> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js">var p1 = new Promise((resolve, reject) => { + setTimeout(() => resolve('p1_resolução_atrasada'), 1000); +}); + +var p2 = new Promise((resolve, reject) => { + reject(new Error('p2_rejeição_imediata')); +}); + +Promise.all([ + p1.catch(erro => { return erro }), + p2.catch(erro => { return erro }), +]).then(valores => { + console.log(valores[0]) // "p1_resolução_atrasada" + console.log(valores[1]) // "Erro: p2_rejeição_imediata" +})</code></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('ES2015', '#sec-promise.all', 'Promise.all')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td> + <p>Definição inicial em um padrão ECMA.</p> + </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-promise.all', 'Promise.all')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</h2> + +<div class="hidden"> +<p>Para contribuir para esse dado de compatibilidade, por favor, escreva um pull request para o repositório: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> +</div> + +<p>{{Compat("javascript.builtins.Promise.all")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Promise")}}</li> + <li>{{jsxref("Promise.race()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/allsettled/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/allsettled/index.html new file mode 100644 index 0000000000..770a4fd3a7 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/promise/allsettled/index.html @@ -0,0 +1,64 @@ +--- +title: Promise.allSettled() +slug: Web/JavaScript/Reference/Global_Objects/Promise/allSettled +translation_of: Web/JavaScript/Reference/Global_Objects/Promise/allSettled +--- +<p>{{JSRef}}</p> + +<p>O método <code><strong>Promise.allSettled()</strong></code> retorna uma promessa que é resolvida após todas as promessas dadas serem resolvidas ou rejeitadas, com um array de objetos que descrevem o resultado de cada promessa.</p> + +<p>É tipicamente usado quando você tem múltiplas tarefas assíncronas que não são dependentes das conclusões umas das outras, ou quando você sempre quer ter o resultado de cada promessa.</p> + +<p>Para comparação, a promessa retornada por {{jsxref("Promise.all()")}} pode ser mais apropriada para tarefas que dependem umas das outras, ou se você precisa que todas as tarefas sejam rejeitadas quando apenas uma é. </p> + +<div>{{EmbedInteractiveExample("pages/js/promise-allsettled.html")}}</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><em>promise</em>.allSettled(<em>iterable</em>);</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>iterable</code></dt> + <dd>Um objeto <a href="/en-US/docs/Web/JavaScript/Guide/iterable">iterável</a>, como um {{jsxref("Array")}}, onde cada membro é uma <code>Promise</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma {{jsxref("Promise")}} <strong>pendente</strong> que vai ser <strong>preenchida assíncronamente</strong> quando todas as promessas na coleção fornecida forem completas, sendo aceitas ou rejeitadas. Quando isso acontecer, é retornado um array contendo um resultado para cada promessa passada como entrada.</p> + +<p>Para cada objeto no array retornado, existe uma string <code>status</code>. Se o status for <code>fulfilled</code>, então o campo <code>value</code> estará presente. Se o status for <code>rejected</code>, então o campo <code>reason</code> estará presente. O valor (value) ou o motivo da falha (reason) refletem o valor com que cada promessa foi completada (ou rejeitada).</p> + +<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><a href="https://tc39.es/proposal-promise-allSettled/"><code>Promise.allSettled()</code> (TC39 Stage 4 Draft)</a></td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<p class="hidden">Para contribuir com os dados de compatibilidae, por favor faça um pull request nesse repositório: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Promise.allSettled")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Archive/Add-ons/Techniques/Promises">Promessas</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Using_promises">Usando promessas</a></li> + <li><a href="/en-US/docs/Learn/JavaScript/Asynchronous/Promises">Programando assincronamente de maneira elegante usando promessas</a></li> + <li>{{jsxref("Promise")}}</li> + <li>{{jsxref("Promise.all()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/catch/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/catch/index.html new file mode 100644 index 0000000000..a39d4576d7 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/promise/catch/index.html @@ -0,0 +1,138 @@ +--- +title: Promise.prototype.catch() +slug: Web/JavaScript/Reference/Global_Objects/Promise/catch +translation_of: Web/JavaScript/Reference/Global_Objects/Promise/catch +--- +<div>{{JSRef}}</div> + +<div>O método <strong>catch()</strong> retorna uma Promise e lida apenas com casos rejeitados. Ele possui o mesmo comportamento de quando chamamos {{jsxref("Promise.then", "Promise.prototype.then(undefined, onRejected)")}} (de fato, chamando <code>obj.catch(onRejected)</code> internamente é chamado <code>obj.then(undefined, onRejected)</code>).</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>p.catch(onRejected)</var>; + +p.catch(function(motivo) { + // rejeição +}); +</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt>onRejected</dt> + <dd>Uma {{jsxref("Function")}} chamada quando a <code>Promise</code> é rejeitada. Esta função possui um argumento:<br> + <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);"><strong>reason</strong></span></font> da rejeição.<br> + O motivo da rejeição.<br> + <br> + A Promise retornada pelo <code>catch()</code> é rejeitada apenas se <code>onRejected</code> cospe um erro ou se o o retorno da Promise foi rejeitada por si mesmo, ou seja, foi resolvida.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Internamente chamamos <code>Promise.prototype.then</code> sobre o objeto que é chamando passando parâmetros como <code>undefined</code> e <code>onRejected</code> no manipulador de eventos. Então retornamos o valor da chamada que é {{jsxref("Promise")}}.</p> + +<div class="warning"> +<p>O exemplo abaixo está cuspindo uma string. Isso é considerado uma má prática. Sempre cuspir uma instance de erro (Error). Em todo caso, a parte que faz a captura deve fazer verificaçoes sobre os argumentos para saber se é uma string ou um erro e você poderá perder informações valiosas como stack traces.</p> +</div> + +<p><strong>Demonstração de uma camada interna:</strong></p> + +<pre class="brush: js notranslate">// Sobrescrevendo o techo original de Promise.prototype.then/catch adicionando alguns logs +(function(Promise){ + var originalThen = Promise.prototype.then; + var originalCatch = Promise.prototype.catch; + + Promise.prototype.then = function(){ + console.log('> > > > > > chamando .then em %o com argumentos: %o', this, arguments); + return originalThen.apply(this, arguments); + }; + Promise.prototype.catch = function(){ + console.log('> > > > > > chamando .catch em %o com argumentos: %o', this, arguments); + return originalCatch.apply(this, arguments); + }; + +})(this.Promise); + + +// chamando um catch em uma Promise já resolvida. +Promise.resolve().catch(function XXX(){}); + +// logs: +// > > > > > > chamando .catch na Promise{} com os argumentos: Arguments{1} [0: function XXX()] +// > > > > > > chamando .then na Promise{} com os argumentos: Arguments{2} [0: undefined, 1: function XXX()]</pre> + +<h2 id="Description">Description</h2> + +<p>O método <code>catch</code> pode ser útil para manipulação de erros na composição da sua promise.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_método_catch">Usando o método <code>catch</code></h3> + +<pre class="brush: js notranslate">var p1 = new Promise(function(resolve, reject) { + resolve('Sucesso'); +}); + +p1.then(function(value) { + console.log(value); // "Sucesso!" + throw 'Ah, não!'; +}).catch(function(e) { + console.log(e); // "Ah, não!" +}).then(function(){ + console.log('Após um catch, a sequencia é restaurada'); +}, function () { + console.log('Não engatilhado devido ao catch'); +}); + +// O seguinte se comporta da mesma maneira que o anterior +p1.then(function(value) { + console.log(value); // "Sucesso!" + return Promise.reject('Ah, não!'); +}).catch(function(e) { + console.log(e); // "Ah, não!" +}).then(function(){ + console.log('Após um catch, a sequencia é restaurada'); +}, function () { + console.log('Não engatilhado devido ao catch'); +}); + +</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-promise.prototype.catch', 'Promise.prototype.catch')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition in an ECMA standard.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-promise.prototype.catch', 'Promise.prototype.catch')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2> + + + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Promise.catch")}}</p> + + + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Promise")}}</li> + <li>{{jsxref("Promise.prototype.then()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/finally/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/finally/index.html new file mode 100644 index 0000000000..59dff0a6cf --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/promise/finally/index.html @@ -0,0 +1,100 @@ +--- +title: Promise.prototype.finally() +slug: Web/JavaScript/Reference/Global_Objects/Promise/finally +tags: + - JavaScript + - Promises + - Referencia + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Promise/finally +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>finally()</strong></code> retorna uma {{jsxref("Promise")}}. Quando a promise for estabelecida, tenha ela sido realizada ou rejeitada, executa-se a função callback especificada. Isso permite a execução de um código que acontecerá independentemente da <code>Promise</code> ter sido realizada (com sucesso) ou rejeitada (com falha).</p> + +<p>Assim, você pode evitar a duplicação do código em ambos os handlers {{jsxref("Promise.then", "then()")}} e {{jsxref("Promise.catch", "catch()")}} da <code>Promise</code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><var>p.finally(quandoEstabelecida)</var>; + +p.finally(function() { + // concluída (realizada ou rejeitada) +}); +</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>quandoEstabelecida</code></dt> + <dd>Uma {{jsxref("Function")}} chamada quando a <code>Promise</code> é concluída.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Retorna uma {{jsxref("Promise")}} onde o manipulador <code>finally</code> é definido como a função especificada, <code>quandoEstabelecida</code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>finally()</code> pode ser útil quando você deseja realizar algum tipo de processamento ou limpeza quando a promise for estabelecida, independentemente de seu resultado (sucesso ou falha).</p> + +<p>O método <code>finally()</code> é bastante similar a chamar <code>.then(quandoEstabelecida, quandoEstabelecida)</code>. Porém, existem algumas diferenças:</p> + +<ul> + <li>Ao passar a função na linha (entre os parênteses do método), você precisa passá-la apenas uma vez, ao invés de ser forçado a declará-la duas vezes ou a definir em uma variável.</li> + <li>O callback de <code>finally</code> não poderá receber nenhum argumento, já que não existem meios confiáveis de determinar se a promise foi realizada ou rejeitada. Seu uso é para quando você realmente <em>não se importa</em> com os possíveis motivos de uma falha ou possíveis valores retornados de um sucesso, não tendo, portanto, razão para fornecê-los.</li> + <li>Diferentemente de <code>Promise.resolve(2).then(() => {}, () => {})</code> (será resolvido como <code>undefined</code>), <code>Promise.resolve(2).finally(() => {})</code> será resolvido como <code>2</code>.</li> + <li>De maneira semelhante, diferentemente de <code>Promise.reject(3).then(() => {}, () => {})</code> (que será resolvido como <code>undefined</code>), <code>Promise.reject(3).finally(() => {})</code> será rejeitado como <code>3</code>.</li> +</ul> + +<div class="note"> +<p><strong>Nota:</strong> Um <code>throw</code> (ou retorno de uma promise rejeitada) no callback de <code>finally</code> rejeitará a nova promise com a razão de rejeição especificada na chamada de <code>throw()</code>.</p> +</div> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js">let carregando = true; + +fetch(minhaRequisicao).then(function(resposta) { + var tipoConteudo = response.headers.get("content-type"); + if(tipoConteudo && tipoConteudo.includes("application/json")) { + return resposta.json(); + } + throw new TypeError("Opa, isso não é JSON!"); + }) + .then(function(json) { /* processamento do seu JSON */ }) + .catch(function(erro) { console.log(erro); }) + .finally(function() { carregando = false; }); + +</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><a href="https://github.com/tc39/proposal-promise-finally">TC39 proposal</a></td> + <td>Stage 4</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2> + +<p class="hidden">To contribute to this compatibility data, please write a pull request against this repository: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Promise.finally")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Promise")}}</li> + <li>{{jsxref("Promise.prototype.then()")}}</li> + <li>{{jsxref("Promise.prototype.catch()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/index.html new file mode 100644 index 0000000000..d3d0e76322 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/promise/index.html @@ -0,0 +1,174 @@ +--- +title: Promise +slug: Web/JavaScript/Reference/Global_Objects/Promise +tags: + - ECMAScript6 + - JavaScript + - Promise +translation_of: Web/JavaScript/Reference/Global_Objects/Promise +--- +<div>{{JSRef("Global_Objects", "Promise")}}</div> + +<p><strong><code>Promise</code></strong> é um objeto usado para processamento assíncrono. Um <code>Promise</code> (<em>de "promessa"</em>) representa um valor que pode estar disponível agora, no futuro ou nunca.</p> + +<div class="note"> +<p><strong>Nota:</strong> Esse artigo descreve o construtor <code>Promise,</code>os métodos e propriedades de tais objetos. Para aprender sobre como promises funcionam e como utilizá-los, é aconselhavel a leitura de <a href="/pt-BR/docs/Web/JavaScript/Guide/Usando_promises">utilizando promises</a>. O construtor é utilizado para embrulhar funções sem suporte ao conceito "promise".</p> +</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Uma <code><strong>Promise</strong></code> representa um proxy para um valor que não é necessariamente conhecido quando a promessa é criada. Isso permite a associação de métodos de tratamento para eventos da ação assíncrona num caso eventual de sucesso ou de falha. Isto permite que métodos assíncronos retornem valores como métodos síncronos: ao invés do valor final, o método assíncrono retorna uma <em>promessa</em> ao valor em algum momento no futuro.</p> + +<p>Um <strong><code>Promise</code></strong> está em um destes estados: </p> + +<ul> + <li><em>pending (</em>pendente<em>)</em>: Estado inicial, que não foi realizada nem rejeitada.</li> + <li><em>fulfilled (</em>realizada): sucesso na operação.</li> + <li><em>rejected (</em>rejeitado): falha na operação.</li> +</ul> + +<p>Uma promessa pendente pode se tornar <em>realizada</em> com um valor ou <em>rejeitada</em> por um motivo (erro). Quando um desses estados ocorre, o método <code>then</code> do <code>Promise</code> é chamado, e ele chama o método de tratamento associado ao estado (<code>rejected</code> ou <code>resolved</code>). Se a promessa foi realizada ou rejeitada quando o método de tratamento correspondente for associado, o método será chamado, deste forma não há uma condição de competição entre uma operação assíncrona e seus manipuladores que estão sendo associados.</p> + +<p>Como os métodos <code>Promise.prototype.then</code> e <code>Promise.prototype.catch</code> retornam promises, eles podem ser encadeados — uma operação chamada <em>composição</em>.</p> + +<p><img alt="" src="https://mdn.mozillademos.org/files/8633/promises.png" style="height: 297px; width: 801px;"></p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>Promise.length</code></dt> + <dd>Propriedade length cujo valor é sempre 1 (número de argumentos do método construtor).</dd> + <dt>{{jsxref("Promise.prototype")}}</dt> + <dd>Representa o protótipo para o método construtor da <code>Promise</code>.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("Promise.all", "Promise.all(lista)")}}</dt> + <dd>Retorna uma promise que é resolvida quando todas as promises no argumento <em>lista</em> forem resolvidas ou rejeitada assim que uma das promises da lista for rejeitada. Se a promise retornada for resolvida, ela é resolvida com um array dos valores das promises resolvidas da lista. Se a promise for rejeitada, ela é rejeitada com o motivo da primeira promise que foi rejeitada na lista. Este método pode ser útil para agregar resultados de múltiplas promises.</dd> + <dt>{{jsxref("Promise.race", "Promise.race(lista)")}}</dt> + <dd>Retorna uma promise que resolve ou rejeita assim que uma das promises do argumento lista resolve ou rejeita, com um valor ou o motivo daquela promise.</dd> +</dl> + +<dl> + <dt>{{jsxref("Promise.reject", "Promise.reject(motivo)")}}</dt> + <dd>Retorna um objeto <code>Promise</code> que foi rejeitado por um dado motivo.</dd> +</dl> + +<dl> + <dt>{{jsxref("Promise.resolve", "Promise.resolve(valor)")}}</dt> + <dd>Retorna um objeto <code>Promise</code> que foi resolvido com um dado valor. Se o valor é <code>thenable</code> (possui um método <code>then</code>), a promise retornada "seguirá" este método, adotando esse estado eventual; caso contrário a promise retornada será realizada com o valor. Geralmente, se você quer saber se um valor é uma promise ou não, utilize {{jsxref("Promise.resolve", "Promise.resolve(valor)")}} e trabalhe com a valor de retorno que é sempre uma promise.</dd> +</dl> + +<h2 id="Protótipo_Promise">Protótipo Promise</h2> + +<h3 id="Propriedades_2">Propriedades</h3> + +<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Propriedades')}}</p> + +<h3 id="Métodos_2">Métodos</h3> + +<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Métodos')}}</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Criando_uma_Promise">Criando uma Promise</h3> + +<pre class="brush: html notranslate" style="display: none;"><button id="btn">Make a promise!</button> +<div id="log"></div> +</pre> + +<p>Este pequeno exemplo mostra o mecanismo de uma <code>Promise</code>. O método <code>testPromise()</code> é chamado cada vez que {{HTMLElement("button")}} é clicado. Isso cria uma promise que resolverá, usando {{domxref("window.setTimeout()")}}, o contador de promise <code>promiseCount</code> (iniciando em 1) a cada 1 a 3s randomicamente. O construtor <code>Promise()</code> é usado para criar a promise.</p> + +<p>A realização da promise é simplesmente registrada, por meio de configuração na função callback de realização usando {{jsxref("Promise.prototype.then()","p1.then()")}}. Alguns logs mostram como a parte síncrona do método é desacoplada da conclusão assíncrona da promise.</p> + +<pre class="brush: js notranslate">var promiseCount = 0; +function testPromise() { + var thisPromiseCount = ++promiseCount; + + var log = document.getElementById('log'); + log.insertAdjacentHTML('beforeend', thisPromiseCount + + ') Started (<small>Sync code started</small>)<br/>'); + + // Criamos uma nova promise: prometemos a contagem dessa promise (após aguardar 3s) + var p1 = new Promise( + // a função resolve() é chamada com a capacidade para resolver ou + // rejeitar a promise + function(resolve, reject) { + log.insertAdjacentHTML('beforeend', thisPromiseCount + + ') Promise started (<small>Async code started</small>)<br/>'); + // Isto é apenas um exemplo para criar assincronismo + window.setTimeout( + function() { + // Cumprimos a promessa ! + resolve(thisPromiseCount) + }, Math.random() * 2000 + 1000); + }); + + // definimos o que fazer quando a promise for realizada + p1.then( + // apenas logamos a mensagem e o valor + function(val) { + log.insertAdjacentHTML('beforeend', val + + ') Promise fulfilled (<small>Async code terminated</small>)<br/>'); + }); + + log.insertAdjacentHTML('beforeend', thisPromiseCount + + ') Promise made (<small>Sync code terminated</small>)<br/>'); +} +</pre> + +<pre class="brush:js notranslate" style="display: none;">if ("Promise" in window) { + btn = document.getElementById("btn"); + btn.addEventListener("click",testPromise); +} +else { + log = document.getElementById('log'); + log.innerHTML = "Live example not available as your browser doesn't support the Promise interface."; +} +</pre> + +<p>Este exemplo é executado pelo click do botão. Você precisa de uma versão de navegedor com suporte a <code>Promise</code>. Clicando algumas vezes no botão num curto intervalo de tempo, você verá as diferentes promises sendo realizadas uma após a outra.</p> + +<p>{{EmbedLiveSample("Criando_uma_Promise", "500", "200")}}</p> + +<h3 id="Carregando_uma_imagem_com_XHR">Carregando uma imagem com XHR</h3> + +<p>Outro simples exemplo usando <code>Promise</code> e <code><a href="/en-US/docs/Web/API/XMLHttpRequest">XMLHTTPRequest</a></code> para carregar imagens está disponível no repositório GitHub MDN<a href="https://github.com/mdn/js-examples/blob/master/promises-test/index.html"> promise-test</a>. Você também pode <a href="https://mdn.github.io/js-examples/promises-test/">vê-lo em ação</a>. Cada passo é comentado e lhe permite acompanhar de perto a arquitetura de Promise e XHR.</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><a href="https://github.com/domenic/promises-unwrapping">domenic/promises-unwrapping</a></td> + <td>Draft</td> + <td>Standardization work is taking place here.</td> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-promise-objects', 'Promise')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition in an ECMA standard.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Navegador">Compatibilidade de Navegador</h2> + +<p>{{Compat("javascript.builtins.Promise")}}</p> + +<p>Veja também</p> + +<ul> + <li><a href="http://promisesaplus.com/">Promises/A+ specification</a></li> + <li><a href="http://www.html5rocks.com/en/tutorials/es6/promises/">Jake Archibald: JavaScript Promises: There and Back Again</a></li> + <li><a href="http://de.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript">Domenic Denicola: Callbacks, Promises, and Coroutines – Asynchronous Programming Patter in JavaScript</a></li> + <li><a href="http://www.mattgreer.org/articles/promises-in-wicked-detail/">Matt Greer: JavaScript Promises ... In Wicked Detail</a></li> + <li><a href="https://www.promisejs.org/">Forbes Lindesay: promisejs.org</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/prototype/index.html new file mode 100644 index 0000000000..a422dd886e --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/promise/prototype/index.html @@ -0,0 +1,113 @@ +--- +title: Promise.prototype +slug: Web/JavaScript/Reference/Global_Objects/Promise/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Promise +--- +<div>{{JSRef("Global_Objects", "Promise")}}</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>A propriedade <code><strong>Promise</strong></code><strong><code>.prototype</code></strong> representa o protótipo para o construtor {{jsxref("Promise")}}.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>{{jsxref("Promise")}} instância herdada de {{jsxref("Promise.prototype")}}. Você pode usar o objeto construtor para adicionar propriedades ou métodos para todas as instâncias de <code>Promise</code>.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>Promise.prototype.constructor</code></dt> + <dd>Retorna a função que cria uma instância. Isso é a função padrão {{jsxref("Promise")}}.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("Promise.catch", "Promise.prototype.catch(onRejected)")}}</dt> + <dd>Adiciona um callback que trata rejeição para a promise e, retorna uma nova promise resolvendo o valor retornado do callback, se ele for chamado, ou para seu valor original de conclusão se a promise for realizada.</dd> + <dt>{{jsxref("Promise.then", "Promise.prototype.then(onFulfilled, onRejected)")}}</dt> + <dd>Adiciona os métodos de tratamento da realização e rejeição da promise e, retorna uma nova promise resolvendo para o valor do método chamado.</dd> +</dl> + +<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-promise.prototype', 'Promise.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</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>32</td> + <td>{{CompatGeckoDesktop(24.0)}} as <code>Future</code><br> + {{CompatGeckoDesktop(25.0)}} as <code>Promise</code> behind a flag[1]<br> + {{CompatGeckoDesktop(29.0)}} by default</td> + <td>{{CompatNo}}</td> + <td>19</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile(24.0)}} as <code>Future</code><br> + {{CompatGeckoMobile(25.0)}} as <code>Promise</code> behind a flag[1]<br> + {{CompatGeckoMobile(29.0)}} by default</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>iOS 8</td> + <td>32</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] Gecko 24 has an experimental implementation of <code>Promise</code>, under the initial name of <code>Future</code>. It got renamed to its final name in Gecko 25, but disabled by default behind the flag <code>dom.promise.enabled</code>. <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=918806">Bug 918806</a> enabled Promises by default in Gecko 29.</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Promise")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/race/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/race/index.html new file mode 100644 index 0000000000..13a3c659b5 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/promise/race/index.html @@ -0,0 +1,149 @@ +--- +title: Promise.race() +slug: Web/JavaScript/Reference/Global_Objects/Promise/race +tags: + - ECMAScript6 + - Experimental + - JavaScript + - Method + - Promise +translation_of: Web/JavaScript/Reference/Global_Objects/Promise/race +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>Promise.race(iterable)</strong></code> retorna uma promise que resolve ou rejeita assim que uma das promises no iterável resolver ou rejeitar, com o valor ou razão daquela promise.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><var>Promise.race(iterable)</var>;</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt>iterable</dt> + <dd>Um objeto iterável, como um {{jsxref("Array")}}. Veja <a href="/en-US/docs/Web/JavaScript/Guide/iterable">iterável</a>.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>A função <code>race</code> retorna uma <code>Promise</code> que é estabelecida da mesma forma que a primeira promise passada estabelecer. Ela resolve ou rejeita, o que acontecer primeiro.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Promise.race_–_exemplos_com_setTimeout">Usando <code>Promise.race</code> – exemplos com <code>setTimeout</code></h3> + +<pre class="brush: js">var p1 = new Promise(function(resolve, reject) { + setTimeout(resolve, 500, "one"); +}); +var p2 = new Promise(function(resolve, reject) { + setTimeout(resolve, 100, "two"); +}); + +Promise.race([p1, p2]).then(function(value) { + console.log(value); // "two" + // Ambos resolvem, mas p2 é mais rápido +}); + +var p3 = new Promise(function(resolve, reject) { + setTimeout(resolve, 100, "three"); +}); +var p4 = new Promise(function(resolve, reject) { + setTimeout(reject, 500, "four"); +}); + +Promise.race([p3, p4]).then(function(value) { + console.log(value); // "three" + // p3 é mais rápido, então ela resolve +}, function(reason) { + // Não é chamado +}); + +var p5 = new Promise(function(resolve, reject) { + setTimeout(resolve, 500, "five"); +}); +var p6 = new Promise(function(resolve, reject) { + setTimeout(reject, 100, "six"); +}); + +Promise.race([p5, p6]).then(function(value) { + // Não é chamado +}, function(reason) { + console.log(reason); // "six" + // p6 é mais rápido, então ela rejeita +}); +</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-promise.race', 'Promise.race')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial em um padrão ECMA.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</h2> + +<p>{{CompatibilityTable}}</p> + +<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>32</td> + <td>{{CompatGeckoDesktop(29.0)}}</td> + <td>{{CompatNo}}</td> + <td>19</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Funcionalidade</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile(29.0)}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + <td>32</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("Promise")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/reject/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/reject/index.html new file mode 100644 index 0000000000..6097afe484 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/promise/reject/index.html @@ -0,0 +1,76 @@ +--- +title: Promise.reject() +slug: Web/JavaScript/Reference/Global_Objects/Promise/reject +translation_of: Web/JavaScript/Reference/Global_Objects/Promise/reject +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>Promise.reject(motivo)</strong></code> retorna um objeto Promise que é rejeitada com um dado motivo.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><var>Promise.reject(motivo)</var>;</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt>motivo</dt> + <dd>Motivo pelo qual este Promise foi rejeitado.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>O método estático <code>Promise.reject</code> retorna uma <code>Promise</code> que é rejeitada. Para fins de debug e captura de erros seletiva, é útil que o motivo seja uma <code>instanceof</code> {{jsxref("Error")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_método_estático_Promise.reject()">Usando o método estático Promise.reject()</h3> + +<pre class="brush: js">Promise.reject("Testando reject estático").then(function(motivo) { + // não executado +}, function(motivo) { + console.log(motivo); // "Testando reject estático" +}); + +Promise.reject(new Error("falha")).then(function(erro) { + // não executado +}, function(erro) { + console.log(erro); // Stacktrace +});</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('ES6', '#sec-promise.reject', 'Promise.reject')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial em um padrão ECMA.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-promise.reject', 'Promise.reject')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.Promise.reject")}}</p> + +<p> </p> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("Promise")}}</li> + <li><a href="https://github.com/petkaantonov/bluebird#error-handling">Captura de erros seletiva com a biblioteca de Promise BlueBird</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/resolve/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/resolve/index.html new file mode 100644 index 0000000000..f4c1220158 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/promise/resolve/index.html @@ -0,0 +1,144 @@ +--- +title: Promise.resolve() +slug: Web/JavaScript/Reference/Global_Objects/Promise/resolve +tags: + - ECMAScript6 + - ES6 + - JavaScript + - Método(2) + - Promise +translation_of: Web/JavaScript/Reference/Global_Objects/Promise/resolve +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>Promise.resolve(value)</strong></code> retorna um objeto {{jsxref("Promise")}} que é resolvido com o valor passado. Se o valor for <em>thenable</em> (ex: tiver um método {{jsxref("Promise.then", "\"then\"")}}), a promise retornada irá "seguir" esse <em>thenable</em>, adotando seu estado final; se o valor for uma promise, o objeto será o resultado da chamada Promise.resolve; do contrário a promise será realizada com o valor.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><var>Promise.resolve(value)</var>; +Promise.resolve(promise); +Promise.resolve(thenable); +</pre> + +<h3 id="Parametros">Parametros</h3> + +<dl> + <dt>value</dt> + <dd>Argumento a ser resolvido <font face="Consolas, Liberation Mono, Courier, monospace">pela <code>Promise</code></font>. Pode também ser uma <code>Promise</code> ou um thenable a resolver.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>A {{jsxref("Promise")}} que será resolvida com o valor passado ou com a {{jsxref("Promise")}} passada como valor, caso o valor seja um objeto {{jsxref("Promise")}} </p> + +<h2 id="Descrição">Descrição</h2> + +<p>A função estática <code>Promise.resolve</code> retorna uma <code>Promise</code> de que será resolvida.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Usando_o_método_estático_Promise.resolve">Usando o método estático <code>Promise.resolve</code></h3> + +<pre class="brush: js">Promise.resolve("Success").then(function(value) { + console.log(value); // "Success" +}, function(value) { + // not called +}); +</pre> + +<h3 id="Resolvendo_um_array">Resolvendo um array</h3> + +<pre class="brush: js">var p = Promise.resolve([1,2,3]); +p.then(function(v) { + console.log(v[0]); // 1 +}); +</pre> + +<h3 id="Resolvendo_outra_Promise">Resolvendo outra <code>Promise</code></h3> + +<pre class="brush: js">var original = Promise.resolve(true); +var cast = Promise.resolve(original); +cast.then(function(v) { + console.log(v); // true +}); + +</pre> + +<p>A ordem invertida dos logs acontece devido ao fato de que os handlers são chamados assincronamente. Veja como o <code>then</code> funciona <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then#Return_value">aqui</a>.</p> + +<h3 id="Resolvendo_thenables_e_disparando_Errors">Resolvendo thenables e disparando Errors</h3> + +<pre class="brush: js">// Resolving a thenable object +var p1 = Promise.resolve({ + then: function(onFulfill, onReject) { onFulfill("fulfilled!"); } +}); +console.log(p1 instanceof Promise) // true, object casted to a Promise + +p1.then(function(v) { + console.log(v); // "fulfilled!" + }, function(e) { + // not called +}); + +// Thenable throws before callback +// Promise rejects +var thenable = { then: function(resolve) { + throw new TypeError("Throwing"); + resolve("Resolving"); +}}; + +var p2 = Promise.resolve(thenable); +p2.then(function(v) { + // not called +}, function(e) { + console.log(e); // TypeError: Throwing +}); + +// Thenable throws after callback +// Promise resolves +var thenable = { then: function(resolve) { + resolve("Resolving"); + throw new TypeError("Throwing"); +}}; + +var p3 = Promise.resolve(thenable); +p3.then(function(v) { + console.log(v); // "Resolving" +}, function(e) { + // not called +}); +</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-promise.resolve', 'Promise.resolve')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial no padrão ECMA.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-promise.resolve', 'Promise.resolve')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2> + +<p class="hidden">To contribute to this compatibility data, please write a pull request against this file: <a href="https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json">https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json</a>.</p> + +<p>{{Compat("javascript.builtins.Promise.resolve")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Promise")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/then/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/then/index.html new file mode 100644 index 0000000000..5e3c015947 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/promise/then/index.html @@ -0,0 +1,181 @@ +--- +title: Promise.prototype.then() +slug: Web/JavaScript/Reference/Global_Objects/Promise/then +translation_of: Web/JavaScript/Reference/Global_Objects/Promise/then +--- +<div>{{JSRef("Global_Objects", "Promise")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <strong>then()</strong> retorna uma <strong>Promise</strong>. Possui dois argumentos, ambos são "<strong>call back functions</strong>", sendo uma para o sucesso e outra para o fracasso da promessa.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><var>p.then(</var><strong style="font-weight: bold;">quandoRealizada</strong><var>, </var><strong style="font-weight: bold;">quandoRejeitada</strong><var>)</var>; + +p.then(function(valor) { + // sucesso + }, function(motivo) { + // rejeitada +}); +</pre> + +<h3 id="Parametros">Parametros</h3> + +<dl> + <dt>quandoRealizada</dt> + <dd>Uma {{jsxref("Function")}} chamada quando a <strong>Promise</strong> é cumprida (Sucesso). Essa função tem um argumento, o valor do cumprimento.</dd> +</dl> + +<dl> + <dt>quandoRejeitada</dt> + <dd>Uma {{jsxref("Function")}} chamada quando a Promise é rejeitada. Essa função tem um argumento, o motivo da recusa.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Assim como o método .then() e {{jsxref("Promise.prototype.catch()")}} retornam uma <strong>Promise</strong>, eles podem ser encadeados - uma operação chamada <em><strong>composition</strong>.</em></p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_método_then">Usando o método then</h3> + +<pre class="brush: js">var p1 = new Promise(function(resolve, reject) { + resolve("Success!"); + // or + // reject ("Error!"); +}); + +p1.then(function(value) { + console.log(value); // Success! +}, function(reason) { + console.log(reason); // Error! +}); +</pre> + +<h3 id="Encadeando">Encadeando</h3> + +<p>Já que o método then() devolve uma <strong>Promise</strong>, você pode facilmente encadeá-los. </p> + +<pre class="brush: js">var p2 = new Promise(function(resolve, reject) { + resolve(1); +}); + +p2.then(function(value) { + console.log(value); // 1 + return value + 1; +}).then(function(value) { + console.log(value); // 2 +}); + +</pre> + +<p>No exemplo acima, o último <strong>.then()</strong> recebeu a soma value + 1, que resultou em 2, porém se o retorno de value + 1 fosse uma <strong>Promise</strong> que também retornasse value + 1, o resultado seria o mesmo. Note, no exemplo abaixo, que leva 1000ms para a impressão de 2 ocorrer.</p> + +<pre class="brush: js">var p2 = new Promise(function(resolve, reject) { + resolve(1); +}); + +p2.then(function(value) { + console.log(value); // 1 + return new Promise(function (resolve, reject) { + setTimeout(function () { + resolve(value + 1); + }, 1000); + }); +}).then(function(value) { + console.log(value); // 2 +});</pre> + +<p> </p> + +<p> </p> + +<h2 id="sect1"> </h2> + +<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><a href="https://github.com/domenic/promises-unwrapping">domenic/promises-unwrapping</a></td> + <td>Draft</td> + <td>Standardization work is taking place here.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-promise.prototype.then', 'Promise.prototype.then')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition in an ECMA standard.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_Browsers">Compatibilidade dos Browsers</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>32</td> + <td>{{CompatGeckoDesktop(24.0)}} as <code>Future</code><br> + {{CompatGeckoDesktop(25.0)}} as <code>Promise</code> behind a flag[1]<br> + {{CompatGeckoDesktop(29.0)}} by default</td> + <td>{{CompatNo}}</td> + <td>19</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile(24.0)}} as <code>Future</code><br> + {{CompatGeckoMobile(25.0)}} as <code>Promise</code> behind a flag[1]<br> + {{CompatGeckoMobile(29.0)}} by default</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>iOS 8</td> + <td>32</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] Gecko 24 possui uma implementação experimental de Promise, under the initial name of <code>Future</code>. It got renamed to its final name in Gecko 25, but disabled by default behind the flag <code>dom.promise.enabled</code>. <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=918806">Bug 918806</a> enabled Promises by default in Gecko 29.</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Promise")}}</li> + <li>{{jsxref("Promise.prototype.catch()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/proxy/index.html b/files/pt-br/web/javascript/reference/global_objects/proxy/index.html new file mode 100644 index 0000000000..2975088492 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/proxy/index.html @@ -0,0 +1,396 @@ +--- +title: Proxy +slug: Web/JavaScript/Reference/Global_Objects/Proxy +translation_of: Web/JavaScript/Reference/Global_Objects/Proxy +--- +<div> +<div>{{JSRef}}</div> +</div> + +<p>O objeto <strong>Proxy</strong> é usado para definir comportamentos customizados para operações fundamentais (por exemplo, pesquisa de propriedade, atribuição, enumeração, invocação de função, etc.).</p> + +<h2 id="Terminologia">Terminologia</h2> + +<dl> + <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler">handler</a></dt> + <dd>Objeto marcador que contém <em>traps</em>.</dd> + <dt>traps</dt> + <dd>Métodos que fornecem acesso à propriedade. Isto é análogo ao conceito de <em>traps </em>(armadilhas) em sistemas operacionais</dd> + <dt>target</dt> + <dd>Objeto que o proxy virtualiza. É frequentemente utilizado como back-end de armazenamento para o proxy. Os invariantes (semânticas que permanecem inalterados) em relação à não-extensibilidade do objeto ou propriedades não-configuráveis são verificados em relação ao <em>target</em>.</dd> +</dl> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox">var p = new Proxy(target, handler); +</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>target</code></dt> + <dd>Um objeto target (pode ser qualquer tipo de objeto, incluindo um array, uma função ou até mesmo outro <em>Proxy</em>) a ser envolvido com o <code>Proxy</code>.</dd> + <dt><code>handler</code></dt> + <dd>Um objeto cujas propriedades são funções que definem o comportamento do proxy quando uma operação é realizada sobre ele.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("Proxy.revocable()")}}</dt> + <dd>Cria um objeto <code> Proxy </code> revogável.</dd> +</dl> + +<h2 id="Métodos_para_manipular_objetos">Métodos para manipular objetos</h2> + +<p>O objeto manipulado é um objeto reservado que contém traps para <code> Proxy. </code></p> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler', 'Methods') }}</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Exemplo_básico">Exemplo básico</h3> + +<p>Neste exemplo simples, o número <code> 37 </code> é retornado como o valor padrão quando o nome da propriedade não está no objeto. Usa-se o manipulador <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/get"><code>get</code></a>.</p> + +<pre class="brush: js">var handler = { + get: function(target, name) { + return name in target ? + target[name] : + 37; + } +}; + +var p = new Proxy({}, handler); +p.a = 1; +p.b = undefined; + +console.log(p.a, p.b); // 1, undefined +console.log('c' in p, p.c); // false, 37 +</pre> + +<h3 id="Encaminhamento_de_Proxy">Encaminhamento de Proxy</h3> + +<p>Neste exemplo, estamos usando um objeto JavaScript nativo ao qual nosso proxy irá encaminhar todas as operações que são aplicadas para ele.</p> + +<pre class="brush: js">var target = {}; +var p = new Proxy(target, {}); + +p.a = 37; // Operação encaminhada para o alvo + +console.log(target.a); // 37. A operação foi devidamente encaminhada +</pre> + +<h3 id="Validação">Validação</h3> + +<p>Com um <code> Proxy</code>, você pode validar facilmente o valor passado para um objeto. Este exemplo usa o manipulador <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/set"> <code> set</code></a>.</p> + +<pre class="brush: js">let validator = { + set: function(obj, prop, value) { + if (prop === 'age') { + if (!Number.isInteger(value)) { + throw new TypeError('The age is not an integer'); + } + if (value > 200) { + throw new RangeError('The age seems invalid'); + } + } + + //O comportamento padrão para armazenar o valor + obj[prop] = value; + + // Indique o sucesso + return true; + } +}; + +let person = new Proxy({}, validator); + +person.age = 100; +console.log(person.age); // 100 +person.age = 'young'; // Lança uma exceção +person.age = 300; // Lança uma exceção</pre> + +<h3 id="Construtor_de_extensão">Construtor de extensão</h3> + +<p>Um proxy de função poderia facilmente estender um construtor com um novo construtor. Este exemplo usa os manipuladores <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/construct"> <code> construct </code> </a> e <a href="/En-US/docs/Web/JavaScript/Referência/Global_Objects/Proxy/handler/apply"> <code> apply</code></a>.</p> + +<pre class="brush: js">function extend(sup, base) { + var descriptor = Object.getOwnPropertyDescriptor( + base.prototype, 'constructor' + ); + base.prototype = Object.create(sup.prototype); + var handler = { + construct: function(target, args) { + var obj = Object.create(base.prototype); + this.apply(target, obj, args); + return obj; + }, + apply: function(target, that, args) { + sup.apply(that, args); + base.apply(that, args); + } + }; + var proxy = new Proxy(base, handler); + descriptor.value = proxy; + Object.defineProperty(base.prototype, 'constructor', descriptor); + return proxy; +} + +var Person = function(name) { + this.name = name; +}; + +var Boy = extend(Person, function(name, age) { + this.age = age; +}); + +Boy.prototype.sex = 'M'; + +var Peter = new Boy('Peter', 13); +console.log(Peter.sex); // "M" +console.log(Peter.name); // "Peter" +console.log(Peter.age); // 13</pre> + +<h3 id="DOM_manipulação_de_nós">DOM manipulação de nós</h3> + +<p>Às vezes, você deseja alternar o atributo ou o nome da classe de dois elementos diferentes. Veja como usar o manipulador <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/set"> <code> set</code></a>.</p> + +<pre class="brush: js">let view = new Proxy({ + selected: null +}, +{ + set: function(obj, prop, newval) { + let oldval = obj[prop]; + + if (prop === 'selected') { + if (oldval) { + oldval.setAttribute('aria-selected', 'false'); + } + if (newval) { + newval.setAttribute('aria-selected', 'true'); + } + } + + // O comportamento para armazenar o valor padrão + obj[prop] = newval; + + // Indica o sucesso + return true; + } +}); + +let i1 = view.selected = document.getElementById('item-1'); +console.log(i1.getAttribute('aria-selected')); // 'true' + +let i2 = view.selected = document.getElementById('item-2'); +console.log(i1.getAttribute('aria-selected')); // 'false' +console.log(i2.getAttribute('aria-selected')); // 'true'</pre> + +<h3 id="Correção_de_valor_e_uma_propriedade_extra">Correção de valor e uma propriedade extra</h3> + +<p>O objeto de proxy <code> produtos </code> avalia o valor passado e converte-o em uma matriz, se necessário. O objeto também suporta uma propriedade adicional chamada <code> latestBrowser </code> tanto em getters como em setters.</p> + +<pre class="brush: js">let products = new Proxy({ + browsers: ['Internet Explorer', 'Netscape'] +}, +{ + get: function(obj, prop) { + // An extra property + if (prop === 'latestBrowser') { + return obj.browsers[obj.browsers.length - 1]; + } + + // O comportamento para armazenar o valor padrão + return obj[prop]; + }, + set: function(obj, prop, value) { + // An extra property + if (prop === 'latestBrowser') { + obj.browsers.push(value); + return true; + } + + // Converta o valor se não for uma matriz + if (typeof value === 'string') { + value = [value]; + } + + // O comportamento para armazenar o valor padrão + obj[prop] = value; + + // Indicate success + return true; + } +}); + +console.log(products.browsers); // ['Internet Explorer', 'Netscape'] +products.browsers = 'Firefox'; // pass a string (by mistake) +console.log(products.browsers); // ['Firefox'] <- no problem, the value is an array + +products.latestBrowser = 'Chrome'; +console.log(products.browsers); // ['Firefox', 'Chrome'] +console.log(products.latestBrowser); // 'Chrome'</pre> + +<h3 id="Encontrando_um_item_de_objeto_em_uma_matriz_por_propriedade">Encontrando um item de objeto em uma matriz por propriedade</h3> + +<p>Esta proxy estende uma matriz com alguns recursos de utilidade. Como você vê, você pode "definir" propriedades flexíveis sem usar <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties"> <code> Object.defineProperties</code></a>. Este exemplo pode ser adaptado para encontrar uma linha de tabela por sua célula. Nesse caso, o alvo será <a href="/en-US/docs/DOM/table.rows"> <code> table.rows </code> </a></p> + +<pre class="brush: js">let products = new Proxy([ + { name: 'Firefox', type: 'browser' }, + { name: 'SeaMonkey', type: 'browser' }, + { name: 'Thunderbird', type: 'mailer' } +], +{ + get: function(obj, prop) { + // O comportamento para retornar o valor; Prop geralmente é um inteiro + if (prop in obj) { + return obj[prop]; + } + + // Obter o número de produtos; Com products.length + if (prop === 'number') { + return obj.length; + } + + let result, types = {}; + + for (let product of obj) { + if (product.name === prop) { + result = product; + } + if (types[product.type]) { + types[product.type].push(product); + } else { + types[product.type] = [product]; + } + } + + // Obtém um produto por nome + if (result) { + return result; + } + + // Obtém produtos por tipo + if (prop in types) { + return types[prop]; + } + + // Obtém tipos de produto + if (prop === 'types') { + return Object.keys(types); + } + + return undefined; + } +}); + +console.log(products[0]); // { name: 'Firefox', type: 'browser' } +console.log(products['Firefox']); // { name: 'Firefox', type: 'browser' } +console.log(products['Chrome']); // undefined +console.log(products.browser); // [{ name: 'Firefox', type: 'browser' }, { name: 'SeaMonkey', type: 'browser' }] +console.log(products.types); // ['browser', 'mailer'] +console.log(products.number); // 3</pre> + +<h3 id="Um_exemplo_completo_de_lista_de_traps">Um exemplo completo de lista de <code>traps</code></h3> + +<p>Agora, para criar uma lista completa de amostra de <code>traps</code>, para fins didáticos, tentaremos propor um objeto <em>não nativo</em> que seja particularmente adequado para este tipo de operação: o objeto global <code>docCookies</code> criado por <a href="https://developer.mozilla.org/en-US/docs/Web/API/Document/cookie/Simple_document.cookie_framework" title="https://developer.mozilla.org/en-US/docs/DOM/document.cookie#A_little_framework.3A_a_complete_cookies_reader.2Fwriter_with_full_unicode_support"> a "little framework" publicada na página<code>document.cookie</code></a>.</p> + +<pre class="brush: js">/* + var docCookies = ... get the "docCookies" object here: + https://developer.mozilla.org/en-US/docs/DOM/document.cookie#A_little_framework.3A_a_complete_cookies_reader.2Fwriter_with_full_unicode_support +*/ + +var docCookies = new Proxy(docCookies, { + get: function (oTarget, sKey) { + return oTarget[sKey] || oTarget.getItem(sKey) || undefined; + }, + set: function (oTarget, sKey, vValue) { + if (sKey in oTarget) { return false; } + return oTarget.setItem(sKey, vValue); + }, + deleteProperty: function (oTarget, sKey) { + if (sKey in oTarget) { return false; } + return oTarget.removeItem(sKey); + }, + enumerate: function (oTarget, sKey) { + return oTarget.keys(); + }, + ownKeys: function (oTarget, sKey) { + return oTarget.keys(); + }, + has: function (oTarget, sKey) { + return sKey in oTarget || oTarget.hasItem(sKey); + }, + defineProperty: function (oTarget, sKey, oDesc) { + if (oDesc && 'value' in oDesc) { oTarget.setItem(sKey, oDesc.value); } + return oTarget; + }, + getOwnPropertyDescriptor: function (oTarget, sKey) { + var vValue = oTarget.getItem(sKey); + return vValue ? { + value: vValue, + writable: true, + enumerable: true, + configurable: false + } : undefined; + }, +}); + +/* Teste Cookies */ + +console.log(docCookies.my_cookie1 = 'First value'); +console.log(docCookies.getItem('my_cookie1')); + +docCookies.setItem('my_cookie1', 'Changed value'); +console.log(docCookies.my_cookie1);</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('ES2015', '#sec-proxy-objects', 'Proxy')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição Inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-proxy-objects', 'Proxy')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>?</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_Compatíveis">Navegadores Compatíveis</h2> + + + +<p>{{Compat("javascript.builtins.Proxy", 2)}}</p> + +<h2 id="Notas_Especificas_Gecko">Notas Especificas Gecko</h2> + +<ul> + <li>No momento, <code>Object.getPrototypeOf(proxy)</code> retorna incondicionalmente um <code>Object.getPrototypeOf(target)</code>, porque a trap ES2015 getPrototypeOf não foi implementada ({{bug(795904)}}, {{bug(888969)}}).</li> + <li><code>Array.isArray(proxy)</code> retorna incondicionalmente um <code>Array.isArray(target)</code> ({{bug(1096753)}}, {{bug(1111785)}}).</li> + <li><code>Object.prototype.toString.call(proxy)</code> retorna incondicionalmente <code>Object.prototype.toString.call(target)</code>, porque ES2015 Symbol.toStringTag não foi implementado ({{bug(1114580)}}).</li> +</ul> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a class="external" href="https://www.youtube.com/watch?v=sClk6aB_CPk">"Proxies are awesome" Brendan Eich presentation at JSConf</a> (<a class="external" href="http://www.slideshare.net/BrendanEich/metaprog-5303821">slides</a>)</li> + <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:proxies">ECMAScript Harmony Proxy proposal page</a> e <a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:proxies_semantics">ECMAScript página de semântica de proxy Harmony</a></li> + <li><a class="external" href="http://soft.vub.ac.be/~tvcutsem/proxies/">Tutorial em proxies</a></li> + <li><a href="/en-US/docs/JavaScript/Old_Proxy_API" title="/en-US/docs/JavaScript/Old_Proxy_API">SpiderMonkey specific Old Proxy API</a></li> + <li>{{jsxref("Object.watch()")}} É um recurso não padrão, mas foi suportado no Gecko há muito tempo.</li> +</ul> + +<h2 id="Nota_de_licença"><code><code>Nota de licença</code></code></h2> + +<p>Alguns conteúdos (texto, exemplos) nesta página foram copiados ou adaptados do <a class="external" href="http://wiki.ecmascript.org/doku.php"> ECMAScript wiki </a> que contém à licença de conteúdo <a class="external" href="http://creativecommons.org/licenses/by-nc-sa/2.0/"> CC 2.0 BY-NC-SA </a>.</p> diff --git a/files/pt-br/web/javascript/reference/global_objects/referenceerror/index.html b/files/pt-br/web/javascript/reference/global_objects/referenceerror/index.html new file mode 100644 index 0000000000..5a00314c2c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/referenceerror/index.html @@ -0,0 +1,171 @@ +--- +title: ReferenceError +slug: Web/JavaScript/Reference/Global_Objects/ReferenceError +translation_of: Web/JavaScript/Reference/Global_Objects/ReferenceError +--- +<div>{{JSRef}}</div> + +<p>O objeto <code><strong>ReferenceError</strong></code> representa um erro quando uma variável não existente é referenciada.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>new ReferenceError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>message</code></dt> + <dd>Opcional. Descrição legível do erro.</dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Opcional. O nome do arquivo contendo o código que causou a excessão.</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Opcional. O número da linha do código que causou a excessão.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>O <code>ReferenceError</code> acontece quando é feita uma tentativa de referenciar uma variável que não foi declarada.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt>{{jsxref("ReferenceError.prototype")}}</dt> + <dd>Permite a inclusão de propriedades em um objeto <code>ReferenceError</code>.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<p>O <code>ReferenceError</code> não contém métodos próprios, porém, ele herda alguns métodos através da cadeia de protótipos.</p> + +<h2 id="Instâncias_do_ReferenceError">Instâncias do <code>ReferenceError</code> </h2> + +<h3 id="Propriedades_2">Propriedades</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError/prototype', 'Properties')}}</div> + +<h3 id="Métodos_2">Métodos</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError/prototype', 'Methods')}}</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Capturando_um_ReferenceError">Capturando um <code>ReferenceError</code></h3> + +<pre class="brush: js">try { + var a = variavelNaoDefinida; +} catch (e) { + console.log(e instanceof ReferenceError); // true + console.log(e.message); // "variavelNaoDefinida não está definida" + console.log(e.name); // "ReferenceError" + console.log(e.fileName); // "Scratchpad/1" + console.log(e.lineNumber); // 2 + console.log(e.columnNumber); // 6 + console.log(e.stack); // "@Scratchpad/2:2:7\n" +} +</pre> + +<h3 id="Criando_um_ReferenceError">Criando um <code>ReferenceError</code></h3> + +<pre class="brush: js">try { + throw new ReferenceError('Olá', 'arquivoQualquer.js', 10); +} catch (e) { + console.log(e instanceof ReferenceError); // true + console.log(e.message); // "Olá" + console.log(e.name); // "ReferenceError" + console.log(e.fileName); // "arquivoQualquer.js" + console.log(e.lineNumber); // 10 + console.log(e.columnNumber); // 0 + console.log(e.stack); // "@Scratchpad/2:2:9\n" +} +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.6.3', 'ReferenceError')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-referenceerror', 'ReferenceError')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-referenceerror', 'ReferenceError')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</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>{{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>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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("ReferenceError.prototype")}}</li> +</ul> 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> diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/compile/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/compile/index.html new file mode 100644 index 0000000000..de36469d18 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/compile/index.html @@ -0,0 +1,84 @@ +--- +title: RegExp.prototype.compile() +slug: Web/JavaScript/Reference/Global_Objects/RegExp/compile +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/compile +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code><strong>compile</strong></code><strong><code>()</code></strong> <span class="tlid-translation translation" lang="pt"><span title=""> está depreciado, é usado para (re-)compilar uma expressão regular durante a execução de um script.</span></span> <span class="tlid-translation translation" lang="pt"><span title="">É basicamente o mesmo que o construtor </span></span> <code>RegExp</code>.</p> + +<h2 id="Sintaxe"><span class="tlid-translation translation" lang="pt"><span title="">Sintaxe</span></span></h2> + +<pre class="syntaxbox"><code><var>regexObj</var>.compile(<var>pattern, flags</var>)</code></pre> + +<h3 id="Parâmetros"><span class="tlid-translation translation" lang="pt"><span title="">Parâmetros</span></span></h3> + +<dl> + <dt><code>pattern</code></dt> + <dd> <span class="tlid-translation translation" lang="pt"><span title="">É o texto da expressão regular</span></span>.</dd> + <dt><code>flags</code></dt> + <dd> + <p><span class="tlid-translation translation" lang="pt"><span title="">Se especificado, as flags podem ter qualquer combinação dos seguintes valores</span></span>:</p> + + <dl> + <dt><code>g</code></dt> + <dd>global.</dd> + <dt><code>i</code></dt> + <dd><span class="tlid-translation translation" lang="pt"><span title="">ignorar caso.</span></span></dd> + <dt><code>m</code></dt> + <dd><span class="tlid-translation translation" lang="pt"><span title="">multilinha;</span> <span title="">trata os caracteres iniciais e finais como (^ e $), trabalhando sobre várias linhas (isto é, corresponde ao início ou ao final de cada linha (delimitado por \n ou \r), não apenas o começo, ou o final de toda a cadeia de entrada).</span></span></dd> + <dt><code>y</code></dt> + <dd>sticky; <span class="tlid-translation translation" lang="pt"><span title="">corresponde apenas ao índice indicado pela propriedade</span></span> <code>lastIndex</code> <span class="tlid-translation translation" lang="pt"><span title="">dessa expressão regular na cadeia de destino (e não tenta corresponder a partir de índices posteriores).</span></span></dd> + </dl> + </dd> +</dl> + +<h2 id="Descrição"><span class="tlid-translation translation" lang="pt"><span title="">Descrição</span></span></h2> + +<p> <span class="tlid-translation translation" lang="pt"><span title="">O método de</span></span> <code>compilação</code> <span class="tlid-translation translation" lang="pt"><span title="">é obsoleto.</span> </span> <span class="tlid-translation translation" lang="pt"><span title="">Você pode simplesmente usar o construtor </span></span> <code>RegExp</code> <span class="tlid-translation translation" lang="pt"><span title="">para obter o mesmo efeito.</span></span></p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_compile()"><span class="tlid-translation translation" lang="pt"><span title="">Usando</span></span> <code>compile()</code></h3> + +<p><span class="tlid-translation translation" lang="pt"><span title="">O exemplo a seguir mostra como recompilar uma expressão regular com um novo padrão e um nova </span></span>flag.</p> + +<pre class="brush: js">var regexObj = new RegExp('foo', 'gi'); +regexObj.compile('new foo', 'g'); +</pre> + +<h2 id="Especificações"><span class="tlid-translation translation" lang="pt"><span title="">Especificações</span></span></h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col"><span class="tlid-translation translation" lang="pt"><span title="">Especificação</span></span></th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compativeis">Browser compativeis</h2> + +<div> + + +<p>{{Compat("javascript.builtins.RegExp.compile")}}</p> +</div> + +<h2 id="Veja_também"><span class="tlid-translation translation" lang="pt"><span title="">Veja também</span></span></h2> + +<ul> + <li>{{jsxref("RegExp")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/exec/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/exec/index.html new file mode 100644 index 0000000000..b5f722a55d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/exec/index.html @@ -0,0 +1,230 @@ +--- +title: RegExp.prototype.exec() +slug: Web/JavaScript/Reference/Global_Objects/RegExp/exec +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/exec +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>exec()</code></strong> executa a busca por um padrão em uma determinada string. Retorna um array, ou {{jsxref("null")}}.</p> + +<p>Se você está precisa somente de um retorno verdadeiro/falso, use o método {{jsxref("RegExp.prototype.test()")}} ou {{jsxref("String.prototype.search()")}}.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><var>regexObj</var>.exec(<var>string</var>)</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>string</code></dt> + <dd>A string para comparar com a expressão regular</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Se a combinação acontecer, o método <code>exec() </code>o método retorna um array e atualiza as propriedades do objeto da expressão regular. Esse array retornado possui o texto combinado como primeiro item e depois um item para cada captura contendo o respectivo texto.</p> + +<p>Se falhar, o retorno do método <code>exec()</code> será {{jsxref("null")}}.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Considere o exemplo abaixo:</p> + +<pre class="brush: js">// Encontra combinações "quick brown" seguido de "jumps", ignorando caracteres entre eles +// Relembra "brown" e "jumps" +// Ignora caixa (maiúsculo e minúsculo) +var re = /quick\s(brown).+?(jumps)/ig; +var result = re.exec('The Quick Brown Fox Jumps Over The Lazy Dog'); +</pre> + +<p>A tabela a seguir provê os resultados do script:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Objeto</td> + <td class="header">Propriedade/Índice</td> + <td class="header">Descrição</td> + <td class="header">Exemplo</td> + </tr> + <tr> + <td rowspan="4"><code>result</code></td> + <td><code>[0]</code></td> + <td>A string completa dos caracteres encontrados</td> + <td><code>Quick Brown Fox Jumps</code></td> + </tr> + <tr> + <td><code>[1], ...[<em>n</em> ]</code></td> + <td>As combinações de substrings parametrizadas encontradas, se existir. A quantidade de possíveis substrings parametrizadas é ilimitado.</td> + <td><code>[1] = Brown<br> + [2] = Jumps</code></td> + </tr> + <tr> + <td><code>index</code></td> + <td> + <p>O índice base 0 do valor encontrado na string.</p> + </td> + <td><code>4</code></td> + </tr> + <tr> + <td><code>input</code></td> + <td>String original</td> + <td><code>The Quick Brown Fox Jumps Over The Lazy Dog</code></td> + </tr> + <tr> + <td rowspan="5"><code>re</code></td> + <td><code>lastIndex</code></td> + <td>O índice que começa a próxima combinação encontrada. Quando "<code>g</code>" não é definido, este valor será sempre 0.</td> + <td><code>25</code></td> + </tr> + <tr> + <td><code>ignoreCase</code></td> + <td>Indica se a flag "<code>i</code>" foi usada para ignorar caixa alta/baixa.</td> + <td><code>true</code></td> + </tr> + <tr> + <td><code>global</code></td> + <td>Indica se a flag "<code>g</code>" foi usada para encontrar combinações de forma global.</td> + <td><code>true</code></td> + </tr> + <tr> + <td><code>multiline</code></td> + <td>Indica se a flag "<code>m</code>" foi usada para pesquisar em strings de diversas linhas.</td> + <td><code>false</code></td> + </tr> + <tr> + <td><code>source</code></td> + <td>Texto do padrão.</td> + <td><code>quick\s(brown).+?(jumps)</code></td> + </tr> + </tbody> +</table> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Procurando_combinações_sucessivas">Procurando combinações sucessivas</h3> + +<p>If your regular expression uses the "<code>g</code>" flag, you can use the <code>exec()</code> method multiple times to find successive matches in the same string. When you do so, the search starts at the substring of <code>str</code> specified by the regular expression's {{jsxref("RegExp.lastIndex", "lastIndex")}} property ({{jsxref("RegExp.prototype.test()", "test()")}} will also advance the {{jsxref("RegExp.lastIndex", "lastIndex")}} property). For example, assume you have this script:</p> + +<pre class="brush: js">var myRe = /ab*/g; +var str = 'abbcdefabh'; +var myArray; +while ((myArray = myRe.exec(str)) !== null) { + var msg = 'Found ' + myArray[0] + '. '; + msg += 'Next match starts at ' + myRe.lastIndex; + console.log(msg); +} +</pre> + +<p>This script displays the following text:</p> + +<pre>Found abb. Next match starts at 3 +Found ab. Next match starts at 9 +</pre> + +<p>Note: Do not place the regular expression literal (or {{jsxref("RegExp")}} constructor) within the <code>while</code> condition or it will create an infinite loop if there is a match due to the {{jsxref("RegExp.lastIndex", "lastIndex")}} property being reset upon each iteration. Also be sure that the global flag is set or a loop will occur here also.</p> + +<h3 id="Usando_exec()_com_RegExp_literais">Usando <code>exec()</code> com <code>RegExp</code> literais</h3> + +<p>You can also use <code>exec()</code> without creating a {{jsxref("RegExp")}} object:</p> + +<pre class="brush: js">var matches = /(hello \S+)/.exec('This is a hello world!'); +console.log(matches[1]); +</pre> + +<p>This will log a message containing 'hello world!'.</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition. Implemented in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.10.6.21', 'RegExp.exec')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-regexp.prototype.exec', 'RegExp.exec')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-regexp.prototype.exec', 'RegExp.exec')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Funcionalidade</th> + <th>Chrome</th> + <th>Edge</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> + <td>{{CompatVersionUnknown}}</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>Edge</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> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>O capítulo de <a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Expressões Regulares</a> no <a href="/pt-BR/docs/Web/JavaScript/Guide">Guia de Javascript</a>.</li> + <li>{{jsxref("RegExp")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/ignorecase/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/ignorecase/index.html new file mode 100644 index 0000000000..e6f55b596f --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/ignorecase/index.html @@ -0,0 +1,70 @@ +--- +title: RegExp.prototype.ignoreCase +slug: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase +tags: + - JavaScript + - Referencia + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase +--- +<div>{{JSRef}}</div> + +<div>O atributo <strong><code>ignoreCase</code></strong> indica se a flag "i" foi ou não utilizada com a expressão regular.</div> + +<div><code>ignoreCase</code> é um atributo somente leitura de uma instância individual de expressão</div> + +<div>regular. </div> + +<div></div> + +<p>{{EmbedInteractiveExample("pages/js/regexp-prototype-ignorecase.html")}}</p> + + + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>O valor de <code>ignoreCase</code> é um {{jsxref("Boolean")}} e<code>true</code> se a flag "<code>i</code>" foi usada; <code>false</code> caso contrário. A flag "i" indica que maiúsculas e minúsculas são equivalentes ao se tentar casar uma string com a expressão regular.</p> + +<p>Você não pode alterar essa propriedade diretamente.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_ignoreCase">Usando <code>ignoreCase</code></h3> + +<pre class="brush: js notranslate">var regex = new RegExp('foo', 'i'); + +console.log(regex.ignoreCase); // true +</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-get-regexp.prototype.ignorecase', 'RegExp.prototype.ignoreCase')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2> + +<div> + + +<p>{{Compat("javascript.builtins.RegExp.ignoreCase")}}</p> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("RegExp.lastIndex")}}</li> + <li>{{jsxref("RegExp.prototype.global")}}</li> + <li>{{jsxref("RegExp.prototype.multiline")}}</li> + <li>{{jsxref("RegExp.prototype.source")}}</li> + <li>{{jsxref("RegExp.prototype.sticky")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/index.html new file mode 100644 index 0000000000..99ff4a626d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/index.html @@ -0,0 +1,636 @@ +--- +title: RegExp +slug: Web/JavaScript/Reference/Global_Objects/RegExp +tags: + - Construtor + - Expressões Regulares + - JavaScript + - Referencia + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp +--- +<div>{{JSRef("Global_Objects", "RegExp")}}</div> + +<h2 id="Sumário">Sumário</h2> + +<p>O construtor <strong><code>RegExp</code></strong> cria um objeto de expressão regular para realizar uma correspondência de texto com um padrão.</p> + +<p>Para uma introdução à expressões regulares, leia o <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">capítulo de Expressões Regulares</a> no <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide">Guia de JavaScript</a>.</p> + +<h2 id="Syntax" name="Syntax">Construtor</h2> + +<p>Notações literais e de construtores são possíveis:</p> + +<pre class="syntaxbox"><code><em>/padrão/<var>flags</var></em> +new RegExp(<em>padrão</em>[, <var>flags</var>]) +RegExp(<em>padrão</em>[, <var>flags</var>])</code> +</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>padrão</code></dt> + <dd>O texto da expressão regular, ou como em ES5, outro objeto RegExp. Os padrões podem incluir caracteres especiais para correspondencia em um intervalo maior de valores do que uma string literal.</dd> + <dt><code>flags</code></dt> + <dd> + <p>Se especificado, <kbd>flags</kbd>indica os marcadores que podem ser adicionados, ou se um objeto é suficiente para o padrão, os valores de flags serão substituidos por qualquer uma das flags de objetos. O valor de <kbd>flags</kbd>é uma string contendo qualquer combinação dos seguintes valores:</p> + + <dl> + <dt><code>g</code></dt> + <dd>corresponder globalmente; acha <strong>todas</strong> as correspondências em vez de parar após achar a primeira</dd> + <dt><code>i</code></dt> + <dd>ignorar maiúsc./minúsc.; Se a <em>flag <kbd>u</kbd></em> estiver ativa, deve ser utilizado o <em>Unicode case folding</em></dd> + <dt><code>m</code></dt> + <dd>multilinha; trata caracteres de início e fim (^ e $) ao operar sobre múltiplas linhas (ou seja, corresponder o início ou fim de <em>cada</em> linha (delimitado por \n ou \r), e não apenas o começo ou fim de toda a string de entrada)</dd> + </dl> + + <dl> + <dt><code>u </code>{{experimental_inline}}</dt> + <dd>unicode; trata o padrão como uma sequência de código unicode</dd> + </dl> + + <dl> + <dt><code>y</code> {{experimental_inline}}</dt> + <dd>aderente; corresponde apenas pelo index indicado pela propriedade <code>lastIndex</code> dessa expressão regular na string alvo (e não tenta corresponder de qualquer indexes posteriores).</dd> + </dl> + </dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Há dois modos de criar um objeto <code>RegExp</code>: uma notação literal e um construtor. Para indicar strings, os parâmetros para a notação literal não usam aspas, enquanto os parâmetros para a função do construtor usam. Então, as seguintes expressões criam a mesma expressão regular:</p> + +<pre class="brush: js">/ab+c/i; +new RegExp('ab+c', 'i'); +</pre> + +<p>A notação literal compila a expressão regular em tempo de execução. Use a notação literal quando a expressão regular permanecerá constante. Por exemplo, se você usar a notação literal para construir a expressão regular usada em um <em>loop</em>, a expressão regular não será recompilada a cada iteração</p> + +<p>O construtor do objeto da expressão regular, por exemplo, <code>new RegExp('ab+c')</code>, fornece uma compilação em tempo de execução da expressão regular. Use a função construtora quando você sabe que o padrão da expressão regular será mudado, ou você não sabe o padrão e o está recebendo de outra fonte, como uma entrada do usuário.</p> + +<p>Começando com ECMAScript 6, <code>new RegExp(/ab+c/, 'i')</code>, deixou de lançar um {{jsxref("TypeError")}} ("can't supply flags quando constructing one RegExp from another") quando o primeiro argumento é um <code>RegExp</code> e o segundo argumento <code>flags</code> está presente. Uma nova <code>RegExp</code> dos argumentos é criada ao invés disso.</p> + +<p>Quando se usa a função construtora, as regras de escapar em uma string (preceder caracteres especiais com \ quando incluídos na string) são necessárias. Por exemplo, as declarações a seguir são equivalentes:</p> + +<pre class="brush: js">var re = /\w+/; +var re = new RegExp('\\w+'); +</pre> + +<h2 id="Special_characters_meaning_in_regular_expressions" name="Special_characters_meaning_in_regular_expressions">Significado dos caracteres especiais nas expressões regulares</h2> + +<ul> + <li><a href="#character-classes">Classes de Caracteres</a></li> + <li><a href="#character-sets">Conjuntos de Caracteres</a></li> + <li><a href="#boundaries">Limites</a></li> + <li><a href="#grouping-back-references">Agrupamentos e back references</a></li> + <li><a href="#quantifiers">Quantificadores</a></li> +</ul> + +<table class="fullwidth-table"> + <tbody> + <tr id="character-classes"> + <th colspan="2">Classes de Caracteres</th> + </tr> + <tr> + <th>Caractere</th> + <th>Significado</th> + </tr> + <tr> + <td><code>.</code></td> + <td> + <p>(O ponto) corresponde um único caracter qualquer <em>exceto</em> os caracteres de nova linha: <code>\n</code>, <code>\r</code>, <code>\u2028</code> ou <code>\u2029</code>.</p> + + <p>Note que a flag multilinha <code>m</code> não muda o comportamento do ponto. Então para corresponder um padrão por múltiplas linhas, o conjunto de caracteres <code>[^]</code> pode ser usado, que corresponderá qualquer caractere, incluindo novas linhas.</p> + + <p>Por exemplo, <code>/.y/</code> corresponde "my" e "ay", mas não "yes", em "yes make my day".</p> + </td> + </tr> + <tr> + <td><code>\d</code></td> + <td> + <p>Corresponde um caractere de dígito no alfabeto basic Latin. Equivalente <code>a [0-9]</code>.</p> + + <p>Por exemplo, <code>/\d/</code> ou <code>/[0-9]/</code> corresponde "2" em "B2 é o número da suíte".</p> + </td> + </tr> + <tr> + <td><code>\D</code></td> + <td> + <p>Corresponde qualquer caractere que não é um dígito no alfabeto basic Latin. Equivalente a <code>[^0-9]</code>.</p> + + <p>Por exemplo, <code>/\D/</code> ou <code>/[^0-9]/</code> corresponde "B" em "B2 é o suite number".</p> + </td> + </tr> + <tr> + <td><code>\w</code></td> + <td> + <p>Corresponde qualquer caractere alfanumérico do alfabeto basic Latin, incluindo o underline. Equivalente a <code>[A-Za-z0-9_]</code>.</p> + + <p>Por exemplo, <code>/\w/</code> corresponde "a" em "apple", "5" em "$5.28", e "3" em "3D".</p> + </td> + </tr> + <tr> + <td><code>\W</code></td> + <td> + <p>Corresponde qualquer caractere que não é um alfanumérico do alfabeto basic Latin. Equivalente a <code>[^A-Za-z0-9_]</code>.</p> + + <p>Por exemplo, <code>/\W/</code> ou <code>/[^A-Za-z0-9_]/</code> corresponde "%" em "50%".</p> + </td> + </tr> + <tr> + <td><code>\s</code></td> + <td> + <p>Corresponde um único caractere de espaço em branco, incluindo espaço, tabulação (tab), quebra de página, nova linha (LF) e outros espaços Unicode. Equivalente a <code>[ \f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]</code>.</p> + + <p>Por exemplo, <code>/\s\w*/</code> corresponde " bar" em "foo bar".</p> + </td> + </tr> + <tr> + <td><code>\S</code></td> + <td> + <p>Corresponde um único caractere que não seja um espaço em branco. Equivalente a <code>[^ \f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]</code>.</p> + + <p>Por exemplo, <code>/\S\w*/</code> corresponde "foo" em "foo bar".</p> + </td> + </tr> + <tr> + <td><code>\t</code></td> + <td>Corresponde uma tabulação.</td> + </tr> + <tr> + <td><code>\r</code></td> + <td>Corresponde uma quebra de linha.</td> + </tr> + <tr> + <td><code>\n</code></td> + <td>Corresponde uma nova linha.</td> + </tr> + <tr> + <td><code>\v</code></td> + <td>Corresponde uma tabulação vertical.</td> + </tr> + <tr> + <td><code>\f</code></td> + <td>Corresponde uma quebra de página.</td> + </tr> + <tr> + <td><code>[\b]</code></td> + <td>Corresponde um caracter backspace. (Não confundir com <code>\b</code>)</td> + </tr> + <tr> + <td><code>\0</code></td> + <td>Corresponde um caractere NUL. Não coloque outro dígito seguinte a esse.</td> + </tr> + <tr> + <td><code>\c<em>X</em></code></td> + <td> + <p>Onde <code><em>X</em></code> é uma letra de A - Z. Corresponde um caractere de controle em uma string.</p> + + <p>Por exemplo, <code>/\cM/</code> corresponde control-M em uma string.</p> + </td> + </tr> + <tr> + <td><code>\x<em>hh</em></code></td> + <td>Corresponde o caractere com o código <code><em>hh</em></code> (dois dígitos hexadecimais).</td> + </tr> + <tr> + <td><code>\u<em>hhhh</em></code></td> + <td>Corresponde o caractere com o valor Unicode <code><em>hhhh</em></code> (quatro dígitos hexadecimais).</td> + </tr> + <tr> + <td><code>\</code></td> + <td> + <p>Para caracteres que são geralmente tratados literalmente, indica que o próximo caractere é especial e não deve ser interpretado literalmente.</p> + + <p>Por exemplo, <code>/b/</code> corresponde o caractere "b". Colocando uma barra invertida antes do "b", ou seja, usando <code>/\b/</code>, o caractere se torna especial, significando corresponder o limite de uma palavra.</p> + + <p><em>ou</em></p> + + <p>Para caracteres que são geralmente tratados especialmente, indica que o próximo caractere não é especial e deve ser interpretado literalmente.</p> + + <p>Por exemplo, "*" é um caractere especial que significa 0 ou mais ocorrências do caractere precedente devem ser correspondidas; por exemplo, <code>/a*/</code> significa corresponder 0 ou mais "a"s. Para corresponder <code>*</code> literalmente, preceda-o com uma barra invertida; por exemplo, <code>/a\*/</code> corresponde "a*".</p> + </td> + </tr> + </tbody> + <tbody> + <tr id="character-sets"> + <th colspan="2">Conjuntos de Caracteres</th> + </tr> + <tr> + <th>Caractere</th> + <th>Significado</th> + </tr> + <tr> + <td><code>[xyz]</code></td> + <td> + <p>Um conjunto de caracteres. Corresponde qualquer um dos caracteres cercados. Você pode especificar uma extensão de caracteres usando um hífen.</p> + + <p>Por exemplo, <code>[abcd]</code> é o mesmo que <code>[a-d]</code>. Eles correspondem o "b" em "banco" e o "c" em "cortar".</p> + </td> + </tr> + <tr> + <td><code>[^xyz]</code></td> + <td> + <p>Um conjunto de caracteres negativo ou complementado. Isto é, corresponde qualquer coisa que não esteja cercada nos colchetes. Você pode especificar uma extensão de caracteres usando um hífen.</p> + + <p>Por exemplo, <code>[^abc]</code> é o mesmo que <code>[^a-c]</code>. Eles inicialmente correspondem "n" em "banco" e "o" em "cortar".</p> + </td> + </tr> + </tbody> + <tbody> + <tr id="boundaries"> + <th colspan="2">Limites</th> + </tr> + <tr> + <th>Caractere</th> + <th>Significado</th> + </tr> + <tr> + <td><code>^</code></td> + <td> + <p>Corresponde o início de uma entrada. Se a flag multilinha é utilizada, também corresponde imediatamente após um caractere de quebra de linha.</p> + + <p>Por exemplo, <code>/^A/</code> não corresponde o "A" em "an A", mas corresponde o primeiro "A" em "An A".</p> + </td> + </tr> + <tr> + <td><code>$</code></td> + <td> + <p>Corresponde o fim de uma entrada. Se a flag multilinha é utilizada, também corresponde imediatamente antes de um caractere de quebra de linha.</p> + + <p>Por exemplo, <code>/o$/</code> não corresponde o "o" em "cantor", mas corresponde em "canto".</p> + </td> + </tr> + <tr> + <td><code>\b</code></td> + <td> + <p>Corresponde um limite de palavra de largura zero, como entre uma letra e um espaço. (Não confundir com <code>[\b]</code>)</p> + + <p>Por exemplo, <code>/\bno/</code> corresponde o "no" em "de noite"; <code>/ly\b/</code> corresponde o "ly" em "possibly yesterday".</p> + </td> + </tr> + <tr> + <td><code>\B</code></td> + <td> + <p>Corresponde um limite de uma não palavra de largura zero, como entre duas letras ou entre dois espaços.</p> + + <p>Por exemplo, <code>/\Bte/</code> corresponde "te" em "de noite", e <code>/on\B/</code> corresponde "on" em "possivelmente ontem".</p> + </td> + </tr> + </tbody> + <tbody> + <tr id="grouping-back-references"> + <th colspan="2">Agrupamentos e back references</th> + </tr> + <tr> + <th>Caractere</th> + <th>Significado</th> + </tr> + <tr> + <td><code>(<em>x</em>)</code></td> + <td> + <p>Corresponde <code><em>x</em></code> e memoriza a correspondência. Esses são chamados parênteses de captura.</p> + + <p>Por exemplo, <code>/(foo)/</code> corresponde e memoriza "foo" em "foo bar". A substring correspondida pode ser chamada novamente dos elementos do array resultante <code>[1], ..., [n]</code> ou das propriedades predefinidas do objeto <code>RegExp</code> <code>$1, ..., $9</code>.</p> + + <p>Grupos de captura têm uma falta na performance. Se você não necessita que a substring correspondida seja chamada novamente, prefira parênteses de não-captura (veja mais abaixo).</p> + </td> + </tr> + <tr> + <td><code>\<em>n</em></code></td> + <td> + <p>Onde <code><em>n</em></code> é um inteiro positivo. A back reference to o last substring matching o n parenthetical no expressão regular (counting left parentheses).</p> + + <p>Por exemplo, <code>/apple(,)\sorange\1/</code> corresponde "apple, orange," em "apple, orange, cherry, peach". Um exemplo mais completo está a seguir nesta tabela.</p> + </td> + </tr> + <tr> + <td><code>(?:<em>x</em>)</code></td> + <td>Corresponde <code><em>x</em></code> mas não memoriza a correspondência. Esses são chamados parênteses de não-captura. A substring correspondida não pode ser chamada novamente dos elementos do array resultante <code>[1], ..., [n]</code> ou das propriedades predefinidas do objeto <code>RegExp</code> <code>$1, ..., $9</code>.</td> + </tr> + </tbody> + <tbody> + <tr id="quantifiers"> + <th colspan="2">Quantificadores</th> + </tr> + <tr> + <th>Caractere</th> + <th>Significado</th> + </tr> + <tr> + <td><code><em>x</em>*</code></td> + <td> + <p>Corresponde o item precedente <em>x</em> zero ou mais vezes.</p> + + <p>Por exemplo, <code>/assusto*/</code> corresponde "assustoooo" em "Um fantasma assustoooou" e "assust" em "Não me assustei", mas nada em "Um bode grunhiu".</p> + + <p>Note que no caso acima, o único caractere a ser selecionado é "o", pois ele é o caractere imediatamente anterior ao asterisco e não há qualquer operador de agrupamento que indique que mais caracteres deveriam ser submetidos à repetição. Se quiséssemos selecionar a ocorrência sequencial da palavra completa "blah", por exemplo, poderíamos utilizar algum agrupamento como <code>/(blah)*/</code> o que geraria a seleção de "blahblahblah" na frase "blahblahblah ração para gatos" ou de "blah" na frase "algoritmo blahut-arimoto".</p> + </td> + </tr> + <tr> + <td><code><em>x</em>+</code></td> + <td> + <p>Corresponde o item precedente <em>x</em> uma ou mais vezes. Equivalente a <code>{1,}</code>.</p> + + <p>Por exemplo, <code>/a+/</code> corresponde o "o" em "doce" e todos os "o"s em "doooooooce".</p> + </td> + </tr> + <tr> + <td><code><em>x</em>?</code></td> + <td> + <p>Corresponde o item precedente <em>x</em> nenhuma ou uma vez.</p> + + <p>Por exemplo, <code>/e?le?/</code> corresponde o "el" em "angel" e o "le" em "angle."</p> + + <p>If used imediatamente after qualquer dos quantifiers <code>*</code>, <code>+</code>, <code>?</code>, ou <code>{}</code>, makes o quantifier non-greedy (matching o minimum number of vezes), como opposed to o default, which é greedy (matching o maximum number of vezes).</p> + + <p>Also used em lookahead assertions, described under <code>(?=)</code>, <code>(?!)</code>, e <code>(?:)</code> em this table.</p> + </td> + </tr> + <tr> + <td><code><em>x</em>(?=<em>y</em>)</code></td> + <td>Corresponde <code><em>x</em></code> apenas se <code><em>x</em></code> é seguido por <code><em>y</em></code>. Por exemplo, <code>/Jack(?=Sprat)/</code> corresponde "Jack" apenas se for seguido por "Sprat". <code>/Jack(?=Sprat|Frost)/</code> corresponde "Jack" apenas se for seguido por "Sprat" ou "Frost". Porém, nem "Sprat" nem "Frost" são partes do resultado da correspondência.</td> + </tr> + <tr> + <td><code><em>x</em>(?!<em>y</em>)</code></td> + <td> + <p>Corresponde <code><em>x</em></code> apenas se <code><em>x</em></code> não é seguido por <code><em>y</em></code>. Por exemplo, <code>/\d+(?!\.)/</code> corresponde um número apenas se não for seguido por um ponto.</p> + + <p><code>/\d+(?!\.)/.exec('3.141')</code> corresponde "141", mas não "3.141".</p> + </td> + </tr> + <tr> + <td><code><em>x</em>|<em>y</em></code></td> + <td> + <p>Corresponde <code><em>x</em></code><em> </em>ou <code><em>y</em></code><em>.</em></p> + + <p>Por exemplo, <code>/verde|vermelha/</code> corresponde "verde" em "maçã verde" e "vermelha" em "maçã vermelha".</p> + + <p>Entretanto, a primeira expressão tem preferência. Se uma string fosse corresponder às duas expressões, ela vai corresponder à que aparece do lado esquerdo do operador <code>|</code>. Por exemplo, <code>/maçãs|maçã/</code> corresponde "maçãs" na frase "<u>maçãs</u> vermelhas" e "maçã" na frase "<u>maçã</u> verde".</p> + </td> + </tr> + <tr> + <td><code><em>x</em>{<em>n</em>}</code></td> + <td> + <p>Onde <code><em>n</em></code> é um número inteiro positivo. Corresponde exatamente <code><em>n</em></code> ocorrências do item precedente <em>x</em>.</p> + + <p>Por exemplo, <code>/o{2}/</code> não corresponde o "o" em "brigadeiro", mas corresponde todos os dois "o"s em "brigadeir<u>oo</u>", e o dois primeiros "o"s em "brigadeir<u>oo</u>o".</p> + </td> + </tr> + <tr> + <td><code><em>x</em>{<em>n</em>,}</code></td> + <td> + <p>Onde <code><em>n</em></code> é um número inteiro positivo. Corresponde <em>pelo menos</em> <code><em>n</em></code> ocorrências do item precedente <em>x </em>(sem que haja um limite superior).</p> + + <p>Por exemplo, <code>/o{2,}/</code> não corresponde o "o" em "brigadeiro", mas corresponde todos os "o"s em "brigadeir<u>oo</u>" e em "brigadeir<u>ooooooooo</u>".</p> + </td> + </tr> + <tr> + <td><code><em>x</em>{<em>n</em>,<em>m</em>}</code></td> + <td> + <p>Onde <code><em>n</em></code> e <code><em>m</em></code> são números inteiros positivos. Corresponde pelo menos <code><em>n</em></code> e no máximo <code><em>m</em></code> ocorrências do item precedente <em>x</em>.</p> + + <p>Por exemplo, <code>/o{2,4}/</code> corresponde nada em "brigadeiro", os dois "o"s em "brigadeir<u>oo</u>", os três "o"s em "brigadeir<u>ooo</u>", e os primeiros quatro "o"s em "brigadeir<u>oooo</u>o".</p> + + <p>É importante perceber que no último caso a correspondência não inclui o último "o" de "brigadeirooooo". Isso se deve ao fato do operador quantificador ter definido o número máximo de ocorrências como 4, ignorando a quinta repetição do caractere.</p> + </td> + </tr> + <tr> + <td> + <p><code><em>x</em>*?</code><br> + <code><em>x</em>+?<br> + <em>x??</em><br> + <em>x{n,}?</em><br> + <em>x{n,m}?</em></code></p> + </td> + <td> + <p><strong>Operadores <em>non-greedy </em>ou<em> lazy</em> (não-gulosos ou preguiçosos)</strong><br> + Esses operadores com a <code>?</code> no final, operam de maneira semelhante aos seus análogos sem <code>?</code> mostrados acima, correspondendo múltiplas ocorrências do item precedente <em>x.</em> Entretanto, desta vez a ocorrência selecionada será a mínima possível.</p> + + <p>No exemplo <code>/(blah)*?/</code>, diante da frase "blahblahblah ração para gatos", nada seria selecionado, pois a ocorrência mínima aceita pelo operador <code>*?</code> seria ocorrência de 0 (zero) vezes da <em>string</em> "blah", o que resulta no nada.</p> + + <p>Já a expressão regular <code>/(blah)+?/</code>, diante da mesma frase, corresponderia a "blah", que é a ocorrência mínima aceita pelo operador <code>+?</code><em>, </em>ou seja, 1 (uma) repetição da sequência "blah".</p> + + <p>Em outro exemplo com mais aplicação prática, digamos que se quer corresponder todos os termos que ficam entre aspas em um texto. Se fizéssemos simplesmente a <em>regex</em> <code>/".*"/</code>, diante de um texto com múltiplas ocorrências de termos entre aspas, como: <em>'Eu "gosto" muito de "estudar" regex'</em>, a nossa expressão regular seria gulosa e selecionaria o maior texto possível que correspondesse à definição, nesse caso, selecionando '<em>"gosto" muito de "estudar"</em>', pois todo esse texto está compreendido entre a primeira aspa (antes de <em>'gosto'</em>) e a última aspa (após <em>'estudar'</em>), o que é um resultado talvez indesejado.<br> + Se usarmos a regex <code>/".*?"/</code>, com o operador não-guloso, as correspondências para a mesma frase seriam '<em>"gosto"</em>' e '<em>"estudar"</em>' separadamente, conforme era a intenção inicial.</p> + </td> + </tr> + </tbody> +</table> + +<h2 id="Properties" name="Properties">Propriedades</h2> + +<dl> + <dt>{{jsxref("RegExp.prototype")}}</dt> + <dd>Permite a adição de propriedades a todos os objetos.</dd> + <dt><code>RegExp.length</code></dt> + <dd>O valor of <code>RegExp.length</code> é 2.</dd> +</dl> + +<div>{{jsOverrides("Function", "Properties", "prototype")}}</div> + +<h2 id="Methods" name="Methods">Métodos</h2> + +<p>O objeto global <code>RegExp não possui métodos próprios, no entanto, herda alguns métodos através da cadeia de prototype.</code></p> + +<div>{{jsOverrides("Function", "Methods", "prototype")}}</div> + +<h2 id="Objetos_e_instancias">Objetos e instancias</h2> + +<h3 id="Properties_of_RegExp_instance" name="Properties_of_RegExp_instance">Propriedades</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/prototype', 'Properties')}}</div> + +<h3 id="Methods_of_RegExp_instance" name="Methods_of_RegExp_instance">Métodos</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/prototype', 'Methods')}}</div> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Using_a_regular_expression_to_change_data_format" name="Example:_Using_a_regular_expression_to_change_data_format">Exemplo: Usando uma expressão regular para mudar o fomato dos dados</h3> + +<p>O seguinte script usa o método {{jsxref("String.prototype.replace()", "replace()")}} da instância de {{jsxref("Global_Objects/String", "String")}} para casar o nome no format <em>nome sobrenome</em> e produzir no formato <em>sobrenome, nome</em>. No texto substituto, o script usa <code>$1</code> e <code>$2</code> para indicar os respectivos parênteses de casamento no padrão da expressão regular.</p> + +<pre class="brush: js">var re = /(\w+)\s(\w+)/; +var str = 'John Smith'; +var newstr = str.replace(re, '$2, $1'); +console.log(newstr); +</pre> + +<p>Isto retornará "Smith, John".</p> + +<h3 id="Example_Using_regular_expression_on_multiple_lines" name="Example:_Using_regular_expression_on_multiple_lines">Exemplo: Usando expressões regulares para quebrar linhas com diferentes <strong>fins de linha</strong>/<strong>quebras de linha</strong></h3> + +<p>O final de linha padrão depende da plataforma utilizada (Unix, Windows, etc.). A divisão(<em>split</em>) de linha fornecida neste exemplo funciona com todas as plataformas.</p> + +<pre class="brush: js">var text = 'Um texto\nE mais um pouco\r\nE ainda mais\rEsse é o fim'; +var lines = text.split(/\r\n|\r|\n/); +console.log(lines) // prints [ 'Um texto', 'E mais um pouco', 'E ainda mais', 'Esse é o fim' ]</pre> + +<p>Note que a ordem dos padrões na expressão regular importa.</p> + +<h3 id="Example_Using_regular_expression_on_multiple_lines" name="Example:_Using_regular_expression_on_multiple_lines">Exemplo: Usando expressão regular sobre múltiplas linhas</h3> + +<pre class="brush: js">var s = 'Please yes\nmake my day!'; +s.match(/yes.*day/); +// Retorna null +s.match(/yes[^]*day/); +// Retorna'yes\nmake my day' +</pre> + +<h3 id="Example_Using_a_regular_expression_with_the_.22sticky.22_flag" name="Example:_Using_a_regular_expression_with_the_.22sticky.22_flag">Exemplo: Using a expressão regular com o "sticky" flag</h3> + +<p>Este exemplo mostra como utilizar a sticky flag em expressões regulares.</p> + +<pre class="brush: js">var text = 'First line\nSecond line'; +var regex = /(\S+) line\n?/y; + +var match = regex.exec(text); +console.log(match[1]); // prints 'First' +console.log(regex.lastIndex); // prints '11' + +var match2 = regex.exec(text); +console.log(match2[1]); // prints 'Second' +console.log(regex.lastIndex); // prints '22' + +var match3 = regex.exec(text); +console.log(match3 === null); // prints 'true' +</pre> + +<p>One can test at run-time whether o sticky flag é supported, using <code>try { … } catch { … }</code>. Para this, either an <code>eval(…)</code> expression ou o <code>RegExp(<var>regex-string</var>, <var>flags-string</var>)</code> syntax must be used (since o <code>/<var>regex</var>/<var>flags</var></code> notation é processed at compile-time, so throws an exception before o <code>catch</code> block é encountered). Por exemplo:</p> + +<pre class="brush: js">var supports_sticky; +try { RegExp('', 'y'); supports_sticky = true; } +catch(e) { supports_sticky = false; } +console.log(supports_sticky); // prints 'true' +</pre> + +<h3 id="Example_Regular_expression_and_Unicode_characters" name="Example:_Regular_expression_and_Unicode_characters">Exemplo: Expressão regular e Unicode caracteres</h3> + +<p>As mentioned above, <code>\w</code> ou <code>\W</code> only corresponde ASCII based caracteres; por exemplo, "a" to "z", "A" to "Z", "0" to "9" e "_". To match caracteres from other languages such como Cyrillic ou Hebrew, use <code>\uhhhh</code>, onde "hhhh" é o caractere's Unicode valor em hexadecimal. This exemplo demonstrates how one can separate out Unicode caracteres from uma palavra.</p> + +<pre class="brush: js">var text = 'Образец text на русском языке'; +var regex = /[\u0400-\u04FF]+/g; + +var match = regex.exec(text); +console.log(match[0]); // prints 'Образец' +console.log(regex.lastIndex); // prints '7' + +var match2 = regex.exec(text); +console.log(match2[0]); // prints 'на' [não print 'text'] +console.log(regex.lastIndex); // prints '15' + +// e assim vai +</pre> + +<p>Here's an external resource para getting o complete Unicode block range para different scripts: <a href="http://kourge.net/projects/regexp-unicode-block">Regexp-unicode-block</a>.</p> + +<h3 id="Example_Extracting_subdomain_name_from_URL" name="Example:_Extracting_subdomain_name_from_URL">Exemplo: Extracting subdomain name from URL</h3> + +<pre class="brush: js">var url = 'http://xxx.domain.com'; +console.log(/[^.]+/.exec(url)[0].substr(7)); // prints 'xxx' +</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 em JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.10', 'RegExp')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-regexp-regular-expression-objects', 'RegExp')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</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> + <tr> + <td>Sticky flag ("y")</td> + <td>{{CompatChrome("39")}} (behind flag)</td> + <td>{{CompatGeckoDesktop("1.9")}} ES4-Style {{bug(773687)}}</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 para 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> + <tr> + <td>Sticky flag ("y")</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("1.9")}} ES4-Style {{bug(773687)}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a> chapter no <a href="/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a></li> + <li>{{jsxref("String.prototype.match()")}}</li> + <li>{{jsxref("String.prototype.replace()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/sticky/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/sticky/index.html new file mode 100644 index 0000000000..2030fc7bf1 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/sticky/index.html @@ -0,0 +1,95 @@ +--- +title: RegExp.prototype.sticky +slug: Web/JavaScript/Reference/Global_Objects/RegExp/sticky +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/sticky +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>sticky</code></strong> indica se a busca é "pegajosa" (percorre a string somente a partir do índice indicado pela propriedade {{jsxref("RegExp.lastIndex", "lastIndex")}} desta expressão regular). A propriedade <code>sticky</code> em um objeto de expressão regular é somente para leitura.</p> + +<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-sticky.html")}}</div> + +<p class="hidden">O código fonte para este exemplo interativo está armazenado em um repositório GitHub. Caso deseje contribuir com o projeto de exemplos interativos, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um <em>pull request</em>.</p> + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>O valor de <code>sticky</code> é do tipo {{jsxref("Boolean")}} e será <em>true </em>quando a flag "<code>y</code>" for utilizada; senão, será <em>false</em>. A flag "<code>y</code>" indica que as correspondências ocorrerão apenas a partir do indice indicado pela propriedade {{jsxref("RegExp.lastIndex", "lastIndex")}} desta expressão regular na string alvo (e não buscará correspondência em nenhum índice anterior). Uma expressão regular definida como <code>sticky</code> e <code>global</code> ignora a flag <code>global</code>.</p> + +<p>Você não pode alterar essa propriedade diretamente. Ela é somente para leitura.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Uilizando_uma_expressão_regular_com_a_flag_sticky">Uilizando uma expressão regular com a flag <em>sticky</em></h3> + +<pre class="brush: js">var str = '#foo#'; +var regex = /foo/y; + +regex.lastIndex = 1; +regex.test(str); // true +regex.lastIndex = 5; +regex.test(str); // false (lastIndex é levado em conta com a flag sticky) +regex.lastIndex; // 0 (reinicia quando não ocorre correspondência) +</pre> + +<h3 id="Flag_sticky_ancorada">Flag sticky ancorada</h3> + +<p>Por diversas versões, a engine SpiderMonkey do Firefox apresentou um<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=773687"> bug</a> na asserção de <code>^</code> com a flag <em>sticky </em>que fazia expressões iniciando com <code>^</code> e usando a flag <em>sticky </em>encontrarem correspondências onde não deveriam. O bug foi introduzido algum tempo após o Firefox 3.6 (que possuía a flag sticky mas não apresentava o bug) e corrigido em 2015. Talvez por este motivo, a especificação ES2015 <a href="http://www.ecma-international.org/ecma-262/7.0/index.html#sec-assertion">destaca especificamente</a> que:</p> + +<blockquote> +<p>Quando a flag <code>y</code> for usada em um padrão, ^ indica que a correspondência ocorrerá apenas no início da entrada, ou (se <code>multiline</code> for <code>true</code>) no início de uma linha.</p> +</blockquote> + +<p>Exemplos de comportamento esperado:</p> + +<pre class="brush: js">var regex = /^foo/y; +regex.lastIndex = 2; +regex.test('..foo'); // false - índice 2 não é o início da string + +var regex2 = /^foo/my; +regex2.lastIndex = 2; +regex2.test('..foo'); // false - índice 2 não é o início da string nem da linha +regex2.lastIndex = 2; +regex2.test('.\nfoo'); // true - índice 2 é o início da linha +</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('ES2015', '#sec-get-regexp.prototype.sticky', 'RegExp.prototype.sticky')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-regexp.prototype.sticky', 'RegExp.prototype.sticky')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<div> +<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Caso deseje contribuir, consulte <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um <em>pull request</em>.</div> + +<p>{{Compat("javascript.builtins.RegExp.sticky")}}</p> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("RegExp.lastIndex")}}</li> + <li>{{jsxref("RegExp.prototype.global")}}</li> + <li>{{jsxref("RegExp.prototype.ignoreCase")}}</li> + <li>{{jsxref("RegExp.prototype.multiline")}}</li> + <li>{{jsxref("RegExp.prototype.source")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/test/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/test/index.html new file mode 100644 index 0000000000..c3470dc4fe --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/test/index.html @@ -0,0 +1,152 @@ +--- +title: RegExp.prototype.test() +slug: Web/JavaScript/Reference/Global_Objects/RegExp/test +tags: + - Expressão Regular + - JavaScript + - Prototype + - Referencia + - RegExp + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/test +--- +<div>{{JSRef}}</div> + +<div>O método <strong>test() </strong>executa uma busca por uma correspondência entre uma expressão regular e uma string. Retorna <code>true</code> ou <code>false</code>.</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>regexObj</var>.test(<var>str</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>str</code></dt> + <dd>A string que confrontará a expressão regular.</dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>Boolean.</p> + +<p><code>true</code> se a string <code>str</code> corresponde com o que está descrito na expressão regular.</p> + +<p>Caso contrário, retorna <code>false</code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Use test() sempre que você quiser saber se um padrão está dentro de uma string( similar ao método {{jsxref("String.prototype.search()")}}); Para mais informações (porém com execução mais lenta) use o método {{jsxref("RegExp.prototype.exec()", "exec()")}} (similar ao método {{jsxref("String.prototype.match()")}}). Assim como {{jsxref("RegExp.prototype.exec()", "exec()")}} (ou em combinação com ele), test() quando chamado várias vezes dentro da mesma instância de expressão regular irá avançar seu ponteiro para a correspondência anterior.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_test">Usando <code>test()</code></h3> + +<p>Exemplo simples que verifica se <code>"hello"</code> está presente no início de uma string, retornando um booleano como resultado.</p> + +<pre class="notranslate">const str = 'hello world!'; +const result = /^hello/.test(str); + +console.log(result); // true</pre> + +<p>O exemplo a seguir mostra uma mensagem dependendo do sucesso do teste.</p> + +<pre class="brush: js notranslate">function testinput(re, str){ + var midstring; + if (re.test(str)) { + midstring = ' Contém '; + } else { + midstring = ' não contém '; + } + console.log(str + midstring + re.source); +} +</pre> + +<h2 id="Specificações">Specificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specificações</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.10.6.3', 'RegExp.test')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-regexp.prototype.test', 'RegExp.test')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_Browser">Compatibilidade com 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>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 para 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="Gecko-specific_notes">Gecko-specific notes</h2> + +<p>A priori no Grecko 8.0 {{geckoRelease("8.0")}}, <code>test()</code> foi implementado incorretamente; quando chamado sem parâmetros, ele encontrária uma correspondência com o valor de entrada anterior (<code>RegExp.input</code> property) no lugar de uma correspondência com <code>"undefined"</code>. Isso está conrrigido; agora <code>/undefined/.test()</code> resultará em <code>true</code>, no lugar de um erro.</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a> chapter in the <a href="/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a></li> + <li>{{jsxref("RegExp")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/set/add/index.html b/files/pt-br/web/javascript/reference/global_objects/set/add/index.html new file mode 100644 index 0000000000..c3787149df --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/set/add/index.html @@ -0,0 +1,131 @@ +--- +title: Set.prototype.add() +slug: Web/JavaScript/Reference/Global_Objects/Set/add +tags: + - ECMAScript6 + - JavaScript + - Prototype + - metodo + - set + - set.add +translation_of: Web/JavaScript/Reference/Global_Objects/Set/add +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>add()</strong></code> acrescenta um novo elemento com o valor especificado no final de um objeto <code>Set</code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.add(value);</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt>value</dt> + <dd>Requerido. O valor de um elemento a ser adicionado ao objeto Set.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p><font face="Open Sans, Arial, sans-serif">O objeto </font><code>Set</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_método_add">Usando o método <code>add</code></h3> + +<pre class="brush: js">var mySet = new Set(); + +mySet.add(1); +mySet.add(5).add("some text"); // pode ser encadeado + +console.log(mySet); +// Set [1, 5, "some text"] +</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('ES6', '#sec-set.prototype.add', 'Set.prototype.add')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.add', 'Set.prototype.add')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatilidade_de_Navegadores_(Browser)">Compatilidade de Navegadores (Browser)</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>Suporte Básico</td> + <td>38</td> + <td>{{CompatGeckoDesktop("13.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</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>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatGeckoMobile("13.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notas_específicas_para_Firefox">Notas específicas para Firefox</h2> + +<ul> + <li>Antes do Firefox 33 {{geckoRelease("33")}}, <code>Set.prototype.add retornava</code> <code>undefined</code> e não era possível encadear chamadas. Isto foi resolvido ({{bug(1031632)}}). O comportamento pode ser encontrado no Chrome/v8 (<a href="https://code.google.com/p/v8/issues/detail?id=3410">issue</a>).</li> +</ul> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> + <li>{{jsxref("Set.prototype.has()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/set/clear/index.html b/files/pt-br/web/javascript/reference/global_objects/set/clear/index.html new file mode 100644 index 0000000000..1026fe61f1 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/set/clear/index.html @@ -0,0 +1,110 @@ +--- +title: Set.prototype.clear() +slug: Web/JavaScript/Reference/Global_Objects/Set/clear +translation_of: Web/JavaScript/Reference/Global_Objects/Set/clear +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>clear()</strong></code> remove todos os elementos de um objeto <code>Set</code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.clear();</code></pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_método_clear">Usando o método <code>clear</code></h3> + +<pre class="brush: js">var mySet = new Set(); +mySet.add(1); +mySet.add("foo"); + +mySet.size; // 2 +mySet.has("foo"); // true + +mySet.clear(); + +mySet.size; // 0 +mySet.has("bar") // false +</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('ES6', '#sec-set.prototype.clear', 'Set.prototype.clear')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definições iniciais</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.clear', 'Set.prototype.clear')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores_(Browser)">Compatibilidade de navegadores (Browser)</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>38</td> + <td>{{CompatGeckoDesktop("19.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</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>25</td> + <td>{{CompatGeckoMobile("19.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/set/delete/index.html b/files/pt-br/web/javascript/reference/global_objects/set/delete/index.html new file mode 100644 index 0000000000..0683060777 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/set/delete/index.html @@ -0,0 +1,123 @@ +--- +title: Set.prototype.delete() +slug: Web/JavaScript/Reference/Global_Objects/Set/delete +tags: + - ECMAScript6 + - ES6 + - Prototype + - metodo + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/delete +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>delete()</strong></code> remove o elemento especificado de um objeto <code>Set</code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.delete(value);</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt>value</dt> + <dd>Requerido. O valor do elemento a ser removido do objeto Set.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>Retorna <code>true</code> se um elemento contido no objeto Set foi removido com sucesso; caso contrário <code>false</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Uso_do_método_delete">Uso do método <code>delete</code></h3> + +<pre class="brush: js">var mySet = new Set(); +mySet.add("foo"); + +mySet.delete("bar"); // Retorna false. Nenhum elemento "bar" foi encontrado para deletar. +mySet.delete("foo"); // Retorna true. remoção bem sucedida. + +mySet.has("foo"); // Retorna false. O elemento "foo" não está mais presente. +</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-set.prototype.delete', 'Set.prototype.delete')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.delete', 'Set.prototype.delete')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Navegadores_(Browser)">Compatibilidade de Navegadores (Browser)</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>Suporte Básico</td> + <td>38</td> + <td>{{CompatGeckoDesktop("13.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</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>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatGeckoMobile("13.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.clear()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/set/entries/index.html b/files/pt-br/web/javascript/reference/global_objects/set/entries/index.html new file mode 100644 index 0000000000..67bc464a4e --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/set/entries/index.html @@ -0,0 +1,109 @@ +--- +title: Set.prototype.entries() +slug: Web/JavaScript/Reference/Global_Objects/Set/entries +translation_of: Web/JavaScript/Reference/Global_Objects/Set/entries +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>entries()</strong></code> retorna um novo objeto Iterador (<code>Iterator</code>) que contém <strong>um array de [valor, valor]</strong> para cada elemento de um objeto <code>Set </code>em ordem de inserção. Os objetos <code>Set </code>não possuem <code>chaves (key) </code>como objetos do tipo <code>Map</code>. Entretanto, para manter a API similar a objetos <code>Map</code>, cada entrada (<em>entry</em>) tem o mesmo valor para sua chave (<code>key</code>) e valor (<code>value</code>), então uma matriz <code>array [valor, valor]</code> é retornado.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.entries()</code></pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_entries()">Usando <code>entries()</code></h3> + +<pre class="brush:js">var mySet = new Set(); +mySet.add("foobar"); +mySet.add(1); +mySet.add("baz"); + +var setIter = mySet.entries(); + +console.log(setIter.next().value); // ["foobar", "foobar"] +console.log(setIter.next().value); // [1, 1] +console.log(setIter.next().value); // ["baz", "baz"] +</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('ES6', '#sec-set.prototype.entries', 'Set.prototype.entries')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.entries', 'Set.prototype.entries')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores_(Browser)">Compatibilidade de navegadores (Browser)</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>38</td> + <td>{{ CompatGeckoDesktop("24") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</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>38</td> + <td>{{ CompatGeckoMobile("24") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Set.prototype.keys()")}}</li> + <li>{{jsxref("Set.prototype.values()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/set/has/index.html b/files/pt-br/web/javascript/reference/global_objects/set/has/index.html new file mode 100644 index 0000000000..1a3f5d68c8 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/set/has/index.html @@ -0,0 +1,86 @@ +--- +title: Set.prototype.has() +slug: Web/JavaScript/Reference/Global_Objects/Set/has +translation_of: Web/JavaScript/Reference/Global_Objects/Set/has +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>has()</strong></code><strong> </strong>retorna um valor booleano indicando se um elemento com o valor especificado existe em um objecto <code>Set</code> ou não.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-has.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><em>mySet</em>.has(<em>valor</em>);</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>valor</code></dt> + <dd>O valor para testar a existência no objeto <code>Set</code>.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Retorna <code>true</code> se um elemento com o valor especificado existe no objeto <code>Set</code>; <code>false</code> caso contrário.</p> + +<div class="blockIndicator note"> +<p><strong>Nota: </strong>Tecnicamente falando, <code>has()</code> usa o algorítimo <code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#Same-value-zero_equality">sameValueZero</a></code> para determinar quando o elemento dado é encontrado.</p> +</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_método_has">Usando o método <code>has</code></h3> + +<pre class="brush: js">var mySet = new Set(); +mySet.add('foo'); + +mySet.has('foo'); // retorna true +mySet.has('bar'); // retorna false + +var set1 = new Set(); +var obj1 = {'key1': 1}; +set1.add(obj1); + +set1.has(obj1); // retorna true +set1.has({'key1': 1}); // retorna false porque obj1 e {'key': 1} fazem referência a objetos diferentes. +set1.add({'key1': 1}); // agora set1 contém 2 registros +</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('ES2015', '#sec-set.prototype.has', 'Set.prototype.has')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.has', 'Set.prototype.has')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + + + +<p>{{Compat("javascript.builtins.Set.has")}}</p> + +<h2 id="Veja_também">Veja também:</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.add()")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/set/index.html b/files/pt-br/web/javascript/reference/global_objects/set/index.html new file mode 100644 index 0000000000..261359a0b0 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/set/index.html @@ -0,0 +1,259 @@ +--- +title: Set +slug: Web/JavaScript/Reference/Global_Objects/Set +tags: + - ECMAScript 2015 + - JavaScript + - Objetos + - Objetos Globais + - conjuntos +translation_of: Web/JavaScript/Reference/Global_Objects/Set +--- +<div>{{JSRef("Global_Objects", "Set")}}</div> + +<h2 id="Sumário">Sumário</h2> + +<p>O objeto <strong><code>Set</code></strong> permite que você armazene valores <em>únicos</em> de qualquer tipo, desde {{Glossary("Primitive", "valores primitivos")}} a referências a objetos.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"> new Set([iterable]);</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt>iterable</dt> + <dd>Se um <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">objeto iterável </a>é passado, todos os seus elementos serão adicionados ao novo Set. Se tal parâmetro não for específicado, ou se seu valor for <code>null</code>, o novo <code>Set</code> estará vazio.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Objetos <code style="font-style: normal; line-height: 1.5;">Set</code><span style="line-height: 1.5;"> são coleções de valores nas quais é possível iterar os elementos em ordem de inserção. Um valor no </span><code style="font-style: normal; line-height: 1.5;">Set</code><span style="line-height: 1.5;"> <strong>pode ocorrer apenas uma vez</strong>; ele é único na coleção do </span><code style="font-style: normal; line-height: 1.5;">Set</code><span style="line-height: 1.5;">.</span></p> + +<h3 id="Igualdade_de_valores">Igualdade de valores</h3> + +<p>Como cada valor no Set deve ser único, a igualdade será checada e não é baseada no mesmo algoritmo que aquele usado no operador ===. Especificamente, para <code>Set</code>s, <code>+0</code> (que é exatamente igual a - 0) e <code>- 0</code> são valores diferentes. No entanto, isto foi modificado na última especificação ECMAScript 2015. Iniciado com o Gecko 29.0 {{geckoRelease("29")}} ({{bug("952870")}}) e pelo <a href="https://code.google.com/p/v8/issues/detail?id=3069">recent nightly Chrome</a>, +0 e -0 são tratados com sendo o mesmo valor em objetos conjunto (Set). Também, <code>NaN</code> e <code>undefined </code>podem ser armazenados em um conjunto Set.</p> + +<h2 id="Properties" name="Properties">Propriedades</h2> + +<dl> + <dt><code>Set.length</code></dt> + <dd>O valor da propriedade comprimento é 0.</dd> + <dd>Para contar o número de elementos de um <code>Set</code>, use {{jsxref("Set.prototype.size")}}.</dd> + <dt>{{jsxref("Set.@@species", "get Set[@@species]")}}</dt> + <dd>A função construtora usada para criar objetos derivados.</dd> + <dt>{{jsxref("Set.prototype")}}</dt> + <dd>Representa o prototype do constructor do <code>Set</code>. Permite a adição de propriedades para todos os objetos do tipo <code>Set</code>.</dd> +</dl> + +<h2 id="Boolean_instances" name="Boolean_instances">Instâncias <code>Set</code> </h2> + +<p>Todas as instâncias de <code>Set</code> herdam de {{jsxref("Set.prototype")}}.</p> + +<h3 id="Propriedades">Propriedades</h3> + +<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/Set/prototype','Properties')}}</p> + +<h3 id="Métodos">Métodos</h3> + +<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/Set/prototype','Methods')}}</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Utilizando_o_objeto_Set">Utilizando o objeto <code>Set</code></h3> + +<pre class="brush: js">var meuSet = new Set(); + +meuSet.add(1); // meuSet [1] +meuSet.add(5); // meuSet [1, 5] +meuSet.add(5); // 5 já foi adicionando, portanto, meuSet [1, 5] +meuSet.add("texto"); +var o = {a: 1, b: 2}; +meuSet.add(o); + +meuSet.add({a: 1, b: 2}); // o está referenciando outro objeto + +meuSet.has(1); // true +meuSet.has(3); // false, 3 não foi adicionado ao set (Conjunto) +meuSet.has(5); // true +meuSet.has(Math.sqrt(25)); // true +meuSet.has("Texto".toLowerCase()); // true +meuSet.has(o); // true + +meuSet.size; // 5 + +meuSet.delete(5); // remove 5 do set +meuSet.has(5); // false, 5 já foi removido + +meuSet.size; // 4, nós simplesmente removemos um valor + +console.log(meuSet) // Set { 1, 'texto', { a: 1, b: 2 }, { a: 1, b: 2 } } +</pre> + + + +<h3 id="Iterando_objetos_Set">Iterando objetos <code>Set</code></h3> + +<pre class="brush: js">// iterar sobre os itens em set +// loga os itens na ordem: 1, "texto" +for (let item of meuSet) console.log(item); + +// loga os itens na ordem: 1, "texto" +for (let item of meuSet.keys()) console.log(item); + +// loga os itens na ordem: 1, "texto" +for (let item of meuSet.values()) console.log(item); + +// loga os itens na ordem: 1, "texto" +//(key e value são os mesmos aqui) +for (let [key, value] of meuSet.entries()) console.log(key); + +// converte Set para um Array +var meuArr = [v for (v of mySet)]; // [1, "some text"] + +// o seguinte também funcionará se for executado em um documento HTML +mySet.add(document.body); +mySet.has(document.querySelector("body")); // true + +// a conversão entre Set e Array +mySet2 = Set([1,2,3,4]); +mySet2.size; // 4 +[...mySet2]; // [1,2,3,4] + +// intersecção pode ser simulado via +var intersection = new Set([...set1].filter(x => set2.has(x))); + +// Iterar entradas set com forEach +meuSet.forEach(function(value) { + console.log(value); +}); + +// 1 +// 2 +// 3 +// 4</pre> + +<h3 id="Implementando_operações_básicas_entre_conjuntos">Implementando operações básicas entre conjuntos</h3> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">function</span> is<span class="function token">Superset</span><span class="punctuation token">(</span><span class="keyword token">set</span><span class="punctuation token">,</span> subset<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> subset<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">if</span> <span class="punctuation token">(</span><span class="operator token">!</span><span class="keyword token">set</span><span class="punctuation token">.</span><span class="function token">has</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">return</span> <span class="keyword token">false</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + <span class="punctuation token">}</span> + <span class="keyword token">return</span> <span class="keyword token">true</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span> + +<span class="keyword token">function</span> <span class="function token">uniao</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> _uniao <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span>setA<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span> + _uniao<span class="punctuation token">.</span><span class="function token">add</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + <span class="keyword token">return</span> _uniao<span class="punctuation token">;</span> +<span class="punctuation token">}</span> + +<span class="keyword token">function</span> <span class="function token">interseccao</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> _<span class="function token">interseccao</span> <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">if</span> <span class="punctuation token">(</span>setA<span class="punctuation token">.</span><span class="function token">has</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + _<span class="function token">interseccao</span><span class="punctuation token">.</span><span class="function token">add</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + <span class="punctuation token">}</span> + <span class="keyword token">return</span> _<span class="function token">interseccao</span><span class="punctuation token">;</span> +<span class="punctuation token">}</span> + +<span class="keyword token">function</span> <span class="function token">diferencaSimetrica</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> _diferenca <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span>setA<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">if</span> <span class="punctuation token">(</span>_diferenca<span class="punctuation token">.</span><span class="function token">has</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> + _diferenca<span class="punctuation token">.</span><span class="keyword token">delete</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> <span class="keyword token">else</span> <span class="punctuation token">{</span> + _diferenca<span class="punctuation token">.</span><span class="function token">add</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + <span class="punctuation token">}</span> + <span class="keyword token">return</span> _diferenca<span class="punctuation token">;</span> +<span class="punctuation token">}</span> + +<span class="keyword token">function</span> <span class="function token">diferenca</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span> + <span class="keyword token">var</span> _diferenca <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span>setA<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span> + _diferenca<span class="punctuation token">.</span><span class="keyword token">delete</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span> + <span class="punctuation token">}</span> + <span class="keyword token">return</span> _diferenca<span class="punctuation token">;</span> +<span class="punctuation token">}</span> + +<span class="comment token">//Exemplos</span> +<span class="keyword token">var</span> setA <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span><span class="punctuation token">[</span><span class="number token">1</span><span class="punctuation token">,</span> <span class="number token">2</span><span class="punctuation token">,</span> <span class="number token">3</span><span class="punctuation token">,</span> <span class="number token">4</span><span class="punctuation token">]</span><span class="punctuation token">)</span><span class="punctuation token">,</span> + setB <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span><span class="punctuation token">[</span><span class="number token">2</span><span class="punctuation token">,</span> <span class="number token">3</span><span class="punctuation token">]</span><span class="punctuation token">)</span><span class="punctuation token">,</span> + setC <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span><span class="punctuation token">[</span><span class="number token">3</span><span class="punctuation token">,</span> <span class="number token">4</span><span class="punctuation token">,</span> <span class="number token">5</span><span class="punctuation token">,</span> <span class="number token">6</span><span class="punctuation token">]</span><span class="punctuation token">)</span><span class="punctuation token">;</span> + +<span class="function token">isSuperset</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setB<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// => true</span> +<span class="function token">uniao</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setC<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// => Set [1, 2, 3, 4, 5, 6]</span> +<span class="function token">interseccao</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setC<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// => Set [3, 4]</span> +<span class="function token">diferencaSimetrica</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setC<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// => Set [1, 2, 5, 6]</span> +<span class="function token">diferenca</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setC<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// => Set [1, 2]</span></code></pre> + +<h3 id="Relação_com_objetos_Array">Relação com objetos <code>Array</code> </h3> + +<pre class="brush: js">var myArray = ["value1", "value2", "value3"]; + +// Use o construtor regular de Set para transformar um array dentro de um Set +var mySet = new Set(myArray); + +mySet.has("value1"); // retorna true + +// Use o operador de propagação para transformar um Set em um Array. +alert(uneval([...mySet])); // Irá mostrar-lhe exatamente o mesmo Array como myArray</pre> + +<h3 id="Removendo_elementos_duplicados_de_um_Array">Removendo elementos duplicados de um <code>Array</code></h3> + +<pre class="line-numbers language-html"><code class="language-html">// Use para remover elementos duplicados de um Array + +const numeros = [2,3,4,4,2,3,3,4,4,5,5,6,6,7,5,32,3,4,5] + +console.log([...new Set(numeros)]) + +// [2, 3, 4, 5, 6, 7, 32]</code></pre> + +<h3 id="Relação_com_objetos_String">Relação com objetos <code>String</code></h3> + +<pre class="brush: js line-numbers language-js"><code class="language-js"><span class="keyword token">var</span> texto <span class="operator token">=</span> <span class="string token">'India'</span><span class="punctuation token">;</span> + +<span class="keyword token">var</span> meuSet <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span>texto<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// Set ['I', 'n', 'd', 'i', 'a']</span> +meuSet<span class="punctuation token">.</span>size<span class="punctuation token">;</span> <span class="comment token">// 5</span></code></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('ES2015', '#sec-set-objects', 'Set')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set-objects', 'Set')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador_Browser">Compatibilidade de navegador (Browser)</h2> + + + +<p>{{Compat("javascript.builtins.Set")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/set/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/set/prototype/index.html new file mode 100644 index 0000000000..2438fccc1c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/set/prototype/index.html @@ -0,0 +1,84 @@ +--- +title: Set.prototype +slug: Web/JavaScript/Reference/Global_Objects/Set/prototype +tags: + - Propriedade + - Prototipo + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set +--- +<div>{{JSRef}}</div> + +<p>A propriedade <code><strong>Set</strong></code><strong><code>.prototype</code></strong> representa o protótipo do construtor do objeto {{jsxref("Set")}}.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Instâncias de {{jsxref("Set")}} herdam de {{jsxref("Set.prototype")}}. Você pode usar o construtor do objeto protótipo para adicionar propriedades ou métodos para todas as instâncias de <code>Set</code> .</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>Set.prototype.constructor</code></dt> + <dd>Retorna a função que criou o protótipo de uma instância. Esta é a função {{jsxref("Set")}} por padrão.</dd> + <dt>{{jsxref("Set.prototype.size")}}</dt> + <dd>Retorna o número de valores no objeto <code>Set</code>.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{jsxref("Set.add", "Set.prototype.add(value)")}}</dt> + <dd>Anexa um novo elemento com o valor passado ao objeto <code>Set</code> . Retorna o objeto <code>Set</code>.</dd> + <dt>{{jsxref("Set.prototype.clear()")}}</dt> + <dd>Remove todos os elementos do objeto <code>Set</code>.</dd> + <dt>{{jsxref("Set.delete", "Set.prototype.delete(value)")}}</dt> + <dd>Remove o elemento associado ao <code>value</code> e retorna o valor que <code>Set.prototype.has(value)</code> teria retornado anteriormente. <code>Set.prototype.has(value)</code> irá retornar <code>false</code> depois disso.</dd> + <dt>{{jsxref("Set.prototype.entries()")}}</dt> + <dd>Retorna um novo objeto <code>Iterator</code> que contém<strong> um array de <code>[value, value]</code></strong> para cada elemento no objeto <code>Set</code> , em ordem de inserção. Isso é similar ao objeto <code>Map</code>, para que cada entrada tenha o mesmo valor para sua <em>chave</em> e<em>valor </em>aqui.</dd> + <dt>{{jsxref("Set.forEach", "Set.prototype.forEach(callbackFn[, thisArg])")}}</dt> + <dd>Chama <code>callbackFn</code> uma vez para cada valor presente no objeto <code>Set</code>, em ordem de inserção. Se um parâmetro <code>thisArg</code> for passado para o <code>forEach</code>, ele será usado como valor de <code>this</code> para cada callback.</dd> + <dt>{{jsxref("Set.has", "Set.prototype.has(value)")}}</dt> + <dd>Retorna um booleano afirmando se um elemento está presente com o dado valor no objeto <code>Set</code> ou não.</dd> + <dt>{{jsxref("Set.prototype.keys()")}}</dt> + <dd>É a mesma função que a função <strong><code>values()</code></strong> e retorna um novo objeto <code>Iterator</code> que contém os valores para cada elemento no objeto <code>Set</code> em ordem de inserção.</dd> + <dt>{{jsxref("Set.prototype.values()")}}</dt> + <dd>Retorna um novo objeto <code>Iterator</code> que contém os <strong>values</strong> para cada elemento no objeto <code>Set</code> em ordem de inserção.</dd> + <dt>{{jsxref("Set.prototype.@@iterator()", "Set.prototype[@@iterator]()")}}</dt> + <dd>Retorna um novo objeto <code>Iterator</code> que contém os <strong>values</strong> para cada elemento do objeto <code>Set</code> em ordem de inserção.</dd> +</dl> + +<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('ES2015', '#sec-set.prototype', 'Set.prototype')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype', 'Set.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + + + +<p>{{Compat("javascript.builtins.Set.prototype")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Map.prototype")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/set/values/index.html b/files/pt-br/web/javascript/reference/global_objects/set/values/index.html new file mode 100644 index 0000000000..be96764668 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/set/values/index.html @@ -0,0 +1,72 @@ +--- +title: Set.prototype.values() +slug: Web/JavaScript/Reference/Global_Objects/Set/values +translation_of: Web/JavaScript/Reference/Global_Objects/Set/values +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>values()</strong></code> retorna um novo objeto <code>Iterator</code> que contem os valores para cada elemento dentro do objeto <code>Set</code> por ordem de inserção.</p> + +<p>O método <strong><code>keys()</code></strong> é um alias desse método (por similaridade com os objetos {{jsxref("Map")}}); ele se comporta exatamente da mesma forma e retorna os <strong>valores</strong> dos elementos do <code>Set</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-values.html")}}</div> + +<p class="hidden">O código-fonte dos exemplos interativos a seguir estão em um repositório do GitHub. Se você quiser contribuir com os mesmos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e crie um pull request.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.values(); +</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um novo objeto <code><strong>Iterator</strong></code> condendo os valores de cada elemento contido no <code>Set</code>, por ordem de inserção.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_values()">Usando <code>values()</code></h3> + +<pre class="brush:js">var mySet = new Set(); +mySet.add('foo'); +mySet.add('bar'); +mySet.add('baz'); + +var setIter = mySet.values(); + +console.log(setIter.next().value); // "foo" +console.log(setIter.next().value); // "bar" +console.log(setIter.next().value); // "baz"</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('ES2015', '#sec-set.prototype.values', 'Set.prototype.values')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definições iniciais.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.values', 'Set.prototype.values')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browsers_compatíveis">Browsers compatíveis</h2> + + + +<p>{{Compat("javascript.builtins.Set.values")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Set.prototype.entries()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/@@iterator/index.html b/files/pt-br/web/javascript/reference/global_objects/string/@@iterator/index.html new file mode 100644 index 0000000000..5a7700861c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/@@iterator/index.html @@ -0,0 +1,84 @@ +--- +title: 'String.prototype[@@iterator]()' +slug: Web/JavaScript/Reference/Global_Objects/String/@@iterator +tags: + - Iterador + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/@@iterator +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>[@@iterator]()</code></strong> retorna um novo objeto <code>Iterator</code> que itera sobre os pontos de código do valor da String, retornando cada ponto de código como um valor String.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>[Symbol.iterator]</code></pre> + +<h3 id="Valor_de_Retorno">Valor de Retorno</h3> + +<p>Novo objeto <code>Iterator</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_iterator">Usando <code>[@@iterator]()</code></h3> + +<pre class="brush:js notranslate">var str = 'A\uD835\uDC68'; + +var strIter = str[Symbol.iterator](); + +console.log(strIter.next().value); // "A" +console.log(strIter.next().value); // "\uD835\uDC68" +</pre> + +<h3 id="Usando_iterator_com_for..of">Usando <code>[@@iterator]()</code> com <code>for..of</code></h3> + +<pre class="brush:js notranslate">var str = 'A\uD835\uDC68B\uD835\uDC69C\uD835\uDC6A'; + +for (var v of str) { + console.log(v); +} +// "A" +// "\uD835\uDC68" +// "B" +// "\uD835\uDC69" +// "C" +// "\uD835\uDC6A" +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col"></th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.@@iterator")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/anchor/index.html b/files/pt-br/web/javascript/reference/global_objects/string/anchor/index.html new file mode 100644 index 0000000000..99207cfb2d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/anchor/index.html @@ -0,0 +1,76 @@ +--- +title: String.prototype.anchor() +slug: Web/JavaScript/Reference/Global_Objects/String/anchor +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<div>O método <strong><code>anchor()</code></strong> cria uma string começando com uma tag inicial <code><a name="..."></code>, um texto e uma tag final <code></a></code>.</div> + +<div class="blockIndicator warning"> +<p>Não use este método. Ao invés, use <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model">DOM APIs</a>. Além disso, a especificação HTML não permite mais que o elemento <a> tenha um atributo <strong>"name"</strong>, portanto, esse método nem mesmo cria uma tag válida.</p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.anchor(<var>name</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>name</code></dt> + <dd>Uma string que deve representar o valor do atributo <em><code>name</code>.</em></dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string começando com uma tag de início <em><code><a name="name"></code></em>, depois o valor da string e, em seguida, uma tag de fim <em><code></a></code></em>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Não use este método. Ao invés, use <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model">DOM APIs</a>. Além disso, a especificação HTML não permite mais que o elemento <em><code><a></code></em> tenha um atributo <strong>"name"</strong>, portanto, esse método nem mesmo cria uma tag válida.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_anchor">Usando <code>anchor()</code></h3> + +<pre class="brush: js notranslate">const nome = 'Ricardo'; +console.log(nome.anchor('https://developer.mozilla.org/pt-BR/)'); +</pre> + +<p>irá retornar o seguinte código HTML:</p> + +<pre class="brush: html notranslate">'<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body"><span class="objectBox objectBox-string"><a name="<a class="url" href="https://developer.mozilla.org/pt-BR/" rel="noopener noreferrer" title="https://developer.mozilla.org/pt-BR/">https://developer.mozilla.org/pt-BR/</a>">Ricardo</a></span></span></span></span>' +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.anchor', 'String.prototype.anchor')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.anchor")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.link()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/big/index.html b/files/pt-br/web/javascript/reference/global_objects/string/big/index.html new file mode 100644 index 0000000000..cbfea513f1 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/big/index.html @@ -0,0 +1,76 @@ +--- +title: String.prototype.big() +slug: Web/JavaScript/Reference/Global_Objects/String/big +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/big +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <strong>big()</strong> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/big" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/big"><big></a> fazendo com que o texto dentro dele seja exibido uma uma fonte maior.</p> + +<div class="note"> +<p><strong>Nota de uso:</strong> O elemento <big> foi removido no <a href="/en-US/docs/Web/Guide/HTML/HTML5">HTML5</a> e não deve mais ser usado. Em vez disso, web developers devem usar a <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/font-size" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/font-size">propriedade CSS correspondente</a>.</p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.big()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>big()</code> cria uma string dentro de uma tag <code><big></code>:<br> + <code>"<big>str</big>"</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_big">Usando <code>big()</code></h3> + +<p>Os exemplos abaixo usam métodos do objeto <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings" title="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings">String </a>para alterar o tamanho de uma string:</p> + +<pre class="brush: js notranslate">var worldString = 'Olá, mundo'; + +console.log(worldString.small()); // <small>Olá, mundo</small> +console.log(worldString.big()); // <big>Olá, mundo</big> +console.log(worldString.fontsize(7)); // <fontsize=7>Olá, Mundo</fontsize> +</pre> + +<p>Com o objeto <code>element.style</code> você pode selecionar o atributo <code>style</code> do elemento e manipulá-lo de forma mais genérica, por exemplo:</p> + +<pre class="brush: js notranslate">document.getElementById('#oIdDoElemento').style.fontSize = '2em'; +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.big', 'String.prototype.big')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.big")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> + <li>{{jsxref("String.prototype.small()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/blink/index.html b/files/pt-br/web/javascript/reference/global_objects/string/blink/index.html new file mode 100644 index 0000000000..b6c77214bb --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/blink/index.html @@ -0,0 +1,71 @@ +--- +title: String.prototype.blink() +slug: Web/JavaScript/Reference/Global_Objects/String/blink +tags: + - Descontinuado + - JavaScript + - Prototipo + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/blink +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code><strong>blink()</strong></code> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/blink" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/blink"><blink></a> que faz uma string piscar.</p> + +<div class="warning"> +<p><strong>Aviso:</strong> A criação de textos que piscam é desaprovada por vários padrões de acessibilidade. O próprio elemento <code><blink></code> não é padrão e está obsoleto!</p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.blink()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/blink" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/blink"><blink></a>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>blink()</code> cria uma string dentro de uma tag <code><blink></code>:<br> + <code>"<blink>str</blink>"</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_blink">Usando <code>blink()</code></h3> + +<p>Os exemplos abaixo usam métodos do objeto <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings" title="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings">String </a>para alterar a formatação de uma string:</p> + +<pre class="brush: js notranslate">var worldString = 'Olá, mundo'; + +console.log(worldString.blink()); // <blink>Olá, mundo</blink> +console.log(worldString.bold()); // <b>Olá, mundo</b> +console.log(worldString.italics()); // <i>Olá, mundo</i> +console.log(worldString.strike()); // <strike>Olá, mundo</strike></pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.blink', 'String.prototype.blink')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.blink")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/bold/index.html b/files/pt-br/web/javascript/reference/global_objects/string/bold/index.html new file mode 100644 index 0000000000..bc34403734 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/bold/index.html @@ -0,0 +1,68 @@ +--- +title: String.prototype.bold() +slug: Web/JavaScript/Reference/Global_Objects/String/bold +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/bold +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code><strong>bold()</strong></code> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/b" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/b"><b></a> que faz com que uma string seja exibida em negrito.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.bold()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/b" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/b"><b></a> .</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>bold()</code> cria uma string dentro de uma tag <code><b></code>:<br> + <code>"<b>str</b>"</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_bold">Usando <code>bold()</code></h3> + +<p>Os exemplos abaixo usam métodos do objeto <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings" title="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings">String </a>para alterar a formatação de uma string:</p> + +<pre class="brush: js notranslate">var worldString = 'Olá, mundo'; + +console.log(worldString.blink()); // <blink>Olá, mundo</blink> +console.log(worldString.bold()); // <b>Olá, mundo</b> +console.log(worldString.italics()); // <i>Olá, mundo</i> +console.log(worldString.strike()); // <strike>Olá, mundo</strike></pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.bold', 'String.prototype.bold')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.bold")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/charat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/charat/index.html new file mode 100644 index 0000000000..87866ac56b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/charat/index.html @@ -0,0 +1,290 @@ +--- +title: String.prototype.charAt() +slug: Web/JavaScript/Reference/Global_Objects/String/charAt +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>charAt()</code></strong> retorna o caractere especificado a partir de uma string.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.charAt(<var>index</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>index</code></dt> + <dd>Um inteiro entre <code>0</code> e <code>str.length - 1</code>. Se nenhum índice for definido, <code>charAt()</code> usará <code>0</code> como índice.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string representando o caractere no índice especificado. Uma string vazia se o <strong><code>index</code> </strong>fornecido estiver fora do intervalo de índices da string <code>str</code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é <code>0</code><strong> </strong>(zero), e o índice do último caractere em uma string declarada como <code>stringName</code> é <code>stringName.length - 1</code>. Se o índice que você fornecer estiver fora do intervalo de índices da string, JavaScript retornará uma string vazia.</p> + +<p>Se nenhum índice for passado para <code>charAt()</code>, <code>0</code> será usado por padrão.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Mostrando_caracteres_em_diferente_localizações_em_uma_string">Mostrando caracteres em diferente localizações em uma string</h3> + +<p>O exemplo a seguir mostra caracteres em diferentes locais em uma string <code>"Brave new world"</code>:</p> + +<pre class="brush: js notranslate">var anyString = 'Brave new world'; + +console.log("A letra no índice 0 é '" + anyString.charAt(0) + "'"); +console.log("A letra no índice 1 é '" + anyString.charAt(1) + "'"); +console.log("A letra no índice 2 é '" + anyString.charAt(2) + "'"); +console.log("A letra no índice 3 é '" + anyString.charAt(3) + "'"); +console.log("A letra no índice 4 é '" + anyString.charAt(4) + "'"); +console.log("A letra no índice 99 é '" + anyString.charAt(999) + "'"); +</pre> + +<p>As linhas acima retornam o seguinte:</p> + +<pre class="brush: js notranslate">A letra no índice 0 é 'B' +A letra no índice 1 é 'r' +A letra no índice 2 é 'a' +A letra no índice 3 é 'v' +A letra no índice 4 é 'e' +A letra no índice 99 é '' +</pre> + +<h3 id="Obtendo_caracteres_inteiros">Obtendo caracteres inteiros</h3> + +<p>O seguinte código fornece um meio de garantir que passar por um loop de string sempre forneça um caractere inteiro, mesmo se a string contiver caracteres que não estão no <a href="https://pt.wikipedia.org/wiki/Plano_(Unicode)" title="https://pt.wikipedia.org/wiki/Plano_(Unicode)">Plano Multilíngue Básico</a>.</p> + +<pre class="brush: js notranslate">var str = 'A \uD87E\uDC04 Z'; // We could also use a non-BMP character directly +for (var i = 0, chr; i < str.length; i++) { + if ((chr = getWholeChar(str, i)) === false) { + continue; + } + // Adapt this line at the top of each loop, passing in the whole string and + // the current iteration and returning a variable to represent the + // individual character + + console.log(chr); +} + +function getWholeChar(str, i) { + var code = str.charCodeAt(i); + + if (isNaN(code)) { + return ''; // Position not found + } + if (code < 0xD800 || code > 0xDFFF) { + return str.charAt(i); + } + + // High surrogate (could change last hex to 0xDB7F to treat high private + // surrogates as single characters) + if (0xD800 <= code && code <= 0xDBFF) { + if (str.length <= (i + 1)) { + throw 'High surrogate without following low surrogate'; + } + var next = str.charCodeAt(i + 1); + if (0xDC00 > next || next > 0xDFFF) { + throw 'High surrogate without following low surrogate'; + } + return str.charAt(i) + str.charAt(i + 1); + } + // Low surrogate (0xDC00 <= code && code <= 0xDFFF) + if (i === 0) { + throw 'Low surrogate without preceding high surrogate'; + } + var prev = str.charCodeAt(i - 1); + + // (could change last hex to 0xDB7F to treat high private + // surrogates as single characters) + if (0xD800 > prev || prev > 0xDBFF) { + throw 'Low surrogate without preceding high surrogate'; + } + // We can pass over low surrogates now as the second component + // in a pair which we have already processed + return false; +} +</pre> + +<p>Em um ambiente ECMAScript 2016 que permite atribuição desestruturada, o seguinte código é uma alternativa mais sucinta e um pouco mais flexível, pois faz incremento para uma variável de incremento automaticamente (se o caractere justificar que seja um par substituto).</p> + +<pre class="brush: js notranslate">var str = 'A\uD87E\uDC04Z'; // We could also use a non-BMP character directly +for (var i = 0, chr; i < str.length; i++) { + [chr, i] = getWholeCharAndI(str, i); + // Adapt this line at the top of each loop, passing in the whole string and + // the current iteration and returning an array with the individual character + // and 'i' value (only changed if a surrogate pair) + + console.log(chr); +} + +function getWholeCharAndI(str, i) { + var code = str.charCodeAt(i); + + if (isNaN(code)) { + return ''; // Position not found + } + if (code < 0xD800 || code > 0xDFFF) { + return [str.charAt(i), i]; // Normal character, keeping 'i' the same + } + + // High surrogate (could change last hex to 0xDB7F to treat high private + // surrogates as single characters) + if (0xD800 <= code && code <= 0xDBFF) { + if (str.length <= (i + 1)) { + throw 'High surrogate without following low surrogate'; + } + var next = str.charCodeAt(i + 1); + if (0xDC00 > next || next > 0xDFFF) { + throw 'High surrogate without following low surrogate'; + } + return [str.charAt(i) + str.charAt(i + 1), i + 1]; + } + // Low surrogate (0xDC00 <= code && code <= 0xDFFF) + if (i === 0) { + throw 'Low surrogate without preceding high surrogate'; + } + var prev = str.charCodeAt(i - 1); + + // (could change last hex to 0xDB7F to treat high private surrogates + // as single characters) + if (0xD800 > prev || prev > 0xDBFF) { + throw 'Low surrogate without preceding high surrogate'; + } + // Return the next character instead (and increment) + return [str.charAt(i + 1), i + 1]; +} +</pre> + +<h3 id="Corrigindo_charAt_para_suportar_caracteres_não-Plano-Multilíngüe-Básico_PMB">Corrigindo <code>charAt()</code> para suportar caracteres não-Plano-Multilíngüe-Básico (PMB)</h3> + +<p>Embora o exemplo anterior possa ser mais útil para programas que devem suportar caracteres não BMP (uma vez que não exige que o chamador saiba onde qualquer caractere não BMP pode aparecer), no caso de desejar, na escolha de um caractere por índice, para tratar os pares substitutos em uma string como os caracteres únicos que eles representam, pode-se usar o seguinte:</p> + +<pre class="brush: js notranslate">function fixedCharAt(str, idx) { + var ret = ''; + str += ''; + var end = str.length; + + var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; + while ((surrogatePairs.exec(str)) != null) { + var li = surrogatePairs.lastIndex; + if (li - 2 < idx) { + idx++; + } else { + break; + } + } + + if (idx >= end || idx < 0) { + return ''; + } + + ret += str.charAt(idx); + + if (/[\uD800-\uDBFF]/.test(ret) && /[\uDC00-\uDFFF]/.test(str.charAt(idx + 1))) { + // Go one further, since one of the "characters" is part of a surrogate pair + ret += str.charAt(idx + 1); + } + return ret; +} +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li><a href="https://mathiasbynens.be/notes/javascript-unicode">JavaScript has a Unicode problem – Mathias Bynens</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.html new file mode 100644 index 0000000000..67bbbac67d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.html @@ -0,0 +1,213 @@ +--- +title: String.prototype.charCodeAt() +slug: Web/JavaScript/Reference/Global_Objects/String/charCodeAt +tags: + - JavaScript + - Referencia + - String + - Unicode + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>charCodeAt()</code></strong> retorna um número inteiro entre <code>0</code> e <code>65535</code> que representa a unidade de código UTF-16 no índice fornecido. A unidade de código UTF-16 corresponde ao ponto de código Unicode para pontos de códigos representáveis em uma única unidade de código UTF-16, mas também pode ser a primeira unidade de código de um par substituto não representável em uma única unidade de código UTF-16. Po exemplo: pontos de código Unicode > (0x10000). Se você quer o valor do ponto de código inteiro, use <strong><code>codePointAt</code></strong>().</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.charCodeAt(<em>index</em>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>index</code></dt> + <dd>Um inteiro maior ou igual a <code>0</code> e menor que o comprimento da string. Se não for um número, o padrão será <code>0</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um número representando o valor de unidade de código UTF-16 do caractere no índice fornecido. O valor {{jsxref("Global_Objects/NaN", "NaN")}} é retornado se o índice estiver fora do intervalo aceitável.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Os pontos de código Unicode variam de <code>0</code> a <code>1114111</code> (<code>0x10FFFF</code>). Os primeiros 128 pontos de código Unicode são uma correspondência direta da codificação de caracteres ASCII. (Para informações sobre Unicode, veja o <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Values,_variables,_and_literals" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Values,_variables,_and_literals">JavaScript Guide</a>.)</p> + +<div class="blockIndicator note"> +<p><strong>Nota</strong>: o <code>charCodeAt()</code> sempre retornará um valor menor do que <code>65536</code>. Isso ocorre pois os pontos de código mais altos são representados por um par de pseudo-caracteres "substitutos" (de menor valor) que são usados para compreender o caracter real.<br> + <br> + Por isso, para examinar (ou reproduzir) o caractere completo para valores de caracteres individuais de valor <code>65536</code> e acima, é necessário recuperar não apenas o <code>charCodeAt(<em>i</em>)</code>, mas também o <code>charCodeAt(<em>i</em>+1)</code> (como se examinando/reproduzindo a string com duas letras), ou usar o <code>codePointAt(<em>i</em>)</code>. Veja o exemplo 2 e 3 (abaixo).</p> +</div> + +<p>Compatibilidade com versões anteriores: Em versões históricas (como JavaScript 1.2) o método <code>charCodeAt()</code> retorna um número indicando o valor de conjunto de códigos ISO-Latin-1 do caractere no dado índice. O conjunto de códigos ISO-Latin-1 varia de <code>0</code> a <code>255</code>. Os primeiros <code>128</code> (do <code>0</code> ao <code>127</code>) são uma correspondência direta ao conjunto de caracteres ASCII.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_charCodeAt">Usando <code>charCodeAt()</code></h3> + +<p>O exemplo a seguir retorna <code>65</code>, o valor Unicode para A.</p> + +<pre class="brush: js notranslate">'ABC'.charCodeAt(0); // retorna 65 +</pre> + +<h3 id="Corrigindo_o_charCodeAt_para_manipular_caracteres_de_Plano_Multilingual_não_Básico_se_sua_presença_na_string_é_desconhecida">Corrigindo o <code>charCodeAt()</code> para manipular caracteres de Plano Multilingual não Básico se sua presença na string é desconhecida</h3> + +<p>Essa versão pode ser usada em loops <strong>for </strong>e afins quando não sabemos se caracteres de Plano Multilingual não Básico existem antes da posição do índice especificado.</p> + +<pre class="brush: js notranslate">function fixedCharCodeAt(str, idx) { + // ex. fixedCharCodeAt('\uD800\uDC00', 0); // 65536 + // ex. fixedCharCodeAt('\uD800\uDC00', 1); // false + idx = idx || 0; + var code = str.charCodeAt(idx); + var hi, low; + + // Substituto elevado (poderia mudar o último hex para 0xDB7F para tratar + // substitutos privados elevados como caracteres únicos) + if (0xD800 <= code && code <= 0xDBFF) { + hi = code; + low = str.charCodeAt(idx + 1); + if (isNaN(low)) { + throw 'High surrogate not followed by low surrogate in fixedCharCodeAt()'; + } + return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000; + } + if (0xDC00 <= code && code <= 0xDFFF) { // Low surrogate + // Retornamos false para permitir os loops pularem essa iteração já que já deveria + //ter tratado os substitutos elevados acima, na iteração anterior + return false; + /*hi = str.charCodeAt(idx - 1); + low = code; + return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;*/ + } + return code; +} +</pre> + +<h3 id="Corrigindo_o_charCodeAt_para_manipular_caracteres_de_Plano_Multilingual_não_Básico_se_sua_presença_na_string_é_desconhecida_2">Corrigindo o <code>charCodeAt()</code> para manipular caracteres de Plano Multilingual não Básico se sua presença na string é desconhecida</h3> + +<pre class="brush: js notranslate">function knownCharCodeAt(str, idx) { + str += ''; + var code, + end = str.length; + + var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; + while ((surrogatePairs.exec(str)) != null) { + var li = surrogatePairs.lastIndex; + if (li - 2 < idx) { + idx++; + } + else { + break; + } + } + + if (idx >= end || idx < 0) { + return NaN; + } + + code = str.charCodeAt(idx); + + var hi, low; + if (0xD800 <= code && code <= 0xDBFF) { + hi = code; + low = str.charCodeAt(idx + 1); + // Vá um adiante, já que um dos "characters" é parte de um par substituto + return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000; + } + return code; +} +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.5', 'String.prototype.charCodeAt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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>{{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>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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="sect1"></h2> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.fromCharCode()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/codepointat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/codepointat/index.html new file mode 100644 index 0000000000..c2b9caa273 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/codepointat/index.html @@ -0,0 +1,143 @@ +--- +title: String.prototype.codePointAt() +slug: Web/JavaScript/Reference/Global_Objects/String/codePointAt +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/codePointAt +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>codePointAt()</strong></code> retorna um número inteiro não negativo que é o valor do ponto de código Unicode.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-codepointat.html","shorter")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.codePointAt(<var>pos</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code><var>pos</var></code></dt> + <dd>A posição de um elemento em uma string a partir do qual retorna o valor do ponto de código.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um número que representa o valor do ponto de código do caractere na <code>pos</code> fornecida. Se não houver nenhum elemento na <code>pos</code>, {{jsxref ("undefined")}} é retornado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se não houver nenhum elemento na posição especificada, é retornado o valor de {{jsxref ("undefined")}}. Se nenhum par substituto UTF-16 começar na <code>pos</code>, a unidade de código na <code>pos</code> será retornada.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>O seguinte código cria no objeto global String a função <code>codePointAt()</code> conforme especificado em ECMAScript 2015 para navegadores sem suporte nativo:</p> + +<pre class="brush: js notranslate">/*! https://mths.be/codepointat v0.2.0 by @mathias */ +if (!String.prototype.codePointAt) { + (function() { + 'use strict'; // needed to support `apply`/`call` with `undefined`/`null` + var defineProperty = (function() { + // IE 8 only supports `Object.defineProperty` on DOM elements + try { + var object = {}; + var $defineProperty = Object.defineProperty; + var result = $defineProperty(object, object, object) && $defineProperty; + } catch(error) {} + return result; + }()); + var codePointAt = function(position) { + if (this == null) { + throw TypeError(); + } + var string = String(this); + var size = string.length; + // `ToInteger` + var index = position ? Number(position) : 0; + if (index != index) { // better `isNaN` + index = 0; + } + // Account for out-of-bounds indices: + if (index < 0 || index >= size) { + return undefined; + } + // Get the first code unit + var first = string.charCodeAt(index); + var second; + if ( // check if it’s the start of a surrogate pair + first >= 0xD800 && first <= 0xDBFF && // high surrogate + size > index + 1 // there is a next code unit + ) { + second = string.charCodeAt(index + 1); + if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate + // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; + } + } + return first; + }; + if (defineProperty) { + defineProperty(String.prototype, 'codePointAt', { + 'value': codePointAt, + 'configurable': true, + 'writable': true + }); + } else { + String.prototype.codePointAt = codePointAt; + } + }()); +} +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_codePointAt">Usando <code>codePointAt()</code></h3> + +<pre class="brush: js notranslate">'ABC'.codePointAt(1) // retorna 66 +'\uD800\uDC00'.codePointAt(0) // retorna 65536 + +'XYZ'.codePointAt(42) // retorna undefined +</pre> + +<h3 id="Criando_um_loop_com_codePointAt">Criando um loop com <code>codePointAt()</code></h3> + +<pre class="brush: js notranslate"><code class="md-code md-lang-javascript"><span class="md-code-keyword">for</span> (<span class="md-code-keyword">let</span> codePoint of <span class="md-code-string">'\ud83d\udc0e\ud83d\udc71\u2764'</span>) { + <span class="md-code-built_in">console</span>.log(codePoint<mark class="md-mark md-code-mark">.codePointAt(<span class="md-code-number">0</span>).toString(<span class="md-code-number">16</span>)</mark>) +} +// <span class="md-code-comment">retorna '1f40e', '1f471', '2764</span></code>'<code class="md-code md-lang-javascript"><span class="md-code-comment"> </span></code> +</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-string.prototype.codepointat', 'String.prototype.codePointAt')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.codePointAt")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.fromCharCode()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/concat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/concat/index.html new file mode 100644 index 0000000000..1ea9f9eacf --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/concat/index.html @@ -0,0 +1,138 @@ +--- +title: String.prototype.concat() +slug: Web/JavaScript/Reference/Global_Objects/String/concat +tags: + - JavaScript + - Prototipo + - Referencia + - String + - concat() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/concat +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>concat()</code></strong> combina o texto de duas ou mais strings e retorna uma nova string.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.concat(<var>string2 </var>[, ...<var>stringN</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>string2...string<em>N</em></code></dt> + <dd>Strings para concatenar à <strong><code>string2</code></strong>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova string contendo a string original concatenada à string passada como parâmetro.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>A função <strong><code>concat()</code></strong> combina o texto de duas ou mais strings e retorna uma nova string. As alterações de texto de uma string não afetam a outra string.</p> + +<p>Se o argumento passado não for do tipo string, o mesmo será convertido em uma string antes de ser concatenado.</p> + +<h2 id="Performance">Performance</h2> + +<p>É extremamente recomendado o uso dos <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Expressions_and_Operators" title="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Expressions_and_Operators">operadores de atribuição</a> (<code>+</code>, <code>+=</code>) em detrimento do método <code>concat()</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_concat">Usando <code>concat()</code></h3> + +<p>O exemplo a seguir concatena uma string à outra string originando uma terceira string.</p> + +<pre class="brush: js notranslate">var hello = 'Olá, '; +console.log(hello.concat('Kevin', ' tenha um bom dia.')); + +// retorna 'Olá, Kevin tenha um bom dia.' +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.6', 'String.prototype.concat')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.concat', 'String.prototype.concat')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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>{{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>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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.concat()")}}</li> + <li>{{jsxref("Operators/Assignment_Operators", "Assignment operators", "", 1)}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/endswith/index.html b/files/pt-br/web/javascript/reference/global_objects/string/endswith/index.html new file mode 100644 index 0000000000..0e62545d41 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/endswith/index.html @@ -0,0 +1,103 @@ +--- +title: String.prototype.endsWith() +slug: Web/JavaScript/Reference/Global_Objects/String/endsWith +tags: + - JavaScript + - Prototipo + - Referencia + - String + - endsWith() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith +--- +<div>{{JSRef}}</div> + +<div></div> + +<p>O método <strong><code>endsWith()</code></strong> indica se uma string termina com determinados caracteres, retornando <code>true</code> ou <code>false</code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.endsWith(s<var>tringSendoBuscada</var>[, <var>tamanho</var>])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>stringSendoBuscada</code></dt> + <dd>Os caracteres a serem pesquisados no final da string.</dd> + <dt><code>tamanho</code></dt> + <dd>Opcional. Se fornecido, substitui o tamanho da string passada. Se omitido, o valor padrão é o tamanho da string.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p><strong><code>true</code></strong> se os caracteres passados forem encontrados no final da string. Do contrário, retorna <strong><code>false</code></strong>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Este método permite que você verifique se uma string termina ou não com determinados caracteres. Este método é case-sensitive.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_endsWith">Usando <code>endsWith()</code></h3> + +<pre class="brush: js notranslate">var str = 'Ser ou não ser, eis a questão'; + +console.log(str.endsWith('questão')); // retorna true +console.log(str.endsWith('ser')); // retorna false +console.log(str.endsWith('ser', 14)); // retorna true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Este método foi adicionada na especificação ECMAScript 6 e talvez não esteja disponível em todos as implementações JavaScript ainda. No entanto, você pode criá-lo adicionando o seguinte código:</p> + +<pre class="brush: js notranslate">if (!String.prototype.endsWith) + String.prototype.endsWith = function(searchStr, Position) { + // This works much better than >= because + // it compensates for NaN: + if (!(Position < this.length)) + Position = this.length; + else + Position |= 0; // round position + return this.substr(Position - searchStr.length, + searchStr.length) === searchStr; + }; +</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-string.prototype.endswith', 'String.prototype.endsWith')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.endsWith")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.startsWith()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fixed/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fixed/index.html new file mode 100644 index 0000000000..4a6004f05d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/fixed/index.html @@ -0,0 +1,66 @@ +--- +title: String.prototype.fixed() +slug: Web/JavaScript/Reference/Global_Objects/String/fixed +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - fixed() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/fixed +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <strong><code>fixed()</code></strong> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/tt" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/tt"><tt></a></code> que faz com que uma string seja exibida em uma fonte de densidade fixa.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.fixed()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string que representa o elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/tt" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/tt"><tt></a>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método<strong> </strong><code>fixed()</code> cria uma string dentro de uma tag <code><tt></code>:<br> + <code>"<tt>str</tt>"</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_fixed">Usando <code>fixed()</code></h3> + +<p>O exemplo a seguir usa o método <code>fixed()</code> para alterar a formatação de uma string:</p> + +<pre class="brush: js notranslate">var worldString = 'Olá, mundo'; +console.log(worldString.fixed()); // "<tt>Olá, mundo</tt>" +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.fixed', 'String.prototype.fixed')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.fixed")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fontcolor/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fontcolor/index.html new file mode 100644 index 0000000000..aafc3074e9 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/fontcolor/index.html @@ -0,0 +1,84 @@ +--- +title: String.prototype.fontcolor() +slug: Web/JavaScript/Reference/Global_Objects/String/fontcolor +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - fontcolor() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontcolor +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>fontcolor()</code> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font"><font></a> que faz com que uma string seja exibida na cor especificada.</p> + +<div class="note"> +<p><strong>Nota de uso:</strong> O elemento <code><font></code> foi removido do <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/HTML5" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/HTML5">HTML5</a> e não deve mais ser usado. Em vez disso, web developers devem usar a <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/color_value" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/color_value">propriedade CSS correspondente</a>.</p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.fontcolor(<var>color</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>color</code></dt> + <dd>Deve ser um string que expresse uma cor em formato hexadecimal ou o nome, em Inglês, de uma cor. Os nomes das cores estão listados na referência de <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/color_value#Palavras-chave_de_cores" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/color_value#Palavras-chave_de_cores">cores CSS</a>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font"><font></a>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se você expressar uma cor em formato hexadecimal, deve usar o formato <code>rrggbb</code>. Por exemplo, os valores RGB hexadecimais para salmão são vermelho = FA, verde = 80 e azul = 72, portanto, o tripleto RGB para salmão é "FA8072".</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_fontcolor">Usando <code>fontcolor()</code></h3> + +<p>O exemplo a seguir usa o método <code>fontcolor()</code> para alterar a cor de uma string, produzindo uma string com a tag HTML <code><font></code>.</p> + +<pre class="brush: js notranslate">var worldString = 'Olá, mundo'; + +console.log(worldString.fontcolor('red') + ' está vermelho nesta linha'); +// '<font color="red">Olá, mundo</font> está vermelho nesta linha' + +console.log(worldString.fontcolor('FF00') + ' está vermelho em hexadecimal nesta linha'); +// '<font color="FF00">Olá, mundo</font> está vermelho em hexadecimal nesta linha' +</pre> + +<p>Com o objeto <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style">element.style</a></code> você pode obter o atributo <code>style</code> do elemento e manipulá-lo de forma mais genérica, por exemplo:</p> + +<pre class="brush: js notranslate">document.getElementById('#oIdDoElemento').style.color = 'red'; +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.fontcolor', 'String.prototype.fontcolor')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.fontcolor")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fontsize/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fontsize/index.html new file mode 100644 index 0000000000..655a012b92 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/fontsize/index.html @@ -0,0 +1,83 @@ +--- +title: String.prototype.fontsize() +slug: Web/JavaScript/Reference/Global_Objects/String/fontsize +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - fontsize() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontsize +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>fontsize()</code> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font"><font></a> que faz com que uma string seja exibida no tamanho da fonte especificada.</p> + +<div class="note"> +<p><strong>Nota de uso:</strong> O elemento <code><font></code> foi removido do <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/HTML5" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/HTML5">HTML5</a> e não deve mais ser usado. Em vez disso, web developers devem usar a <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/font-size" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/font-size">propriedade CSS correspondente</a>.</p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.fontsize(<var>size</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>size</code></dt> + <dd>Um número inteiro entre 1 e 7.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font"><font></a>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Ao especificar o tamanho como um inteiro, você define o tamanho da fonte do texto para um dos 7 tamanhos definidos. Ao especificar <code>size</code> como uma string como "-2", você ajusta o tamanho da fonte do texto em relação ao tamanho definido na tag <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/basefont" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/basefont"><basefont></a>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_fontsize">Usando <code>fontsize()</code></h3> + +<p>O exemplo a seguir usa métodos do objeto global String para alterar o tamanho de uma string:</p> + +<pre class="brush: js notranslate">var worldString = 'Olá, mundo'; + +console.log(worldString.small()); // <small>Olá, mundo</small> +console.log(worldString.big()); // <big>Olá, mundo</big> +console.log(worldString.fontsize(7)); // <font size="7">Olá, mundo</fontsize> +</pre> + +<p>Com o objeto <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style">element.style</a></code> você pode obter o atributo <code>style</code> do elemento e manipulá-lo de forma mais genérica, por exemplo:</p> + +<pre class="brush: js notranslate">document.getElementById('#oIdDoElemento').style.fontSize = '0.7em'; +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.fontsize', 'String.prototype.fontsize')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.fontsize")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.big()")}}</li> + <li>{{jsxref("String.prototype.small()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fromcharcode/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fromcharcode/index.html new file mode 100644 index 0000000000..23a8de8f44 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/fromcharcode/index.html @@ -0,0 +1,142 @@ +--- +title: String.fromCharCode() +slug: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +tags: + - JavaScript + - Referencia + - String + - UTF-16 + - Unicode + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>String.fromCharCode()</code></strong> retorna uma string criada ao usar uma sequência específica de valores Unicode.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code>String.fromCharCode(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>num1, ..., num<em>N</em></code></dt> + <dd>Uma sequência de números que devem ser valores UTF-16. O tamanho é entre <code>0</code> e <code>65535</code> (<code>0xFFFF</code>). Números maiores do que <code>0xFFFF</code> são desconsiderados. Nenhuma verificação de vadalida é realizada.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo os caracteres correspondentes à sequência de valores Unicode.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Esse método retorna uma string e não um objeto {{jsxref("String")}}.</p> + +<p>Como <code>fromCharCode() </code>é um método estático de {{jsxref("String")}}, você sempre o usará como <code>String.fromCharCode()</code>, ao invés de um método de um objeto {{jsxref("String")}} que você tenha criado.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_fromCharCode">Usando <code>fromCharCode()</code></h3> + +<p>O seguinte exemplo retorna a string "ABC".</p> + +<pre class="brush: js notranslate">String.fromCharCode(65, 66, 67); // retorna "ABC" +</pre> + +<h2 id="Fazendo-o_funcionar_com_valores_maiores">Fazendo-o funcionar com valores maiores</h2> + +<p>Embora os valores Unicode mais comuns possam ser representados com um número de 16 bits (como experado durante a padronização do JavaScript) e o fromCharCode() possa ser usado para retornar um único caracter dos valores mais comuns (por exemplo: valores UCS-2 que são os melhores subconjuntos do UTF-16 com os caractres mais comuns), a fim de resolver TODOS os valores Unicode legais (até 21 bits) o método fromCharCode() sozinho é inadequado. Como os caracteres de ponto de código mais alto usam 2 (valor menor) numeros "substitutos" para formar um único caracter, {{jsxref("String.fromCodePoint()")}} (parte do padrão ES2015) pode ser usado para retornar tal par e ainda representar adequadamente esses caracteres de valores altos.</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.3.2', 'StringfromCharCode')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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>{{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>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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fromcodepoint/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fromcodepoint/index.html new file mode 100644 index 0000000000..f8b2bfbf7d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/fromcodepoint/index.html @@ -0,0 +1,213 @@ +--- +title: String.fromCodePoint() +slug: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint +tags: + - JavaScript + - Referencia + - String + - UTF-16 + - Unicode + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint +--- +<div>{{JSRef}}</div> + +<p>O método estático <strong>String.fromCodePoint()</strong> retorna uma seqüência de caracteres criado usando a seqüência especificada de pontos de código.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><code>String.fromCodePoint(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>num1, ..., num<em>N</em></code></dt> + <dd>Uma sequência de pontos de código.</dd> +</dl> + +<h3 id="Exceções">Exceções</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd> + <p>O {{jsxref("RangeError")}} é lançado se um ponto de código Unicode inválido é dado (por exemplo, "RangeError: NaN não é um ponto de código válido").</p> + </dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Como o fromCodePoint() é um método estático do {{jsxref("String")}}, você sempre vai chamar esse método como <strong>String.fromCodePoint()✔</strong> em vez de usá-lo como um método de uma string que você criar, como <strong>"minha string".fromCodePoint()❌</strong>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_fromCodePoint">Usando <code>fromCodePoint()</code></h3> + +<pre class="brush: js notranslate">String.fromCodePoint(42); // "*" +String.fromCodePoint(65, 90); // "AZ" +String.fromCodePoint(0x404); // "\u0404" +String.fromCodePoint(0x2F804); // "\uD87E\uDC04" +String.fromCodePoint(194564); // "\uD87E\uDC04" +String.fromCodePoint(0x1D306, 0x61, 0x1D307) // "\uD834\uDF06a\uD834\uDF07" + +String.fromCodePoint('_'); // RangeError +String.fromCodePoint(Infinity); // RangeError +String.fromCodePoint(-1); // RangeError +String.fromCodePoint(3.14); // RangeError +String.fromCodePoint(3e-2); // RangeError +String.fromCodePoint(NaN); // RangeError +</pre> + +<pre class="brush: js notranslate">// String.fromCharCode() alone cannot get the character at such a high code point +// The following, on the other hand, can return a 4-byte character as well as the +// usual 2-byte ones (i.e., it can return a single character which actually has +// a string length of 2 instead of 1!) +console.log(String.fromCodePoint(0x2F804)); // or 194564 in decimal +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>O método <strong>String.fromCodePoint</strong> foi adicionado ao padrão ECMAScript na versão 6 e pode não ser suportado em todos os navegadores da Web ou em todos os ambientes ainda. <span class="notranslate"> Use o código abaixo para um polyfill:</span></p> + +<pre class="brush: js notranslate">/*! http://mths.be/fromcodepoint v0.1.0 by @mathias */ +if (!String.fromCodePoint) { + (function() { + var defineProperty = (function() { + // IE 8 only supports `Object.defineProperty` on DOM elements + try { + var object = {}; + var $defineProperty = Object.defineProperty; + var result = $defineProperty(object, object, object) && $defineProperty; + } catch(error) {} + return result; + }()); + var stringFromCharCode = String.fromCharCode; + var floor = Math.floor; + var fromCodePoint = function() { + var MAX_SIZE = 0x4000; + var codeUnits = []; + var highSurrogate; + var lowSurrogate; + var index = -1; + var length = arguments.length; + if (!length) { + return ''; + } + var result = ''; + while (++index < length) { + var codePoint = Number(arguments[index]); + if ( + !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity` + codePoint < 0 || // not a valid Unicode code point + codePoint > 0x10FFFF || // not a valid Unicode code point + floor(codePoint) != codePoint // not an integer + ) { + throw RangeError('Invalid code point: ' + codePoint); + } + if (codePoint <= 0xFFFF) { // BMP code point + codeUnits.push(codePoint); + } else { // Astral code point; split in surrogate halves + // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + codePoint -= 0x10000; + highSurrogate = (codePoint >> 10) + 0xD800; + lowSurrogate = (codePoint % 0x400) + 0xDC00; + codeUnits.push(highSurrogate, lowSurrogate); + } + if (index + 1 == length || codeUnits.length > MAX_SIZE) { + result += stringFromCharCode.apply(null, codeUnits); + codeUnits.length = 0; + } + } + return result; + }; + if (defineProperty) { + defineProperty(String, 'fromCodePoint', { + 'value': fromCodePoint, + 'configurable': true, + 'writable': true + }); + } else { + String.fromCodePoint = fromCodePoint; + } + }()); +} +</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-string.fromcodepoint', 'String.fromCodePoint')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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> + <p>{{CompatChrome("41")}}</p> + </td> + <td>{{CompatGeckoDesktop("29")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("28")}}</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("29")}}</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("String.fromCharCode()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/includes/index.html b/files/pt-br/web/javascript/reference/global_objects/string/includes/index.html new file mode 100644 index 0000000000..c76b927cf3 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/includes/index.html @@ -0,0 +1,108 @@ +--- +title: String.prototype.includes() +slug: Web/JavaScript/Reference/Global_Objects/String/includes +tags: + - ES6 + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/includes +--- +<div>{{JSRef}}</div> + +<p>O método <strong>includes()</strong> determina se um conjunto de caracteres pode ser encontrado dentro de outra string, retornando <code>true</code> ou <code>false</code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.includes(<var>searchString</var>[, <var>position</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>searchString</code></dt> + <dd>É o conjunto de caracteres que será pesquisado dentro desta string.</dd> + <dt><code>position</code></dt> + <dd>Opcional. É um número inteiro que indica por onde a busca iniciará, referente ao índice da string a ser pesquisada. O valor padrão é 0.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p><code>true</code> se o conjunto de caracteres for encontrado em algum lugar dentro da string sendo pesquisada. Do contrário, retorna <code>false</code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Este método permite conferir se uma string contém um determinado conjunto de caracteres.</p> + +<h3 id="Case-sensitivity">Case-sensitivity</h3> + +<p>O método <code>includes()</code> é case sensitive. Por exemplo, a seguinte expressão retorna <code>false</code>:</p> + +<pre class="brush: js notranslate">'Bandeira do Brasil'.includes('brasil'); // retorna false +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Utilizando_includes">Utilizando <code>includes()</code></h3> + +<pre class="brush: js notranslate">var str = 'Ser, ou não ser, eis a questão.'; + +console.log(str.includes('Ser')); // true +console.log(str.includes('questão')); // true +console.log(str.includes('não existe')); // false +console.log(str.includes('ser', 1)); // true +console.log(str.includes('SER')); // false +</pre> + +<h2 id="Implementação">Implementação</h2> + +<p>Este método foi adicionado à especificação ECMAScript 6 e pode não estar disponível em todas as implementações JavaScript. No entanto, você pode facilmente implementar este método:</p> + +<pre class="brush: js notranslate">if (!String.prototype.includes) { + String.prototype.includes = function() {'use strict'; + return String.prototype.indexOf.apply(this, arguments) !== -1; + }; +} + +</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-string.prototype.includes', 'String.prototype.includes')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{Compat("javascript.builtins.String.includes")}}</div> + +<h2 id="String.prototype.contains">String.prototype.contains</h2> + +<p>No Firefox 18 - 39, o nome deste método era <code>contains()</code>. Ele foi renomeado para <code>includes()</code> no {{bug(1102219)}} devido ao seguinte motivo:</p> + +<p>Foi <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=789036">reportado</a> que alguns websites que utilizam MooTools 1.2 não funcionavam no Firefox 17. Esta versão do MooTools verifica se <code>String.prototype.contains()</code> existe e, se não existir, MooTools adiciona sua própria função. Com a implementação desta função no Firefox 17, o comportamento desta validação mudou de uma forma que códigos baseados na implementação da função <code>String.prototype.contains()</code> do MooTools parassem de funcionar. Como resultado, esta mudança foi <a href="https://hg.mozilla.org/releases/mozilla-aurora/rev/086db97198a8">desabilitada</a> no Firefox 17 e <code>String.prototype.contains()</code> foi disponibilizada na versão seguinte, no Firefox 18.</p> + +<p>MooTools 1.3 força sua própria versão do <code>String.prototype.contains()</code>, portanto websites baseados nela não devem parar de funcionar. No entanto, você deve notar que <a href="http://mootools.net/core/docs/1.3.2/Types/String#String-method:-contains">a assinatura do MooTools 1.3</a> e a assinatura ECMAScript 6 diferem (no segundo argumento). Posteriormente, <a href="https://github.com/mootools/mootools-core/blob/master/Docs/Types/String.md#note">MooTools 1.5+ mudou sua assinatura para o padrão ES6.</a></p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.includes()")}} {{experimental_inline}}</li> + <li>{{jsxref("TypedArray.prototype.includes()")}} {{experimental_inline}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.startsWith()")}} {{experimental_inline}}</li> + <li>{{jsxref("String.prototype.endsWith()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/index.html b/files/pt-br/web/javascript/reference/global_objects/string/index.html new file mode 100644 index 0000000000..e7ab10819b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/index.html @@ -0,0 +1,338 @@ +--- +title: String +slug: Web/JavaScript/Reference/Global_Objects/String +tags: + - JavaScript + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String +--- +<p>{{JSRef("Global_Objects", "String")}}</p> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>O objeto global <strong><code>String</code></strong> é um construtor para <strong>strings,</strong> ou uma sequência de caracteres.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<p>As formas literais de declaração de <em>String</em> são:</p> + +<pre class="syntaxbox">'string text' +"string text" +"中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어"</pre> + +<p>Além da forma regular, de caracteres<em> </em>de impressão, caracteres especiais podem ser codificados usando a <em>escape notation </em>(notação com barra invertida):</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Codigo</th> + <th scope="col">Saida</th> + </tr> + </thead> + <tbody> + <tr> + <td>\0</td> + <td>o caractere NULL</td> + </tr> + <tr> + <td>\'</td> + <td>aspas simples</td> + </tr> + <tr> + <td>\"</td> + <td>aspas duplas</td> + </tr> + <tr> + <td>\\</td> + <td>barra invertida</td> + </tr> + <tr> + <td>\n</td> + <td>nova linha</td> + </tr> + <tr> + <td>\r</td> + <td>carriage return</td> + </tr> + <tr> + <td>\v</td> + <td>tab vertical</td> + </tr> + <tr> + <td>\t</td> + <td>tab</td> + </tr> + <tr> + <td>\b</td> + <td>backspace</td> + </tr> + <tr> + <td>\f</td> + <td>form feed</td> + </tr> + <tr> + <td>\uXXXX</td> + <td>unicode codepoint</td> + </tr> + <tr> + <td>\xXX</td> + <td>the Latin-1 character</td> + </tr> + </tbody> +</table> + +<p>Ou, usando o objeto global <code>String</code> diretamente:</p> + +<pre class="syntaxbox">String(thing) +new String(thing)</pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>thing</code></dt> + <dd>Qualquer coisa a ser convertida para uma string.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Strings são úteis para guardar dados que podem ser representados em forma de texto. Uma das operações mais usadas nas <strong>strings</strong> é checar seu {{jsxref("String.length", "tamanho")}}, para construir e concatená-las usando <a href="/en-US/docs/Web/JavaScript/Reference/Operators/String_Operators">os operadores</a> <a href="/en-US/docs/Web/JavaScript/Reference/Operators/String_Operators">+ e +=, </a>checando pela existência ou posição de <em>substrings</em> com o método {{jsxref("String.indexOf", "indexOf")}} , ou extrair <em>substrings</em> com o método {{jsxref("String.substring", "substring")}}.</p> + +<h3 id="Character_access" name="Character_access">Acesso à caractere</h3> + +<p>Há duas maneiras de acessar um <span class="st">caractere </span>individual em uma string. A primeira é o método {{jsxref("String.charAt", "charAt")}}:</p> + +<pre class="brush: js">return 'cat'.charAt(1); // returns "a" +</pre> + +<p>A outra maneira (introduzido no ECMAScript 5) consiste em tratar a string como um objeto Array-like, onde os caráteres individuais correspondem a um índice numérico:</p> + +<pre class="brush: js">return 'cat'[1]; // returns "a" +</pre> + +<p>Para acesso de caracteres usando uma notação de colchetes, tentando deletar ou designar um valor a estas propriedades não haverá sucesso. As propriedades envolvidas não são nem escritas ou configuráveis. (Veja {{jsxref("Object.defineProperty")}} para mais informações.)</p> + +<h3 id="Comparing_strings" name="Comparing_strings">Comparando strings</h3> + +<p>Desenvolvedores de C têm a função strcmp() para comparar strings. No JavaScript, basta usar o operador <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">maior que e menor que</a>:</p> + +<pre class="brush: js">var a = "a"; +var b = "b"; +if (a < b) // verdadeiro + print(a + " é menor que " + b); +else if (a > b) + print(a + " é maior que " + b); +else + print(a + " e " + b + " são iguais."); +</pre> + +<p>Um resultado similar pode ser alcançado usando o método {{jsxref("String.localeCompare", "localeCompare")}} herdado pelas instâncias de <code>String</code>.</p> + +<h3 id="Distinção_entre_String_primitiva_e_objetos_String">Distinção entre String primitiva e objetos String</h3> + +<p>Note que o JavaScript distingue entre objetos String e valores de string primitivas. (O mesmo é válido para {{jsxref("Global_Objects/Boolean", "Boolean")}} e {{jsxref("Global_Objects/Number", "Numbers")}}.)</p> + +<p>Strings literais (definidas por aspas duplas ou aspas simples) e strings retornadas da chamada da função String fora do contexto de uma função construtora (sem o uso da palavra chave <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a>) são strings primitivas. O JavaScript converte automaticamente strings primitivas para objetos do tipo String, por isso é possível utilizar os métodos do objeto String através de strings primitivas. Em contextos onde um método é invocado de uma string primitiva ou uma propriedade é procurada, o JavaScript irá criar um objeto com a string primitiva e executar o método ou acessar a propriedade procurada.</p> + +<pre class="brush: js">var s_prim = "foo"; +var s_obj = new String(s_prim); + +console.log(typeof s_prim); // Loga "string" +console.log(typeof s_obj); // Loga "object" +</pre> + +<p>String primitivas e objetos <code>String</code> também dão resultados diferentes quando usado {{jsxref("Global_Objects/eval", "eval")}}. Primitivas passadas para <code>eval</code> são tratadas como código fonte; Objetos <code>String</code> são tratados como todos os outros objetos são, retornando o objeto. Por exemplo:</p> + +<pre class="brush: js">s1 = "2 + 2"; // cria uma string primitiva +s2 = new String("2 + 2"); // cria um objeto de String +console.log(eval(s1)); // retorna o número 4 +console.log(eval(s2)); // retorna a string "2 + 2" +</pre> + +<p>Por estas razões, o código pode quebrar quando encontra objetos <code>String</code> quando espera na verdade uma string primitiva, apesar de que geralmente autores não precisam se preocupar com a distinção.</p> + +<p>Um objeto <code>String</code> pode ser convertido sempre para sua contraparte primitiva com o método {{jsxref("String.valueOf", "valueOf")}}.</p> + +<pre class="brush: js">console.log(eval(s2.valueOf())); // retorna o número 4 +</pre> + +<div class="note"><strong>Note:</strong> Para uma outra possível abordagem para strings em JavaScript, favor ler o artigo sobre <a href="/en-US/docs/Web/JavaScript/Typed_arrays/StringView" title="/en-US/docs/Web/JavaScript/Typed_arrays/StringView"><code>StringView</code> – a C-like representation of strings based on typed arrays</a>.</div> + +<h2 id="Properties" name="Properties">Propriedades</h2> + +<dl> + <dt>{{jsxref("String.prototype")}}</dt> + <dd>Permite a adição de propriedades a um objeto String.</dd> +</dl> + +<div>{{jsOverrides("Function", "Properties", "prototype")}}</div> + +<h2 id="Methods" name="Methods">Métodos</h2> + +<dl> + <dt>{{jsxref("String.fromCharCode()")}}</dt> + <dd>Retorna uma string criada usando a sequência especificada de valores Unicode.</dd> + <dt>{{jsxref("String.fromCodePoint()")}} {{experimental_inline}}</dt> + <dd>Retorna uma string criada usando a sequência especificada de posições de código.</dd> +</dl> + +<div>{{jsOverrides("Function", "Methods", "fromCharCode", "fromCodePoint")}}</div> + +<h2 id="Métodos_genéricos_de_Strings"><code>Métodos genéricos de Strings</code></h2> + +<p>Métodos de instância <code>String</code> também estão disponíveis no Firefox a partir de JavaScript 1.6 (embora não faça parte dos padrões ECMAScript) no objeto String para aplicar métodos String a qualquer objeto:</p> + +<pre class="brush: js">var num = 15; +alert(String.replace(num, /5/, '2')); +</pre> + +<p class="brush: js"><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#Array_generic_methods">Genéricos</a> também estão disponíveis em métodos {{jsxref("Global_Objects/Array", "Array")}}.</p> + +<p class="brush: js">O seguinte é uma implementação para fornecer suporte a navegadores sem suporte:</p> + +<pre class="brush: js">/*globals define*/ +// Assume que todos os métodos de instância String fornecidos +// já presentes (podem ser usadas implementações para este se não disponível) +(function () { + 'use strict'; + + var i, + // Nós também poderíamos construir o array de métodos com os seguintes, + // mas o método getOwnPropertyNames() não é implementável: + // Object.getOwnPropertyNames(String).filter(function (methodName) + // {return typeof String[methodName] === 'function'}); + methods = [ + 'quote', 'substring', 'toLowerCase', 'toUpperCase', 'charAt', + 'charCodeAt', 'indexOf', 'lastIndexOf', 'startsWith', 'endsWith', + 'trim', 'trimLeft', 'trimRight', 'toLocaleLowerCase', + 'toLocaleUpperCase', 'localeCompare', 'match', 'search', + 'replace', 'split', 'substr', 'concat', 'slice' + ], + methodCount = methods.length, + assignStringGeneric = function (methodName) { + var method = String.prototype[methodName]; + String[methodName] = function (arg1) { + return method.apply(arg1, Array.prototype.slice.call(arguments, 1)); + }; + }; + + for (i = 0; i < methodCount; i++) { + assignStringGeneric(methods[i]); + } +}()); +</pre> + +<h2 id="Instâncias_de_String">Instâncias de <code>String</code></h2> + +<h3 id="Propriedades">Propriedades</h3> + +<p>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Propriedades')}}</p> + +<h3 id="Métodos">Métodos</h3> + +<h4 id="Métodos_não_relacionados_ao_HTML">Métodos não relacionados ao HTML</h4> + +<p>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Métodos_não_relacionados_ao_HTML')}}</p> + +<h4 id="Métodos_de_envoltório_HTML">Métodos de envoltório HTML</h4> + +<p>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Métodos_de_envoltório_HTML')}}</p> + +<h2 id="String_instances" name="String_instances">Exemplos</h2> + +<h3 id="Conversão_de_String">Conversão de String</h3> + +<p>É possível usar <code>String</code> como uma alternativa "mais segura" {{jsxref("String.toString", "toString")}}, como embora normalmente ainda chama o <code>toString</code> subjacente, também funciona para <code>null</code> e <code>undefined</code>. Por exemplo:</p> + +<pre class="brush: js">var outputStrings = []; +for (let i = 0, n = inputValues.length; i < n; ++i) { + outputStrings.push(String(inputValues[i])); +} +</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>Definições iniciais.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5', 'String')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string-objects', 'String')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2> + +<p>{{ CompatibilityTable() }}</p> + +<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>Basic support</td> + <td>0.2</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>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>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/API/DOMString" title="/en-US/docs/Web/API/DOMString">DOMString</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays/StringView" title="/en-US/docs/Web/JavaScript/Typed_arrays/StringView"><code>StringView</code> – a C-like representation of strings based on typed arrays</a></li> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/API/DOMString/Binary">Binary strings</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/indexof/index.html b/files/pt-br/web/javascript/reference/global_objects/string/indexof/index.html new file mode 100644 index 0000000000..fc62ad78a0 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/indexof/index.html @@ -0,0 +1,158 @@ +--- +title: String.prototype.indexOf() +slug: Web/JavaScript/Reference/Global_Objects/String/indexOf +tags: + - JavaScript + - Prototipo + - Referencia + - String + - indexOf() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf +--- +<p>{{JSRef("Global_Objects", "String")}}</p> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>O método <code>indexOf()</code> retorna o índice da primeira ocorrência do valor fornecido em searchValue, começando a busca a partir de <code>fromIndex</code>. Retorna <code>-1</code> se o valor não for encontrado.</p> + +<div class="blockIndicator note"> +<p><strong>Nota:</strong> Para o método de Array, veja {{jsxref("Array.prototype.indexOf()")}}.</p> +</div> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><em>str</em>.indexOf(<em>searchValue</em>[, <em>fromIndex</em>]</code>)</pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>searchValue</code></dt> + <dd>Uma string representando o valor a ser buscado. Se nenhuma string for fornecida explicitamente, <code>searchValue</code> terá o valor de <code>undefined</code>, e esse valor será buscado na string atual. Por exemplo, <code>'undefined'.indexOf()</code> retornará <code>0</code>, já que <code>undefined</code> é encontrado na posição <code>0</code>. Já <code>'undefine'.indexOf()</code> retornará <code>-1</code>, já que <code>undefined</code> não pôde ser encontrado.</dd> + <dt><code>fromIndex</code></dt> + <dd>Um número inteiro representando um índice da string original a partir da qual a busca deve começar. Por padrão é <code>0</code>. Se <code>fromIndex < 0</code>, a string toda é percorrida (equivale a passar 0). Se <code>fromIndex</code> <code>>=</code> <code>str.length</code>, o método retornará <code>-1</code>, já que a busca será iniciada após o final da string.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O índice da primeira ocorrência de <em>searchValue</em>, ou <code>-1</code> se não for encontrado.</p> + +<p>Uma string vazia no <em>searchValue</em> produz resultados estranhos. Sem <code>fromIndex</code>, ou com qualquer <code>fromIndex</code> menor que o comprimento da string, o valor retornado é o próprio <code>fromIndex</code>:</p> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js"><span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">)</span> <span class="comment token">// retorna 0</span> +<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">0</span><span class="punctuation token">)</span> <span class="comment token">// retorna 0</span> +<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">3</span><span class="punctuation token">)</span> <span class="comment token">// retorna 3</span> +<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">8</span><span class="punctuation token">)</span> <span class="comment token">// retorna 8</span></code></pre> + +<p>Entretanto, com qualquer <code>fromIndex</code> igual ou maior que o comprimento da string, o valor retornado é o comprimento da string:</p> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js"><span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">11</span><span class="punctuation token">)</span> <span class="comment token">// retorna 10</span> +<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">13</span><span class="punctuation token">)</span> <span class="comment token">// retorna 10</span> +<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">22</span><span class="punctuation token">)</span> <span class="comment token">// retorna 10</span></code></pre> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é <code>0</code>, e o índice do último caractere de uma string chamada <code>stringName</code> é <code>stringName.length - 1</code>.</p> + +<pre class="brush: js notranslate">"Blue Whale".indexOf("Blue"); // retorna 0 +"Blue Whale".indexOf("Whale"); // retorna 5 +"Blue Whale".indexOf("Blute"); // retorna -1 +"Blue Whale".indexOf("Whale", 0); // retorna 5 +"Blue Whale".indexOf("Whale", 5); // retorna 5 +"Blue Whale".indexOf("Whale", 7); // retorna -1 +"Blue Whale".indexOf(""); // retorna 0 +"Blue Whale".indexOf("", 9); // retorna 9 +"Blue Whale".indexOf("", 10); // retorna 10 +"Blue Whale".indexOf("", 11); // retorna 10</pre> + +<h3 id="Verificando_ocorrências">Verificando ocorrências</h3> + +<p>Note que um retorno <code>0</code> não implica em <code>true</code>, e <code>-1</code> não implica em <code>false</code>. Portanto, a maneira correta de se verificar se uma string específica está contida em outra string seria:</p> + +<pre class="brush: js notranslate">"Blue Whale".indexOf("Blue") !== -1; // true +"Blue Whale".indexOf("Bloe") !== -1; // false</pre> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Using_indexOf_and_lastIndexOf" name="Example:_Using_indexOf_and_lastIndexOf">Usando <code>indexOf()</code></h3> + +<p>O exemplo a seguir usa <code>indexOf()</code> para localizar valores dentro da string "<code>Brave new world</code>".</p> + +<pre class="brush: js notranslate">var anyString = "Brave new world"; + +console.log("O índice do primeiro w partindo do começo é " + anyString.indexOf("w")); +// Exibe 8 + +console.log("O índice de 'new' partindo do começo é " + anyString.indexOf("new")); +// Exibe 6 +</pre> + +<h3 id="Example_indexOf_and_case-sensitivity" name="Example:_indexOf_and_case-sensitivity"><code>indexOf()</code> e sensibilidade a maiúsculas e minúsculas</h3> + +<p>O exemplo a seguir define duas variáveis string. Ambas contém a mesma string, exceto que a segunda string tem letras maiúsculas. O primeiro método {{domxref("console.log()")}} exibe <code>19</code>. Porém, como o método <code>indexOf</code> é sensível a letras maiúsculas e minúsculas, a string <code>"cheddar"</code> não é encontrada em <code>myCapString</code>, portanto, o segundo método {{domxref("console.log()")}} exibe <code>-1</code>.</p> + +<pre class="brush: js notranslate">var myString = "brie, pepper jack, cheddar"; +var myCapString = "Brie, Pepper Jack, Cheddar"; + +console.log('myString.indexOf("cheddar") é ' + myString.indexOf("cheddar")); +// Exibe 19 +console.log('myCapString.indexOf("cheddar") é ' + myCapString.indexOf("cheddar")); +// Exibe -1</pre> + +<h3 id="Example_Using_indexOf_to_count_occurrences_of_a_letter_in_a_string" name="Example:_Using_indexOf_to_count_occurrences_of_a_letter_in_a_string">Usando <code>indexOf()</code> para contar as ocorrências de uma letra numa string</h3> + +<p>O exemplo a seguir atribui à variável <code>count</code> o número de ocorrências da letra <code>x</code> na string <code>str</code>:</p> + +<pre class="brush: js notranslate">const str = 'Serx ou não ser, eisx a questão' +count = 0; +pos = str.indexOf("x"); // retorna 3 + +while ( pos != -1 ) { + count++; + pos = str.indexOf( "x", pos + 1 /* o mesmo que 3 + 1 */ ); +} + +console.log(count);</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.7', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p>{{Compat("javascript.builtins.String.indexOf")}}</p> + +<h2 id="See_also" name="See_also"></h2> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/italics/index.html b/files/pt-br/web/javascript/reference/global_objects/string/italics/index.html new file mode 100644 index 0000000000..62467f37c6 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/italics/index.html @@ -0,0 +1,68 @@ +--- +title: String.prototype.italics() +slug: Web/JavaScript/Reference/Global_Objects/String/italics +tags: + - Descontinuado + - JavaScript + - Prototipo + - String + - italics() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/italics +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>italics()</code> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/i" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/i"><i></a></code> que faz com que uma string fique em itálico.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.italics()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/i" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/i"><i></a></code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>italics()</code> cria uma string dentro de uma tag <code><i></code>:<br> + <code>"<i>str</i>"</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_italics">Usando <code>italics()</code></h3> + +<p>O exemplo a seguir usa métodos do objeto global String para alterar a formatação de uma string:</p> + +<pre class="brush: js notranslate">var worldString = 'Olá, mundo'; +console.log(worldString.blink()); // <blink>Olá, mundo</blink> +console.log(worldString.bold()); // <b>Olá, mundo</b> +console.log(worldString.italics()); // <i>Olá, mundo</i> +console.log(worldString.strike()); // <strike>Olá, mundo</strike> +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.italics', 'String.prototype.italics')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.italics")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/lastindexof/index.html b/files/pt-br/web/javascript/reference/global_objects/string/lastindexof/index.html new file mode 100644 index 0000000000..893b27054c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/lastindexof/index.html @@ -0,0 +1,162 @@ +--- +title: String.prototype.lastIndexOf() +slug: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf +tags: + - JavaScript + - Prototipo + - Referencia + - String + - lastIndexOf + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf +--- +<div>{{JSRef}}</div> + +<p>O método <code>lastIndexOf()</code> retorna o índice da última ocorrência do valor especificado encontrado na {{jsxref("String")}}. Quando <code>fromIndex</code> é especificado, a pesquisa é realizada de trás para frente. Retorna <code>-1</code> se o valor não for encontrado.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.lastIndexOf(<var>searchValue</var>[, <var>fromIndex</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>searchValue</code></dt> + <dd>Uma string representando o valor a ser procurado. Se <code>searchValue</code> for uma string vazia, <code>str.length</code> é retornado.</dd> + <dt><code>fromIndex</code></dt> + <dd>Opcional. O índice no qual a pesquisa será iniciada de trás para frente. O valor padrão é <code>+Infinity</code>. Se <code>fromIndex >= str.length</code>, toda string é pesquisada. Se <code>fromIndex < 0</code>, o comportamento será o mesmo que seria com o índice <code>0</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O índice da última ocorrência referente ao valor especificado em <code>searchValue</code>. É retornado <code>-1</code> se nada for encontrado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Os caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é <code>0</code>, e o índice do último caractere é <code>str.length - 1</code>.</p> + +<pre class="brush: js notranslate">'ricardo'.lastIndexOf('r'); // retorna 4 +'ricardo'.lastIndexOf('a', 3); // retorna 3 +'ricardo'.lastIndexOf('a', 0); // retorna -1 +'ricardo'.lastIndexOf('x'); // retorna -1 +'ricardo'.lastIndexOf('r', -5); // retorna 0 +'ricardo'.lastIndexOf('r', 0); // retorna 0 +'ricardo'.lastIndexOf(''); // retorna 7 +'ricardo'.lastIndexOf('', 2); // retorna 2 +</pre> + +<h3 id="Sensível_a_maiúsculas_e_minúsculas">Sensível a maiúsculas e minúsculas</h3> + +<p>O método <code>lastIndexOf()</code> é sensível a letras maiúsculas e minúsculas. Por exemplo, a seguinte expressão retorna <code>-1</code>:</p> + +<pre class="brush: js notranslate">'Blue Whale, Killer Whale'.lastIndexOf('blue'); // retorna -1 +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_lastIndexOf">Usando <code>lastIndexOf()</code></h3> + +<p>O seguinte exemplo usa <code>lastIndexOf()</code> para localizar valores nas string <code>"Brave new world"</code>.</p> + +<pre class="brush: js notranslate">var anyString = 'Brave new world'; + +console.log('O índice do primeiro w a partir do final é ' + anyString.lastIndexOf('w')); +// retorna 10 + +console.log('O índice de "new" a partir do final é ' + anyString.lastIndexOf('new')); +// retorna 6 +</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ários</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.8', 'String.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> + <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/length/index.html b/files/pt-br/web/javascript/reference/global_objects/string/length/index.html new file mode 100644 index 0000000000..63fd9dac65 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/length/index.html @@ -0,0 +1,142 @@ +--- +title: String.length +slug: Web/JavaScript/Reference/Global_Objects/String/length +tags: + - JavaScript + - Propriedade + - Referencia + - String + - Tamanho da string + - length +translation_of: Web/JavaScript/Reference/Global_Objects/String/length +--- +<div>{{JSRef}}</div> + +<p>A propriedade <code>length</code> de um objeto {{jsxref("String")}} contém o comprimento da string. <code>length</code> é uma propriedade <code>read-only</code> (somente leitura) de instâncias de string.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.length</code></pre> + +<h2 id="Descrição">Descrição</h2> + +<p>Essa propriedade retorna o número de unidades de código presentes na string. {{interwiki("wikipedia", "UTF-16")}}, a codificação utilizada pelo JavaScript, utiliza uma unidade de código de 16-bits para representar os caracteres mais comuns, mas precisa usar duas unidades para caracteres menos usados, então é possível que o valor retornado por <code>length</code> não seja exatamente o número de caracteres na string.</p> + +<p>ECMASCript 2016 (ed. 7) estabeleceu um comprimento máximo de <code>2^53 - 1</code> elementos. Anteriormente, nenhum comprimento máximo havia sido especificado. No Firefox, as strings têm um comprimento (<code>length</code>) máximo de <code>2**30 - 2</code> (~ 1 GB). Em versões anteriores ao Firefox 65, o comprimento máximo era <code>2**28 - 1</code> (~ 256 MB).</p> + +<p>Para uma string vazia, <code>length</code> é <code>0</code>.</p> + +<p>A propriedade estática <code>String.length</code> retorna o valor <code>1</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Uso_básico">Uso básico</h3> + +<pre class="brush: js notranslate">var x = 'Mozilla'; +var empty = ''; + +console.log('Mozilla possui ' + x.length + ' unidades de código de comprimento'); +/* "Mozilla possui 7 unidades de código de comprimento" */ + +console.log('A string vazia possui um comprimento de ' + empty.length); +/* "A string vazia possui um comprimento de 0" */ +</pre> + +<h3 id="Atribuindo_valor_ao_comprimento">Atribuindo valor ao comprimento</h3> + +<pre class="brush: js notranslate">let myString = "campainhas"; + +// A tentativa de atribuir um valor à propriedade .length +// de uma string não tem efeito observável. + +myString.length = 4; +console.log(myString); +// retorna "campanhias" +console.log(myString.length); +// retorna 10 +</pre> + +<h2 id="Especificação">Especificação</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Estado</th> + <th scope="col">Comentários</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementada no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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>{{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>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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="http://developer.teradata.com/blog/jasonstrimpel/2011/11/javascript-string-length-and-internationalizing-web-applications">JavaScript <code>String.length</code> and Internationalizing Web Applications</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/link/index.html b/files/pt-br/web/javascript/reference/global_objects/string/link/index.html new file mode 100644 index 0000000000..547ded08d4 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/link/index.html @@ -0,0 +1,75 @@ +--- +title: String.prototype.link() +slug: Web/JavaScript/Reference/Global_Objects/String/link +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - link() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/link +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>link()</code> cria uma string que representa o código para um elemento HTML <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/a" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/a"><a></a></code> a ser usado como um link de hipertexto para outro URL.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.link(<var>url</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>url</code></dt> + <dd>Qualquer string que especifique o atributo <code>href</code> da tag <code><a></code>. Deve ser um URL válido (relativo ou absoluto), com qualquer caractere <code>&</code> escapado como <code>&amp</code> e qualquer <code>"</code> caractere escapado como <code>&quot</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/a" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/a"><a></a></code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Use o método <code>link()</code> para criar um elemento HTML <code><a></code>. A string retornada pode então ser adicionada ao documento por meio de <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/API/Document/write" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/API/Document/write">document.write()</a></code> ou <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/API/Element/innerHTML" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/API/Element/innerHTML">element.innerHTML</a></code>.</p> + +<p>Os links criados com o método <code>link()</code> tornam-se elementos na array de links do objeto <code>document</code>. Veja <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document/links" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document/links">document.links</a></code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_link">Usando <code>link()</code></h3> + +<p>O exemplo a seguir exibe a palavra "MDN" como um link que retorna o usuário à Mozilla Developer Network.</p> + +<pre class="brush: js notranslate">var hotText = 'MDN'; +var URL = 'https://developer.mozilla.org/'; + +console.log('Clique para retornar à' + hotText.link(URL)); +// Clique para retornar à <a href="https://developer.mozilla.org/">MDN</a> +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.link', 'String.prototype.link')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.link")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.anchor()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/localecompare/index.html b/files/pt-br/web/javascript/reference/global_objects/string/localecompare/index.html new file mode 100644 index 0000000000..9645e8b0f8 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/localecompare/index.html @@ -0,0 +1,163 @@ +--- +title: String.prototype.localeCompare() +slug: Web/JavaScript/Reference/Global_Objects/String/localeCompare +tags: + - Internacionalização + - JavaScript + - Prototipo + - Referencia + - String + - localeCompare() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/localeCompare +--- +<div>{{JSRef}}</div> + +<p>O método <code>localeCompare()</code> retorna um número que indica se uma string de referência vem antes ou depois, ou é a mesma que a string fornecida na ordem de classificação.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-localecompare.html")}}</div> + + + +<p>Os novos argumentos <em><code>locales</code></em> e <em><code>options</code></em> permitem que os aplicativos especifiquem o idioma cuja ordem da ordenação deve ser usada e personalizem o comportamento da função. Em implementações mais antigas, que ignoram os argumentos <em><code>locales</code></em> e <em><code>options</code></em>, a localidade e a ordem de classificação usadas são totalmente dependentes da implementação.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>referenceStr</var>.localeCompare(<var>compareString</var>[, <var>locales</var>[, <var>options</var>]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code><var>compareString</var></code></dt> + <dd>A string com a qual a <em><code>referenceStr</code></em> é comparada.</dd> + <dt><code><var>locales</var></code> <var>e </var><code><var>options</var></code></dt> + <dd> + <p>Esses argumentos personalizam o comportamento da função e permitem que os aplicativos especifiquem o idioma cujas convenções de formatação devem ser usadas. Em implementações que ignoram os argumentos <em><code>locales</code></em> e <em><code>options</code></em>, a localidade usada e a forma da string retornada são inteiramente dependentes da implementação.</p> + + <p>Consulte o <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator">construtor </a><code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator">Intl.Collator()</a></code> para obter detalhes sobre esses parâmetros e como usá-los.</p> + </dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um número <strong>negativo</strong> se <em><code>referenceStr</code></em> ocorrer antes de <em><code>compareString</code></em>. Um número <strong>positivo</strong> se o <em><code>referenceStr</code></em> ocorrer após <em><code>compareString</code></em>. <code>0</code> se eles forem equivalentes.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Retorna um inteiro indicando se <em><code>referenceStr</code></em> vem antes, depois ou é equivalente a <em><code>compareString</code></em>.</p> + +<ul> + <li>Negativo quando o <em><code>referenceStr</code></em> ocorre antes de <em><code>compareString</code></em></li> + <li>Positivo quando o <em><code>referenceStr</code></em> ocorre após <em><code>compareString</code></em></li> + <li>Retorna <code>0</code> se eles forem equivalentes</li> +</ul> + +<div class="blockIndicator warning"> +<p><strong>NÃO confie em valores de retorno exatos de -1 ou 1!</strong></p> + +<p>Os resultados de números inteiros negativos e positivos variam entre os navegadores (bem como entre as versões dos navegadores) porque a especificação W3C exige apenas valores negativos e positivos. Alguns navegadores podem retornar <code>-2</code> ou <code>2</code>, ou mesmo algum outro valor negativo ou positivo.</p> +</div> + +<h2 id="Performance">Performance</h2> + +<p>Ao comparar um grande número de strings, como na classificação de grandes arrays, é melhor criar um objeto {{jsxref("Global_Objects/Collator", "Intl.Collator")}} e usar a função fornecida por sua propriedade {{jsxref("Collator.prototype.compare", "compare")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_localeCompare">Usando <code>localeCompare()</code></h3> + +<pre class="brush: js notranslate">// A letra "a" está antes de "c" produzindo um valor negativo +'a'.localeCompare('c'); // -2 ou -1 (ou algum outro valor negativo) + +// Alfabeticamente, a palavra "verificar" vem depois de "contra", produzindo um valor positivo +'verificar'.localeCompare('contra'); // 2 ou 1 (ou algum outro valor negativo) + +// "a" e "a" são equivalentes, resultando em um valor neutro de zero +'a'.localeCompare('a'); // 0 +</pre> + +<h3 id="Ordenar_um_array">Ordenar um array</h3> + +<p><code>localeCompare()</code> permite a ordenação sem distinção entre maiúsculas e minúsculas em um array.</p> + +<pre class="brush: js notranslate">let items = ['réservé', 'Premier', 'Cliché', 'communiqué', 'café', 'Adieu']; +items.sort( (a, b) => a.localeCompare(b, 'fr', {ignorePunctuation: true})); +// ['Adieu', 'café', 'Cliché', 'communiqué', 'Premier', 'réservé'] +</pre> + +<h3 id="Verifique_o_suporte_do_navegador_para_os_novos_argumentos">Verifique o suporte do navegador para os novos argumentos</h3> + +<p>Os argumentos <em><code>locales</code></em> e <em><code>options</code></em> ainda não são suportados em todos os navegadores.</p> + +<p>Para verificar se uma implementação os suporta, use o argumento <code>"i"</code> (um requisito de rejeição das tags de linguagem ilegal) e procure uma exceção {{jsxref ("RangeError")}}:</p> + +<pre class="brush: js notranslate">function localeCompareSupportsLocales() { + try { + 'foo'.localeCompare('bar', 'i'); + } catch (e) { + return e.name === 'RangeError'; + } + return false; +} +</pre> + +<h3 id="Usando_locales">Usando <code>locales</code></h3> + +<p>Os resultados fornecidos por <code>localeCompare()</code> variam entre os idiomas. Para obter a ordem de classificação do idioma usado na interface do usuário de seu aplicativo, certifique-se de especificar esse idioma (e possivelmente alguns idiomas substitutos) usando o argumento <em><code>locales</code></em>:</p> + +<pre class="brush: js notranslate">console.log('ä'.localeCompare('z', 'de')); // um valor negativo: em alemão, ä é classificado antes de z +console.log('ä'.localeCompare('z', 'sv')); // um valor positivo: em sueco, ä é classificado após z +</pre> + +<h3 id="Usando_options">Usando <code>options</code></h3> + +<p>Os resultados fornecidos por <code>localeCompare()</code> podem ser personalizados usando o argumento <em><code>options</code></em>:</p> + +<pre class="brush: js notranslate">// em alemão, ä tem a como letra base +console.log('ä'.localeCompare('a', 'de', { sensitivity: 'base' })); // 0 + +// em sueco, ä e a são letras de base separadas +console.log('ä'.localeCompare('a', 'sv', { sensitivity: 'base' })); // um valor positivo +</pre> + +<h3 id="Ordenação_numérica">Ordenação numérica</h3> + +<pre class="brush: js notranslate">// por padrão, "2" > "10" +console.log(<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body">"2".localeCompare("10")</span></span></span>); // 1 + +// numeric using options: +console.log(<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body">"2".localeCompare("10", undefined, {numeric: true})</span></span></span>); // -1 + +// numeric using locales tag: +console.log(<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body">"2".localeCompare("10", "en-u-kn-true")</span></span></span>); // -1 +</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-string.prototype.localecompare', 'String.prototype.localeCompare')}}</td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sup-String.prototype.localeCompare', 'String.prototype.localeCompare')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.localeCompare")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/match/index.html b/files/pt-br/web/javascript/reference/global_objects/string/match/index.html new file mode 100644 index 0000000000..1ba4671e90 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/match/index.html @@ -0,0 +1,232 @@ +--- +title: String.prototype.match() +slug: Web/JavaScript/Reference/Global_Objects/String/match +tags: + - Expressões Regulares + - JavaScript + - Métodos + - Prototipo + - Referencia + - String + - match() +translation_of: Web/JavaScript/Reference/Global_Objects/String/match +--- +<p>{{JSRef("Global_Objects", "String")}}</p> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <code>match()</code> retorna uma correspondência entre uma string com uma <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">expressão regular</a>.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><em>str</em>.match(regexp);</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>regexp</code></dt> + <dd>Um objeto de <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">expressão regular</a>. Se <em><code>regexp</code></em> não for uma <strong><code>RegExp</code></strong>, o mesmo será convertido para uma nova RegExp usando <code>new <strong>RegExp</strong>(<em>regexp</em>)</code>.<br> + <br> + Se você não fornecer nenhum parâmetro ao usar o método <code>match()</code>, você obterá um {{jsxref ("Array")}} com uma string vazia: <code>[""]</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<ul> + <li>Se o sinalizador <code>g</code> for usado, todos os resultados correspondentes à expressão regular serão retornados, mas a captura de grupos não.</li> + <li>se o sinalizador <code>g</code> não for usado, apenas a primeira correspondência completa e seus grupos de captura relacionados serão retornados. Nesse caso, o item devolvido terá propriedades adicionais conforme descrito a seguir.</li> +</ul> + +<dl> + <dt><code>array</code></dt> + <dd>Um {{jsxref ("Array")}} cujo conteúdo depende da presença ou ausência do sinalizador global (<code>g</code>), ou {{jsxref ("null")}} se nenhuma correspondência for encontrada.</dd> +</dl> + +<h4 id="Propriedades_adicionais">Propriedades adicionais</h4> + +<p>Conforme explicado acima, alguns resultados contêm propriedades adicionais conforme descrito abaixo.</p> + +<dl> + <dt><code>groups</code></dt> + <dd>Um objeto de grupos de captura nomeados cujas chaves são os nomes, e valores são os grupos de captura ou {{jsxref ("undefined")}} se nenhum grupo de captura nomeado foi definido. Consulte <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">Grupos e Intervalos</a> para obter mais informações.</dd> + <dt><code>index</code></dt> + <dd>O índice da pesquisa em que o resultado foi encontrado.</dd> + <dt><code>input</code></dt> + <dd>Uma cópia da string pesquisada.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Se a expressão regular não incluir o sinalizador <code>g</code>, <code>str.match()</code> retornará o mesmo resultado que {{jsxref ("RegExp.prototype.exec()", "RegExp.exec()")}}.</p> + +<h3 id="Notes" name="Notes">Veja também: métodos RegExp</h3> + +<ul> + <li>Se você precisar saber se uma string corresponde a uma expressão regular, use {{jsxref("RegExp.test()", "RegExp.test()")}}.</li> + <li>Se você quiser encontrar apenas uma correspondência, você pode querer usar {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}}.</li> + <li>Se você deseja obter grupos de captura e o sinalizador global (<code>g</code>) está definido, você precisa usar {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}} ou {{jsxref("String. prototype.matchAll() ")}} em vez disso.</li> +</ul> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Using_match" name="Example:_Using_match">Usando <code>match()</code></h3> + +<p>No exemplo a seguir, <code>match()</code> é usado para encontrar "Capítulo", seguido de um ou mais caracteres numéricos, seguido por um ponto decimal e caracteres numéricos 0 ou mais vezes. A expressão inclui a flag <code>i</code> para que diferenças de maiúscula/minúscula sejam ignoradas.</p> + +<pre class="brush:js notranslate">var str = "Para maiores informações, veja o Capítulo 3.4.5.1"; +var re = /(capítulo \d+(\.\d)*)/i; +var found = str.match(re); + +console.log(found); + +// retorna ["Capítulo 3.4.5.1", + "Capítulo 3.4.5.1", + ".1", + index: 33, + input: "Para maiores informações, veja o Capítulo 3.4.5.1"] + +// "Capítulo 3.4.5.1" é a primeira correspondência e o primeiro valor +// capturado a partir de (capítulo \d+(\.\d)*). +// ".1" é o útlimo valor de (\.\d). +// A propriedade "index" (33) é o índice de base zero da correspôndencia inteira. +// A propriedade "input" é a string original que foi analisada. +</pre> + +<h3 id="Example_Using_global_and_ignore_case_flags_with_match" name="Example:_Using_global_and_ignore_case_flags_with_match">Usando as bandeiras (flags) global e ignore com<br> + <code>match()</code></h3> + +<p>O exemplo a seguir demonstra o uso das bandeiras (flags) global e ignore com <code>match()</code>. Todas as letras de <code>A</code> a <code>E</code> e <code>a</code> a <code>e</code> são retornadas, com cada letra sendo um elemento no array.</p> + +<pre class="brush:js notranslate">var str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; +var regexp = /[A-E]/gi; +var matches_array = str.match(regexp); + +console.log(matches_array); +// <code>['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']</code> +</pre> + +<div class="blockIndicator note"> +<p><strong>Nota:</strong> Veja também {{jsxref("String.prototype.matchAll()")}} e <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions#Pesquisa_avan%C3%A7ada_com_Flags" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions#Pesquisa_avan%C3%A7ada_com_Flags">Pesquisa avançada com sinalizadores</a>.</p> +</div> + +<h3 id="Usando_grupos_de_captura_nomeados">Usando grupos de captura nomeados</h3> + +<p>Em navegadores que suportam grupos de captura nomeados, o código a seguir captura "<code>fox</code>" ou "<code>cat</code>" em um grupo denominado "<code>animal</code>":</p> + +<pre class="brush: js notranslate">const paragraph = 'The quick brown fox jumps over the lazy dog. It barked.'; + +const capturingRegex = /(?<animal>fox|cat) jumps over/; +const found = paragraph.match(capturingRegex); +console.log(found.groups); // {animal: "fox"}</pre> + +<h3 id="Usando_match_sem_parâmetros">Usando <code>match()</code> sem parâmetros</h3> + +<pre class="brush: js notranslate">var str = "nada se perde, tudo se transforma"; + +str.match(); // retorna [""] +</pre> + +<h3 id="Um_objeto_não-RegExp_como_parâmetro">Um objeto não-RegExp como parâmetro</h3> + +<p>Quando o parâmetro <em><code>regexp</code></em> é uma string ou um número, ele é convertido implicitamente em um {{jsxref("RegExp")}} usando o <code>new <strong>RegExp</strong>(<em>regexp</em>)</code>.<br> + <br> + Se for um número positivo com um sinal positivo, <code>RegExp()</code> irá ignorar o sinal positivo.</p> + +<pre class="brush: js notranslate"><code>var str1 = "NaN significa 'não é um número'. Infinity contem -Infinity e +Infinity em JavaScript.", + str2 = "Meu avô tem 65 anos e minha avô tem 63.", + str3 = "O contrato foi declarado null (nulo) e void (sem efeito)"; +str1.match("número"); // "número" é um string. retorna ["número"] +str1.match(NaN); // o tipo de NaN é um número. retorna ["NaN"] +str1.match(Infinity); // o tipo de Infinity é um número. retorna ["Infinity"] +str1.match(+Infinity); // retorna ["Infinity"] +str1.match(-Infinity); // retorna ["-Infinity"] +str2.match(65); // retorna ["65"] +str2.match(+65); // Um número com sinal positivo. retorna ["65"] +str3.match(null); // retorna ["null"]</code></pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificações</th> + <th scope="col">Estado</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>ECMAScript 3rd Edition.</td> + <td>Standard</td> + <td>Definição inicial.<br> + Implementado no JavaScript 1.2</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.10', 'String.prototype.match')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.match', 'String.prototype.match')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p>{{ CompatibilityTable() }}</p> + +<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>{{ 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>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>{{ 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("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/matchall/index.html b/files/pt-br/web/javascript/reference/global_objects/string/matchall/index.html new file mode 100644 index 0000000000..7399d9e290 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/matchall/index.html @@ -0,0 +1,146 @@ +--- +title: String.prototype.matchAll() +slug: Web/JavaScript/Reference/Global_Objects/String/matchAll +tags: + - Expressões Regulares + - JavaScript + - Prototipo + - Referencia + - String + - matchAll() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/matchAll +--- +<div>{{JSRef}}</div> + +<p>O método <code>matchAll()</code> retorna um iterador de todos os resultados correspondentes a uma string em relação a uma <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">expressão regular</a>, incluindo <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">grupos de captura</a>.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-matchall.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.matchAll(<var>regexp</var>)</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code><var>regexp</var></code></dt> + <dd> + <p>Um objeto de expressão regular.</p> + + <p>Se um objeto <em><code>obj</code></em> não-RegExp for passado, ele será convertido implicitamente em um {{jsxref("RegExp")}} usando <code>new RegExp(<em>obj</em>)</code>.</p> + + <p>O objeto <code>RegExp</code> deve ter o sinalizador (flag) <code>/g</code>, caso contrário, um <code>TypeError</code> será retornado.</p> + </dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Iteratores_e_geradores" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Iteratores_e_geradores">iterador</a> (que não é um iterável reinicializável).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Regexp.exec_e_matchAll">Regexp.exec() e matchAll()</h3> + +<p>Antes da adição do <code>matchAll()</code> ao JavaScript, era possível usar chamadas <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec">regexp.exec</a> (e regexes com a sinalização (flag) <code>/g</code>) em um loop para obter todas as correspondências:</p> + +<pre class="brush: js notranslate">const regexp = RegExp('foo[a-z]*','g'); +const str = 'table football, foosball'; +let match; + +while ((match = regexp.exec(str)) !== null) { + console.log(`Encontrou ${match[0]} início=${match.index} fim=${regexp.lastIndex}.`); + // retorna "Encontrou football início=6 fim=14." + // retorna "Encontou foosball início=16 fim=24." +}</pre> + +<p>Com o <code>matchAll()</code> disponível, você pode evitar o loop {{jsxref("Statements/while", "while")}} e executar com <code>g</code>.</p> + +<p>Em vez disso, usando o <code>matchAll()</code>, você obtém um iterador para usar com o mais conveniente {{jsxref ("Statements/for ... of", "for...of")}}, {{jsxref ("Operators/Spread_syntax" , "array spread")}} ou construções {{jsxref ("Array.from()")}}:</p> + +<pre class="brush: js notranslate">const regexp = RegExp('foo[a-z]*','g'); +const str = 'table football, foosball'; +const matches = str.matchAll(regexp); + +for (const match of matches) { + console.log(`Encontrou ${match[0]} início=${match.index} fim=${match.index + match[0].length}.`); +} +// retorna "Encontrou football início=6 fim=14." +// retorna "Encontrou foosball início=16 fim=24." + +// O iterador de correspondências se esgota após a iterção for..of +// Chame matchAll novamente para criar um novo iterador +Array.from(str.matchAll(regexp), m => m[0]); +// Array [ "football", "foosball" ]</pre> + +<p><code>matchAll()</code> retornará uma exceção se o sinalizador (flag) <code>g</code> estiver ausente.</p> + +<pre class="brush: js notranslate">const regexp = RegExp('[a-c]',''); +const str = 'abc'; +str.matchAll(regexp); +// retorna TypeError +</pre> + +<p><code>matchAll()</code> cria internamente um clone da <code>regexp</code> - portanto, ao contrário de {{jsxref("Global_Objects/RegExp/exec", "regexp.exec()")}}, o <code>lastIndex</code> não muda conforme a string é verificada.</p> + +<pre class="brush: js notranslate">const regexp = RegExp('[a-c]','g'); +regexp.lastIndex = 1; +const str = 'abc'; +Array.from(str.matchAll(regexp), m => `${regexp.lastIndex} ${m[0]}`); +// Array [ "1 b", "1 c" ]</pre> + +<h3 id="Melhor_acesso_para_capturar_grupos_do_que_String.prototype.match">Melhor acesso para capturar grupos (do que String.prototype.match())</h3> + +<p>Outra razão convincente para usar <code>matchAll()</code> é o acesso aprimorado para capturar grupos.</p> + +<p>Os grupos de captura são ignorados ao usar {{jsxref("Global_Objects/String/match", "match()")}} com o sinalizador global <code>/g</code>:</p> + +<pre class="brush: js notranslate">let regexp = /t(e)(st(\d?))/g; +let str = 'test1test2'; + +str.match(regexp); +// Array ['test1', 'test2']</pre> + +<p>Usando o <code>matchAll()</code>, você pode acessar os grupos de captura facilmente:</p> + +<pre class="brush: js notranslate">let array = [...str.matchAll(regexp)]; + +array[0]; +// ['test1', 'e', 'st1', '1', index: 0, input: 'test1test2', length: 4] +array[1]; +// ['test2', 'e', 'st2', '2', index: 5, input: 'test1test2', length: 4] +</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-string.prototype.matchall', 'String.prototype.matchAll')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">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> + +<p>{{Compat("javascript.builtins.String.matchAll")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.match()")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Using regular expressions in JavaScript</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">Capturing groups</a></li> + <li>{{jsxref("RegExp")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/normalize/index.html b/files/pt-br/web/javascript/reference/global_objects/string/normalize/index.html new file mode 100644 index 0000000000..eb049a0ba5 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/normalize/index.html @@ -0,0 +1,220 @@ +--- +title: String.prototype.normalize() +slug: Web/JavaScript/Reference/Global_Objects/String/normalize +tags: + - ECMAScript2015 + - JavaScript + - Prototipo + - Referencia + - String + - Unicode + - metodo + - normalize() +translation_of: Web/JavaScript/Reference/Global_Objects/String/normalize +--- +<div>{{JSRef}}</div> + +<p>O método<strong> </strong><code>normalize()</code> retorna a Forma de Normalização Unicode (Unicode Normalization Form) de uma dada string (se o valor não é uma string, ele será convertido para uma primeiramente).</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.normalize([<var>form</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>form</code></dt> + <dd>Opcional. Um dentre os seguintes valores: <code>"NFC"</code>, <code>"NFD"</code>, <code>"NFKC"</code>, ou <code>"NFKD"</code>, especificando o formato de normalização. Se o valor for omitido ou for {{jsxref("undefined")}}, <code>"NFC"</code> será utilizado. + <ul> + <li><code>NFC</code> — Formato de Normalização Canônico de Composição. </li> + <li><code>NFD</code> — Formato de Normalização Canônico de Decomposição.</li> + <li><code>NFKC</code> — Formato de Normalização de Compatibilidade de Composição.</li> + <li><code>NFKD</code> — Formato de Normalização de Compatibilidade de Decomposição.</li> + </ul> + </dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo a Forma de Normalização Unicode da string dada.</p> + +<h3 id="Erros_lançados">Erros lançados</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Em erro {{jsxref("RangeError")}} é lançado se <code>form</code> não for um dos valores especificados acima.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>O Unicode atribui um valor numérico exclusivo, denominado <em>ponto de código</em>, a cada caractere. Por exemplo, o ponto de código para <em>"A"</em> é fornecido como U+0041. No entanto, às vezes mais de um ponto de código, ou sequência de pontos de código, podem representar o mesmo caractere abstrato - o caractere <code>"ñ"</code>, por exemplo, pode ser representado por:</p> + +<ul> + <li>Apenas um ponto de código U+00F1.</li> + <li>O ponto de código para <code>"n"</code> (U+006E) seguido pelo ponto de código para o til (U+0303).</li> +</ul> + +<pre class="brush: js notranslate">let string1 = '\u00F1'; +let string2 = '\u006E\u0303'; + +console.log(string1); // retorna ñ +console.log(string2); // retorna ñ</pre> + +<p>No entanto, como os pontos de código são diferentes, a comparação de strings não os tratará como iguais. E como o número de pontos de código em cada versão é diferente, eles até mesmo possuem comprimentos diferentes.</p> + +<pre class="brush: js notranslate">let string1 = '\u00F1'; // ñ +let string2 = '\u006E\u0303'; // ñ + +console.log(string1 === string2); // retorna false +console.log(string1.length); // retorna 1 +console.log(string2.length); // retorna 2</pre> + +<p>O método <code>normalize()</code> ajuda a resolver esse problema convertendo uma string em uma forma normalizada comum para todas as sequências de pontos de código que representam os mesmos caracteres. Existem duas principais formas de normalização, uma baseada na <strong>equivalência canônica</strong> e a outra baseada na <strong>compatibilidade</strong>.</p> + +<h3 id="Normalização_de_equivalência_canônica">Normalização de equivalência canônica</h3> + +<p>Em Unicode, duas sequências de pontos de código têm equivalência canônica se representarem os mesmos caracteres abstratos e tiverem sempre a mesma aparência visual e comportamento (por exemplo, eles devem sempre ser classificados da mesma maneira).</p> + +<p>Você pode usar o <code>normalize()</code> usando os argumentos <code>"NFD"</code> ou <code>"NFC"</code> para produzir uma forma de string que será a mesma para todas as strings canonicamente equivalentes. No exemplo abaixo, normalizamos duas representações do caractere <code>"ñ"</code>:</p> + +<pre class="brush: js notranslate">let string1 = '\u00F1'; // ñ +let string2 = '\u006E\u0303'; // ñ + +string1 = string1.normalize('NFD'); +string2 = string2.normalize('NFD'); + +console.log(string1 === string2); // retorna true +console.log(string1.length); // retorna 2 +console.log(string2.length); // retorna 2</pre> + +<h4 id="Formas_compostas_e_decompostas"><strong>Formas compostas e decompostas</strong></h4> + +<p>Observe que o comprimento da forma normalizada em <code>"NFD"</code> é <code>2</code>. Isso porque <code>"NFD"</code> fornece a versão <strong>decomposta</strong> da forma canônica, na qual pontos de código únicos são divididos em vários combinados. A forma canônica decomposta para <code>"ñ"</code> é <code>"\u006E\u0303"</code>.</p> + +<p>Você pode especificar <code>"NFC"</code> para obter a forma canônica <strong>composta</strong>, na qual vários pontos de código são substituídos por pontos de código únicos sempre que possível. A forma canônica composta para <code>"ñ"</code> é <code>"\u00F1"</code>:</p> + +<pre class="brush: js notranslate">let string1 = '\u00F1'; // ñ +let string2 = '\u006E\u0303'; // ñ + +string1 = string1.normalize('NFC'); +string2 = string2.normalize('NFC'); + +console.log(string1 === string2); // true +console.log(string1.length); // 1 +console.log(string2.length); // 1 +console.log(string2.codePointAt(0).toString(16)); // f1</pre> + +<h3 id="Normalização_de_compatibilidade">Normalização de compatibilidade</h3> + +<p>No Unicode, duas sequências de pontos de código são compatíveis se representarem os mesmos caracteres abstratos e devem ser tratadas da mesma forma em algumas - mas não necessariamente em todas - aplicações.</p> + +<p>Todas as sequências canonicamente equivalentes também são compatíveis, mas não o contrário.</p> + +<p>Por exemplo:</p> + +<ul> + <li>o ponto de código U+FB00 representa a <a href="https://wiki.developer.mozilla.org/en-US/docs/Glossary/Ligature" title="https://wiki.developer.mozilla.org/en-US/docs/Glossary/Ligature">ligadura</a> <code>"ff"</code>. É compatível com dois pontos de código U+0066 consecutivos (<code>"ff"</code>).</li> + <li>o ponto de código U+24B9 representa o símbolo <code>"Ⓓ"</code>. É compatível com o ponto de código U+0044 (<code>"D"</code>).</li> +</ul> + +<p>Em alguns aspectos (como classificação), eles devem ser tratados como equivalentes - e em alguns (como a aparência visual) não devem, portanto, não são canonicamente equivalentes.</p> + +<p>Você pode usar o <code>normalize()</code> usando os argumentos <code>"NFKD"</code> ou <code>"NFKC"</code> para produzir uma forma de string que será a mesma para todas as strings compatíveis:</p> + +<pre class="brush: js notranslate">let string1 = '\uFB00'; +let string2 = '\u0066\u0066'; + +console.log(string1); // ff +console.log(string2); // ff +console.log(string1 === string2); // false +console.log(string1.length); // 1 +console.log(string2.length); // 2 + +string1 = string1.normalize('NFKD'); +string2 = string2.normalize('NFKD'); + +console.log(string1); // ff <- aparência visual modificada +console.log(string2); // ff +console.log(string1 === string2); // true +console.log(string1.length); // 2 +console.log(string2.length); // 2</pre> + +<p>Ao aplicar a normalização de compatibilidade, é importante considerar o que você pretende fazer com as strings, uma vez que a forma normalizada pode não ser apropriada para as aplicações. No exemplo acima, a normalização é apropriada para pesquisa, porque permite que um usuário encontre a string pesquisando por <code>"f"</code>. Mas pode não ser apropriado para exibição, porque a representação visual é diferente.</p> + +<p>Como na normalização canônica, você pode solicitar formulários compatíveis decompostos ou compostos passando <code>"NFKD"</code> ou <code>"NFKC"</code>, respectivamente.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_normalize"><font face="x-locale-heading-primary, zillaslab, Palatino, Palatino Linotype, x-locale-heading-secondary, serif">Usando </font><code>normalize()</code></h3> + +<pre class="brush: js notranslate">// String Inicial + +// U+1E9B: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA +// U+0323: COMBINANDO PONTO ABAIXO +var str = '\u1E9B\u0323'; + + +// Formato de Normalização Canônico de Composição (NFC) + +// U+1E9B: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA +// U+0323: COMBINANDO PONTO ABAIXO +str.normalize('NFC'); // '\u1E9B\u0323' +str.normalize(); // igual à linha de cima + + +// Formato de Normalização Canônico de Decomposição (NFD) + +// U+017F: CARACTERE LATINO - LETRA S COMPRIDA +// U+0323: COMBINANDO PONTO ABAIXO +// U+0307: COMBINANDO PONTO ACIMA +str.normalize('NFD'); // '\u017F\u0323\u0307' + + +// Formato de Normalização de Compatibilidade de Composição. (NFKC) + +// U+1E69: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA E ABAIXO +str.normalize('NFKC'); // '\u1E69' + + +// Formato de Normalização de Compatibilidade de Decomposição (NFKD) + +// U+0073: CARACTERE LATINO - LETRA S COMPRIDA +// U+0323: COMBINANDO PONTO ABAIXO +// U+0307: COMBINANDO PONTO ACIMA +str.normalize('NFKD'); // '\u0073\u0323\u0307' +</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('ES2015', '#sec-string.prototype.normalize', 'String.prototype.normalize')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.normalize', 'String.prototype.normalize')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Nevegadores_compatíveis">Nevegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.normalize")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="http://www.unicode.org/reports/tr15/">Unicode Standard Annex #15, Unicode Normalization Forms</a></li> + <li><a href="http://en.wikipedia.org/wiki/Unicode_equivalence">Unicode equivalence</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/padend/index.html b/files/pt-br/web/javascript/reference/global_objects/string/padend/index.html new file mode 100644 index 0000000000..4c4395451b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/padend/index.html @@ -0,0 +1,103 @@ +--- +title: String.prototype.padEnd() +slug: Web/JavaScript/Reference/Global_Objects/String/padEnd +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - padEnd() +translation_of: Web/JavaScript/Reference/Global_Objects/String/padEnd +--- +<div>{{JSRef}}</div> + +<p>O método <code>padEnd()</code> preenche a string original com um determinado caractere, ou conjunto de caraceres, (repetidamente, se necessário) para que a string resultante alcance um determinado comprimento. O preenchimento é aplicado a partir do final (direita) da string original. A string original não é modificada.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-padend.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.padEnd(<var>targetLength</var> [, <var>padString</var>])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>targetLength</code></dt> + <dd>O comprimento da string resultante após a string original ter sido preenchida. Se o valor for menor do que o próprio comprimento da string original, a string original é retornada sem modificações.</dd> + <dt><code>padString</code></dt> + <dd>Opcional. O caractere (ou caracteres) que deve completar a string atual. Caso o comprimento desta string seja muito longo, estando acima do comprimento alvo, ela será truncada e sua parte esquerda restante é aplicada. O valor padrão para esse parâmetro é "<code> </code>" (<code>U+0020</code>).</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma {{jsxref("String")}} cuja composição vem da string original, completada por um ou mais caracteres de preenchimento, respeitando o comprimento alvo.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_padEnd">Usando padEnd</h3> + +<pre class="brush: js notranslate">'abc'.padEnd(10); // "abc " +'abc'.padEnd(10, "foo"); // "abcfoofoof" +'abc'.padEnd(6, "123456"); // "abc123" +'abc'.padEnd(1); // "abc"</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Rodando o seguinte código antes de qualquer código irá criar o método <code>String.prototype.padEnd()</code> caso ele não esteja disponível nativamente:</p> + +<pre class="brush: js notranslate">// https://github.com/uxitten/polyfill/blob/master/string.polyfill.js +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padEnd +if (!String.prototype.padEnd) { + String.prototype.padEnd = function padEnd(targetLength,padString) { + targetLength = targetLength>>0; //floor if number or convert non-number to 0; + padString = String((typeof padString !== 'undefined' ? padString : ' ')); + if (this.length > targetLength) { + return String(this); + } + else { + targetLength = targetLength-this.length; + if (targetLength > padString.length) { + padString += padString.repeat(targetLength/padString.length); //append to original to ensure we are longer than needed + } + return String(this) + padString.slice(0,targetLength); + } + }; +} +</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('ESDraft', '#sec-string.prototype.padend', 'String.prototype.padEnd')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Definição inicial no ECMAScript 2017.</td> + </tr> + <tr> + <td>{{SpecName('ES8', '#sec-string.prototype.padend', 'String.prototype.padEnd')}}</td> + <td>{{Spec2('ES8')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.padEnd")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.padStart()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/padstart/index.html b/files/pt-br/web/javascript/reference/global_objects/string/padstart/index.html new file mode 100644 index 0000000000..3a60ff2489 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/padstart/index.html @@ -0,0 +1,107 @@ +--- +title: String.prototype.padStart() +slug: Web/JavaScript/Reference/Global_Objects/String/padStart +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - padStart() +translation_of: Web/JavaScript/Reference/Global_Objects/String/padStart +--- +<div>{{JSRef}}</div> + +<p>O método <code>padStart()</code> preenche a string original com um determinado caractere, ou conjunto de caracteres, (várias vezes, se necessário) até que a string resultante atinja o comprimento fornecido. O preenchimento é aplicado antes do primeiro caractere da string original. A string original não é modificada.</p> + + + +<div>{{EmbedInteractiveExample("pages/js/string-padstart.html")}}</div> + + + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.padStart(<var>targetLength</var> [, <var>padString</var>])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>targetLength</code></dt> + <dd>O comprimento da string resultante uma vez que a string alvo tenha sido preenchida. Caso seu valor seja menor do que o comprimento da string alvo, é retornado a própria string alvo, sem alterações.</dd> + <dt><code>padString</code></dt> + <dd>Opcional. O caractere, ou caracteres, que deve preencher a string alvo. Caso o comprimento dessa essa string de preenchimento seja superior ao <code>targetLength</code>, ela será truncada a partir da direita. O valor padrão é <code>" "</code> (<code>U+0020 'SPACE'</code>).</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Uma {{jsxref("String")}} de comprimento específico com uma string de preenchimento aplicada a partir do seu início.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Exemplos_básicos">Exemplos básicos</h3> + +<pre class="brush: js notranslate">'abc'.padStart(10); // " abc" +'abc'.padStart(10, "foo"); // "foofoofabc" +'abc'.padStart(6,"123465"); // "123abc" +'abc'.padStart(8, "0"); // "00000abc" +'abc'.padStart(1); // "abc"</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Ao executar o seguinte código antes de qualquer outro código é criado o método <code>String.prototype.padStart()</code>, em casos onde ele não está disponível nativamente:</p> + +<pre class="brush: js notranslate">// https://github.com/uxitten/polyfill/blob/master/string.polyfill.js +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart +if (!String.prototype.padStart) { + String.prototype.padStart = function padStart(targetLength, padString) { + targetLength = targetLength >> 0; //truncate if number, or convert non-number to 0; + padString = String(typeof padString !== 'undefined' ? padString : ' '); + if (this.length >= targetLength) { + return String(this); + } else { + targetLength = targetLength - this.length; + if (targetLength > padString.length) { + padString += padString.repeat(targetLength / padString.length); //append to original to ensure we are longer than needed + } + return padString.slice(0, targetLength) + String(this); + } + }; +} +</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('ESDraft', '#sec-string.prototype.padstart', 'String.prototype.padStart')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Implementação inical no ECMAScript 2017.</td> + </tr> + <tr> + <td>{{SpecName('ES8', '#sec-string.prototype.padstart', 'String.prototype.padStart')}}</td> + <td>{{Spec2('ES8')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.padStart")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.padEnd()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/string/prototype/index.html new file mode 100644 index 0000000000..14594dfaf6 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/prototype/index.html @@ -0,0 +1,176 @@ +--- +title: String.prototype +slug: Web/JavaScript/Reference/Global_Objects/String/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/String +--- +<div>{{JSRef}}</div> + +<p>A <strong><code>String.prototype</code></strong> representa o prototipo de objeto {{jsxref("String")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Todas as instâncias {{jsxref("String")}} herdam de <code>String.prototype</code>. Alterações na <code>String</code> são propagadas para todas as instâncias {{jsxref("String")}}.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>String.prototype.constructor</code></dt> + <dd>Especifica a função que cria o protótipo de um objeto.</dd> + <dt>{{jsxref("String.prototype.length")}}</dt> + <dd>Reflete o comprimento da string.</dd> + <dt><code><em>N</em></code></dt> + <dd>Usado para acessar o caractere na posição <em>N</em> onde <em>N</em> é um número inteiro entre 0 e um menor que o valor da <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Function/length">length</a></code>. Estas propriedades são apenas de leitura.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<h3 id="Métodos_não_relacionados_ao_HTML">Métodos não relacionados ao HTML</h3> + +<dl> + <dt>{{jsxref("String.prototype.charAt()")}}</dt> + <dd>Retorna o caractere (exatamente uma unidade de código UTF-16) no índice especificado.</dd> + <dt>{{jsxref("String.prototype.charCodeAt()")}}</dt> + <dd>Retorna um número que é o valor da unidade de código UTF-16 em dado índice.</dd> + <dt>{{jsxref("String.prototype.codePointAt()")}}</dt> + <dd>Retorna um número inteiro não negativo Number que é o valor de posição de código da posição de código inicial em dado índice.</dd> + <dt>{{jsxref("String.prototype.concat()")}}</dt> + <dd>Combina o texto de duas strings e retorna uma nova string.</dd> + <dt>{{jsxref("String.prototype.includes()")}}</dt> + <dd> Determina se uma string deve ser encontrada dentro de outra string.</dd> + <dt>{{jsxref("String.prototype.endsWith()")}}</dt> + <dd>Determina se uma string termina com os caracteres de outra string.</dd> + <dt>{{jsxref("String.prototype.indexOf()")}}</dt> + <dd>Retorna o índice dentro do objeto String chamado da primeira ocorrência do valor especificado, ou -1 se não encontrado.</dd> + <dt>{{jsxref("String.prototype.lastIndexOf()")}}</dt> + <dd>Retorna o índice dentro do objeto String chamado da última ocorrência do valor especificado, ou -1 se não encontrado.</dd> + <dt>{{jsxref("String.prototype.localeCompare()")}}</dt> + <dd>Retorna um número indicando se uma string de referência vem antes ou depois ou é o mesmo que uma string dada em ordem de classificação.</dd> + <dt>{{jsxref("String.prototype.match()")}}</dt> + <dd>Usado para combinar uma expressão regular com uma string.</dd> + <dt>{{jsxref("String.prototype.normalize()")}}</dt> + <dd>Retorna o Formulário de Normalização Unicode do valor string chamado.</dd> + <dt>{{jsxref("String.prototype.padEnd()")}}</dt> + <dd>Empacota a string atual desde o final com uma string dada para criar uma nova string de um dado comprimento.</dd> + <dt>{{jsxref("String.prototype.padStart()")}}</dt> + <dd>Empacota a string atual desde o início com uma string dada para criar uma nova string de um dado comprimento.</dd> + <dt><s class="obsoleteElement">{{jsxref("String.prototype.quote()")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Envolve a cadeia entre aspas duplas ("" ").</s></dd> + <dt>{{jsxref("String.prototype.repeat()")}}</dt> + <dd>Retorna uma string consistindo elementos do objeto repetido pelas vezes definidas.</dd> + <dt>{{jsxref("String.prototype.replace()")}}</dt> + <dd>Usado para encontrar uma combinação entre uma expressão regular e uma string, e para substituir uma substring combinada com uma nova substring.</dd> + <dt>{{jsxref("String.prototype.search()")}}</dt> + <dd>Executa a procura por uma combinação entre uma expressão regular e uma string especificada.</dd> + <dt>{{jsxref("String.prototype.slice()")}}</dt> + <dd>Extrai uma seção de uma string e retorna uma nova string.</dd> + <dt>{{jsxref("String.prototype.split()")}}</dt> + <dd>Separa um objeto <a href="pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String" title="The String global object is a constructor for strings, or a sequence of characters."><code>String</code></a> em um array de strings separando a string em substrings.</dd> + <dt>{{jsxref("String.prototype.startsWith()")}}</dt> + <dd>Determina se uma string começa com os caracteres de outra string.</dd> + <dt>{{jsxref("String.prototype.substr()")}}</dt> + <dd>Retorna os caracteres em uma string começando no local especificado através do número especificado de caracteres.</dd> + <dt>{{jsxref("String.prototype.substring()")}}</dt> + <dd>Retorna os caracteres em uma string entre dois índices na string.</dd> + <dt>{{jsxref("String.prototype.toLocaleLowerCase()")}}</dt> + <dd>Os caracteres dentro de uma string são convertidos para letras minúsculas enquanto respeita a localidade atual. Para a maioria das línguas, irá retornar o mesmo que <a href="pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase" title="The toLowerCase() method returns the calling string value converted to lower case."><code>toLowerCase()</code></a>.</dd> + <dt>{{jsxref("String.prototype.toLocaleUpperCase()")}}</dt> + <dd>Os caracteres dentro de uma string são convertidas para letra maiúscula enquanto respeita a localidade atual. Para a maioria das línguas, irá retornar o mesmo que <a href="pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase" title="The toUpperCase() method returns the calling string value converted to upper case."><code>toUpperCase()</code></a>.</dd> + <dt>{{jsxref("String.prototype.toLowerCase()")}}</dt> + <dd>Retorna o valor da string de chamada convertido em minúsculas.</dd> + <dt>{{jsxref("String.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Retorna um objeto literal representando o objeto especificado; Você pode usar esse valor para criar um novo objeto. Substitui o metodo:{{jsxref("Object.prototype.toSource()")}}</dd> + <dt>{{jsxref("String.prototype.toString()")}}</dt> + <dd>Retorna uma string que representa o objeto especificado. Substitui o metodo:{{jsxref("Object.prototype.toString()")}}</dd> + <dt>{{jsxref("String.prototype.toUpperCase()")}}</dt> + <dd>Retorna o valor da string de chamada convertido em maiúscula.</dd> + <dt>{{jsxref("String.prototype.trim()")}}</dt> + <dd>Retira o espaço em branco desde o início e o fim da string. Parte do padrão ECMAScript 5.</dd> + <dt>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</dt> + <dd>Retira o espaço em branco do lado esquerdo da string.</dd> + <dt>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</dt> + <dd>Retira o espaço em branco do lado esquerdo da string.</dd> + <dt>{{jsxref("String.prototype.valueOf()")}}</dt> + <dd>Retorna o valor primitivo do objeto especificado. Substitui o metodo: {{jsxref("Object.prototype.valueOf()")}} </dd> + <dt>{{jsxref("String.prototype.@@iterator()", "String.prototype[@@iterator]()")}}</dt> + <dd>Retorna um novo objeto <code>Iterator </code>que repete sobre os pontos de código de um valor String, retornando cada ponto de código como um valor String.</dd> +</dl> + +<h3 id="Métodos_de_envoltório_HTML">Métodos de envoltório HTML</h3> + +<p>Esses métodos são de uso limitado, pois fornecem apenas um subconjunto das tags e atributos HTML disponíveis.</p> + +<dl> + <dt>{{jsxref("String.prototype.anchor()")}}</dt> + <dd>{{htmlattrxref("name", "a", "<a name=\"name\">")}} (alvo hipertexto)</dd> + <dt>{{jsxref("String.prototype.big()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("big")}}</dd> + <dt>{{jsxref("String.prototype.blink()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("blink")}}</dd> + <dt>{{jsxref("String.prototype.bold()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("b")}}</dd> + <dt>{{jsxref("String.prototype.fixed()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("tt")}}</dd> + <dt>{{jsxref("String.prototype.fontcolor()")}} {{deprecated_inline}}</dt> + <dd>{{htmlattrxref("color", "font", "<font color=\"color\">")}}</dd> + <dt>{{jsxref("String.prototype.fontsize()")}} {{deprecated_inline}}</dt> + <dd>{{htmlattrxref("size", "font", "<font size=\"size\">")}}</dd> + <dt>{{jsxref("String.prototype.italics()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("i")}}</dd> + <dt>{{jsxref("String.prototype.link()")}}</dt> + <dd>{{htmlattrxref("href", "a", "<a href=\"url\">")}} (link para URL)</dd> + <dt>{{jsxref("String.prototype.small()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("small")}}</dd> + <dt>{{jsxref("String.prototype.strike()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("strike")}}</dd> + <dt>{{jsxref("String.prototype.sub()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("sub")}}</dd> + <dt>{{jsxref("String.prototype.sup()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("sup")}}</dd> +</dl> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacoes</th> + <th scope="col">Status</th> + <th scope="col">Comentarios</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.3.1', 'String.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype', 'String.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype', 'String.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_entre_browsers">Compatibilidade entre browsers</h2> + +<p class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, verifique <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um pedido de participação.</p> + +<p>{{Compat("javascript.builtins.String.prototype")}}</p> + +<h2 id="Veja_também">Veja também </h2> + +<ul> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/raw/index.html b/files/pt-br/web/javascript/reference/global_objects/string/raw/index.html new file mode 100644 index 0000000000..86cfe1b25b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/raw/index.html @@ -0,0 +1,120 @@ +--- +title: String.raw() +slug: Web/JavaScript/Reference/Global_Objects/String/raw +tags: + - ECMAScript 2015 + - JavaScript + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/raw +--- +<div>{{JSRef}}</div> + +<p>O método estático <code>String.raw()</code> é uma função tag de <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/template_strings" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/template_strings">modelos literais</a>, similar ao prefixo <code>r</code> no Python ou o prefixo <code>@</code> no C# para string literais (Mas não é <em>idêntico</em>, existe uma diferença, veja explicações nessa <a href="https://bugs.chromium.org/p/v8/issues/detail?id=5016">discussão</a>). Ele é usado para pegar as strings no formato "cru" de modelos literais, isto é, substituições (ex: <font face="consolas, Liberation Mono, courier, monospace"><span style="">${foo}</span></font>) são processados, mas "escapes" (ex:. <code>\n</code>) não são.</p> + +<p>{{EmbedInteractiveExample("pages/js/string-raw.html")}}</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code>String.raw(<var>callSite</var>, <var>...sub</var>) + +String.raw`templateString` +</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>callSite</code></dt> + <dd> Modelo bem-formatado de objeto de local de chamada, como <code>{ raw: ['foo', 'bar', 'baz'] }</code>.</dd> + <dt><code>...substitutions</code></dt> + <dd>Contém os valores das substituições.</dd> + <dt><code>templateString</code></dt> + <dd>Um <a href="/en-US/docs/Web/JavaScript/Reference/template_strings">modelo string</a>, opcionalmente com substituições (<code>${...}</code>).</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>A forma crua de uma string de um modelo string dado.</p> + +<h3 id="Exceções">Exceções</h3> + +<dl> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Um {{jsxref("TypeError")}} é jogado se o primeiro argumento não é um Objeto bem formado.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Na maioria dos casos, <code>String.raw()</code> é usado com modelos de strings. A primeira sintaxe mencionada acima raramente é usada, porque o mecanismo JavaScript a chamará com os argumentos apropriados para você, assim como com outras <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/template_strings" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/template_strings">funções de tag</a>.</p> + +<p><code>String.raw()</code> é a única função de tag embutida de strings de template; ele funciona exatamente como a função de modelo padrão e executa a concatenação. Você pode até reimplementá-lo com o código JavaScript normal.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_String.raw">Usando <code>String.raw()</code></h3> + +<pre class="brush: js notranslate">String.raw`Hi\n${2+3}!`; +// 'Hi\n5!', o caractere após 'Hi' +// não é um caractere de quebra de linha, +// '\' e 'n' são dois caracteres. + +String.raw`Hi\u000A!`; +// 'Hi\u000A!', o mesmo aqui, agora nós teremos os caracteres +// \, u, 0, 0, 0, A, 6. +// Todos as formas de quebra de linha serão ineficazes +// e as contra barras estarão inclusas no valor retornado. +// Você pode confirmar isso verificando a propriedade .length +// da string. + +let name = 'Bob'; +String.raw`Hi\n${name}!`; +// 'Hi\nBob!', substituições são processadas. + +// Normalmente você não chamaria String.raw() como uma função, +// mas para simular `t${0}e${1}s${2}t` você pode fazer: +String.raw({ raw: 'test' }, 0, 1, 2); // 't0e1s2t' +// Note que 'test', uma string, é um objeto array-like +// O código abaixo é equivalente a: +// `foo${2 + 3}bar${'Java' + 'Script'}baz` +String.raw({ + raw: ['foo', 'bar', 'baz'] +}, 2 + 3, 'Java' + 'Script'); // 'foo5barJavaScriptbaz' + +</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('ES2015', '#sec-string.raw', 'String.raw')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.raw', 'String.raw')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.raw")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/template_strings">Modelos de strings</a></li> + <li>{{jsxref("String")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar">Gramática lexical</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/repeat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/repeat/index.html new file mode 100644 index 0000000000..94cdca3831 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/repeat/index.html @@ -0,0 +1,294 @@ +--- +title: String.prototype.repeat() +slug: Web/JavaScript/Reference/Global_Objects/String/repeat +tags: + - JavaScript + - Prototype + - Referencia + - Repetir + - String + - metodo + - repeat() +translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>repeat()</code></strong> constrói e retorna uma nova string com um determinado número de cópias concatenadas da string original.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.repeat(<var>count</var>);</code> +</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>count</code></dt> + <dd>Um número inteiro entre 0 e {{jsxref("Global_Objects/Number/POSITIVE_INFINITY", "+Infinity")}}, indicando o número de vezes que a string deve ser repetida.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova string contendo o número especificado de cópias da string original.</p> + +<h3 id="Exceções">Exceções</h3> + +<ul> + <li>{{jsxref("Errors/Negative_repetition_count", "RangeError")}}: o número de repetições não pode ser negativo.</li> + <li>{{jsxref("Errors/Resulting_string_too_large", "RangeError")}}: o número de repetições deve ser menor que infinito e não deve ultrapassar o tamanho máximo da string.</li> +</ul> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js notranslate">'abc'.repeat(-1); // RangeError +'abc'.repeat(0); // '' +'abc'.repeat(1); // 'abc' +'abc'.repeat(2); // 'abcabc' +'abc'.repeat(3.5); // 'abcabcabc' (o número será convertido para inteiro) +'abc'.repeat(1/0); // RangeError + +({ toString: () => 'abc', repeat: String.prototype.repeat }).repeat(2); +// 'abcabc' (repeat() é um método genérico) +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>O método <code>repeat()</code> foi adicionado à especificação ECMAScript 2015 e pode ainda não estar disponível em todas as implementações do JavaScript. No entanto, você pode usar o seguinte polyfill para implementar o <code>String.prototype.repeat()</code>:</p> + +<pre class="brush: js notranslate">if (!String.prototype.repeat) { + String.prototype.repeat = function(count) { + 'use strict'; + if (this == null) { + throw new TypeError('não é possível converter ' + this + ' para um objeto'); + } + var str = '' + this; + count = +count; + if (count != count) { + count = 0; + } + if (count < 0) { + throw new RangeError('o núm. de repetições não pode ser negativo'); + } + if (count == Infinity) { + throw new RangeError('o núm. de repetições deve ser menor que infinito'); + } + count = Math.floor(count); + if (str.length == 0 || count == 0) { + return ''; + } + + // Ao Garantir que count seja um inteiro de 31 bits nos dá uma grande otimização + // na parte principal. Porém, navegadores atuais (de agosto de 2014 pra cá) + // não conseguem mais manipular strings de 1 << 28 chars ou maiores, então: + if (str.length * count >= 1 << 28) { + throw new RangeError('o núm. de repetições não deve estourar o tamanho máx. de uma string'); + } + var rpt = ''; + for (var i = 0; i < count; i++) { + rpt += str; + } + return rpt; + } +} +</pre> + +<h4 id="Polyfill_ES5">Polyfill ES5</h4> + +<pre class="syntaxbox notranslate">//#es5 +'use strict'; +(function(win){ + var typeOf=(function(w){var f=function f(x){return typeof(x)},o=w.Symbol,p;if(o && typeof(o)==='function' && typeof(o.iterator)==='symbol'){p=o.prototype;f=function(x){return x && x.constructor===o && x!==p?'symbol':typeof x}};return f})(win), + exist=function(o,p,t){return p in o && typeOf(o[p])===t}; + (function(w){ + var o=w.String.prototype; + if(!exist(o,'repeat','function')){o.repeat=(function(A,E){return function(n){var i=n>>0,s=this,l=s.length,j;if(i===0||l<1){s=''}else{j=268435456;if(i<0||i>=j||i*l>j){throw new RE('Invalidcountvalue')}else if(i>0){s=A(++i).join(s)}};return s}})(w.Array,w.RangeError)}; + })(win); +})(window); + +// teste: +console.clear(); +console.log( +'abc'.repeat(false),//'' +'abc'.repeat({}),//'' +'abc'.repeat([]),//'' +'abc'.repeat(['']),//'' +'abc'.repeat([0]),//'' +'abc'.repeat([0,1]),//'' +'abc'.repeat([1,1]),//'' +'abc'.repeat(0),//'' +'abc'.repeat(.6),//'' +'abc'.repeat(true),//'abc' +'abc'.repeat(1),//'abc' +'abc'.repeat(2),//'abcabc' +'abc'.repeat([2]),//'abcabc' +'abc'.repeat(3.5),//'abcabcabc' +''.repeat(2)//'' +); +console.log( +'abc'.repeat(-Infinity),//RangeError: Invalid count value +'abc'.repeat(Infinity),//RangeError: Invalid count value +'abc'.repeat(1/0),//RangeError: Invalid count value +'abc'.repeat(-1)//RangeError: Invalid count value +); + +/* +es5 src: +'use strict'; +(function(win){ + + var typeOf=(function(w){var f=function f(x){return typeof(x)},o=w.Symbol,p;if(o && typeof(o)==='function' && typeof(o.iterator)==='symbol'){p=o.prototype;f=function(x){return x && x.constructor===o && x!==p?'symbol':typeof x}};return f})(win), + exist=function(o,p,t){return p in o && typeOf(o[p])===t}; + + (function(w){ + var o=w.String.prototype; + if(!exist(o,'repeat','function')){ + o.repeat=(function(A,E){ + return function(n){ + var i=n>>0,s=this,l=s.length,j; + if(i===0||l<1){s=''}else{ + j=268435456; + if(i<0||i>=j||i*l>j){throw new RE('Invalidcountvalue')}else if(i>0){s=A(++i).join(s)} + }; + return s + }; + })(w.Array,w.RangeError); + }; + //.. + })(win); + +})(window); +*/ +</pre> + +<h4 id="Polyfill_ES6">Polyfill ES6</h4> + +<pre class="syntaxbox notranslate">//#es6 + +(w=>{ + + const typeOf=(o=>{let f=x=>typeof x;if(o && 'function'===typeof o){const s='symbol';if(s===typeof o.iterator){const p=o.prototype;f=x=>x && x.constructor===o && x!==p?s:typeof x}};return f})(w.Symbol), + + exist=(o,p,t)=>p in o && typeOf(o[p])===t; + + (o=>{ + + if(!exist(o,'repeat','function')){const A=w.Array,E=w.RangeError;o.repeat=function(n){var i=n>>0,s='';if(i!==0){let t=this;const l=t.length;if(l!==0){if(i<0||i>=(t=268435456)||i*l>t){throw new E('Invalid count value')}else if(i>0){s=A(++i).join(t)}}};return s}}; + + })(w.String.prototype); + +})(window); + +/* + +es6 src: + +(w=>{ + + const typeOf=(o=>{let f=x=>typeof x;if(o && 'function'===typeof o){const s='symbol';if(s===typeof o.iterator){const p=o.prototype;f=x=>x && x.constructor===o && x!==p?s:typeof x}};return f})(w.Symbol), + + exist=(o,p,t)=>p in o && typeOf(o[p])===t; + + + (o=>{ + + if(!exist(o,'repeat','function')){ + + const A=w.Array; + + o.repeat=function(n){var i=n>>0,s='';if(i!==0){let t=this;const l=t.length;if(l!==0){if(i<0||i>=(t=268435456)||i*l>t){throw new RangeError('Invalid count value')}else if(i>0){s=A(++i).join(t)}}};return s}; + + }; + + //.. + + })(w.String.prototype); + + +})(window); + +*/ + + +//test: + +console.clear(); + +console.log( + +'abc'.repeat(false),//'' + +'abc'.repeat({}),//'' + +'abc'.repeat([]),//'' + +'abc'.repeat(['']),//'' + +'abc'.repeat([0]),//'' + +'abc'.repeat([0,1]),//'' + +'abc'.repeat([1,1]),//'' + +'abc'.repeat(0),//'' + +'abc'.repeat(.6),//'' + +'abc'.repeat(true),//'abc' + +'abc'.repeat(1),//'abc' + +'abc'.repeat(2),//'abcabc' + +'abc'.repeat([2]),//'abcabc' + +'abc'.repeat(3.5),//'abcabcabc' + +''.repeat(2)//'' + +); + +console.log( + +'abc'.repeat(-Infinity),//RangeError: Invalid count value + +'abc'.repeat(Infinity),//RangeError: Invalid count value + +'abc'.repeat(1/0),//RangeError: Invalid count value + +'abc'.repeat(-1)//RangeError: Invalid count value + +);</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-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">A tabela de compatibilidade nesta página foi gerada a partir de dados estruturados. Se você quiser contribuir para esses dados, vá para <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie uma pull request.</p> + +<p>{{Compat("javascript.builtins.String.repeat")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.concat()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/replace/index.html b/files/pt-br/web/javascript/reference/global_objects/string/replace/index.html new file mode 100644 index 0000000000..8d1863363b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/replace/index.html @@ -0,0 +1,352 @@ +--- +title: String.prototype.replace() +slug: Web/JavaScript/Reference/Global_Objects/String/replace +tags: + - Expressões Regulares + - JavaScript + - Prototipo + - Referencia + - String + - replace() +translation_of: Web/JavaScript/Reference/Global_Objects/String/replace +--- +<div>{{JSRef("Global_Objects", "String")}}</div> + +<h2 id="Resumo">Resumo</h2> + +<p>O método <code>replace()</code> retorna uma nova string com algumas ou todas as correspondências de um padrão substituídas por um determinado caractere (ou caracteres). O padrão pode ser uma string ou uma {{jsxref("RegExp")}}, e a substituição pode ser uma string ou uma função a ser chamada para cada correspondência. Se o padrão for uma string, apenas a primeira ocorrência será substituída.</p> + +<p>A string original não é modificada.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.replace(<var>regexp</var>|<var>substr</var>, <var>newSubStr</var>|<var>function</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>regexp </code></dt> + <dd><span class="tlid-translation translation"><span title="">Um objeto {{jsxref ("RegExp")}} ou literal. A correspondência ou correspondências são substituídas por <em><code>newSubStr</code></em> ou o valor retornado pela <code>function</code> especificada.</span></span></dd> + <dt><code>substr</code></dt> + <dd><span class="tlid-translation translation"><span title="">Uma {{jsxref ("String")}} que será substituída por <code>newSubStr</code>.</span> <span title="">Ele é tratado como uma string textual e não é interpretado como uma expressão regular.</span> <span title="">Apenas a primeira ocorrência será substituída.</span></span></dd> + <dt><code>newSubStr</code></dt> + <dd>A {{jsxref("Global_Objects/String", "String")}} que substitui a <code>substr</code> recebida do parâmetro #1. Uma série de padrões de substituições especiais são suportados. Veja a seção "<a href="#" id="Specifying_a_string_as_a_parameter">Especificando uma string como parâmetro</a>" abaixo.</dd> + <dt><code>function</code></dt> + <dd>A função (function) chamada cria uma nova substring (para ser colocada no lugar da substring recebida pelo parametro #1). Os argumentos fornececidos para essa função estão descritos na seção "<a href="#" id="Specifying_a_string_as_a_parameter">Especificando uma função como parâmetro</a>" mais abaixo.</dd> + <dt><code>flags</code> {{non-standard_inline}}</dt> + <dd> + <p>Uma string especificando uma combinação de <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">flags de expressão regular</a>. O uso do parâmetro <code>flags</code> no método <code>String.prototype.replace()</code> é não-padrão. Ao invés de usar este parâmetro, use um objeto {{jsxref("Global_Objects/RegExp", "RegExp")}} com as flags correspondentes. O valor deste parâmetro deve ser uma string consistindo em um ou mais dos seguintes caracteres para afetar a operação, tais como descrito:</p> + + <dl> + <dt><code>g</code></dt> + <dd>Combinação global.</dd> + <dt><code>i</code></dt> + <dd>Ignora diferenças entre maiúsculas e minúsculas.</dd> + <dt><code>m</code></dt> + <dd>Combinação em várias linhas.</dd> + <dt><code>y</code> {{experimental_inline}}</dt> + <dd>Sticky</dd> + </dl> + + <div class="blockIndicator note"> + <p><strong>Nota: </strong>O argumento <code>flags</code> não funciona no v8 Core (Chrome e NodeJs).</p> + </div> + </dd> +</dl> + +<h3 id="Returns" name="Returns">Valor retornado</h3> + +<p>Uma nova string com alguma ou todas as combinações do padrão substituído(s) pelo valor de substituição.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Este método não muda o objeto {{jsxref("Global_Objects/String", "String")}}. Ele simplesmente retorna uma nova string.</p> + +<p>Para realizar uma pesquisa global e substituir, inclua a flag <code>g</code> na expressão regular ou se o primeiro parâmetro for uma string, inclua <code>g</code> no parâmetro flags.</p> + +<h3 id="Specifying_a_string_as_a_parameter" name="Specifying_a_string_as_a_parameter">Especificando uma string como parâmetro</h3> + +<p>A string substituidora pode incluir o seguinte padrão de substituição especial:</p> + +<table class="fullwidth-table" style="height: 140px; width: 575px;"> + <tbody> + <tr> + <td class="header"><strong>Padrão </strong></td> + <td class="header"><strong>Insere</strong></td> + </tr> + <tr> + <td><code>$$</code></td> + <td>Insere um "$".</td> + </tr> + <tr> + <td><code>$&</code></td> + <td>Insere a string casada.</td> + </tr> + <tr> + <td><code>$`</code></td> + <td>Insere a porção da string que precede a substring combinada.</td> + </tr> + <tr> + <td><code>$'</code></td> + <td>Insere a porção da string que segue a substring combinada.</td> + </tr> + <tr> + <td><code>$<em>n</em></code> ou <code>$<em>nn</em></code></td> + <td>Onde <code><em>n</em></code> ou <code><em>nn</em></code> são dígitos decimais, insere a <em>n</em>-ésima substring entre parêntesis casada, dado o primeiro argumento foi um objeto {{jsxref("Global_Objects/RegExp", "RegExp")}}.</td> + </tr> + </tbody> +</table> + +<h3 id="Specifying_a_function_as_a_parameter" name="Specifying_a_function_as_a_parameter">Especificando uma função como parâmetro</h3> + +<p>Você pode especificar uma função no segundo parâmetro. Neste caso, a função será chamada depois que a correspôndecia for encontrada. O resultado da função (valor retornado) será usado como a string substituta. (Atenção: os padrões de substituição citados acima não se aplicam neste caso). Note que a função será chamada múltiplas vezes para combinação que deve ser substituída se a expressão regular no primeiro parâmetro tiver a regra global.</p> + +<p>Os parâmetros da função são:</p> + +<table class="fullwidth-table" style="height: 375px; width: 490px;"> + <tbody> + <tr> + <td class="header"><strong>Possíveis nomes </strong></td> + <td class="header"><strong>Valor fornecido</strong></td> + </tr> + <tr> + <td><code>match</code></td> + <td>A substring encontrada. Corresponde ao <code>$&</code> acima.</td> + </tr> + <tr> + <td><code>p1, p2, ...</code></td> + <td>O enésimo parâmetro entre parênteses da RegEx no primeiro parâmetro na função <code>replace()</code> {{jsxref("Global_Objects/RegExp", "RegExp")}}. (Corresponde a <code>$1</code>, <code>$2</code>, etc. acima.) Por exemplo, se <code>/(\a+)(\b+)/</code>, for o primeiro parâmetro, <code>p1</code> é a combinação para <code>\a+</code>, e <code>p2</code> para <code>\b+</code>.</td> + </tr> + <tr> + <td><code>offset</code></td> + <td>O offset da string encontrada em relação ao resto da string. Por exemplo, se a string for 'abcd' e a string a ser encontrada for 'bc', então este parâmetro terá o valor 1.</td> + </tr> + <tr> + <td> + <p><code>string</code></p> + </td> + <td> + <p>A string completa que está sendo examinada.</p> + </td> + </tr> + </tbody> +</table> + +<p>(O número exato de argumentos dependerá se o primeiro parâmetro for uma {{jsxref("Global_Objects/RegExp", "RegExp")}} e de quantas combinações entre parênteses houver).</p> + +<p>O exemplo a seguir irá substituir o valor de <code>newString</code> para <code>'abc - 12345 - #$*%'</code>:</p> + +<pre class="brush: js notranslate">function replacer(match, p1, p2, p3, offset, string) { + // p1 não possui digitos, + // p2 possui dígitos, e p3 não possui alfanuméricos + return [p1, p2, p3].join(' - '); +} +var newString = 'abc12345#$*%'.replace(/([^\d]*)(\d*)([^\w]*)/, replacer); + +// retorna <span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body"><span class="objectBox objectBox-string">"abc - 12345 - #$*%"</span></span></span></span> +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Definindo_uma_expressão_regular_com_replace">Definindo uma expressão regular com <code>replace()</code></h3> + +<p>No exemplo a seguir foi definida uma expressão regular com a flag "<code>i</code>" (que ignora diferenças entre maiúsculas e minúsculas) no método <code>replace()</code>.</p> + +<pre class="notranslate"><code>var str = 'Twas the night before Xmas...'; +var newstr = str.replace(/xmas/i, 'Christmas'); + +console.log(newstr); +// retorna "Twas the night before Christmas..."</code></pre> + +<div class="blockIndicator note"> +<p><strong>Nota:</strong> Veja <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">este guia</a> para maiores explicações as sobre expressões regulares.</p> +</div> + +<h3 id="Usando_global_e_ignore_com_replace">Usando <code>global</code> e <code>ignore</code> com <code>replace()</code></h3> + +<p>Substituir globalmente, "<code>g</code>", só pode ser feito com uma expressão regular. No exemplo a seguir, a expressão regular inclui as flags global e ignore que permitem a função <code>replace()</code> substituir cada "<code>maçãs</code>" por "<code>laranjas</code>" na string.</p> + +<pre class="notranslate"><code>var re = /maçãs/gi; +var str = '</code>As maçãs são redondas. As maçãs são suculentas<code>.'; +var newstr = str.replace(re, 'laranjas'); + +console.log(newstr); +// retorna +// "</code>As laranjas são redondas. As laranjas são suculentas<code>."</code></pre> + +<h3 id="Trocando_palavras_em_uma_string">Trocando palavras em uma string</h3> + +<p>O script a seguir troca as palavras na string. Para o texto que vai substituir, o script usa <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">grupos de captura</a> e os padrões de substituição <code>$1</code> e <code>$2</code>.</p> + +<pre class="notranslate"><code>var re = /(\w+)\s(\w+)/; +var str = 'John Smith'; +var newstr = str.replace(re, '$2, $1'); +console.log(newstr); // Smith, John</code></pre> + +<h3 id="Usando_uma_função_que_modifica_os_caracteres_coincidentes">Usando uma função que modifica os caracteres coincidentes</h3> + +<div class="tw-ta-container hide-focus-ring tw-nfl" id="tw-target-text-container"> +<p><span lang="pt">Neste exemplo, todas as ocorrências de letras maiúsculas na string são convertidas em minúsculas e um hífen é inserido antes do local de correspondência. </span>O importante aqui é que é necessário uma operação adicional no item antes dele ser retornado como substituído.</p> +</div> + +<p>A função de substituição aceita a string coincidida como parâmetro e usa ela para transformar os caracteres e concatenar um hífen antes de retornar.</p> + +<pre class="notranslate"><code>function styleHyphenFormat(propertyName) { + function upperToHyphenLower(match, offset, string) { + return (offset ? '-' : '') + match.toLowerCase(); + } + return propertyName.replace(/[A-Z]/g, upperToHyphenLower); +}</code></pre> + +<p>Dado o seguinte parâmetro: <code>styleHyphenFormat('borderTop')</code>, o valor retornado é '<code>border-top</code>'.</p> + +<p>Como queremos transformar o resultado da coincidencia antes da substituição final, nós devemos usar uma função. Isto força que a transformação seja feita antes da chamada do método {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}. Se tivéssemos tentado isto sem a função, o método {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}} não teria efeito.</p> + +<pre class="brush: js example-bad notranslate">let newString = propertyName.replace(/[A-Z]/g, '-' + '$&'.toLowerCase()); // não funciona</pre> + +<p>Isso acontece porque <code>'$&'.toLowerCase()</code> será executada antes (resultando no mesmo que <code>'$&'</code>) em vez de usar os caracteres da string a ser transformada.</p> + +<h3 id="Substituindo_graus_Fahrenheit_em_Celsius">Substituindo graus Fahrenheit em Celsius</h3> + +<p>O exemplo a seguir converte graus Fahrenheit em Celsius. O grau Fahrenheit deve ser um número terminado com "<code>F</code>". A função retorna o número em Celsius terminando em "<code>C</code>". Por exemplo, se o valor de entrada for "<code>212F</code>", a função deve retornar "<code>100C</code>". Se o número for "<code>0F</code>", a função deve retornar "<code>-17.77777777777778C</code>".</p> + +<p>A expressão regular <code>test</code> verifica por números que terminem com "<code>F</code>". O número de graus Fahrenheit é acessível pela função pelo segundo parâmetro, <code>p1</code>. A função calcula o Celsius baseado no Fahrenheit passado via string para a função <code>f2c()</code>. A <code>f2c()</code> então retorna o número em Celsius.</p> + +<pre class="notranslate"><code>function f2c(x) { + function convert(str, p1, offset, s) { + return ((p1 - 32) * 5/9) + 'C'; + } + var s = String(x); + var test = /(-?\d+(?:\.\d*)?)F\b/g; + return s.replace(test, convert); +}</code></pre> + +<h3 id="Use_uma_função_com_expressão_regular_para_evitar_loops_for">Use uma função com expressão regular para evitar loops for</h3> + +<p>O exemplo a seguir pega um padrão de string e converte em um array de objetos.</p> + +<p><strong>Entrada:</strong></p> + +<p>Uma string com caracteres: <code>x</code>, <code>-</code> e <code>_</code></p> + +<pre class="notranslate"><code>x-x_ +x---x---x---x--- +x-xxx-xx-x- +x_x_x___x___x___</code></pre> + +<p><strong>Saída:</strong></p> + +<p>Um array de objetos. Um <code>'x'</code> denota um estado <code>'on'</code>, um <code>'-'</code> (hífen) denota um estado <code>'off'</code> e um <code>'_'</code> (underline) denota o comprimento do estado <code>'on'</code>.</p> + +<pre class="notranslate"><code>[ + { on: true, length: 1 }, + { on: false, length: 1 }, + { on: true, length: 2 } + ... +]</code></pre> + +<p><strong>Código:</strong></p> + +<pre class="notranslate"><code>var str = 'x-x_'; +var retArr = []; +str.replace(/(x_*)|(-)/g, function(match, p1, p2) { + if (p1) { retArr.push({ on: true, length: p1.length }); } + if (p2) { retArr.push({ on: false, length: 1 }); } +}); + +console.log(retArr);</code></pre> + +<p>O código gera um array de 3 objetos como desejado sem usar uma função de loop.</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.</td> + <td>Standard</td> + <td>Defnição inicial. Implementado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.11', 'String.prototype.replace')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.replace', 'String.prototype.replace')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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> + +<h3 id="Notas_específicas_do_Firefox">Notas específicas do Firefox</h3> + +<ul> + <li>Começando no Gecko 27 {{geckoRelease(27)}}, esse método foi ajustado conforme as especificações do ECMAScript. Quando <code>replace()</code> é chamado com uma expressão regular global, a propriedade {{jsxref("RegExp.lastIndex")}} (se especificada) será resetada para <code>0</code> ({{bug(501739)}}).</li> +</ul> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/replaceall/index.html b/files/pt-br/web/javascript/reference/global_objects/string/replaceall/index.html new file mode 100644 index 0000000000..c545573689 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/replaceall/index.html @@ -0,0 +1,178 @@ +--- +title: String.prototype.replaceAll() +slug: Web/JavaScript/Reference/Global_Objects/String/replaceAll +tags: + - Expressão Regular + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - regex + - replaceAll() +translation_of: Web/JavaScript/Reference/Global_Objects/String/replaceAll +--- +<div>{{JSRef}}</div> + +<div class="blockIndicator note"><strong>Nota</strong>: A partir de Agosto de 2020, o método <code>replaceAll()</code> continuará sendo suportado pelo Firefox, mas não pelo Chrome. Ele estará disponível somente no Chrome 85.</div> + +<p>O método <code>replaceAll()</code> retorna uma nova string com todas as ocorrências de um padrão substituídas por uma substituição. O padrão pode ser uma string ou uma {{jsxref ("RegExp")}}, e a substituição pode ser uma string ou uma função a ser chamada para cada ocorrência.<br> + <br> + A <em>string</em> original é mantida sem modificação.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-replaceall.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate">const newStr = <var>str</var>.replaceAll(<var>regexp</var>|<var>substr</var>, <var>newSubstr</var>|<var>function</var>) +</pre> + +<div class="blockIndicator note"> +<p><strong>Nota</strong>: quando usar uma `<var>regexp</var>`, você deve colocar o sinalizador (flag) global "<code>g</code>". Do contrário, será retornado um <code>TypeError</code>: "<em>replaceAll must be called with a global RegExp</em>".</p> +</div> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code><var>regexp</var></code> (padrão)</dt> + <dd>Uma {{jsxref ("RegExp")}} ou literal com o sinalizador (flag) global. As ocorrências serão substituídas por <em><code>newSubstr</code></em> ou pelo valor retornado da <em><code>function</code></em> (função) especificada.</dd> + <dt><code><var>substr</var></code><var> </var>(padrão)</dt> + <dd>Uma {{jsxref ("String")}} que deve ser substituída por <code>newSubstr</code>. É tratada como uma string literal e não é interpretada como uma expressão regular (<em><code>RegExp</code></em>).</dd> + <dt><code><var>newSubstr</var></code> (substituição)</dt> + <dd>É a {{jsxref("String")}} que substitui a <code><em>substring</em></code> especificada pelo parâmetro <code><var>regexp</var></code> ou <code><var>substr</var></code>. Um número de padrões especiais para substituição são suportados; veja a seção "<a href="#">Especificando uma string como parâmetro</a>" abaixo.</dd> + <dt><code><var>function</var></code> (substituição)</dt> + <dd>Uma função a ser chamada retornando a nova <code><em>substring</em></code> a ser usada para substituir as correspondências para a dada <code><var>regexp</var></code> ou <code><var>substr</var></code>. Os argumentos passados para esta função são descritos na seção "<a href="#Especificando uma função como parâmetro">Especificando uma função como parâmetro</a>" abaixo.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Um nova <em>string</em>, com todas as ocorrências de um padrão substituído por uma substituição.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Este método não muda o objeto {{jsxref("String")}} original. Ele simplesmente retorna uma nova <em>string</em>.</p> + +<h3 id="Especificando_uma_string_como_parâmetro"><a id="Especificando uma string como parâmetro" name="Especificando uma string como parâmetro">Especificando uma string como parâmetro</a></h3> + +<p>A <em>string</em> de substituição pode incluir os seguimentos padrões especiais de substituição:</p> + +<table class="standard-table"> + <thead> + <tr> + <th class="header" scope="col">Padrão</th> + <th class="header" scope="col">Insere</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>$$</code></td> + <td>Insere um <code>"$"</code>.</td> + </tr> + <tr> + <td><code>$&</code></td> + <td>Insere a <em>substring</em> correspondente.</td> + </tr> + <tr> + <td><code>$`</code></td> + <td>Insere a porção da <em>string</em> que precede a <em>substring</em> correspondente.</td> + </tr> + <tr> + <td><code>$'</code></td> + <td>Insere a porção da <em>string</em> que sucede a <em>substring</em> correspondente.</td> + </tr> + <tr> + <td><code>$<var>n</var></code></td> + <td>Onde <code><var>n</var></code> é um inteiro positivo menor que 100, insere a <var><code>n</code></var>-ésima <em>string</em> submatch entre parênteses, desde que o primeiro argumento seja um objeto {{jsxref("RegExp")}}. Note que isso é indexado começando pelo <code>1</code>.</td> + </tr> + </tbody> +</table> + +<h3 id="Especificando_uma_função_como_parâmetro"><a id="Especificando uma função como parâmetro" name="Especificando uma função como parâmetro">Especificando uma função como parâmetro</a></h3> + +<p>Você pode especificar uma função como segundo parâmetro. Neste caso, a função será chamada depois da ocorrência ter sido encontrada. O resultado da função (valor de retorno) será usado como uma <em>string</em> para substituição. (<strong>Nota:</strong> Os padrões especiais mencionados acima <strong>não se aplicam </strong>neste caso.)</p> + +<p>Note que a função será chamada múltiplas vezes para cada ocorrência a ser substituída se a expressão regular no primeiro parâmetro for global "<code>g</code>".</p> + +<p>Os argumentos para funções são os seguintes:</p> + +<table class="standard-table"> + <thead> + <tr> + <th class="header" scope="col">Nome possível</th> + <th class="header" scope="col">Valor fornecido</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>match</code></td> + <td>A <em>substring</em> correspondida. (Corresponde ao <code>$&</code> acima.)</td> + </tr> + <tr> + <td><code>p1, p2, ...</code></td> + <td>A <var>n</var>-ésima string encontrada por um grupo de captura entre parênteses, desde que o primeiro argumento para <code>replace()</code> seja uma {{jsxref("RegExp")}}. (Corresponde a <code>$1</code>, <code>$2</code>, etc. acima.) Por exemplo, se <code>/(\a+)(\b+)/</code>, foi dado, <code>p1</code> é a correspondência para <code>\a+</code>, e <code>p2</code> para <code>\b+</code>.</td> + </tr> + <tr> + <td><code>offset</code></td> + <td>O deslocamento da substring correspondente em toda a string sendo examinada. (Por exemplo, se toda a string for '<code>abcd</code>' e a substring correspondente for '<code>bc</code>', este argumento será <code>1</code>.)</td> + </tr> + <tr> + <td><code>string</code></td> + <td>A <em>string</em> inteira será examinada.</td> + </tr> + </tbody> +</table> + +<p>(O número exato de argumentos depende se o primeiro argumento é um objeto {{jsxref("RegExp")}} — e, se então, quantas <em>subcorrespondências </em>entre parênteses são especificadas.)</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_replaceAll">Usando <code>replaceAll()</code></h3> + +<pre class="brush: js notranslate">'aabbcc'.replaceAll('b', '.'); +// 'aa..cc'</pre> + +<h3 id="RegExp_sem_flag_g_retorando_erro">RegExp sem flag "g" retorando erro</h3> + +<p>Ao usar uma expressão regular para realizar uma pesquisa, a mesma deve conter a flag global "<code>g</code>". O código abaixo não irá funcionar:</p> + +<pre class="brush: js; example-bad notranslate">'aabbcc'.replaceAll(/b/, '.'); +TypeError: replaceAll must be called with a global RegExp +</pre> + +<p>Já o código abaixo vai funcionar:</p> + +<pre class="brush: js; example-good notranslate">'aabbcc'.replaceAll(/b/g, '.'); +"aa..cc" +</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-string.prototype.replaceall', 'String.prototype.replaceAll')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.replaceAll")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.replace", "String.prototype.replace()")}}</li> + <li>{{jsxref("String.prototype.match", "String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec", "RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test", "RegExp.prototype.test()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/search/index.html b/files/pt-br/web/javascript/reference/global_objects/string/search/index.html new file mode 100644 index 0000000000..0abfec19df --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/search/index.html @@ -0,0 +1,153 @@ +--- +title: String.prototype.search() +slug: Web/JavaScript/Reference/Global_Objects/String/search +tags: + - Expressões Regulares + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - search() +translation_of: Web/JavaScript/Reference/Global_Objects/String/search +--- +<div>{{JSRef}}</div> + +<p>O método <code>search()</code> realiza uma busca por uma ocorrência entre uma expressão regular e uma {{jsxref ("String")}}.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.search(<var>regexp</var>)</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>regexp</code></dt> + <dd>Um objeto contendo uma expressão regular. Se um objeto <code>obj</code> for passado como parâmetro e não for do tipo <code>RegExp</code>, ele será implicitamente convertido para uma {{jsxref("RegExp")}} através da instrução <code>new RegExp(obj)</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O índice na string do primeiro trecho que satisfaz a expressão regular. Do contrário, o valor <code>-1</code><strong> </strong>será retornado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Quando você quiser saber se um padrão foi encontrado, e também saber seu índice dentro de uma string, use <code>search()</code>. (Se você deseja apenas saber se ele existe, use o método semelhante {{jsxref ("RegExp.prototype.test()", "test()")}} do protótipo RegExp, que retorna um booleano.)</p> + +<p>Para obter mais informações (mas em compensação a execução se torna mais lenta), use {{jsxref ("String.prototype.match()", "match()")}} (semelhante ao método {{jsxref ("RegExp.prototype.exec()" , "exec()")}} da RegExp).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_search">Usando <code>search()</code></h3> + +<p>O exemplo a seguir pesquisa uma string com dois objetos <code>regexp</code> diferentes para mostrar uma pesquisa bem-sucedida (valor positivo) vs. uma pesquisa mal-sucedida (-1).</p> + +<pre class="brush: js notranslate">let str = "hey JudE" +let re = /[A-Z]/g +let reDot = /[.]/g +console.log(str.search(re)) // retorna 4, que é o índice da primeira letra maiúscula "J" +console.log(str.search(reDot)) // retorna -1 pois não conseguiu encontrar o ponto "."</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário(s)</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.12', 'String.prototype.search')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.search', 'String.prototype.search')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.search', 'String.prototype.search')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<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>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> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</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> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notas_específicas_para_a_engine_Gecko">Notas específicas para a engine Gecko</h2> + +<ul> + <li>Antes do {{Gecko("8.0")}}, <code>search()</code> foi implementado incorretamente. Quando era chamadosem parâmetros ou com {{jsxref("undefined")}}, ele buscava pela string '<code>undefined</code>', ao invés de buscar pela string vazia. Isto foi corrigido. Agora <code>'a'.search()</code> e <code>'a'.search(undefined)</code> corretamente retornam 0.</li> + <li>A partir do Gecko 39 {{geckoRelease(39)}}, o argumento não-padrão <code>flags</code> está defasado (deprecated) e dispara um aviso no console ({{bug(1142351)}}).</li> + <li>A partir do Gecko 47 {{geckoRelease(47)}}, o argumento não-padrão <code>flags</code> não é mais suportado em builds <em>non-release</em> e em breve será removido inteiramente ({{bug(1245801)}}).</li> + <li>A partir do Gecko 49 {{geckoRelease(49)}}, o argumento não-padrão <code>flags</code> não é mais suportado ({{bug(1108382)}}).</li> +</ul> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/slice/index.html b/files/pt-br/web/javascript/reference/global_objects/string/slice/index.html new file mode 100644 index 0000000000..74d6819506 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/slice/index.html @@ -0,0 +1,233 @@ +--- +title: String.prototype.slice() +slug: Web/JavaScript/Reference/Global_Objects/String/slice +tags: + - JavaScript + - Prototipo + - Reference + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/slice +--- +<div>{{JSRef("Global_Objects", "String")}}</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>O método <code>slice()</code> extrai uma parte de uma string e a retorna como uma nova string, sem modificar a string original.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.slice(<var>startIndex</var>[, <var>endIndex</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Paramêtros</h3> + +<dl> + <dt><code>startIndex</code></dt> + <dd>É o índice, de base zero, onde se inicia a extração. Se for um número negativo, será o mesmo que executar <em><code>str.length + startIndex</code></em> (por exemplo, se <em><code>startIndex</code></em> for <em><code>-3</code></em>, será o mesmo que executar <em><code>str.length - 3</code></em>).</dd> + <dd> + <pre class="brush: js notranslate">const nome = 'Ricardo'; +console.log(nome.slice(-3)); // retorna 'rdo'</pre> + </dd> +</dl> + +<dl> + <dd>Se <em><code>startIndex</code></em> for maior ou igual a <code><var>str</var><em>.length</em></code>, uma string vazia será retornada.</dd> + <dd> + <pre class="brush: js notranslate">const nome = 'Ricardo'; +console.log(nome.slice(7)); // retorna <empty string>' +</pre> + </dd> + <dt><code>endIndex</code></dt> + <dd>Opcional. É o índice, de base zero, onde termina a extração. O caractere que possuir este índice não será incluso.</dd> + <dd>Se omitido ou possuir valor de <em><code>undefined</code></em>, ou for maior que <code><var>str</var><em>.length</em></code>, <em><code>slice()</code></em> extrairá até o fim da string.</dd> + <dd> + <pre class="brush: js notranslate">const nome = 'Ricardo'; + +// omitindo fimSlice +console.log(nome.slice(0)); // retorna 'Ricardo' + +// undefined fimSlice +let i; // variável criada sem atribuir valor +console.log(nome.slice(0, i)); // retorna 'Ricardo' + +// passando número maior que o tamanho da string +console.log(nome.slice(0, 7)); // retorna 'Ricardo'</pre> + </dd> + <dd>Se negativo, é o mesmo que executar <em><code>str.length + endIndex</code></em> onde <em><code>str.length</code></em> é o tamanho da string (por exemplo, se <em><code>endIndex</code></em> é <em><code>-3</code></em>, é como executar <code><em>str.length - 3</em></code>).</dd> +</dl> + +<dl> + <dd> + <pre class="brush: js notranslate">const nome = 'Ricardo';<strong> +</strong>console.log(nome.slice(0, -3)); // retorna 'Rica' +</pre> + </dd> + <dd>Se for um valor diferente de indefinido e, ao mesmo tempo não for um número, uma string vazia será retornada</dd> + <dd> + <pre class="brush: js notranslate">const nome = 'Ricardo'; +let i; // variável criada sem valor atribuído + +// passando algum valor ≠ de undefined e ≠ de número +console.log(nome.slice(0, NaN)); // retorna <empty string> +console.log(nome.slice(2, false)); // retorna <empty string> +console.log(nome.slice(5, i)); // retorna 'Ricardo' +</pre> + + <p>Se <code><var>endIndex</var></code> for definido e <code><var>startIndex</var></code> for negativo, <code><var>endIndex</var></code> deve ser negativo também, do contrário uma string vazia é retornada.</p> + + <pre class="brush: js notranslate">const nome = 'Ricardo'; +console.log(nome.slice(-3, 0)); // retorna <empty string> +</pre> + + <p>Caso <code><var>endIndex</var></code> seja definido e <code><var>startIndex</var></code> e <code><var>endIndex</var></code> sejam ambos positivos ou negativos, <code><var>endIndex</var></code> deve ser maior que <code><var>startIndex</var></code>, do contrário uma string vazia é retornada.</p> + + <pre class="brush: js notranslate">const nome = 'Ricado'; +console.log(nome.slice(-1, -3)); // retorna <empty string> +console.log(nome.slice(3, 1)); // retorna <empty string> +</pre> + </dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>Uma nova string contento a porção extraída da string.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p><em><code>slice()</code></em> extrai um texto de uma string e retorna uma nova string. Modificações realizadas no texto de uma string não afetam a outra string.</p> + +<p><em><code>slice()</code></em> extrai até, mas não inclue <em><code>endIndex</code>.</em><br> + <br> + <code><em>str.slice(1, 4)</em></code> extrai a partir do segundo caractere até o quarto caractere (ou seja, os caracteres de índices <em><code>1</code></em>, <em><code>2</code></em>, e <em><code>3</code></em>).</p> + +<p>Por exemplo, <em><code>str.slice(2, -1)</code></em> extrai a partir do terceiro carácter até o penúltimo caractere da string.</p> + +<pre class="brush: js notranslate">const nome = 'Ricardo'; +console.log(nome.slice(2, -1)); // retorna 'card' +</pre> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Using_slice_to_create_a_new_string" name="Example:_Using_slice_to_create_a_new_string">Exemplo: Usando <code>slice()</code> para criar uma nova string</h3> + +<p>O exemplo a seguir usa <em><code>slice()</code></em> para criar uma nova string.</p> + +<pre class="brush: js notranslate">var str1 = 'A manhã está sobre nós', // o tamanho de str1 é 22 + str2 = str1.slice(3, 10), + str3 = str1.slice(2, -2), + str4 = str1.slice(13), + str5 = str1.slice(22); +console.log(str2); // retorna 'anhã es' +console.log(str3); // retorna 'manhã está sobre n' +console.log(str4); // retorna 'sobre nós' +console.log(str5); // retorna <empty string> +</pre> + +<h3 id="Example_Using_slice_with_negative_indexes" name="Example:_Using_slice_with_negative_indexes">Exemplo: Usando <code>slice()</code> com índices negativos.</h3> + +<p>O exemplo a seguir usa o <em><code>slice()</code></em> com índices negativos.</p> + +<pre class="brush: js notranslate">var str = 'A manhã está sobre nós'; +str.slice(-3); // retorna 'nós' +str.slice(-3, -1); // retorna 'nó' +str.slice(0, -1); // retorna 'A manhã está sobre nó' +</pre> + +<p>O exemplo abaixo percorre o índice no sentido anti-horário (de trás para frente) até chegar ao índice 11 da string, que será o início. Logo após, percorre o índice da string no sentido horário até chegar ao índice 16 da string, que será o fim.</p> + +<pre class="brush: js notranslate">console.log(str.slice(-11, 16)) // retorna "á sob"</pre> + +<p>O exemplo abaixo percorre o índice no sentido horário até chegar ao índice 10 da string, que será o início. Logo após, percorre o índice da string no sentido anti-horário até chegar ao índice 7 da string, que será o fim.</p> + +<pre class="brush: js notranslate">console.log(str.slice(10, -7)) // retorna "tá so"</pre> + +<p>O exemplo abaixo percorre o índice no sentido anti-horário até chegar ao índice 5 da string, que será o início. Logo após, percorre o índice da string novamente no sentido anti-horário até chegar ao índice 1 da string, que será o fim.</p> + +<pre class="brush: js notranslate">console.log(str.slice(-5, -1)) // retorna "e nó"</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 3rd Edition.</td> + <td>Standard</td> + <td>Initial definition. Implemented in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.13', 'String.prototype.slice')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.slice', 'String.prototype.slice')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_entre_Browsers">Compatibilidade entre Browsers</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("String.prototype.substr()")}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> + <li>{{jsxref("Array.prototype.slice()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/small/index.html b/files/pt-br/web/javascript/reference/global_objects/string/small/index.html new file mode 100644 index 0000000000..2983a5c9fc --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/small/index.html @@ -0,0 +1,72 @@ +--- +title: String.prototype.small() +slug: Web/JavaScript/Reference/Global_Objects/String/small +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - small() +translation_of: Web/JavaScript/Reference/Global_Objects/String/small +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>small()</code> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/small" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/small"><small></a></code> que faz com que uma string seja exibida em uma fonte pequena.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.small()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/small" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/small"><small></a></code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>small()</code> cria uma string dentro de uma tag <code><small></code>: <code>"<small>str</small>"</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_small">Usando <code>small()</code></h3> + +<p>O exemplo a seguir usa métodos do objeto global String para alterar o tamanho da string:</p> + +<pre class="brush: js notranslate">var worldString = 'Olá, mundo'; + +console.log(worldString.small()); // <small>Olá, mundo</small> +console.log(worldString.big()); // <big>Olá, mundo</big> +console.log(worldString.fontsize(7)); // <font size="7">Olá, mundo</fontsize> +</pre> + +<p>Com o objeto <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style">element.style</a> você pode pegar o atributo de estilo do elemento e manipulá-lo de forma mais genérica, por exemplo:</p> + +<pre class="brush: js notranslate">document.getElementById('#oIdDoElemento').style.fontSize = '0.7em'; +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.small', 'String.prototype.small')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.small")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> + <li>{{jsxref("String.prototype.big()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/split/index.html b/files/pt-br/web/javascript/reference/global_objects/string/split/index.html new file mode 100644 index 0000000000..80b42f28e0 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/split/index.html @@ -0,0 +1,282 @@ +--- +title: String.prototype.split() +slug: Web/JavaScript/Reference/Global_Objects/String/split +tags: + - Expressões Regulares + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - split() +translation_of: Web/JavaScript/Reference/Global_Objects/String/split +--- +<div>{{JSRef}}</div> + +<p>O método <code>split()</code> divide uma {{jsxref ("String")}} em uma lista ordenada de substrings, coloca essas substrings em um array e retorna o array. A divisão é feita procurando um padrão, onde o padrão é fornecido como o primeiro parâmetro na chamada do método.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.split([separator[, limit]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<ul> + <li>O caso mais simples é quando o separador é apenas um único caractere que será usado para dividir a string. Por exemplo, uma string contendo valores separados por tabulação (TSV) poderia ser analisada passando um caractere de tabulação como separador, como este: myString.split ("\ t").</li> + <li>Se o <code>separator</code> contiver vários caracteres, toda a sequência de caracteres deve ser encontrada para ser dividida.</li> + <li>Se o <code>separator</code> for omitido ou não aparecer dentro da <code>str</code>, o array retornará um elemento consistindo em toda a string.</li> + <li>Se o <code>separator</code> aparecer no início (ou no final) da string, ele ainda terá o efeito de divisão. O resultado é uma string vazia (ou seja, <code>str.length == 0</code>), que aparece na primeira (ou última) posição do array retornado.</li> + <li>Se o <code>separator</code> for uma string vazia (""), <code>str</code> será convertido em um array contendo cada um de seus caracteres em UTF-16.</li> +</ul> + +<dl> + <dt><code>separator</code></dt> + <dd>Opcional. Especifica o caractere, ou conjunto de caracteres, a ser usado para separar a string. O separador pode ser uma string ou uma {{jsxref("Global_Objects/RegExp", "expressão regular", "", 1)}}.</dd> +</dl> + +<div class="blockIndicator warning"> +<p><strong>Aviso:</strong> Quando uma string vazia (<code>""</code>) é usada como separador, a string não é dividida por caracteres percebidos pelo usuário (<a href="https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries" title="https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries">grapheme clusters</a>) ou caracteres Unicode (pontos de código), mas por unidades de código UTF-16. Isso destrói <a href="http://unicode.org/faq/utf_bom.html#utf16-2" title="http://unicode.org/faq/utf_bom.html#utf16-2">pares substitutos</a>. Consulte “<a href="https://stackoverflow.com/questions/4547609/how-do-you-get-a-string-to-a-character-array-in-javascript/34717402#34717402" title="https://stackoverflow.com/questions/4547609/how-do-you-get-a-string-to-a-character-array-in-javascript/34717402#34717402">Como você transforma uma string em um array de caracteres em JavaScript?” no StackOverflow</a>.</p> +</div> + +<dl> + <dt><code>limite</code></dt> + <dd> + <p>Opcional. Um número inteiro não negativo especificando um limite no número de divisões a serem encontradas. O método <code>split()</code> ainda dividirá em cada ocorrência do separador, até que o número de itens divididos corresponda ao limite ou que a string fique aquém do separador.</p> + + <ul> + <li>O array pode conter menos entradas do que o <code>limit</code> se o final da string for alcançado antes que o limite seja atingido.</li> + <li>Se o <code>limit</code> for <code>0</code>, <code>[]</code> será retornado.</li> + </ul> + </dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um array de strings divididos em cada ponto onde o separador ocorre na string informada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Quando encontrado, o caractere designado como o <code>separator</code> é removido da string e as substrings são retornadas em um array. Se o <code>separator</code> não for encontrado ou for omitido, o array irá conter um elemento consistindo da string inteira. Se o <code>separator</code> for uma string vazia, <code>str</code> será convertida em um array de caracteres.</p> + +<p>Se o separador for uma expressão regular que contenha parênteses de captura, cada vez que o <code>separator</code> for encontrado, os resultados (incluindo qualquer resultado <code>undefined</code>) dos parênteses de captura serão emendados ao array de saída. Entretanto, nem todos os navegadores possuem suporte a isso.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_split">Usando <code>split()</code></h3> + +<p>Quando a string está vazia, o <code>split()</code> irá retornar um array contendo uma string vazia ao invés de um array vazio. Se a string e o separador forem ambos strings vazias, um array vazio será retornado.</p> + +<pre class="brush: js notranslate">const myString = '' +const splits = myString.split() + +console.log(splits); + +// retorna [""]</pre> + +<p>O exemplo a seguir define uma função que divide uma string em um array de strings usando o separador especificado. Depois de dividir a string, a função exibe mensagens indicando a string original (antes da divisão), o separador usado, o número de elementos no array e os elementos individuais do array.</p> + +<pre class="brush: js notranslate">function splitString(stringToSplit, separator) { + var arrayOfStrings = stringToSplit.split(separator); + + console.log('A string original é: "' + stringToSplit + '"'); + console.log('O separador é: "' + separator + '"'); + console.log('O array tem ' + arrayOfStrings.length + ' elementos: ' + arrayOfStrings.join(' / ')); +} + +var tempestString = 'Oh brave new world that has such people in it.'; +var monthString = 'Jan,Fev,Mar,Abr,Mai,Jun,Jul,Ago,Set,Out,Nov,Dez'; + +var space = ' '; +var comma = ','; + +splitString(tempestString, space); +splitString(tempestString); +splitString(monthString, comma); +</pre> + +<p>Esse exemplo produz a saída a seguir:</p> + +<pre class="notranslate">A string original é: "Oh brave new world that has such people in it." +O separador é: " " +O array possui 10 elementos: Oh / brave / new / world / that / has / such / people / in / it. + +A string original é: "Oh brave new world that has such people in it." +O separador é: "undefined" +O array possui 1 elementos: Oh brave new world that has such people in it. + +A string original é: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec" +O separador é: "," +O array possui 12 elementos: Jan / Feb / Mar / Apr / May / Jun / Jul / Aug / Sep / Oct / Nov / Dec +</pre> + +<h3 id="Removendo_espaços_de_uma_string">Removendo espaços de uma string</h3> + +<p>No exemplo a seguir, <code>split()</code> procura por 0 ou mais espaços seguidos por um ponto e vírgula seguido por 0 ou mais espaços e, quando encontrar, remove os espaços e os pontos e vírgulas da string. <code>nameList</code> é o array retornado como resultado do <code>split()</code>.</p> + +<pre class="brush: js notranslate">var names = 'Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand '; + +console.log(names); + +var re = /\s*;\s*/; +var nameList = names.split(re); + +console.log(nameList); +</pre> + +<p>O retorno do código acima são duas linhas. A primeira linha registra a string original e a segunda linha registra o array resultante.</p> + +<pre class="notranslate">Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand +[ "Harry Trump", "Fred Barney", "Helen Rigby", "Bill Abel", "Chris Hand " ] +</pre> + +<h3 id="Retornando_um_número_limitado_de_divisões">Retornando um número limitado de divisões</h3> + +<p>No exemplo a seguir, o <code>split()</code> procura por 0 ou mais espaços em uma string e retorna as 3 primeiras divisões que encontrar.</p> + +<pre class="brush: js notranslate">var myString = 'Hello World. How are you doing?'; +var splits = myString.split(' ', 3); + +console.log(splits); +</pre> + +<p>O script exibirá o texto a seguir:</p> + +<pre class="notranslate">["Hello", "World.", "How"] +</pre> + +<h3 id="Parênteses_de_Captura">Parênteses de Captura</h3> + +<p>Se o <code>separator</code> contém parênteses de captura, os resultados correspondentes são retornados no array.</p> + +<pre class="brush: js notranslate">var myString = 'Hello 1 word. Sentence number 2.'; +var splits = myString.split(/(\d)/); + +console.log(splits); +</pre> + +<p>O script exibirá o texto a seguir:</p> + +<pre class="notranslate">[ "Hello ", "1", " word. Sentence number ", "2", "." ] +</pre> + +<div class="blockIndicator note"> +<p><strong>Nota: </strong><code>\d</code> corresponde à classe de caracteres para dígitos entre 0 e 9.</p> +</div> + +<h3 id="Revertendo_uma_String_usando_split">Revertendo uma String usando <code>split()</code></h3> + +<div class="blockIndicator warning"> +<p>Esta não é a mlehor maneira de reverter uma string:</p> + +<pre class="brush: js example-bad notranslate">const str = 'asdfghjkl' +const strReverse = str.split('').reverse().join('') +// 'lkjhgfdsa' + +// split() retorna um array onde os métodos +// reverse() e join() podem ser aplicados</pre> + +<p>Não funciona se a string contém <code>grapheme clusters</code>, mesmo ao usar uma divisão compatível com Unicode. (Use, por exemplo, <a href="https://github.com/mathiasbynens/esrever" title="https://github.com/mathiasbynens/esrever">esrever</a> no lugar.)</p> + +<pre class="brush: js example-bad notranslate">const str = 'résumé' +const strReverse = str.split(/(?:)/u).reverse().join('') +// retorna "́emuśer"</pre> + +<p><strong>Bonus:</strong> use o operador {{jsxref("Operators/Comparison_Operators", "===", "#Identity_strict_equality_(===)")}} para testar se a string original era um palíndromo.</p> +</div> + + + +<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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.14', 'String.prototype.split')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.split', 'String.prototype.split')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.split', 'String.prototype.split')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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>{{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>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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="sect1"></h2> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("Array.prototype.join()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/startswith/index.html b/files/pt-br/web/javascript/reference/global_objects/string/startswith/index.html new file mode 100644 index 0000000000..899b331458 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/startswith/index.html @@ -0,0 +1,96 @@ +--- +title: String.prototype.startsWith() +slug: Web/JavaScript/Reference/Global_Objects/String/startsWith +tags: + - Começa com + - ECMAScript6 + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - startsWith() +translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>startsWith()</code></strong> determina se uma string começa com os caracteres especificados, retornando <code>true</code> ou <code>false</code>.</p> + +<p>{{EmbedInteractiveExample("pages/js/string-startswith.html")}}</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.startsWith(<var>searchString</var>[, <var>position</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><em><code>searchString</code></em></dt> + <dd>Os caracteres a serem procurados a partir do início dessa string.</dd> + <dt><em><code>position</code></em></dt> + <dd>Opcional. A posição nessa string na qual se inicia a busca pela <em><code>searchString</code></em>. O valor padrão é <code>0</code>.</dd> + <dt> + <h3 id="Valor_retornado">Valor retornado</h3> + </dt> +</dl> + +<p><strong><code>true</code></strong> se os caracteres fornecidos forem encontrados no início da string. Se não, <strong><code>false</code></strong>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Esse método permite determinar se uma string começa ou não com outra string. Esse método é case-sensitive (difere maiúsculas de minúsculas, e vice-versa).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_startsWith">Usando <code>startsWith()</code></h3> + +<pre class="brush: js notranslate">//startswith +let str = 'Ser ou não ser, eis a questão.'; + +console.log(str.startsWith('Ser')) // true +console.log(str.startsWith('não ser')) // false +console.log(str.startsWith('não ser', 7)) // true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Este método foi adicionaldo à especificação ECMAScript 2015 e pode ainda não estar disponível em todas as implementações do JavaScript. No entanto, você pode usar o polyfill <code>String.prototype.startsWith()</code> adicionando o seguinte código:</p> + +<pre class="notranslate">if (!String.prototype.startsWith) { + Object.defineProperty(String.prototype, 'startsWith', { + value: function(search, rawPos) { + var pos = rawPos > 0 ? rawPos|0 : 0; + return this.substring(pos, pos + search.length) === search; + } + }); +}</pre> + +<p>Um polyfill mais robusto (totalmente conforme com a especificação ES2015), mas com menor desempenho e compacto está disponível <a href="https://github.com/mathiasbynens/String.prototype.startsWith">no GitHub por Mathias Bynens</a>.</p> + +<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-string.prototype.startswith', 'String.prototype.startsWith')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{Compat("javascript.builtins.String.startsWith")}}</div> + +<div id="compat-mobile"></div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.endsWith()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/strike/index.html b/files/pt-br/web/javascript/reference/global_objects/string/strike/index.html new file mode 100644 index 0000000000..004f93b675 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/strike/index.html @@ -0,0 +1,68 @@ +--- +title: String.prototype.strike() +slug: Web/JavaScript/Reference/Global_Objects/String/strike +tags: + - Descontinuado + - JavaScript + - Prototipo + - String + - metodo + - strike() +translation_of: Web/JavaScript/Reference/Global_Objects/String/strike +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>strike()</code> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/strike" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/strike"><strike></a></code> que faz com que uma string seja exibida com o texto riscado.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.strike()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/strike" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/strike"><strike></a></code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>strike()</code> cria uma string dentro uma tag <code><strike></code>: "<code><strike>str</strike></code>".</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_strike">Usando <code>strike()</code></h3> + +<p>O exemplo a seguir usa métodos do objeto global String para alterar a formatação da string:</p> + +<pre class="brush: js notranslate">var worldString = 'Olá, mundo'; + +console.log(worldString.blink()); // <blink>Olá, mundo</blink> +console.log(worldString.bold()); // <b>Olá, mundo</b> +console.log(worldString.italics()); // <i>Olá, mundo</i> +console.log(worldString.strike()); // <strike>Olá, mundo</strike> +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.strike', 'String.prototype.strike')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.strike")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/sub/index.html b/files/pt-br/web/javascript/reference/global_objects/string/sub/index.html new file mode 100644 index 0000000000..69289bd133 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/sub/index.html @@ -0,0 +1,123 @@ +--- +title: String.prototype.sub() +slug: Web/JavaScript/Reference/Global_Objects/String/sub +tags: + - Descontinuado + - JavaScript + - Prototipo + - String + - metodo + - sub() +translation_of: Web/JavaScript/Reference/Global_Objects/String/sub +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>sub()</code> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sub" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sub"><sub></a></code> que faz com que uma string seja exibida como subscrito (texto pequeno).</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.sub()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sub" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sub"><sub></a></code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>sub()</code> cria uma string dentro de uma tag <code><sub></code>: <code>"<sub>str</sub>"</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_os_métodos_sub_e_sup">Usando os métodos <code>sub()</code> e <code>sup()</code></h3> + +<p>Os exemplos seguintes usam o métodos <code>sub()</code> e {{jsxref("String.prototype.sup()", "sup()")}} para formatar uma string:</p> + +<pre class="brush: js notranslate">var superText = 'superscript'; +var subText = 'subscript'; + +console.log('This is what a ' + superText.sup() + ' looks like.'); +// This is what a <sup>superscript</sup> looks like + +console.log('This is what a ' + subText.sub() + ' looks like.'); +// This is what a <sub>subscript</sub> looks like. +</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('ES6', '#sec-string.prototype.sub', 'String.prototype.sub')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.sub', 'String.prototype.sub')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("1.0")}}</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>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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.sup()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/substr/index.html b/files/pt-br/web/javascript/reference/global_objects/string/substr/index.html new file mode 100644 index 0000000000..c1e45beaef --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/substr/index.html @@ -0,0 +1,140 @@ +--- +title: String.prototype.substr() +slug: Web/JavaScript/Reference/Global_Objects/String/substr +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - substr() +translation_of: Web/JavaScript/Reference/Global_Objects/String/substr +--- +<div>{{JSRef}}</div> + +<p>O método <code>substr()</code> retorna uma parte da string, começando no índice especificado e estendendo-se por um determinado número de caracteres posteriormente.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-substr.html")}}</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.substr(<var>start</var>[, <var>length</var>])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>start</code></dt> + <dd>Local para começar a extrair os caracteres.</dd> + <dt><code>length</code></dt> + <dd>Opcional. O número de caracteres a serem extraídos.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Uma nova string contendo a seção extraída da string fornecida.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O <code>substr()</code> extrai caracteres de comprimento de uma <code>str</code>, contando a partir do índice inicial.</p> + +<ul> + <li>Se o <code>start</code> for um número positivo, o índice começa a contar no início da string. Seu valor é limitado ao tamanho da string (<code>str.length</code>).</li> + <li>Se o <code>start</code> for um número negativo, o índice começa a contar a partir do final da string. Seu valor é limitado ao tamanho da string (<code>-str.length</code>).</li> +</ul> + +<div class="blockIndicator note"> +<p><strong>Nota</strong>: No Microsoft JScript, valores negativos no argumento <code>start</code> não são considerados como referência ao final da string.</p> +</div> + +<ul> + <li>Se <code>length</code> for omitido, <code>substr()</code> extrairá caracteres até o final da string.</li> + <li>Se <code>length</code> for {{jsxref("undefined")}}, <code>substr()</code> extrai os caracteres até o final da string.</li> + <li>Se <code>length</code> for um número negativo, ele será tratado como <code>0</code>.</li> + <li>Para <code>start</code> e <code>length</code>, {{jsxref("NaN")}} é tratado como 0.</li> +</ul> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_substr">Usando <code>substr()</code></h3> + +<pre class="brush: js notranslate">var aString = 'Mozilla'; + +console.log(aString.substr(0, 1)); // 'M' +console.log(aString.substr(1, 0)); // '' +console.log(aString.substr(-1, 1)); // 'a' +console.log(aString.substr(1, -1)); // '' +console.log(aString.substr(-3)); // 'lla' +console.log(aString.substr(1)); // 'ozilla' +console.log(aString.substr(-20, 2)); // 'Mo' +console.log(aString.substr(20, 2)); // ''</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>JScript da Microsoft não suporta valores negativos para o índice de <code>start</code>. Se você deseja usar esse recurso, você pode usar o seguinte código de compatibilidade para evitar esse erro:</p> + +<pre class="brush: js notranslate">// only run when the substr() function is broken +if ('ab'.substr(-1) != 'b') { + /** + * Get the substring of a string + * @param {integer} start where to start the substring + * @param {integer} length how many characters to return + * @return {string} + */ + String.prototype.substr = function(substr) { + return function(start, length) { + // call the original method + return substr.call(this, + // did we get a negative start, calculate how much it is from the beginning of the string + // adjust the start parameter for negative value + start < 0 ? this.length + start : start, + length) + } + }(String.prototype.substr); +} +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Defined in the (informative) Compatibility Annex B. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.3', 'String.prototype.substr')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Defined in the (informative) Compatibility Annex B</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.substr")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.slice()")}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/substring/index.html b/files/pt-br/web/javascript/reference/global_objects/string/substring/index.html new file mode 100644 index 0000000000..c54108cb75 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/substring/index.html @@ -0,0 +1,229 @@ +--- +title: String.prototype.substring() +slug: Web/JavaScript/Reference/Global_Objects/String/substring +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - substring() +translation_of: Web/JavaScript/Reference/Global_Objects/String/substring +--- +<p>{{JSRef("Global_Objects", "String")}}</p> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <code>substring()</code> retorna a parte da string entre os índices inicial e final, ou até o final da string.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.substring(indexStart[, <var>indexEnd</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>indexStart</code></dt> + <dd>Um inteiro entre <code>0</code> e o comprimento da string (<code>str.length</code>), especificando a posição na string do primeiro caractere a ser incluído na substring retornada.</dd> + <dt><code>indexEnd</code></dt> + <dd>Opcional. Um inteiro entre <code>0</code> e o comprimento da string (<code>str.length</code>), especificando a posição na string do primeiro caractere a <strong>não</strong> ser mais incluído na substring retornada.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova string contendo a parte especificada da string fornecida.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p><code>substring()</code> extrai caracteres desde <code><em>indexStart</em></code> até, mas <strong>não</strong> <strong>incluindo</strong>, <code><em>indexEnd</em></code>. Em particular:</p> + +<ul> + <li>Se <code><em>indexStart</em></code> é igual a <code><em>indexEnd</em></code>, <code>substring()</code> retorna uma string vazia.</li> + <li>Se <code><em>indexEnd</em></code> for omitido, <code>substring()</code> extrai caracteres até o fim da string.</li> + <li>Se qualquer argumento for menor que <code>0</code> ou {{jsxref("NaN")}}, ele será tratado como <code>0</code>.</li> + <li>Se qualquer argumento for maior que <code>stringName.length</code>, ele será tratado como se fosse <code>stringName.length</code></li> +</ul> + +<p>Se <code>indexStart</code> for maior que <code>indexEnd</code>, então o efeito do <code>substring()</code> é como se os dois argumentos estivessem trocados, por exemplo, <code><em>str</em>.substring(1, 0) == <em>str</em>.substring(0, 1)</code>.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Using_substring" name="Example:_Using_substring">Usando <code>substring()</code></h3> + +<p>O seguinte exemplo usa <code>substring()</code> para mostrar caracteres da palavra 'Mozilla':</p> + +<pre class="brush:js notranslate">var anyString = "Mozilla"; + +// Mostra "Moz" +console.log(anyString.substring(0,3)); +console.log(anyString.substring(3,0)); + +// Mostra "lla" +console.log(anyString.substring(4,7)); +console.log(anyString.substring(7,4)); + +// Mostra "Mozill" +console.log(anyString.substring(0,6)); + +// Mostra "Mozilla" +console.log(anyString.substring(0,7)); +console.log(anyString.substring(0,10)); +</pre> + +<h3 id="Usando_substring_com_length">Usando <code>substring()</code> com <code>length</code></h3> + +<p>O exemplo a seguir usa o método <code>substring()</code> e a propriedade {{jsxref ("String.length", "length")}} para extrair os últimos caracteres de uma string específica. Este método pode ser mais fácil de lembrar, visto que você não precisa saber os índices inicial e final como faria nos exemplos acima.</p> + +<pre class="brush: js notranslate">// Mostra 'illa', os últimos 4 caracteres +let anyString = 'Mozilla' +let anyString4 = anyString.substring(anyString.length - 4) +console.log(anyString4); + +// Mostra 'zilla', os últimos 5 caracteres +let anyString = 'Mozilla' +let anyString5 = anyString.substring(anyString.length - 5) +console.log(anyString5);</pre> + +<h3 id="A_diferença_entre_substring_e_substr">A diferença entre <code>substring()</code> e <code>substr()</code></h3> + +<p>Há uma diferença sutil entre os métodos <code>substring()</code> e {{jsxref("String.substr", "substr()")}}, então você deve ter cuidado para não confundi-los.</p> + +<p>Os argumentos de <code>substring()</code> representam os índices inicial e final, enquanto os argumentos de <code>substr()</code> representam o índice inicial e o número de caracteres a serem incluídos na string retornada.</p> + +<p>Além disso, <code>substr()</code> é considerado um <strong>recurso legacy no ECMAScript </strong>e pode ser removido em versões futuras, portanto, é melhor evitar usá-lo, se possível.</p> + +<pre class="brush: js notranslate">let text = 'Mozilla' +console.log(text.substring(2,5)) // retorna "zil" +console.log(text.substr(2,3)) // retorna "zil"</pre> + +<h3 id="Diferenças_entre_substring_e_slice">Diferenças entre <code>substring()</code> e <code>slice()</code></h3> + +<p>Os métodos <code>substring()</code> e {{jsxref("String.slice", "slice()")}} são quase idênticos, mas existem algumas diferenças sutis entre os dois, especialmente na forma como os argumentos negativos são tratados.</p> + +<p>O método <code>substring()</code> troca seus dois argumentos se <code>indexStart</code> for maior que <code>indexEnd</code>, o que significa que uma string ainda será retornada. O método {{jsxref("String.slice", "slice()")}} retorna uma string vazia caso o mesmo ocorra.</p> + +<pre class="brush: js notranslate">let text = 'Mozilla' +console.log(text.substring(5, 2)) // retorna "zil" +console.log(text.slice(5, 2)) // retorna ""</pre> + +<p>Se um ou ambos os argumentos forem negativos ou <code>NaN</code>, o método <code>substring()</code> os tratará como se fossem <code>0</code>.</p> + +<pre class="brush: js notranslate">console.log(text.substring(-5, 2)) // retorna "Mo" +console.log(text.substring(-5, -2)) // retorna ""</pre> + +<p><code>slice()</code> também trata os argumentos <code>NaN</code> como <code>0</code>, mas quando recebe valores negativos, ele conta regressivamente a partir do final da string para encontrar os índices.</p> + +<pre class="brush: js notranslate">console.log(text.slice(-5, 2)) // retorna "" +console.log(text.slice(-5, -2)) // retorna "zil"</pre> + +<p>Veja a página {{jsxref("String.slice", "slice()")}} para mais exemplos com números negativos.</p> + +<h3 id="Example_Replacing_a_substring_within_a_string" name="Example:_Replacing_a_substring_within_a_string">Substituindo uma <code>substring()</code> com uma string</h3> + +<p>O seguinte exemplo substitui uma substring dentro de uma string. Ela irá substituir ambos caracteres e substrings individualmente. A função invocada na linha final do exemplo altera a string "<code style="font-style: normal;">Brave New World</code>" para "<code style="font-style: normal;">Brave New Web</code>".</p> + +<pre class="brush:js notranslate">function replaceString(oldS, newS, fullS) { +// Substitui oldS por newS na string fullS + for (var i = 0; i < fullS.length; i++) { + if (fullS.substring(i, i + oldS.length) == oldS) { + fullS = fullS.substring(0, i) + newS + fullS.substring(i + oldS.length, fullS.length); + } + } + return fullS; +} + +replaceString("World", "Web", "Brave New World");</pre> + +<p>Note que isto pode resultar em um loop infinito se <code>oldS</code> for um substring de <code>newS</code> -- por exemplo, se você tentou substituir "<code>World</code>" com "<code>OtherWorld</code>". O melhor método para substituir strings é o seguinte:</p> + +<pre class="brush:js notranslate">function replaceString(oldS, newS,fullS){ + return fullS.split(oldS).join(newS); +}</pre> + +<p>O código acima serve como um exemplo para operações com substring. Se você precisa substituir substrings, na maioria das vezes você vai querer usar <span style="line-height: 1.5em;">{{jsxref("String.prototype.replace()")}}.</span></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 1st Edition.</td> + <td>Standard</td> + <td>Implementado no JavaScript 1.0</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.15', 'String.prototype.substring')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.substring', 'String.prototype.substring')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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>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> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.substr()")}}</li> + <li>{{jsxref("String.prototype.slice()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/sup/index.html b/files/pt-br/web/javascript/reference/global_objects/string/sup/index.html new file mode 100644 index 0000000000..32bfbef1fd --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/sup/index.html @@ -0,0 +1,69 @@ +--- +title: String.prototype.sup() +slug: Web/JavaScript/Reference/Global_Objects/String/sup +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - sup() +translation_of: Web/JavaScript/Reference/Global_Objects/String/sup +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>sup()</code> cria um elemento HTML <code><a class="external external-icon" href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sup" rel="noopener" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sup"><sup></a></code> que faz com que uma string seja exibida como sobrescrito.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.sup()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <code><a class="external external-icon" href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sup" rel="noopener" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sup"><sup></a></code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>sup()</code> cria uma string dentro de uma tag <code><sup></code>: <code>"<sup>str</sup>"</code></p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_os_métodos_sub_e_sup">Usando os métodos <code>sub()</code> e <code>sup()</code></h3> + +<p>O exemplo a seguir usa os métodos {{jsxref("String.prototype.sub()", "sub()")}} e <code>sup()</code> para formatar uma string:</p> + +<pre class="brush: js notranslate">var superText = 'superscript'; +var supText = 'supscript'; + +console.log('This is what a ' + superText.sup() + ' looks like.'); +// "This is what a <sup>superscript</sup> looks like." + +console.log('This is what a ' + supText.sup() + ' looks like.'); +// "This is what a <sup>supscript</sup> looks like." +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.sup', 'String.prototype.sup')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.sup")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.sup()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tolocalelowercase/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tolocalelowercase/index.html new file mode 100644 index 0000000000..3867903c25 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/tolocalelowercase/index.html @@ -0,0 +1,92 @@ +--- +title: String.prototype.toLocaleLowerCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase +tags: + - Internacionalização + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - toLocaleLowerCase() +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase +--- +<div>{{JSRef}}</div> + +<p>O método <code>toLocaleLowerCase()</code> retorna o valor da string em minúsculas, de acordo com qualquer mapeamento de caixa de texto específico da localidade.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-tolocalelowercase.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.toLocaleLowerCase() +<var>str</var>.toLocaleLowerCase(locale) +<var>str</var>.toLocaleLowerCase([locale, locale, ...]) +</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>locale</code></dt> + <dd>Opcional. O parâmetro <code>locale</code> indica o local a ser usado para converter para minúsculas de acordo com qualquer mapeamento de caixa de texto específico da localidade. Se várias localidades forem fornecidas em um {{jsxref("Array")}}, a <a href="https://tc39.es/ecma402/#sec-bestavailablelocale" title="https://tc39.es/ecma402/#sec-bestavailablelocale">melhor localidade disponível</a> é usada. A localidade padrão é a localidade atual do ambiente do host.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova string que representa a string original convertida em minúsculas, de acordo com qualquer mapeamento da caixa de texto específico da localidade.</p> + +<h3 id="Exceções">Exceções</h3> + +<ul> + <li>Um {{jsxref("RangeError")}} (" invalid language tag: xx_yy ") é lançado se um argumento <code>locale</code> não for uma tag de idioma válido.</li> + <li>Um {{jsxref("TypeError")}} (" invalid element in locales argument ") é lançado se um elemento do array não for do tipo string.</li> +</ul> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>toLocaleLowerCase()</code> retorna o valor da string convertida em minúsculas de acordo com qualquer mapeamento da caixa de texto específico da localidade. <code>toLocaleLowerCase()</code> não afeta o valor da string original. Na maioria dos casos, ele produzirá o mesmo resultado que {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}, mas para alguns locais, como turco, cujos mapeamentos da caixa de texto não seguem o mapeamento padrão em Unicode, pode haver um resultado diferente.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toLocaleLowerCase">Usando <code>toLocaleLowerCase()</code></h3> + +<pre class="brush: js notranslate">'ALFABETO'.toLocaleLowerCase(); // 'alfabeto' + +'\u0130'.toLocaleLowerCase('tr') === 'i'; // true +'\u0130'.toLocaleLowerCase('en-US') === 'i'; // false + +let locales = ['tr', 'TR', 'tr-TR', 'tr-u-co-search', 'tr-x-turkish']; +'\u0130'.toLocaleLowerCase(locales) === 'i'; // true +</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-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sup-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.toLocaleLowerCase")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html new file mode 100644 index 0000000000..ff3f99e8e3 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html @@ -0,0 +1,95 @@ +--- +title: String.prototype.toLocaleUpperCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase +tags: + - Internacionalização + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - toLocaleUpperCase() +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase +--- +<div>{{JSRef}}</div> + +<p>O método <code>toLocaleUpperCase()</code> retorna o valor da string em maiúsculas, de acordo com qualquer mapeamento de caixa de texto específico da localidade.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-tolocaleuppercase.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.toLocaleUpperCase() +<var>str</var>.toLocaleUpperCase(locale) +<var>str</var>.toLocaleUpperCase([locale, locale, ...]) +</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>locale</code></dt> + <dd>Opcional. O parâmetro <code>locale</code> indica a localização a ser usada para converter para maiúsculas de acordo com qualquer mapeamento de caixa de texto específico da localidade. Se vários locais forem fornecidos em um {{jsxref("Array")}}, a <a href="https://tc39.es/ecma402/#sec-bestavailablelocale" title="https://tc39.es/ecma402/#sec-bestavailablelocale">melhor localidade disponível</a> é usada. A localidade padrão é a localidade atual do ambiente do host.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova string que representa a string original convertida em maiúsculas, de acordo com qualquer mapeamento de caixa de texto específico da localidade.</p> + +<h3 id="Exceções">Exceções</h3> + +<ul> + <li>Um {{jsxref("RangeError")}} ("invalid language tag: xx_yy") é lançado se um argumento <code>locale</code> não for uma tag de idioma válido.</li> + <li>Um {{jsxref("TypeError")}} ("invalid element in locales argument") é lançado se um elemento do array não for do tipo string.</li> +</ul> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>toLocaleUpperCase()</code> retorna o valor da string convertida em maiúsculas de acordo com qualquer mapeamento de caixa de texto específico da localidade. <code>toLocaleUpperCase()</code> não afeta o valor da string em si. Na maioria dos casos, ele produzirá o mesmo resultado que {{jsxref("String.prototype.toUpperCase()", "toUpperCase()")}}, mas para alguns locais, como turco, cujos mapeamentos de caixa de texto não seguem o mapeamento de caixa de texto padrão em Unicode, pode haver um resultado diferente.</p> + +<p>Observe também que a conversão não é necessariamente um mapeamento de caracteres 1:1, pois alguns caracteres podem resultar em dois (ou até mais) caracteres quando transformados em maiúsculas. Portanto, o comprimento da string resultante pode ser diferente do comprimento da string de entrada. Isso também implica que a conversão não é estável, então, por exemplo, o seguinte pode retornar <code>false</code>:<br> + <code>x.toLocaleLowerCase() === x.toLocaleUpperCase(). toLocaleLowerCase()</code></p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toLocaleUpperCase">Usando <code>toLocaleUpperCase()</code></h3> + +<pre class="brush: js notranslate">'alfabeto'.toLocaleUpperCase(); // 'ALFABETO' + +'Gesäß'.toLocaleUpperCase(); // 'GESÄSS' + +'i\u0307'.toLocaleUpperCase('lt-LT'); // 'I' + +let locales = ['lt', 'LT', 'lt-LT', 'lt-u-co-phonebk', 'lt-x-lietuva']; +'i\u0307'.toLocaleUpperCase(locales); // 'I'</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-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sup-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.toLocaleUpperCase")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tolowercase/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tolowercase/index.html new file mode 100644 index 0000000000..8883ff88fd --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/tolowercase/index.html @@ -0,0 +1,126 @@ +--- +title: String.prototype.toLowerCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - toLowerCase() +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toLowerCase()</code></strong> retorna o valor da string que foi chamada convertido para minúsculo.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.toLowerCase()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova string contendo o valor da string original convertido para minúsculo.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>toLowerCase()</code> retorna o valor da string original convertido para minúsculo. <code>toLowerCase()</code> não altera o valor da string original.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toLowerCase">Usando <code>toLowerCase()</code></h3> + +<pre class="brush: js notranslate">console.log('ALFABETO'.toLowerCase()); // 'alfabeto' +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementada no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.16', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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>{{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>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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tosource/index.html new file mode 100644 index 0000000000..a7f2bce0d5 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/tosource/index.html @@ -0,0 +1,102 @@ +--- +title: String.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/String/toSource +tags: + - JavaScript + - Non-standard + - Obsoleto + - Prototipo + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/toSource +--- +<div>{{JSRef}} {{obsolete_header}}</div> + +<p>O método <code>toSource()</code> retorna uma string que representa o código-fonte do objeto.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code>String.toSource() +<var>str</var>.toSource() +</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string que representa o código-fonte do objeto chamado.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Função_nativa">Função nativa</h3> + +<p>Para o objeto {{jsxref("String")}} , <code>toSource()</code> retorna a seguinte string (indicando que o código-fonte não está disponível):</p> + +<pre class="brush: js notranslate">function String() { + [native code] +} +</pre> + +<p>Ao chamar {{jsxref("String")}} ou string literais, <code>toSource()</code> retorna a string que representa o código-fonte.</p> + +<p>Esse método é usualmente invocado internamente pelo JavaScript e não explicitamente no código.</p> + +<h2 id="Especificação">Especificação</h2> + +<p>Não é parte de nenhum padrão.</p> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</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>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</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.prototype.toSource()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tostring/index.html new file mode 100644 index 0000000000..5b3a3fa1ce --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/tostring/index.html @@ -0,0 +1,125 @@ +--- +title: String.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/String/toString +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - toString() +translation_of: Web/JavaScript/Reference/Global_Objects/String/toString +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toString()</code></strong> retorna uma string representando o objeto especificado.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.toString()</code></pre> + +<h2 id="Descrição">Descrição</h2> + +<p>O objeto {{jsxref("String")}} substitui o método <code>toString()</code> do objeto {{jsxref("Object")}}. Ele não herda {{jsxref("Object.prototype.toString()")}}. Para objetos {{jsxref("String")}}, o método <code>toString()</code> retorna uma representação de string do objeto e é o mesmo que o método {{jsxref("String.prototype.valueOf()")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toString">Usando <code>toString()</code></h3> + +<p>O exemplo a seguir exibe o valor string de um objeto {{jsxref("String")}}:</p> + +<pre class="brush: js notranslate">var x = new String('Hello world'); + +console.log(x.toString()); // retorna 'Hello world' +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.2', 'String.prototype.toString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tostring', 'String.prototype.toString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.tostring', 'String.prototype.toString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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>{{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>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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> + <li>{{jsxref("String.prototype.valueOf()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/touppercase/index.html b/files/pt-br/web/javascript/reference/global_objects/string/touppercase/index.html new file mode 100644 index 0000000000..3a593fc9b8 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/touppercase/index.html @@ -0,0 +1,135 @@ +--- +title: String.prototype.toUpperCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +tags: + - Caixa alta + - JavaScript + - Letras maúsculas + - Método(2) + - Protótipo(2) + - Referência(2) + - String + - toUpperCase() +translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +--- +<div>{{JSRef}}</div> + +<p>O método <code>toUpperCase()</code> retorna o valor da string original convertido em letras maiúsculas.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.toUpperCase()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova string representando a string original convertida em maiúsculas.</p> + +<h3 id="Exceções">Exceções</h3> + +<dl> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Quando chamado em uma string contendo valor {{jsxref("null")}} ou {{jsxref("undefined")}}, por exemplo, <code>String.prototype.toUpperCase.call(undefined)</code>.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>toUpperCase()</code> retorna o valor da string convertido para letras maiúsculas. <code>toUpperCase()</code> não altera o valor da string original.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Uso_básico">Uso básico</h3> + +<pre class="brush: js notranslate">console.log('alfabeto'.toUpperCase()); // 'ALFABETO' +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.18', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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>{{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>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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/trim/index.html b/files/pt-br/web/javascript/reference/global_objects/string/trim/index.html new file mode 100644 index 0000000000..285cd76427 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/trim/index.html @@ -0,0 +1,137 @@ +--- +title: String.prototype.trim() +slug: Web/JavaScript/Reference/Global_Objects/String/Trim +tags: + - ECMAScript5 + - Prototipo + - Referencia + - Remover espaços + - String + - Texto + - metodo + - trim() +translation_of: Web/JavaScript/Reference/Global_Objects/String/Trim +--- +<div>{{JSRef}}</div> + +<div>O método <strong><code>trim()</code></strong> remove os espaços em branco (<a href="/pt-BR/docs/DOM/Referencia_do_DOM/Whitespace_in_the_DOM">whitespaces</a>) do início e/ou fim de um texto. É considerado espaço em branco (espaço, tabulação, espaço fixo/rígido, etc.) e todo sinal de fim de linha de texto (LF, CR, etc.).</div> + +<div></div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.trim()</code></pre> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>trim()</code> retorna o texto sem espaços em branco no início e/ou fim da string. O <code>trim()</code> não altera o valor da string original.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_trim">Usando <code>trim()</code></h3> + +<p>Os exemplos a seguir retornam o valor de <code>'foo'</code> sem espaços em branco:</p> + +<pre class="brush: js notranslate">//.trim() removendo whitespace de ambos os lados + +var str = ' foo '; +console.log(str.trim()); // retorna 'foo' + +// Outro exemplo de .trim() removendo whitespace de +// apenas um lado. + +var str= 'foo '; +console.log(str.trim()); // retorna 'foo' +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Executar o seguinte código antes antes de qualquer código irá criar o método <code>trim()</code> se o mesmo não estiver disponível nativamente.</p> + +<pre class="brush: js notranslate">if (!String.prototype.trim) { + String.prototype.trim = function () { + return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ''); + }; +} +</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.5.4.20', 'String.prototype.trim')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.8.1.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</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>{{CompatGeckoDesktop("1.9.1")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("10.5")}}</td> + <td>{{CompatSafari("5")}}</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> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</li> + <li>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/trimend/index.html b/files/pt-br/web/javascript/reference/global_objects/string/trimend/index.html new file mode 100644 index 0000000000..556e62d8c3 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/trimend/index.html @@ -0,0 +1,82 @@ +--- +title: String.prototype.trimEnd() +slug: Web/JavaScript/Reference/Global_Objects/String/trimEnd +tags: + - JavaScript + - Prototipo + - Referencia + - Remover espaços ao final da string + - String + - metodo + - trimEnd() +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimEnd +--- +<div>{{JSRef}}</div> + +<p>O método <code>trimEnd()</code> remove espaços do final de uma <em>string</em>. <code>trimRight()</code> é um apelido para este método.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-trimend.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.trimEnd(); +<var>str</var>.trimRight();</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova <em>string </em>representando a <em>string</em> original sem espaços ao seu final (direita).</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Os métodos <code>trimEnd()</code> / <code>trimRight()</code> retornam a <em>string</em> sem os espaços à direita dela. <code>trimEnd()</code> ou <code>trimRight()</code> não altera o valor da <em>string</em> original.</p> + +<h3 id="Aliasing"><em>Aliasing</em></h3> + +<p>Para consistência com funções como {{jsxref("String.prototype.padEnd")}} o nome padrão do método é <code>trimEnd</code>. Entretanto, por razões de compatibilidade na <em>web</em>, <code>trimRight</code> permanece como um apelido para <code>trimEnd</code>. Em alguns motores isso significa:</p> + +<pre class="brush: js notranslate">String.prototype.trimRight.name === "trimEnd";</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_trimEnd">Usando <code>trimEnd()</code></h3> + +<p>O exemplo a seguir mostra a <em>string</em> em caixa baixa <code>' foo'</code>:</p> + +<pre class="brush: js; highlight: [5] notranslate">var str = ' foo '; + +console.log(str.length); // retorna 8 + +str = str.trimEnd(); +console.log(str.length); // retorna 6 +console.log(str); // retorna ' foo' +</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-string.prototype.trimend', 'String.prototype.trimEnd')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.trimEnd")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.trim()")}}</li> + <li>{{jsxref("String.prototype.trimStart()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/trimstart/index.html b/files/pt-br/web/javascript/reference/global_objects/string/trimstart/index.html new file mode 100644 index 0000000000..c784bc670a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/trimstart/index.html @@ -0,0 +1,118 @@ +--- +title: String.prototype.trimStart() +slug: Web/JavaScript/Reference/Global_Objects/String/trimStart +tags: + - JavaScript + - Prototipo + - Referencia + - Remover espaços ao começo string + - String + - metodo + - trimStart() +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimStart +--- +<div>{{JSRef}}</div> + +<p>O método <code>trimStart()</code> remove espaços do começo de uma <em>string</em>. <code>trimLeft()</code> é um apelido para este método.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-trimstart.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.trimStart(); +<var>str</var>.trimLeft();</pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova <em>string</em> representando a <em>string</em> original sem os espaços no começo (fim à esquerda).</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Os métodos <code>trimStart()</code> / <code>trimLeft()</code> retornam a <em>string</em> sem os espaços no fim à esquerda. <code>trimLeft()</code> ou <code>trimStart()</code> não altera o valor da <em>string</em> original.</p> + +<h3 id="Aliasing"><em>Aliasing</em></h3> + +<p>Para consistência com funções como {{jsxref("String.prototype.padStart")}} o nome padrão do método é <code>trimStart</code>. Entretanto, por razões de compatibilidade na <em>web</em>, <code>trimLeft</code> permanece como um apelido para <code>trimStart</code>. Em alguns motores isso significa:</p> + +<pre class="brush: js notranslate">String.prototype.trimLeft.name === "trimStart";</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js; highlight: [5] notranslate">//https://github.com/FabioVergani/js-Polyfill_String-trimStart + +(function(w){ + var String=w.String, Proto=String.prototype; + + (function(o,p){ + if(p in o?o[p]?false:true:true){ + var r=/^\s+/; + o[p]=o.trimLeft||function(){ + return this.replace(r,'') + } + } + })(Proto,'trimStart'); + +})(window); + + +/* +ES6: +(w=>{ + const String=w.String, Proto=String.prototype; + + ((o,p)=>{ + if(p in o?o[p]?false:true:true){ + const r=/^\s+/; + o[p]=o.trimLeft||function(){ + return this.replace(r,'') + } + } + })(Proto,'trimStart'); + +})(window); +*/</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_trimStart">Usando <code>trimStart()</code></h3> + +<p>O seguinte exemplo mostra uma <em>string</em> em caixa baixa <code>'foo '</code>:</p> + +<pre class="brush: js; highlight: [5] notranslate">var str = ' foo '; + +console.log(str.length); // retorna 8 + +str = str.trimStart(); +console.log(str.length); // retorna 5 +console.log(str); // retorna 'foo ' +</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-string.prototype.trimstart', ' String.prototype.trimStart')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.trimStart")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.trim()")}}</li> + <li>{{jsxref("String.prototype.trimEnd()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/string/valueof/index.html b/files/pt-br/web/javascript/reference/global_objects/string/valueof/index.html new file mode 100644 index 0000000000..306a079a95 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/valueof/index.html @@ -0,0 +1,84 @@ +--- +title: String.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/String/valueOf +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - valueOf() +translation_of: Web/JavaScript/Reference/Global_Objects/String/valueOf +--- +<div>{{JSRef}}</div> + +<p>O método <code>valueOf()</code> retorna o valor primitivo de um objeto {{jsxref("String")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-valueof.html")}}</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.valueOf()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string representando o valor primitivo de um objeto {{jsxref("String")}}.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>valueOf()</code> do objeto {{jsxref("String")}} retorna o valor primitivo de um objeto {{jsxref("String")}} como um dado do tipo string. Esse valor é equivalente a {{jsxref("String.prototype.toString()")}}.</p> + +<p>Esse método é normalmente chamado internamente pelo JavaScript e não fica explícito no código.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_valueOf">Usando <code>valueOf()</code></h3> + +<pre class="brush: js notranslate">var x = new String('Olá, mundo'); +console.log(x.valueOf()); // retorna 'Olá, mundo' +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial implementada no JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.3', 'String.prototype.valueOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.valueof', 'String.prototype.valueOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.valueof', 'String.prototype.valueOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in 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> + +<p>{{Compat("javascript.builtins.String.valueOf")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.toString()")}}</li> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/asynciterator/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/asynciterator/index.html new file mode 100644 index 0000000000..0228a1dd81 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/asynciterator/index.html @@ -0,0 +1,75 @@ +--- +title: Symbol.asyncIterator +slug: Web/JavaScript/Reference/Global_Objects/Symbol/asyncIterator +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/asyncIterator +--- +<div>{{JSRef}}</div> + +<p>O <code><strong>Symbol.asyncIterator</strong></code> é um símbolo conhecido que especifica o padrão AsyncIterator para um objeto. Se essa propriedade é configurada em um objeto, é um iterável assíncrono e pode ser usado in um <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of">for await...of</a></code> loop.</p> + + + +<h2 id="Descrição">Descrição</h2> + +<p>O <code>Symbol.asyncIterator</code> é um símbolo built-in que é usado para um acessar o método <code>@@asyncIterator</code> de um objeto. Para que um objeto seja iterável assíncrono, ele deve ter uma chave <code>Symbol.asyncIterator</code>.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Iteráveis_assíncronos_definidos_pelo_usuário">Iteráveis assíncronos definidos pelo usuário</h3> + +<p>Você consegue definir seu próprio iterável assíncrono configurando a propriedade <code>[Symbol.asyncIterator]</code> em um objeto. </p> + +<pre class="brush: js notranslate">const myAsyncIterable = { + async* [Symbol.asyncIterator]() { + yield "hello"; + yield "async"; + yield "iteration!"; + } +}; + +(async () => { + for await (const x of myAsyncIterable) { + console.log(x); + // resultado esperado: + // "hello" + // "async" + // "iteration!" + } +})(); +</pre> + +<p>Quando criando uma API, lembre que iteráveis assíncronos são programados para representar algum iterável — como um fluxo de dados ou uma lista —, não para substituir completamente chamadas e eventos na maioria das situações.</p> + +<h3 id="Iteráveis_assíncronos">Iteráveis assíncronos</h3> + +<p>Não há atualmente objetos Javascript built-in que tenha a chave <code>[Symbol.asyncIterator]</code> configurada por padrão. Entretanto, a WHATWG Streams estão configurando para que o primeiro objeto built-in seja um iterável assíncrono, com a recente chegada do <code>[Symbol.asyncIterator]</code> nas especificações.</p> + +<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-symbol.asynciterator', 'Symbol.asyncIterator')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{compat("javascript.builtins.Symbol.asyncIterator")}}</p> + +<h2 id="Vejá_também">Vejá também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of">for await... of</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/description/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/description/index.html new file mode 100644 index 0000000000..207fc79fa9 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/description/index.html @@ -0,0 +1,61 @@ +--- +title: Symbol.prototype.description +slug: Web/JavaScript/Reference/Global_Objects/Symbol/description +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/description +--- +<div>{{JSRef}}</div> + +<p>A propriedade leitura somente <code><strong>description</strong></code> é uma string que retorna a descrição opcional de objetos {{JSxRef("Symbol")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/symbol-prototype-description.html")}}</div> + + + +<h2 id="Descrição">Descrição</h2> + +<p>{{JSxRef("Symbol")}} objetos podem ser criados com uma uma descrição opcional na qual podem ser usados para debbuging mas não para acessar o próprio símbolo. A <code>Symbol.prototype.description</code> propriedade pode ser usada para ler essa descrição. É diferente do <code>Symbol.prototype.toString()</code> pois não contém a string incluida "<code>Symbol()</code>". Veja os exemplos.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_descrição">Usando descrição</h3> + +<pre class="brush: js notranslate">Symbol('desc').toString(); // "Symbol(desc)" +Symbol('desc').description; // "desc" +Symbol('').description; // "" +Symbol().description; // undefined + +// símbolos conhecidos +Symbol.iterator.toString(); // "Symbol(Symbol.iterator)" +Symbol.iterator.description; // "Symbol.iterator" + +// símbolos globais +Symbol.for('foo').toString(); // "Symbol(foo)" +Symbol.for('foo').description; // "foo" + +</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-symbol.prototype.description", "get Symbol.prototype.description")}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Symbol.description")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{JSxRef("Symbol.prototype.toString()")}}</li> + <li>Polyfill: <a href="https://npmjs.com/symbol.prototype.description">https://npmjs.com/symbol.prototype.description</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/hasinstance/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/hasinstance/index.html new file mode 100644 index 0000000000..b40b57a3c4 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/hasinstance/index.html @@ -0,0 +1,114 @@ +--- +title: Symbol.hasInstance +slug: Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance +tags: + - Propriedade + - Referencia +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance +--- +<div>{{JSRef}}</div> + +<p>O symbol bem-conhecido <strong><code>Symbol.hasInstance</code></strong> é usado para determinar se um objeto construtor reconhece um objeto como de sua instância. O comportamento do operador {{jsxref("Operators/instanceof", "instanceof")}} pode ser customizado por este symbol.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Exemplos">Exemplos</h2> + +<p>Você pode implementar o comportamento customizado do seu <code>instanceof</code> deste jeito; por exemplo:</p> + +<pre class="brush: js">class MyArray { + static [Symbol.hasInstance](instance) { + return this.prototype.isPrototypeOf(instance) || + Array.isArray(instance); + } +} + +console.log([] instanceof MyArray); // true +console.log(new MyArray instanceof MyArray); // true +console.log(new Image instanceof MyArray); // false + +class MySubArray extends MyArray {} +console.log(new MySubArray instanceof MySubArray); // true +console.log(new MySubArray instanceof MyArray); // true +console.log(new MyArray instanceof MySubArray); // false</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-symbol.hasinstance', 'Symbol.hasInstance')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-symbol.hasinstance', 'Symbol.hasInstance')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os 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>{{CompatChrome(51)}}</td> + <td>{{ CompatGeckoDesktop(50) }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</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>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{ CompatGeckoMobile(50) }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Operators/instanceof", "instanceof")}}</li> + <li>{{jsxref("Global_Objects/Object/isPrototypeOf", "isPrototypeOf()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/index.html new file mode 100644 index 0000000000..f4414ffe16 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/index.html @@ -0,0 +1,301 @@ +--- +title: Símbolo +slug: Web/JavaScript/Reference/Global_Objects/Symbol +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol +--- +<div>{{JSRef("Global_Objects", "Symbol")}}</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>A função <code>Symbol()</code> retorna um valor do tipo <strong>símbolo (symbol)</strong>, tem propriedades estáticas que expõem vários membros dos objetos nativos, possuem métodos estáticos que expõem o registro de símbolos globais e se parecem com uma classe de objeto nativo, mas estão incompletos como construtor porque não suportam a sintaxe "<code>new Symbol()</code>" .</p> + +<p>Cada valor símbolo retornado de <code>Symbol()</code> é único. Um símbolo pode ser usado como o identificador para propriedades de objetos; esse é o único propósito do tipo de dado. Algumas explicações sobre propósito e uso podem ser encontradas {{Glossary("Symbol", "no verbete do glossário para Symbol")}}.</p> + +<p>O tipo de dado <strong>símbolo</strong> é um {{Glossary("Primitive", "tipo de dado primitivo")}}.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code>Symbol(<em>[descrição]</em>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parametros</h3> + +<dl> + <dt><code>descrição</code> {{optional_inline}}</dt> + <dd>String opcional. Uma descrição de símbolo no qual pode ser usado para debugar mas não para acessar o próprio símbolo.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Para criar um novo simbolo primitivo, simplesmente escreva <code>Symbol()</code> com uma string opçional para sua descrição:</p> + +<pre class="brush: js notranslate">var sym1 = Symbol(); +var sym2 = Symbol("foo"); +var sym3 = Symbol("foo"); +</pre> + +<p>O codigo acima cria três simbolos novos. Note que a função <strong><em>Symbol("foo")</em></strong> não faz a string <strong><em>"foo"</em></strong> ser um símbolo. Ela cria um novo simbolo a cada vez que é chamada:</p> + +<pre class="brush: js notranslate">Symbol("foo") === Symbol("foo"); // false</pre> + +<p>A sintaxe a seguir com o operador {{jsxref("Operators/new", "new")}} vai resultar em um {{jsxref("TypeError")}}:</p> + +<pre class="brush: js notranslate">var sym = new Symbol(); // TypeError +</pre> + +<p>Isso evita que os autores criem um objeto empacotador explícito de <code>Symbol</code> em vez de um novo valor de símbolo. O que pode surpreender, pois geralmente é possível criar objetos empacotadores explícitos em torno de tipos de dados primitivos (por exemplo, <code>new Boolean</code>, <code>new String</code> e <code>new Number</code>).</p> + +<p>Se você realmente quiser criar um objeto empacotador de <code>Symbol</code> , você pode usar a função <code>Object()</code>:</p> + +<pre class="brush: js notranslate">var sym = Symbol("foo"); +typeof sym; // "symbol" +var symObj = Object(sym); +typeof symObj; // "object" +</pre> + +<h3 id="Símbolos_compartilhados_no_registro_global_de_símbolo">Símbolos compartilhados no registro global de símbolo</h3> + +<p>A sintaxe acima usando a função <code>Symbol()</code> não criará um símbolo global que estará disponível em todo o seu código. Para criar símbolos disponíveis em vários arquivos em um escopo como se fosse global, use os métodos {{jsxref("Symbol.for()")}} e {{jsxref("Symbol.keyFor()")}} para definir e configurar símbolos no registro global de símbolo.</p> + +<h3 id="Encontrando_propriedades_de_símbolos_em_objetos">Encontrando propriedades de símbolos em objetos</h3> + +<p>O método {{jsxref("Object.getOwnPropertySymbols()")}} retorna um array de símbolos e permite que você encontre propriedades de símbolos em um determinado objeto. Observe que cada objeto é inicializado sem suas próprias propriedades de símbolo, de modo que este array estará vazio, a menos que você estabeleça propriedades de símbolo no objeto.</p> + +<h2 id="Properties" name="Properties">Propriedades</h2> + +<dl> + <dt><code>Symbol.length</code></dt> + <dd>Propriedade de tamanho cujo valor é 1.</dd> + <dt>{{jsxref("Symbol.prototype")}}</dt> + <dd>Representa o protótipo do <code>Symbol</code> construtor.</dd> +</dl> + +<h3 id="Símbolos_conhecidos">Símbolos conhecidos</h3> + +<p>Em adição para seus próprios símbolos, JavaScript possui alguns símbolos built-in que representa os comportamentos internos da linguagem que não foram revelados para os desenvolvedores no ECMAScript 5 e anterior. Esses símbolos podem ser acessados usando as seguintes propriedades:</p> + +<dl> + <dt>Symbol.hasInstance</dt> + <dd>Especificado como @@hasInstance. Um método que determina se um construtor de um objeto é reconhecido como a instancia de um objeto. Usado por {{jsxref("Operators/instanceof", "instanceof")}}.</dd> + <dt>Symbol.isConcatSpreadable</dt> + <dd>Especificado como @@isConcatSpreadable. Um valor Booleano indicando se um objeto deve ser adicionado como elemento de uma array. Usado por {{jsxref("Array.prototype.concat()")}}.</dd> + <dt>Symbol.isRegExp</dt> + <dd>Especificado como @@isRegExp. Um valor Booleano indicando se um objeto pode ser usado como uma expressão regular.</dd> + <dt>Symbol.iterator</dt> + <dd>Especificado como @@iterator. Um método retornando o iterador padrão para um objeto. Usado por <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of"><code>for...of</code></a>.</dd> + <dt>Symbol.toPrimitive</dt> + <dd>Especificado como @@toPrimitive. Um método convertendo um objeto para um valor primitivo .</dd> + <dt>Symbol.toStringTag</dt> + <dd>Especificado como @@toStringTag. Um valor string usado para descrição padrão de um objeto. Usado por {{jsxref("Object.prototype.toString()")}}</dd> + <dt>Symbol.unscopables</dt> + <dd>Especificado como @@unscopables. Uma Array com valores string que são valores propriedade. Esses são excluídos das ligações com o objeto associado.</dd> +</dl> + +<h2 id="Methods" name="Methods">Métodos</h2> + +<dl> + <dt>{{jsxref("Symbol.for()", "Symbol.for(key)")}}</dt> + <dd>Procura por símbolos existentes com as chaves dada e retorna as chaves se for encontradas. Caso contrário um novo símbolo vai ser criado no registro de símbolo global com essa chave.</dd> + <dt>{{jsxref("Symbol.keyFor", "Symbol.keyFor(sym)")}}</dt> + <dd>Retorna um símbolo compartilhado do registro global de símbolo para o símbolo dado.</dd> +</dl> + +<h2 id="Boolean_instances" name="Boolean_instances"><code>Symbol</code> protótipo</h2> + +<p>Todos os símbolos herdados de {{jsxref("Symbol.prototype")}}.</p> + +<h3 id="Propriedades">Propriedades</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Properties')}}</p> + +<h3 id="Métodos">Métodos</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Methods')}}</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Creating_Boolean_objects_with_an_initial_value_of_false" name="Creating_Boolean_objects_with_an_initial_value_of_false">Usando o <code>typeof</code> operador com símbolos</h3> + +<p>O {{jsxref("Operators/typeof", "typeof")}} operador pode ajudar a identificar os símbolos.</p> + +<pre class="brush: js notranslate">typeof Symbol() === 'symbol' +typeof Symbol('foo') === 'symbol' +typeof Symbol.iterator === 'symbol' +</pre> + +<h3 id="Conversões_de_tipos_de_símbolo">Conversões de tipos de símbolo</h3> + +<p>Algumas anotações quando trabalhando com conversão de tipo de símbolos.</p> + +<ul> + <li>Quando estiver tentando converter um símbolo para um número, um {{jsxref("TypeError")}} vai ser retornado.<br> + (e.g. <code>+sym</code> or <code>sym | 0</code>).</li> + <li>Quando usando operador de igualdade , <code>Object(sym) == sym</code> retorna <code>true.</code></li> + <li><code>Symbol("foo") + "bar" </code>lança um {{jsxref("TypeError")}} (não pode converter um símbolo para string). Isso previne você de silenciamente criar um novo nome de propriedade string a partir de um símbolo, por exemplo.</li> + <li>A <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#String_conversion">"safer" <code>String(sym)</code> conversion</a> funciona como uma chamada para {{jsxref("Symbol.prototype.toString()")}} com símbolos, mas note que uma <code>new String(sym)</code> vai ser lançada.</li> +</ul> + +<h3 id="Símbolos_e_for...in_iteração">Símbolos e <code>for...in</code> iteração</h3> + +<p>Símbolos não são visíveis em <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a> iterações. Além de , {{jsxref("Object.getOwnPropertyNames()")}} não retornará o objeto símbolo propriedade, entretante, você pode fazer uso do {{jsxref("Object.getOwnPropertySymbols()")}} para conseguir esses resultados.</p> + +<pre class="brush: js notranslate">var obj = {}; + +obj[Symbol("a")] = "a"; +obj[Symbol.for("b")] = "b"; +obj["c"] = "c"; +obj.d = "d"; + +for (var i in obj) { + console.log(i); // logs "c" and "d" +}</pre> + +<h3 id="Símbolos_e_JSON.stringify">Símbolos e <code>JSON.stringify()</code></h3> + +<p>Propriedade com chave de símbolo vão ser completamente ignoradas quando usando <code>JSON.stringify()</code>:</p> + +<pre class="brush: js notranslate">JSON.stringify({[Symbol("foo")]: "foo"}); +// '{}'</pre> + +<p>Para mais detalhes, veja {{jsxref("JSON.stringify()")}}.</p> + +<h3 id="Objeto_wrapper_de_símbolo_como_chave_de_propriedade">Objeto wrapper de símbolo como chave de propriedade</h3> + +<p>Quando um objeto wrapper de um símbolo é usado como uma chave de propriedade , esse objeto vai ser coerced para o seu símbolo wrapper:</p> + +<pre class="brush: js notranslate">var sym = Symbol("foo"); +var obj = {[sym]: 1}; +obj[sym]; // 1 +obj[Object(sym)]; // still 1 +</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-symbol-objects', 'Symbol')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</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>{{CompatChrome(38)}}</td> + <td>{{CompatGeckoDesktop("36.0")}}</td> + <td>{{ CompatNo() }}</td> + <td>25</td> + <td>{{ CompatNo() }}</td> + </tr> + <tr> + <td>Symbol.iterator (@@iterator)</td> + <td>{{CompatChrome(38)}}</td> + <td>{{CompatGeckoDesktop("36.0")}}</td> + <td>{{ CompatNo() }}</td> + <td>25</td> + <td>{{ CompatNo() }}</td> + </tr> + <tr> + <td>Symbol.unscopables (@@unscopables)</td> + <td>{{CompatChrome(38)}}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>25</td> + <td> + <div>{{ CompatNo() }}</div> + </td> + </tr> + <tr> + <td>Other well-known symbols</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</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>{{CompatChrome(38)}}</td> + <td>{{ CompatGeckoMobile("36.0") }}</td> + <td>{{ CompatNo() }}</td> + <td>25</td> + <td>{{ CompatNo() }}</td> + </tr> + <tr> + <td>Symbol.iterator (@@iterator)</td> + <td>{{ CompatNo() }}</td> + <td>{{CompatChrome(38)}}</td> + <td>{{ CompatGeckoMobile("36.0") }}</td> + <td>{{ CompatNo() }}</td> + <td>25</td> + <td>{{ CompatNo() }}</td> + </tr> + <tr> + <td> + <div>Symbol.unscopables (@@unscopables)</div> + </td> + <td>{{ CompatNo() }}</td> + <td>{{CompatChrome(38)}}</td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatNo() }}</td> + <td>25</td> + <td>{{ CompatNo() }}</td> + </tr> + <tr> + <td>Other well-known symbols</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Glossary/Symbol">Glossary: Symbol data type</a></li> + <li>{{jsxref("Operators/typeof", "typeof")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Data_structures">Data types and data structures</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/isconcatspreadable/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/isconcatspreadable/index.html new file mode 100644 index 0000000000..f969972692 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/isconcatspreadable/index.html @@ -0,0 +1,93 @@ +--- +title: Symbol.isConcatSpreadable +slug: Web/JavaScript/Reference/Global_Objects/Symbol/isConcatSpreadable +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/isConcatSpreadable +--- +<div>{{JSRef}}</div> + +<p>O <strong><code>Symbol.isConcatSpreadable</code></strong> é um símbolo conhecido que é usado para configurar se um objeto deve ser achatado para um elemento da array quando usado o método {{jsxref("Array.prototype.concat()")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/symbol-isconcatspreadable.html")}}</div> + + + +<h2 id="Descrição">Descrição</h2> + +<p>O <code>@@isConcatSpreadable</code> símbolo (<code>Symbol.isConcatSpreadable</code>) pode também ser definido como uma propriedade própria ou herdada e seu valor é um booleano. Ele consegue controlar o comportamento das arrays e objetos semelhantes a array:</p> + +<ul> + <li>For array objects, the default behavior is to spread (flatten) elements. <code>Symbol.isConcatSpreadable</code> can avoid flattening in these cases.</li> + <li>For array-like objects, the default behavior is no spreading or flattening. <code>Symbol.isConcatSpreadable</code> can force flattening in these cases.</li> +</ul> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Arrays">Arrays</h3> + +<p>Por padrão, o {{jsxref("Array.prototype.concat()")}} espalha (alinha) arrays no seus resultados:</p> + +<pre class="brush: js notranslate">let alpha = ['a', 'b', 'c'], +let numeric = [1, 2, 3] + +let alphaNumeric = alpha.concat(numeric) + +console.log(alphaNumeric) // Resultado: ['a', 'b', 'c', 1, 2, 3] +</pre> + +<p>Quando configurando o <code>Symbol.isConcatSpreadable</code> para <code>false</code>, o comportamento padrão dele:</p> + +<pre class="brush: js notranslate">let alpha = ['a', 'b', 'c'], +let numeric = [1, 2, 3] + +numeric[Symbol.isConcatSpreadable] = false +let alphaNumeric = alpha.concat(numeric) + +console.log(alphaNumeric) // Resultado: ['a', 'b', 'c', [1, 2, 3] ] +</pre> + +<h3 id="Objetos_de_array_semelhantes">Objetos de array semelhantes </h3> + +<p>Para objetos de array semelhantes, o padrão não é espalhado. <code>Symbol.isConcatSpreadable</code>precisa ser configurado para <code>true</code> para poder conseguir um a array alinhada:</p> + +<pre class="brush: js notranslate">let x = [1, 2, 3] + +let fakeArray = { + [Symbol.isConcatSpreadable]: true, + length: 2, + 0: 'hello', + 1: 'world' +} + +x.concat(fakeArray) // [1, 2, 3, "hello", "world"] +</pre> + +<div class="blockIndicator note"> +<p><strong>Note:</strong> A propriedade <code>length</code> é usada para controlar o número de propriedade dos objetos para ser adicionado. No exemplo acima, <code>length:2</code> indica que duas propriedades tem de ser adicionado.</p> +</div> + +<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-symbol.isconcatspreadable', 'Symbol.isconcatspreadable')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Symbol.isConcatSpreadable")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/iterator/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/iterator/index.html new file mode 100644 index 0000000000..99e910ce5b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/iterator/index.html @@ -0,0 +1,107 @@ +--- +title: Symbol.iterator +slug: Web/JavaScript/Reference/Global_Objects/Symbol/iterator +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/iterator +--- +<div>{{JSRef}}</div> + +<p>O símbolo conhecido <code><strong>Symbol.iterator</strong></code> especifíca o iterador padrão para um objeto. Usado por <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of"><code>for...of</code></a>.</p> + +<div>{{EmbedInteractiveExample("pages/js/symbol-iterator.html")}}</div> + + + +<h2 id="Descrição">Descrição</h2> + +<p>Sempre que um objeto precisa ser iterado (como um começo de um <code>for..of</code> loop), o método <code>@@iterator</code> é chamado sem argumentos, e o <strong>iterador</strong> retornado é usado para obter os valores para serem iterados.</p> + +<p>Alguns tipos built-in tem um comportamento padrão de iteração, enquanto outros tipos (assim como {{jsxref("Object")}}) não tem. O tipo built-in com um método <code>@@iterator</code> são:</p> + +<ul> + <li>{{jsxref("Array.@@iterator", "Array.prototype[@@iterator]()")}}</li> + <li>{{jsxref("TypedArray.@@iterator", "TypedArray.prototype[@@iterator]()")}}</li> + <li>{{jsxref("String.@@iterator", "String.prototype[@@iterator]()")}}</li> + <li>{{jsxref("Map.@@iterator", "Map.prototype[@@iterator]()")}}</li> + <li>{{jsxref("Set.@@iterator", "Set.prototype[@@iterator]()")}}</li> +</ul> + +<p>Veja também <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a> para mais informação.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Iteráveis_definidos_pelo_usuário">Iteráveis definidos pelo usuário</h3> + +<p>Podemos fazer nosso próprio iterável dessa forma:</p> + +<pre class="brush: js notranslate">var myIterable = {} +myIterable[Symbol.iterator] = function* () { + yield 1; + yield 2; + yield 3; +}; +[...myIterable] // [1, 2, 3] +</pre> + +<p>Ou iteráveis podem ser definidos diretamente dentro de uma classe ou um objeto usando <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer#Computed_property_names">computed property</a>:</p> + +<pre class="brush: js notranslate">class Foo { + *[Symbol.iterator] () { + yield 1; + yield 2; + yield 3; + } +} + +const someObj = { + *[Symbol.iterator] () { + yield 'a'; + yield 'b'; + } +} + +[...new Foo] // [ 1, 2, 3 ] +[...someObj] // [ 'a', 'b' ] +</pre> + +<h3 id="Iteráveis_não_bem_formados">Iteráveis não bem formados</h3> + +<p>Se um método <code>@@iterator</code> não retornar um objeto iterador, então é um iterável não bem formado. Usando dessa forma é resultará em uma excessão de tempo ou comportamentos com erros:</p> + +<pre class="brush: js notranslate">var nonWellFormedIterable = {} +nonWellFormedIterable[Symbol.iterator] = () => 1 +[...nonWellFormedIterable] // TypeError: [] is not a function +</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-symbol.iterator', 'Symbol.iterator')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Symbol.iterator")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a></li> + <li>{{jsxref("Array.@@iterator", "Array.prototype[@@iterator]()")}}</li> + <li>{{jsxref("TypedArray.@@iterator", "TypedArray.prototype[@@iterator]()")}}</li> + <li>{{jsxref("String.@@iterator", "String.prototype[@@iterator]()")}}</li> + <li>{{jsxref("Map.@@iterator", "Map.prototype[@@iterator]()")}}</li> + <li>{{jsxref("Set.@@iterator", "Set.prototype[@@iterator]()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/match/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/match/index.html new file mode 100644 index 0000000000..34773830af --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/match/index.html @@ -0,0 +1,65 @@ +--- +title: Symbol.match +slug: Web/JavaScript/Reference/Global_Objects/Symbol/match +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/match +--- +<div>{{JSRef}}</div> + +<p>O símbolo <code><strong>Symbol.match</strong></code> é conhecido por especificar a compatibilidade de uam expressão regular contra uma string. Essa função é chamada pelo método {{jsxref("String.prototype.match()")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/symbol-match.html")}}</div> + + + +<h2 id="Descrição">Descrição</h2> + +<p>Essa função também é usada para identificar se um objeto tem o comportamento de uma expressão regular. Por exemplo, os métodos {{jsxref("String.prototype.startsWith()")}}, {{jsxref("String.prototype.endsWith()")}} e {{jsxref("String.prototype.includes()")}}, verificar se o primeiro agumento é uma expressão regular e irá lançar um {{jsxref("TypeError")}} se eles forém. Agora, se o símbolo <code>match</code> é configurado para <code>false</code> (ou um valor <a href="/en-US/docs/Glossary/Falsy">Falsy</a> ), ele indica que o objeto não tem intensão de ser usado como um ojbeto de expressão regular </p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Desativando_a_verificação_isRegExp">Desativando a verificação <code>isRegExp</code> </h3> + +<p>O seguinte código vai lançar um {{jsxref("TypeError")}}:</p> + +<pre class="brush: js notranslate">'/bar/'.startsWith(/bar/); + +// Lança um TypeError, como /bar/ é uma expressão regular +// não Symbol.match não é modificado.</pre> + +<p>Entretanto, se você configurar <code>Symbol.match</code> para <code>false</code>, a verificação <code>isRegExp </code>(que usa a propriedade <code>match</code> ) que o objeto não é uma expressão regular. O método <code>startsWith</code> e <code>endsWith</code> não vão lançar um <code>TypeError</code> como consequência.</p> + +<pre class="brush: js notranslate">var re = /foo/; +re[Symbol.match] = false; +'/foo/'.startsWith(re); // true +'/baz/'.endsWith(re); // false +</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-symbol.match', 'Symbol.match')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Symbol.match")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Symbol.replace")}}</li> + <li>{{jsxref("Symbol.search")}}</li> + <li>{{jsxref("Symbol.split")}}</li> + <li>{{jsxref("RegExp.@@match", "RegExp.prototype[@@match]()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/matchall/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/matchall/index.html new file mode 100644 index 0000000000..7874646623 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/matchall/index.html @@ -0,0 +1,72 @@ +--- +title: Symbol.matchAll +slug: Web/JavaScript/Reference/Global_Objects/Symbol/matchAll +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/matchAll +--- +<div>{{JSRef}}</div> + +<p>O símbolo <code><strong>Symbol.matchAll</strong></code> é conhecido por retornar um iterador, que produz conrrespondências de uma expressão regular com uma string. Essa função é usada pelo método {{jsxref("String.prototype.matchAll()")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/symbol-matchall.html","shorter")}}</div> + + + +<h2 id="Descrição">Descrição</h2> + +<div> +<p>Esse símbolo é usado pelo {{jsxref("String.prototype.matchAll()")}} e especificado no {{jsxref("RegExp.@@matchAll", "RegExp.prototype[@@matchAll]()")}}. Os próximos dois exemplos retornam o mesmo resultado:</p> + +<pre class="brush: js notranslate">'abc'.matchAll(/a/); + +/a/[Symbol.matchAll]('abc');</pre> + +<p>Esse método existe para costumizar o comportamento conrrespondente com as subclasses {{jsxref("RegExp")}}.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> +</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usuando_Symbol.matchAll">Usuando Symbol.matchAll</h3> + +<pre class="brush: js notranslate">let re = /[0-9]+/g; +let str = '2016-01-02|2019-03-07'; + +const numbers = { + *[Symbol.matchAll] (str) { + for (const n of str.matchAll(/[0-9]+/g)) + yield n[0]; + } +}; + +console.log(Array.from(str.matchAll(numbers))); +// Array ["2016", "01", "02", "2019", "03", "07"] +</pre> + +<p>Veja {{jsxref("String.prototype.matchAll()")}} e {{jsxref("RegExp.@@matchAll", "RegExp.prototype[@@matchAll]()")}} para mais exemplos.</p> + +<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-symbol.matchall', 'Symbol.matchAll')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Symbol.matchAll")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.matchAll()")}}</li> + <li>{{jsxref("RegExp.@@matchAll", "RegExp.prototype[@@matchAll]()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/replace/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/replace/index.html new file mode 100644 index 0000000000..f69a22537d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/replace/index.html @@ -0,0 +1,60 @@ +--- +title: Symbol.replace +slug: Web/JavaScript/Reference/Global_Objects/Symbol/replace +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/replace +--- +<div>{{JSRef}}</div> + +<p>O símbolo <code><strong>Symbol.replace</strong></code> é conhecido por especificar o método que substitui as substrings conrrespondentes de uma string. Essa função é chamada pelo método {{jsxref("String.prototype.replace()")}}.</p> + +<p>Para mais informações, veja {{jsxref("RegExp.@@replace", "RegExp.prototype[@@replace]()")}} e {{jsxref("String.prototype.replace()")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/symbol-replace.html")}}</div> + + + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_Symbol.replace">Usando Symbol.replace</h3> + +<pre class="brush: js notranslate">class CustomReplacer { + constructor(value) { + this.value = value; + } + [Symbol.replace](string) { + return string.replace(this.value, '#!@?'); + } +} + +console.log('football'.replace(new CustomReplacer('foo'))); +// resultado esperado: "#!@?tball"</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-symbol.replace', 'Symbol.replace')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Symbol.replace")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Symbol.match")}}</li> + <li>{{jsxref("Symbol.search")}}</li> + <li>{{jsxref("Symbol.split")}}</li> + <li>{{jsxref("RegExp.@@replace", "RegExp.prototype[@@replace]()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/search/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/search/index.html new file mode 100644 index 0000000000..e2f71e3438 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/search/index.html @@ -0,0 +1,60 @@ +--- +title: Symbol.search +slug: Web/JavaScript/Reference/Global_Objects/Symbol/search +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/search +--- +<div>{{JSRef}}</div> + +<p>O símbolo <code><strong>Symbol.search</strong></code> é um método conhecido por retornar o índice com uma string que corresponde a expressão regular. Essa função é chamada pelo método {{jsxref("String.prototype.search()")}}.</p> + +<p>Para mais informação, veja {{jsxref("RegExp.@@search", "RegExp.prototype[@@search]()")}} e {{jsxref("String.prototype.search()")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/symbol-search.html")}}</div> + + + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Pesquisa_de_string_personalizada">Pesquisa de string personalizada</h3> + +<pre class="brush: js notranslate">class caseInsensitiveSearch { + constructor(value) { + this.value = value.toLowerCase(); + } + [Symbol.search](string) { + return string.toLowerCase().indexOf(this.value); + } +} + +console.log('foobar'.search(new caseInsensitiveSearch('BaR'))); +// resultado esperado: 3</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-symbol.search', 'Symbol.search')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Symbol.search")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Symbol.match")}}</li> + <li>{{jsxref("Symbol.replace")}}</li> + <li>{{jsxref("Symbol.split")}}</li> + <li>{{jsxref("RegExp.@@search", "RegExp.prototype[@@search]()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/species/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/species/index.html new file mode 100644 index 0000000000..fcf636c175 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/species/index.html @@ -0,0 +1,63 @@ +--- +title: Symbol.species +slug: Web/JavaScript/Reference/Global_Objects/Symbol/species +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/species +--- +<div>{{JSRef}}</div> + +<p>O símbolo <code><strong>Symbol.species</strong></code> especifica uma propriedade valor-função que a função construtora usa para criar objetos derivados.</p> + +<div>{{EmbedInteractiveExample("pages/js/symbol-species.html")}}</div> + + + +<h2 id="Descrição">Descrição</h2> + +<p>A propriedade acessora de espécies permite que subclasses substituam o construtor padrão para objetos.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_espécies">Usando espécies</h3> + +<p>Você pode querer que retorne objetos {{jsxref("Array")}} em sua class derivada de array <code>MyArray</code>. Por exemplo, quando usar métodos tais como {{jsxref("Array.map", "map()")}} que retorna o construtor padrão, você quer que esses métodos retornem um objeto <code>Array</code> pai, em vez do objeto <code>MyArray</code>. Esses símbolos espécies permitem que você fala isso:</p> + +<pre class="brush: js notranslate">class MyArray extends Array { + // Substitui espécies para a Array pai construtora + static get [Symbol.species]() { return Array; } +} +let a = new MyArray(1,2,3); +let mapped = a.map(x => x * x); + +console.log(mapped instanceof MyArray); // false +console.log(mapped instanceof Array); // true +</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-symbol.species', 'Symbol.species')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Symbol.species")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Map.@@species", "Map[@@species]")}}</li> + <li>{{jsxref("Set.@@species", "Set[@@species]")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/split/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/split/index.html new file mode 100644 index 0000000000..c6b9e13fd3 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/split/index.html @@ -0,0 +1,60 @@ +--- +title: Symbol.split +slug: Web/JavaScript/Reference/Global_Objects/Symbol/split +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/split +--- +<div>{{JSRef}}</div> + +<p>O <code><strong>Symbol.split</strong></code> é um símbolo conhecido que especifica o método que divide uma string nos índices correspondentes a uma expressão regular. Essa função é chamada pelo método {{jsxref("String.prototype.split()")}}.</p> + +<p>Para mais informações, veja {{jsxref("RegExp.@@split", "RegExp.prototype[@@split]()")}} e {{jsxref("String.prototype.split()")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/symbol-split.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> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Divisão_reversa_personalizada">Divisão reversa personalizada</h3> + +<pre class="brush: js notranslate">class ReverseSplit { + [Symbol.split](string) { + const array = string.split(' '); + return array.reverse(); + } +} + +console.log('Another one bites the dust'.split(new ReverseSplit())); +// resultado esperado: [ "dust", "the", "bites", "one", "Another" ]</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-symbol.split', 'Symbol.split')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Symbol.split")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Symbol.match")}}</li> + <li>{{jsxref("Symbol.replace")}}</li> + <li>{{jsxref("Symbol.search")}}</li> + <li>{{jsxref("RegExp.@@split", "RegExp.prototype[@@split]()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/toprimitive/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/toprimitive/index.html new file mode 100644 index 0000000000..97734f23e2 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/toprimitive/index.html @@ -0,0 +1,75 @@ +--- +title: Symbol.toPrimitive +slug: Web/JavaScript/Reference/Global_Objects/Symbol/toPrimitive +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/toPrimitive +--- +<div>{{JSRef}}</div> + +<p>O <code><strong>Symbol.toPrimitive</strong></code> é um símbolo que específica uma propriedade com valor função que é chamada para converter um ojbeto para um valor primitivo correspondente. </p> + +<div>{{EmbedInteractiveExample("pages/js/symbol-toprimitive.html")}}</div> + + + +<h2 id="Descrição">Descrição</h2> + +<p>Com a ajuda da propriedade <strong><code>Symbol.toPrimitive</code></strong> (usada como uma função valor), um objeto pode ser convertido para um valor primitivo. a função é chamada com um argumento string <strong><code>hint</code></strong>, que espcífica o tipo de preferência do resultado do valor primitivo. O argumento <strong><code>hint</code></strong> pode ser um <code>"<em>number</em>"</code>, <code>"<em>string</em>"</code>, e <code>"<em>default</em>"</code>.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Modificando_valores_primitivos_convertendo_para_um_objeto">Modificando valores primitivos convertendo para um objeto</h3> + +<p>O exemplo a seguir descreve que a propriedade <strong><code>Symbol.toPrimitive</code></strong> pode ser modificar o valor primitivo convertendo para um objeto.</p> + +<pre class="brush: js notranslate">// Um objeto sem propriedade Symbol.toPrimitive. +var obj1 = {}; +console.log(+obj1); // NaN +console.log(`${obj1}`); // "[object Object]" +console.log(obj1 + ''); // "[object Object]" + +// Um objeto com propriedade Symbol.toPrimitive +var obj2 = { + [Symbol.toPrimitive](hint) { + if (hint == 'number') { + return 10; + } + if (hint == 'string') { + return 'hello'; + } + return true; + } +}; +console.log(+obj2); // 10 -- dica é "number" +console.log(`${obj2}`); // "hello" -- dica é "string" +console.log(obj2 + ''); // "true" -- dica é "default" +</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-symbol.toprimitive', 'Symbol.toPrimitive')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Symbol.toPrimitive")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date.@@toPrimitive", "Date.prototype[@@toPrimitive]")}}</li> + <li>{{jsxref("Symbol.@@toPrimitive", "Symbol.prototype[@@toPrimitive]")}}</li> + <li>{{jsxref("Object.prototype.toString()")}}</li> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/tostringtag/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/tostringtag/index.html new file mode 100644 index 0000000000..1418ff89c0 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/tostringtag/index.html @@ -0,0 +1,92 @@ +--- +title: Symbol.toStringTag +slug: Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag +--- +<div>{{JSRef}}</div> + +<p>O símbolo <strong><code>Symbol.toStringTag</code></strong> é uma propriedade com valor string que é usada para a criação de uma descrição de string de um objeto padrão. É acessado internalmente pelo método {{jsxref("Object.prototype.toString()")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/symbol-tostringtag.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> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Tags_padrões">Tags padrões</h3> + +<pre class="brush: js notranslate">Object.prototype.toString.call('foo'); // "[object String]" +Object.prototype.toString.call([1, 2]); // "[object Array]" +Object.prototype.toString.call(3); // "[object Number]" +Object.prototype.toString.call(true); // "[object Boolean]" +Object.prototype.toString.call(undefined); // "[object Undefined]" +Object.prototype.toString.call(null); // "[object Null]" +// ... e mais +</pre> + +<h3 id="Símbolos_built-in_toStringTag">Símbolos built-in toStringTag </h3> + +<pre class="brush: js notranslate">Object.prototype.toString.call(new Map()); // "[object Map]" +Object.prototype.toString.call(function* () {}); // "[object GeneratorFunction]" +Object.prototype.toString.call(Promise.resolve()); // "[object Promise]" +// ... e mais +</pre> + +<h3 id="Classes_personalizadas_para_objeto_tag">Classes personalizadas para objeto tag</h3> + +<p>Quando cria sua própria classe, o JavaScript padroniza para "Object" tag:</p> + +<pre class="brush: js notranslate">class ValidatorClass {} + +Object.prototype.toString.call(new ValidatorClass()); // "[object Object]" +</pre> + +<h3 id="Tag_costumizada_com_toStringTag">Tag costumizada com toStringTag</h3> + +<p>Agora, com a ajuda do <code>toStringTag</code>, você é capaz de costumizar sua própria tag:</p> + +<pre class="brush: js notranslate">class ValidatorClass { + get [Symbol.toStringTag]() { + return 'Validator'; + } +} + +Object.prototype.toString.call(new ValidatorClass()); // "[object Validator]" +</pre> + +<h3 id="toStringTag_disponível_em_todos_os_objetos_protótipos_da_DOM">toStringTag disponível em todos os objetos protótipos da DOM </h3> + +<p>Devido a uma mudança nas especificações <a href="https://github.com/heycam/webidl/pull/357">WebIDL spec change</a> em meados de 2020, navegadores estão adicionando uma propriedade <code>Symbol.toStringTag</code> para todos os objetos protótipos da DOM . Por exemplo, para acessar a propriedade <code>Symbol.toStringTag</code> no {{domxref("HTMLButtonElement")}}:</p> + +<pre class="brush: js notranslate">let test = document.createElement('button'); +test.toString(); // Retorna [object HTMLButtonElement] +test[Symbol.toStringTag]; // Retona HTMLButtonElement</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-symbol.tostringtag', 'Symbol.toStringTag')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + + + +<p>{{Compat("javascript.builtins.Symbol.toStringTag")}}</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/symbol/unscopables/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/unscopables/index.html new file mode 100644 index 0000000000..f1f76c2177 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/symbol/unscopables/index.html @@ -0,0 +1,83 @@ +--- +title: Symbol.unscopables +slug: Web/JavaScript/Reference/Global_Objects/Symbol/unscopables +translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/unscopables +--- +<div>{{JSRef}}</div> + +<p>O símbolo <strong><code>Symbol.unscopables</code></strong> é usado para específicar um valor objeto cujo os nomes de propriedade próprio e herdados são excluídos das associações do ambiente <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code> o objeto associado. </p> + +<div>{{EmbedInteractiveExample("pages/js/symbol-unscopables.html")}}</div> + + + +<h2 id="Descrição">Descrição</h2> + +<p>O <code>@@unscopables</code> símbolo (<code>Symbol.unscopables</code>) pode ser definido em qualquer objeto para impedir que os nomes da propriedade sejam expostos como variavéis lexicais <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code> ligações de ambiente. Note que se usar o <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">Strict mode</a>, <code>with</code> as declarações não estão disponíveis e provavelmente não haverá necessidade desse símbolo.</p> + +<p>Configurando a propriedade para <code>true</code> em um objeto <code>unscopables</code> tornará ele não <em>unscopable</em> e portanto não irá apareer nas variavéis de escopo lexicais. Configurando uma propriedade para <code>false</code> o tornará <code>scopable</code> e portanto irá aparecer no escopo de variavéis lexicais.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Escopo_com_declarações">Escopo com declarações</h3> + +<p>O seguinte código funciona normalmente no ES5 e anteriores. Entretanto, no ECMAScript 2015 e superiores, o método {{jsxref("Array.prototype.keys()")}} foi introduzido. Isso significa que dentro do ambiente <code>with</code> "chaves" seria agora o método e não as variavéis. Isso qunado os símbolos <code>unscopable</code>s foram introduzidos. Uma confiração built-in <code>unscopables</code> é implementada como {{jsxref("Array.@@unscopables", "Array.prototype[@@unscopables]")}} para prevenir que alguns métodos de Array tenham escopo definido na desclaração <code>with</code>.</p> + +<pre class="brush: js notranslate">var keys = []; + +with (Array.prototype) { + keys.push('something'); +} + +Object.keys(Array.prototype[Symbol.unscopables]); +// ["copyWithin", "entries", "fill", "find", "findIndex", +// "includes", "keys", "values"] +</pre> + +<h3 id="Objetos_não_escopáveis">Objetos não escopáveis</h3> + +<p>Você também pode configurar <code>unscopables</code> para seu próprio objeot.</p> + +<pre class="brush: js notranslate">var obj = { + foo: 1, + bar: 2 +}; + +obj[Symbol.unscopables] = { + foo: false, + bar: true +}; + +with (obj) { + console.log(foo); // 1 + console.log(bar); // ReferenceError: bar is not defined +} +</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-symbol.unscopables', 'Symbol.unscopables')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + + + +<p>{{Compat("javascript.builtins.Symbol.unscopables")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.@@unscopables", "Array.prototype[@@unscopables]")}}</li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code> statement (not available in <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">Strict mode</a>)</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/typedarray/index.html b/files/pt-br/web/javascript/reference/global_objects/typedarray/index.html new file mode 100644 index 0000000000..9d34da5245 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/typedarray/index.html @@ -0,0 +1,364 @@ +--- +title: TypedArray +slug: Web/JavaScript/Reference/Global_Objects/TypedArray +tags: + - JavaScript + - NeedsTranslation + - TopicStub + - TypedArray + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/TypedArray +--- +<div>{{JSRef}}</div> + +<p>A <strong><em>TypedArray</em></strong> object describes an array-like view of an underlying <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer">binary data buffer</a>. There is no global property named <code>TypedArray</code>, nor is there a directly visible <code>TypedArray</code> constructor. Instead, there are a number of different global properties, whose values are typed array constructors for specific element types, listed below. On the following pages you will find common properties and methods that can be used with any typed array containing elements of any type.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">new<em> TypedArray</em>(length); +new <em>TypedArray</em>(typedArray); +new <em>TypedArray</em>(object); +new <em>TypedArray</em>(buffer [, byteOffset [, length]]); + +where <em>TypedArray()</em> is one of: + +Int8Array(); +Uint8Array(); +Uint8ClampedArray(); +Int16Array(); +Uint16Array(); +Int32Array(); +Uint32Array(); +Float32Array(); +Float64Array(); +</pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt>length</dt> + <dd>When called with a <code>length</code> argument, an internal array buffer is created in memory of size <em>length multiplied by BYTES_PER_ELEMENT</em> bytes containing 0 value.</dd> + <dt>typedArray</dt> + <dd>When called with a <code>typedArray</code> argument, which can be an object of any of the typed array types (such as <code>Int32Array</code>), the <code>typedArray</code> gets copied into a new typed array. Each value in <code>typedArray</code> is converted to the corresponding type of the constructor before being copied into the new array. Then length of the new typedArray object will be same of length of the typedArray argument.</dd> + <dt>object</dt> + <dd>When called with an <code>object</code> argument, a new typed array is created as if by the <code><em>TypedArray</em>.from()</code> method.</dd> + <dt>buffer, byteOffset, length</dt> + <dd>When called with a <code>buffer</code>, and optionally a <code>byteOffset</code> and a <code>length</code> argument, a new typed array view is created that views the specified {{jsxref("ArrayBuffer")}}. The <code>byteOffset</code> and <code>length</code> parameters specify the memory range that will be exposed by the typed array view. If both are omitted, all of <code>buffer</code> is viewed; if only <code>length</code> is omitted, the remainder of <code>buffer</code> is viewed.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>ECMAScript 2015 defines a <em>TypedArray</em> constructor that serves as the <code>[[Prototype]]</code> of all <em>TypedArray</em> constructors. This constructor is not directly exposed: there is no global <code>%TypedArray%</code> or <code>TypedArray</code> property. It is only directly accessible through <code>Object.getPrototypeOf(Int8Array)</code> and similar. All <em>TypedArray</em>s constructors inherit common properties from the <code>%TypedArray%</code> constructor function. Additionally, all typed array prototypes (<em>TypedArray</em><code>.prototype</code>) have <code>%TypedArray%.prototype</code> as their <code>[[Prototype]]</code>.</p> + +<p>The <code>%TypedArray%</code> constructor on its own is not particularly useful. Calling it or using it in a <code>new</code> expression will throw a <code>TypeError</code>, except when used during object creation in JS engines that support subclassing. There are at present no such engines, so <code>%TypedArray%</code> is only useful to polyfill functions or properties onto all <em>TypedArray</em> constructors.</p> + +<p>When creating a <em>TypedArray </em>instance (i.e. instance of Int8Array or similar), an array buffer is created internally (if ArrayBuffer object is present as constructor argument then this array buffer is used) in memory and this buffer address is saved as internal property of that instances, and all the methods of %<code>TypedArray</code>%.<code>prototype </code>uses that array buffer address to operate on i.e. set value and get value etc.</p> + +<h3 id="Property_access">Property access</h3> + +<p>You can reference elements in the array using standard array index syntax (that is, using bracket notation). However, getting or setting indexed properties on typed arrays will not search in the prototype chain for this property, even when the indices are out of bound. Indexed properties will consult the {{jsxref("ArrayBuffer")}} and will never look at object properties. You can still use named properties, just like with all objects.</p> + +<pre class="brush: js">// Setting and getting using standard array syntax +var int16 = new Int16Array(2); +int16[0] = 42; +console.log(int16[0]); // 42 + +// Indexed properties on prototypes are not consulted (Fx 25) +Int8Array.prototype[20] = 'foo'; +(new Int8Array(32))[20]; // 0 +// even when out of bound +Int8Array.prototype[20] = 'foo'; +(new Int8Array(8))[20]; // undefined +// or with negative integers +Int8Array.prototype[-1] = 'foo'; +(new Int8Array(8))[-1]; // undefined + +// Named properties are allowed, though (Fx 30) +Int8Array.prototype.foo = 'bar'; +(new Int8Array(32)).foo; // "bar"</pre> + +<h2 id="TypedArray_objects">TypedArray objects</h2> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">Type</td> + <td class="header">Size in bytes</td> + <td class="header">Description</td> + <td class="header">Web IDL type</td> + <td class="header">Equivalent C type</td> + </tr> + <tr> + <td>{{jsxref("Int8Array")}}</td> + <td>1</td> + <td>8-bit two's complement signed integer</td> + <td><code>byte</code></td> + <td><code>int8_t</code></td> + </tr> + <tr> + <td>{{jsxref("Uint8Array")}}</td> + <td>1</td> + <td>8-bit unsigned integer</td> + <td><code>octet</code></td> + <td><code>uint8_t</code></td> + </tr> + <tr> + <td>{{jsxref("Uint8ClampedArray")}}</td> + <td>1</td> + <td>8-bit unsigned integer (clamped)</td> + <td><code>octet</code></td> + <td><code>uint8_t</code></td> + </tr> + <tr> + <td>{{jsxref("Int16Array")}}</td> + <td>2</td> + <td>16-bit two's complement signed integer</td> + <td><code>short</code></td> + <td><code>int16_t</code></td> + </tr> + <tr> + <td>{{jsxref("Uint16Array")}}</td> + <td>2</td> + <td>16-bit unsigned integer</td> + <td><code>unsigned short</code></td> + <td><code>uint16_t</code></td> + </tr> + <tr> + <td>{{jsxref("Int32Array")}}</td> + <td>4</td> + <td>32-bit two's complement signed integer</td> + <td><code>long</code></td> + <td><code>int32_t</code></td> + </tr> + <tr> + <td>{{jsxref("Uint32Array")}}</td> + <td>4</td> + <td>32-bit unsigned integer</td> + <td><code>unsigned long</code></td> + <td><code>uint32_t</code></td> + </tr> + <tr> + <td>{{jsxref("Float32Array")}}</td> + <td>4</td> + <td>32-bit IEEE floating point number</td> + <td><code>unrestricted float</code></td> + <td><code>float</code></td> + </tr> + <tr> + <td>{{jsxref("Float64Array")}}</td> + <td>8</td> + <td>64-bit IEEE floating point number</td> + <td><code>unrestricted double</code></td> + <td><code>double</code></td> + </tr> + </tbody> +</table> + +<h2 id="Properties">Properties</h2> + +<dl> + <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT")}}</dt> + <dd>Returns a number value of the element size for the different typed array objects.</dd> + <dt><em>TypedArray</em>.length</dt> + <dd>Length property whose value is 0.</dd> + <dt>{{jsxref("TypedArray.name")}}</dt> + <dd>Returns the string value of the constructor name. E.g "Int8Array".</dd> + <dt>{{jsxref("TypedArray.@@species", "get TypedArray[@@species]")}}</dt> + <dd>The constructor function that is used to create derived objects.</dd> + <dt>{{jsxref("TypedArray.prototype")}}</dt> + <dd>Prototype for the <em>TypedArray</em> objects.</dd> +</dl> + +<h2 id="Methods">Methods</h2> + +<dl> + <dt>{{jsxref("TypedArray.from()")}}</dt> + <dd>Creates a new typed array from an array-like or iterable object. See also {{jsxref("Array.from()")}}.</dd> + <dt>{{jsxref("TypedArray.of()")}}</dt> + <dd>Creates a new typed array with a variable number of arguments. See also {{jsxref("Array.of()")}}.</dd> +</dl> + +<h2 id="TypedArray_prototype">TypedArray prototype</h2> + +<p>All <em>TypedArray</em>s inherit from {{jsxref("TypedArray.prototype")}}.</p> + +<h3 id="Properties_2">Properties</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/TypedArray/prototype','Properties')}}</p> + +<h3 id="Methods_2">Methods</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/TypedArray/prototype','Methods')}}</p> + +<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('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Defined as <code>TypedArray</code> and <code>ArrayBufferView</code> interface with typed array view types. Superseded by ECMAScript 2015.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-typedarray-objects', 'TypedArray Objects')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition in an ECMA standard. Specified behaviour for indexed and named properties. Specified that <code>new</code> is required.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-typedarray-objects', 'TypedArray Objects')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</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>{{CompatChrome(7.0)}}</td> + <td>{{CompatGeckoDesktop("2")}}</td> + <td>10</td> + <td>11.6</td> + <td>5.1</td> + </tr> + <tr> + <td>Indexed properties not consulting prototype</td> + <td>{{CompatVersionUnknown}} [1]</td> + <td>{{CompatGeckoDesktop("25")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Named properties</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("30")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td><code>new</code> is required</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("44")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Iterable in constructor</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("52")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</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 for Android</th> + </tr> + <tr> + <td>Basic support</td> + <td>4.0</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoMobile("2") }}</td> + <td>10</td> + <td>11.6</td> + <td>4.2</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Indexed properties not consulting prototype</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}} [1]</td> + <td>{{ CompatGeckoMobile("25") }}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}} [1]</td> + </tr> + <tr> + <td>Named properties</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoMobile("30") }}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td><code>new</code> is required</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{ CompatGeckoMobile("44") }}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Iterable in constructor</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{ CompatGeckoMobile("52") }}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] <code>-1</code> and similar are not considered as indexed properties and therefore return the value of the prototype property.</p> + +<h2 id="Compatibility_notes">Compatibility notes</h2> + +<p>Starting with ECMAScript 2015, <code>TypedArray</code> constructors require to be constructed with a {{jsxref("Operators/new", "new")}} operator. Calling a <code>TypedArray</code> constructor as a function without <code>new</code>, will throw a {{jsxref("TypeError")}} from now on.</p> + +<pre class="brush: js example-bad">var dv = Int8Array([1, 2, 3]); +// TypeError: calling a builtin Int8Array constructor +// without new is forbidden</pre> + +<pre class="brush: js example-good">var dv = new Int8Array([1, 2, 3]);</pre> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript typed arrays</a></li> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("DataView")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/typedarray/sort/index.html b/files/pt-br/web/javascript/reference/global_objects/typedarray/sort/index.html new file mode 100644 index 0000000000..79481a42b5 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/typedarray/sort/index.html @@ -0,0 +1,126 @@ +--- +title: TypedArray.prototype.sort() +slug: Web/JavaScript/Reference/Global_Objects/TypedArray/sort +translation_of: Web/JavaScript/Reference/Global_Objects/TypedArray/sort +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>sort()</strong></code> ordena os elementos de uma matriz tipada <em>no local</em> e retorna a matriz ordenada. Esse método tem o mesmo algoritmo que {{jsxref("Array.prototype.sort()")}}<em>.</em> <em>TypedArray</em> é uma das maneiras de <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#TypedArray_objects">escrever matrizes</a>.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><var>typedarray</var>.sort([<var>compareFunction</var>])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>compareFunction</code> {{optional_inline}}</dt> + <dd>Especifica uma função que define a ordem de classificação.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>A matriz ordenada.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<p>Para mais exemplos, acesse o método {{jsxref("Array.prototype.sort()")}}.</p> + +<pre class="brush: js">var numbers = new Uint8Array([40, 1, 5, 200]); +numbers.sort(); +// Uint8Array [ 1, 5, 40, 200 ] +// A compare function is not required as in the case of Array +// to sort the numbers numerically. + +var numbers = [40, 1, 5, 200]; +numbers.sort(); +// The elements are sorted as strings. +// [1, 200, 40, 5] + +function compareNumbers(a, b) { + return a - b; +} + +numbers.sort(compareNumbers); +// [ 1, 5, 40, 200 ] +</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('ES2015', '#sec-%typedarray%.prototype.sort', 'TypedArray.prototype.sort')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-%typedarray%.prototype.sort', 'TypedArray.prototype.sort')}}</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í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>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop(46)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</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>{{CompatGeckoMobile(46)}}</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("Array.prototype.sort()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/typeerror/index.html b/files/pt-br/web/javascript/reference/global_objects/typeerror/index.html new file mode 100644 index 0000000000..d793f767ff --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/typeerror/index.html @@ -0,0 +1,168 @@ +--- +title: TypeError +slug: Web/JavaScript/Reference/Global_Objects/TypeError +translation_of: Web/JavaScript/Reference/Global_Objects/TypeError +--- +<div>{{JSRef}}</div> + +<p>O objeto <code><strong>TypeError</strong></code> representa um erro de quando um valor não é do tipo esperado.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code>new TypeError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>message</code></dt> + <dd>Opcional. Mensagem, descrição do erro</dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Opcional. O nome do arquivo contendo o código que causou a exceção</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Opcional. O número da linha do código que causou a exeção</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>O <code>TypeError</code> é ativado quando um operador ou argumento passado para uma função é incompativel com o tipo esperado por esse operador ou função.</p> + +<p> </p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt>{{jsxref("TypeError.prototype")}}</dt> + <dd>Permite a adição de propriedades para o objeto <code>TypeError</code>.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<p>O TypeError global não contém métodos por si só, no entanto, ele herda alguns métodos através da cadeia prototype.</p> + +<h2 id="Instâncias_TypeError"><code>Instâncias TypeError</code></h2> + +<h3 id="Propriedades_2">Propriedades</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError/prototype', 'Properties')}}</div> + +<h3 id="Métodos_2">Métodos</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError/prototype', 'Methods')}}</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Capturando_um_TypeError">Capturando um <code>TypeError</code></h3> + +<pre class="brush: js">try { + null.f(); +} catch (e) { + console.log(e instanceof TypeError); // true + console.log(e.message); // "null has no properties" + console.log(e.name); // "TypeError" + console.log(e.fileName); // "Scratchpad/1" + console.log(e.lineNumber); // 2 + console.log(e.columnNumber); // 2 + console.log(e.stack); // "@Scratchpad/2:2:3\n" +} +</pre> + +<h3 id="Criando_um_TypeError">Criando um <code>TypeError</code></h3> + +<pre class="brush: js">try { + throw new TypeError('Hello', "someFile.js", 10); +} catch (e) { + console.log(e instanceof TypeError); // true + console.log(e.message); // "Hello" + console.log(e.name); // "TypeError" + console.log(e.fileName); // "someFile.js" + console.log(e.lineNumber); // 10 + console.log(e.columnNumber); // 0 + console.log(e.stack); // "@Scratchpad/2:2:9\n" +} +</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-native-error-types-used-in-this-standard-typeerror', 'TypeError')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.6.5', 'TypeError')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES3', '#sec-15.11.6.5', 'TypeError')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition</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>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="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("TypeError.prototype")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/undefined/index.html b/files/pt-br/web/javascript/reference/global_objects/undefined/index.html new file mode 100644 index 0000000000..2fcecff20c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/undefined/index.html @@ -0,0 +1,175 @@ +--- +title: undefined +slug: Web/JavaScript/Reference/Global_Objects/undefined +translation_of: Web/JavaScript/Reference/Global_Objects/undefined +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O valor global <code>undefined</code> representa um valor indefinido. Trata-se de um dos {{Glossary("Primitivo", "tipos primitivos")}} do JavaScript.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code>undefined</code></pre> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>O <code>undefined</code> é uma propriedade do objeto <code>global</code>, ou seja, é uma variável no escopo global. O valor inicial de <code>undefined</code> é o valor primitivo <code>undefined</code>.</p> + +<p>Nos browsers modernos (JavaScript 1.8.5 / Firefox 4+), a especificação ECMAScript 5 define que o <code>undefined</code> é uma propriedade não configurável e somente leitura. Mesmo quando esse não for o caso, evite sobrescrevê-lo.</p> + +<p>Uma variável que não teve um valor atribuído é do tipo <code>undefined</code>. Um método ou sentença também retorna <code>undefined</code> se a variável que está sendo avaliada não tem um valor atribuído. Uma função retorna <code>undefined</code> se um valor não for {{jsxref("Statements/return", "retornado")}}.</p> + +<p>Uma vez que undefined não é uma {{jsxref("Reserved_Words", "palavra reservada")}}, ele pode ser usado como um <a href="/en-US/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Variables">identificador</a> (nome de variável) em qualquer escopo que não seja o escopo global.</p> + +<pre class="brush: js">// escreve no console "foo string" +(function(){ var undefined = 'foo'; console.log(undefined, typeof undefined); })(); + +// escreve no console "foo string" +(function(undefined){ console.log(undefined, typeof undefined); })('foo'); +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Igualdade_estrita_()_e_undefined">Igualdade estrita (===) e <code>undefined</code></h3> + +<p>Voce pode utilizar <code>undefined</code> com os operadores de igualdade e desigualdade estritas para determinar se a variável possui um valor. No código a seguir, a variável <code>x</code> não foi definida, e o resultado do <code>if</code> é verdadeiro.</p> + +<pre class="brush: js">var x; +if (x === undefined) { + // sentenças aqui são executadas +} +else { + // o código aqui não é executado +} + +</pre> + +<div class="note"><span style="color: rgba(0, 0, 0, 0.65098); font-style: italic; background-color: rgba(231, 228, 157, 0.247059);">Observação: O operarador de igualdade estrita (</span><code style="font-style: italic; color: rgba(0, 0, 0, 0.65098);">===</code><span style="color: rgba(0, 0, 0, 0.65098); font-style: italic; background-color: rgba(231, 228, 157, 0.247059);">) tem que ser utilizado aqui uma vez que </span><code style="font-style: italic; color: rgba(0, 0, 0, 0.65098);">x == undefined</code><span style="color: rgba(0, 0, 0, 0.65098); font-style: italic; background-color: rgba(231, 228, 157, 0.247059);"> também checa se </span><code style="font-style: italic; color: rgba(0, 0, 0, 0.65098);">x</code><span style="color: rgba(0, 0, 0, 0.65098); font-style: italic; background-color: rgba(231, 228, 157, 0.247059);"> é nulo, enquanto o operador não o faz. </span><code style="font-style: italic; color: rgba(0, 0, 0, 0.65098);">null</code><span style="color: rgba(0, 0, 0, 0.65098); font-style: italic; background-color: rgba(231, 228, 157, 0.247059);"> não é equivalente à </span><code style="font-style: italic; color: rgba(0, 0, 0, 0.65098);">undefined</code><span style="color: rgba(0, 0, 0, 0.65098); font-style: italic; background-color: rgba(231, 228, 157, 0.247059);">. Veja </span><span style="color: rgba(0, 0, 0, 0.65098); font-style: italic; background-color: rgba(231, 228, 157, 0.247059);">{{jsxref("Operators/Comparison_Operators", "operadores de comparação")}} (em inglês) para maiores detalhes.</span></div> + +<h3 id="Operador_Typeof_e_undefined"><code>Operador Typeof</code> e <code>undefined</code></h3> + +<p>Alternativamente, {{jsxref("Operators/typeof", "typeof")}} pode ser usado:</p> + +<pre class="brush: js">var x; +if (typeof x === 'undefined') { + // esse código é executado +} +</pre> + +<p>Uma das principais razões para usar o {{jsxref("Operators/typeof", "typeof")}} é que ele não lança erros caso a variável não tenha sido inicializada.</p> + +<pre class="brush: js">// x não foi atribuída anteriormente +if (typeof x === 'undefined') { // returna verdadeiro sem lançar erros + // esse código executa +} + +if(x === undefined){ // lança um ReferenceError para x + +} +</pre> + +<p>No entanto, esse tipo de técnica deveria ser evitada. A linguagem JavaScript é uma linguagem com escopo estático, portanto o conhecimento sobre se uma variável está definida pode ser adquirido pela verificação de sua definição dentro do contexto à qual ela pertence. A única exceção é para o escopo global. No entanto, o escopo global é anexado ao objeto global, portanto a verificação da existência de uma variável no contexto global pode ser feita através de uma checagem na propriedade do objeto global usando o operador {{jsxref("Operators/in", "in")}}, por exemplo.</p> + +<h3 id="Operador_Void_e_undefined"><code>Operador Void</code> e <code>undefined</code></h3> + +<p>O operador {{jsxref("Operators/void", "void")}} é a terceira alternativa.</p> + +<pre class="brush: js">var x; +if (x === void 0) { + // esse código executa +} + +// y não foi definido antes +if (y === void 0) { + // lança uma ReferenceError (ao contrário de `typeof`) +} +</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ários</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Definição inicial. Implementado no JavaScript 1.3</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.1.3', 'undefined')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-undefined', 'undefined')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre 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> + +<p> </p> diff --git a/files/pt-br/web/javascript/reference/global_objects/unescape/index.html b/files/pt-br/web/javascript/reference/global_objects/unescape/index.html new file mode 100644 index 0000000000..e3b3d2a9d1 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/unescape/index.html @@ -0,0 +1,136 @@ +--- +title: unescape() +slug: Web/JavaScript/Reference/Global_Objects/unescape +translation_of: Web/JavaScript/Reference/Global_Objects/unescape +--- +<div>{{jsSidebar("Objects")}}</div> + +<div>{{Deprecated_header}}</div> + +<div>A função <strong>unescape()</strong> obsolta computa uma nova string na qual as sequencias hexadecimal são esquecidas com o caractere que representa. As sequências de escape podem ser introduzidas como funções {{jsxref("escape")}}. Porque a função 'unescape' está obsoleta, ao invez disso, use {{jsxref("decodeURI")}} ou {{jsxref("decodeURIComponent")}}.</div> + +<div> </div> + +<div class="note"><strong>Nota:</strong> Não use <code>unescape</code> para decodificar URIs, use <code>decodeURI</code> ao invez disso.</div> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>unescape(str)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>str</code></dt> + <dd>Uma string a ser decodificada.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova string na qual alguns caracteres tem que ser 'unescaped'.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>A função <code>unescape</code> é uma propriedade do objeto global.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js">unescape('abc123'); // "abc123" +unescape('%E4%F6%FC'); // "äöü" +unescape('%u0107'); // "ć" +</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('ES1', '#sec-15.1.2.5', 'unescape')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição Inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.2', 'unescape')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definido na compatibilidade Annex B</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-unescape-string', 'unescape')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Difinito na (normativa) Annex B Para novidades adicionais do ECMAScript para browsers</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-unescape-string', 'unescape')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Difinito na (normativa) Annex B Para novidades adicionais do ECMAScript para browsers</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidades_dos_browsers">Compatibilidades dos browsers</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Novidades</th> + <th>Chrome</th> + <th>Edge</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> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Novidades</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</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> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("decodeURI")}}</li> + <li>{{jsxref("decodeURIComponent")}}</li> + <li>{{jsxref("escape")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/uneval/index.html b/files/pt-br/web/javascript/reference/global_objects/uneval/index.html new file mode 100644 index 0000000000..f137fffd53 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/uneval/index.html @@ -0,0 +1,106 @@ +--- +title: uneval() +slug: Web/JavaScript/Reference/Global_Objects/uneval +translation_of: Web/JavaScript/Reference/Global_Objects/uneval +--- +<div>{{jsSidebar("Objects")}}{{Non-standard_header}}</div> + +<p>O método <code><strong>uneval()</strong></code> cria uma representação do código fonte de um Objeto.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox">uneval(<var>object</var>)</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>object</code></dt> + <dd>A JavaScript expression or statement.</dd> +</dl> + +<div class="note"><strong>Nota:</strong> Você não obterá uma representação em JSON válida para o Objeto..</div> + +<h2 id="Descrição">Descrição</h2> + +<p><code>uneval()</code> é uma função top-level e não é associada a nenhum objeto.</p> + +<h2 id="Examples">Examples</h2> + +<pre class="brush:js">var a = 1; +uneval(a); // retorna uma String contendo 1 + +var b = "1"; +uneval(b) // retorna uma String contendo "1" + +uneval(function foo(){}); // retorna"(function foo(){})" + + +var a = uneval(function foo(){return 'hi'}); +var foo = eval(a); +foo(); // retorna "hi" +</pre> + +<h2 id="Especificações">Especificações</h2> + +<p>Not part of any specifications.</p> + +<h2 id="Compatibilidade_dos_Navegadores">Compatibilidade dos Navegadores</h2> + +<p>{{CompatibilityTable}}</p> + +<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>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</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>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>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</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("Global_Objects/eval", "eval()")}}</li> + <li>{{jsxref("JSON.stringify")}}</li> + <li>{{jsxref("JSON.parse")}}</li> + <li>{{jsxref("Object.toSource")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/weakmap/delete/index.html b/files/pt-br/web/javascript/reference/global_objects/weakmap/delete/index.html new file mode 100644 index 0000000000..0a0d096c13 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/weakmap/delete/index.html @@ -0,0 +1,73 @@ +--- +title: WeakMap.prototype.delete() +slug: Web/JavaScript/Reference/Global_Objects/WeakMap/delete +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap/delete +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>delete()</strong></code> remover o elemento especificado ou setado a partir de um objeto instanciado do <code>WeakMap</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/weakmap-prototype-delete.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>wm</em>.delete(key);</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt>chave(key)</dt> + <dd>Requerido. A chave(<code>key</code>) do elemento a ser removido do objeto instanciado do <code>WeakMap</code>.</dd> +</dl> + +<h3 id="Valores_retornados">Valores retornados</h3> + +<p><code>true</code> se o emento do objeto do <code>WeakMap</code> tenha sido removido com sucesso. <code>false</code> se a chave(<code>key</code>) não for encontrada no <code>WeakMap</code> ou se a chave(<font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">key</span></font>) não for um objeto.</p> + +<h2 id="Examplos">Examplos</h2> + +<h3 id="Usando_o_método_delete">Usando o método <code>delete</code> </h3> + +<pre class="brush: js;highlight:[4]">var wm = new WeakMap(); +wm.set(window, 'foo'); + +console.log(wm.delete(window)); // Returna true. Removido com sucesso. + +wm.has(window); // Returna false. O objeto window não é mais pertecente ao WeakMap. +</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('ES2015', '#sec-weakmap.prototype.delete', 'WeakMap.prototype.delete')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-weakmap.prototype.delete', 'WeakMap.prototype.delete')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2> + +<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, confira A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, confira em <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> envie-nos seu pull request.</div> + +<p>{{Compat("javascript.builtins.WeakMap.delete")}}</p> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("WeakMap")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/weakmap/get/index.html b/files/pt-br/web/javascript/reference/global_objects/weakmap/get/index.html new file mode 100644 index 0000000000..fd35e8ce40 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/weakmap/get/index.html @@ -0,0 +1,74 @@ +--- +title: WeakMap.prototype.get() +slug: Web/JavaScript/Reference/Global_Objects/WeakMap/get +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap/get +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>get()</strong></code> retorna um elemento especificado de um objeto <code>WeakMap</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/weakmap-prototype-get.html")}}</div> + +<p class="hidden">A fonte para este exemplo interativo está em um repositório no GitHub. Caso você queira contribuir para o projeto de exemplos interativos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie uma pull request.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>wm</em>.get(chave);</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt>chave</dt> + <dd>Obrigatório. A chave do elemento a ser retornado pelo objeto <code>WeakMap</code>.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O elemento associado à chave especificada no objeto <code>WeakMap</code>. Se a chave não for encontrada, retorna-se {{jsxref("undefined")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Utilizando_o_método_get">Utilizando o método <code>get</code> </h3> + +<pre class="brush: js">var wm = new WeakMap(); +wm.set(window, 'foo'); + +wm.get(window); // Retorna "foo". +wm.get('baz'); // Returna undefined. +</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-weakmap.prototype.get', 'WeakMap.prototype.get')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-weakmap.prototype.get', 'WeakMap.prototype.get')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2> + + + +<p>{{Compat("javascript.builtins.WeakMap.get")}}</p> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakMap.set()")}}</li> + <li>{{jsxref("WeakMap.has()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/weakmap/has/index.html b/files/pt-br/web/javascript/reference/global_objects/weakmap/has/index.html new file mode 100644 index 0000000000..4a6795c182 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/weakmap/has/index.html @@ -0,0 +1,77 @@ +--- +title: WeakMap.prototype.has() +slug: Web/JavaScript/Reference/Global_Objects/WeakMap/has +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap/has +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>has()</strong></code> retorna um booleano indicando se um elemento com a chave especificada existe no objeto <code>WeakMap</code> ou não.</p> + +<p>{{EmbedInteractiveExample("pages/js/weakmap-prototype-has.html")}}</p> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>wm</em>.has(chave);</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt>chave</dt> + <dd>Obrigatório. A chave do elemento cuja presença deve ser verificada no objeto <code>WeakMap</code>.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<dl> + <dt>Boolean</dt> + <dd>Retorna <code>true</code> se um elemento com a chave especificada existir no objeto <code>WeakMap</code>. Caso contrário, retorna <code>false</code>.</dd> +</dl> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Utilizando_o_método_has">Utilizando o método <code>has</code> </h3> + +<pre class="brush: js">var wm = new WeakMap(); +wm.set(window, 'foo'); + +wm.has(window); // retorna true +wm.has('baz'); // retorna false +</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-weakmap.prototype.has', 'WeakMap.prototype.has')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-weakmap.prototype.has', 'WeakMap.prototype.has')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + + + +<p>{{Compat("javascript.builtins.WeakMap.has")}}</p> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakMap.prototype.set()")}}</li> + <li>{{jsxref("WeakMap.prototype.get()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/weakmap/index.html b/files/pt-br/web/javascript/reference/global_objects/weakmap/index.html new file mode 100644 index 0000000000..1069690348 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/weakmap/index.html @@ -0,0 +1,130 @@ +--- +title: WeakMap +slug: Web/JavaScript/Reference/Global_Objects/WeakMap +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap +--- +<div>{{JSRef("Global_Objects", "WeakMap")}}</div> + +<h2 id="Sumário">Sumário</h2> + +<p>O objeto WeakMap é uma coleção de pares key/value na qual as chaves são fracamente referenciadas.<br> + As chaves <strong>devem </strong>ser objetos, e os valores podem ser de tipos arbitrários.</p> + +<p>Você pode descobrir mais sobre <code>WeakMap</code>s na seção {{SectionOnPage("/en-US/docs/Web/JavaScript/Guide/Keyed_collections", "WeakMap object")}}.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox"><code>new WeakMap([iterable]) +</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>iterable</code></dt> + <dt><span style="font-weight: normal; line-height: 1.5;">Iterable é um Array ou outro objeto iterável cujos elementos são pares key-value (Arrays de dois elementos). Cada par key-value será adicionados ao novo <code>WeakMap</code>. <code>null</code> é tratado como <code>undefined</code>.</span></dt> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<h3 id="Por_quê_WeakMap">Por quê <em>Weak</em>Map?</h3> + +<p><span style="line-height: 1.5;">Um programador JavaScript experiente vai notar que esta API pode ser implementada em JavaScript com dois arrays (um para chaves, um para valores) compartilhado pelos 4 métodos da API. Tal implementação teria duas principais incoveniências. A primeira é uma busca O(n) (n sendo o número de chaves no map). A segunda é o problema de memory leak. Com maps escritos manualmente, o array de chaves guardaria referências para objetos chave, prevenindo-os de serem coletados pelo Garbage Collector. Nos WeakMaps nativos, referências aos objetos chave são segurados de modo "fraco", o que significa que eles não previnem a coleção pelo GC no caso de não haver nenhuma outra referência ao objeto. </span></p> + +<p><span style="line-height: 1.5;">Por conta das referências serem fracas, chaves de <code>WeakMap</code> não são enumeráveis (i.e. não existe um método que dá a você uma lista de chaves). Se existisse tal método, a lista dependeria no estado da coleção do GC, introduzindo não-determinismo. Se você quiser ter uma lista de chaves, deve usar um {{jsxref("Map")}}. </span></p> + +<h2 id="Properties" name="Properties">Propriedades</h2> + +<dl> + <dt><code>WeakMap.length</code></dt> + <dd>O valor da propriedade <code>length</code> é 0.</dd> + <dt>{{jsxref("WeakMap.prototype")}}</dt> + <dd>Representa o prototype para o constructor <code>WeakMap</code>. Permite a adição de propriedades para todos os objetos <code>WeakMap</code>.</dd> +</dl> + +<h2 id="Boolean_instances" name="Boolean_instances"><font face="Courier New, Andale Mono, monospace">Instâncias <code>WeakMap</code></font></h2> + +<p>Todas as instâncias <code>WeakMap</code> herdam de {{jsxref("WeakMap.prototype")}}.</p> + +<h3 id="Propriedades">Propriedades</h3> + +<p>{{page('pt-BR/docs/JavaScript/Reference/Global_Objects/WeakMap/prototype','Propriedades')}}</p> + +<h3 id="Métodos">Métodos</h3> + +<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/WeakMap/prototype','Metodos')}}</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Exemplo_Usando_WeakMap">Exemplo: Usando <code>WeakMap</code></h3> + +<pre class="brush: js">var wm1 = new WeakMap(), + wm2 = new WeakMap(), + wm3 = new WeakMap(); +var o1 = {}, + o2 = function(){}, + o3 = window; + +wm1.set(o1, 37); +wm1.set(o2, "azerty"); +wm2.set(o1, o2); // um valor pode ser qualquer coisa, incluindo um objeto or uma função +wm2.set(o3, undefined); +wm2.set(wm1, wm2); // chaves e valores pode ser quaisquer objetos. Até mesmo WeakMaps! + +wm1.get(o2); // "azerty" +wm2.get(o2); // undefined, pois não existe valor para o2 em wm2 +wm2.get(o3); // undefined, pois este é o valor definido + +wm1.has(o2); // true +wm2.has(o2); // false +wm2.has(o3); // true (mesmo se o valor armazenado for 'undefined') + +wm3.set(o1, 37); +wm3.get(o1); // 37 +wm3.clear(); +wm3.get(o1); // undefined, pois wm3 foi 'limpado' e não há mais valor para o1. + +wm1.has(o1); // true +wm1.delete(o1); +wm1.has(o1); // false +</pre> + +<h2 id="Specifications" name="Specifications">Especificações</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificações</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES2015', '#sec-weakmap-objects', 'WeakMap')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-weakmap-objects', 'WeakMap')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</h2> + +<p><br> + {{Compat("javascript.builtins.WeakMap")}}</p> + +<div id="compat-mobile"> </div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=547941">WeakMap bug at Mozilla</a></li> + <li><a href="http://fitzgeraldnick.com/weblog/53/">Hiding Implementation Details with ECMAScript 2015 WeakMaps</a></li> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/weakmap/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/weakmap/prototype/index.html new file mode 100644 index 0000000000..0baf6d569d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/weakmap/prototype/index.html @@ -0,0 +1,117 @@ +--- +title: WeakMap.prototype +slug: Web/JavaScript/Reference/Global_Objects/WeakMap/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap +--- +<div>{{JSRef("Global_Objects", "WeakMap")}}</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>A propriedade <code><strong>WeakMap</strong></code><strong><code>.prototype</code></strong> representa o prototype fara o construtor {{jsxref("WeakMap")}}.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Instâncias {{jsxref("WeakMap")}} herdam de {{jsxref("WeakMap.prototype")}}. Você pode usar o objeto <code>prototype</code> do construtor para adicionar propriedades ou métodos para todas as instâncias <code>WeakMap</code>.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>WeakMap.prototype.constructor</code></dt> + <dd>Retorna a função construtora das instâncias, neste caso a própria <code>{{jsxref("WeakMap")}}</code>.</dd> +</dl> + +<h2 id="Metodos">Metodos</h2> + +<dl> + <dt>{{jsxref("WeakMap.prototype.clear()")}}</dt> + <dd>Remove todos os pares chave/valor do objeto <code>WeakMap</code></dd> + <dt>{{jsxref("WeakMap.delete", "WeakMap.prototype.delete(key)")}}</dt> + <dd>Remove qualquer valor associado à <code style="font-style: normal; line-height: 1.5;">key</code><span style="line-height: 1.5;">. </span><code style="font-style: normal; line-height: 1.5;">WeakMap.prototype.has(key)</code> e retorna <code style="font-style: normal; line-height: 1.5;">false</code> após.</dd> + <dt>{{jsxref("WeakMap.get", "WeakMap.prototype.get(key)")}}</dt> + <dd>Retorna o valor associado a <code>key</code>, ou <code>undefined</code> se nenhum existir.</dd> + <dt>{{jsxref("WeakMap.has", "WeakMap.prototype.has(key)")}}</dt> + <dd>Retorna um Boolean verificando se há algum valor associado a <code>key</code> no objeto <code>WeakMap</code> ou não.</dd> + <dt>{{jsxref("WeakMap.set", "WeakMap.prototype.set(key, value)")}}</dt> + <dd>Configura um valor para <code>key</code> no objeto <code>WeakMap</code>. Retorna <code>undefined</code>.</dd> +</dl> + +<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-weakmap.prototype', 'WeakMap.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Especificação inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers </h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Recurso</th> + <th>Chrome</th> + <th>Firefox (SpiderMonkey)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("6.0")}}</td> + <td>11</td> + <td>{{CompatNo}}</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>Firefox Mobile (SpiderMonkey)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("6.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h3 id="Notas_para_o_Chrome">Notas para o Chrome</h3> + +<ul> + <li>O recurso é ativado por preferência. Em <span style="font-family: 'Courier New','Andale Mono',monospace;">chrome://flags </span>ative "Enable Experimental JavaScript".</li> +</ul> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Map.prototype")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/weakmap/set/index.html b/files/pt-br/web/javascript/reference/global_objects/weakmap/set/index.html new file mode 100644 index 0000000000..854f8ea816 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/weakmap/set/index.html @@ -0,0 +1,85 @@ +--- +title: WeakMap.prototype.set() +slug: Web/JavaScript/Reference/Global_Objects/WeakMap/set +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap/set +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>set()</code></strong> adiciona um novo elemento com a <code>chave</code> e o <code>valor</code> especificados em um objeto <code>WeakMap</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/weakmap-prototype-set.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><code><em>wm</em>.set(chave, valor);</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt>chave</dt> + <dd>Obrigatório. A chave do elemento a ser adicionado no objeto <code>WeakMap</code>.</dd> + <dt>valor</dt> + <dd>Obrigatório. O valor do elemento a ser adicionado no objeto <code>WeakMap</code>.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>O objeto <code>WeakMap</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Utilizando_o_método_set">Utilizando o método <code>set</code> </h3> + +<pre class="brush: js">var wm = new WeakMap(); +var obj = {}; + +// Adicionar novos elementos ao WeakMap +wm.set(obj, 'foo').set(window, 'bar'); // encadeável + +// Atualizar um elemento no WeakMap +wm.set(obj, 'baz'); +</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-weakmap.prototype.set', 'WeakMap.prototype.set')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-weakmap.prototype.set', 'WeakMap.prototype.set')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + + + +<p>{{Compat("javascript.builtins.WeakMap.set")}}</p> + +<h2 id="Notas_específicas_ao_Firefox">Notas específicas ao Firefox</h2> + +<ul> + <li>Antes do Firefox 33 {{geckoRelease("33")}}, <code>WeakMap.prototype.set</code> retornava <code>undefined</code> e, portanto, não era encadeável. Isso foi resolvido ({{bug(1031632)}}). O comportamento também podia ser encontrado no Chrome/v8 (<a href="https://code.google.com/p/v8/issues/detail?id=3410">issue</a>).</li> +</ul> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakMap.prototype.get()")}}</li> + <li>{{jsxref("WeakMap.prototype.has()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/weakset/index.html b/files/pt-br/web/javascript/reference/global_objects/weakset/index.html new file mode 100644 index 0000000000..841fce848f --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/weakset/index.html @@ -0,0 +1,199 @@ +--- +title: WeakSet +slug: Web/JavaScript/Reference/Global_Objects/WeakSet +translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet +--- +<div>{{JSRef}}</div> + +<div>O objeto <strong>WeakSet</strong> pertmite que você armazene objetos mantidos “fracamente” na coleção.</div> + +<div> </div> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"> new WeakSet([iterable]);</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt>iterable</dt> + <dd>Se um<a href="pt-BR/docs/Web/JavaScript/Reference/Statements/for...of"> objeto interagível </a>é passado, todos os seus elementos serão adicionados ao novo <code>WeakSet</code>.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Objetos <code>WeakSet</code> são coleções de objetos. Um objeto no <code>WeakSet </code>pode ocorrer uma vez; é único na coleção do <code>WeakSet</code>.</p> + +<p>As principais diferenças para o objeto {{jsxref("Set")}} são:</p> + +<ul> + <li>Em contraste ao <code>Sets</code>, <code>WeakSets </code>são <strong>coleções apenas de objetos</strong> e não de valores arbitrários de qualquer tipo.</li> + <li>O <code>WeakSet </code>é <em>fraco</em>. Referências aos objetos nas coleções são mantidas "fracamente". Se não há outra referência para um objeto mantido na <code>WeakSet</code>, eles pode ser coletados pelo gerenciamento de memória (<em>garbage collection</em>).</li> +</ul> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>WeakSet.length</code></dt> + <dd>O valor da propriedade de comprimento é 0.</dd> + <dt>{{jsxref("WeakSet.prototype")}}</dt> + <dd>Representa o protóripo para o construtos <code>Set</code>. Permite a adição de propriedades para todos os objetos do <code>WeakSet</code>.</dd> +</dl> + +<h2 id="Instâncias_WeakSet"><code>Instâncias WeakSet</code></h2> + +<p>Todas as instâncias do <code>WeakSet</code> herdam do {{jsxref("WeakSet.prototype")}}.</p> + +<h3 id="Propriedades_2">Propriedades</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/WeakSet/prototype','Properties')}}</p> + +<h3 id="Métodos">Métodos</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/WeakSet/prototype','Methods')}}</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_o_objeto_do_WeakSet">Usando o objeto do <code>WeakSet</code></h3> + +<pre class="brush: js">var ws = new WeakSet(); +var obj = {}; +var foo = {}; + +ws.add(window); +ws.add(obj); + +ws.has(window); // true +ws.has(foo); // false, foo não foi adicionado ao set + +ws.delete(window); // remove window do set +ws.has(window); // false, window foi removido +</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-weakset-objects', 'WeakSet')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-weakset-objects', 'WeakSet')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatilidade_de_Browser">Compatilidade de Browser</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>{{CompatChrome(36)}}</td> + <td>{{ CompatGeckoDesktop(34) }}</td> + <td>{{CompatNo}}</td> + <td>{{ CompatOpera(23) }}</td> + <td>9</td> + </tr> + <tr> + <td><code>new WeakSet(iterable)</code></td> + <td>38</td> + <td>{{ CompatGeckoDesktop(34) }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>9</td> + </tr> + <tr> + <td>Constructor argument: <code>new WeakSet(null)</code></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + <tr> + <td>Monkey-patched <code>add()</code> in Constructor</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>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>{{ CompatGeckoMobile(34) }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>9</td> + </tr> + <tr> + <td><code>new WeakMap(iterable)</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatGeckoMobile(34) }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>9</td> + </tr> + <tr> + <td>Constructor argument: <code>new WeakSet(null)</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + <tr> + <td>Monkey-patched <code>add()</code> in Constructor</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("WeakMap")}}</li> +</ul> |