From 074785cea106179cb3305637055ab0a009ca74f2 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:42:52 -0500 Subject: initial commit --- .../global_objects/string/@@iterator/index.html | 84 +++++ .../global_objects/string/anchor/index.html | 76 +++++ .../reference/global_objects/string/big/index.html | 76 +++++ .../global_objects/string/blink/index.html | 71 +++++ .../global_objects/string/bold/index.html | 68 ++++ .../global_objects/string/charat/index.html | 290 +++++++++++++++++ .../global_objects/string/charcodeat/index.html | 213 +++++++++++++ .../global_objects/string/codepointat/index.html | 143 +++++++++ .../global_objects/string/concat/index.html | 138 ++++++++ .../global_objects/string/endswith/index.html | 103 ++++++ .../global_objects/string/fixed/index.html | 66 ++++ .../global_objects/string/fontcolor/index.html | 84 +++++ .../global_objects/string/fontsize/index.html | 83 +++++ .../global_objects/string/fromcharcode/index.html | 142 +++++++++ .../global_objects/string/fromcodepoint/index.html | 213 +++++++++++++ .../global_objects/string/includes/index.html | 108 +++++++ .../reference/global_objects/string/index.html | 338 ++++++++++++++++++++ .../global_objects/string/indexof/index.html | 158 +++++++++ .../global_objects/string/italics/index.html | 68 ++++ .../global_objects/string/lastindexof/index.html | 162 ++++++++++ .../global_objects/string/length/index.html | 142 +++++++++ .../global_objects/string/link/index.html | 75 +++++ .../global_objects/string/localecompare/index.html | 163 ++++++++++ .../global_objects/string/match/index.html | 232 ++++++++++++++ .../global_objects/string/matchall/index.html | 146 +++++++++ .../global_objects/string/normalize/index.html | 220 +++++++++++++ .../global_objects/string/padend/index.html | 103 ++++++ .../global_objects/string/padstart/index.html | 107 +++++++ .../global_objects/string/prototype/index.html | 176 +++++++++++ .../reference/global_objects/string/raw/index.html | 120 +++++++ .../global_objects/string/repeat/index.html | 294 +++++++++++++++++ .../global_objects/string/replace/index.html | 352 +++++++++++++++++++++ .../global_objects/string/replaceall/index.html | 178 +++++++++++ .../global_objects/string/search/index.html | 153 +++++++++ .../global_objects/string/slice/index.html | 233 ++++++++++++++ .../global_objects/string/small/index.html | 72 +++++ .../global_objects/string/split/index.html | 282 +++++++++++++++++ .../global_objects/string/startswith/index.html | 96 ++++++ .../global_objects/string/strike/index.html | 68 ++++ .../reference/global_objects/string/sub/index.html | 123 +++++++ .../global_objects/string/substr/index.html | 140 ++++++++ .../global_objects/string/substring/index.html | 229 ++++++++++++++ .../reference/global_objects/string/sup/index.html | 69 ++++ .../string/tolocalelowercase/index.html | 92 ++++++ .../string/tolocaleuppercase/index.html | 95 ++++++ .../global_objects/string/tolowercase/index.html | 126 ++++++++ .../global_objects/string/tosource/index.html | 102 ++++++ .../global_objects/string/tostring/index.html | 125 ++++++++ .../global_objects/string/touppercase/index.html | 135 ++++++++ .../global_objects/string/trim/index.html | 137 ++++++++ .../global_objects/string/trimend/index.html | 82 +++++ .../global_objects/string/trimstart/index.html | 118 +++++++ .../global_objects/string/valueof/index.html | 84 +++++ 53 files changed, 7553 insertions(+) create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/@@iterator/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/anchor/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/big/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/blink/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/bold/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/charat/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/codepointat/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/concat/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/endswith/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/fixed/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/fontcolor/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/fontsize/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/fromcharcode/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/fromcodepoint/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/includes/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/indexof/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/italics/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/lastindexof/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/length/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/link/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/localecompare/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/match/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/matchall/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/normalize/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/padend/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/padstart/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/prototype/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/raw/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/repeat/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/replace/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/replaceall/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/search/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/slice/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/small/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/split/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/startswith/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/strike/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/sub/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/substr/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/substring/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/sup/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/tolocalelowercase/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/tolowercase/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/tosource/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/tostring/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/touppercase/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/trim/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/trimend/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/trimstart/index.html create mode 100644 files/pt-br/web/javascript/reference/global_objects/string/valueof/index.html (limited to 'files/pt-br/web/javascript/reference/global_objects/string') diff --git a/files/pt-br/web/javascript/reference/global_objects/string/@@iterator/index.html b/files/pt-br/web/javascript/reference/global_objects/string/@@iterator/index.html new file mode 100644 index 0000000000..5a7700861c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/@@iterator/index.html @@ -0,0 +1,84 @@ +--- +title: 'String.prototype[@@iterator]()' +slug: Web/JavaScript/Reference/Global_Objects/String/@@iterator +tags: + - Iterador + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/@@iterator +--- +
{{JSRef}}
+ +

O método [@@iterator]() retorna um novo objeto Iterator que itera sobre os pontos de código do valor da String, retornando cada ponto de código como um valor String.

+ +

Sintaxe

+ +
str[Symbol.iterator]
+ +

Valor de Retorno

+ +

Novo objeto Iterator.

+ +

Exemplos

+ +

Usando [@@iterator]()

+ +
var str = 'A\uD835\uDC68';
+
+var strIter = str[Symbol.iterator]();
+
+console.log(strIter.next().value); // "A"
+console.log(strIter.next().value); // "\uD835\uDC68"
+
+ +

Usando [@@iterator]() com for..of

