recursal/MDN huggingface dataset:
Parâmetros Rest
===============

A sintaxe de **rest parameter (parâmetros rest)** nos permite representar um número indefinido de argumentos como um array.

Sintaxe
-------


```js
function(a, b, ...theArgs) {
  // ...
}
```

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

Se o último argumento nomeado de uma função tiver prefixo com `...`, ele irá se tornar um array em que os elemento de 0 (inclusive) até theArgs.length (exclusivo) são disponibilizados pelos argumentos atuais passados à função.

No exemplo acima, `theArgs` irá coletar o terceiro argumento da função (porquê o primeiro é mapeado para `a`, e o segundo para `b`) e assim por diante em todos os argumentos consecutivos.

### Diferença entre *rest parameters* e *`arguments` object*

Há três diferenças principais entre *rest parameters* e os `arguments` objects:

* *rest parameters* são os únicos que não foram atribuidos a um nome separado, enquanto os `arguments` object contêm todos os argumentos passados para a função;
* o objeto `arguments` não é um array, enquanto rest parameters são instâncias `Array`, isso significa que métodos como `sort`, `map`, `forEach` ou `pop` podem ser aplicados diretamente;
* o objeto `arguments` possui a funcionalidade adicional de especificar ele mesmo (como a propriedade `callee`).
### De arguments para array

Rest parameters foram criados para reduzir o código padrão que foi induzida pelos argumentos


```js
// Antes rest parameters, o seguinte codigo pode ser encontrado
function f(a, b){
  var args = Array.prototype.slice.call(arguments, f.length);

  // ...
}

// esse é o equivalente

function(a, b, ...args) {

}
```

Exemplos
--------

Como `theArgs` é um array, você pode pegar número de elementos usando a propriedade `length`:


```js
function fun1(...theArgs) {
  console.log(theArgs.length);
}

fun1(); // 0
fun1(5); // 1
fun1(5, 6, 7); // 3
```


No próximo exemplo, nós usamos o rest parâmetro para buscar argumentos do segundo parâmetro para o fim. Nós multiplicamos eles pelo primeiro parâmetro:


```js
function multiply(multiplier, ...theArgs) {
  return theArgs.map(function (element) {
    return multiplier \* element;
  });
}

var arr = multiply(2, 1, 2, 3);
console.log(arr); // [2, 4, 6]
```


O próximo exemplo mostra como você pode usar metodos do Array em rest params, mas não no objeto `arguments`:


```js
function sortRestArgs(...theArgs) {
  var sortedArgs = theArgs.sort();
  return sortedArgs;
}

console.log(sortRestArgs(5, 3, 7, 1)); // Exibe 1,3,5,7

function sortArguments() {
  var sortedArgs = arguments.sort();
  return sortedArgs; // isso nunca irá ocorrer
}

// throws a TypeError: arguments.sort is not a function
console.log(sortArguments(5, 3, 7, 1));
```


a fim de usar o objeto `arguments`, você precisará converte-lo para um array antes.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-function-definitions |

Compatibilidade
---------------

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

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

* Arguments object
* Array
* Functions
* Spread Operator (en-US)
* Original proposal at ecmascript.org
* JavaScript arguments object and beyond
Operador de Agrupamento
=======================

Sumário
-------

O operador de agrupamento `()` controla a precedência e a precedência de avaliação em expressões.

Sintaxe
-------
```

 ( )
```

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

O operador de agrupamento consiste em um par de parênteses em volta de uma expressão, ou sub-expressão, para ignorar a precedência normal de operadores de modo que expressões com menor precedência possam ser avaliadas antes de uma expressão com maior prioridade.

Exemplos
--------

Ignorando multiplicação e divisão primeiro, então adição e substração para avarliar adição primeiramente.


```js
var a = 1;
var b = 2;
var c = 3;

// default precedence
a + b \* c; // 7
// evaluated by default like this
a + (b \* c); // 7

// now overriding precedence
// addition before multiplication
(a + b) \* c; // 9

// which is equivalent to
a \* c + b \* c; // 9
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-grouping-operator |

Compatibilidade
---------------

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

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

* Operator precedence
* `delete` (en-US)
* `typeof`
Bitwise XOR (^)
===============

O operador bitwise XOR (`^`) retorna o numero 1 em cada posição de bit para a qual os bits correspondentes de ambos, mas não de ambos os operandos, são `1`s.

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

Sintaxe
-------
```

