Bitwise AND (&) - JavaScript

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

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

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`


Desigualdade (!=) - JavaScript

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 (-) - JavaScript

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 (/) - JavaScript

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) - JavaScript

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

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


Assessores de propriedade - JavaScript

Assessores de propriedade
=========================

Os assessores de propriedade fornecem acesso as propriedades de um objeto usando a notação de ponto ou a notação de colchetes.

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

Sintaxe
-------
```

object.property
object["property"]
```

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

Pode-se pensar em um objeto como uma matriz associativa (a.k.a. *map*, *dictionary*, *hash*, *lookup table*). As chaves nesta matriz são os nomes das propriedades dos objetos. É típico quando se fala de propriedades de um objeto para fazer uma distinção entre propriedades e métodos. No entanto, a distinção entre propriedade/método é um pouco mais do que convenção. Um método é simplesmente uma propriedade que pode ser chamada, por exemplo, se tiver uma referência a uma instância de Function como seu valor.

Há duas maneira de acessar propriedades: notação de ponto ou a notação de colchetes.

### Notação de ponto

```js
get = object.property;
object.property = set;
```

Neste código, a propriedade deve ser um identificador válido, i.e. uma sequência de carácteres alfanuméricos, incluíndo também o underline ("`_`") e o cifrão ("`$`"), não pode começar com um número. Por exemplo, `object.$1` é valido, enquanto `object.1` não é.

```js
document.createElement("pre");
```

Aqui, o método chamado "createElement" é recuperado do documento e é chamado.

Se você usar um método para um literal numérico e o literal numérico não tem expoente e nenhum ponto decimal, deixar de espaço em branco antes do ponto que precede a chamada de método para evitar que o ponto seja interpretado como um ponto decimal.

```js
(77).toExponential();
// ou
(77).toExponential();
// ou
(77).toExponential();
// ou
(77).toExponential();
// ou
(77.0).toExponential();
// porque 77. === 77.0, sem ambiguidade :p
```

### Notação de colchete

```js
get = object[property_name];
object[property_name] = set;
```

`property_name` é uma string. A string não precisa ser um identificador válido; pode ser qualquer valor, e.g. "1foo", "!bar!", ou até " " (um espaço).

```js
document["createElement"]("pre");
```

Isto faz exatamente a mesma coisa que o exemplo anterior.

Um espaço antes da notação de colchete é permitido.

```js
document["createElement"]("pre");
```

### Nomes de propriedades

Nomes de propriedades devem ser strings. Isto significa que objetos não-string não podem ser usados como chave em um objeto. Qualquer objeto não-string, incluindo um número, é estereotipado como uma string pelo método toString.

```js
var object = {};
object["1"] = "value";
console.log(object[1]);
```

A saída é "value", desde 1 é estereotipado como '1'.

```js
var foo = { unique\_prop: 1 },
  bar = { unique\_prop: 2 },
  object = {};
object[foo] = "value";
console.log(object[bar]);
```

A saída também é "value", já que ambos foo e bar são convertidos para a mesma string. No motor de Javascript SpiderMonkey, esta string poderia ser "['object Object']".

### Ligação de método

Um método não é limitado ao objeto de quem é metodo. Especificamente, `this` não é fixo em um método, i.e., `this` não se referece necessariamente ao objeto contendo o método. Ao invés disso, `this` é "passado" pela função call. Veja method binding.

### Nota sobre `eval`

Novatos em JavaScript comentem muitas vezes o erro de usar eval onde a notação de colchete pode ser usada no lugar. Por exemplo, a sintaxe a seguir é muitas vezes vista em muitos scripts.

```js
x = eval("document.forms.form\_name.elements." + strFormControl + ".value");
```

`eval` é lento e deve ser evitado sempre que possível. Também, `strFormControl` would have to hold an identifier, which is not required for names and IDs of form controls. It is better to use bracket notation instead:

```js
x = document.forms["form\_name"].elements[strFormControl].value;
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-property-accessors |

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

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

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

* `Object`
* `Object/defineProperty`


Expressão da função async - JavaScript

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* - JavaScript

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

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


yield - JavaScript

yield
=====

A palavra-chave `yield` é usada para pausar e resumir uma generator function (`function*` or generator function legada (en-US)).

Sintaxe
-------
```

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

`expressão`

Define o valor que retorna de uma generator function via o protocolo iterator. Se omitido, será retornado `undefined`.

`rv`

Retorna o valor opcional passado para o metódo `next()` do generator e resume sua execução.

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

A palavra-chave `yield` pausa a execução de uma generator function e o valor da expressão em frente a palavra-chave `yield` é retornado para a chamada do generator. Ele pode ser considerado uma versão da palavra-chave `return` para o generator.

A palavra-chave `yield` atualmente retorna um objeto do tipo `IteratorResult` com duas propriedades, `value` e `done`. A propriedade `value` é o resultado da avaliação da expressão `yield`, e `done` é `false`, indicando que a generator function não foi totalmente completada.

Uma vez pausado em uma expressão `yield`, a execução do código do generator permanece pausado até a próxima chamada do métod `next()`. Cada vez que o método `next()` do generator é chamado, o generator resume a execução e roda até atingir um dos seguintes estados:

* Um `yield`, que causa a pausa do generator novamente e retorna seu novo valor. Na próxima vez que `next()` for chamado, a execução resumirá com a declaração imediamente após `yield`.
* `throw` é usado para invocar uma exception à partir do generator. Isso irá parar completamente a execução do generator, e a execução resume para onde foi chamado o generator normalmente no caso que uma exception é invocada.
* O final de uma generator function é atingido; nesse caso, a execução do generator termina e um `IteratorResult` é retornado para onde o generator foi chamado no qual o `value` é `undefined` e `done` é `true`.
* Uma declaração `return` é atingida. Nesse caso, a execução do generator termina e um `IteratorResult` é retornado para onde o generator foi chamado no qual o `value` é o valor especificado pela declaração `return` statement e `done` é `true`.

Se um valor opcional é passado para o método `next()` do generator, esse valor se torna o valor retornado pela operação `yield` atual do generator.

Entre o caminho de código do generator, os seus operadores `yield`, e a habilidade de especificar um novo valor inicial passando isso para o `Generator.prototype.next()` (en-US), generators oferecem um poder e controle enormes

Exemplos
--------

O código seguinte é a declaração de um exemplo de uma generator function.

```js
function\* foo() {
  var index = 0;
  while (index <= 2) yield index++;
}
```

Uma vez que a generator function é definida, isso pode ser usada para construir um iterator como mostrado a seguir:

```js
var iterator = foo();
console.log(iterator.next()); // { value: 0, done: false }
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
```

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

| Specification |
| --- |
| ECMAScript Language Specification # prod-YieldExpression |

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

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

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

* A partir do Gecko 29, uma generator function completada não invoca mais um `TypeError` "generator has already finished". Ao invés, isso retorna um objeto `IteratorResult` como `{ value: undefined, done: true }` (Erro do Firefox 958951).
* A partir do Gecko 33, a análise (parsing) de uma expressão `yield` foi atualizada para se conformar com a especificação do ES2015 (Erro do Firefox 981599):
    + A expressão após a palavra-chave `yield` é opcional e omitir isso não invoca mais um `SyntaxError` (en-US): `function* foo() { yield; }`
Veja também
-----------

* O protocolo Iterator (en-US)
* `function*`
* `function* expression`
* `yield*`


this - JavaScript

this
====

A palavra-chave **`this`** comporta-se um pouco diferente em Javascript se comparado com outras linguagens. Também possui algumas diferenças entre o modo estrito e o modo não estrito.

Em muitos casos, o valor `this` é determinado pela forma como a função é chamada. Ele não pode ser assinado durante a execução, e isso pode ser diferente a cada vez que a função é chamada. ES5 introduziu o método `bind` para estabelecer o valor `this` da função, independentemente de como ela seja chamada, e ECMAScript 2015 introduziu o arrow functions, cujo `this` é lexicalmente delimitado (o valor `this` é estabelecido segundo o escopo de execução no qual está inserido).

Sintaxe
-------
```

this
```

Contexto global
---------------

No contexto de execução global (fora de qualquer função), `this` refere-se ao objeto global, seja em modo estrito ou não.

```js
console.log(this.document === document); // true

// Em navegadores web, o objeto window é também o objeto global:
console.log(this === window); // true

this.a = 37;
console.log(window.a); // 37
```

Contexto de função
------------------

Dentro de uma função, o valor de `this` depende de como a função é chamada.

### Chamada simples

Como o código a seguir não está no modo estrito, o valor de `this` não é definido pela chamada. Por padrão, `this` será o objeto global que no navegador é o `window`.

```js
function f1() {
  return this;
}

