recursal/MDN huggingface dataset:
Desigualdade (!=)
=================

O operador de desigualdade (`!=`) verifica se seus dois operandos não são igual, retornando um resultado booleano. Ao contrário do operador de desigualdade estrito (en-US), ele tenta converter os tipos e comparar operandos de tipos diferentes.

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

Sintaxe
-------


```js
x != y
```

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

O operador de desigualdade verifica se seus operandos não são iguais. É a negação do operador de igualdade (en-US), de modo que as duas linhas a seguir sempre darão o mesmo resultado:


```js
x != y;

!(x == y);
```


Para obter detalhes do algoritmo de comparação, consulte a página do operador de igualdade (en-US).


```js
3 != "3"; // false
```


Para evitar isso e exigir que diferentes tipos sejam considerados diferentes, use o operador de desigualdade estrita (en-US) em vez disso:


```js
3 !== "3"; // true
```

Exemplos
--------

### Comparação sem conversão de tipo


```js
1 != 2; // true
"hello" != "hola"; // true

1 != 1; // false
"hello" != "hello"; // false
```

### Comparação com conversão de tipo


```js
"1" != 1; // false
1 != "1"; // false
0 != false; // false
0 != null; // true
0 != undefined; // true
0 != !!null; // false, veja o operador lógico NOT
0 != !!undefined; // false, veja o operador lógico NOT
null != undefined; // false

const number1 = new Number(3);
const number2 = new Number(3);
number1 != 3; // false
number1 != number2; // true
```

### Comparação de objetos


```js
const object1 = {
  key: "value",
};

const object2 = {
  key: "value",
};

console.log(object1 != object2); // true
console.log(object1 != object1); // false
```

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

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

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

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

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

* Operador de igualdade (en-US)
* Operador de igualdade estrito (en-US)
* Operador de desigualdade estrito (en-US)
Subtração (-)
=============

O operador de subtração (`-`) é o operador aritmético de subtração usado para encontrar a diferença entre dois números

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

Sintaxe
-------


```js
x - y
```

Exemplos
--------

### Subtração com números


```js
5 - 3; // 2
3 - 5; // -2
```

### Subtração com strings

> 
> **Warning:** Note que o JavaScript sempre tentará converter uma String em numero número
> 
> 
> 


```js
"foo" - 3; // NaN
"5" - 1; // 4
"10" - 5; // 5
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-subtraction-operator-minus |

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

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

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

* Operador de adição
* Operador de divisão
* Operador de multiplicação (en-US)
* Operador de restante (en-US)
* Operador de exponenciação
* Operador de incremento (en-US)
* Operador de decremento (en-US)
* Operador unário negation (en-US)
* Operador unário plus (en-US)
Divisão (/)
===========

O operador de divisão (`/`) produz o quociente de seus operandos onde o operando esquerdo é o dividendo e o operando direito é o divisor.

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

Sintaxe
-------


```js
x / y
```

Exemplos
--------

### Divisão básica


```js
1 / 2; // 0.5

Math.floor(3 / 2); // 1

1.0 / 2.0; // 0.5
```

### Divisão por zero


```js
2.0 / 0; // Infinito

2.0 / 0.0; // Infinito, porque 0.0 === 0

2.0 / -0.0; // -Infinito
```

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

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

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

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

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

* Operador de adição
* Operador de subtração
* Operador de multiplicação (en-US)
* Operador restante (en-US)
* Operador de exponenciação
* Operador de incremento (en-US)
* Operador de decremento (en-US)
* Operador de negação unário (en-US)
* Operador unário plus (en-US)
Expressão de função (function expression)
=========================================

A palavra-chave **`function`** pode ser usada para definir uma função dentro de uma expressão.

Sintaxe
-------
```

function [name]([param1[, param2[, ..., paramN]]]) {
   statements
}
```

### Parâmetros

`name`

O nome da função. Pode ser omitido, neste caso a função será anônima. O nome só é local em relação ao corpo da função.

`paramN`

O nome de um argumento a ser passado para a função.

`statements`

As declarações que compreendem o corpo da função.

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

Uma expressão de função (*function expression*) é muito similar e tem quase a mesma sintaxe de uma declaração de função (veja function statement para mais detalhes). A principal diferença entre uma expressão de função e a declaração de uma função é o nome da função (*function name*)*,* o qual pode ser omitido em expressões de funções para criar funções anônimas. Veja ainda o capítulo sobre funções para maiores informações.

Exemplos
--------

O exemplo a seguir define uma função sem nome e a atribui a x. A função retorna o quadrado de seu argumento:


```js
var x = function (y) {
  return y \* y;
};
```

### Expressão de função nomeada

Se você quer se referir à função atual dentro do corpo da função, você terá que criar uma expressão de função nomeada. Este nome será local apenas para o corpo (escopo) da função. Isto ainda evita o uso da propriedade não-padronizada `arguments.callee` (en-US).


```js
var math = {
  factorial: function factorial(n) {
    if (n <= 1) return 1;
    return n \* factorial(n - 1);
  },
};
```

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

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

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

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

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

* `Funções e Escopos de Funções` (en-US)
* `Função`
* `function statement`
* `function* statement`
* `function* expression`
* `GeneratorFunction` (en-US)VersãoCompatívelDesconhecidaVersãoCompatívelDesconhecida
Operador Vírgula
================

Sumário
-------

o **operador vírgula** avalia o valor de seus operandos (da esquerda para a direita) e retorna o valor do último operando.

Sintaxe
-------
```

