String.raw() - JavaScript

String.raw()
============

O método estático `String.raw()` é uma função tag de modelos literais, similar ao prefixo `r` no Python ou o prefixo `@` no C# para string literais (Mas não é *idêntico*, existe uma diferença, veja explicações nessa discussão). Ele é usado para pegar as strings no formato "cru" de modelos literais, isto é, substituições (ex: `${foo}`) são processados, mas "escapes" (ex:. `\n`) não são.

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

Sintaxe
-------
```

String.raw(callSite, ...sub)

String.raw`templateString`
```

### Parâmetros

`callSite`

Modelo bem-formatado de objeto de local de chamada, como `{ raw: ['foo', 'bar', 'baz'] }`.

`...substitutions`

Contém os valores das substituições.

`templateString`

Um modelo string, opcionalmente com substituições (`${...}`).

### Valor retornado

A forma crua de uma string de um modelo string dado.

### Exceções

`TypeError`

Um `TypeError` é jogado se o primeiro argumento não é um Objeto bem formado.

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

Na maioria dos casos, `String.raw()` é usado com modelos de strings. A primeira sintaxe mencionada acima raramente é usada, porque o mecanismo JavaScript a chamará com os argumentos apropriados para você, assim como com outras funções de tag.

`String.raw()` é a única função de tag embutida de strings de template; ele funciona exatamente como a função de modelo padrão e executa a concatenação. Você pode até reimplementá-lo com o código JavaScript normal.

Exemplos
--------

### Usando `String.raw()`

```js
String.raw`Hi\n${2 + 3}!`;
// 'Hi\n5!', o caractere após 'Hi'
// não é um caractere de quebra de linha,
// '\' e 'n' são dois caracteres.

String.raw`Hi\u000A!`;
// 'Hi\u000A!', o mesmo aqui, agora nós teremos os caracteres
// \, u, 0, 0, 0, A, 6.
// Todos as formas de quebra de linha serão ineficazes
// e as contra barras estarão inclusas no valor retornado.
// Você pode confirmar isso verificando a propriedade .length
// da string.

let name = "Bob";
String.raw`Hi\n${name}!`;
// 'Hi\nBob!', substituições são processadas.

// Normalmente você não chamaria String.raw() como uma função,
// mas para simular `t${0}e${1}s${2}t` você pode fazer:
String.raw({ raw: "test" }, 0, 1, 2); // 't0e1s2t'
// Note que 'test', uma string, é um objeto array-like
// O código abaixo é equivalente a:
// `foo${2 + 3}bar${'Java' + 'Script'}baz`
String.raw(
  {
    raw: ["foo", "bar", "baz"],
  },
  2 + 3,
  "Java" + "Script",
); // 'foo5barJavaScriptbaz'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.raw |

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

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

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

* Modelos de strings
* `String`
* Gramática lexical


String.fromCharCode() - JavaScript

String.fromCharCode()
=====================

O método **`String.fromCharCode()`** retorna uma string criada ao usar uma sequência específica de valores Unicode.

Sintaxe
-------
```

String.fromCharCode(num1[, ...[, numN]])
```

### Parâmetros

`num1, ..., numN`

Uma sequência de números que devem ser valores UTF-16. O tamanho é entre `0` e `65535` (`0xFFFF`). Números maiores do que `0xFFFF` são desconsiderados. Nenhuma verificação de vadalida é realizada.

### Valor retornado

Uma string contendo os caracteres correspondentes à sequência de valores Unicode.

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

Esse método retorna uma string e não um objeto `String`.

Como `fromCharCode()` é um método estático de `String`, você sempre o usará como `String.fromCharCode()`, ao invés de um método de um objeto `String` que você tenha criado.

Exemplos
--------

### Usando `fromCharCode()`

O seguinte exemplo retorna a string "ABC".

```js
String.fromCharCode(65, 66, 67); // retorna "ABC"
```

Fazendo-o funcionar com valores maiores
---------------------------------------

Embora os valores Unicode mais comuns possam ser representados com um número de 16 bits (como esperado durante a padronização do JavaScript) e o fromCharCode() possa ser usado para retornar um único caracter dos valores mais comuns (por exemplo: valores UCS-2 que são os melhores subconjuntos do UTF-16 com os caractres mais comuns), a fim de resolver TODOS os valores Unicode legais (até 21 bits) o método fromCharCode() sozinho é inadequado. Como os caracteres de ponto de código mais alto usam 2 (valor menor) numeros "substitutos" para formar um único caracter, `String.fromCodePoint()` (parte do padrão ES2015) pode ser usado para retornar tal par e ainda representar adequadamente esses caracteres de valores altos.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.fromcharcode |

Navegadores compatíveis
-----------------------

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

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

* `String.fromCodePoint()`
* `String.prototype.charAt()`
* `String.prototype.charCodeAt()`
* `String.prototype.codePointAt()`


String.prototype.slice() - JavaScript

String.prototype.slice()
========================

Sumário
-------

O método `slice()` extrai uma parte de uma string e a retorna como uma nova string, sem modificar a string original.

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

Sintaxe
-------
```

str.slice(startIndex[, endIndex])
```

### Paramêtros

`startIndex`

É o índice, de base zero, onde se inicia a extração. Se for um número negativo, será o mesmo que executar *`str.length + startIndex`* (por exemplo, se *`startIndex`* for *`-3`*, será o mesmo que executar *`str.length - 3`*).

```js
const nome = "Ricardo";
console.log(nome.slice(-3)); // retorna 'rdo'
```

Se *`startIndex`* for maior ou igual a `str.length`, uma string vazia será retornada.

```js
const nome = "Ricardo";
console.log(nome.slice(7)); // retorna <empty string>'
```

`endIndex`

Opcional. É o índice, de base zero, onde termina a extração. O caractere que possuir este índice não será incluso.

Se omitido ou possuir valor de *`undefined`*, ou for maior que `str.length`, *`slice()`* extrairá até o fim da string.

```js
const nome = "Ricardo";

// omitindo fimSlice
console.log(nome.slice(0)); // retorna 'Ricardo'

// undefined fimSlice
let i; // variável criada sem atribuir valor
console.log(nome.slice(0, i)); // retorna 'Ricardo'

// passando número maior que o tamanho da string
console.log(nome.slice(0, 7)); // retorna 'Ricardo'
```

Se negativo, é o mesmo que executar *`str.length + endIndex`* onde *`str.length`* é o tamanho da string (por exemplo, se *`endIndex`* é *`-3`*, é como executar `str.length - 3`).

```js
const nome = "Ricardo";
console.log(nome.slice(0, -3)); // retorna 'Rica'
```

Se for um valor diferente de indefinido e, ao mesmo tempo não for um número, uma string vazia será retornada

```js
const nome = "Ricardo";
let i; // variável criada sem valor atribuído

// passando algum valor ≠ de undefined e ≠ de número
console.log(nome.slice(0, NaN)); // retorna <empty string>
console.log(nome.slice(2, false)); // retorna <empty string>
console.log(nome.slice(5, i)); // retorna 'Ricardo'
```

Se `endIndex` for definido e `startIndex` for negativo, `endIndex` deve ser negativo também, do contrário uma string vazia é retornada.

```js
const nome = "Ricardo";
console.log(nome.slice(-3, 0)); // retorna <empty string>
```

Caso `endIndex` seja definido e `startIndex` e `endIndex` sejam ambos positivos ou negativos, `endIndex` deve ser maior que `startIndex`, do contrário uma string vazia é retornada.

```js
const nome = "Ricado";
console.log(nome.slice(-1, -3)); // retorna <empty string>
console.log(nome.slice(3, 1)); // retorna <empty string>
```

### Retorno

Uma nova string contento a porção extraída da string.

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

*`slice()`* extrai um texto de uma string e retorna uma nova string. Modificações realizadas no texto de uma string não afetam a outra string.

*`slice()`* extrai até, mas não inclue *`endIndex`.*

`str.slice(1, 4)` extrai a partir do segundo caractere até o quarto caractere (ou seja, os caracteres de índices *`1`*, *`2`*, e *`3`*).

Por exemplo, *`str.slice(2, -1)`* extrai a partir do terceiro carácter até o penúltimo caractere da string.

```js
const nome = "Ricardo";
console.log(nome.slice(2, -1)); // retorna 'card'
```

Exemplos
--------

### Exemplo: Usando `slice()` para criar uma nova string

O exemplo a seguir usa *`slice()`* para criar uma nova string.

```js
var str1 = "A manhã está sobre nós", // o tamanho de str1 é 22
  str2 = str1.slice(3, 10),
  str3 = str1.slice(2, -2),
  str4 = str1.slice(13),
  str5 = str1.slice(22);
console.log(str2); // retorna 'anhã es'
console.log(str3); // retorna 'manhã está sobre n'
console.log(str4); // retorna 'sobre nós'
console.log(str5); // retorna <empty string>
```

### Exemplo: Usando `slice()` com índices negativos

O exemplo a seguir usa o *`slice()`* com índices negativos.

```js
var str = "A manhã está sobre nós";
str.slice(-3); // retorna 'nós'
str.slice(-3, -1); // retorna 'nó'
str.slice(0, -1); // retorna 'A manhã está sobre nó'
```

O exemplo abaixo percorre o índice no sentido anti-horário (de trás para frente) até chegar ao índice 11 da string, que será o início. Logo após, percorre o índice da string no sentido horário até chegar ao índice 16 da string, que será o fim.

```js
console.log(str.slice(-11, 16)); // retorna "á sob"
```

O exemplo abaixo percorre o índice no sentido horário até chegar ao índice 10 da string, que será o início. Logo após, percorre o índice da string no sentido anti-horário até chegar ao índice 7 da string, que será o fim.

```js
console.log(str.slice(10, -7)); // retorna "tá so"
```

O exemplo abaixo percorre o índice no sentido anti-horário até chegar ao índice 5 da string, que será o início. Logo após, percorre o índice da string novamente no sentido anti-horário até chegar ao índice 1 da string, que será o fim.

```js
console.log(str.slice(-5, -1)); // retorna "e nó"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.slice |

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

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

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

* `String.prototype.substr()`
* `String.prototype.substring()`
* `Array.prototype.slice()`


String.prototype.codePointAt() - JavaScript

String.prototype.codePointAt()
==============================

O método **`codePointAt()`** retorna um número inteiro não negativo que é o valor do ponto de código Unicode.

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

Sintaxe
-------
```

str.codePointAt(pos)
```

### Parâmetros

`pos`

A posição de um elemento em uma string a partir do qual retorna o valor do ponto de código.

### Valor retornado