a ^ b
```

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

Os operandos são convertidos em números inteiros de 32 bits e expressados por uma série de bits (zeros e uns). Numeros com mais de 32 bits descartam seus bits mais significativos. Por exemplo, o número inteiro a seguir com mais de 32 bits será convertido em um número inteiro de 32 bits:
```

Antes: 11100110111110100000000000000110000000000001
Depois:            10100000000000000110000000000001
```


Cada bit no primeiro operando é emparelhado com o bit correspondente no segundo operando: primeiro bit para o primeiro bit, segundo bit para o segundo bit e assim por diante.

O operador é aplicado para cada par de bits e o resultado é construído em bitwise.

A tabela verdade para a operação XOR é:

| a | b | a XOR b |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |


```js
.    9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------
14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
```


Bitwise XORing any number `x` with `0` yields `x`.

Exemplos
--------

### Usando bitwise XOR


```js
// 9 (00000000000000000000000000001001)
// 14 (00000000000000000000000000001110)

14 ^ 9;
// 7 (00000000000000000000000000000111)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # prod-BitwiseXORExpression |

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

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

Leia também
-----------

* Bitwise operators in the JS guide
* Bitwise XOR assignment operator (en-US)
Operador Condicional Ternário
=============================

Sumário
-------

O **operador condicional (ternário)** é o único operador JavaScript que possui três operandos. Este operador é frequentemente usado como um atalho para a instrução `if`.

Sintaxe
-------
```

condition ? expr1 : expr2
```

Parâmetros
----------

`condition`

Uma expressão que é avaliada como `true` ou `false`.

`expr1`, `expr2`

Expressões com valores de qualquer tipo.

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

Se `condition` é `true`, o operador retornará o valor de `expr1`; se não, ele retorna o valor de `exp2`. Por exemplo, para exibir uma mensagem diferente baseada no valor da variável `isMember`, você poderá utilizar o código (statement) seguinte:


```js
"The fee is " + (isMember ? "$2.00" : "$10.00");
```


Conforme o resultado da operação, você também poderá atribuir a variáveis:


```js
var elvisLives = Math.PI > 4 ? "Yep" : "Nope";
```


Também são possíveis múltiplas avaliaçãoes ternárias (nota: o operador condicional é associativo a direita):


```js
var firstCheck = false,
  secondCheck = false,
  access = firstCheck
    ? "Access denied"
    : secondCheck
      ? "Access denied"
      : "Access granted";

console.log(access); // logs "Access granted"
```


Você também pode usar avaliações ternárias no espaço livre de modo a fazer diferentes operações:


```js
var stop = false,
  age = 16;

age > 18 ? location.assign("continue.html") : (stop = true);
```


Você também pode fazer mais do que uma única operação em cada caso, separando-os por vírgula:


```js
var stop = false,
  age = 23;

age > 18
  ? (alert("OK, you can go."), location.assign("continue.html"))
  : ((stop = true), alert("Sorry, you are much too young!"));
```


Você também pode fazer mais de uma operação durante a atribuição de um valor. Neste caso, **o último valor separado por vírgula dentro** dos parênteses **será o valor a ser atribuído**.


```js
var age = 16;

var url =
  age > 18
    ? (alert("OK, you can go."),
      // alert returns "undefined", but it will be ignored because
      // isn't the last comma-separated value of the parenthesis
      "continue.html") // the value to be assigned if age > 18
    : (alert("You are much too young!"),
      alert("Sorry :-("),
      // etc. etc.
      "stop.html"); // the value to be assigned if !(age > 18)

location.assign(url); // "stop.html"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-conditional-operator |

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

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

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

* Operador condicional if
import.meta
===========

O objeto **`import.meta`** mostra os metadados específicos do contexto de um módulo JavaScript. Ele contém informações sobre o módulo, como a sua URL.

Sintaxe
-------
```