expr1, expr2, expr3...
```

Parameters
----------

`expr1`, `expr2, expr3...`

Quaisquer expressões.

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

Você pode usar o operador vírgula quando desejar incluir múltiplas expressões em um lugar que requer uma única expressão. O uso mais comum desse operador é suprir múltiplos parâmetros em um loop `for`.

Exemplo
-------

Se `a` é um array de 2 dimensões com 10 elementos de um lado, o seguinte código usa o operador vírgula para incrementar duas variáveis mutuamente. Note que a vírgula na declaração `var` ***não*** é o operador vírgula, porque ele não existe dentro de uma expressão. Além disso, ela é uma caractere especial nas declarações `var` para combinar múltiplas delas em uma única. Embora praticamente a vírgula comporte-se quase que igualmente ao operador vírgula. O código imprime os valores dos elementos diagonais da matriz:


```js
for (var i = 0, j = 9; i <= 9; i++, j--)
  document.writeln("a[" + i + "][" + j + "] = " + a[i][j]);
```

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

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

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

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

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

* for loop
Expressão da função async
=========================

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since April 2017.

* Learn more
* See full compatibility
* Report feedback
A palavra chave async pode ser usado para definir funções async dentro das expressões.Você tambem pode definir funções async usando a declaração de função async.Sintaxe
-------
```

async function [nome]([parametro1[, parametro2[, ..., parametroN]]]) {
    declarações
}
```


Como no ES2015, você tambem pode usar arrow functions.

### Parâmetros

`nome`

O nome da função.Pode ser omitida, na qual a função se torna anonima . O nome é somente local para o corpo da função.

`parametroN`

O nome do argumento passado para a função.

`declarações`

As declarações que compoem o corpo da função .

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

Uma expressão `async function` é muito similar, e tem quase a mesma sintaxe de uma `declaração async function`. A principal diferença entre uma expressão `async function` e uma declaração `async function` é o *nome da função*, que pode ser omitido em expressões `async function` para criar *funções anônimas*. Uma expressão `async function` pode ser utilizada como um IIFE (Immediately Invoked Function Expression, em tradução livre: Expressão de Função Invocada Imediatamente) que roda assim que definido. Veja também o capítulo sobre funções para mais informações.

Exemplos
--------

### Exemplo simples


```js
function resolveAfter2Seconds(x) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(x);
    }, 2000);
  });
}

(async function (x) {
  // async function expression usada como uma IIFE
  var a = resolveAfter2Seconds(20);
  var b = resolveAfter2Seconds(30);
  return x + (await a) + (await b);
})(10).then((v) => {
  console.log(v); // imprime 60 após 2 segundo.
});

var add = async function (x) {
  // async function expression atribuída a uma variável
  var a = await resolveAfter2Seconds(20);
  var b = await resolveAfter2Seconds(30);
  return x + a + b;
};

add(10).then((v) => {
  console.log(v); // imprime 60 após 4 segundos.
});
```

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

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

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

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

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

* `async function`
* `AsyncFunction` object
* `await`
Expressão function\*
====================

A palavra-chave **`function*`** pode ser usada para definir uma função generator dentro de uma expressão.

Sintaxe
-------
```

function* [nome]([param1[, param2[, ..., paramN]]]) {
    declarações
}
```


`nome`

O nome da função. Pode ser omitido, no caso da função ser anônima. O nome é local apenas para o corpo da função.

`paramN`

O nome de um argumento para ser passado para a função. Uma função pode ter até 255 argumentos.

`declarações`

As declarações que compõem o corpo da função.

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

Uma expressão `function*` é muito similar e tem quase a mesma sintaxe que a `declaração function*`. A principal diferença entre uma expressão `function*` e a declaração `function*` é o *nome da função*, que pode ser omitido em expressões `function*` para criar funções *anônimas*. Veja também o capítulo sobre funções para mais informações.

Exemplos
--------

O exemplo a seguir define uma função generator e atribui à variável `x`. A função faz um yield do quadrado do seu argumento:


```js
var x = function\* (y) {
  yield y \* y;
};
```

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

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

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

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

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

* `function* statement`
* `GeneratorFunction` (en-US) object
* The Iterator protocol (en-US)
* `yield`
* `yield*`
* `Function` object
* `function statement`
* `function expression`
* `Functions and function scope` (en-US)
await
=====

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since April 2017.

* Learn more
* See full compatibility
* Report feedback
O operador `await` é utilizado para esperar por uma `Promise`. Ele pode ser usado apenas dentro de uma `async function`.

Sintaxe
-------
```