// No navegador
f1() === window; // true
```

Em modo estrito, o valor de `this` permanece seja qual for o definido ao entrar no contexto de execução, assim, no caso a seguir, `this` por padrão será indefinido (`undefined`):

```js
function f2() {
  "use strict"; // assume modo estrito
  return this;
}

f2() === undefined; // true
```

Portanto, em modo estrito, se `this` não for definido durante o contexto da execução, ele permanecerá indefinido (`undefined`).

**Nota:** No segundo exemplo, `this` deveria ser `undefined`, porque `f2` foi chamada diretamente e não como um método ou popriedade de um objeto (ou seja, `window.f2()`). Esta característica não foi implementada em alguns navegadores quando começaram a dar suporte ao strict mode (en-US) (modo estrito). Como resultado, eles incorretamente retornavam o objeto `window`.

### Funções Arrow (seta)

Nas arrow functions (funções seta), o `this` é definido lexicalmente, isto é, seu valor é definido pelo contexto de execução onde está inserido. Em um código global, this assume o objeto global:

```js
var globalObject = this;
var foo = () => this;
console.log(foo() === globalObject); // true
```

Não importa como `foo` é chamado, o `this` continuará como o objeto global. Isto continua verdadeiro mesmo se chamá-lo como método de um determinado objeto (o que normalmente definiria seu this ao objeto), com `call` ou `apply` ou `bind` é usado:

```js
// Chama como um método de um objeto
var obj = { foo: foo };
console.log(obj.foo() === globalObject); // true

// Tentativa de definir this usando call
console.log(foo.call(obj) === globalObject); // true

// Tentantiva de definir this usando bind
foo = foo.bind(obj);
console.log(foo() === globalObject); // true
```

Não importa como for, o this do foo mantém o valor que recebeu quando foi criado (no exemplo acima, o objeto global). O mesmo se aplica para funções arrow criadas dentro de outras funções: seus this são definidos em seus respectivos contextos de execução.

```js
// Cria obj com um método bar que retorna uma função que
// retorna seu this. A função retornada é criada como
// uma função arrow, para que seu this esteja permanentemente
// ligado ao this da função que a envolve. O valor de bar pode ser // definido na chamada, que por sua vez define o valor da função
// retornada.
var obj = {
  bar: function () {
    var x = () => this;
    return x;
  },
};

// Chama bar como método de obj, configurando seu this como obj
// Assina à variável fn uma referência para a função retornada
var fn = obj.bar();

// Chamar fn, sem definir this, por padrão, referenciaria
// ao objeto global ou undefined em modo estrito (strict mode)
console.log(fn() === obj); // true
```

No exemplo acima, a função (chamemos função anônima A) atribuída a obj.bar retorna outra função (chamemos função anônima B) que é criada como uma função arrow (seta). Como resultado, o this da função B é permanentemente definido como o this de obj.bar (função A) quando chamado. Quando a função retornada (função B) é chamada, seu this sempre será aquele que foi definido inicialmente. No exemplo de código acima, o this da função B é definido com o this da função A, que é obj, por isso permanece definido para obj, mesmo quando chamado de uma maneira que normalmente definiria seu this como undefined ou como objeto global (ou qualquer outro método, como naquele exemplo anterior de contexto de execução global).

### Como método de um objeto

Quando uma função é chamada como um método de um objeto, seu this toma o valor do objeto pertencente ao método chamado.

No exemplo a seguir, quando `o.f()` é invocado, o this dentro da função é vinculado ao objeto o.

```js
var o = {
  prop: 37,
  f: function () {
    return this.prop;
  },
};

console.log(o.f()); // logs 37
```

Observe que esse comportamento não é afetado mesmo pela forma como (ou onde) a função foi definida. No exemplo anterior, nós definimos a função in-line (em linha) como o membro f durante a definição de o. No entanto, poderíamos ter apenas facilmente definido a função primeiro e depois anexado a o.f. Fazendo isso resulta no mesmo comportamento:

```js
var o = { prop: 37 };

function independent() {
  return this.prop;
}

o.f = independent;

console.log(o.f()); // registra 37
```

Isto demonstra que é importante apenas que a função foi chamada a partir do membro f de o.

Da mesma forma, a vinculação de this só é afetada pela referência do membro mais imediato. No exemplo a seguir, quando invocamos a função, podemos chamá-la como um método g do objeto o.b. Desta vez, durante a execução, o this dentro da função irá se referir a o.b. O fato do objeto ser um membro de o não tem qualquer consequência; a referência mais imediata é tudo que importa.

```js
o.b = { g: independent, prop: 42 };
console.log(o.b.g()); // registra 42
```

#### `this` na cadeia de protótipos (prototype chain) do objeto

A mesma noção vale para métodos definidos em algum lugar da cadeia de protótipos do objeto. Se o método está na cadeia de protótipo de um objeto, this refere-se ao objeto que é proprietário do método chamado, como se o método estivesse no objeto.

```js
var o = {
  f: function () {
    return this.a + this.b;
  },
};
var p = Object.create(o);
p.a = 1;
p.b = 4;

console.log(p.f()); // 5
```

Neste exemplo, o objeto atribuído à variável p não tem sua própria propriedade f, ele o herda de seu protótipo. Mas não importa que a procura por f finalmente encontre um membro com esse nome em o; a procura começou como uma referência para a p.f, portanto o this dentro da função recebe o valor do objeto referido como p. Isto é, já que f é chamado como um método de p, seu this refere-se a p. Este é um recurso interessante de herança prototípica do JavaScript.

#### `this` com seletores (getter) ou modificadores (setter)

Mais uma vez, a mesma noção se aplica quando uma função é chamada a partir de um getter ou setter. A função usada como getter ou setter tem seu this ligado ao objeto do qual a propriedade está sendo modificada ou selecionada.

```js
function modulus() {
  return Math.sqrt(this.re \* this.re + this.im \* this.im);
}

var o = {
  re: 1,
  im: -1,
  get phase() {
    return Math.atan2(this.im, this.re);
  },
};

Object.defineProperty(o, "modulus", {
  get: modulus,
  enumerable: true,
  configurable: true,
});

console.log(o.phase, o.modulus); // logs -0.78 1.4142
```

### Como um construtor (constructor)

Quando a função é usada com um construtor (com a palavra chave `new`), seu this é vinculado ao novo objeto sendo contruído.

Nota: enquanto o padrão para um construtor é retornar o objeto referenciado por this, ele pode retornar, ao invés, algum outro objeto (se o valor de retorno não é um objeto, então o objeto this é retornado).

```js
/\*
 \* Contrutores funcionam da seguinte forma:
 \*
 \* function MyConstructor(){
 \* // O código do corpo da função vai aqui.
 \* // Criam-se propriedades sobre |this| como
 \* // desejado, assinando-os. Ex.,
 \* this.fum = "nom";
 \* // etc...
 \*
 \* // Se a função tem uma instrução que
 \* // retorna um objeto, esse objeto será o
 \* // resultado da expressão |new|. Caso contrário,
 \* // o resultado da expressão é o objeto
 \* // atualmente vinculado a |this|
 \* // (i.e., o caso mais comumente visto).
 \* }
 \*/

function C() {
  this.a = 37;
}

var o = new C();
console.log(o.a); // logs 37

function C2() {
  this.a = 37;
  return { a: 38 };
}

o = new C2();
console.log(o.a); // registra 38
```

No último exemplo (C2), porque um objeto foi retornado durante a construção, o novo objeto que this foi vinculado simplesmente é descartado. (Isso essencialmente faz da expressão "this.a = 37;" código morto. Não é exatamente morto, pois ele é executado, mas ele pode ser eliminado sem efeitos colaterais.)

### `call` e `apply`

Quando uma função usa a palavra-chave this em seu corpo, o seu valor pode ser vinculado a um determinado objeto na chamada utilizando os métodos `call` or `apply` que todas as funções herdam de Function.prototype.

```js
function add(c, d) {
  return this.a + this.b + c + d;
}

var o = { a: 1, b: 3 };

// O primeiro parâmetro é o objeto a usar como
// 'this'; subsequentes parâmetros são passados como
// argumentos na função chamada
add.call(o, 5, 7); // 1 + 3 + 5 + 7 = 16

// O primeiro parâmetro é o objeto a usar como
// 'this', o segundo é um arranjo (array) cujos
// membros são usados como argumentos na função chamada
add.apply(o, [10, 20]); // 1 + 3 + 10 + 20 = 34
```

Observe que, com call e apply, se o valor passado como this não for um objeto, será feita uma tentativa de convertê-lo em um objeto usando a operação interna ToObject. Portanto, se o valor passado é um primitivo como 7 ou 'foo', ele será convertido para um objeto usando o construtor relacionado, de modo que o número primitivo 7 é convertido em um objeto, como realizado por new Number(7), e a cadeia de caracteres 'foo' em um objeto, como realizado por new String(' foo '), por exemplo.

```js
function bar() {
  console.log(Object.prototype.toString.call(this));
}