import.meta
```

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

A sintaxe consiste na palavra chave `import`, um ponto, e o identificador `meta`. Normalmente no lado esquerdo do ponto é o objeto na qual a propriedade de acesso é realizada is, mas aqui `import` não é exatamente um objeto.

O objeto`import.meta` foi criado no implementação ECMAScript,com um protótipo `null`. O objeto é extensível, e suas propriedades são grávaveis, configuráveis, e enumeráveis.

Exemplos
--------

### Usando import.meta

Dado o modulo `my-module.js`


```html
<script type="module" src="my-module.js"></script>
```


Você pode acessar essa meta informação sobre o modulo usando o objeto `import.meta.`


```js
console.log(import.meta); // { url: "file:///home/user/my-module.js" }
```


Irá retornar um objeto com propriedade URL indicando a base URL do módulo. Isso vai ser o URL da qual o script obteve, por scripts external, ou a base do documento URL contendo documento, para scripts inline.

Note que isso irá incluir parâmetros query e/ou cerquilha (i.e., seguindo o `?` ou `#`).

Por exemplo, seguindo esse HTML:


```html
<script type="module">
 import "./index.mjs?someURLInfo=5";
</script>
```


O arquivo JavaScript a seguir vai registrar o parâmetro `someURLInfo`:


```js
// index.mjs
new URL(import.meta.url).searchParams.get("someURLInfo"); // 5
```


O mesmo se aplica quando um arquivo importa outro:


```js
// index.mjs
import "./index2.mjs?someURLInfo=5";

// index2.mjs
new URL(import.meta.url).searchParams.get("someURLInfo"); // 5
```


Note que enquanto o Node.js vai passar nos parâmetros query (ou na cerquilha) como no exemplo passsado, a partir do Node 14.1.0, a URL com parâmetro query vai dar erro quando carregar no formulário `node --experimental-modules index.mjs?someURLInfo=5` (é tratado como um arquivo ao invés de uma URL nesse contexto).

Nesse arquivo específico, o argumento passado pode ser complementar para ser usado na ampla aplicação `location.href` (com strings query ou cerquilha adicionada depois do caminho de arquivo HTML) (ou por Node.js, através do `process.argv`).

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

| Specification |
| --- |
| ECMAScript Language Specification # prod-ImportMeta |
| HTML Standard # hostgetimportmetaproperties |

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

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

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

* `import`
* `export`
class expression
================

A **expressão class** é uma das formas de definir uma classe no ECMAScript 2015. Parecido com as expressões function, expressões class poder ser nomeadas ou não. Se nomeada, o nome da classe é local para apenas o corpo da classe. Classes no JavaScript usam herança com base no prototype

Sintaxe
-------
```

var MinhaClasse = class [nomeDaClass] [extends] {
  // corpo da classe
};
```

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

Uma expressão de classe tem uma sintaxe similar a uma declaração de classe. No entanto, com expressões de classe, você poderá omitir o nome da classe ("ligação de identificadores"), que você não pode se usar declarações. Adicionalmente, expressões de classe permitem que você redefina/redeclare classes e **não invocar** nenhum tipo de erros como declaração de classe. A propriedade construtora é opcional. E o *typeof* de classes geradas usando essa palavra-chave sempre será "function".

Assim como declarações de classes, o corpo das expressões de classe são executados em strict mode.


```js
"use strict";
var Foo = class {}; // propriedade de construtor é opcional
var Foo = class {}; // Re-declaração é permitida

typeof Foo; //retorna "function"
typeof class {}; //retorna "function"

Foo instanceof Object; // true
Foo instanceof Function; // true
class Foo {} // Throws TypeError, não permite re-declaração
```

Exemplos
--------

### Uma simples expressão de classe

Isso é apenas uma simples classe anônima que você pode referir usando a variável "Foo".


```js
var Foo = class {
  constructor() {}
  bar() {
    return "Olá mundo!";
  }
};

var instance = new Foo();
instance.bar(); // "Olá mundo!"
Foo.name; // "Foo"
```

### Expressões de classes nomeadas

Se você quiser referir a classe atual dentro do corpo da classe, você pode criar uma expressão de classe nomeada. Esse nome é visível apenas no escopo da expressão classe sozinha.