Um número que representa o valor do ponto de código do caractere na `pos` fornecida. Se não houver nenhum elemento na `pos`, `undefined` é retornado.

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

Se não houver nenhum elemento na posição especificada, é retornado o valor de `undefined`. Se nenhum par substituto UTF-16 começar na `pos`, a unidade de código na `pos` será retornada.

Polyfill
--------

O seguinte código cria no objeto global String a função `codePointAt()` conforme especificado em ECMAScript 2015 para navegadores sem suporte nativo:

```js
/\*! https://mths.be/codepointat v0.2.0 by @mathias \*/
if (!String.prototype.codePointAt) {
  (function () {
    "use strict"; // needed to support `apply`/`call` with `undefined`/`null`
    var defineProperty = (function () {
      // IE 8 only supports `Object.defineProperty` on DOM elements
      try {
        var object = {};
        var $defineProperty = Object.defineProperty;
        var result = $defineProperty(object, object, object) && $defineProperty;
      } catch (error) {}
      return result;
    })();
    var codePointAt = function (position) {
      if (this == null) {
        throw TypeError();
      }
      var string = String(this);
      var size = string.length;
      // `ToInteger`
      var index = position ? Number(position) : 0;
      if (index != index) {
        // better `isNaN`
        index = 0;
      }
      // Account for out-of-bounds indices:
      if (index < 0 || index >= size) {
        return undefined;
      }
      // Get the first code unit
      var first = string.charCodeAt(index);
      var second;
      if (
        // check if it’s the start of a surrogate pair
        first >= 0xd800 &&
        first <= 0xdbff && // high surrogate
        size > index + 1 // there is a next code unit
      ) {
        second = string.charCodeAt(index + 1);
        if (second >= 0xdc00 && second <= 0xdfff) {
          // low surrogate
          // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
          return (first - 0xd800) \* 0x400 + second - 0xdc00 + 0x10000;
        }
      }
      return first;
    };
    if (defineProperty) {
      defineProperty(String.prototype, "codePointAt", {
        value: codePointAt,
        configurable: true,
        writable: true,
      });
    } else {
      String.prototype.codePointAt = codePointAt;
    }
  })();
}
```

Exemplos
--------

### Usando `codePointAt()`

```js
"ABC".codePointAt(1); // retorna 66
"\uD800\uDC00".codePointAt(0); // retorna 65536

"XYZ".codePointAt(42); // retorna undefined
```

### Criando um loop com `codePointAt()`

```js
for (let codePoint of "\ud83d\udc0e\ud83d\udc71\u2764") {
  console.log(codePoint.codePointAt(0).toString(16));
}
// retorna '1f40e', '1f471', '2764'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.codepointat |

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

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

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

* `String.fromCodePoint()`
* `String.fromCharCode()`
* `String.prototype.charCodeAt()`
* `String.prototype.charAt()`


String.prototype.repeat() - JavaScript

String.prototype.repeat()
=========================

O método **`repeat()`** constrói e retorna uma nova string com um determinado número de cópias concatenadas da string original.

Sintaxe
-------
```

str.repeat(count);
```

### Parâmetros

`count`

Um número inteiro entre 0 e `+Infinity`, indicando o número de vezes que a string deve ser repetida.

### Valor retornado

Uma nova string contendo o número especificado de cópias da string original.

### Exceções

* `RangeError`: o número de repetições não pode ser negativo.
* `RangeError` (en-US): o número de repetições deve ser menor que infinito e não deve ultrapassar o tamanho máximo da string.
Exemplos
--------

```js
"abc".repeat(-1); // RangeError
"abc".repeat(0); // ''
"abc".repeat(1); // 'abc'
"abc".repeat(2); // 'abcabc'
"abc".repeat(3.5); // 'abcabcabc' (o número será convertido para inteiro)
"abc".repeat(1 / 0); // RangeError

({ toString: () => "abc", repeat: String.prototype.repeat }).repeat(2);
// 'abcabc' (repeat() é um método genérico)
```

Polyfill
--------

O método `repeat()` foi adicionado à especificação ECMAScript 2015 e pode ainda não estar disponível em todas as implementações do JavaScript. No entanto, você pode usar o seguinte polyfill para implementar o `String.prototype.repeat()`:

```js
if (!String.prototype.repeat) {
  String.prototype.repeat = function (count) {
    "use strict";
    if (this == null) {
      throw new TypeError(
        "não é possível converter " + this + " para um objeto",
      );
    }
    var str = "" + this;
    count = +count;
    if (count != count) {
      count = 0;
    }
    if (count < 0) {
      throw new RangeError("o núm. de repetições não pode ser negativo");
    }
    if (count == Infinity) {
      throw new RangeError("o núm. de repetições deve ser menor que infinito");
    }
    count = Math.floor(count);
    if (str.length == 0 || count == 0) {
      return "";
    }

    // Ao Garantir que count seja um inteiro de 31 bits nos dá uma grande otimização
    // na parte principal. Porém, navegadores atuais (de agosto de 2014 pra cá)
    // não conseguem mais manipular strings de 1 << 28 chars ou maiores, então:
    if (str.length \* count >= 1 << 28) {
      throw new RangeError(
        "o núm. de repetições não deve estourar o tamanho máx. de uma string",
      );
    }
    var rpt = "";
    for (var i = 0; i < count; i++) {
      rpt += str;
    }
    return rpt;
  };
}
```

#### Polyfill ES5
```

//#es5
'use strict';
(function(win){
 var typeOf=(function(w){var f=function f(x){return typeof(x)},o=w.Symbol,p;if(o && typeof(o)==='function' && typeof(o.iterator)==='symbol'){p=o.prototype;f=function(x){return x && x.constructor===o && x!==p?'symbol':typeof x}};return f})(win),
 exist=function(o,p,t){return p in o && typeOf(o[p])===t};
 (function(w){
    var o=w.String.prototype;
    if(!exist(o,'repeat','function')){o.repeat=(function(A,E){return function(n){var i=n>>0,s=this,l=s.length,j;if(i===0||l<1){s=''}else{j=268435456;if(i<0||i>=j||i*l>j){throw new RE('Invalidcountvalue')}else if(i>0){s=A(++i).join(s)}};return s}})(w.Array,w.RangeError)};
 })(win);
})(window);

// teste:
console.clear();
console.log(
'abc'.repeat(false),//''
'abc'.repeat({}),//''
'abc'.repeat([]),//''
'abc'.repeat(['']),//''
'abc'.repeat([0]),//''
'abc'.repeat([0,1]),//''
'abc'.repeat([1,1]),//''
'abc'.repeat(0),//''
'abc'.repeat(.6),//''
'abc'.repeat(true),//'abc'
'abc'.repeat(1),//'abc'
'abc'.repeat(2),//'abcabc'
'abc'.repeat([2]),//'abcabc'
'abc'.repeat(3.5),//'abcabcabc'
''.repeat(2)//''
);
console.log(
'abc'.repeat(-Infinity),//RangeError: Invalid count value
'abc'.repeat(Infinity),//RangeError: Invalid count value
'abc'.repeat(1/0),//RangeError: Invalid count value
'abc'.repeat(-1)//RangeError: Invalid count value
);

/*
es5 src:
'use strict';
(function(win){

 var typeOf=(function(w){var f=function f(x){return typeof(x)},o=w.Symbol,p;if(o && typeof(o)==='function' && typeof(o.iterator)==='symbol'){p=o.prototype;f=function(x){return x && x.constructor===o && x!==p?'symbol':typeof x}};return f})(win),
 exist=function(o,p,t){return p in o && typeOf(o[p])===t};

 (function(w){
    var o=w.String.prototype;
    if(!exist(o,'repeat','function')){
        o.repeat=(function(A,E){
            return function(n){
                var i=n>>0,s=this,l=s.length,j;
                if(i===0||l<1){s=''}else{
                    j=268435456;
                    if(i<0||i>=j||i*l>j){throw new RE('Invalidcountvalue')}else if(i>0){s=A(++i).join(s)}
                };
                return s
            };
        })(w.Array,w.RangeError);
    };
    //..
 })(win);

})(window);
*/
```

#### Polyfill ES6
```

//#es6

(w=>{

    const typeOf=(o=>{let f=x=>typeof x;if(o && 'function'===typeof o){const s='symbol';if(s===typeof o.iterator){const p=o.prototype;f=x=>x && x.constructor===o && x!==p?s:typeof x}};return f})(w.Symbol),

    exist=(o,p,t)=>p in o && typeOf(o[p])===t;

    (o=>{

        if(!exist(o,'repeat','function')){const A=w.Array,E=w.RangeError;o.repeat=function(n){var i=n>>0,s='';if(i!==0){let t=this;const l=t.length;if(l!==0){if(i<0||i>=(t=268435456)||i*l>t){throw new E('Invalid count value')}else if(i>0){s=A(++i).join(t)}}};return s}};

    })(w.String.prototype);

})(window);

/*

es6 src:

(w=>{

    const typeOf=(o=>{let f=x=>typeof x;if(o && 'function'===typeof o){const s='symbol';if(s===typeof o.iterator){const p=o.prototype;f=x=>x && x.constructor===o && x!==p?s:typeof x}};return f})(w.Symbol),

    exist=(o,p,t)=>p in o && typeOf(o[p])===t;

    (o=>{

        if(!exist(o,'repeat','function')){

            const A=w.Array;

            o.repeat=function(n){var i=n>>0,s='';if(i!==0){let t=this;const l=t.length;if(l!==0){if(i<0||i>=(t=268435456)||i*l>t){throw new RangeError('Invalid count value')}else if(i>0){s=A(++i).join(t)}}};return s};

        };

        //..

    })(w.String.prototype);

})(window);

*/

//test:

console.clear();

console.log(

'abc'.repeat(false),//''

'abc'.repeat({}),//''

'abc'.repeat([]),//''

'abc'.repeat(['']),//''

'abc'.repeat([0]),//''

'abc'.repeat([0,1]),//''

'abc'.repeat([1,1]),//''

'abc'.repeat(0),//''

'abc'.repeat(.6),//''

'abc'.repeat(true),//'abc'

'abc'.repeat(1),//'abc'

'abc'.repeat(2),//'abcabc'

'abc'.repeat([2]),//'abcabc'

'abc'.repeat(3.5),//'abcabcabc'

''.repeat(2)//''

);

console.log(

'abc'.repeat(-Infinity),//RangeError: Invalid count value

'abc'.repeat(Infinity),//RangeError: Invalid count value

'abc'.repeat(1/0),//RangeError: Invalid count value

'abc'.repeat(-1)//RangeError: Invalid count value

);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.repeat |

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

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

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

* `String.prototype.concat()`


String.prototype.toUpperCase() - JavaScript

