recursal/MDN huggingface dataset:
break
=====

Sumário
-------

O comando **break** encerra o loop atual, `switch`, ou o loop que foi informado no `label` e transfere o controle da execução do programa para o comando seguinte.

Síntaxe
-------
```

break [label];
```


`label`

Opcional. Identificador associado ao label de um comando. Se a estrutura não for um loop ou `switch`, ele será um pré-requisito.

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

O comando `break` inclui um label opcional que permite ao programa encerrar a execução da estrutura que possui o nome informado na label. O comando `break` deve estar dentro dessa estrutura informada no label. A estrutura que possui o nome informada na label pode ser qualquer comando `block`; não é necessário que seja precedida por um loop.

Exemplos
--------

A função a seguir possui um comando `break` que encerra o loop `while` quando a variável i vale 3, e então retorna o valor 3 \* `x`.


```js
function testaBreak(x) {
  var i = 0;

  while (i < 6) {
    if (i == 3) {
      break;
    }
    i += 1;
  }
  return i \* x;
}
```


O código a seguir possui o comando break dentro de uma estrutura nomeada. O comando `break` deverá estar dentro da estrutura na qual o label se refere. Veja que `inner_block` está dentro de `outer_block`.


```js
bloco\_externo: {
  bloco\_interno: {
    console.log("1");
    break bloco_externo; // encerra bloco\_interno e bloco\_externok
    console.log(":-("); // não é executado
  }

  console.log("2"); // não é executado
}
```


O código a seguir também utiliza o comando break com blocos nomeados mas gera um erro de sintaxe pois o comando break está dentro do bloco\_1 mas faz uma referência ao bloco\_2. Um comando break sempre deverá estar dentro da estrutura nomeada na qual fizer referência.


```js
bloco\_1:{
  console.log ('1');
  break bloco_2;            // SyntaxError: label not found
}

bloco\_2:{
  console.log ('2');
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-break-statement |

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

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

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

* `continue`
* `label`
* `switch`
Declaração de função
====================

A **declaração function** define uma função com os especificados parâmetros.

Você pode também definir funções usando o construtor `Function` e uma `function expression`.

Sintaxe
-------
```

function name([param,[, param,[..., param]]]) {
   [statements]
}
```


`name`

O nome da função.

`param`

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

`statements`

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

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

Uma função criada com uma declaração function é um objeto `Function` e tem todas as propriedades, métodos e comportamentos dos objetos `Function`. Veja `Function` para informações detalhadas sobre as funções.

Uma função pode também ser criada usando uma expressão (veja `function expression`).

Por padrão, funções retornam `undefined`. Para retornar qualquer outro valor, a função precisa ter uma instrução `return` que especifica o valor para retorno.

### Criando funções condicionalmente

Funções podem ser condicionalmente declaradas, isso é, uma instrução de função pode ser aninhada dentro de uma instrução `if`. A maioria dos navegadores que não sejam Mozilla ir tratar essas declarações condicionais como uma incondicional e criará a função se a condição for true ou não, veja esse artigo para uma visão geral. Portanto, ela não pode ser usada para criação de expressões de função condicional.

### Declarações de funções hoisting

Declarações de funções em JavaScript são hoisted à definição da função. Você pode usar uma função antes de tê-la declarado:


```js
hoisted(); // logs "foo"

function hoisted() {
  console.log("foo");
}
```


Note que `function expressions` não são hoisted:


```js
notHoisted(); // TypeError: notHoisted is not a function

var notHoisted = function () {
  console.log("bar");
};
```

Exemplos
--------

### Usando funções

O seguinte código declara uma função que retorna a quantidade total das vendas, quando dados os números de unidades vendidas dos produtos a, b e c.


```js
function calc\_sales(units\_a, units\_b, units\_c) {
  return units_a \* 79 + units_b \* 129 + units_c \* 699;
}
```

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

* `Functions and function scope` (en-US)
* `Function`
* `function expression`
* `function* statement`
* `function* expression`
* `Arrow functions`
* `GeneratorFunction` (en-US)
return
======

A **declaração `return`** finaliza a execução de uma função e especifica os valores que devem ser retonados para onde a função foi chamada.

Sintaxe
-------
```

