diff options
Diffstat (limited to 'files/pt-br/web/javascript/reference/global_objects/regexp')
6 files changed, 1267 insertions, 0 deletions
diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/compile/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/compile/index.html new file mode 100644 index 0000000000..de36469d18 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/compile/index.html @@ -0,0 +1,84 @@ +--- +title: RegExp.prototype.compile() +slug: Web/JavaScript/Reference/Global_Objects/RegExp/compile +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/compile +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>O método <code><strong>compile</strong></code><strong><code>()</code></strong> <span class="tlid-translation translation" lang="pt"><span title=""> está depreciado, é usado para (re-)compilar uma expressão regular durante a execução de um script.</span></span> <span class="tlid-translation translation" lang="pt"><span title="">É basicamente o mesmo que o construtor </span></span> <code>RegExp</code>.</p> + +<h2 id="Sintaxe"><span class="tlid-translation translation" lang="pt"><span title="">Sintaxe</span></span></h2> + +<pre class="syntaxbox"><code><var>regexObj</var>.compile(<var>pattern, flags</var>)</code></pre> + +<h3 id="Parâmetros"><span class="tlid-translation translation" lang="pt"><span title="">Parâmetros</span></span></h3> + +<dl> + <dt><code>pattern</code></dt> + <dd> <span class="tlid-translation translation" lang="pt"><span title="">É o texto da expressão regular</span></span>.</dd> + <dt><code>flags</code></dt> + <dd> + <p><span class="tlid-translation translation" lang="pt"><span title="">Se especificado, as flags podem ter qualquer combinação dos seguintes valores</span></span>:</p> + + <dl> + <dt><code>g</code></dt> + <dd>global.</dd> + <dt><code>i</code></dt> + <dd><span class="tlid-translation translation" lang="pt"><span title="">ignorar caso.</span></span></dd> + <dt><code>m</code></dt> + <dd><span class="tlid-translation translation" lang="pt"><span title="">multilinha;</span> <span title="">trata os caracteres iniciais e finais como (^ e $), trabalhando sobre várias linhas (isto é, corresponde ao início ou ao final de cada linha (delimitado por \n ou \r), não apenas o começo, ou o final de toda a cadeia de entrada).</span></span></dd> + <dt><code>y</code></dt> + <dd>sticky; <span class="tlid-translation translation" lang="pt"><span title="">corresponde apenas ao índice indicado pela propriedade</span></span> <code>lastIndex</code> <span class="tlid-translation translation" lang="pt"><span title="">dessa expressão regular na cadeia de destino (e não tenta corresponder a partir de índices posteriores).</span></span></dd> + </dl> + </dd> +</dl> + +<h2 id="Descrição"><span class="tlid-translation translation" lang="pt"><span title="">Descrição</span></span></h2> + +<p> <span class="tlid-translation translation" lang="pt"><span title="">O método de</span></span> <code>compilação</code> <span class="tlid-translation translation" lang="pt"><span title="">é obsoleto.</span> </span> <span class="tlid-translation translation" lang="pt"><span title="">Você pode simplesmente usar o construtor </span></span> <code>RegExp</code> <span class="tlid-translation translation" lang="pt"><span title="">para obter o mesmo efeito.</span></span></p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_compile()"><span class="tlid-translation translation" lang="pt"><span title="">Usando</span></span> <code>compile()</code></h3> + +<p><span class="tlid-translation translation" lang="pt"><span title="">O exemplo a seguir mostra como recompilar uma expressão regular com um novo padrão e um nova </span></span>flag.</p> + +<pre class="brush: js">var regexObj = new RegExp('foo', 'gi'); +regexObj.compile('new foo', 'g'); +</pre> + +<h2 id="Especificações"><span class="tlid-translation translation" lang="pt"><span title="">Especificações</span></span></h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col"><span class="tlid-translation translation" lang="pt"><span title="">Especificação</span></span></th> + <th scope="col">Estado</th> + <th scope="col">Comentario</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}}</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="Browser_compativeis">Browser compativeis</h2> + +<div> + + +<p>{{Compat("javascript.builtins.RegExp.compile")}}</p> +</div> + +<h2 id="Veja_também"><span class="tlid-translation translation" lang="pt"><span title="">Veja também</span></span></h2> + +<ul> + <li>{{jsxref("RegExp")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/exec/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/exec/index.html new file mode 100644 index 0000000000..b5f722a55d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/exec/index.html @@ -0,0 +1,230 @@ +--- +title: RegExp.prototype.exec() +slug: Web/JavaScript/Reference/Global_Objects/RegExp/exec +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/exec +--- +<div>{{JSRef}}</div> + +<p>O método <strong><code>exec()</code></strong> executa a busca por um padrão em uma determinada string. Retorna um array, ou {{jsxref("null")}}.</p> + +<p>Se você está precisa somente de um retorno verdadeiro/falso, use o método {{jsxref("RegExp.prototype.test()")}} ou {{jsxref("String.prototype.search()")}}.</p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox"><var>regexObj</var>.exec(<var>string</var>)</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>string</code></dt> + <dd>A string para comparar com a expressão regular</dd> +</dl> + +<h3 id="Valor_retornado">Valor retornado</h3> + +<p>Se a combinação acontecer, o método <code>exec() </code>o método retorna um array e atualiza as propriedades do objeto da expressão regular. Esse array retornado possui o texto combinado como primeiro item e depois um item para cada captura contendo o respectivo texto.</p> + +<p>Se falhar, o retorno do método <code>exec()</code> será {{jsxref("null")}}.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Considere o exemplo abaixo:</p> + +<pre class="brush: js">// Encontra combinações "quick brown" seguido de "jumps", ignorando caracteres entre eles +// Relembra "brown" e "jumps" +// Ignora caixa (maiúsculo e minúsculo) +var re = /quick\s(brown).+?(jumps)/ig; +var result = re.exec('The Quick Brown Fox Jumps Over The Lazy Dog'); +</pre> + +<p>A tabela a seguir provê os resultados do script:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Objeto</td> + <td class="header">Propriedade/Índice</td> + <td class="header">Descrição</td> + <td class="header">Exemplo</td> + </tr> + <tr> + <td rowspan="4"><code>result</code></td> + <td><code>[0]</code></td> + <td>A string completa dos caracteres encontrados</td> + <td><code>Quick Brown Fox Jumps</code></td> + </tr> + <tr> + <td><code>[1], ...[<em>n</em> ]</code></td> + <td>As combinações de substrings parametrizadas encontradas, se existir. A quantidade de possíveis substrings parametrizadas é ilimitado.</td> + <td><code>[1] = Brown<br> + [2] = Jumps</code></td> + </tr> + <tr> + <td><code>index</code></td> + <td> + <p>O índice base 0 do valor encontrado na string.</p> + </td> + <td><code>4</code></td> + </tr> + <tr> + <td><code>input</code></td> + <td>String original</td> + <td><code>The Quick Brown Fox Jumps Over The Lazy Dog</code></td> + </tr> + <tr> + <td rowspan="5"><code>re</code></td> + <td><code>lastIndex</code></td> + <td>O índice que começa a próxima combinação encontrada. Quando "<code>g</code>" não é definido, este valor será sempre 0.</td> + <td><code>25</code></td> + </tr> + <tr> + <td><code>ignoreCase</code></td> + <td>Indica se a flag "<code>i</code>" foi usada para ignorar caixa alta/baixa.</td> + <td><code>true</code></td> + </tr> + <tr> + <td><code>global</code></td> + <td>Indica se a flag "<code>g</code>" foi usada para encontrar combinações de forma global.</td> + <td><code>true</code></td> + </tr> + <tr> + <td><code>multiline</code></td> + <td>Indica se a flag "<code>m</code>" foi usada para pesquisar em strings de diversas linhas.</td> + <td><code>false</code></td> + </tr> + <tr> + <td><code>source</code></td> + <td>Texto do padrão.</td> + <td><code>quick\s(brown).+?(jumps)</code></td> + </tr> + </tbody> +</table> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Procurando_combinações_sucessivas">Procurando combinações sucessivas</h3> + +<p>If your regular expression uses the "<code>g</code>" flag, you can use the <code>exec()</code> method multiple times to find successive matches in the same string. When you do so, the search starts at the substring of <code>str</code> specified by the regular expression's {{jsxref("RegExp.lastIndex", "lastIndex")}} property ({{jsxref("RegExp.prototype.test()", "test()")}} will also advance the {{jsxref("RegExp.lastIndex", "lastIndex")}} property). For example, assume you have this script:</p> + +<pre class="brush: js">var myRe = /ab*/g; +var str = 'abbcdefabh'; +var myArray; +while ((myArray = myRe.exec(str)) !== null) { + var msg = 'Found ' + myArray[0] + '. '; + msg += 'Next match starts at ' + myRe.lastIndex; + console.log(msg); +} +</pre> + +<p>This script displays the following text:</p> + +<pre>Found abb. Next match starts at 3 +Found ab. Next match starts at 9 +</pre> + +<p>Note: Do not place the regular expression literal (or {{jsxref("RegExp")}} constructor) within the <code>while</code> condition or it will create an infinite loop if there is a match due to the {{jsxref("RegExp.lastIndex", "lastIndex")}} property being reset upon each iteration. Also be sure that the global flag is set or a loop will occur here also.</p> + +<h3 id="Usando_exec()_com_RegExp_literais">Usando <code>exec()</code> com <code>RegExp</code> literais</h3> + +<p>You can also use <code>exec()</code> without creating a {{jsxref("RegExp")}} object:</p> + +<pre class="brush: js">var matches = /(hello \S+)/.exec('This is a hello world!'); +console.log(matches[1]); +</pre> + +<p>This will log a message containing 'hello world!'.</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition. Implemented in JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.10.6.21', 'RegExp.exec')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-regexp.prototype.exec', 'RegExp.exec')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-regexp.prototype.exec', 'RegExp.exec')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Funcionalidade</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>Funcionalidade</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="Veja_também">Veja também</h2> + +<ul> + <li>O capítulo de <a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Expressões Regulares</a> no <a href="/pt-BR/docs/Web/JavaScript/Guide">Guia de Javascript</a>.</li> + <li>{{jsxref("RegExp")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/ignorecase/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/ignorecase/index.html new file mode 100644 index 0000000000..e6f55b596f --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/ignorecase/index.html @@ -0,0 +1,70 @@ +--- +title: RegExp.prototype.ignoreCase +slug: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase +tags: + - JavaScript + - Referencia + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase +--- +<div>{{JSRef}}</div> + +<div>O atributo <strong><code>ignoreCase</code></strong> indica se a flag "i" foi ou não utilizada com a expressão regular.</div> + +<div><code>ignoreCase</code> é um atributo somente leitura de uma instância individual de expressão</div> + +<div>regular. </div> + +<div></div> + +<p>{{EmbedInteractiveExample("pages/js/regexp-prototype-ignorecase.html")}}</p> + + + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>O valor de <code>ignoreCase</code> é um {{jsxref("Boolean")}} e<code>true</code> se a flag "<code>i</code>" foi usada; <code>false</code> caso contrário. A flag "i" indica que maiúsculas e minúsculas são equivalentes ao se tentar casar uma string com a expressão regular.</p> + +<p>Você não pode alterar essa propriedade diretamente.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_ignoreCase">Usando <code>ignoreCase</code></h3> + +<pre class="brush: js notranslate">var regex = new RegExp('foo', 'i'); + +console.log(regex.ignoreCase); // 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-get-regexp.prototype.ignorecase', 'RegExp.prototype.ignoreCase')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2> + +<div> + + +<p>{{Compat("javascript.builtins.RegExp.ignoreCase")}}</p> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("RegExp.lastIndex")}}</li> + <li>{{jsxref("RegExp.prototype.global")}}</li> + <li>{{jsxref("RegExp.prototype.multiline")}}</li> + <li>{{jsxref("RegExp.prototype.source")}}</li> + <li>{{jsxref("RegExp.prototype.sticky")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/index.html new file mode 100644 index 0000000000..99ff4a626d --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/index.html @@ -0,0 +1,636 @@ +--- +title: RegExp +slug: Web/JavaScript/Reference/Global_Objects/RegExp +tags: + - Construtor + - Expressões Regulares + - JavaScript + - Referencia + - RegExp +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp +--- +<div>{{JSRef("Global_Objects", "RegExp")}}</div> + +<h2 id="Sumário">Sumário</h2> + +<p>O construtor <strong><code>RegExp</code></strong> cria um objeto de expressão regular para realizar uma correspondência de texto com um padrão.</p> + +<p>Para uma introdução à expressões regulares, leia o <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">capítulo de Expressões Regulares</a> no <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide">Guia de JavaScript</a>.</p> + +<h2 id="Syntax" name="Syntax">Construtor</h2> + +<p>Notações literais e de construtores são possíveis:</p> + +<pre class="syntaxbox"><code><em>/padrão/<var>flags</var></em> +new RegExp(<em>padrão</em>[, <var>flags</var>]) +RegExp(<em>padrão</em>[, <var>flags</var>])</code> +</pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>padrão</code></dt> + <dd>O texto da expressão regular, ou como em ES5, outro objeto RegExp. Os padrões podem incluir caracteres especiais para correspondencia em um intervalo maior de valores do que uma string literal.</dd> + <dt><code>flags</code></dt> + <dd> + <p>Se especificado, <kbd>flags</kbd>indica os marcadores que podem ser adicionados, ou se um objeto é suficiente para o padrão, os valores de flags serão substituidos por qualquer uma das flags de objetos. O valor de <kbd>flags</kbd>é uma string contendo qualquer combinação dos seguintes valores:</p> + + <dl> + <dt><code>g</code></dt> + <dd>corresponder globalmente; acha <strong>todas</strong> as correspondências em vez de parar após achar a primeira</dd> + <dt><code>i</code></dt> + <dd>ignorar maiúsc./minúsc.; Se a <em>flag <kbd>u</kbd></em> estiver ativa, deve ser utilizado o <em>Unicode case folding</em></dd> + <dt><code>m</code></dt> + <dd>multilinha; trata caracteres de início e fim (^ e $) ao operar sobre múltiplas linhas (ou seja, corresponder o início ou fim de <em>cada</em> linha (delimitado por \n ou \r), e não apenas o começo ou fim de toda a string de entrada)</dd> + </dl> + + <dl> + <dt><code>u </code>{{experimental_inline}}</dt> + <dd>unicode; trata o padrão como uma sequência de código unicode</dd> + </dl> + + <dl> + <dt><code>y</code> {{experimental_inline}}</dt> + <dd>aderente; corresponde apenas pelo index indicado pela propriedade <code>lastIndex</code> dessa expressão regular na string alvo (e não tenta corresponder de qualquer indexes posteriores).</dd> + </dl> + </dd> +</dl> + +<h2 id="Descrição">Descrição</h2> + +<p>Há dois modos de criar um objeto <code>RegExp</code>: uma notação literal e um construtor. Para indicar strings, os parâmetros para a notação literal não usam aspas, enquanto os parâmetros para a função do construtor usam. Então, as seguintes expressões criam a mesma expressão regular:</p> + +<pre class="brush: js">/ab+c/i; +new RegExp('ab+c', 'i'); +</pre> + +<p>A notação literal compila a expressão regular em tempo de execução. Use a notação literal quando a expressão regular permanecerá constante. Por exemplo, se você usar a notação literal para construir a expressão regular usada em um <em>loop</em>, a expressão regular não será recompilada a cada iteração</p> + +<p>O construtor do objeto da expressão regular, por exemplo, <code>new RegExp('ab+c')</code>, fornece uma compilação em tempo de execução da expressão regular. Use a função construtora quando você sabe que o padrão da expressão regular será mudado, ou você não sabe o padrão e o está recebendo de outra fonte, como uma entrada do usuário.</p> + +<p>Começando com ECMAScript 6, <code>new RegExp(/ab+c/, 'i')</code>, deixou de lançar um {{jsxref("TypeError")}} ("can't supply flags quando constructing one RegExp from another") quando o primeiro argumento é um <code>RegExp</code> e o segundo argumento <code>flags</code> está presente. Uma nova <code>RegExp</code> dos argumentos é criada ao invés disso.</p> + +<p>Quando se usa a função construtora, as regras de escapar em uma string (preceder caracteres especiais com \ quando incluídos na string) são necessárias. Por exemplo, as declarações a seguir são equivalentes:</p> + +<pre class="brush: js">var re = /\w+/; +var re = new RegExp('\\w+'); +</pre> + +<h2 id="Special_characters_meaning_in_regular_expressions" name="Special_characters_meaning_in_regular_expressions">Significado dos caracteres especiais nas expressões regulares</h2> + +<ul> + <li><a href="#character-classes">Classes de Caracteres</a></li> + <li><a href="#character-sets">Conjuntos de Caracteres</a></li> + <li><a href="#boundaries">Limites</a></li> + <li><a href="#grouping-back-references">Agrupamentos e back references</a></li> + <li><a href="#quantifiers">Quantificadores</a></li> +</ul> + +<table class="fullwidth-table"> + <tbody> + <tr id="character-classes"> + <th colspan="2">Classes de Caracteres</th> + </tr> + <tr> + <th>Caractere</th> + <th>Significado</th> + </tr> + <tr> + <td><code>.</code></td> + <td> + <p>(O ponto) corresponde um único caracter qualquer <em>exceto</em> os caracteres de nova linha: <code>\n</code>, <code>\r</code>, <code>\u2028</code> ou <code>\u2029</code>.</p> + + <p>Note que a flag multilinha <code>m</code> não muda o comportamento do ponto. Então para corresponder um padrão por múltiplas linhas, o conjunto de caracteres <code>[^]</code> pode ser usado, que corresponderá qualquer caractere, incluindo novas linhas.</p> + + <p>Por exemplo, <code>/.y/</code> corresponde "my" e "ay", mas não "yes", em "yes make my day".</p> + </td> + </tr> + <tr> + <td><code>\d</code></td> + <td> + <p>Corresponde um caractere de dígito no alfabeto basic Latin. Equivalente <code>a [0-9]</code>.</p> + + <p>Por exemplo, <code>/\d/</code> ou <code>/[0-9]/</code> corresponde "2" em "B2 é o número da suíte".</p> + </td> + </tr> + <tr> + <td><code>\D</code></td> + <td> + <p>Corresponde qualquer caractere que não é um dígito no alfabeto basic Latin. Equivalente a <code>[^0-9]</code>.</p> + + <p>Por exemplo, <code>/\D/</code> ou <code>/[^0-9]/</code> corresponde "B" em "B2 é o suite number".</p> + </td> + </tr> + <tr> + <td><code>\w</code></td> + <td> + <p>Corresponde qualquer caractere alfanumérico do alfabeto basic Latin, incluindo o underline. Equivalente a <code>[A-Za-z0-9_]</code>.</p> + + <p>Por exemplo, <code>/\w/</code> corresponde "a" em "apple", "5" em "$5.28", e "3" em "3D".</p> + </td> + </tr> + <tr> + <td><code>\W</code></td> + <td> + <p>Corresponde qualquer caractere que não é um alfanumérico do alfabeto basic Latin. Equivalente a <code>[^A-Za-z0-9_]</code>.</p> + + <p>Por exemplo, <code>/\W/</code> ou <code>/[^A-Za-z0-9_]/</code> corresponde "%" em "50%".</p> + </td> + </tr> + <tr> + <td><code>\s</code></td> + <td> + <p>Corresponde um único caractere de espaço em branco, incluindo espaço, tabulação (tab), quebra de página, nova linha (LF) e outros espaços Unicode. Equivalente a <code>[ \f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]</code>.</p> + + <p>Por exemplo, <code>/\s\w*/</code> corresponde " bar" em "foo bar".</p> + </td> + </tr> + <tr> + <td><code>\S</code></td> + <td> + <p>Corresponde um único caractere que não seja um espaço em branco. Equivalente a <code>[^ \f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]</code>.</p> + + <p>Por exemplo, <code>/\S\w*/</code> corresponde "foo" em "foo bar".</p> + </td> + </tr> + <tr> + <td><code>\t</code></td> + <td>Corresponde uma tabulação.</td> + </tr> + <tr> + <td><code>\r</code></td> + <td>Corresponde uma quebra de linha.</td> + </tr> + <tr> + <td><code>\n</code></td> + <td>Corresponde uma nova linha.</td> + </tr> + <tr> + <td><code>\v</code></td> + <td>Corresponde uma tabulação vertical.</td> + </tr> + <tr> + <td><code>\f</code></td> + <td>Corresponde uma quebra de página.</td> + </tr> + <tr> + <td><code>[\b]</code></td> + <td>Corresponde um caracter backspace. (Não confundir com <code>\b</code>)</td> + </tr> + <tr> + <td><code>\0</code></td> + <td>Corresponde um caractere NUL. Não coloque outro dígito seguinte a esse.</td> + </tr> + <tr> + <td><code>\c<em>X</em></code></td> + <td> + <p>Onde <code><em>X</em></code> é uma letra de A - Z. Corresponde um caractere de controle em uma string.</p> + + <p>Por exemplo, <code>/\cM/</code> corresponde control-M em uma string.</p> + </td> + </tr> + <tr> + <td><code>\x<em>hh</em></code></td> + <td>Corresponde o caractere com o código <code><em>hh</em></code> (dois dígitos hexadecimais).</td> + </tr> + <tr> + <td><code>\u<em>hhhh</em></code></td> + <td>Corresponde o caractere com o valor Unicode <code><em>hhhh</em></code> (quatro dígitos hexadecimais).</td> + </tr> + <tr> + <td><code>\</code></td> + <td> + <p>Para caracteres que são geralmente tratados literalmente, indica que o próximo caractere é especial e não deve ser interpretado literalmente.</p> + + <p>Por exemplo, <code>/b/</code> corresponde o caractere "b". Colocando uma barra invertida antes do "b", ou seja, usando <code>/\b/</code>, o caractere se torna especial, significando corresponder o limite de uma palavra.</p> + + <p><em>ou</em></p> + + <p>Para caracteres que são geralmente tratados especialmente, indica que o próximo caractere não é especial e deve ser interpretado literalmente.</p> + + <p>Por exemplo, "*" é um caractere especial que significa 0 ou mais ocorrências do caractere precedente devem ser correspondidas; por exemplo, <code>/a*/</code> significa corresponder 0 ou mais "a"s. Para corresponder <code>*</code> literalmente, preceda-o com uma barra invertida; por exemplo, <code>/a\*/</code> corresponde "a*".</p> + </td> + </tr> + </tbody> + <tbody> + <tr id="character-sets"> + <th colspan="2">Conjuntos de Caracteres</th> + </tr> + <tr> + <th>Caractere</th> + <th>Significado</th> + </tr> + <tr> + <td><code>[xyz]</code></td> + <td> + <p>Um conjunto de caracteres. Corresponde qualquer um dos caracteres cercados. Você pode especificar uma extensão de caracteres usando um hífen.</p> + + <p>Por exemplo, <code>[abcd]</code> é o mesmo que <code>[a-d]</code>. Eles correspondem o "b" em "banco" e o "c" em "cortar".</p> + </td> + </tr> + <tr> + <td><code>[^xyz]</code></td> + <td> + <p>Um conjunto de caracteres negativo ou complementado. Isto é, corresponde qualquer coisa que não esteja cercada nos colchetes. Você pode especificar uma extensão de caracteres usando um hífen.</p> + + <p>Por exemplo, <code>[^abc]</code> é o mesmo que <code>[^a-c]</code>. Eles inicialmente correspondem "n" em "banco" e "o" em "cortar".</p> + </td> + </tr> + </tbody> + <tbody> + <tr id="boundaries"> + <th colspan="2">Limites</th> + </tr> + <tr> + <th>Caractere</th> + <th>Significado</th> + </tr> + <tr> + <td><code>^</code></td> + <td> + <p>Corresponde o início de uma entrada. Se a flag multilinha é utilizada, também corresponde imediatamente após um caractere de quebra de linha.</p> + + <p>Por exemplo, <code>/^A/</code> não corresponde o "A" em "an A", mas corresponde o primeiro "A" em "An A".</p> + </td> + </tr> + <tr> + <td><code>$</code></td> + <td> + <p>Corresponde o fim de uma entrada. Se a flag multilinha é utilizada, também corresponde imediatamente antes de um caractere de quebra de linha.</p> + + <p>Por exemplo, <code>/o$/</code> não corresponde o "o" em "cantor", mas corresponde em "canto".</p> + </td> + </tr> + <tr> + <td><code>\b</code></td> + <td> + <p>Corresponde um limite de palavra de largura zero, como entre uma letra e um espaço. (Não confundir com <code>[\b]</code>)</p> + + <p>Por exemplo, <code>/\bno/</code> corresponde o "no" em "de noite"; <code>/ly\b/</code> corresponde o "ly" em "possibly yesterday".</p> + </td> + </tr> + <tr> + <td><code>\B</code></td> + <td> + <p>Corresponde um limite de uma não palavra de largura zero, como entre duas letras ou entre dois espaços.</p> + + <p>Por exemplo, <code>/\Bte/</code> corresponde "te" em "de noite", e <code>/on\B/</code> corresponde "on" em "possivelmente ontem".</p> + </td> + </tr> + </tbody> + <tbody> + <tr id="grouping-back-references"> + <th colspan="2">Agrupamentos e back references</th> + </tr> + <tr> + <th>Caractere</th> + <th>Significado</th> + </tr> + <tr> + <td><code>(<em>x</em>)</code></td> + <td> + <p>Corresponde <code><em>x</em></code> e memoriza a correspondência. Esses são chamados parênteses de captura.</p> + + <p>Por exemplo, <code>/(foo)/</code> corresponde e memoriza "foo" em "foo bar". A substring correspondida pode ser chamada novamente dos elementos do array resultante <code>[1], ..., [n]</code> ou das propriedades predefinidas do objeto <code>RegExp</code> <code>$1, ..., $9</code>.</p> + + <p>Grupos de captura têm uma falta na performance. Se você não necessita que a substring correspondida seja chamada novamente, prefira parênteses de não-captura (veja mais abaixo).</p> + </td> + </tr> + <tr> + <td><code>\<em>n</em></code></td> + <td> + <p>Onde <code><em>n</em></code> é um inteiro positivo. A back reference to o last substring matching o n parenthetical no expressão regular (counting left parentheses).</p> + + <p>Por exemplo, <code>/apple(,)\sorange\1/</code> corresponde "apple, orange," em "apple, orange, cherry, peach". Um exemplo mais completo está a seguir nesta tabela.</p> + </td> + </tr> + <tr> + <td><code>(?:<em>x</em>)</code></td> + <td>Corresponde <code><em>x</em></code> mas não memoriza a correspondência. Esses são chamados parênteses de não-captura. A substring correspondida não pode ser chamada novamente dos elementos do array resultante <code>[1], ..., [n]</code> ou das propriedades predefinidas do objeto <code>RegExp</code> <code>$1, ..., $9</code>.</td> + </tr> + </tbody> + <tbody> + <tr id="quantifiers"> + <th colspan="2">Quantificadores</th> + </tr> + <tr> + <th>Caractere</th> + <th>Significado</th> + </tr> + <tr> + <td><code><em>x</em>*</code></td> + <td> + <p>Corresponde o item precedente <em>x</em> zero ou mais vezes.</p> + + <p>Por exemplo, <code>/assusto*/</code> corresponde "assustoooo" em "Um fantasma assustoooou" e "assust" em "Não me assustei", mas nada em "Um bode grunhiu".</p> + + <p>Note que no caso acima, o único caractere a ser selecionado é "o", pois ele é o caractere imediatamente anterior ao asterisco e não há qualquer operador de agrupamento que indique que mais caracteres deveriam ser submetidos à repetição. Se quiséssemos selecionar a ocorrência sequencial da palavra completa "blah", por exemplo, poderíamos utilizar algum agrupamento como <code>/(blah)*/</code> o que geraria a seleção de "blahblahblah" na frase "blahblahblah ração para gatos" ou de "blah" na frase "algoritmo blahut-arimoto".</p> + </td> + </tr> + <tr> + <td><code><em>x</em>+</code></td> + <td> + <p>Corresponde o item precedente <em>x</em> uma ou mais vezes. Equivalente a <code>{1,}</code>.</p> + + <p>Por exemplo, <code>/a+/</code> corresponde o "o" em "doce" e todos os "o"s em "doooooooce".</p> + </td> + </tr> + <tr> + <td><code><em>x</em>?</code></td> + <td> + <p>Corresponde o item precedente <em>x</em> nenhuma ou uma vez.</p> + + <p>Por exemplo, <code>/e?le?/</code> corresponde o "el" em "angel" e o "le" em "angle."</p> + + <p>If used imediatamente after qualquer dos quantifiers <code>*</code>, <code>+</code>, <code>?</code>, ou <code>{}</code>, makes o quantifier non-greedy (matching o minimum number of vezes), como opposed to o default, which é greedy (matching o maximum number of vezes).</p> + + <p>Also used em lookahead assertions, described under <code>(?=)</code>, <code>(?!)</code>, e <code>(?:)</code> em this table.</p> + </td> + </tr> + <tr> + <td><code><em>x</em>(?=<em>y</em>)</code></td> + <td>Corresponde <code><em>x</em></code> apenas se <code><em>x</em></code> é seguido por <code><em>y</em></code>. Por exemplo, <code>/Jack(?=Sprat)/</code> corresponde "Jack" apenas se for seguido por "Sprat". <code>/Jack(?=Sprat|Frost)/</code> corresponde "Jack" apenas se for seguido por "Sprat" ou "Frost". Porém, nem "Sprat" nem "Frost" são partes do resultado da correspondência.</td> + </tr> + <tr> + <td><code><em>x</em>(?!<em>y</em>)</code></td> + <td> + <p>Corresponde <code><em>x</em></code> apenas se <code><em>x</em></code> não é seguido por <code><em>y</em></code>. Por exemplo, <code>/\d+(?!\.)/</code> corresponde um número apenas se não for seguido por um ponto.</p> + + <p><code>/\d+(?!\.)/.exec('3.141')</code> corresponde "141", mas não "3.141".</p> + </td> + </tr> + <tr> + <td><code><em>x</em>|<em>y</em></code></td> + <td> + <p>Corresponde <code><em>x</em></code><em> </em>ou <code><em>y</em></code><em>.</em></p> + + <p>Por exemplo, <code>/verde|vermelha/</code> corresponde "verde" em "maçã verde" e "vermelha" em "maçã vermelha".</p> + + <p>Entretanto, a primeira expressão tem preferência. Se uma string fosse corresponder às duas expressões, ela vai corresponder à que aparece do lado esquerdo do operador <code>|</code>. Por exemplo, <code>/maçãs|maçã/</code> corresponde "maçãs" na frase "<u>maçãs</u> vermelhas" e "maçã" na frase "<u>maçã</u> verde".</p> + </td> + </tr> + <tr> + <td><code><em>x</em>{<em>n</em>}</code></td> + <td> + <p>Onde <code><em>n</em></code> é um número inteiro positivo. Corresponde exatamente <code><em>n</em></code> ocorrências do item precedente <em>x</em>.</p> + + <p>Por exemplo, <code>/o{2}/</code> não corresponde o "o" em "brigadeiro", mas corresponde todos os dois "o"s em "brigadeir<u>oo</u>", e o dois primeiros "o"s em "brigadeir<u>oo</u>o".</p> + </td> + </tr> + <tr> + <td><code><em>x</em>{<em>n</em>,}</code></td> + <td> + <p>Onde <code><em>n</em></code> é um número inteiro positivo. Corresponde <em>pelo menos</em> <code><em>n</em></code> ocorrências do item precedente <em>x </em>(sem que haja um limite superior).</p> + + <p>Por exemplo, <code>/o{2,}/</code> não corresponde o "o" em "brigadeiro", mas corresponde todos os "o"s em "brigadeir<u>oo</u>" e em "brigadeir<u>ooooooooo</u>".</p> + </td> + </tr> + <tr> + <td><code><em>x</em>{<em>n</em>,<em>m</em>}</code></td> + <td> + <p>Onde <code><em>n</em></code> e <code><em>m</em></code> são números inteiros positivos. Corresponde pelo menos <code><em>n</em></code> e no máximo <code><em>m</em></code> ocorrências do item precedente <em>x</em>.</p> + + <p>Por exemplo, <code>/o{2,4}/</code> corresponde nada em "brigadeiro", os dois "o"s em "brigadeir<u>oo</u>", os três "o"s em "brigadeir<u>ooo</u>", e os primeiros quatro "o"s em "brigadeir<u>oooo</u>o".</p> + + <p>É importante perceber que no último caso a correspondência não inclui o último "o" de "brigadeirooooo". Isso se deve ao fato do operador quantificador ter definido o número máximo de ocorrências como 4, ignorando a quinta repetição do caractere.</p> + </td> + </tr> + <tr> + <td> + <p><code><em>x</em>*?</code><br> + <code><em>x</em>+?<br> + <em>x??</em><br> + <em>x{n,}?</em><br> + <em>x{n,m}?</em></code></p> + </td> + <td> + <p><strong>Operadores <em>non-greedy </em>ou<em> lazy</em> (não-gulosos ou preguiçosos)</strong><br> + Esses operadores com a <code>?</code> no final, operam de maneira semelhante aos seus análogos sem <code>?</code> mostrados acima, correspondendo múltiplas ocorrências do item precedente <em>x.</em> Entretanto, desta vez a ocorrência selecionada será a mínima possível.</p> + + <p>No exemplo <code>/(blah)*?/</code>, diante da frase "blahblahblah ração para gatos", nada seria selecionado, pois a ocorrência mínima aceita pelo operador <code>*?</code> seria ocorrência de 0 (zero) vezes da <em>string</em> "blah", o que resulta no nada.</p> + + <p>Já a expressão regular <code>/(blah)+?/</code>, diante da mesma frase, corresponderia a "blah", que é a ocorrência mínima aceita pelo operador <code>+?</code><em>, </em>ou seja, 1 (uma) repetição da sequência "blah".</p> + + <p>Em outro exemplo com mais aplicação prática, digamos que se quer corresponder todos os termos que ficam entre aspas em um texto. Se fizéssemos simplesmente a <em>regex</em> <code>/".*"/</code>, diante de um texto com múltiplas ocorrências de termos entre aspas, como: <em>'Eu "gosto" muito de "estudar" regex'</em>, a nossa expressão regular seria gulosa e selecionaria o maior texto possível que correspondesse à definição, nesse caso, selecionando '<em>"gosto" muito de "estudar"</em>', pois todo esse texto está compreendido entre a primeira aspa (antes de <em>'gosto'</em>) e a última aspa (após <em>'estudar'</em>), o que é um resultado talvez indesejado.<br> + Se usarmos a regex <code>/".*?"/</code>, com o operador não-guloso, as correspondências para a mesma frase seriam '<em>"gosto"</em>' e '<em>"estudar"</em>' separadamente, conforme era a intenção inicial.</p> + </td> + </tr> + </tbody> +</table> + +<h2 id="Properties" name="Properties">Propriedades</h2> + +<dl> + <dt>{{jsxref("RegExp.prototype")}}</dt> + <dd>Permite a adição de propriedades a todos os objetos.</dd> + <dt><code>RegExp.length</code></dt> + <dd>O valor of <code>RegExp.length</code> é 2.</dd> +</dl> + +<div>{{jsOverrides("Function", "Properties", "prototype")}}</div> + +<h2 id="Methods" name="Methods">Métodos</h2> + +<p>O objeto global <code>RegExp não possui métodos próprios, no entanto, herda alguns métodos através da cadeia de prototype.</code></p> + +<div>{{jsOverrides("Function", "Methods", "prototype")}}</div> + +<h2 id="Objetos_e_instancias">Objetos e instancias</h2> + +<h3 id="Properties_of_RegExp_instance" name="Properties_of_RegExp_instance">Propriedades</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/prototype', 'Properties')}}</div> + +<h3 id="Methods_of_RegExp_instance" name="Methods_of_RegExp_instance">Métodos</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/prototype', 'Methods')}}</div> + +<h2 id="Examples" name="Examples">Exemplos</h2> + +<h3 id="Example_Using_a_regular_expression_to_change_data_format" name="Example:_Using_a_regular_expression_to_change_data_format">Exemplo: Usando uma expressão regular para mudar o fomato dos dados</h3> + +<p>O seguinte script usa o método {{jsxref("String.prototype.replace()", "replace()")}} da instância de {{jsxref("Global_Objects/String", "String")}} para casar o nome no format <em>nome sobrenome</em> e produzir no formato <em>sobrenome, nome</em>. No texto substituto, o script usa <code>$1</code> e <code>$2</code> para indicar os respectivos parênteses de casamento no padrão da expressão regular.</p> + +<pre class="brush: js">var re = /(\w+)\s(\w+)/; +var str = 'John Smith'; +var newstr = str.replace(re, '$2, $1'); +console.log(newstr); +</pre> + +<p>Isto retornará "Smith, John".</p> + +<h3 id="Example_Using_regular_expression_on_multiple_lines" name="Example:_Using_regular_expression_on_multiple_lines">Exemplo: Usando expressões regulares para quebrar linhas com diferentes <strong>fins de linha</strong>/<strong>quebras de linha</strong></h3> + +<p>O final de linha padrão depende da plataforma utilizada (Unix, Windows, etc.). A divisão(<em>split</em>) de linha fornecida neste exemplo funciona com todas as plataformas.</p> + +<pre class="brush: js">var text = 'Um texto\nE mais um pouco\r\nE ainda mais\rEsse é o fim'; +var lines = text.split(/\r\n|\r|\n/); +console.log(lines) // prints [ 'Um texto', 'E mais um pouco', 'E ainda mais', 'Esse é o fim' ]</pre> + +<p>Note que a ordem dos padrões na expressão regular importa.</p> + +<h3 id="Example_Using_regular_expression_on_multiple_lines" name="Example:_Using_regular_expression_on_multiple_lines">Exemplo: Usando expressão regular sobre múltiplas linhas</h3> + +<pre class="brush: js">var s = 'Please yes\nmake my day!'; +s.match(/yes.*day/); +// Retorna null +s.match(/yes[^]*day/); +// Retorna'yes\nmake my day' +</pre> + +<h3 id="Example_Using_a_regular_expression_with_the_.22sticky.22_flag" name="Example:_Using_a_regular_expression_with_the_.22sticky.22_flag">Exemplo: Using a expressão regular com o "sticky" flag</h3> + +<p>Este exemplo mostra como utilizar a sticky flag em expressões regulares.</p> + +<pre class="brush: js">var text = 'First line\nSecond line'; +var regex = /(\S+) line\n?/y; + +var match = regex.exec(text); +console.log(match[1]); // prints 'First' +console.log(regex.lastIndex); // prints '11' + +var match2 = regex.exec(text); +console.log(match2[1]); // prints 'Second' +console.log(regex.lastIndex); // prints '22' + +var match3 = regex.exec(text); +console.log(match3 === null); // prints 'true' +</pre> + +<p>One can test at run-time whether o sticky flag é supported, using <code>try { … } catch { … }</code>. Para this, either an <code>eval(…)</code> expression ou o <code>RegExp(<var>regex-string</var>, <var>flags-string</var>)</code> syntax must be used (since o <code>/<var>regex</var>/<var>flags</var></code> notation é processed at compile-time, so throws an exception before o <code>catch</code> block é encountered). Por exemplo:</p> + +<pre class="brush: js">var supports_sticky; +try { RegExp('', 'y'); supports_sticky = true; } +catch(e) { supports_sticky = false; } +console.log(supports_sticky); // prints 'true' +</pre> + +<h3 id="Example_Regular_expression_and_Unicode_characters" name="Example:_Regular_expression_and_Unicode_characters">Exemplo: Expressão regular e Unicode caracteres</h3> + +<p>As mentioned above, <code>\w</code> ou <code>\W</code> only corresponde ASCII based caracteres; por exemplo, "a" to "z", "A" to "Z", "0" to "9" e "_". To match caracteres from other languages such como Cyrillic ou Hebrew, use <code>\uhhhh</code>, onde "hhhh" é o caractere's Unicode valor em hexadecimal. This exemplo demonstrates how one can separate out Unicode caracteres from uma palavra.</p> + +<pre class="brush: js">var text = 'Образец text на русском языке'; +var regex = /[\u0400-\u04FF]+/g; + +var match = regex.exec(text); +console.log(match[0]); // prints 'Образец' +console.log(regex.lastIndex); // prints '7' + +var match2 = regex.exec(text); +console.log(match2[0]); // prints 'на' [não print 'text'] +console.log(regex.lastIndex); // prints '15' + +// e assim vai +</pre> + +<p>Here's an external resource para getting o complete Unicode block range para different scripts: <a href="http://kourge.net/projects/regexp-unicode-block">Regexp-unicode-block</a>.</p> + +<h3 id="Example_Extracting_subdomain_name_from_URL" name="Example:_Extracting_subdomain_name_from_URL">Exemplo: Extracting subdomain name from URL</h3> + +<pre class="brush: js">var url = 'http://xxx.domain.com'; +console.log(/[^.]+/.exec(url)[0].substr(7)); // prints 'xxx' +</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>Initial definition. Implemented em JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.10', 'RegExp')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-regexp-regular-expression-objects', 'RegExp')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</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> + <tr> + <td>Sticky flag ("y")</td> + <td>{{CompatChrome("39")}} (behind flag)</td> + <td>{{CompatGeckoDesktop("1.9")}} ES4-Style {{bug(773687)}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</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 para 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> + <tr> + <td>Sticky flag ("y")</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("1.9")}} ES4-Style {{bug(773687)}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a> chapter no <a href="/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a></li> + <li>{{jsxref("String.prototype.match()")}}</li> + <li>{{jsxref("String.prototype.replace()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/sticky/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/sticky/index.html new file mode 100644 index 0000000000..2030fc7bf1 --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/sticky/index.html @@ -0,0 +1,95 @@ +--- +title: RegExp.prototype.sticky +slug: Web/JavaScript/Reference/Global_Objects/RegExp/sticky +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/sticky +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>sticky</code></strong> indica se a busca é "pegajosa" (percorre a string somente a partir do índice indicado pela propriedade {{jsxref("RegExp.lastIndex", "lastIndex")}} desta expressão regular). A propriedade <code>sticky</code> em um objeto de expressão regular é somente para leitura.</p> + +<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-sticky.html")}}</div> + +<p class="hidden">O código fonte para este exemplo interativo está armazenado em um repositório GitHub. Caso deseje contribuir com o projeto de exemplos interativos, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um <em>pull request</em>.</p> + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Descrição">Descrição</h2> + +<p>O valor de <code>sticky</code> é do tipo {{jsxref("Boolean")}} e será <em>true </em>quando a flag "<code>y</code>" for utilizada; senão, será <em>false</em>. A flag "<code>y</code>" indica que as correspondências ocorrerão apenas a partir do indice indicado pela propriedade {{jsxref("RegExp.lastIndex", "lastIndex")}} desta expressão regular na string alvo (e não buscará correspondência em nenhum índice anterior). Uma expressão regular definida como <code>sticky</code> e <code>global</code> ignora a flag <code>global</code>.</p> + +<p>Você não pode alterar essa propriedade diretamente. Ela é somente para leitura.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Uilizando_uma_expressão_regular_com_a_flag_sticky">Uilizando uma expressão regular com a flag <em>sticky</em></h3> + +<pre class="brush: js">var str = '#foo#'; +var regex = /foo/y; + +regex.lastIndex = 1; +regex.test(str); // true +regex.lastIndex = 5; +regex.test(str); // false (lastIndex é levado em conta com a flag sticky) +regex.lastIndex; // 0 (reinicia quando não ocorre correspondência) +</pre> + +<h3 id="Flag_sticky_ancorada">Flag sticky ancorada</h3> + +<p>Por diversas versões, a engine SpiderMonkey do Firefox apresentou um<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=773687"> bug</a> na asserção de <code>^</code> com a flag <em>sticky </em>que fazia expressões iniciando com <code>^</code> e usando a flag <em>sticky </em>encontrarem correspondências onde não deveriam. O bug foi introduzido algum tempo após o Firefox 3.6 (que possuía a flag sticky mas não apresentava o bug) e corrigido em 2015. Talvez por este motivo, a especificação ES2015 <a href="http://www.ecma-international.org/ecma-262/7.0/index.html#sec-assertion">destaca especificamente</a> que:</p> + +<blockquote> +<p>Quando a flag <code>y</code> for usada em um padrão, ^ indica que a correspondência ocorrerá apenas no início da entrada, ou (se <code>multiline</code> for <code>true</code>) no início de uma linha.</p> +</blockquote> + +<p>Exemplos de comportamento esperado:</p> + +<pre class="brush: js">var regex = /^foo/y; +regex.lastIndex = 2; +regex.test('..foo'); // false - índice 2 não é o início da string + +var regex2 = /^foo/my; +regex2.lastIndex = 2; +regex2.test('..foo'); // false - índice 2 não é o início da string nem da linha +regex2.lastIndex = 2; +regex2.test('.\nfoo'); // true - índice 2 é o início da linha +</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('ES2015', '#sec-get-regexp.prototype.sticky', 'RegExp.prototype.sticky')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definição inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-regexp.prototype.sticky', 'RegExp.prototype.sticky')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<div> +<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Caso deseje contribuir, consulte <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um <em>pull request</em>.</div> + +<p>{{Compat("javascript.builtins.RegExp.sticky")}}</p> +</div> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("RegExp.lastIndex")}}</li> + <li>{{jsxref("RegExp.prototype.global")}}</li> + <li>{{jsxref("RegExp.prototype.ignoreCase")}}</li> + <li>{{jsxref("RegExp.prototype.multiline")}}</li> + <li>{{jsxref("RegExp.prototype.source")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/test/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/test/index.html new file mode 100644 index 0000000000..c3470dc4fe --- /dev/null +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/test/index.html @@ -0,0 +1,152 @@ +--- +title: RegExp.prototype.test() +slug: Web/JavaScript/Reference/Global_Objects/RegExp/test +tags: + - Expressão Regular + - JavaScript + - Prototype + - Referencia + - RegExp + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/test +--- +<div>{{JSRef}}</div> + +<div>O método <strong>test() </strong>executa uma busca por uma correspondência entre uma expressão regular e uma string. Retorna <code>true</code> ou <code>false</code>.</div> + +<h2 id="Sintaxe">Sintaxe</h2> + +<pre class="syntaxbox notranslate"><code><var>regexObj</var>.test(<var>str</var>)</code></pre> + +<h3 id="Parâmetros">Parâmetros</h3> + +<dl> + <dt><code>str</code></dt> + <dd>A string que confrontará a expressão regular.</dd> +</dl> + +<h3 id="Retorno">Retorno</h3> + +<p>Boolean.</p> + +<p><code>true</code> se a string <code>str</code> corresponde com o que está descrito na expressão regular.</p> + +<p>Caso contrário, retorna <code>false</code>.</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Use test() sempre que você quiser saber se um padrão está dentro de uma string( similar ao método {{jsxref("String.prototype.search()")}}); Para mais informações (porém com execução mais lenta) use o método {{jsxref("RegExp.prototype.exec()", "exec()")}} (similar ao método {{jsxref("String.prototype.match()")}}). Assim como {{jsxref("RegExp.prototype.exec()", "exec()")}} (ou em combinação com ele), test() quando chamado várias vezes dentro da mesma instância de expressão regular irá avançar seu ponteiro para a correspondência anterior.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Usando_test">Usando <code>test()</code></h3> + +<p>Exemplo simples que verifica se <code>"hello"</code> está presente no início de uma string, retornando um booleano como resultado.</p> + +<pre class="notranslate">const str = 'hello world!'; +const result = /^hello/.test(str); + +console.log(result); // true</pre> + +<p>O exemplo a seguir mostra uma mensagem dependendo do sucesso do teste.</p> + +<pre class="brush: js notranslate">function testinput(re, str){ + var midstring; + if (re.test(str)) { + midstring = ' Contém '; + } else { + midstring = ' não contém '; + } + console.log(str + midstring + re.source); +} +</pre> + +<h2 id="Specificações">Specificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specificações</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.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.10.6.3', 'RegExp.test')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-regexp.prototype.test', 'RegExp.test')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade_com_Browser">Compatibilidade com Browser</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 para 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="Gecko-specific_notes">Gecko-specific notes</h2> + +<p>A priori no Grecko 8.0 {{geckoRelease("8.0")}}, <code>test()</code> foi implementado incorretamente; quando chamado sem parâmetros, ele encontrária uma correspondência com o valor de entrada anterior (<code>RegExp.input</code> property) no lugar de uma correspondência com <code>"undefined"</code>. Isso está conrrigido; agora <code>/undefined/.test()</code> resultará em <code>true</code>, no lugar de um erro.</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a> chapter in the <a href="/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a></li> + <li>{{jsxref("RegExp")}}</li> +</ul> |