String.prototype.toUpperCase()
==============================

O método `toUpperCase()` retorna o valor da string original convertido em letras maiúsculas.

Sintaxe
-------
```

str.toUpperCase()
```

### Valor retornado

Uma nova string representando a string original convertida em maiúsculas.

### Exceções

`TypeError`

Quando chamado em uma string contendo valor `null` ou `undefined`, por exemplo, `String.prototype.toUpperCase.call(undefined)`.

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

O método `toUpperCase()` retorna o valor da string convertido para letras maiúsculas. `toUpperCase()` não altera o valor da string original.

Exemplos
--------

### Uso básico

```js
console.log("alfabeto".toUpperCase()); // 'ALFABETO'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.touppercase |

Navegadores compatíveis
-----------------------

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

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

* `String.prototype.toLocaleLowerCase()`
* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toLowerCase()`


String.prototype.fixed() - JavaScript

String.prototype.fixed()
========================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método **`fixed()`** cria um elemento HTML `<tt>` (en-US) que faz com que uma string seja exibida em uma fonte de densidade fixa.

Sintaxe
-------
```

str.fixed()
```

### Valor retornado

Uma string que representa o elemento HTML <tt> (en-US).

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

 O método `fixed()` cria uma string dentro de uma tag `<tt>`:
 `"<tt>str</tt>"`.

Exemplos
--------

### Usando `fixed()`

O exemplo a seguir usa o método `fixed()` para alterar a formatação de uma string:

```js
var worldString = "Olá, mundo";
console.log(worldString.fixed()); // "<tt>Olá, mundo</tt>"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.fixed |

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

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

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

* `String.prototype.bold()`
* `String.prototype.italics()`
* `String.prototype.strike()`


String.prototype.toLocaleLowerCase() - JavaScript

String.prototype.toLocaleLowerCase()
====================================

O método `toLocaleLowerCase()` retorna o valor da string em minúsculas, de acordo com qualquer mapeamento de caixa de texto específico da localidade.

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

Sintaxe
-------
```

str.toLocaleLowerCase()
str.toLocaleLowerCase(locale)
str.toLocaleLowerCase([locale, locale, ...])
```

### Parâmetros

`locale`

Opcional. O parâmetro `locale` indica o local a ser usado para converter para minúsculas de acordo com qualquer mapeamento de caixa de texto específico da localidade. Se várias localidades forem fornecidas em um `Array`, a melhor localidade disponível é usada. A localidade padrão é a localidade atual do ambiente do host.

### Valor retornado

Uma nova string que representa a string original convertida em minúsculas, de acordo com qualquer mapeamento da caixa de texto específico da localidade.

### Exceções

* Um `RangeError` (en-US) (" invalid language tag: xx\_yy ") é lançado se um argumento `locale` não for uma tag de idioma válido.
* Um `TypeError` (" invalid element in locales argument ") é lançado se um elemento do array não for do tipo string.
Descrição
---------

O método `toLocaleLowerCase()` retorna o valor da string convertida em minúsculas de acordo com qualquer mapeamento da caixa de texto específico da localidade. `toLocaleLowerCase()` não afeta o valor da string original. Na maioria dos casos, ele produzirá o mesmo resultado que `toLowerCase()`, mas para alguns locais, como turco, cujos mapeamentos da caixa de texto não seguem o mapeamento padrão em Unicode, pode haver um resultado diferente.

Exemplos
--------

### Usando `toLocaleLowerCase()`

```js
"ALFABETO".toLocaleLowerCase(); // 'alfabeto'

"\u0130".toLocaleLowerCase("tr") === "i"; // true
"\u0130".toLocaleLowerCase("en-US") === "i"; // false

let locales = ["tr", "TR", "tr-TR", "tr-u-co-search", "tr-x-turkish"];
"\u0130".toLocaleLowerCase(locales) === "i"; // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tolocalelowercase |
| ECMAScript Internationalization API Specification # sup-string.prototype.tolocalelowercase |

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

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

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

* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toLowerCase()`
* `String.prototype.toUpperCase()`


String.prototype.split() - JavaScript

String.prototype.split()
========================

O método `split()` divide uma `String` em uma lista ordenada de substrings, coloca essas substrings em um array e retorna o array. A divisão é feita procurando um padrão, onde o padrão é fornecido como o primeiro parâmetro na chamada do método.

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

Sintaxe
-------
```

str.split([separator[, limit]])
```

### Parâmetros

* O caso mais simples é quando o separador é apenas um único caractere que será usado para dividir a string. Por exemplo, uma string contendo valores separados por tabulação (TSV) poderia ser analisada passando um caractere de tabulação como separador, como este: myString.split ("\ t").
* Se o `separator` contiver vários caracteres, toda a sequência de caracteres deve ser encontrada para ser dividida.
* Se o `separator` for omitido ou não aparecer dentro da `str`, o array retornará um elemento consistindo em toda a string.
* Se o `separator` aparecer no início (ou no final) da string, ele ainda terá o efeito de divisão. O resultado é uma string vazia (ou seja, `str.length == 0`), que aparece na primeira (ou última) posição do array retornado.
* Se o `separator` for uma string vazia (""), `str` será convertido em um array contendo cada um de seus caracteres em UTF-16.

`separator`

Opcional. Especifica o caractere, ou conjunto de caracteres, a ser usado para separar a string. O separador pode ser uma string ou uma expressão regular.

**Aviso:** Quando uma string vazia (`""`) é usada como separador, a string não é dividida por caracteres percebidos pelo usuário (grapheme clusters) ou caracteres Unicode (pontos de código), mas por unidades de código UTF-16. Isso destrói pares substitutos. Consulte "Como você transforma uma string em um array de caracteres em JavaScript?" no StackOverflow.

`limite`

Opcional. Um número inteiro não negativo especificando um limite no número de divisões a serem encontradas. O método `split()` ainda dividirá em cada ocorrência do separador, até que o número de itens divididos corresponda ao limite ou que a string fique aquém do separador.

* O array pode conter menos entradas do que o `limit` se o final da string for alcançado antes que o limite seja atingido.
* Se o `limit` for `0`, `[]` será retornado.

### Valor retornado

Um array de strings divididos em cada ponto onde o separador ocorre na string informada.

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

Quando encontrado, o caractere designado como o `separator` é removido da string e as substrings são retornadas em um array. Se o `separator` não for encontrado ou for omitido, o array irá conter um elemento consistindo da string inteira. Se o `separator` for uma string vazia, `str` será convertida em um array de caracteres.

Se o separador for uma expressão regular que contenha parênteses de captura, cada vez que o `separator` for encontrado, os resultados (incluindo qualquer resultado `undefined`) dos parênteses de captura serão emendados ao array de saída. Entretanto, nem todos os navegadores possuem suporte a isso.

Exemplos
--------

### Usando `split()`

Quando a string está vazia, o `split()` irá retornar um array contendo uma string vazia ao invés de um array vazio. Se a string e o separador forem ambos strings vazias, um array vazio será retornado.

```js
const myString = "";
const splits = myString.split();

console.log(splits);

// retorna [""]
```

O exemplo a seguir define uma função que divide uma string em um array de strings usando o separador especificado. Depois de dividir a string, a função exibe mensagens indicando a string original (antes da divisão), o separador usado, o número de elementos no array e os elementos individuais do array.

```js
function splitString(stringToSplit, separator) {
  var arrayOfStrings = stringToSplit.split(separator);

  console.log('A string original é: "' + stringToSplit + '"');
  console.log('O separador é: "' + separator + '"');
  console.log(
    "O array tem " +
      arrayOfStrings.length +
      " elementos: " +
      arrayOfStrings.join(" / "),
  );
}

var tempestString = "Oh brave new world that has such people in it.";
var monthString = "Jan,Fev,Mar,Abr,Mai,Jun,Jul,Ago,Set,Out,Nov,Dez";

var space = " ";
var comma = ",";

splitString(tempestString, space);
splitString(tempestString);
splitString(monthString, comma);
```

Esse exemplo produz a saída a seguir:
```

A string original é: "Oh brave new world that has such people in it."
O separador é: " "
O array possui 10 elementos: Oh / brave / new / world / that / has / such / people / in / it.

A string original é: "Oh brave new world that has such people in it."
O separador é: "undefined"
O array possui 1 elementos: Oh brave new world that has such people in it.

A string original é: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec"
O separador é: ","
O array possui 12 elementos: Jan / Feb / Mar / Apr / May / Jun / Jul / Aug / Sep / Oct / Nov / Dec
```

### Removendo espaços de uma string

No exemplo a seguir, `split()` procura por 0 ou mais espaços seguidos por um ponto e vírgula seguido por 0 ou mais espaços e, quando encontrar, remove os espaços e os pontos e vírgulas da string. `nameList` é o array retornado como resultado do `split()`.

```js
var names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand ";

console.log(names);

var re = /\s\*;\s\*/;
var nameList = names.split(re);

console.log(nameList);
```

O retorno do código acima são duas linhas. A primeira linha registra a string original e a segunda linha registra o array resultante.
```

Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand
[ "Harry Trump", "Fred Barney", "Helen Rigby", "Bill Abel", "Chris Hand " ]
```

### Retornando um número limitado de divisões

No exemplo a seguir, o `split()` procura por 0 ou mais espaços em uma string e retorna as 3 primeiras divisões que encontrar.

```js
var myString = "Hello World. How are you doing?";
var splits = myString.split(" ", 3);

console.log(splits);
```

O script exibirá o texto a seguir:
```

["Hello", "World.", "How"]
```

### Parênteses de Captura

Se o `separator` contém parênteses de captura, os resultados correspondentes são retornados no array.

```js
var myString = "Hello 1 word. Sentence number 2.";
var splits = myString.split(/(\d)/);

console.log(splits);
```

O script exibirá o texto a seguir:
```

[ "Hello ", "1", " word. Sentence number ", "2", "." ]
```

**Nota:**`\d` corresponde à classe de caracteres para dígitos entre 0 e 9.

### Revertendo uma String usando `split()`

**Aviso:** Esta não é a melhor maneira de reverter uma string:

```js
const str = "asdfghjkl";
const strReverse = str.split("").reverse().join("");
// 'lkjhgfdsa'

// split() retorna um array onde os métodos
// reverse() e join() podem ser aplicados
```

Não funciona se a string contém `grapheme clusters`, mesmo ao usar uma divisão compatível com Unicode. (Use, por exemplo, esrever no lugar.)

```js
const str = "résumé";
const strReverse = str.split(/(?:)/u).reverse().join("");
// retorna "́emuśer"
```

**Bonus:** use o operador `===` (en-US) para testar se a string original era um palíndromo.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.split |

Navegadores compatíveis
-----------------------

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

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

* `String.prototype.charAt()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `Array.prototype.join()`