bar.call(7); // [object Number]
```

### O método `bind`

ECMAScript 5 introduziu `Function.prototype.bind`. Chamando f.bind(algumObjeto) cria-se uma nova função com o mesmo corpo e escopo que f, mas onde o this ocorrer na função original, na nova função ele será permanentemente ligado ao primeiro argumento de bind, independentemente de como a função esteja sendo usada.

```js
function f(){
  return this.a;
}

var g = f.bind({a:"azerty"});
console.log(g()); // azerty

var h = g.bind({a: 'yoo'}); // bind só funciona uma vez!
console.log.(h()); // azerty

var o = {a:37, f:f, g:g, h: h};
console.log(o.a, o.f(), o.g(), o.h()); // 37, 37, azerty, azerty
```

### Como um manipulador de eventos DOM

Quando uma função é usada como um manipulador de eventos, seu this está definido para o elemento do evento a partir do qual foi disparado (alguns navegadores não seguem essa convenção para os listeners adicionados dinamicamente com métodos que não sejam addEventListener).

```js
// Quando chamado como listener, transforma o elemento blue
// relacionado
function bluify(e) {
  // sempre true
  console.log(this === e.currentTarget);
  // true quando currentTarget e target são o mesmo objeto
  console.log(this === e.target);
  this.style.backgroundColor = "#A5D9F3";
}

// Obtém uma lista de todo elemento no documento
var elements = document.getElementsByTagName("\*");

// Adiciona bluify com um click listener (escutador de click)
// para que quando o elemento seja clicado se torne azul
for (var i = 0; i < elements.length; i++) {
  elements[i].addEventListener("click", bluify, false);
}
```

### Em um manipulador de evento in-line (em linha)

Quando o código é chamado de um manipulador de evento in-line, seu this está definido para o elemento DOM em que o listener é colocado:

```js
<button onclick="alert(this.tagName.toLowerCase());">Show this</button>
```

O alerta acima mostra button. Note, porém, que apenas o código exterior tem um this definido desta maneira:

```js
<button onclick="alert((function(){return this}()));">Show inner this</button>
```

Neste caso, o this da função interior não está definido, portanto ele retorna o objeto global/objeto window (ou seja, o objeto padrão no modo não-estrito onde this não está definido pela chamada).

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-this-keyword |

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

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

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

* Strict mode (en-US)
* All this, um artigo sobre this em diferentes contextos


null - JavaScript

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`


Encadeamento opcional - JavaScript

Encadeamento opcional
=====================

O operador de **encadeamento opcional** **`?.`** permite a leitura do valor de uma propriedade localizada internamente em uma cadeia de objetos conectados, sem que a validação de cada referência da cadeia seja expressivamente realizada.

O operador **`?.`** funciona de maneira similar ao operador `.` de encadeamento, exceto que, ao invés de causar um erro se a referência é nullish (en-US) (`null` ou `undefined`), a expressão sofre um "curto-circuito" e retorna com um valor de `undefined`. Quando utilizado com uma chamada de função, retorna `undefined` se a função executada não existir.

Isso resulta em expressões mais curtas e simples ao acessar propriedades encadeadas quando a possibilidade de uma referência ser inexistente. Isso também pode auxiliar ao explorar o conteúdo de um objeto quando não existe garantia da existência de determinadas propriedades obrigatórias.

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

Sintaxe
-------
```

obj.val?.prop
obj.val?.[expr]
obj.arr?.[index]
obj.func?.(args)
```

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

O operador de encadeamento opcional provê uma forma de simplificar o acesso a valores através de objetos conectados, quando é possível que uma referência ou função possa ser `undefined` ou `null`.

Por exemplo, considere um objeto `obj` que possui uma estrutura aninhada. Sem o encadeamento opcional, verificar proriedades profundamente aninhadas requer uma validação de referências intermediárias, algo como:

```js
let nestedProp = obj.first && obj.first.second;
```

O valor de `obj.first` é confirmadamente não-`null` (e não-`undefined`) antes de acessar o valor de `obj.first.second`. Isso previne o erro que ocorreria se você simplesmente acessasse `obj.first.second` diretamente sem testar `obj.first`.

Com o operador de encadeamento opcional (`?.`), entretanto, você não precisa explicitamente testar e aplicar curto-circuito baseado no estado de `obj.first` antes de tentar acessar `obj.first.second`:

```js
let nestedProp = obj.first?.second;
```

Ao utilizar o operador `?.` ao invés de apenas `.`, o JavaScript sabe que deve implicitamente checar e ter certeza que `obj.first` não é `null` ou `undefined` antes de tentar acessar `obj.first.second`. Se `obj.first` é `null` ou `undefined`, a expressão automaticamente sofrerá curto-circuito, retornando `undefined`.

Isso é equivalente ao seguinte, exceto que a variável temporária, de fato, não é criada:

```js
let temp = obj.first;
let nestedProp = temp === null || temp === undefined ? undefined : temp.second;
```

### Encadeamento opcional com chamadas de funções

Você pode usar o encadeamento opcional ao tentar chamar um método que pode não existir. Isso pode auxiliar, por exemplo, ao utilizar uma API em que o método está indisponível, seja pela época da implementação ou por causa de uma funcionalidade que ainda não está disponível no dispositivo do usuário.

Usar encadeamento opcional com chamadas de função faz com que a expressão automaticamente retorne `undefined` ao invés de lançar uma exceção se o método não é encontrado:

```js
let result = someInterface.customMethod?.();
```

**Nota:** Se existe uma propriedade com tal nome e que não é uma função, usando `?.` ainda lançará a exceção `TypeError` (`x.y is not a function`).

#### Lidando com callbacks opcionais ou manipuladores de eventos

Se você usa callbacks ou consulta métodos de objetos com atribuição via desestruturação, você pode ter valores não-existentes que você não conseguirá chamar como funções, a menos que você tenha testado sua existência. Usando `?.`, você pode evitar esse teste extra:

```js
// Escrito como ES2019
function doSomething(onContent, onError) {
  try {
    // ... faz algo com os dados
  } catch (err) {
    if (onError) {
      // teste se onError realmente existe
      onError(err.message);
    }
  }
}
```

```js
// Usando encadeamento opcional com chamadas de função
function doSomething(onContent, onError) {
  try {
    // ... faz algo com os dados
  } catch (err) {
    onError?.(err.message); // Nenhuma exceção se onError for undefined
  }
}
```

### Encadeamento opcional com expressões

Você também pode usar o operador de encadeamento opcional ao acessar propriedades com uma expressão usando assessores de propriedade:

```js
let nestedProp = obj?.["prop" + "Name"];
```

### Encadeamento opcional não válido no lado esquerdo de uma atribuição

```js
let object = {};
object?.property = 1; // Uncaught SyntaxError: Invalid left-hand side in assignment
```

### Acesso a item de Array com encadeamento opcional

```js
let arrayItem = arr?.[42];
```

Exemplos
--------

### Exemplo básico

Esse exemplo busca plo valor da propriedade `name` para o membro `bar` em um map quando não existe tal membro. Portanto, o resultado é `undefined`.

```js
let myMap = new Map();
myMap.set("foo", { name: "baz", desc: "inga" });

let nameBar = myMap.get("bar")?.name;
```

### Avaliação com curto-circuito

Ao usar o encadeamento opcional com expressões, se o operador do lado esquerdo é `null` ou `undefined`, a expressão não será avaliada. Por exemplo:

```js
let potentiallyNullObj = null;
let x = 0;
let prop = potentiallyNullObj?.[x++];

console.log(x); // 0 já que x não foi incrementado
```

### Empilhando o operator de encadeamento opcional

Com estruturadas aninhadas, é possível usar encadeamento opcional múltiplas vezes:

```js
let customer = {
  name: "Carl",
  details: {
    age: 82,
    location: "Paradise Falls", // endereço detalhado é desconhecido
  },
};
let customerCity = customer.details?.address?.city;

// … isso também funcional com encadeamento opcional em chamada de função
let duration = vacations.trip?.getTime?.();
```

### Combinando com o operador de coalescência nula (nullish coalescing)

O operador de coalescência nula pode ser usado após o encadeamento opcional, para construir um valor padrão quando nada é encontrado:

```js
let customer = {
  name: "Carl",
  details: { age: 82 },
};
const customerCity = customer?.city ?? "Cidade desconhecida";
console.log(customerCity); // Cidade desconhecida
```

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