[rv] = await expressão;
```


`expressão`

Uma `Promise` ou qualquer valor para esperar uma resolução.

`rv`

Retorna um valor final da promise, ou o próprio valor se ele não for uma `Promise`.

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

A expressão `await` faz a execução de uma função `async` pausar, para esperar pelo retorno da `Promise`, e resume a execução da função `async` quando o valor da Promise é resolvido. Ele então retorna o valor final da Promise. Se esse valor não for uma `Promise`, ele é convertido para uma `Promise` resolvida.

Se a `Promise` for rejeitada, a expressão `await` invoca uma Exception com o valor rejeitado.

Exemplos
--------

Se uma `Promise` é passada para uma expressão `await`, ele espera pela sefinalização da `Promise` e retorna seu valor final.


```js
function resolveAfter2Seconds(x) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(x);
    }, 2000);
  });
}

async function f1() {
  var x = await resolveAfter2Seconds(10);
  console.log(x); // 10
}
f1();
```


Se o valor não for uma `Promise`, ele converte o valor para uma `Promise` resolvida, e espera por ele.


```js
async function f2() {
  var y = await 20;
  console.log(y); // 20
}
f2();
```


Se a `Promise` for rejeitada, o valor rejeitado é invocado em uma Exception.


```js
async function f3() {
  try {
    var z = await Promise.reject(30);
  } catch (e) {
    console.log(e); // 30
  }
}
f3();
```

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

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

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

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

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

* `async function`
* `async function expression`
* `AsyncFunction` object
null
====

Resumo
------

O valor `null` é um literal em JavaScript que representa um valor nulo ou "vazio" (p/ex: que aponta para um objeto inexistente). É um dos valores primitivos do JavaScript.

Sintaxe
-------
```

null
```

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

O valor `null` é um literal, e não uma propriedade do objeto global (como o `undefined` 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 `null` ou `undefined`, esteja ciente das diferenças entre o operador de igualdade (==) e o de igualdade estrita (===) (en-US) (em inglês). Uma conversão de tipos é realizada na operação de igualdade.


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

### Diferenças entre `null` e `undefined`


```js
typeof null; // object (bug no ECMAScript, deveria ser null - http://2ality.com/2013/10/typeof-null.html)
typeof undefined; // undefined
null === undefined; // falso
null == undefined; // verdadeiro
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-null-value |

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

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

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

* `undefined`
* `NaN`
Adição (+)
==========

O operador de adição (`+`) produz a soma de operandos numéricos ou concatenação de strings.

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

Sintaxe
-------


```js
x + y
```

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

O operador de adição está encarregado para duas operações distintas, adição numérica e concatenação de Strings. Ao avaliar, ele primeiro coage ambos os operandos para primitivos chamando a função do objeto `[@@toPrimitive]()`()(com "default" como dica), e os métodos valueOf(), e toString(), nessa ordem. Em seguida, são testados os tipos dos dois operandos:

* Se um lado é uma string, o outro operando também é convertido em uma string e eles são concatenados.
* Se ambos forem BigInts, a adição de BigInt será executada. Se um lado for um BigInt, mas o outro não, um `TypeError` será lançado.
* Caso contrário, ambos os lados são convertidos em números e a adição numérica é executada.

A concatenação de strings geralmente é considerada equivalente a literais de modelo ou String.prototype.concat(), mas não são. A adição força a expressão a uma chamada *primitive* , que chama `valueOf()` em prioridade; por outro lado, literais de modelo e `concact()` converte a expressão para uma string, que chama `toString()` em prioridade. Se a expressão tiver o método `@@toPrimitive`, a concatenação de strings o chama com "default" como dica, enquanto literais de modelo usam "string". Isso é importante para objetos que têm diferentes representações de string e primitivas — como Temporal, cujo método `valueOf()` lança.


```js
const t = Temporal.Now.instant();
"" + t; // Throws TypeError
`${t}`; // '2022-07-31T04:48:56.113918308Z'
"".concat(t); // '2022-07-31T04:48:56.113918308Z'
```


Você é aconselhado a não usar "" + x para executar a coerção de string.

Exemplos
--------

### Adição numérica


