recursal/MDN huggingface dataset:
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()
=========================

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

**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()
======================

**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()
==============================

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

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

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

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.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()
================================

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\_\_()
=======================================

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