recursal/MDN huggingface dataset:
Math.max()
==========

Sumário
-------

A função **`Math.max()`** retorna o maior de um ou mais números.

Sintaxe
-------
```

Math.max([valor1[,valor2, ...]])
```

### Parâmetros

`valor1, valor2, ...`

Números.

### Valor de retorno

O maior dos números passados como argumentos. Se pelo menos um dos argumentos não puder ser convertido para um número `NaN` é retornado.

Descrição
---------

Por `max` ser um método estático em `Math`, você sempre irá usá-lo da seguinte maneira `Math.max()`, e não como um método da classe `Math` que você tenha instanciado.

Se nenhum argumento for passado o resultado sempre será - `Infinity`.

Se um dos argumentos não puder ser convertido em um número, o resultado será `NaN`.

Exemplos
--------

### Usando `Math.max`


```js
Math.max(10, 20); // 20
Math.max(-10, -20); // -10
Math.max(-10, 20); // 20
```

### Retornando o maior elemento de um array

`Array.reduce()` pode ser usada para encontrar o maior elemento em um vetor numérico, comparando cada valor:


```js
var arr = [1, 2, 3];
var max = arr.reduce(function (a, b) {
  return Math.max(a, b);
}, -Infinity);
```


A função a seguir utiliza `Function.prototype.apply()` para encontrar o elemento de maior valor dentro do array. `getMaxOfArray([1,2,3])` é equivalente a `Math.max(1, 2, 3)`, mas você pode usar `getMaxOfArray` em arrays construídos programaticamente e o ideal é utilizá-la somente em arrays com relativamente poucos elementos.


```js
function getMaxOfArray(numArray) {
  return Math.max.apply(null, numArray);
}
```


O novo operador spread (en-US) é um modo curto de se escrever a solução com `apply` para retornar o maior valor de um array.


```js
var arr = [1, 2, 3];
var max = Math.max(...arr);
// max: 3
```


Entretanto, tanto spread(`...`) quanto `apply` 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 usando apply e funções embutidas para mais detalhes. A solução com `reduce` não apresenta esse problema.

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.max |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* O objeto `Math` pertence a.
* `Math.min()`
Math.LOG2E
==========

A propriedade **`Math.LOG2E`** representa o logaritmo com base 2 de `e`, aproximadamente 1.442:


Math.LOG2E

=

log
2

(
e
)
≈
1.442

\mathtt{\mi{Math.LOG2E}} = \log\_2(e) \approx 1.442



| Property attributes of `Math.LOG2E` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Descrição
---------