| Specification | Status | Comment |
| --- | --- | --- |
| Proposal for the "optional chaining" operator | Stage 4 |  |

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

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

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

* O Nullish Coalescing Operator
* TC39 proposals


instanceof - JavaScript

instanceof
==========

O operador **`instanceof`** testa se um objeto tem, em seu prototype, a função construtora.Experimente
-----------

Sintaxe
-------
```

objeto instanceof construtor
```

### Parâmetros

`objeto`

O objeto a ser testado

`construtor`

Função construtora a ser verificada

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

O operador instanceof testa a presença da função construtora no prototype do objeto.

```js
// definindo construtores
function C() {}
function D() {}

var o = new C();

// true, porque: Object.getPrototypeOf(o) === C.prototype
o instanceof C;

// false, porque D.prototype não está no prototype desse objeto
o instanceof D;

o instanceof Object; // true, porque:
C.prototype instanceof Object; // true

C.prototype = {};
var o2 = new C();

o2 instanceof C; // true

// false, porque C.prototype não está mais no prototype desse objeto
o instanceof C;

D.prototype = new C(); // use inheritance
var o3 = new D();
o3 instanceof D; // true
o3 instanceof C; // true
```

Note que o resultado do instanceof pode alterar quando a gente altera o prototype da função construtora. No entanto, a gente não pode alterar (por padrão) o prototype do objeto. Só é possível fazer essa alteração usando a pseudopropriedade \_\_proto\_\_.

### `instanceof` and multiple context (e.g. frames or windows)

Different scope have different execution environments. This means that they have different built-ins (different global object, different constructors, etc.). This may result in unexpected results. For instance, `[] instanceof window.frames[0].Array` will return `false`, because `Array.prototype !== window.frames[0].Array` and arrays inherit from the former. This may not make sense at first but when you start dealing with multiple frames or windows in your script and pass objects from one context to another via functions, this will be a valid and strong issue. For instance, you can securely check if a given object is in fact an Array using `Array.isArray(myObj)`

**Nota:** **Note for Mozilla developers:**
 In code using XPCOM `instanceof` has special effect: `obj instanceof xpcomInterface` (e.g. `Components.interfaces.nsIFile`) calls `obj.QueryInterface(xpcomInterface)` and returns `true` if QueryInterface succeeded. A side effect of such call is that you can use *`xpcomInterface`*'s properties on `obj` after a successful `instanceof` test. Unlike standard JavaScript globals, the test `obj instanceof xpcomInterface`works as expected even if `obj` is from a different scope.

Examples
--------

### Demonstrating that `String` and `Date` are of type `Object` and exceptional cases

The following code uses `instanceof` to demonstrate that `String` and `Date` objects are also of type `Object` (they are derived from `Object`).

However, objects created with the object literal notation are an exception here: Although the prototype is undefined, `instanceof Object` returns `true`.

```js
var simpleStr = "This is a simple string";
var myString = new String();
var newStr = new String("String created with constructor");
var myDate = new Date();
var myObj = {};

simpleStr instanceof String; // returns false, checks the prototype chain, finds undefined
myString instanceof String; // returns true
newStr instanceof String; // returns true
myString instanceof Object; // returns true

myObj instanceof Object; // returns true, despite an undefined prototype
({}) instanceof Object; // returns true, same case as above

myString instanceof Date; // returns false

myDate instanceof Date; // returns true
myDate instanceof Object; // returns true
myDate instanceof String; // returns false
```

### Demonstrating that `mycar` is of type `Car` and type `Object`

The following code creates an object type `Car` and an instance of that object type, `mycar`. The `instanceof` operator demonstrates that the `mycar` object is of type `Car` and of type `Object`.

```js
function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}
var mycar = new Car("Honda", "Accord", 1998);
var a = mycar instanceof Car; // retorna true
var b = mycar instanceof Object; // 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.

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

* `typeof`


Precedência de Operadores - JavaScript

Precedência de Operadores
=========================

Resumo
------

A precedência de operadores determina a ordem em que os operadores são processados. Operadores com maior precedência são processados primeiro.

Um exemplo simples:
```

3 + 4 * 5 // returns 23
```

O operador de multiplicação ("`*`") tem maior precedência que o operador de adição ("`+`") e por isso será executado primeiro.

Associatividade
---------------

Associatividade determina a ordem em que operadores da mesma precedência são processados. Por exemplo, considere a expressão:
```

a OP b OP c
```

Associatividade à esquerda (esquerda para direita) significa que a expressão será processada como `(a OP b) OP c`, enquanto associatividade à direita (direita para esquerda) significa que será interpretada como `a OP (b OP c)`. Operadores de atribuição são associativos à direita, então você pode escrever:
```

a = b = 5; 5 = b = a
```

com o resultado esperado que `a` e `b` tenham o valor 5. Isto é porque o operador de atribuição retorna o valor que ele atribuiu. Primeiro, `b` é definido com o valor 5. Então `a` é definido com o valor de `b`.

Tabela
------

A tabela seguinte está ordenada da mais alta (20) para a mais baixa (0) precedência.

| Precedência | Tipo do Operador | Associatividade | Operadores individuais |
| --- | --- | --- | --- |
| 20 | Agrupamento | n/a | `( … )` |
| 19 | Acesso a Membro | esquerda para direita | `… . …` |
| Acesso a Membro Computado | esquerda para direita | `… [ … ]` |
| new (en-US)
 (com lista de argumentos)
  | n/a | `new … ( … )` |
| 18 | Chamada a Função | esquerda para direita | `… ( … )` |
| new
 (sem lista de argumentos)
  | direita para esquerda | `new …` |
| 17 | Incremento Pós-fixado (en-US) | n/a | `… ++` |
| Decremento Pós-fixado (en-US) | n/a | `… --` |
| 16 | NÃO lógico (en-US) | direita para esquerda | `! …` |
| NÃO bit-a-bit (en-US) | direita para esquerda | `~ …` |
| Positivo Unário (en-US) | direita para esquerda | `+ …` |
| Negativo Unário (en-US) | direita para esquerda | `- …` |
| Incremento Pré-fixado (en-US) | direita para esquerda | `++ …` |
| Decremento Pré-fixado (en-US) | direita para esquerda | `-- …` |
| typeof | direita para esquerda | `typeof …` |
| void | direita para esquerda | `void …` |
| delete (en-US) | direita para esquerda | `delete …` |
| 15 | Exponenciação | direita para esquerda | … \*\* … |
| 14 | Multiplicação (en-US) | esquerda para direita | `… * …` |
| Divisão (en-US) | esquerda para direita | `… / …` |
| Resto (en-US) | esquerda para direita | `… % …` |
| 13 | Adição (en-US) | esquerda para direita | `… + …` |
| Subtração (en-US) | esquerda para direita | `… - …` |
| 12 | Deslocamento de bits para esquerda (en-US) | esquerda para direita | `… << …` |
| Deslocamento de bits para direita (en-US) | esquerda para direita | `… >> …` |
| Deslocamento de bits para direita, sem sinal (en-US) | esquerda para direita | `… >>> …` |
| 11 | Menor Que (en-US) | esquerda para direita | `… < …` |
| Menor ou Igual a (en-US) | esquerda para direita | `… <= …` |
| Maior Que (en-US) | esquerda para direita | `… > …` |
| Maior ou Igual a (en-US) | esquerda para direita | `… >= …` |
| in | esquerda para direita | `… in …` |
| instanceof | esquerda para direita | `… instanceof …` |
| 10 | Igualdade (en-US) | esquerda para direita | `… == …` |
| Desigualdade (en-US) | esquerda para direita | `… != …` |
| Igualdade Estrita (en-US) | esquerda para direita | `… === …` |
| Desigualdade Estrita (en-US) | esquerda para direita | `… !== …` |
| 9 | E bit-a-bit (en-US) | esquerda para direita | `… & …` |
| 8 | OU exclusivo bit-a-bit (en-US) | esquerda para direita | `… ^ …` |
| 7 | OU bit-a-bit (en-US) | esquerda para direita | `… | …` |
| 6 | E lógico (en-US) | esquerda para direita | `… && …` |
| 5 | OU lógico (en-US) | esquerda para direita | `… || …` |
| 4 | Condicional | direita para esquerda | `… ? … : …` |
| 3 | Atribuição (en-US) | direita para esquerda | `… = …` |
| `… += …` |
| `… -= …` |
| `… *= …` |
| `… /= …` |
| `… %= …` |
| `… <<= …` |
| `… >>= …` |
| `… >>>= …` |
| `… &= …` |
| `… ^= …` |
| `… |= …` |
| 2 | yield | direita para esquerda | `yield …` |
| yield\* | `yield* …` |
| 1 | Propagação (en-US) | n/a | `...` … |
| 0 | Vírgula / Sequência | esquerda para direita | `… , …` |


Adição (+) - JavaScript

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

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)


Sintaxe e tipos - JavaScript

Sintaxe e tipos
===============

* « Previous
* Next »

Este capítulo trata sobre a sintaxe básica do JavaScript, declarações de variáveis, tipos de dados e literais.

Sintaxe básica
--------------

JavaScript pega emprestado a maior parte de sua sintaxe do Java, mas também é influenciado por Awk, Perl e Python.

JavaScript é **case-sensitive** e usa o conjunto de caracteres **Unicode.** Por exemplo, a palavra Früh (que significa "cedo" em Alemão) pode ser usada como nome de variável.

```js
var Früh = "foobar";
```

Mas a variável `früh` não é a mesma que `Früh` porque JavaScript é case sensitive.

No JavaScript, instruções são chamadas de declaração e são separadas por um ponto e vírgula (;). Espaços, tabulação e uma nova linha são chamados de espaços em branco. O código fonte dos scripts em JavaScript são lidos da esquerda para a direita e são convertidos em uma sequência de elementos de entrada como simbolos, caracteres de controle, terminadores de linha, comentários ou espaço em branco. ECMAScript também define determinadas palavras-chave e literais, e tem regras para inserção automática de ponto e vírgula (ASI) para terminar as declarações. No entanto, recomenda-se sempre adicionar ponto e vírgula no final de suas declarações; isso evitará alguns imprevistos. Para obter mais informações, consulte a referência detalhada sobre a gramática léxica do JavaScript.

Comentários
-----------

A sintaxe dos comentários em JavaScript é semelhante como em C++ e em muitas outras linguagens:

```js
// comentário de uma linha