return [[expression]];
```


`expression`

A expressão cujo valor será retornado. Se omitido, `undefined` é retornado.

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

Quando uma declaração `return` é usada em um corpo de função, a execução dessa função é parada. Se especificado, um dado valor é retornado à quem chamou a função. Se a expressão for omitida, `undefined` será retornado. Todas as declarações return a seguir param a execução da função:


```js
return;
return true;
return false;
return x;
return x + y / 3;
```

### Inserção Automática de Ponto-e-Vírgula

A declaração `return` é afetada pela inserção automática de ponto e vírgula (ASI). Nenhum terminador de linha é permitido entre a palavra-chave `return` e a expressão.


```js
return
a + b;
```


é transformado pelo ASI em:
```

return;
a + b;
```


O console irá alertar "unreachable code after return statement" (código inacessível após a declaração return).

**Nota:** A partir do Gecko 40, um alerta é mostrado no console se um código inacessível é encontrado após uma declaração `return`.

Exemplos
--------

### return

A função a seguir retorna o quadro do seu argumento, `x`, quando `x` é um número.


```js
function square(x) {
  return x \* x;
}
```

### Interrompendo uma função

Uma função para imediatamente no ponto em que `return` é chamado.


```js
function counter() {
  for (var count = 1; ; count++) {
    // loop infinito
    console.log(count + "A"); // até 5
    if (count === 5) {
      return;
    }
    console.log(count + "B"); // até 4
  }
  console.log(count + "C"); // nunca aparece
}

counter();

// Saída:
// 1A
// 1B
// 2A
// 2B
// 3A
// 3B
// 4A
// 4B
// 5A
```

### Retornando uma função

Veja também o artigo sobre Closures.


```js
function magic(x) {
  return function calc(x) {
    return x \* 42;
  };
}

var answer = magic();
answer(1337); // 56154
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-return-statement |

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

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

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

* Funções (en-US)
* Closures
while
=====

A **declaração while** cria um laço que executa uma rotina especifica enquanto a condição de teste for avaliada como verdadeira. A condição é avaliada antes da execução da rotina.

Syntax
------
```

while (condição) {
  rotina
}
```


`condição`

Uma expressão avaliada antes de cada passagem através do laço. Se essa condição for avaliada como verdadeira, a rotina é executada. Quando a condição for avaliada como falsa, a execução continua na declaração depois do laço `while`.

rotina

Uma declaração que é executada enquanto a condição é avaliada como verdadeira. Para executar multiplas declarações dentro de um laço, use uma declaração em bloco (en-US) (`{ ... }`) para agrupar essas declarações.

Exemplos
--------

O seguinte laço `while` itera enquanto n é menor que três.


```js
var n = 0;
var x = 0;

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


Cada iteração, o laço incrementa n e soma à x. Portanto, x e n assumem os seguintes valores:

* Depois da primeira passagem: n = 1 e x = 1
* Depois da segunda passagem: n = 2 e x = 3
* Depois da terceira passagem: n = 3 e x = 6

Depois de completar a terceira passagem, a condição n < 3 não é mais verdadeira, então o laço termina.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-while-statement |

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

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

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

* `do...while`
* `for`
debugger
========

A **declaração debug** invoca qualquer funcionalidade de depuração disponivel, como definir um breakpoint. Se nenhuma funcionalidade de depuração estiver disponivel, essa declaração não tem nenhum efeito.

Sintaxe
-------
```