+ +
var str = 'A\uD835\uDC68B\uD835\uDC69C\uD835\uDC6A';
+
+for (var v of str) {
+  console.log(v);
+}
+// "A"
+// "\uD835\uDC68"
+// "B"
+// "\uD835\uDC69"
+// "C"
+// "\uD835\uDC6A"
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
StatusComment
{{SpecName('ES2015', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}}{{Spec2('ES2015')}}Definição inicial.
{{SpecName('ESDraft', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}}{{Spec2('ESDraft')}}
+ + + + + +

{{Compat("javascript.builtins.String.@@iterator")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/anchor/index.html b/files/pt-br/web/javascript/reference/global_objects/string/anchor/index.html new file mode 100644 index 0000000000..99207cfb2d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/anchor/index.html @@ -0,0 +1,76 @@ +--- +title: String.prototype.anchor() +slug: Web/JavaScript/Reference/Global_Objects/String/anchor +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor +--- +
{{JSRef}} {{deprecated_header}}
+ +
O método anchor() cria uma string começando com uma tag inicial <a name="...">, um texto e uma tag final </a>.
+ +
+

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

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

irá retornar o seguinte código HTML:

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

Especificações

+ + + + + + + + + + +
Specification
{{SpecName('ESDraft', '#sec-string.prototype.anchor', 'String.prototype.anchor')}}
+ + + + + +

{{Compat("javascript.builtins.String.anchor")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/big/index.html b/files/pt-br/web/javascript/reference/global_objects/string/big/index.html new file mode 100644 index 0000000000..cbfea513f1 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/big/index.html @@ -0,0 +1,76 @@ +--- +title: String.prototype.big() +slug: Web/JavaScript/Reference/Global_Objects/String/big +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/big +--- +
{{JSRef}} {{deprecated_header}}
+ +

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

+ +
+

Nota de uso: O elemento <big> foi removido no HTML5 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:

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

+ +
document.getElementById('#oIdDoElemento').style.fontSize = '2em';
+
+ +

Especificações

+ + + + + + + + + + +
Specification
{{SpecName('ESDraft', '#sec-string.prototype.big', 'String.prototype.big')}}
+ + + + + +

{{Compat("javascript.builtins.String.big")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/blink/index.html b/files/pt-br/web/javascript/reference/global_objects/string/blink/index.html new file mode 100644 index 0000000000..b6c77214bb --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/blink/index.html @@ -0,0 +1,71 @@ +--- +title: String.prototype.blink() +slug: Web/JavaScript/Reference/Global_Objects/String/blink +tags: + - Descontinuado + - JavaScript + - Prototipo + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/blink +--- +
{{JSRef}} {{deprecated_header}}
+ +

O método blink() cria um elemento HTML <blink> que faz uma string piscar.

+ +
+

Aviso: A criação de textos que piscam é desaprovada por vários padrões de acessibilidade. O próprio elemento <blink> não é padrão e está obsoleto!

+
+ +

Sintaxe

+ +
str.blink()
+ +

Valor retornado

+ +

Uma string contendo um elemento HTML <blink>.

+ +

Descrição

+ +

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

+ +

Exemplos

+ + + +

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

+ +
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
{{SpecName('ESDraft', '#sec-string.prototype.blink', 'String.prototype.blink')}}
+ + + + + +

{{Compat("javascript.builtins.String.blink")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/bold/index.html b/files/pt-br/web/javascript/reference/global_objects/string/bold/index.html new file mode 100644 index 0000000000..bc34403734 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/bold/index.html @@ -0,0 +1,68 @@ +--- +title: String.prototype.bold() +slug: Web/JavaScript/Reference/Global_Objects/String/bold +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/bold +--- +
{{JSRef}} {{deprecated_header}}
+ +

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:

+ +
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
{{SpecName('ESDraft', '#sec-string.prototype.bold', 'String.prototype.bold')}}
+ + + + + +

{{Compat("javascript.builtins.String.bold")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/charat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/charat/index.html new file mode 100644 index 0000000000..87866ac56b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/charat/index.html @@ -0,0 +1,290 @@ +--- +title: String.prototype.charAt() +slug: Web/JavaScript/Reference/Global_Objects/String/charAt +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt +--- +
{{JSRef}}
+ +

O método charAt() retorna o caractere especificado a partir de uma string.

+ +

Sintaxe

+ +
str.charAt(index)
+ +

Parâmetros

+ +
+
index
+
Um inteiro entre 0 e str.length - 1. Se nenhum índice for definido, charAt() usará 0 como índice.
+
+ +

Valor retornado

+ +

Uma string representando o caractere no índice especificado. Uma string vazia se o index fornecido estiver fora do intervalo de índices da string str.

+ +

Descrição

+ +

Caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é 0 (zero), e o índice do último caractere em uma string declarada como stringName é stringName.length - 1. Se o índice que você fornecer estiver fora do intervalo de índices da string, JavaScript retornará uma string vazia.

+ +

Se nenhum índice for passado para charAt(), 0 será usado por padrão.

+ +

Exemplos

+ +

Mostrando caracteres em diferente localizações em uma string

+ +

O exemplo a seguir mostra caracteres em diferentes locais em uma string "Brave new world":

+ +
var anyString = 'Brave new world';
+
+console.log("A letra no índice 0 é '" + anyString.charAt(0)   + "'");
+console.log("A letra no índice 1 é '" + anyString.charAt(1)   + "'");
+console.log("A letra no índice 2 é '" + anyString.charAt(2)   + "'");
+console.log("A letra no índice 3 é '" + anyString.charAt(3)   + "'");
+console.log("A letra no índice 4 é '" + anyString.charAt(4)   + "'");
+console.log("A letra no índice 99 é '" + anyString.charAt(999) + "'");
+
+ +

As linhas acima retornam o seguinte:

+ +
A letra no índice 0 é 'B'
+A letra no índice 1 é 'r'
+A letra no índice 2 é 'a'
+A letra no índice 3 é 'v'
+A letra no índice 4 é 'e'
+A letra no índice 99 é ''
+
+ +

Obtendo caracteres inteiros

+ +

O seguinte código fornece um meio de garantir que passar por um loop de string sempre forneça um caractere inteiro, mesmo se a string contiver caracteres que não estão no Plano Multilíngue Básico.

+ +
var str = 'A \uD87E\uDC04 Z'; // We could also use a non-BMP character directly
+for (var i = 0, chr; i < str.length; i++) {
+  if ((chr = getWholeChar(str, i)) === false) {
+    continue;
+  }
+  // Adapt this line at the top of each loop, passing in the whole string and
+  // the current iteration and returning a variable to represent the
+  // individual character
+
+  console.log(chr);
+}
+
+function getWholeChar(str, i) {
+  var code = str.charCodeAt(i);
+
+  if (isNaN(code)) {
+    return ''; // Position not found
+  }
+  if (code < 0xD800 || code > 0xDFFF) {
+    return str.charAt(i);
+  }
+
+  // High surrogate (could change last hex to 0xDB7F to treat high private
+  // surrogates as single characters)
+  if (0xD800 <= code && code <= 0xDBFF) {
+    if (str.length <= (i + 1)) {
+      throw 'High surrogate without following low surrogate';
+    }
+    var next = str.charCodeAt(i + 1);
+      if (0xDC00 > next || next > 0xDFFF) {
+        throw 'High surrogate without following low surrogate';
+      }
+      return str.charAt(i) + str.charAt(i + 1);
+  }
+  // Low surrogate (0xDC00 <= code && code <= 0xDFFF)
+  if (i === 0) {
+    throw 'Low surrogate without preceding high surrogate';
+  }
+  var prev = str.charCodeAt(i - 1);
+
+  // (could change last hex to 0xDB7F to treat high private
+  // surrogates as single characters)
+  if (0xD800 > prev || prev > 0xDBFF) {
+    throw 'Low surrogate without preceding high surrogate';
+  }
+  // We can pass over low surrogates now as the second component
+  // in a pair which we have already processed
+  return false;
+}
+
+ +

Em um ambiente ECMAScript 2016 que permite atribuição desestruturada, o seguinte código é uma alternativa mais sucinta e um pouco mais flexível, pois faz incremento para uma variável de incremento automaticamente (se o caractere justificar que seja um par substituto).

+ +
var str = 'A\uD87E\uDC04Z'; // We could also use a non-BMP character directly
+for (var i = 0, chr; i < str.length; i++) {
+  [chr, i] = getWholeCharAndI(str, i);
+  // Adapt this line at the top of each loop, passing in the whole string and
+  // the current iteration and returning an array with the individual character
+  // and 'i' value (only changed if a surrogate pair)
+
+  console.log(chr);
+}
+
+function getWholeCharAndI(str, i) {
+  var code = str.charCodeAt(i);
+
+  if (isNaN(code)) {
+    return ''; // Position not found
+  }
+  if (code < 0xD800 || code > 0xDFFF) {
+    return [str.charAt(i), i]; // Normal character, keeping 'i' the same
+  }
+
+  // High surrogate (could change last hex to 0xDB7F to treat high private
+  // surrogates as single characters)
+  if (0xD800 <= code && code <= 0xDBFF) {
+    if (str.length <= (i + 1)) {
+      throw 'High surrogate without following low surrogate';
+    }
+    var next = str.charCodeAt(i + 1);
+      if (0xDC00 > next || next > 0xDFFF) {
+        throw 'High surrogate without following low surrogate';
+      }
+      return [str.charAt(i) + str.charAt(i + 1), i + 1];
+  }
+  // Low surrogate (0xDC00 <= code && code <= 0xDFFF)
+  if (i === 0) {
+    throw 'Low surrogate without preceding high surrogate';
+  }
+  var prev = str.charCodeAt(i - 1);
+
+  // (could change last hex to 0xDB7F to treat high private surrogates
+  // as single characters)
+  if (0xD800 > prev || prev > 0xDBFF) {
+    throw 'Low surrogate without preceding high surrogate';
+  }
+  // Return the next character instead (and increment)
+  return [str.charAt(i + 1), i + 1];
+}
+
+ +

Corrigindo charAt() para suportar caracteres não-Plano-Multilíngüe-Básico (PMB)

+ +

Embora o exemplo anterior possa ser mais útil para programas que devem suportar caracteres não BMP (uma vez que não exige que o chamador saiba onde qualquer caractere não BMP pode aparecer), no caso de desejar, na escolha de um caractere por índice, para tratar os pares substitutos em uma string como os caracteres únicos que eles representam, pode-se usar o seguinte:

+ +
function fixedCharAt(str, idx) {
+  var ret = '';
+  str += '';
+  var end = str.length;
+
+  var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  while ((surrogatePairs.exec(str)) != null) {
+    var li = surrogatePairs.lastIndex;
+    if (li - 2 < idx) {
+      idx++;
+    } else {
+      break;
+    }
+  }
+
+  if (idx >= end || idx < 0) {
+    return '';
+  }
+
+  ret += str.charAt(idx);
+
+  if (/[\uD800-\uDBFF]/.test(ret) && /[\uDC00-\uDFFF]/.test(str.charAt(idx + 1))) {
+    // Go one further, since one of the "characters" is part of a surrogate pair
+    ret += str.charAt(idx + 1);
+  }
+  return ret;
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition.
{{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}}{{Spec2('ES6')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.html new file mode 100644 index 0000000000..67bbbac67d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.html @@ -0,0 +1,213 @@ +--- +title: String.prototype.charCodeAt() +slug: Web/JavaScript/Reference/Global_Objects/String/charCodeAt +tags: + - JavaScript + - Referencia + - String + - Unicode + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt +--- +
{{JSRef}}
+ +

O método charCodeAt() retorna um número inteiro entre 0 e 65535 que representa a unidade de código UTF-16 no índice fornecido. A unidade de código UTF-16 corresponde ao ponto de código Unicode para pontos de códigos representáveis em uma única unidade de código UTF-16, mas também pode ser a primeira unidade de código de um par substituto não representável em uma única unidade de código UTF-16. Po exemplo: pontos de código Unicode  > (0x10000). Se você quer o valor do ponto de código inteiro, use codePointAt().

+ +

Sintaxe

+ +
str.charCodeAt(index)
+ +

Parâmetros

+ +
+
index
+
Um inteiro maior ou igual a 0 e menor que o comprimento da string. Se não for um número, o padrão será 0.
+
+ +

Valor retornado

+ +

Um número representando o valor de unidade de código UTF-16 do caractere no índice fornecido. O valor {{jsxref("Global_Objects/NaN", "NaN")}} é retornado se o índice estiver fora do intervalo aceitável.

+ +

Descrição

+ +

Os pontos de código Unicode variam de 0 a 1114111 (0x10FFFF). Os primeiros 128 pontos de código Unicode são uma correspondência direta da codificação de caracteres ASCII. (Para informações sobre Unicode, veja o JavaScript Guide.)

+ +
+

Nota: o charCodeAt() sempre retornará um valor menor do que 65536. Isso ocorre pois os pontos de código mais altos são representados por um par de pseudo-caracteres "substitutos" (de menor valor) que são usados para compreender o caracter real.
+
+ Por isso, para examinar (ou reproduzir) o caractere completo para valores de caracteres individuais de valor 65536 e acima, é necessário recuperar não apenas o charCodeAt(i), mas também o charCodeAt(i+1) (como se examinando/reproduzindo a string com duas letras), ou usar o codePointAt(i). Veja o exemplo 2 e 3 (abaixo).

+
+ +

Compatibilidade com versões anteriores: Em versões históricas (como JavaScript 1.2) o método charCodeAt() retorna um número indicando o valor de conjunto de códigos ISO-Latin-1 do caractere no dado índice. O conjunto de códigos ISO-Latin-1 varia de 0 a 255. Os primeiros 128 (do 0 ao 127) são uma correspondência direta ao conjunto de caracteres ASCII.

+ +

Exemplos

+ +

Usando charCodeAt()

+ +

O exemplo a seguir retorna 65, o valor Unicode para A.

+ +
'ABC'.charCodeAt(0); // retorna 65
+
+ +

Corrigindo o charCodeAt() para manipular caracteres de Plano Multilingual não Básico se sua presença na string é desconhecida

+ +

Essa versão pode ser usada em loops for e afins quando não sabemos se caracteres de Plano Multilingual não Básico existem antes da posição do índice especificado.

+ +
function fixedCharCodeAt(str, idx) {
+  // ex. fixedCharCodeAt('\uD800\uDC00', 0); // 65536
+  // ex. fixedCharCodeAt('\uD800\uDC00', 1); // false
+  idx = idx || 0;
+  var code = str.charCodeAt(idx);
+  var hi, low;
+
+  // Substituto elevado (poderia mudar o último hex para 0xDB7F para tratar
+  // substitutos privados elevados como caracteres únicos)
+  if (0xD800 <= code && code <= 0xDBFF) {
+    hi = code;
+    low = str.charCodeAt(idx + 1);
+    if (isNaN(low)) {
+      throw 'High surrogate not followed by low surrogate in fixedCharCodeAt()';
+    }
+    return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;
+  }
+  if (0xDC00 <= code && code <= 0xDFFF) { // Low surrogate
+    // Retornamos false para permitir os loops pularem essa iteração já que já deveria
+    //ter tratado os substitutos elevados acima, na iteração anterior
+    return false;
+    /*hi = str.charCodeAt(idx - 1);
+    low = code;
+    return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;*/
+  }
+  return code;
+}
+
+ +

Corrigindo o charCodeAt() para manipular caracteres de Plano Multilingual não Básico se sua presença na string é desconhecida

+ +
function knownCharCodeAt(str, idx) {
+  str += '';
+  var code,
+      end = str.length;
+
+  var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  while ((surrogatePairs.exec(str)) != null) {
+    var li = surrogatePairs.lastIndex;
+    if (li - 2 < idx) {
+      idx++;
+    }
+    else {
+      break;
+    }
+  }
+
+  if (idx >= end || idx < 0) {
+    return NaN;
+  }
+
+  code = str.charCodeAt(idx);
+
+  var hi, low;
+  if (0xD800 <= code && code <= 0xDBFF) {
+    hi = code;
+    low = str.charCodeAt(idx + 1);
+    // Vá um adiante, já que um dos "characters" é parte de um par substituto
+    return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;
+  }
+  return code;
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição inicial. Implementado no JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.5.4.5', 'String.prototype.charCodeAt')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}}{{Spec2('ESDraft')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/codepointat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/codepointat/index.html new file mode 100644 index 0000000000..c2b9caa273 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/codepointat/index.html @@ -0,0 +1,143 @@ +--- +title: String.prototype.codePointAt() +slug: Web/JavaScript/Reference/Global_Objects/String/codePointAt +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/codePointAt +--- +
{{JSRef}}
+ +

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

+ +
{{EmbedInteractiveExample("pages/js/string-codepointat.html","shorter")}}
+ + + +

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, {{jsxref ("undefined")}} é retornado.

+ +

Descrição

+ +

Se não houver nenhum elemento na posição especificada, é retornado o valor de {{jsxref ("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:

+ +
/*! 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()

+ +
'ABC'.codePointAt(1)           // retorna 66
+'\uD800\uDC00'.codePointAt(0)  // retorna 65536
+
+'XYZ'.codePointAt(42)          // retorna undefined
+
+ +

Criando um loop com codePointAt()

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

Especificações

+ + + + + + + + + + +
Especificação
{{SpecName('ESDraft', '#sec-string.prototype.codepointat', 'String.prototype.codePointAt')}}
+ +

Compatibilidade de navegador

+ + + +

{{Compat("javascript.builtins.String.codePointAt")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/concat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/concat/index.html new file mode 100644 index 0000000000..1ea9f9eacf --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/concat/index.html @@ -0,0 +1,138 @@ +--- +title: String.prototype.concat() +slug: Web/JavaScript/Reference/Global_Objects/String/concat +tags: + - JavaScript + - Prototipo + - Referencia + - String + - concat() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/concat +--- +
{{JSRef}}
+ +

O método concat() combina o texto de duas ou mais strings e retorna uma nova string.

+ +

Sintaxe

+ +
str.concat(string2 [, ...stringN])
+ +

Parâmetros

+ +
+
string2...stringN
+
Strings para concatenar à string2.
+
+ +

Valor retornado

+ +

Uma nova string contendo a string original concatenada à string passada como parâmetro.

+ +

Descrição

+ +

A função concat() combina o texto de duas ou mais strings e retorna uma nova string. As alterações de texto de uma string não afetam a outra string.

+ +

Se o argumento passado não for do tipo string, o mesmo será convertido em uma string antes de ser concatenado.

+ +

Performance

+ +

É extremamente recomendado o uso dos operadores de atribuição (+, +=) em detrimento do método concat().

+ +

Exemplos

+ +

Usando concat()

+ +

O exemplo a seguir concatena uma string à outra string originando uma terceira string.

+ +
var hello = 'Olá, ';
+console.log(hello.concat('Kevin', ' tenha um bom dia.'));
+
+// retorna 'Olá, Kevin tenha um bom dia.'
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentários
{{SpecName('ES3')}}{{Spec2('ES3')}}Definição inicial. Implementado no JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.5.4.6', 'String.prototype.concat')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.concat', 'String.prototype.concat')}}{{Spec2('ES6')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/endswith/index.html b/files/pt-br/web/javascript/reference/global_objects/string/endswith/index.html new file mode 100644 index 0000000000..0e62545d41 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/endswith/index.html @@ -0,0 +1,103 @@ +--- +title: String.prototype.endsWith() +slug: Web/JavaScript/Reference/Global_Objects/String/endsWith +tags: + - JavaScript + - Prototipo + - Referencia + - String + - endsWith() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith +--- +
{{JSRef}}
+ +
+ +

O método endsWith() indica se uma string termina com determinados caracteres, retornando true ou false.

+ +

Sintaxe

+ +
str.endsWith(stringSendoBuscada[, tamanho])
+ +

Parâmetros

+ +
+
stringSendoBuscada
+
Os caracteres a serem pesquisados no final da string.
+
tamanho
+
Opcional. Se fornecido, substitui o tamanho da string passada. Se omitido, o valor padrão é o tamanho da string.
+
+ +

Valor retornado

+ +

true se os caracteres passados forem encontrados no final da string. Do contrário, retorna false.

+ +

Descrição

+ +

Este método permite que você verifique se uma string termina ou não com determinados caracteres. Este método é case-sensitive.

+ +

Exemplos

+ +

Usando endsWith()

+ +
var str = 'Ser ou não ser, eis a questão';
+
+console.log(str.endsWith('questão')); // retorna true
+console.log(str.endsWith('ser'));     // retorna false
+console.log(str.endsWith('ser', 14)); // retorna true
+
+ +

Polyfill

+ +

Este método foi adicionada na especificação ECMAScript 6 e talvez não esteja disponível em todos as implementações JavaScript ainda. No entanto, você pode criá-lo adicionando o seguinte código:

+ +
if (!String.prototype.endsWith)
+  String.prototype.endsWith = function(searchStr, Position) {
+      // This works much better than >= because
+      // it compensates for NaN:
+      if (!(Position < this.length))
+        Position = this.length;
+      else
+        Position |= 0; // round position
+      return this.substr(Position - searchStr.length,
+                         searchStr.length) === searchStr;
+  };
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES6', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}{{Spec2('ES6')}}Definição inicial.
{{SpecName('ESDraft', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}{{Spec2('ESDraft')}}
+ + + + + +

{{Compat("javascript.builtins.String.endsWith")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fixed/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fixed/index.html new file mode 100644 index 0000000000..4a6004f05d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/fixed/index.html @@ -0,0 +1,66 @@ +--- +title: String.prototype.fixed() +slug: Web/JavaScript/Reference/Global_Objects/String/fixed +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - fixed() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/fixed +--- +
{{JSRef}} {{deprecated_header}}
+ +

O método fixed() cria um elemento HTML <tt> 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>.

+ +

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:

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

Especificações

+ + + + + + + + + + +
Specification
{{SpecName('ESDraft', '#sec-string.prototype.fixed', 'String.prototype.fixed')}}
+ + + + + +

{{Compat("javascript.builtins.String.fixed")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fontcolor/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fontcolor/index.html new file mode 100644 index 0000000000..aafc3074e9 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/fontcolor/index.html @@ -0,0 +1,84 @@ +--- +title: String.prototype.fontcolor() +slug: Web/JavaScript/Reference/Global_Objects/String/fontcolor +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - fontcolor() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontcolor +--- +
{{JSRef}} {{deprecated_header}}
+ +

O método fontcolor() cria um elemento HTML <font> que faz com que uma string seja exibida na cor especificada.

+ +
+

Nota de uso: O elemento <font> foi removido do HTML5 e não deve mais ser usado. Em vez disso, web developers devem usar a propriedade CSS correspondente.

+
+ +

Sintaxe

+ +
str.fontcolor(color)
+ +

Parâmetros

+ +
+
color
+
Deve ser um string que expresse uma cor em formato hexadecimal ou o nome, em Inglês, de uma cor. Os nomes das cores estão listados na referência de cores CSS.
+
+ +

Valor retornado

+ +

Uma string contendo um elemento HTML <font>.

+ +

Descrição

+ +

Se você expressar uma cor em formato hexadecimal, deve usar o formato rrggbb. Por exemplo, os valores RGB hexadecimais para salmão são vermelho = FA, verde = 80 e azul = 72, portanto, o tripleto RGB para salmão é "FA8072".

+ +

Exemplos

+ +

Usando fontcolor()

+ +

O exemplo a seguir usa o método fontcolor() para alterar a cor de uma string, produzindo uma string com a tag HTML <font>.

+ +
var worldString = 'Olá, mundo';
+
+console.log(worldString.fontcolor('red') +  ' está vermelho nesta linha');
+// '<font color="red">Olá, mundo</font> está vermelho nesta linha'
+
+console.log(worldString.fontcolor('FF00') + ' está vermelho em hexadecimal nesta linha');
+// '<font color="FF00">Olá, mundo</font> está vermelho em hexadecimal nesta linha'
+
+ +

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

+ +
document.getElementById('#oIdDoElemento').style.color = 'red';
+
+ +

Especificações

+ + + + + + + + + + +
Specification
{{SpecName('ESDraft', '#sec-string.prototype.fontcolor', 'String.prototype.fontcolor')}}
+ + + + + +

{{Compat("javascript.builtins.String.fontcolor")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fontsize/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fontsize/index.html new file mode 100644 index 0000000000..655a012b92 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/fontsize/index.html @@ -0,0 +1,83 @@ +--- +title: String.prototype.fontsize() +slug: Web/JavaScript/Reference/Global_Objects/String/fontsize +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - fontsize() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontsize +--- +
{{JSRef}} {{deprecated_header}}
+ +

O método fontsize() cria um elemento HTML <font> que faz com que uma string seja exibida no tamanho da fonte especificada.

+ +
+

Nota de uso: O elemento <font> foi removido do HTML5 e não deve mais ser usado. Em vez disso, web developers devem usar a propriedade CSS correspondente.

+
+ +

Sintaxe

+ +
str.fontsize(size)
+ +

Parâmetros

+ +
+
size
+
Um número inteiro entre 1 e 7.
+
+ +

Valor retornado

+ +

Uma string contendo um elemento HTML <font>.

+ +

Descrição

+ +

Ao especificar o tamanho como um inteiro, você define o tamanho da fonte do texto para um dos 7 tamanhos definidos. Ao especificar size como uma string como "-2", você ajusta o tamanho da fonte do texto em relação ao tamanho definido na tag <basefont>.

+ +

Exemplos

+ +

Usando fontsize()

+ +

O exemplo a seguir usa métodos do objeto global String para alterar o tamanho de uma string:

+ +
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)); // <font size="7">Olá, mundo</fontsize>
+
+ +

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

+ +
document.getElementById('#oIdDoElemento').style.fontSize = '0.7em';
+
+ +

Especificações

+ + + + + + + + + + +
Specification
{{SpecName('ESDraft', '#sec-string.prototype.fontsize', 'String.prototype.fontsize')}}
+ + + + + +

{{Compat("javascript.builtins.String.fontsize")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fromcharcode/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fromcharcode/index.html new file mode 100644 index 0000000000..23a8de8f44 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/fromcharcode/index.html @@ -0,0 +1,142 @@ +--- +title: String.fromCharCode() +slug: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +tags: + - JavaScript + - Referencia + - String + - UTF-16 + - Unicode + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +--- +
{{JSRef}}
+ +

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 {{jsxref("String")}}.

+ +

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

+ +

Exemplos

+ +

Usando fromCharCode()

+ +

O seguinte exemplo retorna a string "ABC".

+ +
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 experado 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, {{jsxref("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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição inicial. Implementado no JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.5.3.2', 'StringfromCharCode')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.fromcharcodes', 'String.fromCharCode')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-string.fromcharcodes', 'String.fromCharCode')}}{{Spec2('ESDraft')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
CaracterísticasChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticasAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fromcodepoint/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fromcodepoint/index.html new file mode 100644 index 0000000000..f8b2bfbf7d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/fromcodepoint/index.html @@ -0,0 +1,213 @@ +--- +title: String.fromCodePoint() +slug: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint +tags: + - JavaScript + - Referencia + - String + - UTF-16 + - Unicode + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint +--- +
{{JSRef}}
+ +

O método estático String.fromCodePoint() retorna uma seqüência de caracteres criado usando a seqüência especificada de pontos de código.

+ +

Syntax

+ +
String.fromCodePoint(num1[, ...[, numN]])
+ +

Parâmetros

+ +
+
num1, ..., numN
+
Uma sequência de pontos de código.
+
+ +

Exceções

+ +
+
{{jsxref("RangeError")}}
+
+

O {{jsxref("RangeError")}} é lançado se um ponto de código Unicode inválido é dado (por exemplo, "RangeError: NaN não é um ponto de código válido").

+
+
+ +

Descrição

+ +

Como o fromCodePoint() é um método estático do {{jsxref("String")}}, você sempre vai chamar esse método como String.fromCodePoint()✔ em vez de usá-lo como um método de uma string que você criar, como "minha string".fromCodePoint()❌.

+ +

Exemplos

+ +

Usando fromCodePoint()

+ +
String.fromCodePoint(42);       // "*"
+String.fromCodePoint(65, 90);   // "AZ"
+String.fromCodePoint(0x404);    // "\u0404"
+String.fromCodePoint(0x2F804);  // "\uD87E\uDC04"
+String.fromCodePoint(194564);   // "\uD87E\uDC04"
+String.fromCodePoint(0x1D306, 0x61, 0x1D307) // "\uD834\uDF06a\uD834\uDF07"
+
+String.fromCodePoint('_');      // RangeError
+String.fromCodePoint(Infinity); // RangeError
+String.fromCodePoint(-1);       // RangeError
+String.fromCodePoint(3.14);     // RangeError
+String.fromCodePoint(3e-2);     // RangeError
+String.fromCodePoint(NaN);      // RangeError
+
+ +
// String.fromCharCode() alone cannot get the character at such a high code point
+// The following, on the other hand, can return a 4-byte character as well as the
+// usual 2-byte ones (i.e., it can return a single character which actually has
+// a string length of 2 instead of 1!)
+console.log(String.fromCodePoint(0x2F804)); // or 194564 in decimal
+
+ +

Polyfill

+ +

O método String.fromCodePoint  foi adicionado ao padrão ECMAScript na versão 6 e pode não ser suportado em todos os navegadores da Web ou em todos os ambientes ainda. Use o código abaixo para um polyfill:

+ +
/*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
+if (!String.fromCodePoint) {
+  (function() {
+    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 stringFromCharCode = String.fromCharCode;
+    var floor = Math.floor;
+    var fromCodePoint = function() {
+      var MAX_SIZE = 0x4000;
+      var codeUnits = [];
+      var highSurrogate;
+      var lowSurrogate;
+      var index = -1;
+      var length = arguments.length;
+      if (!length) {
+        return '';
+      }
+      var result = '';
+      while (++index < length) {
+        var codePoint = Number(arguments[index]);
+        if (
+          !isFinite(codePoint) ||       // `NaN`, `+Infinity`, or `-Infinity`
+          codePoint < 0 ||              // not a valid Unicode code point
+          codePoint > 0x10FFFF ||       // not a valid Unicode code point
+          floor(codePoint) != codePoint // not an integer
+        ) {
+          throw RangeError('Invalid code point: ' + codePoint);
+        }
+        if (codePoint <= 0xFFFF) { // BMP code point
+          codeUnits.push(codePoint);
+        } else { // Astral code point; split in surrogate halves
+          // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+          codePoint -= 0x10000;
+          highSurrogate = (codePoint >> 10) + 0xD800;
+          lowSurrogate = (codePoint % 0x400) + 0xDC00;
+          codeUnits.push(highSurrogate, lowSurrogate);
+        }
+        if (index + 1 == length || codeUnits.length > MAX_SIZE) {
+          result += stringFromCharCode.apply(null, codeUnits);
+          codeUnits.length = 0;
+        }
+      }
+      return result;
+    };
+    if (defineProperty) {
+      defineProperty(String, 'fromCodePoint', {
+        'value': fromCodePoint,
+        'configurable': true,
+        'writable': true
+      });
+    } else {
+      String.fromCodePoint = fromCodePoint;
+    }
+  }());
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES6', '#sec-string.fromcodepoint', 'String.fromCodePoint')}}{{Spec2('ES6')}}Initial definition.
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support +

{{CompatChrome("41")}}

+ 		{{CompatGeckoDesktop("29")}}{{CompatNo}}{{CompatOpera("28")}}{{CompatNo}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatNo}}{{CompatNo}}{{CompatGeckoMobile("29")}}{{CompatNo}}{{CompatNo}}{{CompatNo}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/includes/index.html b/files/pt-br/web/javascript/reference/global_objects/string/includes/index.html new file mode 100644 index 0000000000..c76b927cf3 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/includes/index.html @@ -0,0 +1,108 @@ +--- +title: String.prototype.includes() +slug: Web/JavaScript/Reference/Global_Objects/String/includes +tags: + - ES6 + - JavaScript + - Prototipo + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/includes +--- +
{{JSRef}}
+ +

O método includes() determina se um conjunto de caracteres pode ser encontrado dentro de outra string, retornando true ou false.

+ +

Sintaxe

+ +
str.includes(searchString[, position])
+ +

Parâmetros

+ +
+
searchString
+
É o conjunto de caracteres que será pesquisado dentro desta string.
+
position
+
Opcional. É um número inteiro que indica por onde a busca iniciará, referente ao índice da string a ser pesquisada. O valor padrão é 0.
+
+ +

Valor retornado

+ +

true se o conjunto de caracteres for encontrado em algum lugar dentro da string sendo pesquisada. Do contrário, retorna false.

+ +

Descrição

+ +

Este método permite conferir se uma string contém um determinado conjunto de caracteres.

+ +

Case-sensitivity

+ +

O método includes() é case sensitive. Por exemplo, a seguinte expressão retorna false:

+ +
'Bandeira do Brasil'.includes('brasil'); // retorna false
+
+ +

Exemplos

+ +

Utilizando includes()

+ +
var str = 'Ser, ou não ser, eis a questão.';
+
+console.log(str.includes('Ser'));         // true
+console.log(str.includes('questão'));     // true
+console.log(str.includes('não existe'));  // false
+console.log(str.includes('ser', 1));      // true
+console.log(str.includes('SER'));         // false
+
+ +

Implementação

+ +

Este método foi adicionado à especificação ECMAScript 6 e pode não estar disponível em todas as implementações JavaScript. No entanto, você pode facilmente implementar este método:

+ +
if (!String.prototype.includes) {
+  String.prototype.includes = function() {'use strict';
+    return String.prototype.indexOf.apply(this, arguments) !== -1;
+  };
+}
+
+
+ +

Especificações

+ + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES6', '#sec-string.prototype.includes', 'String.prototype.includes')}}{{Spec2('ES6')}}Definição inicial.
+ + + +
{{Compat("javascript.builtins.String.includes")}}
+ +

String.prototype.contains

+ +

No Firefox 18 - 39, o nome deste método era contains(). Ele foi renomeado para includes() no {{bug(1102219)}} devido ao seguinte motivo:

+ +

Foi reportado que alguns websites que utilizam MooTools 1.2 não funcionavam no Firefox 17. Esta versão do MooTools verifica se String.prototype.contains() existe e, se não existir, MooTools adiciona sua própria função. Com a implementação desta função no Firefox 17, o comportamento desta validação mudou de uma forma que códigos baseados na implementação da função String.prototype.contains() do MooTools parassem de funcionar. Como resultado, esta mudança foi desabilitada no Firefox 17 e String.prototype.contains() foi disponibilizada na versão seguinte, no Firefox 18.

+ +

MooTools 1.3 força sua própria versão do String.prototype.contains(), portanto websites baseados nela não devem parar de funcionar. No entanto, você deve notar que a assinatura do MooTools 1.3 e a assinatura ECMAScript 6 diferem (no segundo argumento). Posteriormente, MooTools 1.5+ mudou sua assinatura para o padrão ES6.

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/index.html b/files/pt-br/web/javascript/reference/global_objects/string/index.html new file mode 100644 index 0000000000..e7ab10819b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/index.html @@ -0,0 +1,338 @@ +--- +title: String +slug: Web/JavaScript/Reference/Global_Objects/String +tags: + - JavaScript + - Reference + - String +translation_of: Web/JavaScript/Reference/Global_Objects/String +--- +

{{JSRef("Global_Objects", "String")}}

+ +

Sumário

+ +

O objeto global String  é um construtor para strings, ou uma sequência de caracteres.

+ +

Sintaxe

+ +

As formas literais de declaração de String  são:

+ +
'string text'
+"string text"
+"中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어"
+ +

Além da forma regular, de caracteres de impressão, caracteres especiais podem ser codificados usando a escape notation (notação com barra invertida):

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CodigoSaida
\0o  caractere NULL
\'aspas simples
\"aspas duplas
\\barra invertida
\nnova linha
\rcarriage return
\vtab vertical
\ttab
\bbackspace
\fform feed
\uXXXXunicode codepoint
\xXXthe Latin-1 character
+ +

Ou, usando o objeto global String diretamente:

+ +
String(thing)
+new String(thing)
+ +

Parâmetros

+ +
+
thing
+
Qualquer coisa a ser convertida para uma string.
+
+ +

Descrição

+ +

Strings são úteis para guardar dados que podem ser representados em forma de texto. Uma das operações mais usadas nas strings é checar seu {{jsxref("String.length", "tamanho")}}, para construir e concatená-las  usando os operadores + e +=, checando pela existência ou posição de substrings com o método {{jsxref("String.indexOf", "indexOf")}} , ou extrair substrings com o método {{jsxref("String.substring", "substring")}}.

+ +

Acesso à caractere

+ +

Há duas maneiras de acessar um caractere individual em uma string. A primeira é o método {{jsxref("String.charAt", "charAt")}}:

+ +
return 'cat'.charAt(1); // returns "a"
+
+ +

A outra maneira (introduzido no ECMAScript 5) consiste em tratar a string como um objeto Array-like, onde os caráteres individuais correspondem a um índice numérico:

+ +
return 'cat'[1]; // returns "a"
+
+ +

Para acesso de caracteres usando uma notação de colchetes, tentando deletar ou designar um valor a estas propriedades não haverá sucesso. As propriedades envolvidas não são nem escritas ou configuráveis. (Veja {{jsxref("Object.defineProperty")}} para mais informações.)

+ +

Comparando strings

+ +

Desenvolvedores de C têm a função strcmp() para comparar strings. No JavaScript, basta usar o operador maior que e menor que:

+ +
var a = "a";
+var b = "b";
+if (a < b) // verdadeiro
+  print(a + " é menor que " + b);
+else if (a > b)
+  print(a + " é maior que " + b);
+else
+  print(a + " e " + b + " são iguais.");
+
+ +

Um resultado similar pode ser alcançado usando o método  {{jsxref("String.localeCompare", "localeCompare")}} herdado pelas instâncias de String.

+ +

Distinção entre String primitiva e objetos String

+ +

Note que o JavaScript distingue entre objetos String e valores de string primitivas. (O mesmo é válido para {{jsxref("Global_Objects/Boolean", "Boolean")}} e {{jsxref("Global_Objects/Number", "Numbers")}}.)

+ +

Strings literais (definidas por aspas duplas ou aspas simples) e strings retornadas da chamada da função String fora do contexto de uma função construtora (sem o uso da palavra chave new) são strings primitivas. O JavaScript converte automaticamente strings primitivas para objetos do tipo String, por isso é possível utilizar os métodos do objeto String através de strings primitivas. Em contextos onde um método é invocado de uma string primitiva ou uma propriedade é procurada, o JavaScript irá criar um objeto com a string primitiva e executar o método ou acessar a propriedade procurada.

+ +
var s_prim = "foo";
+var s_obj = new String(s_prim);
+
+console.log(typeof s_prim); // Loga "string"
+console.log(typeof s_obj);  // Loga "object"
+
+ +

String primitivas e objetos String também dão resultados diferentes quando usado {{jsxref("Global_Objects/eval", "eval")}}. Primitivas passadas para eval são tratadas como código fonte; Objetos String são tratados como todos os outros objetos são, retornando o objeto. Por exemplo:

+ +
s1 = "2 + 2";               // cria uma string primitiva
+s2 = new String("2 + 2");   // cria um objeto de String
+console.log(eval(s1));      // retorna o número 4
+console.log(eval(s2));      // retorna a string "2 + 2"
+
+ +

Por estas razões, o código pode quebrar quando encontra objetos String quando espera na verdade uma string primitiva, apesar de que geralmente autores não precisam se preocupar com a distinção.

+ +

Um objeto String pode ser convertido sempre para sua contraparte primitiva com o método {{jsxref("String.valueOf", "valueOf")}}.

+ +
console.log(eval(s2.valueOf())); // retorna o número 4
+
+ +
Note: Para uma outra possível abordagem para strings em JavaScript, favor ler o artigo sobre StringView – a C-like representation of strings based on typed arrays.
+ +

Propriedades

+ +
+
{{jsxref("String.prototype")}}
+
Permite a adição de propriedades a um objeto String.
+
+ +
{{jsOverrides("Function", "Properties", "prototype")}}
+ +

Métodos

+ +
+
{{jsxref("String.fromCharCode()")}}
+
Retorna uma string criada usando a sequência especificada de valores Unicode.
+
{{jsxref("String.fromCodePoint()")}} {{experimental_inline}}
+
Retorna uma string criada usando a sequência especificada de posições de código.
+
+ +
{{jsOverrides("Function", "Methods", "fromCharCode", "fromCodePoint")}}
+ +

Métodos genéricos de Strings

+ +

Métodos de instância String também estão disponíveis no Firefox a partir de JavaScript 1.6 (embora não faça parte dos padrões ECMAScript) no objeto String para aplicar métodos String a qualquer objeto:

+ +
var num = 15;
+alert(String.replace(num, /5/, '2'));
+
+ +

Genéricos também estão disponíveis em métodos {{jsxref("Global_Objects/Array", "Array")}}.

+ +

O seguinte é uma implementação para fornecer suporte a navegadores sem suporte:

+ +
/*globals define*/
+// Assume que todos os métodos de instância String fornecidos
+// já presentes (podem ser usadas implementações para este se não disponível)
+(function () {
+    'use strict';
+
+    var i,
+        // Nós também poderíamos construir o array de métodos com os seguintes,
+        // mas o método getOwnPropertyNames() não é implementável:
+        // Object.getOwnPropertyNames(String).filter(function (methodName)
+        //  {return typeof String[methodName] === 'function'});
+        methods = [
+            'quote', 'substring', 'toLowerCase', 'toUpperCase', 'charAt',
+            'charCodeAt', 'indexOf', 'lastIndexOf', 'startsWith', 'endsWith',
+            'trim', 'trimLeft', 'trimRight', 'toLocaleLowerCase',
+            'toLocaleUpperCase', 'localeCompare', 'match', 'search',
+            'replace', 'split', 'substr', 'concat', 'slice'
+        ],
+        methodCount = methods.length,
+        assignStringGeneric = function (methodName) {
+            var method = String.prototype[methodName];
+            String[methodName] = function (arg1) {
+                return method.apply(arg1, Array.prototype.slice.call(arguments, 1));
+            };
+        };
+
+    for (i = 0; i < methodCount; i++) {
+        assignStringGeneric(methods[i]);
+    }
+}());
+
+ +

Instâncias de String

+ +

Propriedades

+ +

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Propriedades')}}

+ +

Métodos

+ +

Métodos não relacionados ao HTML

+ +

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Métodos_não_relacionados_ao_HTML')}}

+ +

Métodos de envoltório HTML

+ +

{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Métodos_de_envoltório_HTML')}}

+ +

Exemplos

+ +

Conversão de String

+ +

É possível usar String como uma alternativa "mais segura" {{jsxref("String.toString", "toString")}}, como embora normalmente ainda chama o toString subjacente, também funciona para null e undefined. Por exemplo:

+ +
var outputStrings = [];
+for (let i = 0, n = inputValues.length; i < n; ++i) {
+  outputStrings.push(String(inputValues[i]));
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
ECMAScript 1st Edition.StandardDefinições iniciais.
{{SpecName('ES5.1', '#sec-15.5', 'String')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-string-objects', 'String')}}{{Spec2('ES6')}} 
+ +

Compatibilidade de Browser

+ +

{{ CompatibilityTable() }}

+ +
+ + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support0.2{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/indexof/index.html b/files/pt-br/web/javascript/reference/global_objects/string/indexof/index.html new file mode 100644 index 0000000000..fc62ad78a0 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/indexof/index.html @@ -0,0 +1,158 @@ +--- +title: String.prototype.indexOf() +slug: Web/JavaScript/Reference/Global_Objects/String/indexOf +tags: + - JavaScript + - Prototipo + - Referencia + - String + - indexOf() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf +--- +

{{JSRef("Global_Objects", "String")}}

+ +

Sumário

+ +

O método indexOf() retorna o índice da primeira ocorrência do valor fornecido em searchValue, começando a busca a partir de fromIndex. Retorna -1 se o valor não for encontrado.

+ +
+

Nota: Para o método de Array, veja {{jsxref("Array.prototype.indexOf()")}}.

+
+ +

Sintaxe

+ +
str.indexOf(searchValue[, fromIndex])
+ +

Parâmetros

+ +
+
searchValue
+
Uma string representando o valor a ser buscado. Se nenhuma string for fornecida explicitamente, searchValue terá o valor de undefined, e esse valor será buscado na string atual. Por exemplo, 'undefined'.indexOf() retornará 0, já que undefined é encontrado na posição 0. Já 'undefine'.indexOf() retornará -1, já que undefined não pôde ser encontrado.
+
fromIndex
+
Um número inteiro representando um índice da string original a partir da qual a busca deve começar. Por padrão é 0. Se fromIndex < 0, a string toda é percorrida (equivale a passar 0). Se fromIndex >= str.length, o método retornará -1, já que a busca será iniciada após o final da string.
+
+ +

Valor retornado

+ +

O índice da primeira ocorrência de searchValue, ou -1 se não for encontrado.

+ +

Uma string vazia no searchValue produz resultados estranhos. Sem fromIndex, ou com qualquer fromIndex menor que o comprimento da string, o valor retornado é o próprio fromIndex:

+ +
'Olá, mundo'.indexOf('') // retorna 0
+'Olá, mundo'.indexOf('', 0) // retorna 0
+'Olá, mundo'.indexOf('', 3) // retorna 3
+'Olá, mundo'.indexOf('', 8) // retorna 8
+ +

Entretanto, com qualquer fromIndex igual ou maior que o comprimento da string, o valor retornado é o comprimento da string:

+ +
'Olá, mundo'.indexOf('', 11) // retorna 10
+'Olá, mundo'.indexOf('', 13) // retorna 10
+'Olá, mundo'.indexOf('', 22) // retorna 10
+ +

Descrição

+ +

Caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é 0, e o índice do último caractere de uma string chamada stringName é stringName.length - 1.

+ +
"Blue Whale".indexOf("Blue");     // retorna  0
+"Blue Whale".indexOf("Whale");    // retorna  5
+"Blue Whale".indexOf("Blute");    // retorna -1
+"Blue Whale".indexOf("Whale", 0); // retorna  5
+"Blue Whale".indexOf("Whale", 5); // retorna  5
+"Blue Whale".indexOf("Whale", 7); // retorna -1
+"Blue Whale".indexOf("");         // retorna  0
+"Blue Whale".indexOf("", 9);      // retorna  9
+"Blue Whale".indexOf("", 10);     // retorna 10
+"Blue Whale".indexOf("", 11);     // retorna 10
+ +

Verificando ocorrências

+ +

Note que um retorno 0 não implica em true, e -1 não implica em false. Portanto, a maneira correta de se verificar se uma string específica está contida em outra string seria:

+ +
"Blue Whale".indexOf("Blue") !== -1; // true
+"Blue Whale".indexOf("Bloe") !== -1; // false
+ +

Exemplos

+ +

Usando indexOf()

+ +

O exemplo a seguir usa indexOf() para localizar valores dentro da string "Brave new world".

+ +
var anyString = "Brave new world";
+
+console.log("O índice do primeiro w partindo do começo é " + anyString.indexOf("w"));
+// Exibe 8
+
+console.log("O índice de 'new' partindo do começo é " + anyString.indexOf("new"));
+// Exibe 6
+
+ +

indexOf() e sensibilidade a maiúsculas e minúsculas

+ +

O exemplo a seguir define duas variáveis string. Ambas contém a mesma string, exceto que a segunda string tem letras maiúsculas. O primeiro método {{domxref("console.log()")}} exibe 19. Porém, como o método indexOf é sensível a letras maiúsculas e minúsculas, a string "cheddar" não é encontrada em myCapString, portanto, o segundo método {{domxref("console.log()")}} exibe -1.

+ +
var myString    = "brie, pepper jack, cheddar";
+var myCapString = "Brie, Pepper Jack, Cheddar";
+
+console.log('myString.indexOf("cheddar") é ' + myString.indexOf("cheddar"));
+// Exibe 19
+console.log('myCapString.indexOf("cheddar") é ' + myCapString.indexOf("cheddar"));
+// Exibe -1
+ +

Usando indexOf() para contar as ocorrências de uma letra numa string

+ +

O exemplo a seguir atribui à variável count o número de ocorrências da letra x na string str:

+ +
const str = 'Serx ou não ser, eisx a questão'
+count = 0;
+pos = str.indexOf("x"); // retorna 3
+
+while ( pos != -1 ) {
+   count++;
+   pos = str.indexOf( "x", pos + 1 /* o mesmo que 3 + 1 */ );
+}
+
+console.log(count);
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoSituaçãoComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição inicial.
{{SpecName('ES5.1', '#sec-15.5.4.7', 'String.prototype.indexOf')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}{{Spec2('ES6')}}
+ + + +

{{Compat("javascript.builtins.String.indexOf")}}

+ +

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/italics/index.html b/files/pt-br/web/javascript/reference/global_objects/string/italics/index.html new file mode 100644 index 0000000000..62467f37c6 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/italics/index.html @@ -0,0 +1,68 @@ +--- +title: String.prototype.italics() +slug: Web/JavaScript/Reference/Global_Objects/String/italics +tags: + - Descontinuado + - JavaScript + - Prototipo + - String + - italics() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/italics +--- +
{{JSRef}} {{deprecated_header}}
+ +

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:

+ +
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
{{SpecName('ESDraft', '#sec-string.prototype.italics', 'String.prototype.italics')}}
+ + + + + +

{{Compat("javascript.builtins.String.italics")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/lastindexof/index.html b/files/pt-br/web/javascript/reference/global_objects/string/lastindexof/index.html new file mode 100644 index 0000000000..893b27054c --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/lastindexof/index.html @@ -0,0 +1,162 @@ +--- +title: String.prototype.lastIndexOf() +slug: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf +tags: + - JavaScript + - Prototipo + - Referencia + - String + - lastIndexOf + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf +--- +
{{JSRef}}
+ +

O método lastIndexOf() retorna o índice da última ocorrência do valor especificado encontrado na {{jsxref("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.

+ +
'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:

+ +
'Blue Whale, Killer Whale'.lastIndexOf('blue'); // retorna -1
+
+ +

Exemplos

+ +

Usando lastIndexOf()

+ +

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

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoEstadoComentários
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição inicial.
{{SpecName('ES5.1', '#sec-15.5.4.8', 'String.prototype.lastIndexOf')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}{{Spec2('ESDraft')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/length/index.html b/files/pt-br/web/javascript/reference/global_objects/string/length/index.html new file mode 100644 index 0000000000..63fd9dac65 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/length/index.html @@ -0,0 +1,142 @@ +--- +title: String.length +slug: Web/JavaScript/Reference/Global_Objects/String/length +tags: + - JavaScript + - Propriedade + - Referencia + - String + - Tamanho da string + - length +translation_of: Web/JavaScript/Reference/Global_Objects/String/length +--- +
{{JSRef}}
+ +

A propriedade length de um objeto {{jsxref("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. {{interwiki("wikipedia", "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

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

+ +
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  "campanhias"
+console.log(myString.length);
+// retorna 10
+
+ +

Especificação

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoEstadoComentários
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição inicial. Implementada no JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}{{Spec2('ES6')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/link/index.html b/files/pt-br/web/javascript/reference/global_objects/string/link/index.html new file mode 100644 index 0000000000..547ded08d4 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/link/index.html @@ -0,0 +1,75 @@ +--- +title: String.prototype.link() +slug: Web/JavaScript/Reference/Global_Objects/String/link +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - link() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/link +--- +
{{JSRef}} {{deprecated_header}}
+ +

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.

+ +

Exemplos

+ + + +

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

+ +
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
{{SpecName('ESDraft', '#sec-string.prototype.link', 'String.prototype.link')}}
+ + + + + +

{{Compat("javascript.builtins.String.link")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/localecompare/index.html b/files/pt-br/web/javascript/reference/global_objects/string/localecompare/index.html new file mode 100644 index 0000000000..9645e8b0f8 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/localecompare/index.html @@ -0,0 +1,163 @@ +--- +title: String.prototype.localeCompare() +slug: Web/JavaScript/Reference/Global_Objects/String/localeCompare +tags: + - Internacionalização + - JavaScript + - Prototipo + - Referencia + - String + - localeCompare() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/localeCompare +--- +
{{JSRef}}
+ +

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.

+ +
{{EmbedInteractiveExample("pages/js/string-localecompare.html")}}
+ + + +

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

+ + + +
+

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 {{jsxref("Global_Objects/Collator", "Intl.Collator")}} e usar a função fornecida por sua propriedade {{jsxref("Collator.prototype.compare", "compare")}}.

+ +

Exemplos

+ +

Usando localeCompare()

+ +
// 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 negativo)
+
+// "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.

+ +
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 {{jsxref ("RangeError")}}:

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

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

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

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

+ + + + + + + + + + + + + + + +
Especificação
{{SpecName('ESDraft', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}
{{SpecName('ES Int Draft', '#sup-String.prototype.localeCompare', 'String.prototype.localeCompare')}}
+ +

Compatibilidade de navegador

+ + + +

{{Compat("javascript.builtins.String.localeCompare")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/match/index.html b/files/pt-br/web/javascript/reference/global_objects/string/match/index.html new file mode 100644 index 0000000000..1ba4671e90 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/match/index.html @@ -0,0 +1,232 @@ +--- +title: String.prototype.match() +slug: Web/JavaScript/Reference/Global_Objects/String/match +tags: + - Expressões Regulares + - JavaScript + - Métodos + - Prototipo + - Referencia + - String + - match() +translation_of: Web/JavaScript/Reference/Global_Objects/String/match +--- +

{{JSRef("Global_Objects", "String")}}

+ +

Resumo

+ +

O método match() retorna uma correspondência entre uma string com uma expressão regular.

+ +

Sintaxe

+ +
str.match(regexp);
+ +

Parâmetros

+ +
+
regexp
+
Um objeto de expressão regular. Se regexp não for uma RegExp, o mesmo será convertido para uma nova RegExp usando new RegExp(regexp).
+
+ Se você não fornecer nenhum parâmetro ao usar o método match(), você obterá um {{jsxref ("Array")}} com uma string vazia: [""].
+
+ +

Valor retornado

+ + + +
+
array
+
Um {{jsxref ("Array")}} cujo conteúdo depende da presença ou ausência do sinalizador global (g), ou {{jsxref ("null")}} se nenhuma correspondência for encontrada.
+
+ +

Propriedades adicionais

+ +

Conforme explicado acima, alguns resultados contêm propriedades adicionais conforme descrito abaixo.

+ +
+
groups
+
Um objeto de grupos de captura nomeados cujas chaves são os nomes, e valores são os grupos de captura ou {{jsxref ("undefined")}} se nenhum grupo de captura nomeado foi definido. Consulte Grupos e Intervalos para obter mais informações.
+
index
+
O índice da pesquisa em que o resultado foi encontrado.
+
input
+
Uma cópia da string pesquisada.
+
+ +

Descrição

+ +

Se a expressão regular não incluir o sinalizador g, str.match() retornará o mesmo resultado que {{jsxref ("RegExp.prototype.exec()", "RegExp.exec()")}}.

+ +

Veja também: métodos RegExp

+ + + +

Exemplos

+ +

Usando match()

+ +

No exemplo a seguir, match() é usado para encontrar "Capítulo", seguido de um ou mais caracteres numéricos, seguido por um ponto decimal e caracteres numéricos 0 ou mais vezes. A expressão inclui a flag i para que diferenças de maiúscula/minúscula sejam ignoradas.

+ +
var str = "Para maiores informações, veja o Capítulo 3.4.5.1";
+var re = /(capítulo \d+(\.\d)*)/i;
+var found = str.match(re);
+
+console.log(found);
+
+// retorna ["Capítulo 3.4.5.1",
+            "Capítulo 3.4.5.1",
+            ".1",
+            index: 33,
+            input: "Para maiores informações, veja o Capítulo 3.4.5.1"]
+
+// "Capítulo 3.4.5.1" é a primeira correspondência e o primeiro valor
+//  capturado a partir de (capítulo \d+(\.\d)*).
+// ".1" é o útlimo valor de (\.\d).
+// A propriedade "index" (33) é o índice de base zero da correspôndencia inteira.
+// A propriedade "input" é a string original que foi analisada.
+
+ +

Usando as bandeiras (flags) global e ignore com
+ match()

+ +

O exemplo a seguir demonstra o uso das bandeiras (flags) global e ignore com match(). Todas as letras de A a E e a a e são retornadas, com cada letra sendo um elemento no array.

+ +
var str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var regexp = /[A-E]/gi;
+var matches_array = str.match(regexp);
+
+console.log(matches_array);
+// ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']
+
+ +
+

Nota: Veja também {{jsxref("String.prototype.matchAll()")}} e Pesquisa avançada com sinalizadores.

+
+ +

Usando grupos de captura nomeados

+ +

Em navegadores que suportam grupos de captura nomeados, o código a seguir captura "fox" ou "cat" em um grupo denominado "animal":

+ +
const paragraph = 'The quick brown fox jumps over the lazy dog. It barked.';
+
+const capturingRegex = /(?<animal>fox|cat) jumps over/;
+const found = paragraph.match(capturingRegex);
+console.log(found.groups); // {animal: "fox"}
+ +

Usando match() sem parâmetros

+ +
var str = "nada se perde, tudo se transforma";
+
+str.match();  // retorna [""]
+
+ +

Um objeto não-RegExp como parâmetro

+ +

Quando o parâmetro regexp é uma string ou um número, ele é convertido implicitamente em um {{jsxref("RegExp")}} usando o new RegExp(regexp).
+
+ Se for um número positivo com um sinal positivo, RegExp() irá ignorar o sinal positivo.

+ +
var str1 = "NaN significa 'não é um número'. Infinity contem -Infinity e +Infinity em JavaScript.",
+    str2 = "Meu avô tem 65 anos e minha avô tem 63.",
+    str3 = "O contrato foi declarado null (nulo) e void (sem efeito)";
+str1.match("número");   // "número" é um string. retorna ["número"]
+str1.match(NaN);        // o tipo de NaN é um número. retorna ["NaN"]
+str1.match(Infinity);   // o tipo de Infinity é um número. retorna ["Infinity"]
+str1.match(+Infinity);  // retorna ["Infinity"]
+str1.match(-Infinity);  // retorna ["-Infinity"]
+str2.match(65);         // retorna ["65"]
+str2.match(+65);        // Um número com sinal positivo. retorna ["65"]
+str3.match(null);       // retorna ["null"]
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçõesEstadoComentário
ECMAScript 3rd Edition.StandardDefinição inicial.
+ Implementado no JavaScript 1.2
{{SpecName('ES5.1', '#sec-15.5.4.10', 'String.prototype.match')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.match', 'String.prototype.match')}}{{Spec2('ES6')}}
+ + + +

{{ CompatibilityTable() }}

+ +
+ + + + + + + + + + + + + + + + + + + +
característicaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte Básico{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte Básico{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/matchall/index.html b/files/pt-br/web/javascript/reference/global_objects/string/matchall/index.html new file mode 100644 index 0000000000..7399d9e290 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/matchall/index.html @@ -0,0 +1,146 @@ +--- +title: String.prototype.matchAll() +slug: Web/JavaScript/Reference/Global_Objects/String/matchAll +tags: + - Expressões Regulares + - JavaScript + - Prototipo + - Referencia + - String + - matchAll() + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/matchAll +--- +
{{JSRef}}
+ +

O método matchAll() retorna um iterador de todos os resultados correspondentes a uma string em relação a uma expressão regular, incluindo grupos de captura.

+ +
{{EmbedInteractiveExample("pages/js/string-matchall.html")}}
+ + + +

Sintaxe

+ +
str.matchAll(regexp)
+ +

Parâmetros

+ +
+
regexp
+
+

Um objeto de expressão regular.

+ +

Se um objeto obj não-RegExp for passado, ele será convertido implicitamente em um {{jsxref("RegExp")}} usando new RegExp(obj).

+ +

O objeto RegExp deve ter o sinalizador (flag) /g, caso contrário, um TypeError será retornado.

+
+
+ +

Valor retornado

+ +

Um iterador (que não é um iterável reinicializável).

+ +

Exemplos

+ +

Regexp.exec() e matchAll()

+ +

Antes da adição do matchAll() ao JavaScript, era possível usar chamadas regexp.exec (e regexes com a sinalização (flag) /g) em um loop para obter todas as correspondências:

+ +
const regexp = RegExp('foo[a-z]*','g');
+const str = 'table football, foosball';
+let match;
+
+while ((match = regexp.exec(str)) !== null) {
+  console.log(`Encontrou ${match[0]} início=${match.index} fim=${regexp.lastIndex}.`);
+  // retorna "Encontrou football início=6 fim=14."
+  // retorna "Encontou foosball início=16 fim=24."
+}
+ +

Com o matchAll() disponível, você pode evitar o loop {{jsxref("Statements/while", "while")}} e executar com g.

+ +

Em vez disso, usando o matchAll(), você obtém um iterador para usar com o mais conveniente {{jsxref ("Statements/for ... of", "for...of")}}, {{jsxref ("Operators/Spread_syntax" , "array spread")}} ou construções {{jsxref ("Array.from()")}}:

+ +
const regexp = RegExp('foo[a-z]*','g');
+const str = 'table football, foosball';
+const matches = str.matchAll(regexp);
+
+for (const match of matches) {
+  console.log(`Encontrou ${match[0]} início=${match.index} fim=${match.index + match[0].length}.`);
+}
+// retorna "Encontrou football início=6 fim=14."
+// retorna "Encontrou foosball início=16 fim=24."
+
+// O iterador de correspondências se esgota após a iterção for..of
+// Chame matchAll novamente para criar um novo iterador
+Array.from(str.matchAll(regexp), m => m[0]);
+// Array [ "football", "foosball" ]
+ +

matchAll() retornará uma exceção se o sinalizador (flag) g estiver ausente.

+ +
const regexp = RegExp('[a-c]','');
+const str = 'abc';
+str.matchAll(regexp);
+// retorna TypeError
+
+ +

matchAll() cria internamente um clone da regexp - portanto, ao contrário de {{jsxref("Global_Objects/RegExp/exec", "regexp.exec()")}}, o lastIndex não muda conforme a string é verificada.

+ +
const regexp = RegExp('[a-c]','g');
+regexp.lastIndex = 1;
+const str = 'abc';
+Array.from(str.matchAll(regexp), m => `${regexp.lastIndex} ${m[0]}`);
+// Array [ "1 b", "1 c" ]
+ +

Melhor acesso para capturar grupos (do que String.prototype.match())

+ +

Outra razão convincente para usar matchAll() é o acesso aprimorado para capturar grupos.

+ +

Os grupos de captura são ignorados ao usar {{jsxref("Global_Objects/String/match", "match()")}} com o sinalizador global /g:

+ +
let regexp = /t(e)(st(\d?))/g;
+let str = 'test1test2';
+
+str.match(regexp);
+// Array ['test1', 'test2']
+ +

Usando o matchAll(), você pode acessar os grupos de captura facilmente:

+ +
let array = [...str.matchAll(regexp)];
+
+array[0];
+// ['test1', 'e', 'st1', '1', index: 0, input: 'test1test2', length: 4]
+array[1];
+// ['test2', 'e', 'st2', '2', index: 5, input: 'test1test2', length: 4]
+
+ +

Especificações

+ + + + + + + + + + + + +
Specification
{{SpecName('ESDraft', '#sec-string.prototype.matchall', 'String.prototype.matchAll')}}
+ + + + + +

{{Compat("javascript.builtins.String.matchAll")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/normalize/index.html b/files/pt-br/web/javascript/reference/global_objects/string/normalize/index.html new file mode 100644 index 0000000000..eb049a0ba5 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/normalize/index.html @@ -0,0 +1,220 @@ +--- +title: String.prototype.normalize() +slug: Web/JavaScript/Reference/Global_Objects/String/normalize +tags: + - ECMAScript2015 + - JavaScript + - Prototipo + - Referencia + - String + - Unicode + - metodo + - normalize() +translation_of: Web/JavaScript/Reference/Global_Objects/String/normalize +--- +
{{JSRef}}
+ +

O método normalize() retorna a Forma de Normalização Unicode (Unicode Normalization Form) de uma dada string (se o valor não é uma string, ele será convertido para uma primeiramente).

+ +

Sintaxe

+ +
str.normalize([form])
+ +

Parâmetros

+ +
+
form
+
Opcional. Um dentre os seguintes valores: "NFC", "NFD", "NFKC", ou "NFKD", especificando o formato de normalização. Se o valor for omitido ou for {{jsxref("undefined")}}, "NFC" será utilizado. +
    +
  • NFC — Formato de Normalização Canônico de Composição. 
    • +
  • NFD — Formato de Normalização Canônico de Decomposição.
    • +
  • NFKC — Formato de Normalização de Compatibilidade de Composição.
    • +
  • NFKD — Formato de Normalização de Compatibilidade de Decomposição.
    • +
+
+
+ +

Valor retornado

+ +

Uma string contendo a Forma de Normalização Unicode da string dada.

+ +

Erros lançados

+ +
+
{{jsxref("RangeError")}}
+
Em erro {{jsxref("RangeError")}} é lançado se form não for um dos valores especificados acima.
+
+ +

Descrição

+ +

O Unicode atribui um valor numérico exclusivo, denominado ponto de código, a cada caractere. Por exemplo, o ponto de código para "A" é fornecido como U+0041. No entanto, às vezes mais de um ponto de código, ou sequência de pontos de código, podem representar o mesmo caractere abstrato - o caractere "ñ", por exemplo, pode ser representado por:

+ + + +
let string1 = '\u00F1';
+let string2 = '\u006E\u0303';
+
+console.log(string1);  //  retorna ñ
+console.log(string2);  //  retorna ñ
+ +

No entanto, como os pontos de código são diferentes, a comparação de strings não os tratará como iguais. E como o número de pontos de código em cada versão é diferente, eles até mesmo possuem comprimentos diferentes.

+ +
let string1 = '\u00F1';            // ñ
+let string2 = '\u006E\u0303';      // ñ
+
+console.log(string1 === string2); // retorna false
+console.log(string1.length);      // retorna 1
+console.log(string2.length);      // retorna 2
+ +

O método normalize() ajuda a resolver esse problema convertendo uma string em uma forma normalizada comum para todas as sequências de pontos de código que representam os mesmos caracteres. Existem duas principais formas de normalização, uma baseada na equivalência canônica e a outra baseada na compatibilidade.

+ +

Normalização de equivalência canônica

+ +

Em Unicode, duas sequências de pontos de código têm equivalência canônica se representarem os mesmos caracteres abstratos e tiverem sempre a mesma aparência visual e comportamento (por exemplo, eles devem sempre ser classificados da mesma maneira).

+ +

Você pode usar o normalize() usando os argumentos "NFD" ou "NFC" para produzir uma forma de string que será a mesma para todas as strings canonicamente equivalentes. No exemplo abaixo, normalizamos duas representações do caractere "ñ":

+ +
let string1 = '\u00F1';           // ñ
+let string2 = '\u006E\u0303';     // ñ
+
+string1 = string1.normalize('NFD');
+string2 = string2.normalize('NFD');
+
+console.log(string1 === string2); // retorna true
+console.log(string1.length);      // retorna 2
+console.log(string2.length);      // retorna 2
+ +

Formas compostas e decompostas

+ +

Observe que o comprimento da forma normalizada em "NFD" é 2. Isso porque "NFD" fornece a versão decomposta da forma canônica, na qual pontos de código únicos são divididos em vários combinados. A forma canônica decomposta para "ñ" é "\u006E\u0303".

+ +

Você pode especificar "NFC" para obter a forma canônica composta, na qual vários pontos de código são substituídos por pontos de código únicos sempre que possível. A forma canônica composta para "ñ" é "\u00F1":

+ +
let string1 = '\u00F1';                           // ñ
+let string2 = '\u006E\u0303';                     // ñ
+
+string1 = string1.normalize('NFC');
+string2 = string2.normalize('NFC');
+
+console.log(string1 === string2);                 // true
+console.log(string1.length);                      // 1
+console.log(string2.length);                      // 1
+console.log(string2.codePointAt(0).toString(16)); // f1
+ +

Normalização de compatibilidade

+ +

No Unicode, duas sequências de pontos de código são compatíveis se representarem os mesmos caracteres abstratos e devem ser tratadas da mesma forma em algumas - mas não necessariamente em todas - aplicações.

+ +

Todas as sequências canonicamente equivalentes também são compatíveis, mas não o contrário.

+ +

Por exemplo:

+ + + +

Em alguns aspectos (como classificação), eles devem ser tratados como equivalentes - e em alguns (como a aparência visual) não devem, portanto, não são canonicamente equivalentes.

+ +

Você pode usar o normalize() usando os argumentos "NFKD" ou "NFKC" para produzir uma forma de string que será a mesma para todas as strings compatíveis:

+ +
let string1 = '\uFB00';
+let string2 = '\u0066\u0066';
+
+console.log(string1);             // ff
+console.log(string2);             // ff
+console.log(string1 === string2); // false
+console.log(string1.length);      // 1
+console.log(string2.length);      // 2
+
+string1 = string1.normalize('NFKD');
+string2 = string2.normalize('NFKD');
+
+console.log(string1);             // ff <- aparência visual modificada
+console.log(string2);             // ff
+console.log(string1 === string2); // true
+console.log(string1.length);      // 2
+console.log(string2.length);      // 2
+ +

Ao aplicar a normalização de compatibilidade, é importante considerar o que você pretende fazer com as strings, uma vez que a forma normalizada pode não ser apropriada para as aplicações. No exemplo acima, a normalização é apropriada para pesquisa, porque permite que um usuário encontre a string pesquisando por "f". Mas pode não ser apropriado para exibição, porque a representação visual é diferente.

+ +

Como na normalização canônica, você pode solicitar formulários compatíveis decompostos ou compostos passando "NFKD" ou "NFKC", respectivamente.

+ +

Exemplos

+ +

Usando normalize()

+ +
// String Inicial
+
+// U+1E9B: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA
+// U+0323: COMBINANDO PONTO ABAIXO
+var str = '\u1E9B\u0323';
+
+
+// Formato de Normalização Canônico de Composição (NFC)
+
+// U+1E9B: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA
+// U+0323: COMBINANDO PONTO ABAIXO
+str.normalize('NFC'); // '\u1E9B\u0323'
+str.normalize();      // igual à linha de cima
+
+
+// Formato de Normalização Canônico de Decomposição (NFD)
+
+// U+017F: CARACTERE LATINO - LETRA S COMPRIDA
+// U+0323: COMBINANDO PONTO ABAIXO
+// U+0307: COMBINANDO PONTO ACIMA
+str.normalize('NFD'); // '\u017F\u0323\u0307'
+
+
+// Formato de Normalização de Compatibilidade de Composição. (NFKC)
+
+// U+1E69: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA E ABAIXO
+str.normalize('NFKC'); // '\u1E69'
+
+
+// Formato de Normalização de Compatibilidade de Decomposição (NFKD)
+
+// U+0073: CARACTERE LATINO - LETRA S COMPRIDA
+// U+0323: COMBINANDO PONTO ABAIXO
+// U+0307: COMBINANDO PONTO ACIMA
+str.normalize('NFKD'); // '\u0073\u0323\u0307'
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES2015', '#sec-string.prototype.normalize', 'String.prototype.normalize')}}{{Spec2('ES2015')}}Definição inicial.
{{SpecName('ESDraft', '#sec-string.prototype.normalize', 'String.prototype.normalize')}}{{Spec2('ESDraft')}}
+ +

Nevegadores compatíveis

+ + + +

{{Compat("javascript.builtins.String.normalize")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/padend/index.html b/files/pt-br/web/javascript/reference/global_objects/string/padend/index.html new file mode 100644 index 0000000000..4c4395451b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/padend/index.html @@ -0,0 +1,103 @@ +--- +title: String.prototype.padEnd() +slug: Web/JavaScript/Reference/Global_Objects/String/padEnd +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - padEnd() +translation_of: Web/JavaScript/Reference/Global_Objects/String/padEnd +--- +
{{JSRef}}
+ +

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.

+ +
{{EmbedInteractiveExample("pages/js/string-padend.html")}}
+ + + +

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 {{jsxref("String")}} cuja composição vem da string original, completada por um ou mais caracteres de preenchimento, respeitando o comprimento alvo.

+ +

Exemplos

+ +

Usando padEnd

+ +
'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:

+ +
// https://github.com/uxitten/polyfill/blob/master/string.polyfill.js
+// https://developer.mozilla.org/en-US/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

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ESDraft', '#sec-string.prototype.padend', 'String.prototype.padEnd')}}{{Spec2('ESDraft')}}Definição inicial no ECMAScript 2017.
{{SpecName('ES8', '#sec-string.prototype.padend', 'String.prototype.padEnd')}}{{Spec2('ES8')}}
+ + + + + +

{{Compat("javascript.builtins.String.padEnd")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/padstart/index.html b/files/pt-br/web/javascript/reference/global_objects/string/padstart/index.html new file mode 100644 index 0000000000..3a60ff2489 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/padstart/index.html @@ -0,0 +1,107 @@ +--- +title: String.prototype.padStart() +slug: Web/JavaScript/Reference/Global_Objects/String/padStart +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - padStart() +translation_of: Web/JavaScript/Reference/Global_Objects/String/padStart +--- +
{{JSRef}}
+ +

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.

+ + + +
{{EmbedInteractiveExample("pages/js/string-padstart.html")}}
+ + + + + +

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 {{jsxref("String")}} de comprimento específico com uma string de preenchimento aplicada a partir do seu início.

+ +

Exemplos

+ +

Exemplos básicos

+ +
'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:

+ +
// https://github.com/uxitten/polyfill/blob/master/string.polyfill.js
+// https://developer.mozilla.org/en-US/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

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ESDraft', '#sec-string.prototype.padstart', 'String.prototype.padStart')}}{{Spec2('ESDraft')}}Implementação inical no ECMAScript 2017.
{{SpecName('ES8', '#sec-string.prototype.padstart', 'String.prototype.padStart')}}{{Spec2('ES8')}}
+ + + + + +

{{Compat("javascript.builtins.String.padStart")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/string/prototype/index.html new file mode 100644 index 0000000000..14594dfaf6 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/prototype/index.html @@ -0,0 +1,176 @@ +--- +title: String.prototype +slug: Web/JavaScript/Reference/Global_Objects/String/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/String +--- +
{{JSRef}}
+ +

A String.prototype representa o prototipo de objeto  {{jsxref("String")}}.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Descrição

+ +

Todas as instâncias {{jsxref("String")}} herdam de String.prototype. Alterações na String são propagadas para todas as instâncias {{jsxref("String")}}.

+ +

Propriedades

+ +
+
String.prototype.constructor
+
Especifica a função que cria o protótipo de um objeto.
+
{{jsxref("String.prototype.length")}}
+
Reflete o comprimento da string.
+
N
+
Usado para acessar o caractere na posição N onde N é um número inteiro entre 0 e um menor que o valor da length. Estas propriedades são apenas de leitura.
+
+ +

Métodos

+ +

Métodos não relacionados ao HTML

+ +
+
{{jsxref("String.prototype.charAt()")}}
+
Retorna o caractere (exatamente uma unidade de código UTF-16) no índice especificado.
+
{{jsxref("String.prototype.charCodeAt()")}}
+
Retorna um número que é o valor da unidade de código UTF-16 em dado índice.
+
{{jsxref("String.prototype.codePointAt()")}}
+
Retorna um número inteiro não negativo Number que é o valor de posição de código da posição de código inicial em dado índice.
+
{{jsxref("String.prototype.concat()")}}
+
Combina o texto de duas strings e retorna uma nova string.
+
{{jsxref("String.prototype.includes()")}}
+
 Determina se uma string deve ser encontrada dentro de outra string.
+
{{jsxref("String.prototype.endsWith()")}}
+
Determina se uma string termina com os caracteres de outra string.
+
{{jsxref("String.prototype.indexOf()")}}
+
Retorna o índice dentro do objeto String chamado da primeira ocorrência do valor especificado, ou -1 se não encontrado.
+
{{jsxref("String.prototype.lastIndexOf()")}}
+
Retorna o índice dentro do objeto String chamado da última ocorrência do valor especificado, ou -1 se não encontrado.
+
{{jsxref("String.prototype.localeCompare()")}}
+
Retorna um número indicando se uma string de referência vem antes ou depois ou é o mesmo que uma string dada em ordem de classificação.
+
{{jsxref("String.prototype.match()")}}
+
Usado para combinar uma expressão regular com uma string.
+
{{jsxref("String.prototype.normalize()")}}
+
Retorna o Formulário de Normalização Unicode do valor string chamado.
+
{{jsxref("String.prototype.padEnd()")}}
+
Empacota a string atual desde o final com uma string dada para criar uma nova string de um dado comprimento.
+
{{jsxref("String.prototype.padStart()")}}
+
Empacota a string atual desde o início com uma string dada para criar uma nova string de um dado comprimento.
+
{{jsxref("String.prototype.quote()")}} {{obsolete_inline}}
+
Envolve a cadeia entre aspas duplas ("" ").
+
{{jsxref("String.prototype.repeat()")}}
+
Retorna uma string consistindo elementos do objeto repetido pelas vezes definidas.
+
{{jsxref("String.prototype.replace()")}}
+
Usado para encontrar uma combinação entre uma expressão regular e uma string, e para substituir uma substring combinada com uma nova substring.
+
{{jsxref("String.prototype.search()")}}
+
Executa a procura por uma combinação entre uma expressão regular e uma string especificada.
+
{{jsxref("String.prototype.slice()")}}
+
Extrai uma seção de uma string e retorna uma nova string.
+
{{jsxref("String.prototype.split()")}}
+
Separa um objeto String em um array de strings separando a string em substrings.
+
{{jsxref("String.prototype.startsWith()")}}
+
Determina se uma string começa com os caracteres de outra string.
+
{{jsxref("String.prototype.substr()")}}
+
Retorna os caracteres em uma string começando no local especificado através do número especificado de caracteres.
+
{{jsxref("String.prototype.substring()")}}
+
Retorna os caracteres em uma string entre dois índices na string.
+
{{jsxref("String.prototype.toLocaleLowerCase()")}}
+
Os caracteres dentro de uma string são convertidos para letras minúsculas enquanto respeita a localidade atual. Para a maioria das línguas, irá retornar o mesmo que toLowerCase().
+
{{jsxref("String.prototype.toLocaleUpperCase()")}}
+
Os caracteres dentro de uma string são convertidas para letra maiúscula enquanto respeita a localidade atual. Para a maioria das línguas, irá retornar o mesmo que toUpperCase().
+
{{jsxref("String.prototype.toLowerCase()")}}
+
Retorna o valor da string de chamada convertido em minúsculas.
+
{{jsxref("String.prototype.toSource()")}} {{non-standard_inline}}
+
Retorna um objeto literal representando o objeto especificado; Você pode usar esse valor para criar um novo objeto. Substitui o metodo:{{jsxref("Object.prototype.toSource()")}}
+
{{jsxref("String.prototype.toString()")}}
+
Retorna uma string que representa o objeto especificado. Substitui o metodo:{{jsxref("Object.prototype.toString()")}}
+
{{jsxref("String.prototype.toUpperCase()")}}
+
Retorna o valor da string de chamada convertido em maiúscula.
+
{{jsxref("String.prototype.trim()")}}
+
Retira o espaço em branco desde o início e o fim da string. Parte do padrão ECMAScript 5.
+
{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}
+
Retira o espaço em branco do lado esquerdo da string.
+
{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}
+
Retira o espaço em branco do lado esquerdo da string.
+
{{jsxref("String.prototype.valueOf()")}}
+
Retorna o valor primitivo do objeto especificado. Substitui o metodo: {{jsxref("Object.prototype.valueOf()")}} 
+
{{jsxref("String.prototype.@@iterator()", "String.prototype[@@iterator]()")}}
+
Retorna um novo objeto  Iterator que repete sobre os pontos de código de um valor String, retornando cada ponto de código como um valor String.
+
+ +

Métodos de envoltório HTML

+ +

Esses métodos são de uso limitado, pois fornecem apenas um subconjunto das tags e atributos HTML disponíveis.

+ +
+
{{jsxref("String.prototype.anchor()")}}
+
{{htmlattrxref("name", "a", "<a name=\"name\">")}} (alvo hipertexto)
+
{{jsxref("String.prototype.big()")}} {{deprecated_inline}}
+
{{HTMLElement("big")}}
+
{{jsxref("String.prototype.blink()")}} {{deprecated_inline}}
+
{{HTMLElement("blink")}}
+
{{jsxref("String.prototype.bold()")}} {{deprecated_inline}}
+
{{HTMLElement("b")}}
+
{{jsxref("String.prototype.fixed()")}} {{deprecated_inline}}
+
{{HTMLElement("tt")}}
+
{{jsxref("String.prototype.fontcolor()")}} {{deprecated_inline}}
+
{{htmlattrxref("color", "font", "<font color=\"color\">")}}
+
{{jsxref("String.prototype.fontsize()")}} {{deprecated_inline}}
+
{{htmlattrxref("size", "font", "<font size=\"size\">")}}
+
{{jsxref("String.prototype.italics()")}} {{deprecated_inline}}
+
{{HTMLElement("i")}}
+
{{jsxref("String.prototype.link()")}}
+
{{htmlattrxref("href", "a", "<a href=\"url\">")}} (link para URL)
+
{{jsxref("String.prototype.small()")}} {{deprecated_inline}}
+
{{HTMLElement("small")}}
+
{{jsxref("String.prototype.strike()")}} {{deprecated_inline}}
+
{{HTMLElement("strike")}}
+
{{jsxref("String.prototype.sub()")}} {{deprecated_inline}}
+
{{HTMLElement("sub")}}
+
{{jsxref("String.prototype.sup()")}} {{deprecated_inline}}
+
{{HTMLElement("sup")}}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificacoesStatusComentarios
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição inicial.
{{SpecName('ES5.1', '#sec-15.5.3.1', 'String.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-string.prototype', 'String.prototype')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-string.prototype', 'String.prototype')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidade entre browsers

+ + + +

{{Compat("javascript.builtins.String.prototype")}}

+ +

Veja também 

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/raw/index.html b/files/pt-br/web/javascript/reference/global_objects/string/raw/index.html new file mode 100644 index 0000000000..86cfe1b25b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/raw/index.html @@ -0,0 +1,120 @@ +--- +title: String.raw() +slug: Web/JavaScript/Reference/Global_Objects/String/raw +tags: + - ECMAScript 2015 + - JavaScript + - Referencia + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/raw +--- +
{{JSRef}}
+ +

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.

+ +

{{EmbedInteractiveExample("pages/js/string-raw.html")}}

+ +

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

+ +
+
{{jsxref("TypeError")}}
+
Um {{jsxref("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()

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

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES2015', '#sec-string.raw', 'String.raw')}}{{Spec2('ES2015')}}Definição inicial.
{{SpecName('ESDraft', '#sec-string.raw', 'String.raw')}}{{Spec2('ESDraft')}}
+ +

Compatibilidade de navegador

+ + + +

{{Compat("javascript.builtins.String.raw")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/repeat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/repeat/index.html new file mode 100644 index 0000000000..94cdca3831 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/repeat/index.html @@ -0,0 +1,294 @@ +--- +title: String.prototype.repeat() +slug: Web/JavaScript/Reference/Global_Objects/String/repeat +tags: + - JavaScript + - Prototype + - Referencia + - Repetir + - String + - metodo + - repeat() +translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat +--- +
{{JSRef}}
+ +

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  {{jsxref("Global_Objects/Number/POSITIVE_INFINITY", "+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

+ + + +

Exemplos

+ +
'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():

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

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES2015', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}{{Spec2('ES2015')}}Definição inicial.
{{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}{{Spec2('ESDraft')}}
+ + + + + +

{{Compat("javascript.builtins.String.repeat")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/replace/index.html b/files/pt-br/web/javascript/reference/global_objects/string/replace/index.html new file mode 100644 index 0000000000..8d1863363b --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/replace/index.html @@ -0,0 +1,352 @@ +--- +title: String.prototype.replace() +slug: Web/JavaScript/Reference/Global_Objects/String/replace +tags: + - Expressões Regulares + - JavaScript + - Prototipo + - Referencia + - String + - replace() +translation_of: Web/JavaScript/Reference/Global_Objects/String/replace +--- +
{{JSRef("Global_Objects", "String")}}
+ +

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 {{jsxref("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.

+ +

Sintaxe

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

Parâmetros

+ +
+
regexp
+
Um objeto {{jsxref ("RegExp")}} ou literal. A correspondência ou correspondências são substituídas por newSubStr ou o valor retornado pela function especificada.
+
substr
+
Uma {{jsxref ("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 {{jsxref("Global_Objects/String", "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_inline}}
+
+

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 {{jsxref("Global_Objects/RegExp", "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_inline}}
+
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 {{jsxref("Global_Objects/String", "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 $nnOnde n ou nn são dígitos decimais, insere a n-ésima substring entre parêntesis casada, dado o primeiro argumento foi um objeto {{jsxref("Global_Objects/RegExp", "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
matchA 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() {{jsxref("Global_Objects/RegExp", "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+.
offsetO 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 {{jsxref("Global_Objects/RegExp", "RegExp")}} e de quantas combinações entre parênteses houver).

+ +

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

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

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

+ +
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 e os padrões de substituição $1 e $2.

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

+ +
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 {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}. Se tivéssemos tentado isto sem a função, o método {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}} não teria efeito.

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

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

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

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
ECMAScript 3rd Edition.StandardDefnição inicial. Implementado no JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.5.4.11', 'String.prototype.replace')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.replace', 'String.prototype.replace')}}{{Spec2('ES6')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Notas específicas do Firefox

+ + + +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/replaceall/index.html b/files/pt-br/web/javascript/reference/global_objects/string/replaceall/index.html new file mode 100644 index 0000000000..c545573689 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/replaceall/index.html @@ -0,0 +1,178 @@ +--- +title: String.prototype.replaceAll() +slug: Web/JavaScript/Reference/Global_Objects/String/replaceAll +tags: + - Expressão Regular + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - regex + - replaceAll() +translation_of: Web/JavaScript/Reference/Global_Objects/String/replaceAll +--- +
{{JSRef}}
+ +
Nota: A partir de Agosto de 2020, o método replaceAll() continuará sendo suportado pelo Firefox, mas não pelo Chrome. Ele estará disponível somente no Chrome 85.
+ +

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 {{jsxref ("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.

+ +
{{EmbedInteractiveExample("pages/js/string-replaceall.html")}}
+ + + +

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 {{jsxref ("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 {{jsxref ("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 {{jsxref("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 {{jsxref("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ãoInsere
$$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.
$nOnde n é um inteiro positivo menor que 100, insere a n-ésima string submatch entre parênteses, desde que o primeiro argumento seja um objeto {{jsxref("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ívelValor fornecido
matchA 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 {{jsxref("RegExp")}}. (Corresponde a $1, $2, etc. acima.) Por exemplo, se /(\a+)(\b+)/, foi dado, p1 é a correspondência para \a+, e p2 para \b+.
offsetO 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.)
stringA string inteira será examinada.
+ +

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

+ +

Exemplos

+ +

Usando replaceAll()

+ +
'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:

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

Já o código abaixo vai funcionar:

+ +
'aabbcc'.replaceAll(/b/g, '.');
+"aa..cc"
+
+ +

Especificações

+ + + + + + + + + + + + +
Especificação
{{SpecName('ESDraft', '#sec-string.prototype.replaceall', 'String.prototype.replaceAll')}}
+ + + + + +

{{Compat("javascript.builtins.String.replaceAll")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/search/index.html b/files/pt-br/web/javascript/reference/global_objects/string/search/index.html new file mode 100644 index 0000000000..0abfec19df --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/search/index.html @@ -0,0 +1,153 @@ +--- +title: String.prototype.search() +slug: Web/JavaScript/Reference/Global_Objects/String/search +tags: + - Expressões Regulares + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - search() +translation_of: Web/JavaScript/Reference/Global_Objects/String/search +--- +
{{JSRef}}
+ +

O método search() realiza uma busca por uma ocorrência entre uma expressão regular e uma {{jsxref ("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 {{jsxref("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 {{jsxref ("RegExp.prototype.test()", "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 {{jsxref ("String.prototype.match()", "match()")}} (semelhante ao método {{jsxref ("RegExp.prototype.exec()" , "exec()")}} da RegExp).

+ +

Exemplos

+ + + +

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

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificaçãoStatusComentário(s)
{{SpecName('ES3')}}{{Spec2('ES3')}}Definição inicial. Implementado no JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.5.4.12', 'String.prototype.search')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.search', 'String.prototype.search')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-string.prototype.search', 'String.prototype.search')}}{{Spec2('ESDraft')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureChromeEdgeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidEdgeFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Notas específicas para a engine Gecko

+ + + +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/slice/index.html b/files/pt-br/web/javascript/reference/global_objects/string/slice/index.html new file mode 100644 index 0000000000..74d6819506 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/slice/index.html @@ -0,0 +1,233 @@ +--- +title: String.prototype.slice() +slug: Web/JavaScript/Reference/Global_Objects/String/slice +tags: + - JavaScript + - Prototipo + - Reference + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/slice +--- +
{{JSRef("Global_Objects", "String")}}
+ +

Sumário

+ +

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

+ +

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).
+
+ 
const nome = 'Ricardo';
+console.log(nome.slice(-3)); // retorna 'rdo'
+
+
+ +
+
Se startIndex for maior ou igual a str.length, uma string vazia será retornada.
+
+ 
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.
+
+ 
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).
+
+ +
+
+ 
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
+
+ 
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.

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

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

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

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

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

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

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

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

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
ECMAScript 3rd Edition.StandardInitial definition. Implemented in JavaScript 1.2.
{{SpecName('ES5.1', '#sec-15.5.4.13', 'String.prototype.slice')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.slice', 'String.prototype.slice')}}{{Spec2('ES6')}}
+ +

Compatibilidade entre Browsers

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/small/index.html b/files/pt-br/web/javascript/reference/global_objects/string/small/index.html new file mode 100644 index 0000000000..2983a5c9fc --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/small/index.html @@ -0,0 +1,72 @@ +--- +title: String.prototype.small() +slug: Web/JavaScript/Reference/Global_Objects/String/small +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - small() +translation_of: Web/JavaScript/Reference/Global_Objects/String/small +--- +
{{JSRef}} {{deprecated_header}}
+ +

O método small() cria um elemento HTML <small> que faz com que uma string seja exibida em uma fonte pequena.

+ +

Sintaxe

+ +
str.small()
+ +

Valor retornado

+ +

Uma string contendo um elemento HTML <small>.

+ +

Descrição

+ +

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

+ +

Exemplos

+ +

Usando small()

+ +

O exemplo a seguir usa métodos do objeto global String para alterar o tamanho da string:

+ +
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)); // <font size="7">Olá, mundo</fontsize>
+
+ +

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

+ +
document.getElementById('#oIdDoElemento').style.fontSize = '0.7em';
+
+ +

Especificações

+ + + + + + + + + + +
Specification
{{SpecName('ESDraft', '#sec-string.prototype.small', 'String.prototype.small')}}
+ + + + + +

{{Compat("javascript.builtins.String.small")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/split/index.html b/files/pt-br/web/javascript/reference/global_objects/string/split/index.html new file mode 100644 index 0000000000..80b42f28e0 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/split/index.html @@ -0,0 +1,282 @@ +--- +title: String.prototype.split() +slug: Web/JavaScript/Reference/Global_Objects/String/split +tags: + - Expressões Regulares + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - split() +translation_of: Web/JavaScript/Reference/Global_Objects/String/split +--- +
{{JSRef}}
+ +

O método split() divide uma {{jsxref ("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.

+ +

Sintaxe

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

Parâmetros

+ + + +
+
separator
+
Opcional. Especifica o caractere, ou conjunto de caracteres, a ser usado para separar a string. O separador pode ser uma string ou uma {{jsxref("Global_Objects/RegExp", "expressão regular", "", 1)}}.
+
+ +
+

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.

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

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

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

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

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

+ +
+

Esta não é a mlehor maneira de reverter uma string:

+ +
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.)

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

Bonus: use o operador {{jsxref("Operators/Comparison_Operators", "===", "#Identity_strict_equality_(===)")}} para testar se a string original era um palíndromo.

+
+ + + +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES3')}}{{Spec2('ES3')}}Definição inicial. Implementado no JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.5.4.14', 'String.prototype.split')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.split', 'String.prototype.split')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-string.prototype.split', 'String.prototype.split')}}{{Spec2('ESDraft')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/startswith/index.html b/files/pt-br/web/javascript/reference/global_objects/string/startswith/index.html new file mode 100644 index 0000000000..899b331458 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/startswith/index.html @@ -0,0 +1,96 @@ +--- +title: String.prototype.startsWith() +slug: Web/JavaScript/Reference/Global_Objects/String/startsWith +tags: + - Começa com + - ECMAScript6 + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - startsWith() +translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith +--- +
{{JSRef}}
+ +

O método startsWith() determina se uma string começa com os caracteres especificados, retornando true ou false.

+ +

{{EmbedInteractiveExample("pages/js/string-startswith.html")}}

+ +

Sintaxe

+ +
str.startsWith(searchString[, position])
+ +

Parâmetros

+ +
+
searchString
+
Os caracteres a serem procurados a partir do início dessa string.
+
position
+
Opcional. A posição nessa string na qual se inicia a busca pela searchString. O valor padrão é 0.
+
+

Valor retornado

+
+
+ +

true se os caracteres fornecidos forem encontrados no início da string. Se não, false.

+ +

Descrição

+ +

Esse método permite determinar se uma string começa ou não com outra string. Esse método é case-sensitive (difere maiúsculas de minúsculas, e vice-versa).

+ +

Exemplos

+ +

Usando startsWith()

+ +
//startswith
+let str = 'Ser ou não ser, eis a questão.';
+
+console.log(str.startsWith('Ser'))          // true
+console.log(str.startsWith('não ser'))      // false
+console.log(str.startsWith('não ser', 7))  // true
+
+ +

Polyfill

+ +

Este método foi adicionaldo à 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 polyfill String.prototype.startsWith() adicionando o seguinte código:

+ +
if (!String.prototype.startsWith) {
+    Object.defineProperty(String.prototype, 'startsWith', {
+        value: function(search, rawPos) {
+            var pos = rawPos > 0 ? rawPos|0 : 0;
+            return this.substring(pos, pos + search.length) === search;
+        }
+    });
+}
+ +

Um polyfill mais robusto (totalmente conforme com a especificação ES2015), mas com menor desempenho e compacto está disponível no GitHub por Mathias Bynens.

+ +

Especificações

+ + + + + + + + + + +
Especificação
{{SpecName('ESDraft', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}}
+ + + +
{{Compat("javascript.builtins.String.startsWith")}}
+ +
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/strike/index.html b/files/pt-br/web/javascript/reference/global_objects/string/strike/index.html new file mode 100644 index 0000000000..004f93b675 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/strike/index.html @@ -0,0 +1,68 @@ +--- +title: String.prototype.strike() +slug: Web/JavaScript/Reference/Global_Objects/String/strike +tags: + - Descontinuado + - JavaScript + - Prototipo + - String + - metodo + - strike() +translation_of: Web/JavaScript/Reference/Global_Objects/String/strike +--- +
{{JSRef}} {{deprecated_header}}
+ +

O método strike() cria um elemento HTML <strike> que faz com que uma string seja exibida com o texto riscado.

+ +

Sintaxe

+ +
str.strike()
+ +

Valor retornado

+ +

Uma string contendo um elemento HTML <strike>.

+ +

Descrição

+ +

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

+ +

Exemplos

+ +

Usando strike()

+ +

O exemplo a seguir usa métodos do objeto global String para alterar a formatação da string:

+ +
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
{{SpecName('ESDraft', '#sec-string.prototype.strike', 'String.prototype.strike')}}
+ + + + + +

{{Compat("javascript.builtins.String.strike")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/sub/index.html b/files/pt-br/web/javascript/reference/global_objects/string/sub/index.html new file mode 100644 index 0000000000..69289bd133 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/sub/index.html @@ -0,0 +1,123 @@ +--- +title: String.prototype.sub() +slug: Web/JavaScript/Reference/Global_Objects/String/sub +tags: + - Descontinuado + - JavaScript + - Prototipo + - String + - metodo + - sub() +translation_of: Web/JavaScript/Reference/Global_Objects/String/sub +--- +
{{JSRef}} {{deprecated_header}}
+ +

O método sub() cria um elemento HTML <sub> que faz com que uma string seja exibida como subscrito (texto pequeno).

+ +

Sintaxe

+ +
str.sub()
+ +

Valor retornado

+ +

Uma string contendo um elemento HTML <sub>.

+ +

Descrição

+ +

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

+ +

Exemplos

+ +

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

+ +

Os exemplos seguintes usam o métodos sub() e {{jsxref("String.prototype.sup()", "sup()")}} para formatar uma string:

+ +
var superText = 'superscript';
+var subText = 'subscript';
+
+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 ' + subText.sub() + ' looks like.');
+// This is what a <sub>subscript</sub> looks like.
+
+ +

Especificação

+ + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES6', '#sec-string.prototype.sub', 'String.prototype.sub')}}{{Spec2('ES6')}}Definição inicial. Implementado no JavaScript 1.0.
{{SpecName('ESDraft', '#sec-string.prototype.sub', 'String.prototype.sub')}}{{Spec2('ESDraft')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatVersionUnknown}}{{CompatGeckoDesktop("1.0")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("1.0")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/substr/index.html b/files/pt-br/web/javascript/reference/global_objects/string/substr/index.html new file mode 100644 index 0000000000..c1e45beaef --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/substr/index.html @@ -0,0 +1,140 @@ +--- +title: String.prototype.substr() +slug: Web/JavaScript/Reference/Global_Objects/String/substr +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - substr() +translation_of: Web/JavaScript/Reference/Global_Objects/String/substr +--- +
{{JSRef}}
+ +

O método substr() retorna uma parte da string, começando no índice especificado e estendendo-se por um determinado número de caracteres posteriormente.

+ +
{{EmbedInteractiveExample("pages/js/string-substr.html")}}
+ +

Sintaxe

+ +
str.substr(start[, length])
+ +

Parâmetros

+ +
+
start
+
Local para começar a extrair os caracteres.
+
length
+
Opcional. O número de caracteres a serem extraídos.
+
+ +

Valor de retorno

+ +

Uma nova string contendo a seção extraída da string fornecida.

+ +

Descrição

+ +

O substr() extrai caracteres de comprimento de uma str, contando a partir do índice inicial.

+ + + +
+

Nota: No Microsoft JScript, valores negativos no argumento start não são considerados como referência ao final da string.

+
+ + + +

Exemplos

+ +

Usando substr()

+ +
var aString = 'Mozilla';
+
+console.log(aString.substr(0, 1));   // 'M'
+console.log(aString.substr(1, 0));   // ''
+console.log(aString.substr(-1, 1));  // 'a'
+console.log(aString.substr(1, -1));  // ''
+console.log(aString.substr(-3));     // 'lla'
+console.log(aString.substr(1));      // 'ozilla'
+console.log(aString.substr(-20, 2)); // 'Mo'
+console.log(aString.substr(20, 2));  // ''
+ +

Polyfill

+ +

JScript da Microsoft não suporta valores negativos para o índice de start. Se você deseja usar esse recurso, você pode usar o seguinte código de compatibilidade para evitar esse erro:

+ +
// only run when the substr() function is broken
+if ('ab'.substr(-1) != 'b') {
+  /**
+   *  Get the substring of a string
+   *  @param  {integer}  start   where to start the substring
+   *  @param  {integer}  length  how many characters to return
+   *  @return {string}
+   */
+  String.prototype.substr = function(substr) {
+    return function(start, length) {
+      // call the original method
+      return substr.call(this,
+      	// did we get a negative start, calculate how much it is from the beginning of the string
+        // adjust the start parameter for negative value
+        start < 0 ? this.length + start : start,
+        length)
+    }
+  }(String.prototype.substr);
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES3')}}{{Spec2('ES3')}}Defined in the (informative) Compatibility Annex B. Implemented in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-B.2.3', 'String.prototype.substr')}}{{Spec2('ES5.1')}}Defined in the (informative) Compatibility Annex B
{{SpecName('ES6', '#sec-string.prototype.substr', 'String.prototype.substr')}}{{Spec2('ES6')}}Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers
{{SpecName('ESDraft', '#sec-string.prototype.substr', 'String.prototype.substr')}}{{Spec2('ESDraft')}}Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers
+ + + + + +

{{Compat("javascript.builtins.String.substr")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/substring/index.html b/files/pt-br/web/javascript/reference/global_objects/string/substring/index.html new file mode 100644 index 0000000000..c54108cb75 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/substring/index.html @@ -0,0 +1,229 @@ +--- +title: String.prototype.substring() +slug: Web/JavaScript/Reference/Global_Objects/String/substring +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - substring() +translation_of: Web/JavaScript/Reference/Global_Objects/String/substring +--- +

{{JSRef("Global_Objects", "String")}}

+ +

Resumo

+ +

O método substring() retorna a parte da string entre os índices inicial e final, ou até o final da string.

+ +

Sintaxe

+ +
str.substring(indexStart[, indexEnd])
+ +

Parâmetros

+ +
+
indexStart
+
Um inteiro entre 0 e o comprimento da string (str.length), especificando a posição na string do primeiro caractere a ser incluído na substring retornada.
+
indexEnd
+
Opcional. Um inteiro entre 0 e o comprimento da string (str.length), especificando a posição na string do primeiro caractere a não ser mais incluído na substring retornada.
+
+ +

Valor retornado

+ +

Uma nova string contendo a parte especificada da string fornecida.

+ +

Descrição

+ +

substring() extrai caracteres desde indexStart até, mas não incluindo, indexEnd. Em particular:

+ + + +

Se indexStart for maior que indexEnd, então o efeito do substring() é como se os dois argumentos estivessem trocados, por exemplo, str.substring(1, 0) == str.substring(0, 1).

+ +

Exemplos

+ +

Usando substring()

+ +

O seguinte exemplo usa substring() para mostrar caracteres da palavra 'Mozilla':

+ +
var anyString = "Mozilla";
+
+// Mostra "Moz"
+console.log(anyString.substring(0,3));
+console.log(anyString.substring(3,0));
+
+// Mostra "lla"
+console.log(anyString.substring(4,7));
+console.log(anyString.substring(7,4));
+
+// Mostra "Mozill"
+console.log(anyString.substring(0,6));
+
+// Mostra "Mozilla"
+console.log(anyString.substring(0,7));
+console.log(anyString.substring(0,10));
+
+ +

Usando substring() com length

+ +

O exemplo a seguir usa o método substring() e a propriedade {{jsxref ("String.length", "length")}} para extrair os últimos caracteres de uma string específica. Este método pode ser mais fácil de lembrar, visto que você não precisa saber os índices inicial e final como faria nos exemplos acima.

+ +
// Mostra 'illa', os últimos 4 caracteres
+let anyString = 'Mozilla'
+let anyString4 = anyString.substring(anyString.length - 4)
+console.log(anyString4);
+
+// Mostra 'zilla', os últimos 5 caracteres
+let anyString = 'Mozilla'
+let anyString5 = anyString.substring(anyString.length - 5)
+console.log(anyString5);
+ +

A diferença entre substring() e substr()

+ +

Há uma diferença sutil entre os métodos substring() e {{jsxref("String.substr", "substr()")}}, então você deve ter cuidado para não confundi-los.

+ +

Os argumentos de substring() representam os índices inicial e final, enquanto os argumentos de substr() representam o índice inicial e o número de caracteres a serem incluídos na string retornada.

+ +

Além disso, substr() é considerado um recurso legacy no ECMAScript e pode ser removido em versões futuras, portanto, é melhor evitar usá-lo, se possível.

+ +
let text = 'Mozilla'
+console.log(text.substring(2,5))  // retorna "zil"
+console.log(text.substr(2,3))     // retorna "zil"
+ +

Diferenças entre substring() e slice()

+ +

Os métodos substring() e {{jsxref("String.slice", "slice()")}} são quase idênticos, mas existem algumas diferenças sutis entre os dois, especialmente na forma como os argumentos negativos são tratados.

+ +

O método substring() troca seus dois argumentos se indexStart for maior que indexEnd, o que significa que uma string ainda será retornada. O método {{jsxref("String.slice", "slice()")}} retorna uma string vazia caso o mesmo ocorra.

+ +
let text = 'Mozilla'
+console.log(text.substring(5, 2))  // retorna "zil"
+console.log(text.slice(5, 2))      // retorna ""
+ +

Se um ou ambos os argumentos forem negativos ou NaN, o método substring() os tratará como se fossem 0.

+ +
console.log(text.substring(-5, 2))  // retorna "Mo"
+console.log(text.substring(-5, -2)) // retorna ""
+ +

slice() também trata os argumentos NaN como 0, mas quando recebe valores negativos, ele conta regressivamente a partir do final da string para encontrar os índices.

+ +
console.log(text.slice(-5, 2))   // retorna ""
+console.log(text.slice(-5, -2))  // retorna "zil"
+ +

Veja a página {{jsxref("String.slice", "slice()")}} para mais exemplos com números negativos.

+ +

Substituindo uma substring() com uma string

+ +

O seguinte exemplo substitui uma substring dentro de uma string. Ela irá substituir ambos caracteres e substrings individualmente. A função invocada na linha final do exemplo altera a string "Brave New World" para "Brave New Web".

+ +
function replaceString(oldS, newS, fullS) {
+// Substitui oldS por newS na string fullS
+  for (var i = 0; i < fullS.length; i++) {
+    if (fullS.substring(i, i + oldS.length) == oldS) {
+     fullS = fullS.substring(0, i) + newS + fullS.substring(i + oldS.length, fullS.length);
+    }
+  }
+  return fullS;
+}
+
+replaceString("World", "Web", "Brave New World");
+ +

Note que isto pode resultar em um loop infinito se oldS for um substring de newS -- por exemplo, se você tentou substituir "World" com "OtherWorld". O melhor método para substituir strings é o seguinte:

+ +
function replaceString(oldS, newS,fullS){
+  return fullS.split(oldS).join(newS);
+}
+ +

O código acima serve como um exemplo para operações com substring. Se você precisa substituir substrings, na maioria das vezes você vai querer usar {{jsxref("String.prototype.replace()")}}.

+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
ECMAScript 1st Edition.StandardImplementado no JavaScript 1.0
{{SpecName('ES5.1', '#sec-15.5.4.15', 'String.prototype.substring')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.substring', 'String.prototype.substring')}}{{Spec2('ES6')}}
+ + + +

{{ CompatibilityTable() }}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}{{ CompatVersionUnknown() }}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/sup/index.html b/files/pt-br/web/javascript/reference/global_objects/string/sup/index.html new file mode 100644 index 0000000000..32bfbef1fd --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/sup/index.html @@ -0,0 +1,69 @@ +--- +title: String.prototype.sup() +slug: Web/JavaScript/Reference/Global_Objects/String/sup +tags: + - Descontinuado + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - sup() +translation_of: Web/JavaScript/Reference/Global_Objects/String/sup +--- +
{{JSRef}} {{deprecated_header}}
+ +

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

+ +

Sintaxe

+ +
str.sup()
+ +

Valor retornado

+ +

Uma string contendo um elemento HTML <sup>.

+ +

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 {{jsxref("String.prototype.sub()", "sub()")}} e sup() para formatar uma string:

+ +
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
{{SpecName('ESDraft', '#sec-string.prototype.sup', 'String.prototype.sup')}}
+ + + + + +

{{Compat("javascript.builtins.String.sup")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tolocalelowercase/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tolocalelowercase/index.html new file mode 100644 index 0000000000..3867903c25 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/tolocalelowercase/index.html @@ -0,0 +1,92 @@ +--- +title: String.prototype.toLocaleLowerCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase +tags: + - Internacionalização + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - toLocaleLowerCase() +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase +--- +
{{JSRef}}
+ +

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.

+ +
{{EmbedInteractiveExample("pages/js/string-tolocalelowercase.html")}}
+ + + +

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 {{jsxref("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

+ + + +

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 {{jsxref("String.prototype.toLowerCase()", "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()

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

+ + + + + + + + + + + + + +
Especificação
{{SpecName('ESDraft', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}
{{SpecName('ES Int Draft', '#sup-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}
+ +

Compatibilidade de navegador

+ + + +

{{Compat("javascript.builtins.String.toLocaleLowerCase")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html new file mode 100644 index 0000000000..ff3f99e8e3 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html @@ -0,0 +1,95 @@ +--- +title: String.prototype.toLocaleUpperCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase +tags: + - Internacionalização + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - toLocaleUpperCase() +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase +--- +
{{JSRef}}
+ +

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.

+ +
{{EmbedInteractiveExample("pages/js/string-tolocaleuppercase.html")}}
+ + + +

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 {{jsxref("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

+ + + +

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 {{jsxref("String.prototype.toUpperCase()", "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()

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

+ + + + + + + + + + + + + +
Especificação
{{SpecName('ESDraft', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}
{{SpecName('ES Int Draft', '#sup-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}
+ +

Compatibilidade de navegador

+ + + +

{{Compat("javascript.builtins.String.toLocaleUpperCase")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tolowercase/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tolowercase/index.html new file mode 100644 index 0000000000..8883ff88fd --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/tolowercase/index.html @@ -0,0 +1,126 @@ +--- +title: String.prototype.toLowerCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - toLowerCase() +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +--- +
{{JSRef}}
+ +

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

+ +
console.log('ALFABETO'.toLowerCase()); // 'alfabeto'
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoEstadoComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição inicial. Implementada no JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.5.4.16', 'String.prototype.toLowerCase')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}{{Spec2('ESDraft')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
RecursoChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
RecursoAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tosource/index.html new file mode 100644 index 0000000000..a7f2bce0d5 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/tosource/index.html @@ -0,0 +1,102 @@ +--- +title: String.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/String/toSource +tags: + - JavaScript + - Non-standard + - Obsoleto + - Prototipo + - String + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/String/toSource +--- +
{{JSRef}} {{obsolete_header}}
+ +

O método toSource() retorna uma string que representa o código-fonte do objeto.

+ +

Sintaxe

+ +
String.toSource()
+str.toSource()
+
+ +

Valor retornado

+ +

Uma string que representa o código-fonte do objeto chamado.

+ +

Exemplos

+ +

Função nativa

+ +

Para o objeto {{jsxref("String")}} , toSource() retorna  a seguinte string (indicando que o código-fonte não está disponível):

+ +
function String() {
+    [native code]
+}
+
+ +

Ao chamar {{jsxref("String")}} ou string literais, toSource() retorna a string que representa o código-fonte.

+ +

Esse método é usualmente invocado internamente pelo JavaScript e não explicitamente no código.

+ +

Especificação

+ +

Não é parte de nenhum padrão.

+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatUnknown}}{{CompatVersionUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatUnknown}}{{CompatUnknown}}{{CompatVersionUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tostring/index.html new file mode 100644 index 0000000000..5b3a3fa1ce --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/tostring/index.html @@ -0,0 +1,125 @@ +--- +title: String.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/String/toString +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - toString() +translation_of: Web/JavaScript/Reference/Global_Objects/String/toString +--- +
{{JSRef}}
+ +

O método toString() retorna uma string representando o objeto especificado.

+ +

Sintaxe

+ +
str.toString()
+ +

Descrição

+ +

O objeto {{jsxref("String")}} substitui o método toString() do objeto {{jsxref("Object")}}. Ele não herda {{jsxref("Object.prototype.toString()")}}. Para objetos {{jsxref("String")}}, o método toString() retorna uma representação de string do objeto e é o mesmo que o método {{jsxref("String.prototype.valueOf()")}}.

+ +

Exemplos

+ +

Usando toString()

+ +

O exemplo a seguir exibe o valor string de um objeto {{jsxref("String")}}:

+ +
var x = new String('Hello world');
+
+console.log(x.toString()); // retorna 'Hello world'
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoEstadoComentário
{{SpecName('ES3')}}{{Spec2('ES3')}}Definição inicial. Implementado no JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.5.4.2', 'String.prototype.toString')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.tostring', 'String.prototype.toString')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-string.prototype.tostring', 'String.prototype.toString')}}{{Spec2('ESDraft')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FuncionalidadeChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FuncionalidadeAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/touppercase/index.html b/files/pt-br/web/javascript/reference/global_objects/string/touppercase/index.html new file mode 100644 index 0000000000..3a593fc9b8 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/touppercase/index.html @@ -0,0 +1,135 @@ +--- +title: String.prototype.toUpperCase() +slug: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +tags: + - Caixa alta + - JavaScript + - Letras maúsculas + - Método(2) + - Protótipo(2) + - Referência(2) + - String + - toUpperCase() +translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +--- +
{{JSRef}}
+ +

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

+ +
+
{{jsxref("TypeError")}}
+
Quando chamado em uma string contendo valor {{jsxref("null")}} ou {{jsxref("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

+ +
console.log('alfabeto'.toUpperCase()); // 'ALFABETO'
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição inicial. Implementado no JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.5.4.18', 'String.prototype.toUpperCase')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}{{Spec2('ESDraft')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/trim/index.html b/files/pt-br/web/javascript/reference/global_objects/string/trim/index.html new file mode 100644 index 0000000000..285cd76427 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/trim/index.html @@ -0,0 +1,137 @@ +--- +title: String.prototype.trim() +slug: Web/JavaScript/Reference/Global_Objects/String/Trim +tags: + - ECMAScript5 + - Prototipo + - Referencia + - Remover espaços + - String + - Texto + - metodo + - trim() +translation_of: Web/JavaScript/Reference/Global_Objects/String/Trim +--- +
{{JSRef}}
+ +
O método trim() remove os espaços em branco (whitespaces) do início e/ou fim de um texto. É considerado espaço em branco (espaço, tabulação, espaço fixo/rígido, etc.) e todo sinal de fim de linha de texto (LF, CR, etc.).
+ +
+ +

Sintaxe

+ +
str.trim()
+ +

Descrição

+ +

O método trim() retorna o texto sem espaços em branco no início e/ou fim da string. O trim() não altera o valor da string original.

+ +

Exemplos

+ +

Usando trim()

+ +

Os exemplos a seguir retornam o valor de 'foo' sem espaços em branco:

+ +
//.trim() removendo whitespace de ambos os lados
+
+var str = '   foo  ';
+console.log(str.trim()); // retorna 'foo'
+
+// Outro exemplo de .trim() removendo whitespace de
+// apenas um lado.
+
+var str= 'foo    ';
+console.log(str.trim()); // retorna 'foo'
+
+ +

Polyfill

+ +

Executar o seguinte código antes antes de qualquer código irá criar o método trim() se o mesmo não estiver disponível nativamente.

+ +
if (!String.prototype.trim) {
+  String.prototype.trim = function () {
+    return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
+  };
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES5.1', '#sec-15.5.4.20', 'String.prototype.trim')}}{{Spec2('ES5.1')}}Definição inicial. Implementado no JavaScript 1.8.1.
{{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}}{{Spec2('ES6')}}
+ + + +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatVersionUnknown}}{{CompatGeckoDesktop("1.9.1")}}{{CompatIE("9")}}{{CompatOpera("10.5")}}{{CompatSafari("5")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/trimend/index.html b/files/pt-br/web/javascript/reference/global_objects/string/trimend/index.html new file mode 100644 index 0000000000..556e62d8c3 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/trimend/index.html @@ -0,0 +1,82 @@ +--- +title: String.prototype.trimEnd() +slug: Web/JavaScript/Reference/Global_Objects/String/trimEnd +tags: + - JavaScript + - Prototipo + - Referencia + - Remover espaços ao final da string + - String + - metodo + - trimEnd() +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimEnd +--- +
{{JSRef}}
+ +

O método trimEnd() remove espaços do final de uma string. trimRight() é um apelido para este método.

+ +
{{EmbedInteractiveExample("pages/js/string-trimend.html")}}
+ + + +

Sintaxe

+ +
str.trimEnd();
+str.trimRight();
+ +

Valor retornado

+ +

Uma nova string representando a string original sem espaços ao seu final (direita).

+ +

Descrição

+ +

Os métodos trimEnd() / trimRight() retornam a string sem os espaços à direita dela. trimEnd() ou trimRight() não altera o valor da string original.

+ +

Aliasing

+ +

Para consistência com funções como {{jsxref("String.prototype.padEnd")}} o nome padrão do método é trimEnd. Entretanto, por razões de compatibilidade na web, trimRight permanece como um apelido para trimEnd. Em alguns motores isso significa:

+ +
String.prototype.trimRight.name === "trimEnd";
+ +

Exemplos

+ +

Usando trimEnd()

+ +

O exemplo a seguir mostra a string em caixa baixa '   foo':

+ +
var str = '   foo  ';
+
+console.log(str.length); // retorna 8
+
+str = str.trimEnd();
+console.log(str.length); // retorna 6
+console.log(str);        // retorna '   foo'
+
+ +

Especificações

+ + + + + + + + + + + + +
Especificação
{{SpecName('ESDraft', '#sec-string.prototype.trimend', 'String.prototype.trimEnd')}}
+ + + + + +

{{Compat("javascript.builtins.String.trimEnd")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/trimstart/index.html b/files/pt-br/web/javascript/reference/global_objects/string/trimstart/index.html new file mode 100644 index 0000000000..c784bc670a --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/trimstart/index.html @@ -0,0 +1,118 @@ +--- +title: String.prototype.trimStart() +slug: Web/JavaScript/Reference/Global_Objects/String/trimStart +tags: + - JavaScript + - Prototipo + - Referencia + - Remover espaços ao começo string + - String + - metodo + - trimStart() +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimStart +--- +
{{JSRef}}
+ +

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

+ +
{{EmbedInteractiveExample("pages/js/string-trimstart.html")}}
+ + + +

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 {{jsxref("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:

+ +
String.prototype.trimLeft.name === "trimStart";
+ +

Polyfill

+ +
//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  ':

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

+ + + + + + + + + + + + +
Especificação
{{SpecName('ESDraft', '#sec-string.prototype.trimstart', ' String.prototype.trimStart')}}
+ + + + + +

{{Compat("javascript.builtins.String.trimStart")}}

+ +

Veja também

+ + diff --git a/files/pt-br/web/javascript/reference/global_objects/string/valueof/index.html b/files/pt-br/web/javascript/reference/global_objects/string/valueof/index.html new file mode 100644 index 0000000000..306a079a95 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/string/valueof/index.html @@ -0,0 +1,84 @@ +--- +title: String.prototype.valueOf() +slug: Web/JavaScript/Reference/Global_Objects/String/valueOf +tags: + - JavaScript + - Prototipo + - Referencia + - String + - metodo + - valueOf() +translation_of: Web/JavaScript/Reference/Global_Objects/String/valueOf +--- +
{{JSRef}}
+ +

O método valueOf() retorna o valor primitivo de um objeto {{jsxref("String")}}.

+ +
{{EmbedInteractiveExample("pages/js/string-valueof.html")}}
+ +

Sintaxe

+ +
str.valueOf()
+ +

Valor retornado

+ +

Uma string representando o valor primitivo de um objeto {{jsxref("String")}}.

+ +

Descrição

+ +

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

+ +

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

+ +

Exemplos

+ +

Usando valueOf()

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

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoStatusComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição inicial implementada no JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.5.4.3', 'String.prototype.valueOf')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-string.prototype.valueof', 'String.prototype.valueOf')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-string.prototype.valueof', 'String.prototype.valueOf')}}{{Spec2('ESDraft')}}
+ + + + + +

{{Compat("javascript.builtins.String.valueOf")}}

+ +

Veja também

+ + -- cgit v1.2.3-54-g00ecf