recursal/MDN huggingface dataset:
Symbol.matchAll
===============

O símbolo **`Symbol.matchAll`** é conhecido por retornar um iterador, que produz conrrespondências de uma expressão regular com uma string. Essa função é usada pelo método `String.prototype.matchAll()`.

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

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

Esse símbolo é usado pelo `String.prototype.matchAll()` e especificado no `RegExp.prototype[@@matchAll]()` (en-US). Os próximos dois exemplos retornam o mesmo resultado:


```js
"abc".matchAll(/a/);

/a/[Symbol.matchAll]("abc");
```


Esse método existe para costumizar o comportamento conrrespondente com as subclasses `RegExp`.

| Property attributes of `Symbol.matchAll` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Usuando Symbol.matchAll


```js
let re = /[0-9]+/g;
let str = "2016-01-02|2019-03-07";

const numbers = {
  \*[Symbol.matchAll](str) {
    for (const n of str.matchAll(/[0-9]+/g)) yield n[0];
  },
};

console.log(Array.from(str.matchAll(numbers)));
// Array ["2016", "01", "02", "2019", "03", "07"]
```


Veja `String.prototype.matchAll()` e `RegExp.prototype[@@matchAll]()` (en-US) para mais exemplos.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.matchall |

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

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

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

* `String.prototype.matchAll()`
* `RegExp.prototype[@@matchAll]()` (en-US)
Symbol.asyncIterator
====================

O **`Symbol.asyncIterator`** é um símbolo conhecido que especifica o padrão AsyncIterator para um objeto. Se essa propriedade é configurada em um objeto, é um iterável assíncrono e pode ser usado in um `for await...of` loop.

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

O `Symbol.asyncIterator` é um símbolo built-in que é usado para um acessar o método `@@asyncIterator` de um objeto. Para que um objeto seja iterável assíncrono, ele deve ter uma chave `Symbol.asyncIterator`.

| Property attributes of `Symbol.asyncIterator` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Iteráveis assíncronos definidos pelo usuário

Você consegue definir seu próprio iterável assíncrono configurando a propriedade `[Symbol.asyncIterator]` em um objeto.


```js
const myAsyncIterable = {
  async \*[Symbol.asyncIterator]() {
    yield "hello";
    yield "async";
    yield "iteration!";
  },
};

(async () => {
  for await (const x of myAsyncIterable) {
    console.log(x);
    // resultado esperado:
    // "hello"
    // "async"
    // "iteration!"
  }
})();
```


Quando criando uma API, lembre que iteráveis assíncronos são programados para representar algum iterável — como um fluxo de dados ou uma lista —, não para substituir completamente chamadas e eventos na maioria das situações.

### Iteráveis assíncronos

Não há atualmente objetos Javascript built-in que tenha a chave `[Symbol.asyncIterator]` configurada por padrão. Entretanto, a WHATWG Streams estão configurando para que o primeiro objeto built-in seja um iterável assíncrono, com a recente chegada do `[Symbol.asyncIterator]` nas especificações.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.asynciterator |

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

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

Vejá também
-----------

* Iteration protocols
* for await... of
Symbol.prototype.description
============================

A propriedade leitura somente **`description`** é uma string que retorna a descrição opcional de objetos `Symbol`.

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

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

`Symbol` objetos podem ser criados com uma uma descrição opcional na qual podem ser usados para debbuging mas não para acessar o próprio símbolo. A `Symbol.prototype.description` propriedade pode ser usada para ler essa descrição. É diferente do `Symbol.prototype.toString()` pois não contém a string incluida "`Symbol()`". Veja os exemplos.

Exemplos
--------

### Usando descrição


```js
Symbol("desc").toString(); // "Symbol(desc)"
Symbol("desc").description; // "desc"
Symbol("").description; // ""
Symbol().description; // undefined

// símbolos conhecidos
Symbol.iterator.toString(); // "Symbol(Symbol.iterator)"
Symbol.iterator.description; // "Symbol.iterator"

// símbolos globais
Symbol.for("foo").toString(); // "Symbol(foo)"
Symbol.for("foo").description; // "foo"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.prototype.description |

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

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

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

* `Symbol.prototype.toString()` (en-US)
* Polyfill: https://npmjs.com/symbol.prototype.description
Symbol.split
============

O **`Symbol.split`** é um símbolo conhecido que especifica o método que divide uma string nos índices correspondentes a uma expressão regular. Essa função é chamada pelo método `String.prototype.split()`.

Para mais informações, veja `RegExp.prototype[@@split]()` (en-US) e `String.prototype.split()`.

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

| Property attributes of `Symbol.split` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Divisão reversa personalizada


```js
class ReverseSplit {
  [Symbol.split](string) {
    const array = string.split(" ");
    return array.reverse();
  }
}