String.prototype.valueOf() - JavaScript

String.prototype.valueOf()
==========================

O método `valueOf()` retorna o valor primitivo de um objeto `String`.

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

Sintaxe
-------
```

str.valueOf()
```

### Valor retornado

Uma string representando o valor primitivo de um objeto `String`.

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

O método `valueOf()` do objeto `String` retorna o valor primitivo de um objeto `String` como um dado do tipo string. Esse valor é equivalente a `String.prototype.toString()`.

Esse método é normalmente chamado internamente pelo JavaScript e não fica explícito no código.

Exemplos
--------

### Usando `valueOf()`

```js
var x = new String("Olá, mundo");
console.log(x.valueOf()); // retorna 'Olá, mundo'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.valueof |

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

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

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

* `String.prototype.toString()`
* `Object.prototype.valueOf()`


String.prototype.localeCompare() - JavaScript

String.prototype.localeCompare()
================================

O método `localeCompare()` retorna um número que indica se uma string de referência vem antes ou depois, ou é a mesma que a string fornecida na ordem de classificação.

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

Os novos argumentos *`locales`* e *`options`* permitem que os aplicativos especifiquem o idioma cuja ordem da ordenação deve ser usada e personalizem o comportamento da função. Em implementações mais antigas, que ignoram os argumentos *`locales`* e *`options`*, a localidade e a ordem de classificação usadas são totalmente dependentes da implementação.

Sintaxe
-------
```

referenceStr.localeCompare(compareString[, locales[, options]])
```

### Parâmetros

`compareString`

A string com a qual a *`referenceStr`* é comparada.

`locales` \_e \_`options`

Esses argumentos personalizam o comportamento da função e permitem que os aplicativos especifiquem o idioma cujas convenções de formatação devem ser usadas. Em implementações que ignoram os argumentos *`locales`* e *`options`*, a localidade usada e a forma da string retornada são inteiramente dependentes da implementação.

Consulte o construtor `Intl.Collator()` (en-US) para obter detalhes sobre esses parâmetros e como usá-los.

### Valor retornado

Um número **negativo** se *`referenceStr`* ocorrer antes de *`compareString`*. Um número **positivo** se o *`referenceStr`* ocorrer após *`compareString`*. `0` se eles forem equivalentes.

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

Retorna um inteiro indicando se *`referenceStr`* vem antes, depois ou é equivalente a *`compareString`*.

* Negativo quando o *`referenceStr`* ocorre antes de *`compareString`*
* Positivo quando o *`referenceStr`* ocorre após *`compareString`*
* Retorna `0` se eles forem equivalentes

**Aviso:** **NÃO confie em valores de retorno exatos de -1 ou 1!**

Os resultados de números inteiros negativos e positivos variam entre os navegadores (bem como entre as versões dos navegadores) porque a especificação W3C exige apenas valores negativos e positivos. Alguns navegadores podem retornar `-2` ou `2`, ou mesmo algum outro valor negativo ou positivo.

Performance
-----------

Ao comparar um grande número de strings, como na classificação de grandes arrays, é melhor criar um objeto `Intl.Collator` (en-US) e usar a função fornecida por sua propriedade `compare` (en-US).

Exemplos
--------

### Usando `localeCompare()`

```js
// A letra "a" está antes de "c" produzindo um valor negativo
"a".localeCompare("c"); // -2 ou -1 (ou algum outro valor negativo)

// Alfabeticamente, a palavra "verificar" vem depois de "contra", produzindo um valor positivo
"verificar".localeCompare("contra"); // 2 ou 1 (ou algum outro valor positivo)

// "a" e "a" são equivalentes, resultando em um valor neutro de zero
"a".localeCompare("a"); // 0
```

### Ordenar um array

`localeCompare()` permite a ordenação sem distinção entre maiúsculas e minúsculas em um array.

```js
let items = ["réservé", "Premier", "Cliché", "communiqué", "café", "Adieu"];
items.sort((a, b) => a.localeCompare(b, "fr", { ignorePunctuation: true }));
// ['Adieu', 'café', 'Cliché', 'communiqué', 'Premier', 'réservé']
```

### Verifique o suporte do navegador para os novos argumentos

Os argumentos *`locales`* e *`options`* ainda não são suportados em todos os navegadores.

Para verificar se uma implementação os suporta, use o argumento `"i"` (um requisito de rejeição das tags de linguagem ilegal) e procure uma exceção `RangeError` (en-US):

```js
function localeCompareSupportsLocales() {
  try {
    "foo".localeCompare("bar", "i");
  } catch (e) {
    return e.name === "RangeError";
  }
  return false;
}
```

### Usando `locales`

Os resultados fornecidos por `localeCompare()` variam entre os idiomas. Para obter a ordem de classificação do idioma usado na interface do usuário de seu aplicativo, certifique-se de especificar esse idioma (e possivelmente alguns idiomas substitutos) usando o argumento *`locales`*:

```js
console.log("ä".localeCompare("z", "de")); // um valor negativo: em alemão, ä é classificado antes de z
console.log("ä".localeCompare("z", "sv")); // um valor positivo: em sueco, ä é classificado após z
```

### Usando `options`

Os resultados fornecidos por `localeCompare()` podem ser personalizados usando o argumento *`options`*:

```js
// em alemão, ä tem a como letra base
console.log("ä".localeCompare("a", "de", { sensitivity: "base" })); // 0

// em sueco, ä e a são letras de base separadas
console.log("ä".localeCompare("a", "sv", { sensitivity: "base" })); // um valor positivo
```

### Ordenação numérica

```js
// por padrão, "2" > "10"
console.log("2".localeCompare("10")); // 1

// numeric using options:
console.log("2".localeCompare("10", undefined, { numeric: true })); // -1

// numeric using locales tag:
console.log("2".localeCompare("10", "en-u-kn-true")); // -1
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.localecompare |
| ECMAScript Internationalization API Specification # sup-String.prototype.localeCompare |

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

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

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

* `Intl.Collator` (en-US)


String.prototype.anchor() - JavaScript

String.prototype.anchor()
=========================

 **Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método **`anchor()`** cria uma string começando com uma tag inicial `<a name="...">`, um texto e uma tag final `</a>`.

**Aviso:** Não use este método. Ao invés, use DOM APIs. Além disso, a especificação HTML não permite mais que o elemento <a> tenha um atributo **"name"**, portanto, esse método nem mesmo cria uma tag válida.

Sintaxe
-------
```

str.anchor(name)
```

### Parâmetros

`name`

Uma string que deve representar o valor do atributo *`name`.*

### Valor retornado

Uma string começando com uma tag de início *`<a name="name">`*, depois o valor da string e, em seguida, uma tag de fim *`</a>`*.

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

Não use este método. Ao invés, use DOM APIs. Além disso, a especificação HTML não permite mais que o elemento *`<a>`* tenha um atributo **"name"**, portanto, esse método nem mesmo cria uma tag válida.

Exemplos
--------

### Usando `anchor()`

```js
const nome = 'Ricardo';
console.log(nome.anchor('https://developer.mozilla.org/pt-BR/)');
```

irá retornar o seguinte código HTML:

```html
'<a name="https://developer.mozilla.org/pt-BR/">Ricardo</a>'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.anchor |

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

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

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

* `String.prototype.link()`


String.prototype.search() - JavaScript

String.prototype.search()
=========================

O método `search()` realiza uma busca por uma ocorrência entre uma expressão regular e uma `String`.

Sintaxe
-------
```

str.search(regexp)
```

### Parâmetros

`regexp`

Um objeto contendo uma expressão regular. Se um objeto `obj` for passado como parâmetro e não for do tipo `RegExp`, ele será implicitamente convertido para uma `RegExp` através da instrução `new RegExp(obj)`.

### Valor retornado

O índice na string do primeiro trecho que satisfaz a expressão regular. Do contrário, o valor `-1` será retornado.

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

Quando você quiser saber se um padrão foi encontrado, e também saber seu índice dentro de uma string, use `search()`. (Se você deseja apenas saber se ele existe, use o método semelhante `test()` do protótipo RegExp, que retorna um booleano.)

Para obter mais informações (mas em compensação a execução se torna mais lenta), use `match()` (semelhante ao método `exec()` da RegExp).

Exemplos
--------

### Usando `search()`

O exemplo a seguir pesquisa uma string com dois objetos `regexp` diferentes para mostrar uma pesquisa bem-sucedida (valor positivo) vs. uma pesquisa mal-sucedida (-1).

```js
let str = "hey JudE";
let re = /[A-Z]/g;
let reDot = /[.]/g;
console.log(str.search(re)); // retorna 4, que é o índice da primeira letra maiúscula "J"
console.log(str.search(reDot)); // retorna -1 pois não conseguiu encontrar o ponto "."
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.search |

Navegadores compatíveis
-----------------------

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

Notas específicas para a engine Gecko
-------------------------------------

* Antes do Gecko 8.0, `search()` foi implementado incorretamente. Quando era chamadosem parâmetros ou com `undefined`, ele buscava pela string '`undefined`', ao invés de buscar pela string vazia. Isto foi corrigido. Agora `'a'.search()` e `'a'.search(undefined)` corretamente retornam 0.
* A partir do Gecko 39, o argumento não-padrão `flags` está defasado (deprecated) e dispara um aviso no console (Erro do Firefox 1142351).
* A partir do Gecko 47, o argumento não-padrão `flags` não é mais suportado em builds *non-release* e em breve será removido inteiramente (Erro do Firefox 1245801).
* A partir do Gecko 49, o argumento não-padrão `flags` não é mais suportado (Erro do Firefox 1108382).
Veja também
-----------

* `String.prototype.match()`
* `RegExp.prototype.exec()`


String.prototype.sup() - JavaScript

String.prototype.sup()
======================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método `sup()` cria um elemento HTML `<sup>` (en-US) que faz com que uma string seja exibida como sobrescrito.

Sintaxe
-------
```

str.sup()
```

### Valor retornado

Uma string contendo um elemento HTML `<sup>` (en-US).

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

O método `sup()` cria uma string dentro de uma tag `<sup>`: `"<sup>str</sup>"`

Exemplos
--------

### Usando os métodos `sub()` e `sup()`

O exemplo a seguir usa os métodos `sub()` e `sup()` para formatar uma string:

