recursal/MDN huggingface dataset:
String.prototype.italics()
==========================

**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 `italics()` cria um elemento HTML `<i>` que faz com que uma string fique em itálico.

Sintaxe
-------
```

str.italics()
```

### Valor retornado

Uma string contendo um elemento HTML `<i>`.

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

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

Exemplos
--------

### Usando `italics()`

O exemplo a seguir usa métodos do objeto global 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.italics |

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.bold()`
* `String.prototype.strike()`
String.prototype.padEnd()
=========================

O método `padEnd()` preenche a string original com um determinado caractere, ou conjunto de caraceres, (repetidamente, se necessário) para que a string resultante alcance um determinado comprimento. O preenchimento é aplicado a partir do final (direita) da string original. A string original não é modificada.

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

Sintaxe
-------
```

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

### Parâmetros

`targetLength`

O comprimento da string resultante após a string original ter sido preenchida. Se o valor for menor do que o próprio comprimento da string original, a string original é retornada sem modificações.

`padString`

Opcional. O caractere (ou caracteres) que deve completar a string atual. Caso o comprimento desta string seja muito longo, estando acima do comprimento alvo, ela será truncada e sua parte esquerda restante é aplicada. O valor padrão para esse parâmetro é " " (`U+0020`).

### Valor retornado

Uma `String` cuja composição vem da string original, completada por um ou mais caracteres de preenchimento, respeitando o comprimento alvo.

Exemplos
--------

### Usando padEnd


```js
"abc".padEnd(10); // "abc "
"abc".padEnd(10, "foo"); // "abcfoofoof"
"abc".padEnd(6, "123456"); // "abc123"
"abc".padEnd(1); // "abc"
```

Polyfill
--------

Rodando o seguinte código antes de qualquer código irá criar o método `String.prototype.padEnd()` caso ele não esteja 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/padEnd
if (!String.prototype.padEnd) {
  String.prototype.padEnd = function padEnd(targetLength, padString) {
    targetLength = targetLength >> 0; //floor 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 String(this) + padString.slice(0, targetLength);
    }
  };
}
```

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

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

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

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

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

* `String.prototype.padStart()`
String.prototype.link()
=======================

**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 `link()` cria uma string que representa o código para um elemento HTML `<a>` a ser usado como um link de hipertexto para outro URL.

Sintaxe
-------
```

str.link(url)
```

### Parâmetros

`url`

Qualquer string que especifique o atributo `href` da tag `<a>`. Deve ser um URL válido (relativo ou absoluto), com qualquer caractere `&` escapado como `&amp` e qualquer `"` caractere escapado como `&quot`.

### Valor retornado

Uma string contendo um elemento HTML `<a>`.

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

Use o método `link()` para criar um elemento HTML `<a>`. A string retornada pode então ser adicionada ao documento por meio de `document.write()` ou `element.innerHTML`.

Os links criados com o método `link()` tornam-se elementos na array de links do objeto `document`. Veja `document.links` (en-US).

Exemplos
--------

### Usando `link()`

O exemplo a seguir exibe a palavra "MDN" como um link que retorna o usuário à Mozilla Developer Network.


```js
var hotText = "MDN";
var URL = "https://developer.mozilla.org/";

console.log("Clique para retornar à" + hotText.link(URL));
// Clique para retornar à <a href="https://developer.mozilla.org/">MDN</a>
```

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

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

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

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

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

* `String.prototype.anchor()`
String.prototype.toLocaleUpperCase()
====================================

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

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

Sintaxe
-------
```

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

### Parâmetros

`locale`

Opcional. O parâmetro `locale` indica a localização a ser usada para converter para maiúsculas de acordo com qualquer mapeamento de caixa de texto específico da localidade. Se vários locais forem fornecidos 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 maiúsculas, de acordo com qualquer mapeamento de 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 `toLocaleUpperCase()` retorna o valor da string convertida em maiúsculas de acordo com qualquer mapeamento de caixa de texto específico da localidade. `toLocaleUpperCase()` não afeta o valor da string em si. Na maioria dos casos, ele produzirá o mesmo resultado que `toUpperCase()`, mas para alguns locais, como turco, cujos mapeamentos de caixa de texto não seguem o mapeamento de caixa de texto padrão em Unicode, pode haver um resultado diferente.

 Observe também que a conversão não é necessariamente um mapeamento de caracteres 1:1, pois alguns caracteres podem resultar em dois (ou até mais) caracteres quando transformados em maiúsculas. Portanto, o comprimento da string resultante pode ser diferente do comprimento da string de entrada. Isso também implica que a conversão não é estável, então, por exemplo, o seguinte pode retornar `false`:
 `x.toLocaleLowerCase() === x.toLocaleUpperCase(). toLocaleLowerCase()`

Exemplos
--------

### Usando `toLocaleUpperCase()`


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

"Gesäß".toLocaleUpperCase(); // 'GESÄSS'

"i\u0307".toLocaleUpperCase("lt-LT"); // 'I'

let locales = ["lt", "LT", "lt-LT", "lt-u-co-phonebk", "lt-x-lietuva"];
"i\u0307".toLocaleUpperCase(locales); // 'I'
```

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

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

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

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

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

* `String.prototype.toLocaleLowerCase()`
* `String.prototype.toLowerCase()`
* `String.prototype.toUpperCase()`
String.prototype.trimStart()
============================

O método `trimStart()` remove espaços do começo de uma *string*. `trimLeft()` é um apelido para este método.

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

Sintaxe
-------
```

str.trimStart();
str.trimLeft();
```

### Valor retornado

Uma nova *string* representando a *string* original sem os espaços no começo (fim à esquerda).

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

Os métodos `trimStart()` / `trimLeft()` retornam a *string* sem os espaços no fim à esquerda. `trimLeft()` ou `trimStart()` não altera o valor da *string* original.

### *Aliasing*

Para consistência com funções como `String.prototype.padStart` o nome padrão do método é `trimStart`. Entretanto, por razões de compatibilidade na *web*, `trimLeft` permanece como um apelido para `trimStart`. Em alguns motores isso significa:


```js
String.prototype.trimLeft.name === "trimStart";
```

Polyfill
--------


```js
//https://github.com/FabioVergani/js-Polyfill\_String-trimStart

(function (w) {
  var String = w.String,
    Proto = String.prototype;

  (function (o, p) {
    if (p in o ? (o[p] ? false : true) : true) {
      var r = /^\s+/;
      o[p] =
        o.trimLeft ||
        function () {
          return this.replace(r, "");
        };
    }
  })(Proto, "trimStart");
})(window);

/\*
ES6:
(w=>{
 const String=w.String, Proto=String.prototype;

 ((o,p)=>{
 if(p in o?o[p]?false:true:true){
 const r=/^\s+/;
 o[p]=o.trimLeft||function(){
 return this.replace(r,'')
 }
 }
 })(Proto,'trimStart');

})(window);
\*/
```

Exemplos
--------

### Usando `trimStart()`

O seguinte exemplo mostra uma *string* em caixa baixa `'foo '`:


```js
var str = " foo ";

console.log(str.length); // retorna 8

str = str.trimStart();
console.log(str.length); // retorna 5
console.log(str); // retorna 'foo '
```

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

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

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

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

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

* `String.prototype.trim()`
* `String.prototype.trimEnd()`
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()
=====================

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

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

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