/\* isto é um comentário longo
 de múltiplas linhas.
 \*/

/\* Você não pode, porém, /\* aninhar comentários \*/ SyntaxError \*/
```

Declarações
-----------

Existem três tipos de declarações em JavaScript.

`var`

Declara uma variável, opcionalmente, inicializando-a com um valor.

`let`

Declara uma variável local de escopo do bloco, opcionalmente, inicializando-a com um valor.

`const`

Declara uma constante de escopo de bloco, apenas de leitura.

### Variáveis

Você usa variáveis como nomes simbólicos para os valores em sua aplicação. O nome das variáveis, chamados de identificadores, obedecem determinadas regras.

Um identificador JavaScript deve começar com uma letra, underline (`_`), ou cifrão (`$`); os caracteres subsequentes podem também ser números (0-9). Devido JavaScript ser case-sensitive, letras incluem caracteres de "A" a "Z" (maiúsculos) e caracteres de "a" a "z" (minúsculos).

Você pode usar a ISO 8859-1 ou caracteres Unicode tal como os identificadores å e ü. Você pode também usar as sequências de escape Unicode como caracteres e identificadores.

Alguns exemplos de nomes legais são `Numeros_visitas`, `temp99`, e `_nome`.

### Declarando variáveis

Você pode declarar uma variável de três formas:

* Com a palavra chave `var`. Por exemplo, var `x = 42`. Esta sintaxe pode ser usada para declarar tanto variáveis locais como variáveis globais.
* Por simples adição de valor. Por exemplo, `x = 42`. Isso declara uma variável global. Essa declaração gera um aviso de advertência no JavaScript. Você não deve usar essa variante.
* Com a palavra chave `let`. Por exemplo, `let y = 13`. Essa sintaxe pode ser usada para declarar uma variável local de escopo de bloco. Veja escopo de variável abaixo.
### Classificando variáveis

Uma variável declarada usando a declaração `var` ou `let` sem especificar o valor inicial tem o valor `undefined`.

Uma tentativa de acessar uma variável não declarada resultará no lançamento de uma exceção `ReferenceError`:

```js
var a;
console.log("O valor de a é " + a); // saída "O valor de a é undefined"
console.log("O valor de b é " + b); // executa uma exception de erro de referência (ReferenceError)
```

Você pode usar `undefined` para determinar se uma variável tem um valor. No código a seguir, não é atribuído um valor de entrada na variável e a declaração `if` será avaliada como verdadeira (`true`).

```js
var input;
if (input === undefined) {
  facaIsto();
} else {
  facaAquilo();
}
```

O valor `undefined` se comporta como falso (`false`), quando usado em um contexto booleano. Por exemplo, o código a seguir executa a função `myFunction` devido o elemento `myArray` ser undefined:

```js
var myArray = [];
if (!myArray[0]) myFunction();
```

O valor `undefined` converte-se para `NaN` quando usado no contexto numérico.

```js
var a;
a + 2; // Avaliado como NaN
```

Quando você avalia uma variável nula, o valor nulo se comporta como 0 em contextos numéricos e como falso em contextos booleanos. Por exemplo:

```js
var n = null;
console.log(n \* 32); // a saída para o console será 0.
```

### Escopo de variável

Quando você declara uma variável fora de qualquer função, ela é chamada de variável *global*, porque está disponível para qualquer outro código no documento atual. Quando você declara uma variável dentro de uma função, é chamada de variável *local*, pois ela está disponível somente dentro dessa função.

JavaScript antes do ECMAScript 6 não possuía escopo de declaração de bloco; pelo contrário, uma variável declarada dentro de um bloco de uma *função* é uma variável local (ou contexto *global*) do bloco que está inserido a função. Por exemplo o código a seguir exibirá 5, porque o escopo de `x` está na função (ou contexto global) no qual `x` é declarado, não o bloco, que neste caso é a declaração `if`.

```js
if (true) {
  var x = 5;
}
console.log(x); // 5
```

Esse comportamento é alterado, quando usado a declaração `let` introduzida pelo ECMAScript 6.

```js
if (true) {
  let y = 5;
}
console.log(y); // ReferenceError: y não está definido
```

### Variável de elevação

Outra coisa incomum sobre variáveis em JavaScript é que você pode utilizar a variável e declará-la depois, sem obter uma exceção. Este conceito é conhecido como **hoisting**; variáveis em JavaScript são num sentido "hoisted" ou lançada para o topo da função ou declaração. No entanto, as variáveis que são "hoisted" retornarão um valor `undefined`. Então, mesmo se você usar ou referir a variável e depois declará-la e inicializá-la, ela ainda retornará undefined.

```js
/\*\*
 \* Exemplo 1
 \*/
console.log(x === undefined); // exibe "true"
var x = 3;

/\*\*
 \* Exemplo 2
 \*/
// retornará um valor undefined
var myvar = "my value";

(function () {
  console.log(myvar); // undefined
  var myvar = "local value";
})();
```

Os exemplos acima serão interpretados como:

```js
/\*\*
 \* Exemplo 1
 \*/
var x;
console.log(x === undefined); // exibe "true"
x = 3;

/\*\*
 \* Exemplo 2
 \*/
var myvar = "um valor";

(function () {
  var myvar;
  console.log(myvar); // undefined
  myvar = "valor local";
})();
```

Devido o hoisting, todas as declarações `var` em uma função devem ser colocadas no início da função. Essa recomendação de prática deixa o código mais legível.

### Variáveis Globais

Variáveis globais são propriedades do *objeto global*. Em páginas web o objeto global é a `window`, assim você pode configurar e acessar variáveis globais utilizando a sintaxe `window.variavel.`

Consequentemente, você pode acessar variáveis globais declaradas em uma janela ou frame ou frame de outra janela. Por exemplo, se uma variável chamada phoneNumber é declarada em um documento, você pode consultar esta variável de um frame como `parent.phoneNumber`.

### Constantes

Você pode criar uma constante apenas de leitura por meio da palavra-chave `const`. A sintaxe de um identificador de uma constante é semelhante ao identificador de uma variável: deve começar com uma letra, sublinhado ou cifrão e pode conter caractere alfabético, numérico ou sublinhado.

```js
const PI = 3.14;
```

Uma constante não pode alterar seu valor por meio de uma atribuição ou ser declarada novamente enquanto o script está em execução. Deve ser inicializada com um valor.

As regras de escopo para as constantes são as mesmas para as váriaveis `let` de escopo de bloco. Se a palavra-chave `const` for omitida, presume-se que o identificador represente uma variável.

Você não pode declarar uma constante com o mesmo nome de uma função ou variável que estão no mesmo escopo. Por exemplo:

```js
// Isto irá causar um erro
function f() {}
const f = 5;