```js
var superText = "superscript";
var supText = "supscript";

console.log("This is what a " + superText.sup() + " looks like.");
// "This is what a <sup>superscript</sup> looks like."

console.log("This is what a " + supText.sup() + " looks like.");
// "This is what a <sup>supscript</sup> looks like."
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.sup |

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

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

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

* `String.prototype.sup()`


String.prototype.big() - JavaScript

String.prototype.big()
======================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método **big()** cria um elemento HTML <big> fazendo com que o texto dentro dele seja exibido uma uma fonte maior.

**Nota:** O elemento <big> foi removido no HTML5 (en-US) e não deve mais ser usado. Em vez disso, web developers devem usar a propriedade CSS correspondente.

Sintaxe
-------
```

str.big()
```

### Valor retornado

Uma string contendo um elemento HTML.

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

 O método `big()` cria uma string dentro de uma tag `<big>`:
 `"<big>str</big>"`.

Exemplos
--------

### Usando `big()`

Os exemplos abaixo usam métodos do objeto String para alterar o tamanho de uma string:

```js
var worldString = "Olá, mundo";

console.log(worldString.small()); // <small>Olá, mundo</small>
console.log(worldString.big()); // <big>Olá, mundo</big>
console.log(worldString.fontsize(7)); // <fontsize=7>Olá, Mundo</fontsize>
```

Com o objeto `element.style` você pode selecionar o atributo `style` do elemento e manipulá-lo de forma mais genérica, por exemplo:

```js
document.getElementById("#oIdDoElemento").style.fontSize = "2em";
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.big |

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

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

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

* `String.prototype.fontsize()`
* `String.prototype.small()`


String.prototype.lastIndexOf() - JavaScript

String.prototype.lastIndexOf()
==============================

O método `lastIndexOf()` retorna o índice da última ocorrência do valor especificado encontrado na `String`. Quando `fromIndex` é especificado, a pesquisa é realizada de trás para frente. Retorna `-1` se o valor não for encontrado.

Sintaxe
-------
```

str.lastIndexOf(searchValue[, fromIndex])
```

### Parâmetros

`searchValue`

Uma string representando o valor a ser procurado. Se `searchValue` for uma string vazia, `str.length` é retornado.

`fromIndex`

Opcional. O índice no qual a pesquisa será iniciada de trás para frente. O valor padrão é `+Infinity`. Se `fromIndex >= str.length`, toda string é pesquisada. Se `fromIndex < 0`, o comportamento será o mesmo que seria com o índice `0`.

### Valor retornado

O índice da última ocorrência referente ao valor especificado em `searchValue`. É retornado `-1` se nada for encontrado.

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

Os caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é `0`, e o índice do último caractere é `str.length - 1`.

```js
"ricardo".lastIndexOf("r"); // retorna 4
"ricardo".lastIndexOf("a", 3); // retorna 3
"ricardo".lastIndexOf("a", 0); // retorna -1
"ricardo".lastIndexOf("x"); // retorna -1
"ricardo".lastIndexOf("r", -5); // retorna 0
"ricardo".lastIndexOf("r", 0); // retorna 0
"ricardo".lastIndexOf(""); // retorna 7
"ricardo".lastIndexOf("", 2); // retorna 2
```

### Sensível a maiúsculas e minúsculas

O método `lastIndexOf()` é sensível a letras maiúsculas e minúsculas. Por exemplo, a seguinte expressão retorna `-1`:

```js
"Blue Whale, Killer Whale".lastIndexOf("blue"); // retorna -1
```

Exemplos
--------

### Usando `lastIndexOf()`

O seguinte exemplo usa `lastIndexOf()` para localizar valores nas string `"Brave new world"`.

```js
var anyString = "Brave new world";

console.log(
  "O índice do primeiro w a partir do final é " + anyString.lastIndexOf("w"),
);
// retorna 10

console.log(
  'O índice de "new" a partir do final é ' + anyString.lastIndexOf("new"),
);
// retorna 6
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.lastindexof |

Navegadores compatíveis
-----------------------

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

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

* `String.prototype.charAt()`
* `String.prototype.indexOf()`
* `String.prototype.split()`
* `Array.prototype.indexOf()`
* `Array.prototype.lastIndexOf()`


String.prototype.bold() - JavaScript

String.prototype.bold()
=======================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método **`bold()`** cria um elemento HTML <b> que faz com que uma string seja exibida em negrito.

Sintaxe
-------
```

str.bold()
```

### Valor retornado

Uma string contendo um elemento HTML <b> .

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

 O método `bold()` cria uma string dentro de uma tag `<b>`:
 `"<b>str</b>"`.

Exemplos
--------

### Usando `bold()`

Os exemplos abaixo usam métodos do objeto String para alterar a formatação de uma string:

```js
var worldString = "Olá, mundo";

console.log(worldString.blink()); // <blink>Olá, mundo</blink>
console.log(worldString.bold()); // <b>Olá, mundo</b>
console.log(worldString.italics()); // <i>Olá, mundo</i>
console.log(worldString.strike()); // <strike>Olá, mundo</strike>
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.bold |

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

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

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

* `String.prototype.blink()`
* `String.prototype.italics()`
* `String.prototype.strike()`


String.length - JavaScript

String.length
=============

A propriedade `length` de um objeto `String` contém o comprimento da string. `length` é uma propriedade `read-only` (somente leitura) de instâncias de string.

Sintaxe
-------
```

str.length
```

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

Essa propriedade retorna o número de unidades de código presentes na string. UTF-16, a codificação utilizada pelo JavaScript, utiliza uma unidade de código de 16-bits para representar os caracteres mais comuns, mas precisa usar duas unidades para caracteres menos usados, então é possível que o valor retornado por `length` não seja exatamente o número de caracteres na string.

ECMASCript 2016 (ed. 7) estabeleceu um comprimento máximo de `2^53 - 1` elementos. Anteriormente, nenhum comprimento máximo havia sido especificado. No Firefox, as strings têm um comprimento (`length`) máximo de `2**30 - 2` (~ 1 GB). Em versões anteriores ao Firefox 65, o comprimento máximo era `2**28 - 1` (~ 256 MB).

Para uma string vazia, `length` é `0`.

A propriedade estática `String.length` retorna o valor `1`.

Exemplos
--------

### Uso básico

```js
var x = "Mozilla";
var empty = "";

console.log(
  "Mozilla possui " + x.length + " unidades de código de comprimento",
);
/\* "Mozilla possui 7 unidades de código de comprimento" \*/

console.log("A string vazia possui um comprimento de " + empty.length);
/\* "A string vazia possui um comprimento de 0" \*/
```

### Atribuindo valor ao comprimento

```js
let myString = "campainhas";

// A tentativa de atribuir um valor à propriedade .length
// de uma string não tem efeito observável.

myString.length = 4;
console.log(myString);
// retorna "campainhas"
console.log(myString.length);
// retorna 10
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-properties-of-string-instances-length |

Navegadores compatíveis
-----------------------

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

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

* JavaScript `String.length` and Internationalizing Web Applications


String.prototype.toLowerCase() - JavaScript

String.prototype.toLowerCase()
==============================

O método **`toLowerCase()`** retorna o valor da string que foi chamada convertido para minúsculo.

Sintaxe
-------
```

str.toLowerCase()
```

### Valor retornado

Uma nova string contendo o valor da string original convertido para minúsculo.

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

O método `toLowerCase()` retorna o valor da string original convertido para minúsculo. `toLowerCase()` não altera o valor da string original.

Exemplos
--------

### Usando `toLowerCase()`

```js
console.log("ALFABETO".toLowerCase()); // 'alfabeto'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tolowercase |

Navegadores compatíveis
-----------------------

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

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

* `String.prototype.toLocaleLowerCase()`
* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toUpperCase()`


String.prototype.replace() - JavaScript

String.prototype.replace()
==========================

Resumo
------

O método `replace()` retorna uma nova string com algumas ou todas as correspondências de um padrão substituídas por um determinado caractere (ou caracteres). O padrão pode ser uma string ou uma `RegExp`, e a substituição pode ser uma string ou uma função a ser chamada para cada correspondência. Se o padrão for uma string, apenas a primeira ocorrência será substituída.

A string original não é modificada.

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

Sintaxe
-------
```

str.replace(regexp|substr, newSubStr|function)
```

### Parâmetros

`regexp`

Um objeto `RegExp` ou literal. A correspondência ou correspondências são substituídas por *`newSubStr`* ou o valor retornado pela `function` especificada.

`substr`

Uma `String` que será substituída por `newSubStr`. Ele é tratado como uma string textual e não é interpretado como uma expressão regular. Apenas a primeira ocorrência será substituída.

`newSubStr`

A `String` que substitui a `substr` recebida do parâmetro #1. Uma série de padrões de substituições especiais são suportados. Veja a seção "

Especificando uma string como parâmetro

" abaixo.

`function`

A função (function) chamada cria uma nova substring (para ser colocada no lugar da substring recebida pelo parametro #1). Os argumentos fornececidos para essa função estão descritos na seção "

Especificando uma função como parâmetro

" mais abaixo.

`flags`
Non-standard

Uma string especificando uma combinação de flags de expressão regular. O uso do parâmetro `flags` no método `String.prototype.replace()` é não-padrão. Ao invés de usar este parâmetro, use um objeto `RegExp` com as flags correspondentes. O valor deste parâmetro deve ser uma string consistindo em um ou mais dos seguintes caracteres para afetar a operação, tais como descrito:

`g`

Combinação global.

`i`

Ignora diferenças entre maiúsculas e minúsculas.

`m`

Combinação em várias linhas.

`y`
Experimental

Sticky

>
> \*\*Nota:\*\*O argumento `flags` não funciona no v8 Core (Chrome e NodeJs).
>
>
>

### Valor retornado

Uma nova string com alguma ou todas as combinações do padrão substituído(s) pelo valor de substituição.

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

Este método não muda o objeto `String`. Ele simplesmente retorna uma nova string.

Para realizar uma pesquisa global e substituir, inclua a flag `g` na expressão regular ou se o primeiro parâmetro for uma string, inclua `g` no parâmetro flags.

### Especificando uma string como parâmetro

A string substituidora pode incluir o seguinte padrão de substituição especial:

| **Padrão** | **Insere** |
| --- | --- |
| `$$` | Insere um "$". |
| `$&` | Insere a string casada. |
| `$`` | Insere a porção da string que precede a substring combinada. |
| `$'` | Insere a porção da string que segue a substring combinada. |
| `$n` ou `$nn` | Onde `n` ou `nn` são dígitos decimais, insere a *n*-ésima substring entre parêntesis casada, dado o primeiro argumento foi um objeto `RegExp`. |

### Especificando uma função como parâmetro

Você pode especificar uma função no segundo parâmetro. Neste caso, a função será chamada depois que a correspôndecia for encontrada. O resultado da função (valor retornado) será usado como a string substituta. (Atenção: os padrões de substituição citados acima não se aplicam neste caso). Note que a função será chamada múltiplas vezes para combinação que deve ser substituída se a expressão regular no primeiro parâmetro tiver a regra global.