Por `LOG2E` ser uma propriedade estática de `Math`, deve-se sempre usá-la como `Math.LOG2E`, e não como propriedade de um objeto `Math` criado por você (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.LOG2E`

A função a seguir retorna o logaritmo com base 2 de `e`:


```js
function getLog2e() {
  return Math.LOG2E;
}

getLog2e(); // 1.4426950408889634
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log2e |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Math.exp()`
* `Math.log()`
* `Math.log2()`
Math.acos()
===========

A função **`Math.acos()`** retorna o arco cosseno (em radianos de um numero, sendo esse



∀
x
∊
[

-
1

;
1
]
,

Math.acos
(
x
)

=
arccos
(
x
)
=
 the unique 

y
∊
[
0
;
π
]

such that

cos
(
y
)
=
x

\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

Syntax
------
```

Math.acos(x)
```

### Parâmetros

Um numero.

### Retorno

O arco cosseno(em radianos) se o valor passado como parâmetro for entre -1 e 1; caso contrario retornará `NaN`.

Description
-----------

O `Math.acos()` 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á retornado `NaN`.

Porque `acos() é um metodo estático`, você sempre usará `Math.acos() ao invés de criar um Objecto Math(Math não é um construtor).`

Exemplos
--------

### Usando `Math.acos()`


```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
```


Para valores menores que -1 ou maiores que than 1, `Math.acos()` o método retornrá `NaN`.

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.acos |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.cos()
==========

A função **`Math.cos()`** ,que é estatica, retorna o cosseno de um ângulo, que deve estar em radianos. A expressão é 


length

adjacent


length

hypotenuse


.

Experimente
-----------

Sintaxe
-------
```

Math.cos(x)
```

### Parâmetros

`x`

Ângulo em radianos

### Valor de retorno

O cosseno do número: x

Descrição
---------

`Math.cos()` é um método que retorna um número entre -1 e 1, que representa o cosseno de um ângulo.

Já que `cos()` é um método estático de `Math`, você sempre deve usar `Math.cos()`, ao invez de criar um objeto de `Math` (`Math` não tem construtor).

Exemplos
--------

### Usando `Math.cos()`


```js
Math.cos(0); // 1
Math.cos(1); // 0.5403023058681398

Math.cos(Math.PI); // -1
Math.cos(2 \* Math.PI); // 1
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.cos |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.sin()`
* `Math.tan()`
Math.cbrt()
===========

A função **`Math.cbrt()`** retorna a raiz cúbica de um número, isto é



M
a
t
h
.
c
b
r
t
(
x
)

=

x
3

 =
 y, tal que

y
3

=
x

\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{the unique} ; y ; \text{such that} ; y^3 = x

Sintaxe
-------
```

Math.cbrt(x)
```

### Parâmetros

`x`

Um número.

### Valor de retorno

A raiz cúbica do número fornecido.

Descrição
---------

Porque `cbrt()` é um método estático de `Math`, você sempre irá utilizar como `Math.cbrt()`, ao invés de um método de um objeto `Math` que você tenha criado (`Math` não é um construtor).

Exemplos
--------

### Utilizando `Math.cbrt()`


```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
```

Polyfill
--------

Para todo 


x
≥
0

x \geq 0

, temos 


x
3

=

x

1
/
3

\sqrt[3]{x} = x^{1/3}

, então isto pode ser simulado pela seguinte função:


```js
if (!Math.cbrt) {
  Math.cbrt = function (x) {
    var y = Math.pow(Math.abs(x), 1 / 3);
    return x < 0 ? -y : y;
  };
}
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.cbrt |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Math.pow()`
* `Math.sqrt()`
Math.PI
=======

A propriedade **`Math.PI`** representa a proporção entre circunferência de um círculo com o seu diâmetro, aproximadamente 3.14159:


Math.PI

=
π
≈
3.14159

\mathtt{\mi{Math.PI}} = \pi \approx 3.14159

Experimente
-----------

| Property attributes of `Math.PI` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Descrição
---------

Como `PI` é uma propriedade estática de `Math`, sempre use-a como `Math.PI`, ao invés de uma propriedade de um objeto `Math` que você criou (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.PI`

A seguinte função usa `Math.PI` para calcular a circunferência de um círculo com um dado raio.


```js
function calcularCircunferencia(raio) {
  return 2 \* Math.PI \* raio;
}

calcularCircunferencia(1); // 6.283185307179586
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.pi |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Math`
Math.abs()
==========

Sumário
-------

A função **`Math.abs(x)`** retorna o valor absoluto de um número "x", tal qual:



Math.abs
(
x
)

=

|
x
|

=

{

x

if

x
>
0

0

if

x
=
0

-
x

if

x
<
0


{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x & \text{if} \quad x \geq 0 \ -x & \text{if} \quad x < 0 \end{cases}

Sintaxe
-------
```

var abs = Math.abs(x);
```

### Parâmetros

`x`

Um número.

### Valor de Retorno

O valor absoluto do número passado

Descrição
---------

Por `abs` ser um método estático de `Math`, você sempre o usará como `Math.abs()` ao ínves de usar como método de um objeto `Math` criado por você. (`Math` não é um construtor);

Exemplos
--------

### Comportamento de `Math.abs()`

Passando um string não-numérica ou variável indefinida/vazia retorna `NaN`. Passando null retorna 0.


```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
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.abs |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja Também
-----------

* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
* `Math.trunc()`
Reflect.defineProperty()
========================

O método estático **`Reflect.defineProperty()`** é como o `Object.defineProperty()`, mas retorna um `Boolean`.

Experimente
-----------

Sintaxe
-------
```

Reflect.defineProperty(target, propertyKey, attributes)
```

### Parâmetros

`target`

O objeto de destino onde será definida a propriedade.

`propertyKey`

O nome da propriedade a ser definida ou modificada.

`attributes`

Os atributos para a propriedade que está sendo definida ou modificada.

### Valor de retorno

Um `Boolean` indicando se a propriedade foi ou não definida com êxito.

### Erros

Um `TypeError`, se `target` não for um `Object`.

Descrição
---------

O método `Reflect.defineProperty` permite a adição precisa ou a modificação de uma propriedade em um objeto. Para mais detalhes veja o `Object.defineProperty`, que é semelhante.

**Nota:** **Uma diferença fundamental:** `Object.defineProperty` retorna o objeto ou lança um `TypeError` se a propriedade não tiver sido definida com êxito. `Reflect.defineProperty`, no entanto, simplesmente retorna um `Boolean` indicando se a propriedade foi ou não definida com êxito.

Exemplos
--------

### Usando `Reflect.defineProperty()`


```js
let obj = {};
Reflect.defineProperty(obj, "x", { value: 7 }); // true
obj.x; // 7
```

### Verificando se a definição da propriedade foi bem-sucedida

Com o `Object.defineProperty`, que retorna um objeto se for bem-sucedido ou lança um `TypeError`, você usaria um bloco try...catch para detectar qualquer erro que ocorreu ao definir uma propriedade.

Como `Reflect.defineProperty` retorna um status de sucesso booleano, você pode usar apenas um bloco `if...else` aqui:


```js
if (Reflect.defineProperty(target, property, attributes)) {
  // success
} else {
  // failure
}
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.defineproperty |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Reflect`
* `Object.defineProperty()`
Reflect.set()
=============

O método estático **`Reflect.set()`** define uma propriedade em um objeto.

Sintaxe
-------
```

Reflect.set(alvo, propriedade, valor[, receptor])
```

### Parâmetros

`alvo`

O objeto alvo onde a propriedade será definida.

`propriedade`

O nome da propriedade a ser definida.

valor

o valor a ser definido para a propriedade.

receptor

O valor do `this` fornecido para a chamada do alvo se um setter é encontrado.

### Retorno

Um `Boolean` indicando se a definicão da propriedade ocorreu com sucesso ou não.

### Exceções

Um `TypeError`, se o `alvo` não for um `Object`.

Descrição
---------

O método `Reflect.set` permite que você defina uma propriedade em um objeto. Ele define a propriedade e is like the property accessor syntax as a function.

Exemplos
--------

### Usando `Reflect.set()`


```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 }
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.set |

Compatilibidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Reflect`
* Property accessors
Reflect.apply()
===============

O método estático **`Reflect.apply()`** chama uma função alvo com os argumentos especificados.

Sintaxe
-------
```

Reflect.apply(target, thisArgument, argumentsList)
```

### Parâmetros

target

Função que será chamada.

thisArgument

O valor de "`this"` que será usado pela function do target.

argumentsList

Um objeto do tipo array que especifica os argumentos com que o *`target`* deve ser chamado.

### Valor de retorno

O resultado da função alvo chamada com o **`this`** e argumentos especificados.

### Exceções

Um `TypeError`, se a função especificada no *target* não for invocável.

Descrição
---------

No ES5, tipicamente é usado o método `Function.prototype.apply()` para chamar uma função com o valor de `this e argumentos` fornecidos como um array (ou um array-like object).


```js
Function.prototype.apply.call(Math.floor, undefined, [1.75]);
```


Com o `Reflect.apply` isso se torna menos verboso e mais fácil de entender.

Exemplos
--------

### Usando `Reflect.apply()`


```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"
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.apply |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Reflect`
* `Function.prototype.apply()`
TypedArray.prototype.sort()
===========================

O método **`sort()`** ordena os elementos de uma matriz tipada *no local* e retorna a matriz ordenada. Esse método tem o mesmo algoritmo que `Array.prototype.sort()`*.* *TypedArray* é uma das maneiras de escrever matrizes (en-US).

Syntax
------
```

typedarray.sort([compareFunction])
```

### Parâmetros

`compareFunction` Optional

Especifica uma função que define a ordem de classificação.

### Valor de retorno

A matriz ordenada.

Exemplos
--------

Para mais exemplos, acesse o método `Array.prototype.sort()`.


```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 ]
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.sort |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver também
----------

* `Array.prototype.sort()`
JSON.parse()
============

O método **`JSON.parse()`** analisa uma string JSON, construindo o valor ou um objeto JavaScript descrito pela string. Uma função **reviver** opcional pode ser fornecida para executar uma transformação no objeto que será retornado.

Experimente
-----------

Sintaxe
-------
```

JSON.parse(text[, reviver])
```

### Parâmetros

`text`

A string para analisar como JSON. Veja o objeto `JSON` para uma descrição da sintaxe JSON.

`reviver` Optional

Se for uma função, prescreve como o valor originalmente produzido pela análise será transformado antes de ser retornado.

### Valor retornado

O `Object` correspondente ao `text` JSON fornecido.

### Exceções

Lança uma exceção `SyntaxError` (en-US) se a string a ser analisada não for um JSON válido.

Exemplos
--------

### Usando `JSON.parse()`


```js
JSON.parse("{}"); // {}
JSON.parse("true"); // true
JSON.parse('"foo"'); // "foo"
JSON.parse('[1, 5, "false"]'); // [1, 5, "false"]
JSON.parse("null"); // null
```

### Usando o parâmetro `reviver`

Se um `reviver` for especificado, o valor calculado pela análise será *transformado* 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 `reviver`. Em seguida, ele é chamado, com o objeto contendo a propriedade sendo processada como `this`, e com o nome da propriedade como uma string, e o valor da propriedade como argumentos. Se a função `reviver` retornar `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.

Se o `reviver` 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.


```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
// ""
```

### `JSON.parse()` não permite vírgulas à direta


```js
// ambos retornarão um SyntaxError
JSON.parse("[1, 2, 3, 4, ]");
JSON.parse('{"foo" : 1, }');
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-json.parse |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja Também
-----------

* `JSON.stringify()`
Array.prototype.at()
====================

Baseline 2022
-------------

Newly availableSince March 2022, this feature works across the latest devices and browser versions. This feature might not work in older devices or browsers.

* Learn more
* See full compatibility
* Report feedback
O método **`at()`** recebe um valor inteiro e retorna o item referente ao index dele, permitindo valores positivos ou negativos. Valores negativos contam apartir do último item do array.

Isto não quer dizer que exista alguma coisa errada em utilizar a notação com colchetes. Por exemplo `array[0]` retornaria o primeiro item. Porém ao invés de utilizar o `array.length` para os últimos items; e.g `array[array.length-1]` para o último item, você pode utilizar o `array.at(-1)`. (Veja os exemplos abaixo)

Experimente
-----------

Sintaxe
-------


```js
at(index);
```

### Parâmetros

`index`

O index (posição) do elemento do array que será retornado. Quando um valor negativo é passado como argumento a contagem dos elementos é feita de trás para frente.

### Valor retornado

O elemento correspondente ao index passado como argumento. Retorna `undefined` se o index passado não for encontrado.

Exemplos
--------

### Retornando o último item de um array

O exemplo a seguir exibe uma função que retorna o último elemento encontrado de um array específico.


```js
// O array com items
const cart = ["apple", "banana", "pear"];

// A função que retorna o último item do array passado como argumento
function returnLast(arr) {
  return arr.at(-1);
}

// Pega o último item do array 'cart'
const item1 = returnLast(cart);
console.log(item1); // 'pear'

// Adiciona um item ao array 'cart'
cart.push("orange");
const item2 = returnLast(cart);
console.log(item2); // 'orange'
```

### Comparando métodos

 Este exemplo compara a diferentes maneiras de selecionar o penúltimo item de um `Array`.
 Todos os métodos abaixos são válidos, mas este exemplo destaca a sucintez e legibilidade do método `at()`.


```js
// O array com items
const colors = ["red", "green", "blue"];

// Usando a propriedade length
const lengthWay = colors[colors.length - 2];
console.log(lengthWay); // 'green'

// Usando o método slice(). Perceba que um array é retornado
const sliceWay = colors.slice(-2, -1);
console.log(sliceWay[0]); // 'green'

// Usando o método at()
const atWay = colors.at(-2);
console.log(atWay); // 'green'
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.at |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* Um polyfill do método `Array.prototype.at` está disponível em `core-js`
* Um polyfill para o método at().
* `Array.prototype.find()` – retorna um valor baseado no teste fornecido.
* `Array.prototype.includes()` – verifica se um valor existe em um array.
* `Array.prototype.indexOf()` – retorna o index de um determinado elemento.
Array.prototype.values()
========================

O método **`values()`** retorna um novo objeto de **`Array Iterator`** que contém os valores para cada índice no array.

Sintaxe
-------
```

arr.values()
```

Exemplos
--------

### Iteração usando `for...of` loop


```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);
}
```

### Iteração alternativa


```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
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.values |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Notas específicas do Firefox
----------------------------

* Devido a um problema de compatibilidade, `Array.prototype.values()` foi removido do SpiderMonkey por enquanto.
Ver também
----------

* `Array.prototype.keys()`
* `Array.prototype.entries()`
* `Array.prototype.forEach()`
* `Array.prototype.every()`
* `Array.prototype.some()`