debugger;
```

Exemplos
--------

O exemplo a seguir mostra o código onde uma declaração debugger foi inserida para invocar um depurador (se um existir) quando a função for chamada.


```js
function codigoPotencialmenteBugado() {
  debugger;
  // faça atividades de depuração como examinar, pular um passo etc.
}
```


Quando o depurador é invocado, a execução é parada na declaração debugger. É como um breakpoint no código-fonte.

![Paused at a debugger statement.](/pt-BR/docs/Web/JavaScript/Reference/Statements/debugger/screen_shot_2014-02-07_at_9.14.35_am.png)

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-debugger-statement |

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

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

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

* Depurando JavaScript
* O Depurador nas Ferramentas de Desenvolvedor do Firefox
class
=====

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

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

* Learn more
* See full compatibility
* Report feedback
A **declaração class** cria uma nova classe com dado **nome** usando a herança do protótipo base.
Você também pode definir uma classe usando class expression.

Sintaxe
-------


```js
class name [extends] {
  // class body
}
```

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

Assim como as expressões de classe, o corpo de uma declaração de classe é executado em strict mode.

Declarações de classe não são hoisted (ao contrário de function declarations).

Exemplos
--------

### Declaração simples de classe

No exemplo a seguir, primeiro definimos uma classe chamada *Polygon*, então extendemos essa classe para criar uma classe chamada *Square*. Note que *super()*, usada no construtor, só pode ser usada em construtores e deve ser chamada antes da chave *this* ser usada.


```js
class Poligono {
  constructor(altura, largura) {
    this.nome = "Polígono";
    this.altura = altura;
    this.largura = largura;
  }
}

class Quadrado extends Poligono {
  constructor(altura) {
    super(altura, altura);
    this.nome = "Quadrado";
  }
}
```

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

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

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

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

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

* `function` declaration
* `class` expression
* Classes
label (Etiqueta)
================

Provém uma declaração com um indentificador o qual pode ser referido posteriormente utilizando-se os comandos *break* ou *continue*.

Por exemplo, você pode usar um *label* para identificar um laço e então com um comando de *break* ou *continue* indicar se este deve ser interrompido ou então continuar sua execução.

Sintaxe
-------
```

label :
   declaração
```

### Parâmetros

`label`

Qualquer idenfiticador JavaScript válido que não é uma palavra reservada.

`declaração`

Uma declaração qualquer. *break* pode ser utilizado com qualquer declaração entiquetada (com *label*) , assim como o *continue* também pode.


**Aviso:** ### Evite usar labelsLabels não são comunmente utilizados em JavaScript já que estes fazem com que programas fiquei mais difíceis de ler e entender. Sempre que possível evite utilizar labels e, dependendo dos casos, prefira chamar funções (en-US) ou lançar um erro (en-US).

Exemplos
--------

### `Exemplo com continue`


```js
var i, j;

loop1: for (i = 0; i < 3; i++) {
  //O primeiro 'for' é etiquetado com "loop1"
  loop2: for (j = 0; j < 3; j++) {
    //O segundo é etiquetado com "loop2"
    if (i == 1 && j == 1) {
      continue loop1;
    } else {
      console.log("i = " + i + ", j = " + j);
    }
  }
}

// Sua saída é:
// "i = 0, j = 0"
// "i = 0, j = 1"
// "i = 0, j = 2"
// "i = 1, j = 0"
// "i = 2, j = 0"
// "i = 2, j = 1"
// "i = 2, j = 2"
// Note como pula-se "i = 1, j = 1" e "i = 1, j = 2"
```

### Exemplo 2 `(continue)`

Dado uma lista de itens e outra de testes, este exemplo conta o número de ítens que passam em todos os testes.


```js
var itemsPassed = 0;
var i, j;

top: for (i = 0; i < items.length; i++) {
  for (j = 0; j < tests.length; j++) if (!tests[j].pass(items[i])) continue top;
  itemsPassed++;
}
```

### Exemplo 3 `(break)`

Dado uma lista de ítens e uma lista de testes, neste exemplo determina-se se todos os ítens passam em todos os testes.


```js
var allPass = true;
var i, j;

top: for (i = 0; items.length; i++)
  for (j = 0; j < tests.length; i++)
    if (!tests[j].pass(items[i])) {
      allPass = false;
      break top;
    }
```

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

* break (en-US)
* continue (en-US)
empty
=====

Uma **declaração vazia** é usada para fornecer nenhuma declaração, embora a sintaxe do JavaScript esperasse uma.

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

Sintaxe
-------
```