Os parâmetros da função são:

| **Possíveis nomes** | **Valor fornecido** |
| --- | --- |
| `match` | A substring encontrada. Corresponde ao `$&` acima. |
| `p1, p2, ...` | O enésimo parâmetro entre parênteses da RegEx no primeiro parâmetro na função `replace()` `RegExp`. (Corresponde a `$1`, `$2`, etc. acima.) Por exemplo, se `/(\a+)(\b+)/`, for o primeiro parâmetro, `p1` é a combinação para `\a+`, e `p2` para `\b+`. |
| `offset` | O offset da string encontrada em relação ao resto da string. Por exemplo, se a string for 'abcd' e a string a ser encontrada for 'bc', então este parâmetro terá o valor 1. |
| `string` | A string completa que está sendo examinada. |

(O número exato de argumentos dependerá se o primeiro parâmetro for uma `RegExp` e de quantas combinações entre parênteses houver).

O exemplo a seguir irá substituir o valor de `newString` para `'abc - 12345 - #$*%'`:

```js
function replacer(match, p1, p2, p3, offset, string) {
  // p1 não possui digitos,
  // p2 possui dígitos, e p3 não possui alfanuméricos
  return [p1, p2, p3].join(" - ");
}
var newString = "abc12345#$\*%".replace(/([^\d]\*)(\d\*)([^\w]\*)/, replacer);

// retorna "abc - 12345 - #$\*%"
```

Exemplos
--------

### Definindo uma expressão regular com `replace()`

No exemplo a seguir foi definida uma expressão regular com a flag "`i`" (que ignora diferenças entre maiúsculas e minúsculas) no método `replace()`.

```js
var str = "Twas the night before Xmas...";
var newstr = str.replace(/xmas/i, "Christmas");

console.log(newstr);
// retorna "Twas the night before Christmas..."
```

**Nota:** Veja este guia para maiores explicações as sobre expressões regulares.

### Usando `global` e `ignore` com `replace()`

Substituir globalmente, "`g`", só pode ser feito com uma expressão regular. No exemplo a seguir, a expressão regular inclui as flags global e ignore que permitem a função `replace()` substituir cada "`maçãs`" por "`laranjas`" na string.

```js
var re = /maçãs/gi;
var str = "As maçãs são redondas. As maçãs são suculentas.";
var newstr = str.replace(re, "laranjas");

console.log(newstr);
// retorna
// "As laranjas são redondas. As laranjas são suculentas."
```

### Trocando palavras em uma string

O script a seguir troca as palavras na string. Para o texto que vai substituir, o script usa grupos de captura (en-US) e os padrões de substituição `$1` e `$2`.

```js
var re = /(\w+)\s(\w+)/;
var str = "John Smith";
var newstr = str.replace(re, "$2, $1");
console.log(newstr); // Smith, John
```

### Usando uma função que modifica os caracteres coincidentes

Neste exemplo, todas as ocorrências de letras maiúsculas na string são convertidas em minúsculas e um hífen é inserido antes do local de correspondência. O importante aqui é que é necessário uma operação adicional no item antes dele ser retornado como substituído.

A função de substituição aceita a string coincidida como parâmetro e usa ela para transformar os caracteres e concatenar um hífen antes de retornar.

```js
function styleHyphenFormat(propertyName) {
  function upperToHyphenLower(match, offset, string) {
    return (offset ? "-" : "") + match.toLowerCase();
  }
  return propertyName.replace(/[A-Z]/g, upperToHyphenLower);
}
```

Dado o seguinte parâmetro: `styleHyphenFormat('borderTop')`, o valor retornado é '`border-top`'.

Como queremos transformar o resultado da coincidencia antes da substituição final, nós devemos usar uma função. Isto força que a transformação seja feita antes da chamada do método `toLowerCase()`. Se tivéssemos tentado isto sem a função, o método `toLowerCase()` não teria efeito.

```js
let newString = propertyName.replace(/[A-Z]/g, "-" + "$&".toLowerCase()); // não funciona
```

Isso acontece porque `'$&'.toLowerCase()` será executada antes (resultando no mesmo que `'$&'`) em vez de usar os caracteres da string a ser transformada.

### Substituindo graus Fahrenheit em Celsius

O exemplo a seguir converte graus Fahrenheit em Celsius. O grau Fahrenheit deve ser um número terminado com "`F`". A função retorna o número em Celsius terminando em "`C`". Por exemplo, se o valor de entrada for "`212F`", a função deve retornar "`100C`". Se o número for "`0F`", a função deve retornar "`-17.77777777777778C`".

A expressão regular `test` verifica por números que terminem com "`F`". O número de graus Fahrenheit é acessível pela função pelo segundo parâmetro, `p1`. A função calcula o Celsius baseado no Fahrenheit passado via string para a função `f2c()`. A `f2c()` então retorna o número em Celsius.

```js
function f2c(x) {
  function convert(str, p1, offset, s) {
    return ((p1 - 32) \* 5) / 9 + "C";
  }
  var s = String(x);
  var test = /(-?\d+(?:\.\d\*)?)F\b/g;
  return s.replace(test, convert);
}
```

### Use uma função com expressão regular para evitar loops for

O exemplo a seguir pega um padrão de string e converte em um array de objetos.

**Entrada:**

Uma string com caracteres: `x`, `-` e `_`
```

x-x_
x---x---x---x---
x-xxx-xx-x-
x_x_x___x___x___
```

**Saída:**

Um array de objetos. Um `'x'` denota um estado `'on'`, um `'-'` (hífen) denota um estado `'off'` e um `'_'` (underline) denota o comprimento do estado `'on'`.
```

[
  { on: true, length: 1 },
  { on: false, length: 1 },
  { on: true, length: 2 }
  ...
]
```

**Código:**

```js
var str = "x-x\_";
var retArr = [];
str.replace(/(x\_\*)|(-)/g, function (match, p1, p2) {
  if (p1) {
    retArr.push({ on: true, length: p1.length });
  }
  if (p2) {
    retArr.push({ on: false, length: 1 });
  }
});

console.log(retArr);
```

O código gera um array de 3 objetos como desejado sem usar uma função de loop.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.replace |

Navegadores compatíveis
-----------------------

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

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

* `String.prototype.match()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`


String.prototype.replaceAll() - JavaScript

String.prototype.replaceAll()
=============================

O método `replaceAll()` retorna uma nova string com todas as ocorrências de um padrão substituídas por uma substituição. O padrão pode ser uma string ou uma `RegExp`, e a substituição pode ser uma string ou uma função a ser chamada para cada ocorrência.

A *string* original é mantida sem modificação.

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

Sintaxe
-------
```

const newStr = str.replaceAll(regexp|substr, newSubstr|function)
```

**Nota:** quando usar uma `regexp`, você deve colocar o sinalizador (flag) global "`g`". Do contrário, será retornado um `TypeError`: "*replaceAll must be called with a global RegExp*".

### Parâmetros

`regexp` (padrão)

Uma `RegExp` ou literal com o sinalizador (flag) global. As ocorrências serão substituídas por *`newSubstr`* ou pelo valor retornado da *`function`* (função) especificada.

`substr` (padrão)

Uma `String` que deve ser substituída por `newSubstr`. É tratada como uma string literal e não é interpretada como uma expressão regular (*`RegExp`*).

`newSubstr` (substituição)

É a `String` que substitui a `substring` especificada pelo parâmetro `regexp` ou `substr`. Um número de padrões especiais para substituição são suportados; veja a seção "

Especificando uma string como parâmetro

" abaixo.

`function` (substituição)

Uma função a ser chamada retornando a nova `substring` a ser usada para substituir as correspondências para a dada `regexp` ou `substr`. Os argumentos passados para esta função são descritos na seção "Especificando uma função como parâmetro" abaixo.

### Valor de retorno

Um nova *string*, com todas as ocorrências de um padrão substituído por uma substituição.

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

Este método não muda o objeto `String` original. Ele simplesmente retorna uma nova *string*.

### Especificando uma string como parâmetro

A *string* de substituição pode incluir os seguimentos padrões especiais de substituição:

| Padrão | Insere |
| --- | --- |
| `$$` | Insere um `"$"`. |
| `$&` | Insere a *substring* correspondente. |
| `$`` | Insere a porção da *string* que precede a *substring* correspondente. |
| `$'` | Insere a porção da *string* que sucede a *substring* correspondente. |
| `$n` | Onde `n` é um inteiro positivo menor que 100, insere a *`n`*-ésima *string* submatch entre parênteses, desde que o primeiro argumento seja um objeto `RegExp`. Note que isso é indexado começando pelo `1`. |

### Especificando uma função como parâmetro

Você pode especificar uma função como segundo parâmetro. Neste caso, a função será chamada depois da ocorrência ter sido encontrada. O resultado da função (valor de retorno) será usado como uma *string* para substituição. (**Nota:** Os padrões especiais mencionados acima **não se aplicam** neste caso.)

Note que a função será chamada múltiplas vezes para cada ocorrência a ser substituída se a expressão regular no primeiro parâmetro for global "`g`".

Os argumentos para funções são os seguintes:

| Nome possível | Valor fornecido |
| --- | --- |
| `match` | A *substring* correspondida. (Corresponde ao `$&` acima.) |
| `p1, p2, ...` | A *n*-ésima string encontrada por um grupo de captura entre parênteses, desde que o primeiro argumento para `replace()` seja uma `RegExp`. (Corresponde a `$1`, `$2`, etc. acima.) Por exemplo, se `/(\a+)(\b+)/`, foi dado, `p1` é a correspondência para `\a+`, e `p2` para `\b+`. |
| `offset` | O deslocamento da substring correspondente em toda a string sendo examinada. (Por exemplo, se toda a string for '`abcd`' e a substring correspondente for '`bc`', este argumento será `1`.) |
| `string` | A *string* inteira será examinada. |

(O número exato de argumentos depende se o primeiro argumento é um objeto `RegExp` — e, se então, quantas *subcorrespondências* entre parênteses são especificadas.)

Exemplos
--------

### Usando `replaceAll()`

```js
"aabbcc".replaceAll("b", ".");
// 'aa..cc'
```

### RegExp sem flag "g" retorando erro

Ao usar uma expressão regular para realizar uma pesquisa, a mesma deve conter a flag global "`g`". O código abaixo não irá funcionar:

```js
'aabbcc'.replaceAll(/b/, '.');
TypeError: replaceAll must be called with a global RegExp
```

Já o código abaixo vai funcionar:

