initial commit

1 files changed, 186 insertions, 0 deletions

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) &gt; -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 &gt;&gt;&gt; 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 &gt;= tamanho, retorna -1.
+    if (n &gt;= tamanho) {
+      return -1;
+    }
+
+    // 7. Se n&gt;= 0, entao k seja n.
+    // 8. Senao, n&lt;0, k seja tamanho - abs(n).
+    // Se k é menor que 0, entao k seja 0.
+    k = Math.max(n &gt;= 0 ? n : tamanho - Math.abs(n), 0);
+
+    // 9. Repita, enquanto k &lt; tamanho
+    while (k &lt; 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 &amp;&amp; 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>