;
```

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

A instrução vazia é um ponto-e-vírgula (;) indicando que nenhuma instrução será executada, mesmo se a sintaxe do JavaScript exigir uma.

O comportamento oposto, em que você deseja várias instruções, mas o JavaScript permite apenas uma única, é possível usando uma instrução de bloco ; combina várias declarações em uma única.

Exemplos
--------

A instrução vazia às vezes é usada com instruções de loop. Veja o exemplo a seguir com um corpo de loop vazio:


```js
var arr = [1, 2, 3];

// Assign all array values to 0
for (i = 0; i < arr.length; arr[i++] = 0 /\* empty statement \*/);

console.log(arr);
// [0, 0, 0]
```


**Nota:** É uma boa ideia comentar o uso intencional da declaração vazia, pois não é realmente óbvio distinguir entre um ponto e vírgula normal. No exemplo a seguir, o uso provavelmente não é intencional:


```js
if (condition) // Caution, this "if" does nothing!
  killTheUniverse(); // So this gets always executed!!!
```


Outro Exemplo: Uma declaração `if...else` declaração sem chaves ({ }). Se três for verdadeiro, nada acontecerá, quatro não importa e também a função launchRocket ( ) no caso contrário não será executada.


```js
if (one) doOne();
else if (two) doTwo();
else if (three) // nothing here
else if (four) doFour();
else launchRocket();
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-empty-statement |

Browsers compatíveis
--------------------

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

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

* `Block statement`
continue
========

A palavra chave **continue** termina a atual iteração do laço em que ele se encontra ou de um laço rotulado, e continua a execução deste laço com a próxima iteração.

Syntax
------
```

continue [rótulo];
```


`rótulo`

Identificador associado ao laço.

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

Diferentemente do `break`, o `continue` não termina a execução do laço completamente, em vez disso ele:

* Volta à condição, em um laço do tipo `while`.
* Volta à expressão, atualizando-a, em um laço do tipo `for`.

O `continue` pode incluir, opcionalmente, um rótulo que premite ao programa pular para a próxima iteração de um laço rotulado em vez de pular o loop em que ele se encontra. Neste caso, o `continue` necessita estar dentro deste laço rotulado.

Exemplos
--------

### Usando `continue` com `while`

O exemplo abaixo mostra um laço `while` que tem um `continue` que será executado quando o valor de `i` for 3. Assim, `n` terá os valores 1, 3, 7, e 12.


```js
var i = 0;
var n = 0;

while (i < 5) {
  i++;

  if (i === 3) {
    continue;
  }

  n += i;
}
```

### Usando o `continue` com um rótulo

No exemplo abaixo, um laço rotulado como `checkiandj` contém o laço rotulado `checkj`. Se o `continue` for alcançado, o programa continua a execução voltando ao topo do rótulo `checkj`. Cada vez que o `continue` for alcançado, `checkj` reiterará até sua condição for falsa. Quando retornar `false`, o restante de `checkiandj` será executado.

Se o `continue` tivesse o rótulo `checkiandj`, o programa iria continuar retornando a execução ao label `checkiandj`.

Veja também `label`.


```js
var i = 0;
var j = 8;

checkiandj: while (i < 4) {
  console.log("i: " + i);
  i += 1;

  checkj: while (j > 4) {
    console.log("j: " + j);
    j -= 1;

    if (j % 2 == 0) continue checkj;
    console.log(j + " is odd.");
  }
  console.log("i = " + i);
  console.log("j = " + j);
}
```


Output:


```js
"i: 0";

// start checkj
"j: 8";
"7 is odd.";
"j: 7";
"j: 6";
"5 is odd.";
"j: 5";
// end checkj

"i = 1";
"j = 4";

"i: 1";
"i = 2";
"j = 4";

"i: 2";
"i = 3";
"j = 4";

"i: 3";
"i = 4";
"j = 4";
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-continue-statement |

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

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

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

* `break`
* `label`
do...while
==========

A declaração **`do...while`** cria um laço que executa uma declaração até que o teste da condição for falsa (false). A condição é avaliada depois que o bloco de código é executado, resultando que uma declaração seja executada pelo menos uma vez.

Sintaxe
-------
```

