1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
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>
|