console.log("Another one bites the dust".split(new ReverseSplit()));
// resultado esperado: [ "dust", "the", "bites", "one", "Another" ]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.split |

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

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

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

* `Symbol.match`
* `Symbol.replace`
* `Symbol.search`
* `RegExp.prototype[@@split]()` (en-US)
Symbol.species
==============

O símbolo **`Symbol.species`** especifica uma propriedade valor-função que a função construtora usa para criar objetos derivados.

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

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

A propriedade acessora de espécies permite que subclasses substituam o construtor padrão para objetos.

| Property attributes of `Symbol.species` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Usando espécies

Você pode querer que retorne objetos `Array` em sua class derivada de array `MyArray`. Por exemplo, quando usar métodos tais como `map()` que retorna o construtor padrão, você quer que esses métodos retornem um objeto `Array` pai, em vez do objeto `MyArray`. Esses símbolos espécies permitem que você fala isso:


```js
class MyArray extends Array {
  // Substitui espécies para a Array pai construtora
  static get [Symbol.species]() {
    return Array;
  }
}
let a = new MyArray(1, 2, 3);
let mapped = a.map((x) => x \* x);

console.log(mapped instanceof MyArray); // false
console.log(mapped instanceof Array); // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.species |

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

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

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

* `Map[@@species]`
* `Set[@@species]` (en-US)
Symbol.unscopables
==================

O símbolo **`Symbol.unscopables`** é usado para específicar um valor objeto cujo os nomes de propriedade próprio e herdados são excluídos das associações do ambiente `with` o objeto associado.

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

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

O `@@unscopables` símbolo (`Symbol.unscopables`) pode ser definido em qualquer objeto para impedir que os nomes da propriedade sejam expostos como variavéis lexicais `with` ligações de ambiente. Note que se usar o Strict mode, `with` as declarações não estão disponíveis e provavelmente não haverá necessidade desse símbolo.

Configurando a propriedade para `true` em um objeto `unscopables` tornará ele não *unscopable* e portanto não irá apareer nas variavéis de escopo lexicais. Configurando uma propriedade para `false` o tornará `scopable` e portanto irá aparecer no escopo de variavéis lexicais.

| Property attributes of `Symbol.unscopables` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Escopo com declarações

O seguinte código funciona normalmente no ES5 e anteriores. Entretanto, no ECMAScript 2015 e superiores, o método `Array.prototype.keys()` foi introduzido. Isso significa que dentro do ambiente `with` "chaves" seria agora o método e não as variavéis. Isso qunado os símbolos `unscopable`s foram introduzidos. Uma confiração built-in `unscopables` é implementada como `Array.prototype[@@unscopables]` para prevenir que alguns métodos de Array tenham escopo definido na desclaração `with`.


```js
var keys = [];

with (Array.prototype) {
  keys.push("something");
}

Object.keys(Array.prototype[Symbol.unscopables]);
// ["copyWithin", "entries", "fill", "find", "findIndex",
// "includes", "keys", "values"]
```

### Objetos não escopáveis

Você também pode configurar `unscopables` para seu próprio objeot.


```js
var obj = {
  foo: 1,
  bar: 2,
};

obj[Symbol.unscopables] = {
  foo: false,
  bar: true,
};