// Isto também irá causar um erro.
function f() {
  const g = 5;
  var g;

  //declarações
}
```

Estrutura de dados e tipos
--------------------------

### Tipos de dados

O mais recente padrão ECMAScript define sete tipos de dados:

* Seis tipos de dados são os chamados primitivos:
    + Boolean. `true` e `false`.
    + null. Uma palavra-chave que indica valor nulo. Devido JavaScript ser case-sensitive, `null` não é o mesmo que `Null`, `NULL`, ou ainda outra variação.
    + undefined. Uma propriedade superior cujo valor é indefinido.
    + Number. `42` ou `3.14159`.
    + String. "Howdy"
    + Symbol (novo em ECMAScript 6). Um tipo de dado cuja as instâncias são únicas e imutáveis.
* e Object

Embora esses tipos de dados sejam uma quantidade relativamente pequena, eles permitem realizar funções úteis em suas aplicações. `Objetos` e `funções` são outros elementos fundamentais na linguagem. Você pode pensar em objetos como recipientes para os valores, e funções como métodos que suas aplicações podem executar.

### Conversão de tipos de dados

JavaScript é uma linguagem dinamicamente tipada. Isso significa que você não precisa especificar o tipo de dado de uma variável quando declará-la, e tipos de dados são convertidos automaticamente conforme a necessidade durante a execução do script. Então, por exemplo, você pode definir uma variável da seguinte forma:

```js
var answer = 42;
```

E depois, você pode atribuir uma string para a mesma variável, por exemplo:

```js
answer = "Obrigado pelos peixes...";
```

Devido JavaScript ser dinamicamente tipado, essa declaração não gera uma mensagem de erro.

Em expressões envolvendo valores numérico e string com o operador +, JavaScript converte valores numérico para strings. Por exemplo, considere a seguinte declaração:

```js
x = "A resposta é " + 42; // "A resposta é 42"
y = 42 + " é a resposta"; // "42 é a resposta"
```

Nas declarações envolvendo outros operadores, JavaScript não converte valores numérico para strings. Por exemplo:

```js
"37" - 7; // 30
"37" + 7; // "377"
```

### Convertendo strings para números

No caso de um valor que representa um número está armazenado na memória como uma string, existem métodos para a conversão.

* `parseInt()`
* `parseFloat()`

parseInt irá retornar apenas números inteiros, então seu uso é restrito para a casa dos decimais. Além disso, é uma boa prática ao usar parseInt incluir o parâmetro da base. O parâmetro da base é usado para especificar qual sistema númerico deve ser usado.

Uma método alternativo de conversão de um número em forma de string é com o operador `+` (operador soma):

```js
"1.1" + "1.1" = "1.11.1"
(+"1.1") + (+"1.1") = 2.2
// Nota: Os parênteses foram usados para deixar mais legível o código, ele não é requirido.
```

Literais
--------

Você usa literais para representar valores em JavaScript. Estes são valores fixados, não variáveis, que você `literalmente` insere em seu script. Esta seção descreve os seguintes tipos literais:

* Array literal
* Literais boolean
* Literais de ponto flutuante
* Inteiros
* Objeto literal
* String literal
### Array literal

Um array literal é uma lista de zero ou mais expressões, onde cada uma delas representam um elemento do array, inseridas entre colchetes (`[]`). Quando você cria um array usando um array literal, ele é inicializado com os valores especificados como seus elementos, e seu comprimento é definido com o número de elementos especificados.

O exemplo a seguir cria um array `coffees` com três elementos e um comprimento de três:

```js
var coffees = ["French Roast", "Colombian", "Kona"];
```

**Nota:** **Nota :** Um array literal é um tipo de inicializador de objetos. Veja Usando inicializadores de Objetos.

Se um array é criado usando um literal no topo do script, JavaScript interpreta o array cada vez que avalia a expressão que contêm o array literal. Além disso, um literal usado em uma função é criado cada vez que a função é chamada.

Array literal são também um array de objetos. Veja `Array` e Coleções indexadas para detalhes sobre array de objetos.

#### Vírgulas extras em array literal

Você não precisa especificar todos os elementos em um array literal. Se você colocar duas vírgulas em uma linha, o array é criado com `undefined` para os elementos não especificados. O exemplo a seguir cria um array chamado `fish`:

```js
var fish = ["Lion", , "Angel"];
```

Esse array tem dois elementos com valores e um elemento vazio (`fish[0]` é "Lion", `fish[1]` é `undefined`, e `fish[2]` é "Angel" ).

Se você incluir uma vírgula à direita no final da lista dos elementos, a vírgula é ignorada. No exemplo a seguir, o comprimento do array é três. Não há nenhum `myList[3]`. Todas as outras vírgulas na lista indicam um novo elemento.

**Nota:** **Nota :** Vírgulas à direita podem criar erros em algumas versões de navegadores web antigos, é recomendável removê-las.

```js-olint
var myList = ["home", , "school", ];
```

No exemplo a seguir, o comprimento do array é quatro, e `myList[0]` e `myList[2]` são `undefined`.

```js
var myList = [, "home", , "school"];
```

No exemplo a seguir, o comprimento do array é quatro, e `myList[1]` e `myList[3]` são `undefined`. Apenas a última vírgula é ignorada.

```js
var myList = ["home", , "school", ,];
```

Entender o comportamento de vírgulas extras é importante para a compreensão da linguagem JavaScript, no entanto, quando você escrever seu próprio código: declarar explicitamente os elementos em falta como `undefined` vai aumentar a clareza do código, e consequentemente na sua manutenção.

### Literais Boolean

O tipo Boolean tem dois valores literal: `true` e `false`.

Não confunda os valores primitivos Boolean `true` e `false` com os valores `true` e `false` do objeto Boolean. O objeto Boolean é um invólucro em torno do tipo de dado primitivo. Veja `Boolean` para mais informação.

### Inteiros

Inteiros podem ser expressos em decimal (base 10), hexadecimal (base 16), octal (base 8) e binário (base 2).

* Decimal inteiro literal consiste em uma sequência de dígitos sem um 0 (zero).
* 0 (zero) em um inteiro literal indica que ele está em octal. Octal pode incluir somente os dígitos 0-7.
* 0x (ou 0X) indica um hexadecimal. Inteiros hexadecimais podem incluir dígitos (0-9) e as letras a-f e A-F.
* 0b (ou 0B) indica um binário. Inteiros binário podem incluir apenas os dígitos 0 e 1.

Alguns exemplos de inteiros literal são:
```

0, 117 and -345 (decimal, base 10)
015, 0001 and -077 (octal, base 8)
0x1123, 0x00111 and -0xF1A7 (hexadecimal, "hex" or base 16)
0b11, 0b0011 and -0b11 (binário, base 2)
```

Para maiores informações, veja Literais numérico na referência Léxica.

### Literais de ponto flutuante

Um literal de ponto flutuante pode ter as seguintes partes:

* Um inteiro decimal que pode ter sinal (precedido por "`+`" ou "`-`"),
* Um ponto decimal ("`.`"),
* Uma fração (outro número decimal),
* Um expoente.

O expoente é um "e" ou "E" seguido por um inteiro, que pode ter sinal (precedido por "+" ou "-"). Um literal de ponto flutuante deve ter no mínimo um dígito e um ponto decimal ou "e" (ou "E").

Mais sucintamente, a sintaxe é:
```

[(+|-)][digitos][.digitos][(E|e)[(+|-)]digitos]
```

Por exemplo:
```

3.1415926
-.123456789
-3.1E+12
.1e-23
```

### Objeto literal

Um objeto literal é uma lista de zero ou mais pares de nomes de propriedades e valores associados de um objeto, colocado entre chaves (`{}`). Você não deve usar um objeto literal no início de uma declaração. Isso levará a um erro ou não se comportará conforme o esperado, porque o `{` será interpretado como início de um bloco.

Segue um exemplo de um objeto literal. O primeiro elemento do objeto `carro` define uma propriedade, `meuCarro`, e atribui para ele uma nova string, "Punto"; o segundo elemento, a propriedade `getCarro`, é imediatamente atribuído o resultado de chamar uma função (`tipoCarro("Fiat")`); o terceiro elemento, a propriedade `especial`, usa uma variável existente (`vendas)`.

```js
var vendas = "Toyota";

function tipoCarro(nome) {
  if (nome == "Fiat") {
    return nome;
  } else {
    return "Desculpa, não vendemos carros " + nome + ".";
  }
}

var carro = {
  meuCarro: "Punto",
  getCarro: tipoCarro("Fiat"),
  especial: vendas,
};

console.log(carro.meuCarro); // Punto
console.log(carro.getCarro); // Fiat
console.log(carro.especial); // Toyota
```

Além disso, você pode usar um literal numérico ou string para o nome de uma propriedade ou aninhar um objeto dentro do outro. O exemplo a seguir usar essas opções.

```js
var carro = { carros: { a: "Saab", b: "Jeep" }, 7: "Mazda" };

