diff options
Diffstat (limited to 'files/pt-br/web/javascript/reference/global_objects/string')
53 files changed, 7553 insertions, 0 deletions
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 +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>[@@iterator]()</code></strong> retorna um novo objeto <code>Iterator</code> que itera sobre os pontos de código do valor da String, retornando cada ponto de código como um valor String.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>[Symbol.iterator]</code></pre> + +<h3 id="Valor_de_Retorno">Valor de Retorno</h3> + +<p>Novo objeto <code>Iterator</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_iterator">Usando <code>[@@iterator]()</code></h3> + +<pre class="brush:js notranslate">var str = 'A\uD835\uDC68'; + +var strIter = str[Symbol.iterator](); + +console.log(strIter.next().value); // "A" +console.log(strIter.next().value); // "\uD835\uDC68" +</pre> + +<h3 id="Usando_iterator_com_for..of">Usando <code>[@@iterator]()</code> com <code>for..of</code></h3> + +<pre class="brush:js notranslate">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" +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col"></th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.@@iterator")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a></li> +</ul> 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 +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<div>O método <strong><code>anchor()</code></strong> cria uma string começando com uma tag inicial <code><a name="..."></code>, um texto e uma tag final <code></a></code>.</div> + +<div class="blockIndicator warning"> +<p>Não use este método. Ao invés, use <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model">DOM APIs</a>. Além disso, a especificação HTML não permite mais que o elemento <a> tenha um atributo <strong>"name"</strong>, portanto, esse método nem mesmo cria uma tag válida.</p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.anchor(<var>name</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>name</code></dt> + <dd>Uma string que deve representar o valor do atributo <em><code>name</code>.</em></dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string começando com uma tag de início <em><code><a name="name"></code></em>, depois o valor da string e, em seguida, uma tag de fim <em><code></a></code></em>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Não use este método. Ao invés, use <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model">DOM APIs</a>. Além disso, a especificação HTML não permite mais que o elemento <em><code><a></code></em> tenha um atributo <strong>"name"</strong>, portanto, esse método nem mesmo cria uma tag válida.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_anchor">Usando <code>anchor()</code></h3> + +<pre class="brush: js notranslate">const nome = 'Ricardo'; +console.log(nome.anchor('https://developer.mozilla.org/pt-BR/)'); +</pre> + +<p>irá retornar o seguinte código HTML:</p> + +<pre class="brush: html notranslate">'<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body"><span class="objectBox objectBox-string"><a name="<a class="url" href="https://developer.mozilla.org/pt-BR/" rel="noopener noreferrer" title="https://developer.mozilla.org/pt-BR/">https://developer.mozilla.org/pt-BR/</a>">Ricardo</a></span></span></span></span>' +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.anchor', 'String.prototype.anchor')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.anchor")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.link()")}}</li> +</ul> 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 +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <strong>big()</strong> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/big" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/big"><big></a> fazendo com que o texto dentro dele seja exibido uma uma fonte maior.</p> + +<div class="note"> +<p><strong>Nota de uso:</strong> O elemento <big> foi removido no <a href="/en-US/docs/Web/Guide/HTML/HTML5">HTML5</a> e não deve mais ser usado. Em vez disso, web developers devem usar a <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/font-size" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/font-size">propriedade CSS correspondente</a>.</p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.big()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>big()</code> cria uma string dentro de uma tag <code><big></code>:<br> + <code>"<big>str</big>"</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_big">Usando <code>big()</code></h3> + +<p>Os exemplos abaixo usam métodos do objeto <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings" title="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings">String </a>para alterar o tamanho de uma string:</p> + +<pre class="brush: js notranslate">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> +</pre> + +<p>Com o objeto <code>element.style</code> você pode selecionar o atributo <code>style</code> do elemento e manipulá-lo de forma mais genérica, por exemplo:</p> + +<pre class="brush: js notranslate">document.getElementById('#oIdDoElemento').style.fontSize = '2em'; +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.big', 'String.prototype.big')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.big")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> + <li>{{jsxref("String.prototype.small()")}}</li> +</ul> 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 +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code><strong>blink()</strong></code> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/blink" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/blink"><blink></a> que faz uma string piscar.</p> + +<div class="warning"> +<p><strong>Aviso:</strong> A criação de textos que piscam é desaprovada por vários padrões de acessibilidade. O próprio elemento <code><blink></code> não é padrão e está obsoleto!</p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.blink()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/blink" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/blink"><blink></a>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>blink()</code> cria uma string dentro de uma tag <code><blink></code>:<br> + <code>"<blink>str</blink>"</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_blink">Usando <code>blink()</code></h3> + +<p>Os exemplos abaixo usam métodos do objeto <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings" title="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings">String </a>para alterar a formatação de uma string:</p> + +<pre class="brush: js notranslate">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></pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.blink', 'String.prototype.blink')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.blink")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> 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 +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code><strong>bold()</strong></code> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/b" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/b"><b></a> que faz com que uma string seja exibida em negrito.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.bold()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/b" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/b"><b></a> .</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>bold()</code> cria uma string dentro de uma tag <code><b></code>:<br> + <code>"<b>str</b>"</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_bold">Usando <code>bold()</code></h3> + +<p>Os exemplos abaixo usam métodos do objeto <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings" title="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings">String </a>para alterar a formatação de uma string:</p> + +<pre class="brush: js notranslate">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></pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.bold', 'String.prototype.bold')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.bold")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>charAt()</code></strong> retorna o caractere especificado a partir de uma string.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.charAt(<var>index</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>index</code></dt> + <dd>Um inteiro entre <code>0</code> e <code>str.length - 1</code>. Se nenhum índice for definido, <code>charAt()</code> usará <code>0</code> como índice.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string representando o caractere no índice especificado. Uma string vazia se o <strong><code>index</code> </strong>fornecido estiver fora do intervalo de índices da string <code>str</code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é <code>0</code><strong> </strong>(zero), e o índice do último caractere em uma string declarada como <code>stringName</code> é <code>stringName.length - 1</code>. Se o índice que você fornecer estiver fora do intervalo de índices da string, JavaScript retornará uma string vazia.</p> + +<p>Se nenhum índice for passado para <code>charAt()</code>, <code>0</code> será usado por padrão.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Mostrando_caracteres_em_diferente_localizações_em_uma_string">Mostrando caracteres em diferente localizações em uma string</h3> + +<p>O exemplo a seguir mostra caracteres em diferentes locais em uma string <code>"Brave new world"</code>:</p> + +<pre class="brush: js notranslate">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) + "'"); +</pre> + +<p>As linhas acima retornam o seguinte:</p> + +<pre class="brush: js notranslate">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 é '' +</pre> + +<h3 id="Obtendo_caracteres_inteiros">Obtendo caracteres inteiros</h3> + +<p>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 <a href="https://pt.wikipedia.org/wiki/Plano_(Unicode)" title="https://pt.wikipedia.org/wiki/Plano_(Unicode)">Plano Multilíngue Básico</a>.</p> + +<pre class="brush: js notranslate">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; +} +</pre> + +<p>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).</p> + +<pre class="brush: js notranslate">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]; +} +</pre> + +<h3 id="Corrigindo_charAt_para_suportar_caracteres_não-Plano-Multilíngüe-Básico_PMB">Corrigindo <code>charAt()</code> para suportar caracteres não-Plano-Multilíngüe-Básico (PMB)</h3> + +<p>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:</p> + +<pre class="brush: js notranslate">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; +} +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li><a href="https://mathiasbynens.be/notes/javascript-unicode">JavaScript has a Unicode problem – Mathias Bynens</a></li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>charCodeAt()</code></strong> retorna um número inteiro entre <code>0</code> e <code>65535</code> 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 <strong><code>codePointAt</code></strong>().</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.charCodeAt(<em>index</em>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>index</code></dt> + <dd>Um inteiro maior ou igual a <code>0</code> e menor que o comprimento da string. Se não for um número, o padrão será <code>0</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>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.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Os pontos de código Unicode variam de <code>0</code> a <code>1114111</code> (<code>0x10FFFF</code>). 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 <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Values,_variables,_and_literals" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Values,_variables,_and_literals">JavaScript Guide</a>.)</p> + +<div class="blockIndicator note"> +<p><strong>Nota</strong>: o <code>charCodeAt()</code> sempre retornará um valor menor do que <code>65536</code>. 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.<br> + <br> + Por isso, para examinar (ou reproduzir) o caractere completo para valores de caracteres individuais de valor <code>65536</code> e acima, é necessário recuperar não apenas o <code>charCodeAt(<em>i</em>)</code>, mas também o <code>charCodeAt(<em>i</em>+1)</code> (como se examinando/reproduzindo a string com duas letras), ou usar o <code>codePointAt(<em>i</em>)</code>. Veja o exemplo 2 e 3 (abaixo).</p> +</div> + +<p>Compatibilidade com versões anteriores: Em versões históricas (como JavaScript 1.2) o método <code>charCodeAt()</code> 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 <code>0</code> a <code>255</code>. Os primeiros <code>128</code> (do <code>0</code> ao <code>127</code>) são uma correspondência direta ao conjunto de caracteres ASCII.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_charCodeAt">Usando <code>charCodeAt()</code></h3> + +<p>O exemplo a seguir retorna <code>65</code>, o valor Unicode para A.</p> + +<pre class="brush: js notranslate">'ABC'.charCodeAt(0); // retorna 65 +</pre> + +<h3 id="Corrigindo_o_charCodeAt_para_manipular_caracteres_de_Plano_Multilingual_não_Básico_se_sua_presença_na_string_é_desconhecida">Corrigindo o <code>charCodeAt()</code> para manipular caracteres de Plano Multilingual não Básico se sua presença na string é desconhecida</h3> + +<p>Essa versão pode ser usada em loops <strong>for </strong>e afins quando não sabemos se caracteres de Plano Multilingual não Básico existem antes da posição do índice especificado.</p> + +<pre class="brush: js notranslate">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; +} +</pre> + +<h3 id="Corrigindo_o_charCodeAt_para_manipular_caracteres_de_Plano_Multilingual_não_Básico_se_sua_presença_na_string_é_desconhecida_2">Corrigindo o <code>charCodeAt()</code> para manipular caracteres de Plano Multilingual não Básico se sua presença na string é desconhecida</h3> + +<pre class="brush: js notranslate">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; +} +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.5', 'String.prototype.charCodeAt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte Básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte Básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="sect1"></h2> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.fromCharCode()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code><strong>codePointAt()</strong></code> retorna um número inteiro não negativo que é o valor do ponto de código Unicode.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-codepointat.html","shorter")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.codePointAt(<var>pos</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code><var>pos</var></code></dt> + <dd>A posição de um elemento em uma string a partir do qual retorna o valor do ponto de código.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um número que representa o valor do ponto de código do caractere na <code>pos</code> fornecida. Se não houver nenhum elemento na <code>pos</code>, {{jsxref ("undefined")}} é retornado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>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 <code>pos</code>, a unidade de código na <code>pos</code> será retornada.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>O seguinte código cria no objeto global String a função <code>codePointAt()</code> conforme especificado em ECMAScript 2015 para navegadores sem suporte nativo:</p> + +<pre class="brush: js notranslate">/*! 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; + } + }()); +} +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_codePointAt">Usando <code>codePointAt()</code></h3> + +<pre class="brush: js notranslate">'ABC'.codePointAt(1) // retorna 66 +'\uD800\uDC00'.codePointAt(0) // retorna 65536 + +'XYZ'.codePointAt(42) // retorna undefined +</pre> + +<h3 id="Criando_um_loop_com_codePointAt">Criando um loop com <code>codePointAt()</code></h3> + +<pre class="brush: js notranslate"><code class="md-code md-lang-javascript"><span class="md-code-keyword">for</span> (<span class="md-code-keyword">let</span> codePoint of <span class="md-code-string">'\ud83d\udc0e\ud83d\udc71\u2764'</span>) { + <span class="md-code-built_in">console</span>.log(codePoint<mark class="md-mark md-code-mark">.codePointAt(<span class="md-code-number">0</span>).toString(<span class="md-code-number">16</span>)</mark>) +} +// <span class="md-code-comment">retorna '1f40e', '1f471', '2764</span></code>'<code class="md-code md-lang-javascript"><span class="md-code-comment"> </span></code> +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.codepointat', 'String.prototype.codePointAt')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.codePointAt")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.fromCharCode()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>concat()</code></strong> combina o texto de duas ou mais strings e retorna uma nova string.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.concat(<var>string2 </var>[, ...<var>stringN</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>string2...string<em>N</em></code></dt> + <dd>Strings para concatenar à <strong><code>string2</code></strong>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova string contendo a string original concatenada à string passada como parâmetro.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>A função <strong><code>concat()</code></strong> 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.</p> + +<p>Se o argumento passado não for do tipo string, o mesmo será convertido em uma string antes de ser concatenado.</p> + +<h2 id="Performance">Performance</h2> + +<p>É extremamente recomendado o uso dos <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Expressions_and_Operators" title="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Expressions_and_Operators">operadores de atribuição</a> (<code>+</code>, <code>+=</code>) em detrimento do método <code>concat()</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_concat">Usando <code>concat()</code></h3> + +<p>O exemplo a seguir concatena uma string à outra string originando uma terceira string.</p> + +<pre class="brush: js notranslate">var hello = 'Olá, '; +console.log(hello.concat('Kevin', ' tenha um bom dia.')); + +// retorna 'Olá, Kevin tenha um bom dia.' +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentários</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.6', 'String.prototype.concat')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.concat', 'String.prototype.concat')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.concat()")}}</li> + <li>{{jsxref("Operators/Assignment_Operators", "Assignment operators", "", 1)}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<div></div> + +<p>O método <strong><code>endsWith()</code></strong> indica se uma string termina com determinados caracteres, retornando <code>true</code> ou <code>false</code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.endsWith(s<var>tringSendoBuscada</var>[, <var>tamanho</var>])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>stringSendoBuscada</code></dt> + <dd>Os caracteres a serem pesquisados no final da string.</dd> + <dt><code>tamanho</code></dt> + <dd>Opcional. Se fornecido, substitui o tamanho da string passada. Se omitido, o valor padrão é o tamanho da string.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p><strong><code>true</code></strong> se os caracteres passados forem encontrados no final da string. Do contrário, retorna <strong><code>false</code></strong>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Este método permite que você verifique se uma string termina ou não com determinados caracteres. Este método é case-sensitive.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_endsWith">Usando <code>endsWith()</code></h3> + +<pre class="brush: js notranslate">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 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>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:</p> + +<pre class="brush: js notranslate">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; + }; +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.endsWith")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.startsWith()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> +</ul> 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 +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <strong><code>fixed()</code></strong> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/tt" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/tt"><tt></a></code> que faz com que uma string seja exibida em uma fonte de densidade fixa.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.fixed()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string que representa o elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/tt" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/tt"><tt></a>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método<strong> </strong><code>fixed()</code> cria uma string dentro de uma tag <code><tt></code>:<br> + <code>"<tt>str</tt>"</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_fixed">Usando <code>fixed()</code></h3> + +<p>O exemplo a seguir usa o método <code>fixed()</code> para alterar a formatação de uma string:</p> + +<pre class="brush: js notranslate">var worldString = 'Olá, mundo'; +console.log(worldString.fixed()); // "<tt>Olá, mundo</tt>" +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.fixed', 'String.prototype.fixed')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.fixed")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> 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 +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>fontcolor()</code> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font"><font></a> que faz com que uma string seja exibida na cor especificada.</p> + +<div class="note"> +<p><strong>Nota de uso:</strong> O elemento <code><font></code> foi removido do <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/HTML5" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/HTML5">HTML5</a> e não deve mais ser usado. Em vez disso, web developers devem usar a <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/color_value" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/color_value">propriedade CSS correspondente</a>.</p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.fontcolor(<var>color</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>color</code></dt> + <dd>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 <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/color_value#Palavras-chave_de_cores" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/color_value#Palavras-chave_de_cores">cores CSS</a>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font"><font></a>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Se você expressar uma cor em formato hexadecimal, deve usar o formato <code>rrggbb</code>. 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".</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_fontcolor">Usando <code>fontcolor()</code></h3> + +<p>O exemplo a seguir usa o método <code>fontcolor()</code> para alterar a cor de uma string, produzindo uma string com a tag HTML <code><font></code>.</p> + +<pre class="brush: js notranslate">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' +</pre> + +<p>Com o objeto <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style">element.style</a></code> você pode obter o atributo <code>style</code> do elemento e manipulá-lo de forma mais genérica, por exemplo:</p> + +<pre class="brush: js notranslate">document.getElementById('#oIdDoElemento').style.color = 'red'; +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.fontcolor', 'String.prototype.fontcolor')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.fontcolor")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> +</ul> 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 +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>fontsize()</code> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font"><font></a> que faz com que uma string seja exibida no tamanho da fonte especificada.</p> + +<div class="note"> +<p><strong>Nota de uso:</strong> O elemento <code><font></code> foi removido do <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/HTML5" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/HTML5">HTML5</a> e não deve mais ser usado. Em vez disso, web developers devem usar a <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/font-size" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/font-size">propriedade CSS correspondente</a>.</p> +</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.fontsize(<var>size</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>size</code></dt> + <dd>Um número inteiro entre 1 e 7.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font"><font></a>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Ao especificar o tamanho como um inteiro, você define o tamanho da fonte do texto para um dos 7 tamanhos definidos. Ao especificar <code>size</code> como uma string como "-2", você ajusta o tamanho da fonte do texto em relação ao tamanho definido na tag <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/basefont" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/basefont"><basefont></a>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_fontsize">Usando <code>fontsize()</code></h3> + +<p>O exemplo a seguir usa métodos do objeto global String para alterar o tamanho de uma string:</p> + +<pre class="brush: js notranslate">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> +</pre> + +<p>Com o objeto <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style">element.style</a></code> você pode obter o atributo <code>style</code> do elemento e manipulá-lo de forma mais genérica, por exemplo:</p> + +<pre class="brush: js notranslate">document.getElementById('#oIdDoElemento').style.fontSize = '0.7em'; +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.fontsize', 'String.prototype.fontsize')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.fontsize")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.big()")}}</li> + <li>{{jsxref("String.prototype.small()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>String.fromCharCode()</code></strong> retorna uma string criada ao usar uma sequência específica de valores Unicode.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code>String.fromCharCode(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>num1, ..., num<em>N</em></code></dt> + <dd>Uma sequência de números que devem ser valores UTF-16. O tamanho é entre <code>0</code> e <code>65535</code> (<code>0xFFFF</code>). Números maiores do que <code>0xFFFF</code> são desconsiderados. Nenhuma verificação de vadalida é realizada.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo os caracteres correspondentes à sequência de valores Unicode.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Esse método retorna uma string e não um objeto {{jsxref("String")}}.</p> + +<p>Como <code>fromCharCode() </code>é um método estático de {{jsxref("String")}}, você sempre o usará como <code>String.fromCharCode()</code>, ao invés de um método de um objeto {{jsxref("String")}} que você tenha criado.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_fromCharCode">Usando <code>fromCharCode()</code></h3> + +<p>O seguinte exemplo retorna a string "ABC".</p> + +<pre class="brush: js notranslate">String.fromCharCode(65, 66, 67); // retorna "ABC" +</pre> + +<h2 id="Fazendo-o_funcionar_com_valores_maiores">Fazendo-o funcionar com valores maiores</h2> + +<p>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.</p> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.3.2', 'StringfromCharCode')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Características</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte Básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Características</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte Básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método estático <strong>String.fromCodePoint()</strong> retorna uma seqüência de caracteres criado usando a seqüência especificada de pontos de código.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox notranslate"><code>String.fromCodePoint(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>num1, ..., num<em>N</em></code></dt> + <dd>Uma sequência de pontos de código.</dd> +</dl> + +<h3 id="Exceções">Exceções</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd> + <p>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").</p> + </dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Como o fromCodePoint() é um método estático do {{jsxref("String")}}, você sempre vai chamar esse método como <strong>String.fromCodePoint()✔</strong> em vez de usá-lo como um método de uma string que você criar, como <strong>"minha string".fromCodePoint()❌</strong>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_fromCodePoint">Usando <code>fromCodePoint()</code></h3> + +<pre class="brush: js notranslate">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 +</pre> + +<pre class="brush: js notranslate">// 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 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>O método <strong>String.fromCodePoint</strong> 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. <span class="notranslate"> Use o código abaixo para um polyfill:</span></p> + +<pre class="brush: js notranslate">/*! 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; + } + }()); +} +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.fromcodepoint', 'String.fromCodePoint')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td> + <p>{{CompatChrome("41")}}</p> + </td> + <td>{{CompatGeckoDesktop("29")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("28")}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("29")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.fromCharCode()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <strong>includes()</strong> determina se um conjunto de caracteres pode ser encontrado dentro de outra string, retornando <code>true</code> ou <code>false</code>.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.includes(<var>searchString</var>[, <var>position</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>searchString</code></dt> + <dd>É o conjunto de caracteres que será pesquisado dentro desta string.</dd> + <dt><code>position</code></dt> + <dd>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.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p><code>true</code> se o conjunto de caracteres for encontrado em algum lugar dentro da string sendo pesquisada. Do contrário, retorna <code>false</code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Este método permite conferir se uma string contém um determinado conjunto de caracteres.</p> + +<h3 id="Case-sensitivity">Case-sensitivity</h3> + +<p>O método <code>includes()</code> é case sensitive. Por exemplo, a seguinte expressão retorna <code>false</code>:</p> + +<pre class="brush: js notranslate">'Bandeira do Brasil'.includes('brasil'); // retorna false +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Utilizando_includes">Utilizando <code>includes()</code></h3> + +<pre class="brush: js notranslate">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 +</pre> + +<h2 id="Implementação">Implementação</h2> + +<p>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:</p> + +<pre class="brush: js notranslate">if (!String.prototype.includes) { + String.prototype.includes = function() {'use strict'; + return String.prototype.indexOf.apply(this, arguments) !== -1; + }; +} + +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.includes', 'String.prototype.includes')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{Compat("javascript.builtins.String.includes")}}</div> + +<h2 id="String.prototype.contains">String.prototype.contains</h2> + +<p>No Firefox 18 - 39, o nome deste método era <code>contains()</code>. Ele foi renomeado para <code>includes()</code> no {{bug(1102219)}} devido ao seguinte motivo:</p> + +<p>Foi <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=789036">reportado</a> que alguns websites que utilizam MooTools 1.2 não funcionavam no Firefox 17. Esta versão do MooTools verifica se <code>String.prototype.contains()</code> 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 <code>String.prototype.contains()</code> do MooTools parassem de funcionar. Como resultado, esta mudança foi <a href="https://hg.mozilla.org/releases/mozilla-aurora/rev/086db97198a8">desabilitada</a> no Firefox 17 e <code>String.prototype.contains()</code> foi disponibilizada na versão seguinte, no Firefox 18.</p> + +<p>MooTools 1.3 força sua própria versão do <code>String.prototype.contains()</code>, portanto websites baseados nela não devem parar de funcionar. No entanto, você deve notar que <a href="http://mootools.net/core/docs/1.3.2/Types/String#String-method:-contains">a assinatura do MooTools 1.3</a> e a assinatura ECMAScript 6 diferem (no segundo argumento). Posteriormente, <a href="https://github.com/mootools/mootools-core/blob/master/Docs/Types/String.md#note">MooTools 1.5+ mudou sua assinatura para o padrão ES6.</a></p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array.prototype.includes()")}} {{experimental_inline}}</li> + <li>{{jsxref("TypedArray.prototype.includes()")}} {{experimental_inline}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.startsWith()")}} {{experimental_inline}}</li> + <li>{{jsxref("String.prototype.endsWith()")}} {{experimental_inline}}</li> +</ul> 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 +--- +<p>{{JSRef("Global_Objects", "String")}}</p> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>O objeto global <strong><code>String</code></strong> é um construtor para <strong>strings,</strong> ou uma sequência de caracteres.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<p>As formas literais de declaração de <em>String</em> são:</p> + +<pre class="syntaxbox">'string text' +"string text" +"中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어"</pre> + +<p>Além da forma regular, de caracteres<em> </em>de impressão, caracteres especiais podem ser codificados usando a <em>escape notation </em>(notação com barra invertida):</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Codigo</th> + <th scope="col">Saida</th> + </tr> + </thead> + <tbody> + <tr> + <td>\0</td> + <td>o caractere NULL</td> + </tr> + <tr> + <td>\'</td> + <td>aspas simples</td> + </tr> + <tr> + <td>\"</td> + <td>aspas duplas</td> + </tr> + <tr> + <td>\\</td> + <td>barra invertida</td> + </tr> + <tr> + <td>\n</td> + <td>nova linha</td> + </tr> + <tr> + <td>\r</td> + <td>carriage return</td> + </tr> + <tr> + <td>\v</td> + <td>tab vertical</td> + </tr> + <tr> + <td>\t</td> + <td>tab</td> + </tr> + <tr> + <td>\b</td> + <td>backspace</td> + </tr> + <tr> + <td>\f</td> + <td>form feed</td> + </tr> + <tr> + <td>\uXXXX</td> + <td>unicode codepoint</td> + </tr> + <tr> + <td>\xXX</td> + <td>the Latin-1 character</td> + </tr> + </tbody> +</table> + +<p>Ou, usando o objeto global <code>String</code> diretamente:</p> + +<pre class="syntaxbox">String(thing) +new String(thing)</pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>thing</code></dt> + <dd>Qualquer coisa a ser convertida para uma string.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Strings são úteis para guardar dados que podem ser representados em forma de texto. Uma das operações mais usadas nas <strong>strings</strong> é checar seu {{jsxref("String.length", "tamanho")}}, para construir e concatená-las usando <a href="/en-US/docs/Web/JavaScript/Reference/Operators/String_Operators">os operadores</a> <a href="/en-US/docs/Web/JavaScript/Reference/Operators/String_Operators">+ e +=, </a>checando pela existência ou posição de <em>substrings</em> com o método {{jsxref("String.indexOf", "indexOf")}} , ou extrair <em>substrings</em> com o método {{jsxref("String.substring", "substring")}}.</p> + +<h3 id="Character_access" name="Character_access">Acesso à caractere</h3> + +<p>Há duas maneiras de acessar um <span class="st">caractere </span>individual em uma string. A primeira é o método {{jsxref("String.charAt", "charAt")}}:</p> + +<pre class="brush: js">return 'cat'.charAt(1); // returns "a" +</pre> + +<p>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:</p> + +<pre class="brush: js">return 'cat'[1]; // returns "a" +</pre> + +<p>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.)</p> + +<h3 id="Comparing_strings" name="Comparing_strings">Comparando strings</h3> + +<p>Desenvolvedores de C têm a função strcmp() para comparar strings. No JavaScript, basta usar o operador <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">maior que e menor que</a>:</p> + +<pre class="brush: js">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."); +</pre> + +<p>Um resultado similar pode ser alcançado usando o método {{jsxref("String.localeCompare", "localeCompare")}} herdado pelas instâncias de <code>String</code>.</p> + +<h3 id="Distinção_entre_String_primitiva_e_objetos_String">Distinção entre String primitiva e objetos String</h3> + +<p>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")}}.)</p> + +<p>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 <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a>) 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.</p> + +<pre class="brush: js">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" +</pre> + +<p>String primitivas e objetos <code>String</code> também dão resultados diferentes quando usado {{jsxref("Global_Objects/eval", "eval")}}. Primitivas passadas para <code>eval</code> são tratadas como código fonte; Objetos <code>String</code> são tratados como todos os outros objetos são, retornando o objeto. Por exemplo:</p> + +<pre class="brush: js">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" +</pre> + +<p>Por estas razões, o código pode quebrar quando encontra objetos <code>String</code> quando espera na verdade uma string primitiva, apesar de que geralmente autores não precisam se preocupar com a distinção.</p> + +<p>Um objeto <code>String</code> pode ser convertido sempre para sua contraparte primitiva com o método {{jsxref("String.valueOf", "valueOf")}}.</p> + +<pre class="brush: js">console.log(eval(s2.valueOf())); // retorna o número 4 +</pre> + +<div class="note"><strong>Note:</strong> Para uma outra possível abordagem para strings em JavaScript, favor ler o artigo sobre <a href="/en-US/docs/Web/JavaScript/Typed_arrays/StringView" title="/en-US/docs/Web/JavaScript/Typed_arrays/StringView"><code>StringView</code> – a C-like representation of strings based on typed arrays</a>.</div> + +<h2 id="Properties" name="Properties">Propriedades</h2> + +<dl> + <dt>{{jsxref("String.prototype")}}</dt> + <dd>Permite a adição de propriedades a um objeto String.</dd> +</dl> + +<div>{{jsOverrides("Function", "Properties", "prototype")}}</div> + +<h2 id="Methods" name="Methods">Métodos</h2> + +<dl> + <dt>{{jsxref("String.fromCharCode()")}}</dt> + <dd>Retorna uma string criada usando a sequência especificada de valores Unicode.</dd> + <dt>{{jsxref("String.fromCodePoint()")}} {{experimental_inline}}</dt> + <dd>Retorna uma string criada usando a sequência especificada de posições de código.</dd> +</dl> + +<div>{{jsOverrides("Function", "Methods", "fromCharCode", "fromCodePoint")}}</div> + +<h2 id="Métodos_genéricos_de_Strings"><code>Métodos genéricos de Strings</code></h2> + +<p>Métodos de instância <code>String</code> 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:</p> + +<pre class="brush: js">var num = 15; +alert(String.replace(num, /5/, '2')); +</pre> + +<p class="brush: js"><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#Array_generic_methods">Genéricos</a> também estão disponíveis em métodos {{jsxref("Global_Objects/Array", "Array")}}.</p> + +<p class="brush: js">O seguinte é uma implementação para fornecer suporte a navegadores sem suporte:</p> + +<pre class="brush: js">/*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]); + } +}()); +</pre> + +<h2 id="Instâncias_de_String">Instâncias de <code>String</code></h2> + +<h3 id="Propriedades">Propriedades</h3> + +<p>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Propriedades')}}</p> + +<h3 id="Métodos">Métodos</h3> + +<h4 id="Métodos_não_relacionados_ao_HTML">Métodos não relacionados ao HTML</h4> + +<p>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Métodos_não_relacionados_ao_HTML')}}</p> + +<h4 id="Métodos_de_envoltório_HTML">Métodos de envoltório HTML</h4> + +<p>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Métodos_de_envoltório_HTML')}}</p> + +<h2 id="String_instances" name="String_instances">Exemplos</h2> + +<h3 id="Conversão_de_String">Conversão de String</h3> + +<p>É possível usar <code>String</code> como uma alternativa "mais segura" {{jsxref("String.toString", "toString")}}, como embora normalmente ainda chama o <code>toString</code> subjacente, também funciona para <code>null</code> e <code>undefined</code>. Por exemplo:</p> + +<pre class="brush: js">var outputStrings = []; +for (let i = 0, n = inputValues.length; i < n; ++i) { + outputStrings.push(String(inputValues[i])); +} +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Definições iniciais.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5', 'String')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string-objects', 'String')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>0.2</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/API/DOMString" title="/en-US/docs/Web/API/DOMString">DOMString</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays/StringView" title="/en-US/docs/Web/JavaScript/Typed_arrays/StringView"><code>StringView</code> – a C-like representation of strings based on typed arrays</a></li> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/API/DOMString/Binary">Binary strings</a></li> +</ul> 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 +--- +<p>{{JSRef("Global_Objects", "String")}}</p> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>O método <code>indexOf()</code> retorna o índice da primeira ocorrência do valor fornecido em searchValue, começando a busca a partir de <code>fromIndex</code>. Retorna <code>-1</code> se o valor não for encontrado.</p> + +<div class="blockIndicator note"> +<p><strong>Nota:</strong> Para o método de Array, veja {{jsxref("Array.prototype.indexOf()")}}.</p> +</div> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><em>str</em>.indexOf(<em>searchValue</em>[, <em>fromIndex</em>]</code>)</pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>searchValue</code></dt> + <dd>Uma string representando o valor a ser buscado. Se nenhuma string for fornecida explicitamente, <code>searchValue</code> terá o valor de <code>undefined</code>, e esse valor será buscado na string atual. Por exemplo, <code>'undefined'.indexOf()</code> retornará <code>0</code>, já que <code>undefined</code> é encontrado na posição <code>0</code>. Já <code>'undefine'.indexOf()</code> retornará <code>-1</code>, já que <code>undefined</code> não pôde ser encontrado.</dd> + <dt><code>fromIndex</code></dt> + <dd>Um número inteiro representando um índice da string original a partir da qual a busca deve começar. Por padrão é <code>0</code>. Se <code>fromIndex < 0</code>, a string toda é percorrida (equivale a passar 0). Se <code>fromIndex</code> <code>>=</code> <code>str.length</code>, o método retornará <code>-1</code>, já que a busca será iniciada após o final da string.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O índice da primeira ocorrência de <em>searchValue</em>, ou <code>-1</code> se não for encontrado.</p> + +<p>Uma string vazia no <em>searchValue</em> produz resultados estranhos. Sem <code>fromIndex</code>, ou com qualquer <code>fromIndex</code> menor que o comprimento da string, o valor retornado é o próprio <code>fromIndex</code>:</p> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js"><span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">)</span> <span class="comment token">// retorna 0</span> +<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">0</span><span class="punctuation token">)</span> <span class="comment token">// retorna 0</span> +<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">3</span><span class="punctuation token">)</span> <span class="comment token">// retorna 3</span> +<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">8</span><span class="punctuation token">)</span> <span class="comment token">// retorna 8</span></code></pre> + +<p>Entretanto, com qualquer <code>fromIndex</code> igual ou maior que o comprimento da string, o valor retornado é o comprimento da string:</p> + +<pre class="brush: js line-numbers language-js notranslate"><code class="language-js"><span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">11</span><span class="punctuation token">)</span> <span class="comment token">// retorna 10</span> +<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">13</span><span class="punctuation token">)</span> <span class="comment token">// retorna 10</span> +<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">22</span><span class="punctuation token">)</span> <span class="comment token">// retorna 10</span></code></pre> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é <code>0</code>, e o índice do último caractere de uma string chamada <code>stringName</code> é <code>stringName.length - 1</code>.</p> + +<pre class="brush: js notranslate">"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</pre> + +<h3 id="Verificando_ocorrências">Verificando ocorrências</h3> + +<p>Note que um retorno <code>0</code> não implica em <code>true</code>, e <code>-1</code> não implica em <code>false</code>. Portanto, a maneira correta de se verificar se uma string específica está contida em outra string seria:</p> + +<pre class="brush: js notranslate">"Blue Whale".indexOf("Blue") !== -1; // true +"Blue Whale".indexOf("Bloe") !== -1; // false</pre> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Using_indexOf_and_lastIndexOf" name="Example:_Using_indexOf_and_lastIndexOf">Usando <code>indexOf()</code></h3> + +<p>O exemplo a seguir usa <code>indexOf()</code> para localizar valores dentro da string "<code>Brave new world</code>".</p> + +<pre class="brush: js notranslate">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 +</pre> + +<h3 id="Example_indexOf_and_case-sensitivity" name="Example:_indexOf_and_case-sensitivity"><code>indexOf()</code> e sensibilidade a maiúsculas e minúsculas</h3> + +<p>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 <code>19</code>. Porém, como o método <code>indexOf</code> é sensível a letras maiúsculas e minúsculas, a string <code>"cheddar"</code> não é encontrada em <code>myCapString</code>, portanto, o segundo método {{domxref("console.log()")}} exibe <code>-1</code>.</p> + +<pre class="brush: js notranslate">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</pre> + +<h3 id="Example_Using_indexOf_to_count_occurrences_of_a_letter_in_a_string" name="Example:_Using_indexOf_to_count_occurrences_of_a_letter_in_a_string">Usando <code>indexOf()</code> para contar as ocorrências de uma letra numa string</h3> + +<p>O exemplo a seguir atribui à variável <code>count</code> o número de ocorrências da letra <code>x</code> na string <code>str</code>:</p> + +<pre class="brush: js notranslate">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);</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Situação</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.7', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p>{{Compat("javascript.builtins.String.indexOf")}}</p> + +<h2 id="See_also" name="See_also"></h2> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> +</ul> 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 +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>italics()</code> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/i" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/i"><i></a></code> que faz com que uma string fique em itálico.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.italics()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/i" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/i"><i></a></code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>italics()</code> cria uma string dentro de uma tag <code><i></code>:<br> + <code>"<i>str</i>"</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_italics">Usando <code>italics()</code></h3> + +<p>O exemplo a seguir usa métodos do objeto global String para alterar a formatação de uma string:</p> + +<pre class="brush: js notranslate">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> +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.italics', 'String.prototype.italics')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.italics")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code>lastIndexOf()</code> retorna o índice da última ocorrência do valor especificado encontrado na {{jsxref("String")}}. Quando <code>fromIndex</code> é especificado, a pesquisa é realizada de trás para frente. Retorna <code>-1</code> se o valor não for encontrado.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.lastIndexOf(<var>searchValue</var>[, <var>fromIndex</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>searchValue</code></dt> + <dd>Uma string representando o valor a ser procurado. Se <code>searchValue</code> for uma string vazia, <code>str.length</code> é retornado.</dd> + <dt><code>fromIndex</code></dt> + <dd>Opcional. O índice no qual a pesquisa será iniciada de trás para frente. O valor padrão é <code>+Infinity</code>. Se <code>fromIndex >= str.length</code>, toda string é pesquisada. Se <code>fromIndex < 0</code>, o comportamento será o mesmo que seria com o índice <code>0</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O índice da última ocorrência referente ao valor especificado em <code>searchValue</code>. É retornado <code>-1</code> se nada for encontrado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Os caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é <code>0</code>, e o índice do último caractere é <code>str.length - 1</code>.</p> + +<pre class="brush: js notranslate">'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 +</pre> + +<h3 id="Sensível_a_maiúsculas_e_minúsculas">Sensível a maiúsculas e minúsculas</h3> + +<p>O método <code>lastIndexOf()</code> é sensível a letras maiúsculas e minúsculas. Por exemplo, a seguinte expressão retorna <code>-1</code>:</p> + +<pre class="brush: js notranslate">'Blue Whale, Killer Whale'.lastIndexOf('blue'); // retorna -1 +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_lastIndexOf">Usando <code>lastIndexOf()</code></h3> + +<p>O seguinte exemplo usa <code>lastIndexOf()</code> para localizar valores nas string <code>"Brave new world"</code>.</p> + +<pre class="brush: js notranslate">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 +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Estado</th> + <th scope="col">Comentários</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.8', 'String.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> + <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>A propriedade <code>length</code> de um objeto {{jsxref("String")}} contém o comprimento da string. <code>length</code> é uma propriedade <code>read-only</code> (somente leitura) de instâncias de string.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.length</code></pre> + +<h2 id="Descrição">Descrição</h2> + +<p>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 <code>length</code> não seja exatamente o número de caracteres na string.</p> + +<p>ECMASCript 2016 (ed. 7) estabeleceu um comprimento máximo de <code>2^53 - 1</code> elementos. Anteriormente, nenhum comprimento máximo havia sido especificado. No Firefox, as strings têm um comprimento (<code>length</code>) máximo de <code>2**30 - 2</code> (~ 1 GB). Em versões anteriores ao Firefox 65, o comprimento máximo era <code>2**28 - 1</code> (~ 256 MB).</p> + +<p>Para uma string vazia, <code>length</code> é <code>0</code>.</p> + +<p>A propriedade estática <code>String.length</code> retorna o valor <code>1</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Uso_básico">Uso básico</h3> + +<pre class="brush: js notranslate">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" */ +</pre> + +<h3 id="Atribuindo_valor_ao_comprimento">Atribuindo valor ao comprimento</h3> + +<pre class="brush: js notranslate">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 +</pre> + +<h2 id="Especificação">Especificação</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Estado</th> + <th scope="col">Comentários</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementada no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="http://developer.teradata.com/blog/jasonstrimpel/2011/11/javascript-string-length-and-internationalizing-web-applications">JavaScript <code>String.length</code> and Internationalizing Web Applications</a></li> +</ul> 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 +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>link()</code> cria uma string que representa o código para um elemento HTML <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/a" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/a"><a></a></code> a ser usado como um link de hipertexto para outro URL.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.link(<var>url</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>url</code></dt> + <dd>Qualquer string que especifique o atributo <code>href</code> da tag <code><a></code>. Deve ser um URL válido (relativo ou absoluto), com qualquer caractere <code>&</code> escapado como <code>&amp</code> e qualquer <code>"</code> caractere escapado como <code>&quot</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/a" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/a"><a></a></code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Use o método <code>link()</code> para criar um elemento HTML <code><a></code>. A string retornada pode então ser adicionada ao documento por meio de <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/API/Document/write" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/API/Document/write">document.write()</a></code> ou <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/API/Element/innerHTML" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/API/Element/innerHTML">element.innerHTML</a></code>.</p> + +<p>Os links criados com o método <code>link()</code> tornam-se elementos na array de links do objeto <code>document</code>. Veja <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document/links" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document/links">document.links</a></code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_link">Usando <code>link()</code></h3> + +<p>O exemplo a seguir exibe a palavra "MDN" como um link que retorna o usuário à Mozilla Developer Network.</p> + +<pre class="brush: js notranslate">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> +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.link', 'String.prototype.link')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.link")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.anchor()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code>localeCompare()</code> 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.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-localecompare.html")}}</div> + + + +<p>Os novos argumentos <em><code>locales</code></em> e <em><code>options</code></em> 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 <em><code>locales</code></em> e <em><code>options</code></em>, a localidade e a ordem de classificação usadas são totalmente dependentes da implementação.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>referenceStr</var>.localeCompare(<var>compareString</var>[, <var>locales</var>[, <var>options</var>]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code><var>compareString</var></code></dt> + <dd>A string com a qual a <em><code>referenceStr</code></em> é comparada.</dd> + <dt><code><var>locales</var></code> <var>e </var><code><var>options</var></code></dt> + <dd> + <p>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 <em><code>locales</code></em> e <em><code>options</code></em>, a localidade usada e a forma da string retornada são inteiramente dependentes da implementação.</p> + + <p>Consulte o <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator">construtor </a><code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator">Intl.Collator()</a></code> para obter detalhes sobre esses parâmetros e como usá-los.</p> + </dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um número <strong>negativo</strong> se <em><code>referenceStr</code></em> ocorrer antes de <em><code>compareString</code></em>. Um número <strong>positivo</strong> se o <em><code>referenceStr</code></em> ocorrer após <em><code>compareString</code></em>. <code>0</code> se eles forem equivalentes.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Retorna um inteiro indicando se <em><code>referenceStr</code></em> vem antes, depois ou é equivalente a <em><code>compareString</code></em>.</p> + +<ul> + <li>Negativo quando o <em><code>referenceStr</code></em> ocorre antes de <em><code>compareString</code></em></li> + <li>Positivo quando o <em><code>referenceStr</code></em> ocorre após <em><code>compareString</code></em></li> + <li>Retorna <code>0</code> se eles forem equivalentes</li> +</ul> + +<div class="blockIndicator warning"> +<p><strong>NÃO confie em valores de retorno exatos de -1 ou 1!</strong></p> + +<p>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 <code>-2</code> ou <code>2</code>, ou mesmo algum outro valor negativo ou positivo.</p> +</div> + +<h2 id="Performance">Performance</h2> + +<p>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")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_localeCompare">Usando <code>localeCompare()</code></h3> + +<pre class="brush: js notranslate">// 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 +</pre> + +<h3 id="Ordenar_um_array">Ordenar um array</h3> + +<p><code>localeCompare()</code> permite a ordenação sem distinção entre maiúsculas e minúsculas em um array.</p> + +<pre class="brush: js notranslate">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é'] +</pre> + +<h3 id="Verifique_o_suporte_do_navegador_para_os_novos_argumentos">Verifique o suporte do navegador para os novos argumentos</h3> + +<p>Os argumentos <em><code>locales</code></em> e <em><code>options</code></em> ainda não são suportados em todos os navegadores.</p> + +<p>Para verificar se uma implementação os suporta, use o argumento <code>"i"</code> (um requisito de rejeição das tags de linguagem ilegal) e procure uma exceção {{jsxref ("RangeError")}}:</p> + +<pre class="brush: js notranslate">function localeCompareSupportsLocales() { + try { + 'foo'.localeCompare('bar', 'i'); + } catch (e) { + return e.name === 'RangeError'; + } + return false; +} +</pre> + +<h3 id="Usando_locales">Usando <code>locales</code></h3> + +<p>Os resultados fornecidos por <code>localeCompare()</code> 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 <em><code>locales</code></em>:</p> + +<pre class="brush: js notranslate">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 +</pre> + +<h3 id="Usando_options">Usando <code>options</code></h3> + +<p>Os resultados fornecidos por <code>localeCompare()</code> podem ser personalizados usando o argumento <em><code>options</code></em>:</p> + +<pre class="brush: js notranslate">// 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 +</pre> + +<h3 id="Ordenação_numérica">Ordenação numérica</h3> + +<pre class="brush: js notranslate">// por padrão, "2" > "10" +console.log(<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body">"2".localeCompare("10")</span></span></span>); // 1 + +// numeric using options: +console.log(<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body">"2".localeCompare("10", undefined, {numeric: true})</span></span></span>); // -1 + +// numeric using locales tag: +console.log(<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body">"2".localeCompare("10", "en-u-kn-true")</span></span></span>); // -1 +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificação</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}</td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sup-String.prototype.localeCompare', 'String.prototype.localeCompare')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.localeCompare")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li> +</ul> 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 +--- +<p>{{JSRef("Global_Objects", "String")}}</p> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <code>match()</code> retorna uma correspondência entre uma string com uma <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">expressão regular</a>.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><em>str</em>.match(regexp);</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>regexp</code></dt> + <dd>Um objeto de <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">expressão regular</a>. Se <em><code>regexp</code></em> não for uma <strong><code>RegExp</code></strong>, o mesmo será convertido para uma nova RegExp usando <code>new <strong>RegExp</strong>(<em>regexp</em>)</code>.<br> + <br> + Se você não fornecer nenhum parâmetro ao usar o método <code>match()</code>, você obterá um {{jsxref ("Array")}} com uma string vazia: <code>[""]</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<ul> + <li>Se o sinalizador <code>g</code> for usado, todos os resultados correspondentes à expressão regular serão retornados, mas a captura de grupos não.</li> + <li>se o sinalizador <code>g</code> não for usado, apenas a primeira correspondência completa e seus grupos de captura relacionados serão retornados. Nesse caso, o item devolvido terá propriedades adicionais conforme descrito a seguir.</li> +</ul> + +<dl> + <dt><code>array</code></dt> + <dd>Um {{jsxref ("Array")}} cujo conteúdo depende da presença ou ausência do sinalizador global (<code>g</code>), ou {{jsxref ("null")}} se nenhuma correspondência for encontrada.</dd> +</dl> + +<h4 id="Propriedades_adicionais">Propriedades adicionais</h4> + +<p>Conforme explicado acima, alguns resultados contêm propriedades adicionais conforme descrito abaixo.</p> + +<dl> + <dt><code>groups</code></dt> + <dd>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 <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">Grupos e Intervalos</a> para obter mais informações.</dd> + <dt><code>index</code></dt> + <dd>O índice da pesquisa em que o resultado foi encontrado.</dd> + <dt><code>input</code></dt> + <dd>Uma cópia da string pesquisada.</dd> +</dl> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Se a expressão regular não incluir o sinalizador <code>g</code>, <code>str.match()</code> retornará o mesmo resultado que {{jsxref ("RegExp.prototype.exec()", "RegExp.exec()")}}.</p> + +<h3 id="Notes" name="Notes">Veja também: métodos RegExp</h3> + +<ul> + <li>Se você precisar saber se uma string corresponde a uma expressão regular, use {{jsxref("RegExp.test()", "RegExp.test()")}}.</li> + <li>Se você quiser encontrar apenas uma correspondência, você pode querer usar {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}}.</li> + <li>Se você deseja obter grupos de captura e o sinalizador global (<code>g</code>) está definido, você precisa usar {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}} ou {{jsxref("String. prototype.matchAll() ")}} em vez disso.</li> +</ul> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Using_match" name="Example:_Using_match">Usando <code>match()</code></h3> + +<p>No exemplo a seguir, <code>match()</code> é 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 <code>i</code> para que diferenças de maiúscula/minúscula sejam ignoradas.</p> + +<pre class="brush:js notranslate">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. +</pre> + +<h3 id="Example_Using_global_and_ignore_case_flags_with_match" name="Example:_Using_global_and_ignore_case_flags_with_match">Usando as bandeiras (flags) global e ignore com<br> + <code>match()</code></h3> + +<p>O exemplo a seguir demonstra o uso das bandeiras (flags) global e ignore com <code>match()</code>. Todas as letras de <code>A</code> a <code>E</code> e <code>a</code> a <code>e</code> são retornadas, com cada letra sendo um elemento no array.</p> + +<pre class="brush:js notranslate">var str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; +var regexp = /[A-E]/gi; +var matches_array = str.match(regexp); + +console.log(matches_array); +// <code>['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']</code> +</pre> + +<div class="blockIndicator note"> +<p><strong>Nota:</strong> Veja também {{jsxref("String.prototype.matchAll()")}} e <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions#Pesquisa_avan%C3%A7ada_com_Flags" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions#Pesquisa_avan%C3%A7ada_com_Flags">Pesquisa avançada com sinalizadores</a>.</p> +</div> + +<h3 id="Usando_grupos_de_captura_nomeados">Usando grupos de captura nomeados</h3> + +<p>Em navegadores que suportam grupos de captura nomeados, o código a seguir captura "<code>fox</code>" ou "<code>cat</code>" em um grupo denominado "<code>animal</code>":</p> + +<pre class="brush: js notranslate">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"}</pre> + +<h3 id="Usando_match_sem_parâmetros">Usando <code>match()</code> sem parâmetros</h3> + +<pre class="brush: js notranslate">var str = "nada se perde, tudo se transforma"; + +str.match(); // retorna [""] +</pre> + +<h3 id="Um_objeto_não-RegExp_como_parâmetro">Um objeto não-RegExp como parâmetro</h3> + +<p>Quando o parâmetro <em><code>regexp</code></em> é uma string ou um número, ele é convertido implicitamente em um {{jsxref("RegExp")}} usando o <code>new <strong>RegExp</strong>(<em>regexp</em>)</code>.<br> + <br> + Se for um número positivo com um sinal positivo, <code>RegExp()</code> irá ignorar o sinal positivo.</p> + +<pre class="brush: js notranslate"><code>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"]</code></pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificações</th> + <th scope="col">Estado</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>ECMAScript 3rd Edition.</td> + <td>Standard</td> + <td>Definição inicial.<br> + Implementado no JavaScript 1.2</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.10', 'String.prototype.match')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.match', 'String.prototype.match')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte Básico</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte Básico</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code>matchAll()</code> retorna um iterador de todos os resultados correspondentes a uma string em relação a uma <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">expressão regular</a>, incluindo <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">grupos de captura</a>.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-matchall.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.matchAll(<var>regexp</var>)</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code><var>regexp</var></code></dt> + <dd> + <p>Um objeto de expressão regular.</p> + + <p>Se um objeto <em><code>obj</code></em> não-RegExp for passado, ele será convertido implicitamente em um {{jsxref("RegExp")}} usando <code>new RegExp(<em>obj</em>)</code>.</p> + + <p>O objeto <code>RegExp</code> deve ter o sinalizador (flag) <code>/g</code>, caso contrário, um <code>TypeError</code> será retornado.</p> + </dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Iteratores_e_geradores" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Iteratores_e_geradores">iterador</a> (que não é um iterável reinicializável).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Regexp.exec_e_matchAll">Regexp.exec() e matchAll()</h3> + +<p>Antes da adição do <code>matchAll()</code> ao JavaScript, era possível usar chamadas <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec">regexp.exec</a> (e regexes com a sinalização (flag) <code>/g</code>) em um loop para obter todas as correspondências:</p> + +<pre class="brush: js notranslate">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." +}</pre> + +<p>Com o <code>matchAll()</code> disponível, você pode evitar o loop {{jsxref("Statements/while", "while")}} e executar com <code>g</code>.</p> + +<p>Em vez disso, usando o <code>matchAll()</code>, 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()")}}:</p> + +<pre class="brush: js notranslate">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" ]</pre> + +<p><code>matchAll()</code> retornará uma exceção se o sinalizador (flag) <code>g</code> estiver ausente.</p> + +<pre class="brush: js notranslate">const regexp = RegExp('[a-c]',''); +const str = 'abc'; +str.matchAll(regexp); +// retorna TypeError +</pre> + +<p><code>matchAll()</code> cria internamente um clone da <code>regexp</code> - portanto, ao contrário de {{jsxref("Global_Objects/RegExp/exec", "regexp.exec()")}}, o <code>lastIndex</code> não muda conforme a string é verificada.</p> + +<pre class="brush: js notranslate">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" ]</pre> + +<h3 id="Melhor_acesso_para_capturar_grupos_do_que_String.prototype.match">Melhor acesso para capturar grupos (do que String.prototype.match())</h3> + +<p>Outra razão convincente para usar <code>matchAll()</code> é o acesso aprimorado para capturar grupos.</p> + +<p>Os grupos de captura são ignorados ao usar {{jsxref("Global_Objects/String/match", "match()")}} com o sinalizador global <code>/g</code>:</p> + +<pre class="brush: js notranslate">let regexp = /t(e)(st(\d?))/g; +let str = 'test1test2'; + +str.match(regexp); +// Array ['test1', 'test2']</pre> + +<p>Usando o <code>matchAll()</code>, você pode acessar os grupos de captura facilmente:</p> + +<pre class="brush: js notranslate">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] +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Specification</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.matchall', 'String.prototype.matchAll')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.matchAll")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.match()")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Using regular expressions in JavaScript</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">Capturing groups</a></li> + <li>{{jsxref("RegExp")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método<strong> </strong><code>normalize()</code> 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).</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.normalize([<var>form</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>form</code></dt> + <dd>Opcional. Um dentre os seguintes valores: <code>"NFC"</code>, <code>"NFD"</code>, <code>"NFKC"</code>, ou <code>"NFKD"</code>, especificando o formato de normalização. Se o valor for omitido ou for {{jsxref("undefined")}}, <code>"NFC"</code> será utilizado. + <ul> + <li><code>NFC</code> — Formato de Normalização Canônico de Composição. </li> + <li><code>NFD</code> — Formato de Normalização Canônico de Decomposição.</li> + <li><code>NFKC</code> — Formato de Normalização de Compatibilidade de Composição.</li> + <li><code>NFKD</code> — Formato de Normalização de Compatibilidade de Decomposição.</li> + </ul> + </dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo a Forma de Normalização Unicode da string dada.</p> + +<h3 id="Erros_lançados">Erros lançados</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Em erro {{jsxref("RangeError")}} é lançado se <code>form</code> não for um dos valores especificados acima.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>O Unicode atribui um valor numérico exclusivo, denominado <em>ponto de código</em>, a cada caractere. Por exemplo, o ponto de código para <em>"A"</em> é 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 <code>"ñ"</code>, por exemplo, pode ser representado por:</p> + +<ul> + <li>Apenas um ponto de código U+00F1.</li> + <li>O ponto de código para <code>"n"</code> (U+006E) seguido pelo ponto de código para o til (U+0303).</li> +</ul> + +<pre class="brush: js notranslate">let string1 = '\u00F1'; +let string2 = '\u006E\u0303'; + +console.log(string1); // retorna ñ +console.log(string2); // retorna ñ</pre> + +<p>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.</p> + +<pre class="brush: js notranslate">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</pre> + +<p>O método <code>normalize()</code> 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 <strong>equivalência canônica</strong> e a outra baseada na <strong>compatibilidade</strong>.</p> + +<h3 id="Normalização_de_equivalência_canônica">Normalização de equivalência canônica</h3> + +<p>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).</p> + +<p>Você pode usar o <code>normalize()</code> usando os argumentos <code>"NFD"</code> ou <code>"NFC"</code> 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 <code>"ñ"</code>:</p> + +<pre class="brush: js notranslate">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</pre> + +<h4 id="Formas_compostas_e_decompostas"><strong>Formas compostas e decompostas</strong></h4> + +<p>Observe que o comprimento da forma normalizada em <code>"NFD"</code> é <code>2</code>. Isso porque <code>"NFD"</code> fornece a versão <strong>decomposta</strong> da forma canônica, na qual pontos de código únicos são divididos em vários combinados. A forma canônica decomposta para <code>"ñ"</code> é <code>"\u006E\u0303"</code>.</p> + +<p>Você pode especificar <code>"NFC"</code> para obter a forma canônica <strong>composta</strong>, 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 <code>"ñ"</code> é <code>"\u00F1"</code>:</p> + +<pre class="brush: js notranslate">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</pre> + +<h3 id="Normalização_de_compatibilidade">Normalização de compatibilidade</h3> + +<p>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.</p> + +<p>Todas as sequências canonicamente equivalentes também são compatíveis, mas não o contrário.</p> + +<p>Por exemplo:</p> + +<ul> + <li>o ponto de código U+FB00 representa a <a href="https://wiki.developer.mozilla.org/en-US/docs/Glossary/Ligature" title="https://wiki.developer.mozilla.org/en-US/docs/Glossary/Ligature">ligadura</a> <code>"ff"</code>. É compatível com dois pontos de código U+0066 consecutivos (<code>"ff"</code>).</li> + <li>o ponto de código U+24B9 representa o símbolo <code>"Ⓓ"</code>. É compatível com o ponto de código U+0044 (<code>"D"</code>).</li> +</ul> + +<p>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.</p> + +<p>Você pode usar o <code>normalize()</code> usando os argumentos <code>"NFKD"</code> ou <code>"NFKC"</code> para produzir uma forma de string que será a mesma para todas as strings compatíveis:</p> + +<pre class="brush: js notranslate">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</pre> + +<p>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 <code>"f"</code>. Mas pode não ser apropriado para exibição, porque a representação visual é diferente.</p> + +<p>Como na normalização canônica, você pode solicitar formulários compatíveis decompostos ou compostos passando <code>"NFKD"</code> ou <code>"NFKC"</code>, respectivamente.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_normalize"><font face="x-locale-heading-primary, zillaslab, Palatino, Palatino Linotype, x-locale-heading-secondary, serif">Usando </font><code>normalize()</code></h3> + +<pre class="brush: js notranslate">// 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' +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype.normalize', 'String.prototype.normalize')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.normalize', 'String.prototype.normalize')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Nevegadores_compatíveis">Nevegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.normalize")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="http://www.unicode.org/reports/tr15/">Unicode Standard Annex #15, Unicode Normalization Forms</a></li> + <li><a href="http://en.wikipedia.org/wiki/Unicode_equivalence">Unicode equivalence</a></li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code>padEnd()</code> 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.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-padend.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.padEnd(<var>targetLength</var> [, <var>padString</var>])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>targetLength</code></dt> + <dd>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.</dd> + <dt><code>padString</code></dt> + <dd>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 é "<code> </code>" (<code>U+0020</code>).</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma {{jsxref("String")}} cuja composição vem da string original, completada por um ou mais caracteres de preenchimento, respeitando o comprimento alvo.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_padEnd">Usando padEnd</h3> + +<pre class="brush: js notranslate">'abc'.padEnd(10); // "abc " +'abc'.padEnd(10, "foo"); // "abcfoofoof" +'abc'.padEnd(6, "123456"); // "abc123" +'abc'.padEnd(1); // "abc"</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Rodando o seguinte código antes de qualquer código irá criar o método <code>String.prototype.padEnd()</code> caso ele não esteja disponível nativamente:</p> + +<pre class="brush: js notranslate">// 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); + } + }; +} +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.padend', 'String.prototype.padEnd')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Definição inicial no ECMAScript 2017.</td> + </tr> + <tr> + <td>{{SpecName('ES8', '#sec-string.prototype.padend', 'String.prototype.padEnd')}}</td> + <td>{{Spec2('ES8')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.padEnd")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.padStart()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code>padStart()</code> 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.</p> + + + +<div>{{EmbedInteractiveExample("pages/js/string-padstart.html")}}</div> + + + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.padStart(<var>targetLength</var> [, <var>padString</var>])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>targetLength</code></dt> + <dd>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.</dd> + <dt><code>padString</code></dt> + <dd>Opcional. O caractere, ou caracteres, que deve preencher a string alvo. Caso o comprimento dessa essa string de preenchimento seja superior ao <code>targetLength</code>, ela será truncada a partir da direita. O valor padrão é <code>" "</code> (<code>U+0020 'SPACE'</code>).</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Uma {{jsxref("String")}} de comprimento específico com uma string de preenchimento aplicada a partir do seu início.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Exemplos_básicos">Exemplos básicos</h3> + +<pre class="brush: js notranslate">'abc'.padStart(10); // " abc" +'abc'.padStart(10, "foo"); // "foofoofabc" +'abc'.padStart(6,"123465"); // "123abc" +'abc'.padStart(8, "0"); // "00000abc" +'abc'.padStart(1); // "abc"</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Ao executar o seguinte código antes de qualquer outro código é criado o método <code>String.prototype.padStart()</code>, em casos onde ele não está disponível nativamente:</p> + +<pre class="brush: js notranslate">// 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); + } + }; +} +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.padstart', 'String.prototype.padStart')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Implementação inical no ECMAScript 2017.</td> + </tr> + <tr> + <td>{{SpecName('ES8', '#sec-string.prototype.padstart', 'String.prototype.padStart')}}</td> + <td>{{Spec2('ES8')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.padStart")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.padEnd()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>A <strong><code>String.prototype</code></strong> representa o prototipo de objeto {{jsxref("String")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>Todas as instâncias {{jsxref("String")}} herdam de <code>String.prototype</code>. Alterações na <code>String</code> são propagadas para todas as instâncias {{jsxref("String")}}.</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>String.prototype.constructor</code></dt> + <dd>Especifica a função que cria o protótipo de um objeto.</dd> + <dt>{{jsxref("String.prototype.length")}}</dt> + <dd>Reflete o comprimento da string.</dd> + <dt><code><em>N</em></code></dt> + <dd>Usado para acessar o caractere na posição <em>N</em> onde <em>N</em> é um número inteiro entre 0 e um menor que o valor da <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Function/length">length</a></code>. Estas propriedades são apenas de leitura.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<h3 id="Métodos_não_relacionados_ao_HTML">Métodos não relacionados ao HTML</h3> + +<dl> + <dt>{{jsxref("String.prototype.charAt()")}}</dt> + <dd>Retorna o caractere (exatamente uma unidade de código UTF-16) no índice especificado.</dd> + <dt>{{jsxref("String.prototype.charCodeAt()")}}</dt> + <dd>Retorna um número que é o valor da unidade de código UTF-16 em dado índice.</dd> + <dt>{{jsxref("String.prototype.codePointAt()")}}</dt> + <dd>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.</dd> + <dt>{{jsxref("String.prototype.concat()")}}</dt> + <dd>Combina o texto de duas strings e retorna uma nova string.</dd> + <dt>{{jsxref("String.prototype.includes()")}}</dt> + <dd> Determina se uma string deve ser encontrada dentro de outra string.</dd> + <dt>{{jsxref("String.prototype.endsWith()")}}</dt> + <dd>Determina se uma string termina com os caracteres de outra string.</dd> + <dt>{{jsxref("String.prototype.indexOf()")}}</dt> + <dd>Retorna o índice dentro do objeto String chamado da primeira ocorrência do valor especificado, ou -1 se não encontrado.</dd> + <dt>{{jsxref("String.prototype.lastIndexOf()")}}</dt> + <dd>Retorna o índice dentro do objeto String chamado da última ocorrência do valor especificado, ou -1 se não encontrado.</dd> + <dt>{{jsxref("String.prototype.localeCompare()")}}</dt> + <dd>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.</dd> + <dt>{{jsxref("String.prototype.match()")}}</dt> + <dd>Usado para combinar uma expressão regular com uma string.</dd> + <dt>{{jsxref("String.prototype.normalize()")}}</dt> + <dd>Retorna o Formulário de Normalização Unicode do valor string chamado.</dd> + <dt>{{jsxref("String.prototype.padEnd()")}}</dt> + <dd>Empacota a string atual desde o final com uma string dada para criar uma nova string de um dado comprimento.</dd> + <dt>{{jsxref("String.prototype.padStart()")}}</dt> + <dd>Empacota a string atual desde o início com uma string dada para criar uma nova string de um dado comprimento.</dd> + <dt><s class="obsoleteElement">{{jsxref("String.prototype.quote()")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Envolve a cadeia entre aspas duplas ("" ").</s></dd> + <dt>{{jsxref("String.prototype.repeat()")}}</dt> + <dd>Retorna uma string consistindo elementos do objeto repetido pelas vezes definidas.</dd> + <dt>{{jsxref("String.prototype.replace()")}}</dt> + <dd>Usado para encontrar uma combinação entre uma expressão regular e uma string, e para substituir uma substring combinada com uma nova substring.</dd> + <dt>{{jsxref("String.prototype.search()")}}</dt> + <dd>Executa a procura por uma combinação entre uma expressão regular e uma string especificada.</dd> + <dt>{{jsxref("String.prototype.slice()")}}</dt> + <dd>Extrai uma seção de uma string e retorna uma nova string.</dd> + <dt>{{jsxref("String.prototype.split()")}}</dt> + <dd>Separa um objeto <a href="pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String" title="The String global object is a constructor for strings, or a sequence of characters."><code>String</code></a> em um array de strings separando a string em substrings.</dd> + <dt>{{jsxref("String.prototype.startsWith()")}}</dt> + <dd>Determina se uma string começa com os caracteres de outra string.</dd> + <dt>{{jsxref("String.prototype.substr()")}}</dt> + <dd>Retorna os caracteres em uma string começando no local especificado através do número especificado de caracteres.</dd> + <dt>{{jsxref("String.prototype.substring()")}}</dt> + <dd>Retorna os caracteres em uma string entre dois índices na string.</dd> + <dt>{{jsxref("String.prototype.toLocaleLowerCase()")}}</dt> + <dd>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 <a href="pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase" title="The toLowerCase() method returns the calling string value converted to lower case."><code>toLowerCase()</code></a>.</dd> + <dt>{{jsxref("String.prototype.toLocaleUpperCase()")}}</dt> + <dd>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 <a href="pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase" title="The toUpperCase() method returns the calling string value converted to upper case."><code>toUpperCase()</code></a>.</dd> + <dt>{{jsxref("String.prototype.toLowerCase()")}}</dt> + <dd>Retorna o valor da string de chamada convertido em minúsculas.</dd> + <dt>{{jsxref("String.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>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()")}}</dd> + <dt>{{jsxref("String.prototype.toString()")}}</dt> + <dd>Retorna uma string que representa o objeto especificado. Substitui o metodo:{{jsxref("Object.prototype.toString()")}}</dd> + <dt>{{jsxref("String.prototype.toUpperCase()")}}</dt> + <dd>Retorna o valor da string de chamada convertido em maiúscula.</dd> + <dt>{{jsxref("String.prototype.trim()")}}</dt> + <dd>Retira o espaço em branco desde o início e o fim da string. Parte do padrão ECMAScript 5.</dd> + <dt>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</dt> + <dd>Retira o espaço em branco do lado esquerdo da string.</dd> + <dt>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</dt> + <dd>Retira o espaço em branco do lado esquerdo da string.</dd> + <dt>{{jsxref("String.prototype.valueOf()")}}</dt> + <dd>Retorna o valor primitivo do objeto especificado. Substitui o metodo: {{jsxref("Object.prototype.valueOf()")}} </dd> + <dt>{{jsxref("String.prototype.@@iterator()", "String.prototype[@@iterator]()")}}</dt> + <dd>Retorna um novo objeto <code>Iterator </code>que repete sobre os pontos de código de um valor String, retornando cada ponto de código como um valor String.</dd> +</dl> + +<h3 id="Métodos_de_envoltório_HTML">Métodos de envoltório HTML</h3> + +<p>Esses métodos são de uso limitado, pois fornecem apenas um subconjunto das tags e atributos HTML disponíveis.</p> + +<dl> + <dt>{{jsxref("String.prototype.anchor()")}}</dt> + <dd>{{htmlattrxref("name", "a", "<a name=\"name\">")}} (alvo hipertexto)</dd> + <dt>{{jsxref("String.prototype.big()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("big")}}</dd> + <dt>{{jsxref("String.prototype.blink()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("blink")}}</dd> + <dt>{{jsxref("String.prototype.bold()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("b")}}</dd> + <dt>{{jsxref("String.prototype.fixed()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("tt")}}</dd> + <dt>{{jsxref("String.prototype.fontcolor()")}} {{deprecated_inline}}</dt> + <dd>{{htmlattrxref("color", "font", "<font color=\"color\">")}}</dd> + <dt>{{jsxref("String.prototype.fontsize()")}} {{deprecated_inline}}</dt> + <dd>{{htmlattrxref("size", "font", "<font size=\"size\">")}}</dd> + <dt>{{jsxref("String.prototype.italics()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("i")}}</dd> + <dt>{{jsxref("String.prototype.link()")}}</dt> + <dd>{{htmlattrxref("href", "a", "<a href=\"url\">")}} (link para URL)</dd> + <dt>{{jsxref("String.prototype.small()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("small")}}</dd> + <dt>{{jsxref("String.prototype.strike()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("strike")}}</dd> + <dt>{{jsxref("String.prototype.sub()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("sub")}}</dd> + <dt>{{jsxref("String.prototype.sup()")}} {{deprecated_inline}}</dt> + <dd>{{HTMLElement("sup")}}</dd> +</dl> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacoes</th> + <th scope="col">Status</th> + <th scope="col">Comentarios</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.3.1', 'String.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype', 'String.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype', 'String.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_entre_browsers">Compatibilidade entre browsers</h2> + +<p class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, verifique <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um pedido de participação.</p> + +<p>{{Compat("javascript.builtins.String.prototype")}}</p> + +<h2 id="Veja_também">Veja também </h2> + +<ul> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método estático <code>String.raw()</code> é uma função tag de <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/template_strings" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/template_strings">modelos literais</a>, similar ao prefixo <code>r</code> no Python ou o prefixo <code>@</code> no C# para string literais (Mas não é <em>idêntico</em>, existe uma diferença, veja explicações nessa <a href="https://bugs.chromium.org/p/v8/issues/detail?id=5016">discussão</a>). Ele é usado para pegar as strings no formato "cru" de modelos literais, isto é, substituições (ex: <font face="consolas, Liberation Mono, courier, monospace"><span style="">${foo}</span></font>) são processados, mas "escapes" (ex:. <code>\n</code>) não são.</p> + +<p>{{EmbedInteractiveExample("pages/js/string-raw.html")}}</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code>String.raw(<var>callSite</var>, <var>...sub</var>) + +String.raw`templateString` +</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>callSite</code></dt> + <dd> Modelo bem-formatado de objeto de local de chamada, como <code>{ raw: ['foo', 'bar', 'baz'] }</code>.</dd> + <dt><code>...substitutions</code></dt> + <dd>Contém os valores das substituições.</dd> + <dt><code>templateString</code></dt> + <dd>Um <a href="/en-US/docs/Web/JavaScript/Reference/template_strings">modelo string</a>, opcionalmente com substituições (<code>${...}</code>).</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>A forma crua de uma string de um modelo string dado.</p> + +<h3 id="Exceções">Exceções</h3> + +<dl> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Um {{jsxref("TypeError")}} é jogado se o primeiro argumento não é um Objeto bem formado.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Na maioria dos casos, <code>String.raw()</code> é 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 <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/template_strings" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/template_strings">funções de tag</a>.</p> + +<p><code>String.raw()</code> é 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.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_String.raw">Usando <code>String.raw()</code></h3> + +<pre class="brush: js notranslate">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' + +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.raw', 'String.raw')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.raw', 'String.raw')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.raw")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/template_strings">Modelos de strings</a></li> + <li>{{jsxref("String")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar">Gramática lexical</a></li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>repeat()</code></strong> constrói e retorna uma nova string com um determinado número de cópias concatenadas da string original.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.repeat(<var>count</var>);</code> +</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>count</code></dt> + <dd>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.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova string contendo o número especificado de cópias da string original.</p> + +<h3 id="Exceções">Exceções</h3> + +<ul> + <li>{{jsxref("Errors/Negative_repetition_count", "RangeError")}}: o número de repetições não pode ser negativo.</li> + <li>{{jsxref("Errors/Resulting_string_too_large", "RangeError")}}: o número de repetições deve ser menor que infinito e não deve ultrapassar o tamanho máximo da string.</li> +</ul> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: js notranslate">'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) +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>O método <code>repeat()</code> 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 <code>String.prototype.repeat()</code>:</p> + +<pre class="brush: js notranslate">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; + } +} +</pre> + +<h4 id="Polyfill_ES5">Polyfill ES5</h4> + +<pre class="syntaxbox notranslate">//#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); +*/ +</pre> + +<h4 id="Polyfill_ES6">Polyfill ES6</h4> + +<pre class="syntaxbox notranslate">//#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 + +);</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">A tabela de compatibilidade nesta página foi gerada a partir de dados estruturados. Se você quiser contribuir para esses dados, vá para <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie uma pull request.</p> + +<p>{{Compat("javascript.builtins.String.repeat")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.concat()")}}</li> +</ul> 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 +--- +<div>{{JSRef("Global_Objects", "String")}}</div> + +<h2 id="Resumo">Resumo</h2> + +<p>O método <code>replace()</code> 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.</p> + +<p>A string original não é modificada.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.replace(<var>regexp</var>|<var>substr</var>, <var>newSubStr</var>|<var>function</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>regexp </code></dt> + <dd><span class="tlid-translation translation"><span title="">Um objeto {{jsxref ("RegExp")}} ou literal. A correspondência ou correspondências são substituídas por <em><code>newSubStr</code></em> ou o valor retornado pela <code>function</code> especificada.</span></span></dd> + <dt><code>substr</code></dt> + <dd><span class="tlid-translation translation"><span title="">Uma {{jsxref ("String")}} que será substituída por <code>newSubStr</code>.</span> <span title="">Ele é tratado como uma string textual e não é interpretado como uma expressão regular.</span> <span title="">Apenas a primeira ocorrência será substituída.</span></span></dd> + <dt><code>newSubStr</code></dt> + <dd>A {{jsxref("Global_Objects/String", "String")}} que substitui a <code>substr</code> recebida do parâmetro #1. Uma série de padrões de substituições especiais são suportados. Veja a seção "<a href="#" id="Specifying_a_string_as_a_parameter">Especificando uma string como parâmetro</a>" abaixo.</dd> + <dt><code>function</code></dt> + <dd>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 "<a href="#" id="Specifying_a_string_as_a_parameter">Especificando uma função como parâmetro</a>" mais abaixo.</dd> + <dt><code>flags</code> {{non-standard_inline}}</dt> + <dd> + <p>Uma string especificando uma combinação de <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">flags de expressão regular</a>. O uso do parâmetro <code>flags</code> no método <code>String.prototype.replace()</code> é 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:</p> + + <dl> + <dt><code>g</code></dt> + <dd>Combinação global.</dd> + <dt><code>i</code></dt> + <dd>Ignora diferenças entre maiúsculas e minúsculas.</dd> + <dt><code>m</code></dt> + <dd>Combinação em várias linhas.</dd> + <dt><code>y</code> {{experimental_inline}}</dt> + <dd>Sticky</dd> + </dl> + + <div class="blockIndicator note"> + <p><strong>Nota: </strong>O argumento <code>flags</code> não funciona no v8 Core (Chrome e NodeJs).</p> + </div> + </dd> +</dl> + +<h3 id="Returns" name="Returns">Valor retornado</h3> + +<p>Uma nova string com alguma ou todas as combinações do padrão substituído(s) pelo valor de substituição.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Este método não muda o objeto {{jsxref("Global_Objects/String", "String")}}. Ele simplesmente retorna uma nova string.</p> + +<p>Para realizar uma pesquisa global e substituir, inclua a flag <code>g</code> na expressão regular ou se o primeiro parâmetro for uma string, inclua <code>g</code> no parâmetro flags.</p> + +<h3 id="Specifying_a_string_as_a_parameter" name="Specifying_a_string_as_a_parameter">Especificando uma string como parâmetro</h3> + +<p>A string substituidora pode incluir o seguinte padrão de substituição especial:</p> + +<table class="fullwidth-table" style="height: 140px; width: 575px;"> + <tbody> + <tr> + <td class="header"><strong>Padrão </strong></td> + <td class="header"><strong>Insere</strong></td> + </tr> + <tr> + <td><code>$$</code></td> + <td>Insere um "$".</td> + </tr> + <tr> + <td><code>$&</code></td> + <td>Insere a string casada.</td> + </tr> + <tr> + <td><code>$`</code></td> + <td>Insere a porção da string que precede a substring combinada.</td> + </tr> + <tr> + <td><code>$'</code></td> + <td>Insere a porção da string que segue a substring combinada.</td> + </tr> + <tr> + <td><code>$<em>n</em></code> ou <code>$<em>nn</em></code></td> + <td>Onde <code><em>n</em></code> ou <code><em>nn</em></code> são dígitos decimais, insere a <em>n</em>-ésima substring entre parêntesis casada, dado o primeiro argumento foi um objeto {{jsxref("Global_Objects/RegExp", "RegExp")}}.</td> + </tr> + </tbody> +</table> + +<h3 id="Specifying_a_function_as_a_parameter" name="Specifying_a_function_as_a_parameter">Especificando uma função como parâmetro</h3> + +<p>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.</p> + +<p>Os parâmetros da função são:</p> + +<table class="fullwidth-table" style="height: 375px; width: 490px;"> + <tbody> + <tr> + <td class="header"><strong>Possíveis nomes </strong></td> + <td class="header"><strong>Valor fornecido</strong></td> + </tr> + <tr> + <td><code>match</code></td> + <td>A substring encontrada. Corresponde ao <code>$&</code> acima.</td> + </tr> + <tr> + <td><code>p1, p2, ...</code></td> + <td>O enésimo parâmetro entre parênteses da RegEx no primeiro parâmetro na função <code>replace()</code> {{jsxref("Global_Objects/RegExp", "RegExp")}}. (Corresponde a <code>$1</code>, <code>$2</code>, etc. acima.) Por exemplo, se <code>/(\a+)(\b+)/</code>, for o primeiro parâmetro, <code>p1</code> é a combinação para <code>\a+</code>, e <code>p2</code> para <code>\b+</code>.</td> + </tr> + <tr> + <td><code>offset</code></td> + <td>O offset da string encontrada em relação ao resto da string. Por exemplo, se a string for 'abcd' e a string a ser encontrada for 'bc', então este parâmetro terá o valor 1.</td> + </tr> + <tr> + <td> + <p><code>string</code></p> + </td> + <td> + <p>A string completa que está sendo examinada.</p> + </td> + </tr> + </tbody> +</table> + +<p>(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).</p> + +<p>O exemplo a seguir irá substituir o valor de <code>newString</code> para <code>'abc - 12345 - #$*%'</code>:</p> + +<pre class="brush: js notranslate">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 <span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body"><span class="objectBox objectBox-string">"abc - 12345 - #$*%"</span></span></span></span> +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Definindo_uma_expressão_regular_com_replace">Definindo uma expressão regular com <code>replace()</code></h3> + +<p>No exemplo a seguir foi definida uma expressão regular com a flag "<code>i</code>" (que ignora diferenças entre maiúsculas e minúsculas) no método <code>replace()</code>.</p> + +<pre class="notranslate"><code>var str = 'Twas the night before Xmas...'; +var newstr = str.replace(/xmas/i, 'Christmas'); + +console.log(newstr); +// retorna "Twas the night before Christmas..."</code></pre> + +<div class="blockIndicator note"> +<p><strong>Nota:</strong> Veja <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">este guia</a> para maiores explicações as sobre expressões regulares.</p> +</div> + +<h3 id="Usando_global_e_ignore_com_replace">Usando <code>global</code> e <code>ignore</code> com <code>replace()</code></h3> + +<p>Substituir globalmente, "<code>g</code>", 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 <code>replace()</code> substituir cada "<code>maçãs</code>" por "<code>laranjas</code>" na string.</p> + +<pre class="notranslate"><code>var re = /maçãs/gi; +var str = '</code>As maçãs são redondas. As maçãs são suculentas<code>.'; +var newstr = str.replace(re, 'laranjas'); + +console.log(newstr); +// retorna +// "</code>As laranjas são redondas. As laranjas são suculentas<code>."</code></pre> + +<h3 id="Trocando_palavras_em_uma_string">Trocando palavras em uma string</h3> + +<p>O script a seguir troca as palavras na string. Para o texto que vai substituir, o script usa <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">grupos de captura</a> e os padrões de substituição <code>$1</code> e <code>$2</code>.</p> + +<pre class="notranslate"><code>var re = /(\w+)\s(\w+)/; +var str = 'John Smith'; +var newstr = str.replace(re, '$2, $1'); +console.log(newstr); // Smith, John</code></pre> + +<h3 id="Usando_uma_função_que_modifica_os_caracteres_coincidentes">Usando uma função que modifica os caracteres coincidentes</h3> + +<div class="tw-ta-container hide-focus-ring tw-nfl" id="tw-target-text-container"> +<p><span lang="pt">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. </span>O importante aqui é que é necessário uma operação adicional no item antes dele ser retornado como substituído.</p> +</div> + +<p>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.</p> + +<pre class="notranslate"><code>function styleHyphenFormat(propertyName) { + function upperToHyphenLower(match, offset, string) { + return (offset ? '-' : '') + match.toLowerCase(); + } + return propertyName.replace(/[A-Z]/g, upperToHyphenLower); +}</code></pre> + +<p>Dado o seguinte parâmetro: <code>styleHyphenFormat('borderTop')</code>, o valor retornado é '<code>border-top</code>'.</p> + +<p>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.</p> + +<pre class="brush: js example-bad notranslate">let newString = propertyName.replace(/[A-Z]/g, '-' + '$&'.toLowerCase()); // não funciona</pre> + +<p>Isso acontece porque <code>'$&'.toLowerCase()</code> será executada antes (resultando no mesmo que <code>'$&'</code>) em vez de usar os caracteres da string a ser transformada.</p> + +<h3 id="Substituindo_graus_Fahrenheit_em_Celsius">Substituindo graus Fahrenheit em Celsius</h3> + +<p>O exemplo a seguir converte graus Fahrenheit em Celsius. O grau Fahrenheit deve ser um número terminado com "<code>F</code>". A função retorna o número em Celsius terminando em "<code>C</code>". Por exemplo, se o valor de entrada for "<code>212F</code>", a função deve retornar "<code>100C</code>". Se o número for "<code>0F</code>", a função deve retornar "<code>-17.77777777777778C</code>".</p> + +<p>A expressão regular <code>test</code> verifica por números que terminem com "<code>F</code>". O número de graus Fahrenheit é acessível pela função pelo segundo parâmetro, <code>p1</code>. A função calcula o Celsius baseado no Fahrenheit passado via string para a função <code>f2c()</code>. A <code>f2c()</code> então retorna o número em Celsius.</p> + +<pre class="notranslate"><code>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); +}</code></pre> + +<h3 id="Use_uma_função_com_expressão_regular_para_evitar_loops_for">Use uma função com expressão regular para evitar loops for</h3> + +<p>O exemplo a seguir pega um padrão de string e converte em um array de objetos.</p> + +<p><strong>Entrada:</strong></p> + +<p>Uma string com caracteres: <code>x</code>, <code>-</code> e <code>_</code></p> + +<pre class="notranslate"><code>x-x_ +x---x---x---x--- +x-xxx-xx-x- +x_x_x___x___x___</code></pre> + +<p><strong>Saída:</strong></p> + +<p>Um array de objetos. Um <code>'x'</code> denota um estado <code>'on'</code>, um <code>'-'</code> (hífen) denota um estado <code>'off'</code> e um <code>'_'</code> (underline) denota o comprimento do estado <code>'on'</code>.</p> + +<pre class="notranslate"><code>[ + { on: true, length: 1 }, + { on: false, length: 1 }, + { on: true, length: 2 } + ... +]</code></pre> + +<p><strong>Código:</strong></p> + +<pre class="notranslate"><code>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);</code></pre> + +<p>O código gera um array de 3 objetos como desejado sem usar uma função de loop.</p> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>ECMAScript 3rd Edition.</td> + <td>Standard</td> + <td>Defnição inicial. Implementado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.11', 'String.prototype.replace')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.replace', 'String.prototype.replace')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h3 id="Notas_específicas_do_Firefox">Notas específicas do Firefox</h3> + +<ul> + <li>Começando no Gecko 27 {{geckoRelease(27)}}, esse método foi ajustado conforme as especificações do ECMAScript. Quando <code>replace()</code> é chamado com uma expressão regular global, a propriedade {{jsxref("RegExp.lastIndex")}} (se especificada) será resetada para <code>0</code> ({{bug(501739)}}).</li> +</ul> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<div class="blockIndicator note"><strong>Nota</strong>: A partir de Agosto de 2020, o método <code>replaceAll()</code> continuará sendo suportado pelo Firefox, mas não pelo Chrome. Ele estará disponível somente no Chrome 85.</div> + +<p>O método <code>replaceAll()</code> 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.<br> + <br> + A <em>string</em> original é mantida sem modificação.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-replaceall.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate">const newStr = <var>str</var>.replaceAll(<var>regexp</var>|<var>substr</var>, <var>newSubstr</var>|<var>function</var>) +</pre> + +<div class="blockIndicator note"> +<p><strong>Nota</strong>: quando usar uma `<var>regexp</var>`, você deve colocar o sinalizador (flag) global "<code>g</code>". Do contrário, será retornado um <code>TypeError</code>: "<em>replaceAll must be called with a global RegExp</em>".</p> +</div> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code><var>regexp</var></code> (padrão)</dt> + <dd>Uma {{jsxref ("RegExp")}} ou literal com o sinalizador (flag) global. As ocorrências serão substituídas por <em><code>newSubstr</code></em> ou pelo valor retornado da <em><code>function</code></em> (função) especificada.</dd> + <dt><code><var>substr</var></code><var> </var>(padrão)</dt> + <dd>Uma {{jsxref ("String")}} que deve ser substituída por <code>newSubstr</code>. É tratada como uma string literal e não é interpretada como uma expressão regular (<em><code>RegExp</code></em>).</dd> + <dt><code><var>newSubstr</var></code> (substituição)</dt> + <dd>É a {{jsxref("String")}} que substitui a <code><em>substring</em></code> especificada pelo parâmetro <code><var>regexp</var></code> ou <code><var>substr</var></code>. Um número de padrões especiais para substituição são suportados; veja a seção "<a href="#">Especificando uma string como parâmetro</a>" abaixo.</dd> + <dt><code><var>function</var></code> (substituição)</dt> + <dd>Uma função a ser chamada retornando a nova <code><em>substring</em></code> a ser usada para substituir as correspondências para a dada <code><var>regexp</var></code> ou <code><var>substr</var></code>. Os argumentos passados para esta função são descritos na seção "<a href="#Especificando uma função como parâmetro">Especificando uma função como parâmetro</a>" abaixo.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Um nova <em>string</em>, com todas as ocorrências de um padrão substituído por uma substituição.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Este método não muda o objeto {{jsxref("String")}} original. Ele simplesmente retorna uma nova <em>string</em>.</p> + +<h3 id="Especificando_uma_string_como_parâmetro"><a id="Especificando uma string como parâmetro" name="Especificando uma string como parâmetro">Especificando uma string como parâmetro</a></h3> + +<p>A <em>string</em> de substituição pode incluir os seguimentos padrões especiais de substituição:</p> + +<table class="standard-table"> + <thead> + <tr> + <th class="header" scope="col">Padrão</th> + <th class="header" scope="col">Insere</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>$$</code></td> + <td>Insere um <code>"$"</code>.</td> + </tr> + <tr> + <td><code>$&</code></td> + <td>Insere a <em>substring</em> correspondente.</td> + </tr> + <tr> + <td><code>$`</code></td> + <td>Insere a porção da <em>string</em> que precede a <em>substring</em> correspondente.</td> + </tr> + <tr> + <td><code>$'</code></td> + <td>Insere a porção da <em>string</em> que sucede a <em>substring</em> correspondente.</td> + </tr> + <tr> + <td><code>$<var>n</var></code></td> + <td>Onde <code><var>n</var></code> é um inteiro positivo menor que 100, insere a <var><code>n</code></var>-ésima <em>string</em> submatch entre parênteses, desde que o primeiro argumento seja um objeto {{jsxref("RegExp")}}. Note que isso é indexado começando pelo <code>1</code>.</td> + </tr> + </tbody> +</table> + +<h3 id="Especificando_uma_função_como_parâmetro"><a id="Especificando uma função como parâmetro" name="Especificando uma função como parâmetro">Especificando uma função como parâmetro</a></h3> + +<p>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 <em>string</em> para substituição. (<strong>Nota:</strong> Os padrões especiais mencionados acima <strong>não se aplicam </strong>neste caso.)</p> + +<p>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 "<code>g</code>".</p> + +<p>Os argumentos para funções são os seguintes:</p> + +<table class="standard-table"> + <thead> + <tr> + <th class="header" scope="col">Nome possível</th> + <th class="header" scope="col">Valor fornecido</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>match</code></td> + <td>A <em>substring</em> correspondida. (Corresponde ao <code>$&</code> acima.)</td> + </tr> + <tr> + <td><code>p1, p2, ...</code></td> + <td>A <var>n</var>-ésima string encontrada por um grupo de captura entre parênteses, desde que o primeiro argumento para <code>replace()</code> seja uma {{jsxref("RegExp")}}. (Corresponde a <code>$1</code>, <code>$2</code>, etc. acima.) Por exemplo, se <code>/(\a+)(\b+)/</code>, foi dado, <code>p1</code> é a correspondência para <code>\a+</code>, e <code>p2</code> para <code>\b+</code>.</td> + </tr> + <tr> + <td><code>offset</code></td> + <td>O deslocamento da substring correspondente em toda a string sendo examinada. (Por exemplo, se toda a string for '<code>abcd</code>' e a substring correspondente for '<code>bc</code>', este argumento será <code>1</code>.)</td> + </tr> + <tr> + <td><code>string</code></td> + <td>A <em>string</em> inteira será examinada.</td> + </tr> + </tbody> +</table> + +<p>(O número exato de argumentos depende se o primeiro argumento é um objeto {{jsxref("RegExp")}} — e, se então, quantas <em>subcorrespondências </em>entre parênteses são especificadas.)</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_replaceAll">Usando <code>replaceAll()</code></h3> + +<pre class="brush: js notranslate">'aabbcc'.replaceAll('b', '.'); +// 'aa..cc'</pre> + +<h3 id="RegExp_sem_flag_g_retorando_erro">RegExp sem flag "g" retorando erro</h3> + +<p>Ao usar uma expressão regular para realizar uma pesquisa, a mesma deve conter a flag global "<code>g</code>". O código abaixo não irá funcionar:</p> + +<pre class="brush: js; example-bad notranslate">'aabbcc'.replaceAll(/b/, '.'); +TypeError: replaceAll must be called with a global RegExp +</pre> + +<p>Já o código abaixo vai funcionar:</p> + +<pre class="brush: js; example-good notranslate">'aabbcc'.replaceAll(/b/g, '.'); +"aa..cc" +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificação</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.replaceall', 'String.prototype.replaceAll')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.replaceAll")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.replace", "String.prototype.replace()")}}</li> + <li>{{jsxref("String.prototype.match", "String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec", "RegExp.prototype.exec()")}}</li> + <li>{{jsxref("RegExp.prototype.test", "RegExp.prototype.test()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code>search()</code> realiza uma busca por uma ocorrência entre uma expressão regular e uma {{jsxref ("String")}}.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.search(<var>regexp</var>)</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>regexp</code></dt> + <dd>Um objeto contendo uma expressão regular. Se um objeto <code>obj</code> for passado como parâmetro e não for do tipo <code>RegExp</code>, ele será implicitamente convertido para uma {{jsxref("RegExp")}} através da instrução <code>new RegExp(obj)</code>.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>O índice na string do primeiro trecho que satisfaz a expressão regular. Do contrário, o valor <code>-1</code><strong> </strong>será retornado.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Quando você quiser saber se um padrão foi encontrado, e também saber seu índice dentro de uma string, use <code>search()</code>. (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.)</p> + +<p>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).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_search">Usando <code>search()</code></h3> + +<p>O exemplo a seguir pesquisa uma string com dois objetos <code>regexp</code> diferentes para mostrar uma pesquisa bem-sucedida (valor positivo) vs. uma pesquisa mal-sucedida (-1).</p> + +<pre class="brush: js notranslate">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 "."</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário(s)</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.12', 'String.prototype.search')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.search', 'String.prototype.search')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.search', 'String.prototype.search')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Edge</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Edge</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notas_específicas_para_a_engine_Gecko">Notas específicas para a engine Gecko</h2> + +<ul> + <li>Antes do {{Gecko("8.0")}}, <code>search()</code> foi implementado incorretamente. Quando era chamadosem parâmetros ou com {{jsxref("undefined")}}, ele buscava pela string '<code>undefined</code>', ao invés de buscar pela string vazia. Isto foi corrigido. Agora <code>'a'.search()</code> e <code>'a'.search(undefined)</code> corretamente retornam 0.</li> + <li>A partir do Gecko 39 {{geckoRelease(39)}}, o argumento não-padrão <code>flags</code> está defasado (deprecated) e dispara um aviso no console ({{bug(1142351)}}).</li> + <li>A partir do Gecko 47 {{geckoRelease(47)}}, o argumento não-padrão <code>flags</code> não é mais suportado em builds <em>non-release</em> e em breve será removido inteiramente ({{bug(1245801)}}).</li> + <li>A partir do Gecko 49 {{geckoRelease(49)}}, o argumento não-padrão <code>flags</code> não é mais suportado ({{bug(1108382)}}).</li> +</ul> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.match()")}}</li> + <li>{{jsxref("RegExp.prototype.exec()")}}</li> +</ul> 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 +--- +<div>{{JSRef("Global_Objects", "String")}}</div> + +<h2 id="Summary" name="Summary">Sumário</h2> + +<p>O método <code>slice()</code> extrai uma parte de uma string e a retorna como uma nova string, sem modificar a string original.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.slice(<var>startIndex</var>[, <var>endIndex</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Paramêtros</h3> + +<dl> + <dt><code>startIndex</code></dt> + <dd>É o índice, de base zero, onde se inicia a extração. Se for um número negativo, será o mesmo que executar <em><code>str.length + startIndex</code></em> (por exemplo, se <em><code>startIndex</code></em> for <em><code>-3</code></em>, será o mesmo que executar <em><code>str.length - 3</code></em>).</dd> + <dd> + <pre class="brush: js notranslate">const nome = 'Ricardo'; +console.log(nome.slice(-3)); // retorna 'rdo'</pre> + </dd> +</dl> + +<dl> + <dd>Se <em><code>startIndex</code></em> for maior ou igual a <code><var>str</var><em>.length</em></code>, uma string vazia será retornada.</dd> + <dd> + <pre class="brush: js notranslate">const nome = 'Ricardo'; +console.log(nome.slice(7)); // retorna <empty string>' +</pre> + </dd> + <dt><code>endIndex</code></dt> + <dd>Opcional. É o índice, de base zero, onde termina a extração. O caractere que possuir este índice não será incluso.</dd> + <dd>Se omitido ou possuir valor de <em><code>undefined</code></em>, ou for maior que <code><var>str</var><em>.length</em></code>, <em><code>slice()</code></em> extrairá até o fim da string.</dd> + <dd> + <pre class="brush: js notranslate">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'</pre> + </dd> + <dd>Se negativo, é o mesmo que executar <em><code>str.length + endIndex</code></em> onde <em><code>str.length</code></em> é o tamanho da string (por exemplo, se <em><code>endIndex</code></em> é <em><code>-3</code></em>, é como executar <code><em>str.length - 3</em></code>).</dd> +</dl> + +<dl> + <dd> + <pre class="brush: js notranslate">const nome = 'Ricardo';<strong> +</strong>console.log(nome.slice(0, -3)); // retorna 'Rica' +</pre> + </dd> + <dd>Se for um valor diferente de indefinido e, ao mesmo tempo não for um número, uma string vazia será retornada</dd> + <dd> + <pre class="brush: js notranslate">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' +</pre> + + <p>Se <code><var>endIndex</var></code> for definido e <code><var>startIndex</var></code> for negativo, <code><var>endIndex</var></code> deve ser negativo também, do contrário uma string vazia é retornada.</p> + + <pre class="brush: js notranslate">const nome = 'Ricardo'; +console.log(nome.slice(-3, 0)); // retorna <empty string> +</pre> + + <p>Caso <code><var>endIndex</var></code> seja definido e <code><var>startIndex</var></code> e <code><var>endIndex</var></code> sejam ambos positivos ou negativos, <code><var>endIndex</var></code> deve ser maior que <code><var>startIndex</var></code>, do contrário uma string vazia é retornada.</p> + + <pre class="brush: js notranslate">const nome = 'Ricado'; +console.log(nome.slice(-1, -3)); // retorna <empty string> +console.log(nome.slice(3, 1)); // retorna <empty string> +</pre> + </dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>Uma nova string contento a porção extraída da string.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p><em><code>slice()</code></em> 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.</p> + +<p><em><code>slice()</code></em> extrai até, mas não inclue <em><code>endIndex</code>.</em><br> + <br> + <code><em>str.slice(1, 4)</em></code> extrai a partir do segundo caractere até o quarto caractere (ou seja, os caracteres de índices <em><code>1</code></em>, <em><code>2</code></em>, e <em><code>3</code></em>).</p> + +<p>Por exemplo, <em><code>str.slice(2, -1)</code></em> extrai a partir do terceiro carácter até o penúltimo caractere da string.</p> + +<pre class="brush: js notranslate">const nome = 'Ricardo'; +console.log(nome.slice(2, -1)); // retorna 'card' +</pre> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Using_slice_to_create_a_new_string" name="Example:_Using_slice_to_create_a_new_string">Exemplo: Usando <code>slice()</code> para criar uma nova string</h3> + +<p>O exemplo a seguir usa <em><code>slice()</code></em> para criar uma nova string.</p> + +<pre class="brush: js notranslate">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> +</pre> + +<h3 id="Example_Using_slice_with_negative_indexes" name="Example:_Using_slice_with_negative_indexes">Exemplo: Usando <code>slice()</code> com índices negativos.</h3> + +<p>O exemplo a seguir usa o <em><code>slice()</code></em> com índices negativos.</p> + +<pre class="brush: js notranslate">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ó' +</pre> + +<p>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.</p> + +<pre class="brush: js notranslate">console.log(str.slice(-11, 16)) // retorna "á sob"</pre> + +<p>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.</p> + +<pre class="brush: js notranslate">console.log(str.slice(10, -7)) // retorna "tá so"</pre> + +<p>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.</p> + +<pre class="brush: js notranslate">console.log(str.slice(-5, -1)) // retorna "e nó"</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>ECMAScript 3rd Edition.</td> + <td>Standard</td> + <td>Initial definition. Implemented in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.13', 'String.prototype.slice')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.slice', 'String.prototype.slice')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_entre_Browsers">Compatibilidade entre Browsers</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.substr()")}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> + <li>{{jsxref("Array.prototype.slice()")}}</li> +</ul> 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 +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>small()</code> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/small" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/small"><small></a></code> que faz com que uma string seja exibida em uma fonte pequena.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.small()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/small" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/small"><small></a></code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>small()</code> cria uma string dentro de uma tag <code><small></code>: <code>"<small>str</small>"</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_small">Usando <code>small()</code></h3> + +<p>O exemplo a seguir usa métodos do objeto global String para alterar o tamanho da string:</p> + +<pre class="brush: js notranslate">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> +</pre> + +<p>Com o objeto <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style">element.style</a> você pode pegar o atributo de estilo do elemento e manipulá-lo de forma mais genérica, por exemplo:</p> + +<pre class="brush: js notranslate">document.getElementById('#oIdDoElemento').style.fontSize = '0.7em'; +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.small', 'String.prototype.small')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.small")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.fontsize()")}}</li> + <li>{{jsxref("String.prototype.big()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code>split()</code> 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.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.split([separator[, limit]])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<ul> + <li>O caso mais simples é quando o separador é apenas um único caractere que será usado para dividir a string. Por exemplo, uma string contendo valores separados por tabulação (TSV) poderia ser analisada passando um caractere de tabulação como separador, como este: myString.split ("\ t").</li> + <li>Se o <code>separator</code> contiver vários caracteres, toda a sequência de caracteres deve ser encontrada para ser dividida.</li> + <li>Se o <code>separator</code> for omitido ou não aparecer dentro da <code>str</code>, o array retornará um elemento consistindo em toda a string.</li> + <li>Se o <code>separator</code> aparecer no início (ou no final) da string, ele ainda terá o efeito de divisão. O resultado é uma string vazia (ou seja, <code>str.length == 0</code>), que aparece na primeira (ou última) posição do array retornado.</li> + <li>Se o <code>separator</code> for uma string vazia (""), <code>str</code> será convertido em um array contendo cada um de seus caracteres em UTF-16.</li> +</ul> + +<dl> + <dt><code>separator</code></dt> + <dd>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)}}.</dd> +</dl> + +<div class="blockIndicator warning"> +<p><strong>Aviso:</strong> Quando uma string vazia (<code>""</code>) é usada como separador, a string não é dividida por caracteres percebidos pelo usuário (<a href="https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries" title="https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries">grapheme clusters</a>) ou caracteres Unicode (pontos de código), mas por unidades de código UTF-16. Isso destrói <a href="http://unicode.org/faq/utf_bom.html#utf16-2" title="http://unicode.org/faq/utf_bom.html#utf16-2">pares substitutos</a>. Consulte “<a href="https://stackoverflow.com/questions/4547609/how-do-you-get-a-string-to-a-character-array-in-javascript/34717402#34717402" title="https://stackoverflow.com/questions/4547609/how-do-you-get-a-string-to-a-character-array-in-javascript/34717402#34717402">Como você transforma uma string em um array de caracteres em JavaScript?” no StackOverflow</a>.</p> +</div> + +<dl> + <dt><code>limite</code></dt> + <dd> + <p>Opcional. Um número inteiro não negativo especificando um limite no número de divisões a serem encontradas. O método <code>split()</code> 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.</p> + + <ul> + <li>O array pode conter menos entradas do que o <code>limit</code> se o final da string for alcançado antes que o limite seja atingido.</li> + <li>Se o <code>limit</code> for <code>0</code>, <code>[]</code> será retornado.</li> + </ul> + </dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Um array de strings divididos em cada ponto onde o separador ocorre na string informada.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Quando encontrado, o caractere designado como o <code>separator</code> é removido da string e as substrings são retornadas em um array. Se o <code>separator</code> não for encontrado ou for omitido, o array irá conter um elemento consistindo da string inteira. Se o <code>separator</code> for uma string vazia, <code>str</code> será convertida em um array de caracteres.</p> + +<p>Se o separador for uma expressão regular que contenha parênteses de captura, cada vez que o <code>separator</code> for encontrado, os resultados (incluindo qualquer resultado <code>undefined</code>) dos parênteses de captura serão emendados ao array de saída. Entretanto, nem todos os navegadores possuem suporte a isso.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_split">Usando <code>split()</code></h3> + +<p>Quando a string está vazia, o <code>split()</code> 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.</p> + +<pre class="brush: js notranslate">const myString = '' +const splits = myString.split() + +console.log(splits); + +// retorna [""]</pre> + +<p>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.</p> + +<pre class="brush: js notranslate">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); +</pre> + +<p>Esse exemplo produz a saída a seguir:</p> + +<pre class="notranslate">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 +</pre> + +<h3 id="Removendo_espaços_de_uma_string">Removendo espaços de uma string</h3> + +<p>No exemplo a seguir, <code>split()</code> 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. <code>nameList</code> é o array retornado como resultado do <code>split()</code>.</p> + +<pre class="brush: js notranslate">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); +</pre> + +<p>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.</p> + +<pre class="notranslate">Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand +[ "Harry Trump", "Fred Barney", "Helen Rigby", "Bill Abel", "Chris Hand " ] +</pre> + +<h3 id="Retornando_um_número_limitado_de_divisões">Retornando um número limitado de divisões</h3> + +<p>No exemplo a seguir, o <code>split()</code> procura por 0 ou mais espaços em uma string e retorna as 3 primeiras divisões que encontrar.</p> + +<pre class="brush: js notranslate">var myString = 'Hello World. How are you doing?'; +var splits = myString.split(' ', 3); + +console.log(splits); +</pre> + +<p>O script exibirá o texto a seguir:</p> + +<pre class="notranslate">["Hello", "World.", "How"] +</pre> + +<h3 id="Parênteses_de_Captura">Parênteses de Captura</h3> + +<p>Se o <code>separator</code> contém parênteses de captura, os resultados correspondentes são retornados no array.</p> + +<pre class="brush: js notranslate">var myString = 'Hello 1 word. Sentence number 2.'; +var splits = myString.split(/(\d)/); + +console.log(splits); +</pre> + +<p>O script exibirá o texto a seguir:</p> + +<pre class="notranslate">[ "Hello ", "1", " word. Sentence number ", "2", "." ] +</pre> + +<div class="blockIndicator note"> +<p><strong>Nota: </strong><code>\d</code> corresponde à classe de caracteres para dígitos entre 0 e 9.</p> +</div> + +<h3 id="Revertendo_uma_String_usando_split">Revertendo uma String usando <code>split()</code></h3> + +<div class="blockIndicator warning"> +<p>Esta não é a mlehor maneira de reverter uma string:</p> + +<pre class="brush: js example-bad notranslate">const str = 'asdfghjkl' +const strReverse = str.split('').reverse().join('') +// 'lkjhgfdsa' + +// split() retorna um array onde os métodos +// reverse() e join() podem ser aplicados</pre> + +<p>Não funciona se a string contém <code>grapheme clusters</code>, mesmo ao usar uma divisão compatível com Unicode. (Use, por exemplo, <a href="https://github.com/mathiasbynens/esrever" title="https://github.com/mathiasbynens/esrever">esrever</a> no lugar.)</p> + +<pre class="brush: js example-bad notranslate">const str = 'résumé' +const strReverse = str.split(/(?:)/u).reverse().join('') +// retorna "́emuśer"</pre> + +<p><strong>Bonus:</strong> use o operador {{jsxref("Operators/Comparison_Operators", "===", "#Identity_strict_equality_(===)")}} para testar se a string original era um palíndromo.</p> +</div> + + + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.14', 'String.prototype.split')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.split', 'String.prototype.split')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.split', 'String.prototype.split')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte Básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte Básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="sect1"></h2> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("Array.prototype.join()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>startsWith()</code></strong> determina se uma string começa com os caracteres especificados, retornando <code>true</code> ou <code>false</code>.</p> + +<p>{{EmbedInteractiveExample("pages/js/string-startswith.html")}}</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.startsWith(<var>searchString</var>[, <var>position</var>])</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><em><code>searchString</code></em></dt> + <dd>Os caracteres a serem procurados a partir do início dessa string.</dd> + <dt><em><code>position</code></em></dt> + <dd>Opcional. A posição nessa string na qual se inicia a busca pela <em><code>searchString</code></em>. O valor padrão é <code>0</code>.</dd> + <dt> + <h3 id="Valor_retornado">Valor retornado</h3> + </dt> +</dl> + +<p><strong><code>true</code></strong> se os caracteres fornecidos forem encontrados no início da string. Se não, <strong><code>false</code></strong>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>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).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_startsWith">Usando <code>startsWith()</code></h3> + +<pre class="brush: js notranslate">//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 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>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 <code>String.prototype.startsWith()</code> adicionando o seguinte código:</p> + +<pre class="notranslate">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; + } + }); +}</pre> + +<p>Um polyfill mais robusto (totalmente conforme com a especificação ES2015), mas com menor desempenho e compacto está disponível <a href="https://github.com/mathiasbynens/String.prototype.startsWith">no GitHub por Mathias Bynens</a>.</p> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{Compat("javascript.builtins.String.startsWith")}}</div> + +<div id="compat-mobile"></div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.endsWith()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> +</ul> 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 +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>strike()</code> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/strike" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/strike"><strike></a></code> que faz com que uma string seja exibida com o texto riscado.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.strike()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/strike" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/strike"><strike></a></code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>strike()</code> cria uma string dentro uma tag <code><strike></code>: "<code><strike>str</strike></code>".</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_strike">Usando <code>strike()</code></h3> + +<p>O exemplo a seguir usa métodos do objeto global String para alterar a formatação da string:</p> + +<pre class="brush: js notranslate">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> +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.strike', 'String.prototype.strike')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.strike")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> +</ul> 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 +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>sub()</code> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sub" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sub"><sub></a></code> que faz com que uma string seja exibida como subscrito (texto pequeno).</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.sub()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sub" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sub"><sub></a></code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>sub()</code> cria uma string dentro de uma tag <code><sub></code>: <code>"<sub>str</sub>"</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_os_métodos_sub_e_sup">Usando os métodos <code>sub()</code> e <code>sup()</code></h3> + +<p>Os exemplos seguintes usam o métodos <code>sub()</code> e {{jsxref("String.prototype.sup()", "sup()")}} para formatar uma string:</p> + +<pre class="brush: js notranslate">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. +</pre> + +<h2 id="Especificação">Especificação</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.sub', 'String.prototype.sub')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.sub', 'String.prototype.sub')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.sup()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code>substr()</code> retorna uma parte da string, começando no índice especificado e estendendo-se por um determinado número de caracteres posteriormente.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-substr.html")}}</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.substr(<var>start</var>[, <var>length</var>])</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>start</code></dt> + <dd>Local para começar a extrair os caracteres.</dd> + <dt><code>length</code></dt> + <dd>Opcional. O número de caracteres a serem extraídos.</dd> +</dl> + +<h3 id="Valor_de_retorno">Valor de retorno</h3> + +<p>Uma nova string contendo a seção extraída da string fornecida.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O <code>substr()</code> extrai caracteres de comprimento de uma <code>str</code>, contando a partir do índice inicial.</p> + +<ul> + <li>Se o <code>start</code> for um número positivo, o índice começa a contar no início da string. Seu valor é limitado ao tamanho da string (<code>str.length</code>).</li> + <li>Se o <code>start</code> for um número negativo, o índice começa a contar a partir do final da string. Seu valor é limitado ao tamanho da string (<code>-str.length</code>).</li> +</ul> + +<div class="blockIndicator note"> +<p><strong>Nota</strong>: No Microsoft JScript, valores negativos no argumento <code>start</code> não são considerados como referência ao final da string.</p> +</div> + +<ul> + <li>Se <code>length</code> for omitido, <code>substr()</code> extrairá caracteres até o final da string.</li> + <li>Se <code>length</code> for {{jsxref("undefined")}}, <code>substr()</code> extrai os caracteres até o final da string.</li> + <li>Se <code>length</code> for um número negativo, ele será tratado como <code>0</code>.</li> + <li>Para <code>start</code> e <code>length</code>, {{jsxref("NaN")}} é tratado como 0.</li> +</ul> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_substr">Usando <code>substr()</code></h3> + +<pre class="brush: js notranslate">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)); // ''</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>JScript da Microsoft não suporta valores negativos para o índice de <code>start</code>. Se você deseja usar esse recurso, você pode usar o seguinte código de compatibilidade para evitar esse erro:</p> + +<pre class="brush: js notranslate">// 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); +} +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Defined in the (informative) Compatibility Annex B. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.3', 'String.prototype.substr')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Defined in the (informative) Compatibility Annex B</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td>Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.substr")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.slice()")}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> +</ul> 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 +--- +<p>{{JSRef("Global_Objects", "String")}}</p> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>O método <code>substring()</code> retorna a parte da string entre os índices inicial e final, ou até o final da string.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.substring(indexStart[, <var>indexEnd</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Parâmetros</h3> + +<dl> + <dt><code>indexStart</code></dt> + <dd>Um inteiro entre <code>0</code> e o comprimento da string (<code>str.length</code>), especificando a posição na string do primeiro caractere a ser incluído na substring retornada.</dd> + <dt><code>indexEnd</code></dt> + <dd>Opcional. Um inteiro entre <code>0</code> e o comprimento da string (<code>str.length</code>), especificando a posição na string do primeiro caractere a <strong>não</strong> ser mais incluído na substring retornada.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova string contendo a parte especificada da string fornecida.</p> + +<h2 id="Description" name="Description">Descrição</h2> + +<p><code>substring()</code> extrai caracteres desde <code><em>indexStart</em></code> até, mas <strong>não</strong> <strong>incluindo</strong>, <code><em>indexEnd</em></code>. Em particular:</p> + +<ul> + <li>Se <code><em>indexStart</em></code> é igual a <code><em>indexEnd</em></code>, <code>substring()</code> retorna uma string vazia.</li> + <li>Se <code><em>indexEnd</em></code> for omitido, <code>substring()</code> extrai caracteres até o fim da string.</li> + <li>Se qualquer argumento for menor que <code>0</code> ou {{jsxref("NaN")}}, ele será tratado como <code>0</code>.</li> + <li>Se qualquer argumento for maior que <code>stringName.length</code>, ele será tratado como se fosse <code>stringName.length</code></li> +</ul> + +<p>Se <code>indexStart</code> for maior que <code>indexEnd</code>, então o efeito do <code>substring()</code> é como se os dois argumentos estivessem trocados, por exemplo, <code><em>str</em>.substring(1, 0) == <em>str</em>.substring(0, 1)</code>.</p> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Using_substring" name="Example:_Using_substring">Usando <code>substring()</code></h3> + +<p>O seguinte exemplo usa <code>substring()</code> para mostrar caracteres da palavra 'Mozilla':</p> + +<pre class="brush:js notranslate">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)); +</pre> + +<h3 id="Usando_substring_com_length">Usando <code>substring()</code> com <code>length</code></h3> + +<p>O exemplo a seguir usa o método <code>substring()</code> 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.</p> + +<pre class="brush: js notranslate">// 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);</pre> + +<h3 id="A_diferença_entre_substring_e_substr">A diferença entre <code>substring()</code> e <code>substr()</code></h3> + +<p>Há uma diferença sutil entre os métodos <code>substring()</code> e {{jsxref("String.substr", "substr()")}}, então você deve ter cuidado para não confundi-los.</p> + +<p>Os argumentos de <code>substring()</code> representam os índices inicial e final, enquanto os argumentos de <code>substr()</code> representam o índice inicial e o número de caracteres a serem incluídos na string retornada.</p> + +<p>Além disso, <code>substr()</code> é considerado um <strong>recurso legacy no ECMAScript </strong>e pode ser removido em versões futuras, portanto, é melhor evitar usá-lo, se possível.</p> + +<pre class="brush: js notranslate">let text = 'Mozilla' +console.log(text.substring(2,5)) // retorna "zil" +console.log(text.substr(2,3)) // retorna "zil"</pre> + +<h3 id="Diferenças_entre_substring_e_slice">Diferenças entre <code>substring()</code> e <code>slice()</code></h3> + +<p>Os métodos <code>substring()</code> 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.</p> + +<p>O método <code>substring()</code> troca seus dois argumentos se <code>indexStart</code> for maior que <code>indexEnd</code>, o que significa que uma string ainda será retornada. O método {{jsxref("String.slice", "slice()")}} retorna uma string vazia caso o mesmo ocorra.</p> + +<pre class="brush: js notranslate">let text = 'Mozilla' +console.log(text.substring(5, 2)) // retorna "zil" +console.log(text.slice(5, 2)) // retorna ""</pre> + +<p>Se um ou ambos os argumentos forem negativos ou <code>NaN</code>, o método <code>substring()</code> os tratará como se fossem <code>0</code>.</p> + +<pre class="brush: js notranslate">console.log(text.substring(-5, 2)) // retorna "Mo" +console.log(text.substring(-5, -2)) // retorna ""</pre> + +<p><code>slice()</code> também trata os argumentos <code>NaN</code> como <code>0</code>, mas quando recebe valores negativos, ele conta regressivamente a partir do final da string para encontrar os índices.</p> + +<pre class="brush: js notranslate">console.log(text.slice(-5, 2)) // retorna "" +console.log(text.slice(-5, -2)) // retorna "zil"</pre> + +<p>Veja a página {{jsxref("String.slice", "slice()")}} para mais exemplos com números negativos.</p> + +<h3 id="Example_Replacing_a_substring_within_a_string" name="Example:_Replacing_a_substring_within_a_string">Substituindo uma <code>substring()</code> com uma string</h3> + +<p>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 "<code style="font-style: normal;">Brave New World</code>" para "<code style="font-style: normal;">Brave New Web</code>".</p> + +<pre class="brush:js notranslate">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");</pre> + +<p>Note que isto pode resultar em um loop infinito se <code>oldS</code> for um substring de <code>newS</code> -- por exemplo, se você tentou substituir "<code>World</code>" com "<code>OtherWorld</code>". O melhor método para substituir strings é o seguinte:</p> + +<pre class="brush:js notranslate">function replaceString(oldS, newS,fullS){ + return fullS.split(oldS).join(newS); +}</pre> + +<p>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 <span style="line-height: 1.5em;">{{jsxref("String.prototype.replace()")}}.</span></p> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Implementado no JavaScript 1.0</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.15', 'String.prototype.substring')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.substring', 'String.prototype.substring')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.substr()")}}</li> + <li>{{jsxref("String.prototype.slice()")}}</li> +</ul> 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 +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code>sup()</code> cria um elemento HTML <code><a class="external external-icon" href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sup" rel="noopener" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sup"><sup></a></code> que faz com que uma string seja exibida como sobrescrito.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.sup()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string contendo um elemento HTML <code><a class="external external-icon" href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sup" rel="noopener" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sup"><sup></a></code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>sup()</code> cria uma string dentro de uma tag <code><sup></code>: <code>"<sup>str</sup>"</code></p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_os_métodos_sub_e_sup">Usando os métodos <code>sub()</code> e <code>sup()</code></h3> + +<p>O exemplo a seguir usa os métodos {{jsxref("String.prototype.sub()", "sub()")}} e <code>sup()</code> para formatar uma string:</p> + +<pre class="brush: js notranslate">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." +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.sup', 'String.prototype.sup')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.sup")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.sup()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code>toLocaleLowerCase()</code> retorna o valor da string em minúsculas, de acordo com qualquer mapeamento de caixa de texto específico da localidade.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-tolocalelowercase.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.toLocaleLowerCase() +<var>str</var>.toLocaleLowerCase(locale) +<var>str</var>.toLocaleLowerCase([locale, locale, ...]) +</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>locale</code></dt> + <dd>Opcional. O parâmetro <code>locale</code> 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 <a href="https://tc39.es/ecma402/#sec-bestavailablelocale" title="https://tc39.es/ecma402/#sec-bestavailablelocale">melhor localidade disponível</a> é usada. A localidade padrão é a localidade atual do ambiente do host.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>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.</p> + +<h3 id="Exceções">Exceções</h3> + +<ul> + <li>Um {{jsxref("RangeError")}} (" invalid language tag: xx_yy ") é lançado se um argumento <code>locale</code> não for uma tag de idioma válido.</li> + <li>Um {{jsxref("TypeError")}} (" invalid element in locales argument ") é lançado se um elemento do array não for do tipo string.</li> +</ul> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>toLocaleLowerCase()</code> retorna o valor da string convertida em minúsculas de acordo com qualquer mapeamento da caixa de texto específico da localidade. <code>toLocaleLowerCase()</code> 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.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toLocaleLowerCase">Usando <code>toLocaleLowerCase()</code></h3> + +<pre class="brush: js notranslate">'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 +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sup-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.toLocaleLowerCase")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code>toLocaleUpperCase()</code> retorna o valor da string em maiúsculas, de acordo com qualquer mapeamento de caixa de texto específico da localidade.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-tolocaleuppercase.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.toLocaleUpperCase() +<var>str</var>.toLocaleUpperCase(locale) +<var>str</var>.toLocaleUpperCase([locale, locale, ...]) +</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>locale</code></dt> + <dd>Opcional. O parâmetro <code>locale</code> 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 <a href="https://tc39.es/ecma402/#sec-bestavailablelocale" title="https://tc39.es/ecma402/#sec-bestavailablelocale">melhor localidade disponível</a> é usada. A localidade padrão é a localidade atual do ambiente do host.</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>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.</p> + +<h3 id="Exceções">Exceções</h3> + +<ul> + <li>Um {{jsxref("RangeError")}} ("invalid language tag: xx_yy") é lançado se um argumento <code>locale</code> não for uma tag de idioma válido.</li> + <li>Um {{jsxref("TypeError")}} ("invalid element in locales argument") é lançado se um elemento do array não for do tipo string.</li> +</ul> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>toLocaleUpperCase()</code> retorna o valor da string convertida em maiúsculas de acordo com qualquer mapeamento de caixa de texto específico da localidade. <code>toLocaleUpperCase()</code> 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.</p> + +<p>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 <code>false</code>:<br> + <code>x.toLocaleLowerCase() === x.toLocaleUpperCase(). toLocaleLowerCase()</code></p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toLocaleUpperCase">Usando <code>toLocaleUpperCase()</code></h3> + +<pre class="brush: js notranslate">'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'</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td> + </tr> + <tr> + <td>{{SpecName('ES Int Draft', '#sup-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.toLocaleUpperCase")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toLowerCase()</code></strong> retorna o valor da string que foi chamada convertido para minúsculo.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.toLowerCase()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova string contendo o valor da string original convertido para minúsculo.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>toLowerCase()</code> retorna o valor da string original convertido para minúsculo. <code>toLowerCase()</code> não altera o valor da string original.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toLowerCase">Usando <code>toLowerCase()</code></h3> + +<pre class="brush: js notranslate">console.log('ALFABETO'.toLowerCase()); // 'alfabeto' +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Estado</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementada no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.16', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Recurso</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte Básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Recurso</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte Básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> 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 +--- +<div>{{JSRef}} {{obsolete_header}}</div> + +<p>O método <code>toSource()</code> retorna uma string que representa o código-fonte do objeto.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code>String.toSource() +<var>str</var>.toSource() +</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string que representa o código-fonte do objeto chamado.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Função_nativa">Função nativa</h3> + +<p>Para o objeto {{jsxref("String")}} , <code>toSource()</code> retorna a seguinte string (indicando que o código-fonte não está disponível):</p> + +<pre class="brush: js notranslate">function String() { + [native code] +} +</pre> + +<p>Ao chamar {{jsxref("String")}} ou string literais, <code>toSource()</code> retorna a string que representa o código-fonte.</p> + +<p>Esse método é usualmente invocado internamente pelo JavaScript e não explicitamente no código.</p> + +<h2 id="Especificação">Especificação</h2> + +<p>Não é parte de nenhum padrão.</p> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>toString()</code></strong> retorna uma string representando o objeto especificado.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.toString()</code></pre> + +<h2 id="Descrição">Descrição</h2> + +<p>O objeto {{jsxref("String")}} substitui o método <code>toString()</code> do objeto {{jsxref("Object")}}. Ele não herda {{jsxref("Object.prototype.toString()")}}. Para objetos {{jsxref("String")}}, o método <code>toString()</code> retorna uma representação de string do objeto e é o mesmo que o método {{jsxref("String.prototype.valueOf()")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_toString">Usando <code>toString()</code></h3> + +<p>O exemplo a seguir exibe o valor string de um objeto {{jsxref("String")}}:</p> + +<pre class="brush: js notranslate">var x = new String('Hello world'); + +console.log(x.toString()); // retorna 'Hello world' +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Estado</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.2', 'String.prototype.toString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tostring', 'String.prototype.toString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.tostring', 'String.prototype.toString')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Funcionalidade</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Funcionalidade</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> + <li>{{jsxref("String.prototype.valueOf()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code>toUpperCase()</code> retorna o valor da string original convertido em letras maiúsculas.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.toUpperCase()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova string representando a string original convertida em maiúsculas.</p> + +<h3 id="Exceções">Exceções</h3> + +<dl> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Quando chamado em uma string contendo valor {{jsxref("null")}} ou {{jsxref("undefined")}}, por exemplo, <code>String.prototype.toUpperCase.call(undefined)</code>.</dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>toUpperCase()</code> retorna o valor da string convertido para letras maiúsculas. <code>toUpperCase()</code> não altera o valor da string original.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Uso_básico">Uso básico</h3> + +<pre class="brush: js notranslate">console.log('alfabeto'.toUpperCase()); // 'ALFABETO' +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.18', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<div>O método <strong><code>trim()</code></strong> remove os espaços em branco (<a href="/pt-BR/docs/DOM/Referencia_do_DOM/Whitespace_in_the_DOM">whitespaces</a>) 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.).</div> + +<div></div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.trim()</code></pre> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>trim()</code> retorna o texto sem espaços em branco no início e/ou fim da string. O <code>trim()</code> não altera o valor da string original.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_trim">Usando <code>trim()</code></h3> + +<p>Os exemplos a seguir retornam o valor de <code>'foo'</code> sem espaços em branco:</p> + +<pre class="brush: js notranslate">//.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' +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Executar o seguinte código antes antes de qualquer código irá criar o método <code>trim()</code> se o mesmo não estiver disponível nativamente.</p> + +<pre class="brush: js notranslate">if (!String.prototype.trim) { + String.prototype.trim = function () { + return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ''); + }; +} +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.20', 'String.prototype.trim')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definição inicial. Implementado no JavaScript 1.8.1.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("1.9.1")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("10.5")}}</td> + <td>{{CompatSafari("5")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</li> + <li>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code>trimEnd()</code> remove espaços do final de uma <em>string</em>. <code>trimRight()</code> é um apelido para este método.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-trimend.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.trimEnd(); +<var>str</var>.trimRight();</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova <em>string </em>representando a <em>string</em> original sem espaços ao seu final (direita).</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Os métodos <code>trimEnd()</code> / <code>trimRight()</code> retornam a <em>string</em> sem os espaços à direita dela. <code>trimEnd()</code> ou <code>trimRight()</code> não altera o valor da <em>string</em> original.</p> + +<h3 id="Aliasing"><em>Aliasing</em></h3> + +<p>Para consistência com funções como {{jsxref("String.prototype.padEnd")}} o nome padrão do método é <code>trimEnd</code>. Entretanto, por razões de compatibilidade na <em>web</em>, <code>trimRight</code> permanece como um apelido para <code>trimEnd</code>. Em alguns motores isso significa:</p> + +<pre class="brush: js notranslate">String.prototype.trimRight.name === "trimEnd";</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_trimEnd">Usando <code>trimEnd()</code></h3> + +<p>O exemplo a seguir mostra a <em>string</em> em caixa baixa <code>' foo'</code>:</p> + +<pre class="brush: js; highlight: [5] notranslate">var str = ' foo '; + +console.log(str.length); // retorna 8 + +str = str.trimEnd(); +console.log(str.length); // retorna 6 +console.log(str); // retorna ' foo' +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificação</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.trimend', 'String.prototype.trimEnd')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.trimEnd")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.trim()")}}</li> + <li>{{jsxref("String.prototype.trimStart()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code>trimStart()</code> remove espaços do começo de uma <em>string</em>. <code>trimLeft()</code> é um apelido para este método.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-trimstart.html")}}</div> + + + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><var>str</var>.trimStart(); +<var>str</var>.trimLeft();</pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma nova <em>string</em> representando a <em>string</em> original sem os espaços no começo (fim à esquerda).</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Os métodos <code>trimStart()</code> / <code>trimLeft()</code> retornam a <em>string</em> sem os espaços no fim à esquerda. <code>trimLeft()</code> ou <code>trimStart()</code> não altera o valor da <em>string</em> original.</p> + +<h3 id="Aliasing"><em>Aliasing</em></h3> + +<p>Para consistência com funções como {{jsxref("String.prototype.padStart")}} o nome padrão do método é <code>trimStart</code>. Entretanto, por razões de compatibilidade na <em>web</em>, <code>trimLeft</code> permanece como um apelido para <code>trimStart</code>. Em alguns motores isso significa:</p> + +<pre class="brush: js notranslate">String.prototype.trimLeft.name === "trimStart";</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js; highlight: [5] notranslate">//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); +*/</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_trimStart">Usando <code>trimStart()</code></h3> + +<p>O seguinte exemplo mostra uma <em>string</em> em caixa baixa <code>'foo '</code>:</p> + +<pre class="brush: js; highlight: [5] notranslate">var str = ' foo '; + +console.log(str.length); // retorna 8 + +str = str.trimStart(); +console.log(str.length); // retorna 5 +console.log(str); // retorna 'foo ' +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificação</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.trimstart', ' String.prototype.trimStart')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.trimStart")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.trim()")}}</li> + <li>{{jsxref("String.prototype.trimEnd()")}}</li> +</ul> 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 +--- +<div>{{JSRef}}</div> + +<p>O método <code>valueOf()</code> retorna o valor primitivo de um objeto {{jsxref("String")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/string-valueof.html")}}</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>str</var>.valueOf()</code></pre> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Uma string representando o valor primitivo de um objeto {{jsxref("String")}}.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>valueOf()</code> 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()")}}.</p> + +<p>Esse método é normalmente chamado internamente pelo JavaScript e não fica explícito no código.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_valueOf">Usando <code>valueOf()</code></h3> + +<pre class="brush: js notranslate">var x = new String('Olá, mundo'); +console.log(x.valueOf()); // retorna 'Olá, mundo' +</pre> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Status</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definição inicial implementada no JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.3', 'String.prototype.valueOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.valueof', 'String.prototype.valueOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.valueof', 'String.prototype.valueOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2> + +<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> + +<p>{{Compat("javascript.builtins.String.valueOf")}}</p> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.toString()")}}</li> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> +</ul> |