with (obj) {
  console.log(foo); // 1
  console.log(bar); // ReferenceError: bar is not defined
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.unscopables |

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

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

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

* `Array.prototype[@@unscopables]`
* `with` statement (not available in Strict mode)
Symbol.toPrimitive
==================

O **`Symbol.toPrimitive`** é um símbolo que específica uma propriedade com valor função que é chamada para converter um ojbeto para um valor primitivo correspondente.

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

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

Com a ajuda da propriedade **`Symbol.toPrimitive`** (usada como uma função valor), um objeto pode ser convertido para um valor primitivo. a função é chamada com um argumento string **`hint`**, que espcífica o tipo de preferência do resultado do valor primitivo. O argumento **`hint`** pode ser um `"number"`, `"string"`, e `"default"`.

| Property attributes of `Symbol.toPrimitive` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Modificando valores primitivos convertendo para um objeto

O exemplo a seguir descreve que a propriedade **`Symbol.toPrimitive`** pode ser modificar o valor primitivo convertendo para um objeto.


```js
// Um objeto sem propriedade Symbol.toPrimitive.
var obj1 = {};
console.log(+obj1); // NaN
console.log(`${obj1}`); // "[object Object]"
console.log(obj1 + ""); // "[object Object]"

// Um objeto com propriedade Symbol.toPrimitive
var obj2 = {
  [Symbol.toPrimitive](hint) {
    if (hint == "number") {
      return 10;
    }
    if (hint == "string") {
      return "hello";
    }
    return true;
  },
};
console.log(+obj2); // 10 -- dica é "number"
console.log(`${obj2}`); // "hello" -- dica é "string"
console.log(obj2 + ""); // "true" -- dica é "default"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.toprimitive |

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

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

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

* `Date.prototype[@@toPrimitive]`
* `Symbol.prototype[@@toPrimitive]` (en-US)
* `Object.prototype.toString()`
* `Object.prototype.valueOf()`
Symbol.hasInstance
==================

O symbol bem-conhecido **`Symbol.hasInstance`** é usado para determinar se um objeto construtor reconhece um objeto como de sua instância. O comportamento do operador `instanceof` pode ser customizado por este symbol.

| Property attributes of `Symbol.hasInstance` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

Você pode implementar o comportamento customizado do seu `instanceof` deste jeito; por exemplo:


```js
class MyArray {
  static [Symbol.hasInstance](instance) {
    return this.prototype.isPrototypeOf(instance) || Array.isArray(instance);
  }
}

console.log([] instanceof MyArray); // true
console.log(new MyArray() instanceof MyArray); // true
console.log(new Image() instanceof MyArray); // false

class MySubArray extends MyArray {}
console.log(new MySubArray() instanceof MySubArray); // true
console.log(new MySubArray() instanceof MyArray); // true
console.log(new MyArray() instanceof MySubArray); // false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.hasinstance |

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

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

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

* `instanceof`
* `isPrototypeOf()`
Symbol.search
=============

O símbolo **`Symbol.search`** é um método conhecido por retornar o índice com uma string que corresponde a expressão regular. Essa função é chamada pelo método `String.prototype.search()`.

Para mais informação, veja `RegExp.prototype[@@search]()` (en-US) e `String.prototype.search()`.

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

| Property attributes of `Symbol.search` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Pesquisa de string personalizada


```js
class caseInsensitiveSearch {
  constructor(value) {
    this.value = value.toLowerCase();
  }
  [Symbol.search](string) {
    return string.toLowerCase().indexOf(this.value);
  }
}

console.log("foobar".search(new caseInsensitiveSearch("BaR")));
// resultado esperado: 3
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.search |

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

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

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

* `Symbol.match`
* `Symbol.replace`
* `Symbol.split`
* `RegExp.prototype[@@search]()` (en-US)
Symbol.toStringTag
==================

O símbolo **`Symbol.toStringTag`** é uma propriedade com valor string que é usada para a criação de uma descrição de string de um objeto padrão. É acessado internalmente pelo método `Object.prototype.toString()`.

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

| Property attributes of `Symbol.toStringTag` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Tags padrões


```js
Object.prototype.toString.call("foo"); // "[object String]"
Object.prototype.toString.call([1, 2]); // "[object Array]"
Object.prototype.toString.call(3); // "[object Number]"
Object.prototype.toString.call(true); // "[object Boolean]"
Object.prototype.toString.call(undefined); // "[object Undefined]"
Object.prototype.toString.call(null); // "[object Null]"
// ... e mais
```

### Símbolos built-in toStringTag


```js
Object.prototype.toString.call(new Map()); // "[object Map]"
Object.prototype.toString.call(function\* () {}); // "[object GeneratorFunction]"
Object.prototype.toString.call(Promise.resolve()); // "[object Promise]"
// ... e mais
```

### Classes personalizadas para objeto tag

Quando cria sua própria classe, o JavaScript padroniza para "Object" tag:


```js
class ValidatorClass {}

Object.prototype.toString.call(new ValidatorClass()); // "[object Object]"
```

### Tag costumizada com toStringTag

Agora, com a ajuda do `toStringTag`, você é capaz de costumizar sua própria tag:


```js
class ValidatorClass {
  get [Symbol.toStringTag]() {
    return "Validator";
  }
}

Object.prototype.toString.call(new ValidatorClass()); // "[object Validator]"
```

### toStringTag disponível em todos os objetos protótipos da DOM

Devido a uma mudança nas especificações WebIDL spec change em meados de 2020, navegadores estão adicionando uma propriedade `Symbol.toStringTag` para todos os objetos protótipos da DOM . Por exemplo, para acessar a propriedade `Symbol.toStringTag` no `HTMLButtonElement` (en-US):


```js
let test = document.createElement("button");
test.toString(); // Retorna [object HTMLButtonElement]
test[Symbol.toStringTag]; // Retona HTMLButtonElement
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.tostringtag |

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

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

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

* `Object.prototype.toString()`
Symbol.replace
==============

O símbolo **`Symbol.replace`** é conhecido por especificar o método que substitui as substrings conrrespondentes de uma string. Essa função é chamada pelo método `String.prototype.replace()`.

Para mais informações, veja `RegExp.prototype[@@replace]()` (en-US) e `String.prototype.replace()`.

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

| Property attributes of `Symbol.replace` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Usando Symbol.replace


```js
class CustomReplacer {
  constructor(value) {
    this.value = value;
  }
  [Symbol.replace](string) {
    return string.replace(this.value, "#!@?");
  }
}

console.log("football".replace(new CustomReplacer("foo")));
// resultado esperado: "#!@?tball"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.replace |

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

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

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

* `Symbol.match`
* `Symbol.search`
* `Symbol.split`
* `RegExp.prototype[@@replace]()` (en-US)
Symbol.match
============

O símbolo **`Symbol.match`** é conhecido por especificar a compatibilidade de uam expressão regular contra uma string. Essa função é chamada pelo método `String.prototype.match()`.

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

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

Essa função também é usada para identificar se um objeto tem o comportamento de uma expressão regular. Por exemplo, os métodos `String.prototype.startsWith()`, `String.prototype.endsWith()` e `String.prototype.includes()`, verificar se o primeiro agumento é uma expressão regular e irá lançar um `TypeError` se eles forém. Agora, se o símbolo `match` é configurado para `false` (ou um valor Falsy ), ele indica que o objeto não tem intensão de ser usado como um ojbeto de expressão regular

| Property attributes of `Symbol.match` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Desativando a verificação `isRegExp`

O seguinte código vai lançar um `TypeError`:


```js
"/bar/".startsWith(/bar/);

// Lança um TypeError, como /bar/ é uma expressão regular
// não Symbol.match não é modificado.
```


Entretanto, se você configurar `Symbol.match` para `false`, a verificação `isRegExp` (que usa a propriedade `match` ) que o objeto não é uma expressão regular. O método `startsWith` e `endsWith` não vão lançar um `TypeError` como consequência.


```js
var re = /foo/;
re[Symbol.match] = false;
"/foo/".startsWith(re); // true
"/baz/".endsWith(re); // false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.match |

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

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

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

* `Symbol.replace`
* `Symbol.search`
* `Symbol.split`
* `RegExp.prototype[@@match]()` (en-US)
Symbol.isConcatSpreadable
=========================

O **`Symbol.isConcatSpreadable`** é um símbolo conhecido que é usado para configurar se um objeto deve ser achatado para um elemento da array quando usado o método `Array.prototype.concat()`.

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

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

O `@@isConcatSpreadable` símbolo (`Symbol.isConcatSpreadable`) pode também ser definido como uma propriedade própria ou herdada e seu valor é um booleano. Ele consegue controlar o comportamento das arrays e objetos semelhantes a array:

* For array objects, the default behavior is to spread (flatten) elements. `Symbol.isConcatSpreadable` can avoid flattening in these cases.
* For array-like objects, the default behavior is no spreading or flattening. `Symbol.isConcatSpreadable` can force flattening in these cases.

| Property attributes of `Symbol.isConcatSpreadable` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Exemplos
--------

### Arrays

Por padrão, o `Array.prototype.concat()` espalha (alinha) arrays no seus resultados:


```js
let alpha = ['a', 'b', 'c'],
let numeric = [1, 2, 3]

let alphaNumeric = alpha.concat(numeric)

console.log(alphaNumeric)  // Resultado: ['a', 'b', 'c', 1, 2, 3]
```


Quando configurando o `Symbol.isConcatSpreadable` para `false`, o comportamento padrão dele:


```js
let alpha = ['a', 'b', 'c'],
let numeric = [1, 2, 3]

numeric[Symbol.isConcatSpreadable] = false
let alphaNumeric = alpha.concat(numeric)

console.log(alphaNumeric)  // Resultado: ['a', 'b', 'c', [1, 2, 3] ]
```

### Objetos de array semelhantes

Para objetos de array semelhantes, o padrão não é espalhado. `Symbol.isConcatSpreadable`precisa ser configurado para `true` para poder conseguir um a array alinhada:


```js
let x = [1, 2, 3];

let fakeArray = {
  [Symbol.isConcatSpreadable]: true,
  length: 2,
  0: "hello",
  1: "world",
};

x.concat(fakeArray); // [1, 2, 3, "hello", "world"]
```


**Nota:** A propriedade `length` é usada para controlar o número de propriedade dos objetos para ser adicionado. No exemplo acima, `length:2` indica que duas propriedades tem de ser adicionado.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.isconcatspreadable |

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

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

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

* `Array.prototype.concat()`