console.log(carro.carros.b); // Jeep
console.log(carro[7]); // Mazda
```

Nomes de propriedades de objeto podem ser qualquer string, incluindo uma string vazia. Caso o nome da propriedade não seja um identificador JavaScript ou número, ele deve ser colocado entre aspas. Nomes de propriedades que não possuem identificadores válido, também não podem ser acessadas pela propriedade de ponto (`.`), mas podem ser acessadas e definidas com a notação do tipo array ("`[]`").

```js
var unusualPropertyNames = {
  "": "Uma string vazia",
  "!": "Bang!"
}
console.log(unusualPropertyNames."");   // SyntaxError: string inesperada
console.log(unusualPropertyNames[""]);  // Um string vazia
console.log(unusualPropertyNames.!);    // SyntaxError: símbolo ! inesperado
console.log(unusualPropertyNames["!"]); // Bang!
```

Observe:

```js
var foo = { a: "alpha", 2: "two" };
console.log(foo.a); // alpha
console.log(foo[2]); // two
//console.log(foo.2); // Error: missing ) after argument list
//console.log(foo[a]); // Error: a não está definido
console.log(foo["a"]); // alpha
console.log(foo["2"]); // two
```

### Expressão Regex Literal

Um regex literal é um padrão entre barras. A seguir um exemplo de regex literal.
```

var re = /ab+c/;
```

### String Literal

Uma string literal são zero ou mais caracteres dispostos em aspas duplas (`"`) ou aspas simples (`'`). Uma sequência de caracteres deve ser delimitada por aspas do mesmo tipo; ou seja, as duas aspas simples ou ambas aspas duplas. A seguir um exemplo de strings literais.
```

"foo"
'bar'
"1234"
"um linha \n outra linha"
"John's cat"
```

Você pode chamar qualquer um dos métodos do objeto string em uma string literal - JavaScript automaticamente converte a string literal para um objeto string temporário, chama o método, em seguida, descarta o objeto string temporário. Você também pode usar a propriedade `String.length` com uma string literal:

```js
console.log("John's cat".length);
// Irá exibir a quantidade de caracteres na string incluindo o espaço em branco.
// Nesse caso, 10 caracteres.
```

Você deve usar string literal, a não ser que você precise usar um objeto string. Veja `String` para detalhes sobre objetos de strings.

#### Uso de caracteres especiais em string

Além dos caracteres comuns, você também pode incluir caracteres especiais em strings, como mostrado no exemplo a seguir.

```js
"uma linha \n outra linha";
```

A tabela a seguir lista os caracteres especiais que podem ser usados em strings no JavaScript.

| Caracter | Descrição |
| --- | --- |
| `\0` | Byte nulo |
| `\b` | Backspace |
| `\f` | Alimentador de formulário |
| `\n` | Nova linha |
| `\r` | Retorno do carro |
| `\t` | Tabulação |
| `\v` | Tabulação vertical |
| `\'` | Apóstrofo ou aspas simples |
| `\"` | Aspas dupla |
| `\\` | Caractere de barra invertida |
| `\XXX` | Caractere com a codificação Latin-1 especificada por três dígitos octal *XXX* entre 0 e 377. Por exemplo, \251 é sequência octal para o símbolo de direitos autorais. |
|  |  |
| `\xXX` | Caractere com a codificação Latin-1 especificada por dois dígitos hexadecimal *XX* entre 00 e FF. Por exemplo, \xA9 é a sequência hexadecimal para o símbolo de direitos autorais. |
|  |  |
| `\uXXXX` | Caractere Unicode especificado por quatro dígitos hexadecimal *XXXX*. Por exemplo, \u00A9 é a sequência Unicode para o símbolo de direitos autorais. Veja sequências de escape Unicode. |

#### Caracteres de escape

Para caracteres não listados na tabela, se precedidos de barra invertida ela é ignorada, seu uso está absoleto e deve ser ignorado.

Você pode inserir uma aspa dentro de uma string precendendo-a com uma barra invertida. Isso é conhecido como *escaping* das aspas. Por exemplo:

```js
var quote = "Ele lê \"The Cremation of Sam McGee\" de R.W. Service.";
console.log(quote);
```

O resultado disso seria:
```

Ele lê "The Cremation of Sam McGee" de R.W. Service.
```

Para incluir uma barra invertida dentro de uma string, você deve escapar o caractere de barra invertida. Por exemplo, para atribuir o caminho do arquivo `c:\temp` para uma string, utilize o seguinte:

```js
var home = "c:\\temp";
```

Você também pode escapar quebras de linhas, precedendo-as com barra invertida. A barra invertida e a quebra de linha são ambas removidas da string.

```js
var str =
  "esta string \
está quebrada \
em várias\
linhas.";
console.log(str); // esta string está quebrada em várias linhas.
```

Embora JavaScript não tenha sintaxe "heredoc", você pode adicionar uma quebra de linha e um escape de quebra de linha no final de cada linha:

```js
var poema =
  "Rosas são vermelhas\n\
Violetas são azuis,\n\
Esse seu sorriso\n\
é o que me seduz. (Lucas Pedrosa)";
```

Mais informação
---------------

Este capítulo focou na sintaxe básica das declarações e tipos. Para saber mais sobre a linguagem JavaScript, veja também os seguintes capítulos deste guia:

* Controle de fluxo e manipulação de erro
* Laços e iteração
* Funções
* Expressões e operadores

No próximo capítulo, veremos a construção de controle de fluxos e manipulação de erro.

* « Previous
* Next »


Laços e iterações - JavaScript

Laços e iterações
=================

* « Previous
* Next »

Laços oferecem um jeito fácil e rápido de executar uma ação repetidas vezes. Este capítulo do guia do JavaScript abordará diferentes formas de iterações existentes no JavaScript.

Você pode pensar em um laço de repetição como um jogo onde você manda o seu personagem andar X passos em uma direção e Y passos em outra; por exemplo, a ideia "vá 5 passos para leste" pode ser expressa em um laço desta forma:

```js
var passo;
for (passo = 0; passo < 5; passo++) {
  // Executa 5 vezes, com os valores de passos de 0 a 4.
  console.log("Ande um passo para o leste");
}
```

Existem várias formas diferentes de laços, mas eles essencialmente fazem a mesma coisa: repetir uma ação múltiplas vezes ( inclusive você poderá repetir 0 vezes). Os vários mecanismos diferentes de laços oferecem diferentes formas de determinar quando este irá começar ou terminar. Há várias situações em que é mais fácil resolver um problema utilizando um determinado tipo de laço do que outros.

Os possíveis laços de repetição em JavaScript:

* for\_statement
* do...while\_statement
* while\_statement
* label\_statement
* break\_statement
* continue\_statement
* for...in\_statement
* for...of\_statement
`Declaração for`
----------------

Um laço for é repetido até que a condição especificada seja falsa. O laço for no JavaScript é similar ao Java e C. Uma declaração for é feita da seguinte maneira:
```

for ([expressaoInicial]; [condicao]; [incremento])
  declaracao
```

Quando um for é executado, ocorre o seguinte:

1. A expressão `expressao Inicial` é inicializada e, caso possível, é executada. Normalmente essa expressão inicializa um ou mais contadores, mas a sintaxe permite expressões de qualquer grau de complexidade. Podendo conter também declaração de variáveis.
2. A expressão `condicao` é avaliada. caso o resultado de `condicao` seja verdadeiro, o laço é executado. Se o valor de `condicao` é falso, então o laço terminará. Se a expressão `condicao` é omitida, a `condicao` é assumida como verdadeira.
3. A instrução é executada. Para executar múltiplas declarações, use uma declaração em bloco ({ ... }) para agrupá-las.
4. A atualização da expressão `incremento`, se houver, executa, e retorna o controle para o passo 2.
### Exemplo

A função a seguir contém uma declaração `for` que contará o número de opções selecionadas em uma lista (um elemento `<select>` permite várias seleções). Dentro do `for` é declarado uma váriavel `i` inicializada com zero. A declaração `for` verifica se `i` é menor que o número de opções no elemento `<select>`, executa sucessivas declaração `if`, e incrementa `i` de um em um a cada passagem pelo laço.