do
   statement
while (condition);
```


`declarações`

A declaração é executada pelo menos uma vez e re-executada cada vez que a condição (`condition`) for avaliada como verdadeira (true). Para executar múltiplas declarações dentro do laço, use um `block` declaração (`{ ... }`) ao grupo dessas declarações.

`condição`

Uma expressão é validade depois de cada passagem pelo laço. Se a condição `(condition)` é avaliada como verdadeira (true) o bloco de código é executado novamente. Quando a condição `(condition)` é avaliada como falsa (false), o controle passa para a instrução seguinte ao laço **do...while**.

Exemplos
--------

### Usando `do...while`

No exemplo seguinte, o laço **do...while** soma pelo menos uma vez e executa novamente até `i` não ser menor que 5.

### Conteúdo HTML


```html
<div id="exemplo"></div>
```

### Conteúdo JavaScript


```js
var resultado = "";
var i = 0;
do {
  i += 1;
  resultado += i + " ";
} while (i < 5);
document.getElementById("exemplo").innerHTML = resultado;
```

### Resultado

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-do-while-statement |

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

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

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

* `while`
* `for`
static
======

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

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

* Learn more
* See full compatibility
* Report feedback
A palavra chave **static** define um método estático para a classe. Métodos estáticos não são chamados na instâncias da classe. Em vez disso, eles são chamados na própria classe. Geralmente, são funções utilitárias, como funções para criar ou clonar objetos.

Sintaxe
-------
```

static nomeDoMetodo() { ... }
```

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

Chamadas a métodos estáticos são feitas diretamente na classe e não podem ser feitas em uma instância da classe. Métodos estáticos são comumente utilizados como funções utilitárias.

Chamada de métodos estáticos
----------------------------

### De outro método estático

Para chamar um método estático dentro de outro método estático da mesma classe, podemos utilizar a palavra reservada `this`.


```js
class ChamadaDoMetodoEstatico {
  static metodoEstatico() {
    return "O método estático foi chamado";
  }
  static outroMetodoEstatico() {
    return this.metodoEstatico() + " de outro método estático";
  }
}
ChamadaDoMetodoEstatico.metodoEstatico();
// 'O método estático foi chamado'

ChamadaDoMetodoEstatico.outroMetodoEstatico();
// 'O método estático foi chamado de outro método estático'
```

### De outro construtor e outros métodos

Métodos estáticos não são diretamente acessíveis utilizando-se `this` a partir de métodos não estáticos. É necessário chamá-los usando o nome da classe:


```js
nomeDaClasse.nomeDoMetodoEstatico();
```


ou chamando o método como uma propriedade do construtor:


```js
this.constructor.nomeDoMetodoEstatico().
```



```js
class ChamadaDoMetodoEstatico {
  constructor() {
    console.log(ChamadaDoMetodoEstatico.MetodoEstatico());
    // 'O método estático foi chamado.'

    console.log(this.constructor.MetodoEstatico());
    // 'O método estático foi chamado.'
  }

  static MetodoEstatico() {
    return "O método estático foi chamado.";
  }
}
```

Exemplos
--------

O exemplo a seguir demonstra várias coisas. Ele mostra como um método estático é implementado em uma classe e como uma classe com um membro estático pode virar uma subclasse. Por fim, ele mostra como um método estático pode e não pode ser chamado.


```js
class Tripple {
  static tripple(n) {
    n = n | 1;
    return n \* 3;
  }
}

class BiggerTripple extends Tripple {
  static tripple(n) {
    return super.tripple(n) \* super.tripple(n);
  }
}

console.log(Tripple.tripple());
console.log(Tripple.tripple(6));
console.log(BiggerTripple.tripple(3));
var tp = new Tripple();
console.log(tp.tripple()); //Logs 'tp.tripple is not a function'.
```

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

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

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

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

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

* `class` expression
* `class` declaration
* Classes