```js
"aabbcc".replaceAll(/b/g, ".");
("aa..cc");
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.replaceall |

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

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

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

* `String.prototype.replace()`
* `String.prototype.match()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`


String.prototype.padStart() - JavaScript

String.prototype.padStart()
===========================

O método `padStart()` preenche a string original com um determinado caractere, ou conjunto de caracteres, (várias vezes, se necessário) até que a string resultante atinja o comprimento fornecido. O preenchimento é aplicado antes do primeiro caractere da string original. A string original não é modificada.

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

Sintaxe
-------
```

str.padStart(targetLength [, padString])
```

### Parâmetros

`targetLength`

O comprimento da string resultante uma vez que a string alvo tenha sido preenchida. Caso seu valor seja menor do que o comprimento da string alvo, é retornado a própria string alvo, sem alterações.

`padString`

Opcional. O caractere, ou caracteres, que deve preencher a string alvo. Caso o comprimento dessa essa string de preenchimento seja superior ao `targetLength`, ela será truncada a partir da direita. O valor padrão é `" "` (`U+0020 'SPACE'`).

### Valor de retorno

Uma `String` de comprimento específico com uma string de preenchimento aplicada a partir do seu início.

Exemplos
--------

### Exemplos básicos

```js
"abc".padStart(10); // " abc"
"abc".padStart(10, "foo"); // "foofoofabc"
"abc".padStart(6, "123465"); // "123abc"
"abc".padStart(8, "0"); // "00000abc"
"abc".padStart(1); // "abc"
```

Polyfill
--------

Ao executar o seguinte código antes de qualquer outro código é criado o método `String.prototype.padStart()`, em casos onde ele não está disponível nativamente:

```js
// https://github.com/uxitten/polyfill/blob/master/string.polyfill.js
// https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/String/padStart
if (!String.prototype.padStart) {
  String.prototype.padStart = function padStart(targetLength, padString) {
    targetLength = targetLength >> 0; //truncate if number, or convert non-number to 0;
    padString = String(typeof padString !== "undefined" ? padString : " ");
    if (this.length >= targetLength) {
      return String(this);
    } else {
      targetLength = targetLength - this.length;
      if (targetLength > padString.length) {
        padString += padString.repeat(targetLength / padString.length); //append to original to ensure we are longer than needed
      }
      return padString.slice(0, targetLength) + String(this);
    }
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.padstart |

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

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

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

* `String.prototype.padEnd()`


Object.prototype.isPrototypeOf() - JavaScript

Object.prototype.isPrototypeOf()
================================

O método **`isPrototypeOf()`** checa se um objeto existe em na cadeia de protótipos de um outro objeto.

**Nota:** `isPrototypeOf()` difere do operador `instanceof`. Na expressão "`objeto instanceof UmaFuncaoQualquer`", a cadeia de protótipos do `objeto` é comparada com `UmaFuncaoQualquer.prototype`, e não com a própria função `UmaFuncaoQualquer`.

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

Sintaxe
-------
```

prototypeObj.isPrototypeOf(objeto)
```

### Parâmetros

`objeto`

Objeto no qual será feito uma busca na cadeia de protótipos.

### Retorno

Um `Boolean` indicando se prototypeObj está na cadeia de protótipos do objeto.

### Erros possíveis

`TypeError`

Um `TypeError` é mostrado se `prototypeObj` é *undefined* ou *null*.

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

O método `isPrototypeOf()` lhe permite checar se um objeto está ou não na cadeia de protótipos (cadeia hieráquica) de um outro objeto.

Em outras palavras, você pode descobrir se um objeto x (já instanciado) é herdeiro de um objeto y.

Exemplos
--------

Este exemplo demonstra que `Baz.prototype`, `Bar.prototype`, `Foo.prototype` e `Object.prototype` estão na cadeia de protótipos de `baz` , ou seja, baz herda atributos de Baz, Bar e Foo:

```js
function Foo() {}
function Bar() {}
function Baz() {}

Bar.prototype = Object.create(Foo.prototype);
Baz.prototype = Object.create(Bar.prototype);

const foo = new Foo();
const bar = new Bar();
const baz = new Baz();

// cadeia de protótipos:
// foo: Foo <- Object
// bar: Bar <- Foo <- Object
// baz: Baz <- Bar <- Foo <- Object
console.log(Baz.prototype.isPrototypeOf(baz)); // true
console.log(Baz.prototype.isPrototypeOf(bar)); // false
console.log(Baz.prototype.isPrototypeOf(foo)); // false
console.log(Bar.prototype.isPrototypeOf(baz)); // true
console.log(Bar.prototype.isPrototypeOf(foo)); // false
console.log(Foo.prototype.isPrototypeOf(baz)); // true
console.log(Foo.prototype.isPrototypeOf(bar)); // true
console.log(Object.prototype.isPrototypeOf(baz)); // true
```

O método`isPrototypeOf()`, junto com o operador `instanceof` vêm a ser útil se você tem um código que só pode funcionar quando estiver lidando com objetos que descendem de uma cadeia de protótipos específicos, por exemplo, para garantir que certos métodos ou propriedades estarão presentes naquele objeto que você precisa.

Por exemplo, checar se o objeto `baz` descende de `Foo.prototype`:

```js
if (Foo.prototype.isPrototypeOf(baz)) {
  // fazer algo seguramente
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.isprototypeof |

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

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

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

* `instanceof`
* `Object.getPrototypeOf()`
* `Object.setPrototypeOf()`
* `Object.prototype.__proto__`


Object.prototype.__lookupSetter__() - JavaScript

Object.prototype.\_\_lookupSetter\_\_()
=======================================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método **`__lookupSetter__`** retorna a função vinculada como *setter* para a propriedade especificada.

Sintaxe
-------
```

obj.__lookupSetter__(sprop)
```

### Parâmetros

`sprop`

Uma cadeia de caracteres (*string*) contendo o nome da propriedade a qual o *setter* deve ser retornado.

### Valor de retorno

A função vinculada como *setter* para a propriedade especificada.

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

Se o *setter* foi definido para uma propriedade do objeto, não era possível referenciar a função através da propriedade, porque aquela propriedade se refere ao valor de retorno da função. `__lookupSetter__` pode ser usado para obter a referência para a função *setter*.

É possível agora fazer isso de forma padronizada usando `Object.getOwnPropertyDescriptor()`.

Exemplos
--------

### Formas compatíveis e não padronizadas de obter um definidor de propriedades

```js
var obj = {
  set foo(value) {
    this.bar = value;
  },
};

// Forma não padronizada e depreciada
obj.\_\_lookupSetter\_\_("foo");
// (function(value) { this.bar = value; })

// Forma compatível padronizada
Object.getOwnPropertyDescriptor(obj, "foo").set;
// (function(value) { this.bar = value; })
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.\_\_lookupSetter\_\_ |

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

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

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

* `Object.prototype.__lookupGetter__()`
* Operador `set`
* `Object.getOwnPropertyDescriptor()` e `Object.getPrototypeOf()`
* `Object.prototype.__defineGetter__()`
* `Object.prototype.__defineSetter__()`
* JS Guide: Defining Getters and Setters


Object.prototype.__proto__ - JavaScript

Object.prototype.\_\_proto\_\_
==============================

**Aviso:** **Cuidado:** Alterando o `[[Prototype]]` de um objeto é, pela natureza que as engines do Javascript modernos otimizam os acessos à propriedades, uma operação muito lenta, em \*\**TODOS* \*\*os mecanismos browsers e JavaScript. Os efeitos no desempenho de alteração na herança são sutis e distantes, e não se limitam simplesmente ao tempo gasto em na declaração `obj.__proto__ = ...`, mas podem se estender para ***qualquer*** código que tenha acesso a ***qualquer*** objeto cujo `[[Prototype]]` foi alterado. Se você se preocupa com desempenho, evite configurar o `[[Prototype]]` de um objeto. Ao invés disso, crie um novo objeto com o `[[Prototype]]` desejado usando `Object.create()`.

**Aviso:** **Cuidado:** Enquanto `Object.prototype.__proto__` é suportado hoje em dia em quase todos os navegadores, a existência e o comportamento exato foram padronizados na especificação ECMAScript 2015 como um recurso legado para assegurar compatibilidade com os navegadores. Para melhor suporte, recomenda-se que apenas `Object.getPrototypeOf()` seja usado em vez disso.

A propriedade `__proto__` de `Object.prototype` (en-US) é uma propriedade de acesso (uma função getter e uma setter) que expõe o interno `[[Prototype]]` (ou um objeto ou `null`) de um objeto o qual é acessado.

O uso de `__proto__` é controverso, e foi desencorajado. Nunca foi incluído originalmente na especificação do idioma EcmaScript, mas os navegadores modernos decidiram implementá-lo de qualquer maneira. Somente recentemente, a propriedade `__proto__` foi padronizada na especificação de linguagem ECMAScript 2015 para navegadores para garantir compatibilidade, e então ser suportada no futuro. É obsoleta a favor de `Object.getPrototypeOf`/`Reflect.getPrototypeOf` (en-US) e `Object.setPrototypeOf`/`Reflect.setPrototypeOf` (en-US) (embora ainda, definir `[[Prototype]]` é uma operação lenta que deve ser evitada se o desempenho for uma preocupação).

A propriedade `__proto__` também pode ser usada em uma definição literal de objeto para definir o objeto `[[Prototype]]` na criação, como uma alternativa para `Object.create()`. Veja: object initializer / literal syntax.

Sintaxe
-------

```js
var shape = {};
var circle = new Circle();

// Define o objeto prototype.
// OBSOLETO. Isto é somente exemplo. NÃO FAÇA ISSO em código real.
shape.__proto__ = circle;

// Retorna o objeto prototype
console.log(shape.__proto__ === circle); // true
```

```js
var shape = function () {};
var p = {
  a: function () {
    console.log("aaa");
  },
};
shape.prototype.__proto__ = p;

var circle = new shape();

circle.a(); //aaa

console.log(shape.prototype === circle.__proto__); //true

//ou

var shape = function () {};
var p = {
  a: function () {
    console.log("a");
  },
};

var circle = new shape();
circle.__proto__ = p;

circle.a(); // a

console.log(shape.prototype === circle.__proto__); //false

//ou

function test() {}
test.prototype.myname = function () {
  console.log("myname");
};
var a = new test();

console.log(a.__proto__ === test.prototype); //true

a.myname(); //myname

//ou

var fn = function () {};
fn.prototype.myname = function () {
  console.log("myname");
};

var obj = {
  \_\_proto\_\_: fn.prototype,
};

obj.myname(); //myname
```

Nota: são dois underscores(underlines), seguidos de cinco caracteres "proto", seguidos por mais dois underscores(underlines).

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

A função getter de `__proto__` expõe o valor interno de `[[Prototype]]` de um objeto. Para objetos criado usando um objeto literal, este valor é `Object.prototype` (en-US). Para os objetos criados usando literais de matrizes, esse valor é `Array.prototype`. Para funções, esse valor é `Function.prototype` (en-US). Para objeto criados usando `new fun`, onde `fun` é uma função construtora built-in fornecida pelo JavaScript (`Array`, `Boolean`, `Date`, `Number`, `Object`, `String`, e assim por diante — incluindo novos construtores adicionados como evolução do JavaScript), este valor é sempre `fun.prototype`. Para objetos criados usando `new fun`, onde `fun` é uma função definida em um script, esse valor é o valor de `fun.prototype`. (Ou seja, se o construtor não retornou um outro objeto explicitamente, ou o `fun.prototype` foi reatribuído desde que a instância foi criada).

O setter `__proto__` permite ao `[[Prototype]]` de um objeto sejá mutável. O objeto deve ser extensível de acordo com `Object.isExtensible()`: se não for, um erro `TypeError` é emitido. O valor fornecido deve ser um objeto ou `null`. Fornecer qualquer outro valor não fará nada.

Para entender como os prototypes são usados para herança, veja o artigo:Inheritance and the prototype chain.

A propriedade `__proto__` é simplesmente uma propriedade acessora `Object.prototype` (en-US) consistindo de uma função getter e setter. Um acesso de propriedade para `__proto__` que eventualmente consulte `Object.prototype` (en-US) irá encontrar esta propriedade, mas um acesso que não consulta `Object.prototype` (en-US) não a encontrará. Se alguma outra propriedade `__proto__` for encontrada antes de consultar `Object.prototype` (en-US), essa propriedade irá ocultar a que encontrou `Object.prototype` (en-US).

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.\_\_proto\_\_ |

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

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

Notas de compatibilidade
------------------------

Enquanto a especificação ECMAScript 2015 dita que o suporte para `__proto__` é requerido *somente* para navegadores (apesar de ser normativo), outros ambientes podem suportar também para uso legado.

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

* `Object.prototype.isPrototypeOf()`
* `Object.getPrototypeOf()`
* `Object.setPrototypeOf()`


Object.prototype.propertyIsEnumerable() - JavaScript

Object.prototype.propertyIsEnumerable()
=======================================

O método **`propertyIsEnumerable()`** retorna um booleano indicando quando a propriedade especificada é enumerável e é a propriedade do próprio objeto

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

Sintaxe
-------
```

obj.propertyIsEnumerable(prop)
```

### Parâmetros

`prop`

O nome da propriedade para teste

### Valor de Retorno

O `Boolean` indicando se a propriedade especificada é enumeravel e é a propriedade do objeto

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

Every object has a `propertyIsEnumerable` method. This method can determine whether the specified property in an object can be enumerated by a `for...in` loop, with the exception of properties inherited through the prototype chain. If the object does not have the specified property, this method returns `false`.

Exemplos
--------

### O uso basico de `propertyIsEnumerable`

O exemplos a seguir mostram o uso de `propertyIsEnumerable` em um objeto e um array:

```js
var o = {};
var a = [];
o.prop = "is enumerable";
a[0] = "is enumerable";

o.propertyIsEnumerable("prop"); // returns true
a.propertyIsEnumerable(0); // returns true
```

### Objetos User-defined vs. built-in

Os exemplos a seguir demostram a enumerabilidade da propriedade user-defined vs. built-in :

```js
var a = ["is enumerable"];

a.propertyIsEnumerable(0); // returns true
a.propertyIsEnumerable("length"); // returns false

Math.propertyIsEnumerable("random"); // returns false
this.propertyIsEnumerable("Math"); // returns false
```

### Propriedade Direct vs. inherited

```js
var a = [];
a.propertyIsEnumerable("constructor"); // returns false

function firstConstructor() {
  this.property = "is not enumerable";
}

firstConstructor.prototype.firstMethod = function () {};

function secondConstructor() {
  this.method = function () {
    return "is enumerable";
  };
}

secondConstructor.prototype = new firstConstructor();
secondConstructor.prototype.constructor = secondConstructor;

var o = new secondConstructor();
o.arbitraryProperty = "is enumerable";

o.propertyIsEnumerable("arbitraryProperty"); // returns true
o.propertyIsEnumerable("method"); // returns true
o.propertyIsEnumerable("property"); // returns false

o.property = "is enumerable";

o.propertyIsEnumerable("property"); // returns true

// These return false as they are on the prototype which
// propertyIsEnumerable does not consider (even though the last two
// are iteratable with for-in)
o.propertyIsEnumerable("prototype"); // returns false (as of JS 1.8.1/FF3.6)
o.propertyIsEnumerable("constructor"); // returns false
o.propertyIsEnumerable("firstMethod"); // returns false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.propertyisenumerable |

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

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

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

* Enumerability and ownership of properties
* `for...in`
* `Object.keys()`
* `Object.defineProperty()`


Object.values() - JavaScript

Object.values()
===============

**Experimental:** **Esta é uma tecnologia experimental (en-US)**
Verifique a tabela de compatibilidade entre Navegadores cuidadosamente antes de usar essa funcionalidade em produção.

O método **`Object.values()`** retorna um array com os valores das propriedades de um dado objeto, na mesma ordem provida pelo `for...in` laço (sendo a diferença que o laço for-in também enumera as propriedades na cadeia prototype).

Sintaxe
-------
```

Object.values(obj)
```

### Parâmetros

`obj`

O objeto cujos valores das propriedades enumeradas serão retornados.

### Valor de retorno

Um array contendo os valores das propriedades enumeradas do dado objeto.

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

`Object.values()` retorna um array cujos elementos são os valores das propriedades enumeradas encontradas no objeto. A ordem das propriedades é a mesma que a dada pelo laço sobre os valores da propriedade do objeto manualmente.

Exemplos
--------

```js
var obj = { foo: "bar", baz: 42 };
console.log(Object.values(obj)); // ['bar', 42]

// array como objeto
var obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.values(obj)); // ['a', 'b', 'c']

// array como objeto com ordenação de chave aleatória
var an_obj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.values(an_obj)); // ['b', 'c', 'a']