```js
// Number + Number -> adição
1 + 2; // 3
// Boolean + Number -> adição
true + 1; // 2
// Boolean + Boolean -> adição
false + false; // 0
```

### Concatenação de String


```js
// String + String -> concatenação
"foo" + "bar"; // "foobar"
// Number + String -> concatenação
5 + "foo"; // "5foo"
// String + Boolean -> concatenação
"foo" + false; // "foofalse"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-addition-operator-plus |

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

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

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

* Operador de subtração
* Operador de divisão
* Operador de multiplicação (en-US)
* Operador restante (en-US)
* Operador de exponenciação
* Operador de incremento (en-US)
* Operador de decremento (en-US)
* Operador de negação unário (en-US)
* Operador unário plus (en-US)
Operador Exponencial
====================

Sumário
-------

 O **operador de exponenciação (`**`)** retorna o resultado de elevar o primeiro operando à potência do
 segundo operando. É equivalente ao método `Math.pow`, exceto que também aceita números do tipo BigInt
 como operandos.

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

Sintaxe
-------


```js
x \*\* y;
```

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

O operador de exponenciação é associativo à direita: `a ** b ** c` é igual a `a ** (b ** c)`.

 Na maioria das linguagens, como PHP, Python e outras que têm um operador de exponenciação `(**)`,
 o operador de exponenciação é definido para ter uma precedência maior do que os operadores unários,
 como o unário `+` e unário `-`, mas há algumas exceções.
 Por exemplo, no Bash, o operador `**` é definido para ter uma precedência menor do que os operadores unários.

 Em JavaScript, é impossível escrever uma expressão de exponenciação ambígua.
 Ou seja, você não pode colocar um operador unário (`+ / - / ~ /! / delete / void / typeof`)
 imediatamente antes do número base; fazer isso causará um SyntaxError.


```js
    -2 \*\* 2;
    // // 4 no Bash, -4 em outros idiomas.
    // Isso é inválido em JavaScript, pois a operação é ambígua.

    -(2 \*\* 2);
    // -4 em JavaScript e a intenção do autor não é ambígua.
```


 Observe que algumas linguagens de programação usam o símbolo circunflexo `^` para exponenciação,
 mas o JavaScript usa esse símbolo para o operador `XOR lógico bit a bit`.

Exemplos
--------

### Exponenciação básica


```js
2 \*\* 3; // 8
3 \*\* 2; // 9
3 \*\* 2.5; // 15.588457268119896
10 \*\* -1; // 0.1
NaN \*\* 2; // NaN
```

### Associatividade


```js
2 \*\* 3 \*\* 2; // 512
2 \*\* (3 \*\* 2); // 512
(2 \*\* 3) \*\* 2; // 64
```

### Uso com operadores unários

Para inverter o sinal do resultado de uma expressão de exponenciação:


```js
-(2 \*\* 2); // -4
```


Para forçar a base de uma expressão de exponenciação a ser um número negativo:


```js
(-2) \*\* 2; // 4
```

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

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

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

* Operador condicional if
* Operador de adição
* Operador de subtração
* Operador de multiplicação (en-US)
* Operador de divisão
* Operador de resto (en-US)
* Operador de incremento (en-US)
* Operador de decremento (en-US)
* Operador de negação unária (en-US)
* Operador de adição unária (en-US)
:nth-of-type()
==============

A pseudo-classe CSS **`:nth-of-type()`** corresponde a um ou mais elementos de um dado tipo, baseado em sua posição entre um grupo de irmãos.


```css
/\* Seleciona cada quarto elemento <p>
 entre qualquer grupo de irmãos \*/
p:nth-of-type(4n) {
  color: lime;
}
```

Sintaxe
-------

A pseudo-classe `nth-of-type` é especificada com um único argumento, o qual representa o padrão para a correspondência dos elementos.

Veja `:nth-child` para uma explicação mais detalhada de sua sintaxe.

### Sintaxe formal

Error: could not find syntax for this itemExemplos
--------

### Exemplo básico

#### HTML


```html
<div>
  <div>Este elemento não é contado.</div>
  <p>1º parágrafo.</p>
  <p>2º parágrafo.</p>
  <div>Este elemento não é contado.</div>
  <p>3º parágrafo.</p>
  <p>4º parágrafo.</p>
</div>
```


#### CSS


```css
/\* Parágrafos ímpares \*/
p:nth-of-type(2n + 1) {
  color: red;
}

/\* Parágrafos pares \*/
p:nth-of-type(2n) {
  color: blue;
}

/\* Primeiro parágrafo \*/
p:nth-of-type(1) {
  font-weight: bold;
}
```


#### Resultado

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

| Specification |
| --- |
| Selectors Level 4 # nth-of-type-pseudo |

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

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

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

* `:nth-child`, `:nth-last-of-type` (en-US)