```js
var Foo = class NamedFoo {
  constructor() {}
  whoIsThere() {
    return NamedFoo.name;
  }
};
var bar = new Foo();
bar.whoIsThere(); // "NamedFoo"
NamedFoo.name; // ReferenceError: NamedFoo is not defined
Foo.name; // "NamedFoo"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-class-definitions |

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

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

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

* Expressão `function`
* Declaração `class`
* Classes
void operator
=============

O **`operador void`** avalia a expressão dada e, em seguida, retorna `undefined`.

Sintaxe
-------
```

void expressão
```

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

Este operador permite a inserção de expressões que produzem efeitos secundários em lugares onde uma expressão que avalia a ação `undefined` é desejada.

O operador `void` é muitas vezes utilizado apenas para obter o valor primitivo `undefined`, geralmente usando "`void(0)`" (o que equivale a "`void 0`"). Nestes casos, a variável global `undefined` pode ser utilizado em vez (supondo que ele não tenha sido atribuído a um valor não-padrão).

Chamada imediata das expressões da função
-----------------------------------------

Quando usamos uma Chamada imediata das expressões da função, valores nulos podem ser usado para forçar a palavra-chave da função a ser tratada como uma expressão em vez de uma declaração.


```js
void (function iife() {
  var bar = function () {};
  var baz = function () {};
  var foo = function () {
    bar();
    baz();
  };
  var biz = function () {};

  foo();
  biz();
})();
```

JavaScript URIs
---------------

Quando o navegador segue uma URI `javascript`, ele avalia o código na URI e então troca o conteúdo da página pelo valor retornado por este, a não ser que o valor retornado seja `undefined`. O operador `void` pode ser usado para retornar `undefined`. Por exemplo:


```html
<a href="javascript:void(0);">Clique aqui para não fazer nada</a>

<a href="javascript:void(document.body.style.backgroundColor='green');">
  Clique aqui para o papel de parede ser verde
</a>
```


Note que no entanto o pseudo protocolo `javascript:` tem seu uso desencorajado perante outras alternativas como *unobtrusive event handlers*.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-void-operator |

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

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

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

* `undefined`
Bitwise AND (&)
===============

O operador bitwise AND (`&`) retorna `1` em cada posição do bit em que os bits corrrespondentes de ambos os operandos são `1`.

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

Sintaxe
-------


```js
a & b
```

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

 Os operandos são convertidos em inteiros de 32 bits e expressos por uma série de bits (zeros e uns). Números com mais de 32 bits têm seus bits mais significativos descartados. Por exemplo, o seguinte inteiro com mais de 32 bits será convertido em um de 32 bits
 inteiro:
```

Antes: 11100110111110100000000000000110000000000001
Depois:            10100000000000000110000000000001
```


 Cada bit no primeiro operando é emparelhado com o bit correspondente no segundo
 operando: *primeiro bit* para o *primeiro bit* , *segundo bit* para o *segundo bit*, e assim por diante.

O operador é aplicado a cada par de bits e o resultado é construído em bitwase.

A tabela verdade para a operação AND é:

| a | b | a AND b |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
```

     9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------
14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
```


 A operação AND bit a bit (Bitwase) de qualquer número `x` com `0` produz
 `0` .

Exemplos
--------

### Usando bitwase AND


```js
// 5: 00000000000000000000000000000101
// 2: 00000000000000000000000000000010
5  e  2 ; // 0
```

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

| Specification |
| --- |
| ECMAScript Language Specification # prod-BitwiseANDExpression |

Compatibilidade de navegadores
------------------------------

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

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

* Operadores Bitwise no JS guide
* Operador de atribuição Bitwise AND (en-US)
in operator
===========

O **operador** **`in`** retorna `true` se a propriedade especificada estiver no objeto especificado ou na sua cadeia de protótipo (prototype chain) desde objeto.

Sintaxe
-------
```

prop in object
```

### Parâmetros

`prop`

Um string ou símbolo representando o nome de uma propriedade ou o índice de um array (não-símbolos serão trazidos para strings).

`object`

Objeto para verificar se este (ou sua cadeia de protótipo) contém a propriedade com o nome especificado.

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

Os exemplos a seguir mostram alguns usos do operador `in`.


```js
// Arrays
var trees = ["redwood", "bay", "cedar", "oak", "maple"];
0 in trees; // retorna true
3 in trees; // retorna true
6 in trees; // retorna false
"bay" in trees; // retorna false (você precisa especificar o
// número do índice, não o valor naquele índice)
"length" in trees; // retorna true (length é uma propridade do Array)
Symbol.iterator in trees; // retorna true (arrays são iteráveis, funciona apenas na ES2015+)