```html
<form name="selectForm">
  <p>
    <label for="tipoMusica"
 >Escolha alguns tipos de música, em seguida, clique no botão
      abaixo:</label
 >
    <select id="tipoMusica" name="tipoMusica" multiple="multiple">
      <option selected="selected">R&B</option>
      <option>Jazz</option>
      <option>Blues</option>
      <option>New Age</option>
      <option>Classico</option>
      <option>Ópera</option>
    </select>
  </p>
  <p><input id="btn" type="button" value="Quantos foram selecionados?" /></p>
</form>

<script>
 function howMany(selectObject) {
 var numeroSelecionadas = 0;
 for (var i = 0; i < selectObject.options.length; i++) {
 if (selectObject.options[i].selected) {
 numeroSelecionadas++;
 }
 }
 return numeroSelecionadas;
 }

 var btn = document.getElementById("btn");
 btn.addEventListener("click", function () {
 alert(
 "Total de opções selecionadas: " +
 howMany(document.selectForm.tipoMusica),
 );
 });
</script>
```

`Declaração do...while`
-----------------------

A instrução do...while repetirá até que a condição especificada seja falsa.
```

do
  declaracao
while (condicao);
```

A instrução será executada uma vez antes da condição ser verificada. Para executar multiplas instruções utilize uma declaração de bloco ({ ... }) para agrupá-las. Caso a `condicao` seja verdadeira, então o laço será executado novamente. Ao final de cada execução, a `condicao` é verificada. Quando a condição contida no while for falsa a execução do laço é terminada e o controle é passado para a instrução seguinte a `do...while`.

### Exemplo

No exemplo a seguir, o laço é executado pelo menos uma vez e irá executar até que `i` seja menor que 5.

```js
do {
  i += 1;
  console.log(i);
} while (i < 5);
```

`Declaração while`
------------------

Uma declaração while executa suas instruções, desde que uma condição especificada seja avaliada como verdadeira. Segue uma declaração `while`:
```

while (condicao)
  declaracao
```

Se a condição se tornar falsa, a declaração dentro do laço para a execução e o controle é passado para a instrução após o laço.

O teste da condição ocorre antes que o laço seja executado. Desta forma se a condição for verdadeira o laço executará e testará a condição novamente. Se a condição for falsa o laço termina e passa o controle para as instruções após o laço.

Para executar múltiplas declarações, use uma declaração em bloco ({ ... }) para agrupar essas declarações.

### Exemplo 1

O `while` a seguir executará enquanto `n` for menor que três:

```js
n = 0;
x = 0;
while (n < 3) {
  n++;
  x += n;
}
```

A cada iteração, o laço incrementa `n` e adiciona este valor para `x`. Portanto, `x` e `n` recebem os seguintes valores:

* Depois de executar pela primeira vez: `n` = 1 e `x` = 1
* Depois da segunda vez: `n` = 2 e `x` = 3
* Depois da terceira vez: `n` = 3 e `x` = 6

Depois de executar pela terceira vez, a condição `n < 3` não será mais verdadeira, então o laço encerrará.

### Exemplo 2

Evite laços infinitos. Tenha certeza que a condição do laço eventualmente será falsa; caso contrário, o laço nunca terminará. O while a seguir executará para sempre pois sua condição nunca será falsa:

```js
while (true) {
  console.log("Olá, mundo");
}
```

`Declaração label`
------------------

Um label provê um identificador que permite que este seja referenciado em outro lugar no seu programa. Por exemplo, você pode usar uma label para identificar um laço, e então usar `break` ou `continue` para indicar quando o programa deverá interromper o laço ou continuar sua execução.

Segue a sintaxe da instrução label:
```

label : declaracao
```

Um label pode usar qualquer idenficador que não seja uma palavra reservada do JavaScript. Você pode identificar qualquer instrução com um label.

### Exemplo

Neste exemplo, o label `markLoop` idenfica um laço `while`.

```js
markLoop: while (theMark == true) {
  facaAlgo();
}
```

`Declaração break`
------------------

Use break para terminar laços, `switch`, ou um conjunto que utiliza label.

* Quando você utiliza `break` sem um label, ele encerrará imediatamente o laço mais interno `while`, `do-while`, `for`, ou `switch` e transferirá o controle para a próxima instrução.
* Quando você utiliza `break` com um label, ele encerrará o label específico.

Segue a sintaxe do break:

1. `break;`
2. `break label;`

Na primeira opção será encerrado o laço de repetição mais interno ou `switch`. Já na segunda opção será encerrada o bloco de código referente a label.

### **Exemplo** **1**

O exemplo a seguir percorre os elementos de um array até que ele encontre o índice do elemento que possui o valor contido em `theValue`:

```js
for (i = 0; i < a.length; i++) {
  if (a[i] == theValue) {
    break;
  }
}
```

### **Exemplo 2:** Utilizando break em label

```js
var x = 0;
var z = 0;
labelCancelaLaco: while (true) {
  console.log("Laço exterior: " + x);
  x += 1;
  z = 1;
  while (true) {
    console.log("Laço interior: " + z);
    z += 1;
    if (z === 10 && x === 10) {
      break labelCancelaLaco;
    } else if (z === 10) {
      break;
    }
  }
}
```

`Declaração continue`
---------------------

A declaração continue pode ser usada para reiniciar uma instrução `while`, `do-while`, `for`, ou `label`.

* Quando você utiliza `continue` sem uma label, ele encerrará a iteração atual mais interna de uma instrução `while`, `do-while`, ou `for` e continuará a execução do laço a partir da próxima iteração. Ao contrário da instrução `break`, `continue` não encerra a execução completa do laço. Em um laço `while`, ele voltará para a condição. Em um laço `for`, ele pulará para a expressão de incrementação.
* Quando você utiliza `continue` com uma label, o `continue` será aplicado ao laço identificado por esta label.

Segue a sintaxe do `continue`:

1. `continue;`
2. `continue`*`label;`*
### Exemplo 1

O exemplo a seguir mostra um laço `while` utilizando `continue` que executará quando o valor de `i` for igual a 3. Desta forma, `n` recebe os valores um, três, sete, e doze.

```js
i = 0;
n = 0;
while (i < 5) {
  i++;
  if (i == 3) {
    continue;
  }
  n += i;
}
```

### Exemplo 2

Uma instrução label `checkiandj` contém uma instrução label `checkj`. Se o `continue` for executado, o programa terminará a iteração atual de `checkj` e começará a próxima iteração. Toda vez que o `continue` for executado, `checkj` recomeçará até que a condição do `while` for falsa. Quando isto ocorrer `checkiandj` executará até que sua condição seja falsa.

Se o `continue` estivesse referenciando `checkiandj`, o programa deveria continuar do topo de `checkiandj`.

```js
checkiandj: while (i < 4) {
  console.log(i);
  i += 1;
  checkj: while (j > 4) {
    console.log(j);
    j -= 1;
    if (j % 2 == 0) {
      continue checkj;
    }
    console.log(j + " é estranho.");
  }
  console.log("i = " + i);
  console.log("j = " + j);
}
```

`Declaração for...in`
---------------------

 A declaração for...in executa iterações a partir de uma variável específica, percorrendo todas as propriedades de um objeto.
 Para cada propriedade distinta, o JavaScript executará uma iteração. Segue a sintaxe:
```

for (variavel in objeto) {
  declaracoes
}
```

### Exemplo

A função a seguir recebe em seu argumento um objeto e o nome deste objeto. Então executará uma iteração para cada elemento e retornará uma lista de string, que irá conter o nome da propriedade e seu valor.

```js
function dump\_props(obj, obj\_name) {
  var result = "";
  for (var i in obj) {
    result += obj_name + "." + i + " = " + obj[i] + "<br>";
  }
  result += "<hr>";
  return result;
}
```

Para um objeto chamado `car` com propriedades `make` e `model`, o resultado será:

```js
car.make = Ford;
car.model = Mustang;
```

### Arrays

Embora seja tentador usar esta forma para interagir com os elementos de um Array, a declaração **for...in** irá retornar o nome pré-definido da propriedade ao invés do seu index numérico. Assim é melhor usar o tradicional for com index numérico quando interagir com arrays, pois o **for...in** interage com as propriedades definidas pelo programador ao invés dos elementos do array.

Declaração `for...of`
---------------------

A declaração for...of cria uma laço com objetos interativos ((incluindo, `Array`, `Map`, `Set`, assim por conseguinte ), executando uma iteração para o valor de cada propriedade distinta.
```

for (variavel of objeto) {
  declaracoes
}
```

O exemplo a seguir mostra a diferença entre o `for...of` e o `for...in`. Enquanto o `for...in` interage com o nome das propriedades, o `for...of` interage com o valor das propriedades.

```js
let arr = [3, 5, 7];
arr.foo = "hello";

for (let i in arr) {
  console.log(i); // logs "0", "1", "2", "foo"
}

for (let i of arr) {
  console.log(i); // logs "3", "5", "7"
}
```

* « Previous
* Next »