// getFoo é a propriedade a qual não é enumerável
var my_obj = Object.create(
  {},
  {
    getFoo: {
      value: function () {
        return this.foo;
      },
    },
  },
);
my_obj.foo = "bar";
console.log(Object.values(my_obj)); // ['bar']

// argumento não-objeto será coagido num objeto
console.log(Object.values("foo")); // ['f', 'o', 'o']
```

Biblioteca de Suporte
---------------------

`Para adicionar compatibilidade ao suporte de Object.values` em ambientes antigos que nativamente não o suportam, você pode encontrar uma biblioteca de suporte nos repositórios tc39/proposal-object-values-entries ou no es-shims/Object.values.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.values |

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

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

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

* Enumerability and ownership of properties
* `Object.keys()`
* `Object.entries()`
Experimental
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.getOwnPropertyNames()`


Object.prototype.hasOwnProperty() - JavaScript

Object.prototype.hasOwnProperty()
=================================

Resumo
------

O método **`hasOwnProperty()`** retorna um booleano indicando se o objeto possui a propriedade especificada como uma propriedade definida no próprio objeto em questão (ao contrário de uma propriedade herdada).

Sintaxe
-------
```

obj.hasOwnProperty(prop)
```

### Parâmetros

`prop`

Uma `String` ou symbol indicando o nome da propriedade a ser verificada.

### Valor de Retorno

Um `booleano` indicando se o objeto possui ou não a propriedade especificada como uma propriedade do próprio objeto e que a propriedade não é uma propriedade herdada.

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

Todo objeto descendente de `Object` herda o método `hasOwnProperty`. Este método pode ser usado para determinar se um objeto possui a propriedade especificada como propriedade direta do objeto.

Diferentemente do operador `in`, este método não checa a cadeia prototípica do objeto.

Nota
----

o método `hasOwnProperty` retorna `true` mesmo se o valor da propridade em questão é `null` ou `undefined`
```

o = new Object();
o.propUm = null;
o.hasOwnProperty('propUm'); // retorna true
o.propDois = undefined;
o.hasOwnProperty('propDois'); // retorna true
```

Exemplos
--------

### Usando `hasOwnProperty` para testar a existência de uma propriedade

O seguinte exemplo determina se o objeto `o` possui uma propriedade com o nome `prop`:
```

o = new Object();
o.hasOwnProperty('prop'); // retorna false
o.prop = 'existe';
o.hasOwnProperty('prop'); // retorna true
```

### Propriedades Diretas vs Propriedades Herdadas

O seguinte exemplo diferencia entre propriedade diretas e propriedade herdadas da cadeia prototípica:

```js
o = new Object();
o.prop = "existe";
o.hasOwnProperty("prop"); // Retorna true
o.hasOwnProperty("toString"); // Retorna false
o.hasOwnProperty("hasOwnProperty"); // Retorna false
```

### Percorrer através das propriedades de um objeto

O seguinte exemplo mostra como percorrer as propriedade de um objeto sem executar as propriedade herdadas.

Vale observar que o loop `for...in` percorre somente itens enumeráveis. Entretanto, o método hasOwnProperty também funciona com propriedades não enumeráveis.

```js
var buz = {
  fog: "stack",
};

for (var nome in buz) {
  if (buz.hasOwnProperty(nome)) {
    alert("this is fog (" + nome + ") for sure. Value: " + buz[nome]);
  } else {
    alert(nome); // toString ou qualquer outra coisa
  }
}
```

### Exemplo: `hasOwnProperty` como propriedade

JavaScript não protege o nome `hasOwnProperty`, assim, se existir a possibilidade do objeto possuir uma propriedade com esse nome, é necessário usar externamente `hasOwnProperty` para se ter o resultado correto:

```js
var foo = {
  hasOwnProperty: function () {
    return false;
  },
  bar: "Here be dragons",
};

foo.hasOwnProperty("bar"); // Sempre retorna false

// Usando a propriedade hasOwnProperty de outro objeto e definindo 'this' como foo
({}).hasOwnProperty.call(foo, "bar"); // true

// Também é possível usar hasOwnProperty do objeto
Object.prototype.hasOwnProperty.call(foo, "bar"); // true
```

Observe que neste ultimo caso nenhum novo objeto é criado.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.hasownproperty |

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

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

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

* Enumerability and ownership of properties (en-US)
* `Object.getOwnPropertyNames()`
* for...in
* `in`
* JavaScript Guide: Inheritance revisted