// Objetos predefinidos
"PI" in Math; // retorna true

// Objetos personalizados
var mycar = { make: "Honda", model: "Accord", year: 1998 };
"make" in mycar; // retorna true
"model" in mycar; // retorna true
```


Você precisa especificar um objeto no lado direito do operador `in`. Por exemplo, você pode especifica um string criado com o construtor `String`, mas você não pode especificar um string literal.


```js
var color1 = new String("green");
"length" in color1; // retorna true

var color2 = "coral";
// gera um erro (color2 não é um objeto String)
"length" in color2;
```

### Usando `in` com propriedade removida ou undefined

Se você remover uma propriedade com o operador `delete` (en-US) , o operador `in` retorna `false` para essa propriedade.


```js
var mycar = { make: "Honda", model: "Accord", year: 1998 };
delete mycar.make;
"make" in mycar; // retorna false

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
delete trees[3];
3 in trees; // retorna false
```


Se você definir uma propriedade como `undefined`, mas não a remover, o operador `in` retorna `true` para essa propriedade.


```js
var mycar = { make: "Honda", model: "Accord", year: 1998 };
mycar.make = undefined;
"make" in mycar; // retorna true
```



```js
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
trees[3] = undefined;
3 in trees; // retorna true
```

### Propriedades herdadas

O operador `in` retorna `true` para propriedades que estão na cadeida de protótipo (prototype chain).


```js
"toString" in {}; // retorna true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-relational-operators |

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

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

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

* `for...in`
* `delete` (en-US)
* `Object.prototype.hasOwnProperty()`
* `Reflect.has()` (en-US)
* Enumerability and ownership of properties (en-US)
new.target
==========

A propriedade `new.target` permite que você detecte quando uma função ou construtor foi chamado utilizando o operador new. Em construtores e funções instaciadas com o operador new , `new.target` retorna a referência ao construtor ou função. Em chamadas normais de funções , `new.target` é `undefined`.

Sintaxe
-------
```

new.target
```

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

A sintaxe `new.target` consiste na palavra- chave `"new`", o ponto, e o nome da propriedade `"target"`. Normalmente "`new."` serve como um contexto para a propriedade de acesso, mas aqui `"new."` não é exatamente um objeto. Em chamadas de construtores, entretanto, `new.target` se refere ao construtor invocado pelo `new` e então "`new.`" se torna um contexto virtual.

`new.target` é uma propriedade meta que é disponibilizada para todas as funções. Em funções do tipo flecha `=>`, `new.target` se refere ao `new.target` em torno da função.

Exemplos
--------

### new.target em chamadas de Função

Em chamadas normais de função (diferente de chamadas a funções do tipo construtor), `new.target` é `undefined`. Isso permite que você detecte se a função foi chamada como um novo construtor.


```js
function Foo() {
  if (!new.target) throw "Foo() must be called with new";
  console.log("Foo instanciado com new");
}

Foo(); // throws "Foo() must be called with new"
new Foo(); // logs "Foo instanciado com new"
```

### new.target em Construtores

Em classes construtoras, `new.target` se refere ao construtor que foi diretamente invocado pelo `new`. Isto também é o caso se o construtor é uma classe pai e foi delegado pelo construtor de um filho.


```js
class A {
  constructor() {
    console.log(new.target.name);
  }
}

class B extends A {
  constructor() {
    super();
  }
}

var a = new A(); // logs "A"
var b = new B(); // logs "B"

class C {
  constructor() {
    console.log(new.target);
  }
}
class D extends C {
  constructor() {
    super();
  }
}

var c = new C(); // logs class C{constructor(){console.log(new.target);}}
var d = new D(); // logs class D extends C{constructor(){super();}}
```


A partir do exemplo acima das classes C e D, mostra que new.target aponta para a definição da classe na qual foi inicializada. Exemplo, quando D foi inicializado utilizando new, a definição da classe D foi impressa e similiarmente ao caso de C, a classe C foi impressa.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-built-in-function-objects |

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

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

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

* funções
* Classes
* `new`
* `this`