From efa487110f67c16b3ea87b11b9b778f51822a6a2 Mon Sep 17 00:00:00 2001 From: fsdude Date: Wed, 27 May 2020 21:01:02 -0300 Subject: [PATCH 01/13] Deleted file that aren't updated with english version --- .../01-regexp-introduction/article-pt.md | 127 ------------------ 1 file changed, 127 deletions(-) delete mode 100644 9-regular-expressions/01-regexp-introduction/article-pt.md diff --git a/9-regular-expressions/01-regexp-introduction/article-pt.md b/9-regular-expressions/01-regexp-introduction/article-pt.md deleted file mode 100644 index 23b70545e..000000000 --- a/9-regular-expressions/01-regexp-introduction/article-pt.md +++ /dev/null @@ -1,127 +0,0 @@ -# Padrões e flags - -Expressão regular é uma maneira poderosa de buscar e substituir dentro de uma string. - -Em JavaScript, expressões regulares são implementadas usando objetos de uma classe 'RegExp' embutida e integrada com strings. - -Observe que as expressões regulares variam entre linguagens de programação. Nesse tutorial, nos concentramos em JavaScript. Claro que há muito em comum, mas existem algumas diferenças em Perl, Ruby, PHP, etc. - -## Expressões regulares - -Uma expressão regular (também "regexp", ou apenas "reg") consiste em um *padrão* e opcionais *flags*. - -Existem duas sintaxes para criar um objeto de expressão regular. - -A sintaxe longa: - -```js -regexp = new RegExp("padrão", "flags"); -``` - -...E a curta, usando barras `"/"`: - -```js -regexp = /padrão/; // sem flags -regexp = /padrão/gmi; // com flags `g`, `m` e `i` (que serão detalhadas em breve) -``` - -Barras `"/"` dizem ao JavaScript que estamos criando uma expressão regular. Elas desempenham o mesmo papel que as aspas para strings. - -## Uso - -Para buscar dentro de uma string, nós podemos usar o método [search](mdn:js/String/search). - -Aqui está um exemplo: - -```js run -let str = "Eu amo JavaScript!"; // irá buscar aqui - -let regexp = /amo/; -alert( str.search(regexp) ); // 3 -``` - -O método `str.search` busca pelo `padrão:/amo/` e retorna a posição dentro da string. Como devemos adivinhar, `padrão:/love/` é o padrão mais simples possível. O que ele faz é uma simples pesquisa de substring. - -O código acima é o mesmo que: - -```js run -let str = "Eu amo JavaScript!"; // irá buscar aqui - -let substr = 'amo'; -alert( str.search(substr) ); // 3 -``` - -Então procurar pelo `padrão:/amo/` é o mesmo que procurar por `"amo"`. - -Mas isso é apenas por agora. Em breve nós iremos criar expressões regulares mais complexas com muito mais poder de busca. - -```smart header="Cores" -A partir daqui, o esquema de cores é: - -- regexp -- `padrão:vermelho` -- string (onde nós buscamos) -- `sujeito:azul` -- result -- `correspondência:verde` -``` - - -````smart header="Quando usar `new RegExp`?" -Normalmente nós usamos a sintaxe curta `/.../`. Mas não suporta inserções variáveis `${...}`. - -Por outro lado, `new RegExp` permite construir um padrão dinamicamente de uma string, então é mais flexível. - -Aqui está um exemplo de uma regexp gerada dinamicamente: - -```js run -let tag = prompt("Qual tag quer procurar?", "h2"); -let regexp = new RegExp(`<${tag}>`); - -// procura

por padrão -alert( "

".search(regexp)); -``` -```` - - -## Flags - -Expressões regulares podem ter flags que afetam a busca. - -Existem apenas 5 delas em JavaScript: - -`i` -: Com essa flag a busca é case-insensitive: não faz distinção entre `A` e `a` (veja o exemplo abaixo). - -`g` -: Com essa flag a busca procura por todas as correspondências, sem ela -- apenas a primeira (nós veremos usos no próximo capítulo). - -`m` -: Modo multilinha (abordado no capítulo ). - -`s` -: Modo "dotall", permite que o `.` corresponda às novas linhas (abordado no capítulo ). - -`u` -: Habilita o suporte completo a unicode. A flag permite o processamento correto dos pares substitutos. Mais sobre isso no capítulo . - -`y` -: Modo fixo (abordado no capítulo ) - -Abordaremos todas essas flags mais adiante no tutorial. - -Por agora, a mais simples flag é `i`, aqui está um exemplo: - -```js run -let str = "Eu amo JavaScript!"; - -alert( str.search(/AMO/i) ); // 3 (encontrado em minúsculas) - -alert( str.search(/AMO/) ); // -1 (nada encontrado sem a 'i' flag) -``` - -Então a `i` flag já faz as expressões regulares mais poderosas do que uma simples pesquisa de substring. Mas ainda há muito mais. Abodaremos outras flags e recursos nos próximos capítulos. - - -## Sumário - -- Uma expressão regular consiste de um padrão e flags opcionais: `g`, `i`, `m`, `u`, `s`, `y`. -- Sem flags e símbolos especiais que iremos estudar depois, a busca por uma regexp é o mesmo que uma pesquisa de substring. -- O método `str.search(regexp)` retorna o índice onde a correspondência é encontrada ou `-1` se não há correspondência. No próximo capítulo veremos outros métodos. From b707c26c229bcab104dfd1aeb4a34cde9ad174eb Mon Sep 17 00:00:00 2001 From: fsdude Date: Wed, 27 May 2020 21:01:39 -0300 Subject: [PATCH 02/13] Retranslation of the updated english version done --- .../01-regexp-introduction/article.md | 174 +++++++++--------- 1 file changed, 87 insertions(+), 87 deletions(-) diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md index a35d19a7b..ce4b5aa57 100644 --- a/9-regular-expressions/01-regexp-introduction/article.md +++ b/9-regular-expressions/01-regexp-introduction/article.md @@ -1,177 +1,177 @@ -# Patterns and flags +# Padrões e flags -Regular expressions are patterns that provide a powerful way to search and replace in text. +Expressões regulares são padrões que fornecem uma maneira poderosa de pesquisar e substituir no texto. -In JavaScript, they are available via the [RegExp](mdn:js/RegExp) object, as well as being integrated in methods of strings. +Em JavaScript, elas estão disponíveis através do objeto [RegExp](mdn:js/RegExp), além de serem integradas aos métodos de strings. -## Regular Expressions +## Expressões regulares -A regular expression (also "regexp", or just "reg") consists of a *pattern* and optional *flags*. +Uma expressão regular (também "regexp" ou apenas "reg") consiste em um *padrão* e *flags* opcionais. -There are two syntaxes that can be used to create a regular expression object. +Existem duas sintaxes que podem ser usadas para criar um objeto de expressão regular. -The "long" syntax: +A sintaxe "longa": ```js -regexp = new RegExp("pattern", "flags"); +regexp = new RegExp("padrão", "flags"); ``` -And the "short" one, using slashes `"/"`: +E a "curta", usando barras `"/"`: ```js -regexp = /pattern/; // no flags -regexp = /pattern/gmi; // with flags g,m and i (to be covered soon) +regexp = /padrão/; // sem flags +regexp = /padrão/gmi; // com flags `g`, `m` e `i` (a ser abordado em breve) ``` -Slashes `pattern:/.../` tell JavaScript that we are creating a regular expression. They play the same role as quotes for strings. +Barras `padrão:/.../` informam ao JavaScript que estamos criando uma expressão regular. Eles desempenham o mesmo papel que aspas para strings. -In both cases `regexp` becomes an instance of the built-in `RegExp` class. +Em ambos os casos, a `regexp` se torna uma instância da classe interna `RegExp`. -The main difference between these two syntaxes is that pattern using slashes `/.../` does not allow for expressions to be inserted (like string template literals with `${...}`). They are fully static. +A principal diferença entre essas duas sintaxes é que o padrão usando barras `/.../` não permite a inserção de expressões (como modelos de string literais com `${...}`). Eles são totalmente estáticos. -Slashes are used when we know the regular expression at the code writing time -- and that's the most common situation. While `new RegExp`, is more often used when we need to create a regexp "on the fly" from a dynamically generated string. For instance: +As barras são usadas quando conhecemos a expressão regular no momento da escrita do código - e essa é a situação mais comum. Enquanto `new RegExp` é mais frequentemente usada quando precisamos criar uma regexp "de improviso" a partir de uma string gerada dinamicamente. Por exemplo: ```js -let tag = prompt("What tag do you want to find?", "h2"); +let tag = prompt("Qual tag você deseja encontrar?", "h2"); -let regexp = new RegExp(`<${tag}>`); // same as /

/ if answered "h2" in the prompt above +let regexp = new RegExp(`<${tag}>`); // igual a /

/ se respondeu "h2" no prompt acima ``` ## Flags -Regular expressions may have flags that affect the search. +Expressões regulares podem ter flags que afetam a pesquisa. -There are only 6 of them in JavaScript: +Existem apenas 6 delas em JavaScript: -`pattern:i` -: With this flag the search is case-insensitive: no difference between `A` and `a` (see the example below). +`padrão:i` +: Com essa flag, a pesquisa não diferencia maiúsculas de minúsculas: não há diferença entre `A` e `a` (veja o exemplo abaixo). -`pattern:g` -: With this flag the search looks for all matches, without it -- only the first match is returned. +`padrão:g` +: Com essa flag, a pesquisa procura todas as correspondências, sem ela - somente a primeira correspondência é retornada. -`pattern:m` -: Multiline mode (covered in the chapter ). +`padrão:m` +: Modo multilinha (abordado no capítulo ). -`pattern:s` -: Enables "dotall" mode, that allows a dot `pattern:.` to match newline character `\n` (covered in the chapter ). +`padrão:s` +: Ativa o modo "dotall", que permite que um ponto `padrão:.` corresponda ao caractere de nova linha `\n` (abordado no capítulo ). -`pattern:u` -: Enables full unicode support. The flag enables correct processing of surrogate pairs. More about that in the chapter . +`padrão:u` +: Ativa o suporte completo a unicode. A flag permite o processamento correto de pares substitutos. Mais sobre isso no capítulo . -`pattern:y` -: "Sticky" mode: searching at the exact position in the text (covered in the chapter ) +`padrão:y` +: Modo "Fixo": pesquisando na posição exata no texto (abordado no capítulo ) -```smart header="Colors" -From here on the color scheme is: +```smart header="Cores" +A partir daqui, o esquema de cores é: -- regexp -- `pattern:red` -- string (where we search) -- `subject:blue` -- result -- `match:green` +- regexp -- `padrão:vermelho` +- string (onde pesquisamos) -- `sujeito:azul` +- result -- `correspondência:verde` ``` -## Searching: str.match +## Pesquisando: str.match -As mentioned previously, regular expressions are integrated with string methods. +Como mencionado anteriormente, expressões regulares são integradas a métodos de string. -The method `str.match(regexp)` finds all matches of `regexp` in the string `str`. +O método `str.match(regexp)` encontra todas as correspondências de `regexp` na string `str`. -It has 3 working modes: +Possui 3 modos de trabalho: -1. If the regular expression has flag `pattern:g`, it returns an array of all matches: +1. Se a expressão regular tiver flag `padrão:g`, ela retornará uma matriz de todas as correspondências: ```js run - let str = "We will, we will rock you"; + let str = "Nós vamos, nós vamos sacudir você"; - alert( str.match(/we/gi) ); // We,we (an array of 2 substrings that match) + alert( str.match(/nós/gi) ); // Nós, nós (uma matriz de 2 substrings que correspondem) ``` - Please note that both `match:We` and `match:we` are found, because flag `pattern:i` makes the regular expression case-insensitive. + Observe que ambas `correspondência:Nós` e `correspondência:nós` são encontradas, porque flag `padrão:i` torna a expressão regular sem distinção entre maiúsculas e minúsculas. -2. If there's no such flag it returns only the first match in the form of an array, with the full match at index `0` and some additional details in properties: +2. Se não houver essa flag, ela retornará apenas a primeira correspondência na forma de uma matriz, com a correspondência completa no índice `0` e alguns detalhes adicionais nas propriedades: ```js run - let str = "We will, we will rock you"; + let str = "Nós vamos, nós vamos sacudir você"; - let result = str.match(/we/i); // without flag g + let result = str.match(/nós/i); // sem flag g - alert( result[0] ); // We (1st match) + alert( result[0] ); // Nós (1º correspondência) alert( result.length ); // 1 - // Details: - alert( result.index ); // 0 (position of the match) - alert( result.input ); // We will, we will rock you (source string) + // Detalhes: + alert( result.index ); // 0 (posição da correspondência) + alert( result.input ); // Nós vamos, nós vamos sacudir você (string de origem) ``` - The array may have other indexes, besides `0` if a part of the regular expression is enclosed in parentheses. We'll cover that in the chapter . + A matriz pode ter outros índices, além de `0` se uma parte da expressão regular estiver entre parênteses. Abordaremos isso no capítulo . -3. And, finally, if there are no matches, `null` is returned (doesn't matter if there's flag `pattern:g` or not). +3. E, finalmente, se não houver correspondências, `null` é retornado (não importa se há flags `padrão:g` ou não). - This a very important nuance. If there are no matches, we don't receive an empty array, but instead receive `null`. Forgetting about that may lead to errors, e.g.: + Esta é uma nuance muito importante. Se não houver correspondências, não receberemos uma matriz vazia, mas receberemos `null`. Esquecer isso pode levar a erros, por exemplo: ```js run let matches = "JavaScript".match(/HTML/); // = null if (!matches.length) { // Error: Cannot read property 'length' of null - alert("Error in the line above"); + alert("Erro na linha acima"); } ``` - If we'd like the result to always be an array, we can write it this way: + Se quisermos que o resultado seja sempre uma matriz, podemos escrevê-lo desta maneira: ```js run - let matches = "JavaScript".match(/HTML/)*!* || []*/!*; + let matches = "JavaScript".match(/HTML/) || []; if (!matches.length) { - alert("No matches"); // now it works + alert("Sem correspondências"); // agora funciona } ``` -## Replacing: str.replace +## Substituindo: str.replace -The method `str.replace(regexp, replacement)` replaces matches found using `regexp` in string `str` with `replacement` (all matches if there's flag `pattern:g`, otherwise, only the first one). +O método `str.replace(regexp, substituição)` substitui as correspondências encontradas usando `regexp` na string ` str` por `substituição` (todas as correspondências se houver flag `padrão:g`, caso contrário, apenas a primeira). -For instance: +Por exemplo: ```js run -// no flag g -alert( "We will, we will".replace(/we/i, "I") ); // I will, we will +// sem flag g +alert( "Nós vamos, nós vamos".replace(/nós/i, "Eu") ); // Eu vamos, nós vamos -// with flag g -alert( "We will, we will".replace(/we/ig, "I") ); // I will, I will +// com flag g +alert( "Nós vamos, nós vamos".replace(/nós/ig, "Eu") ); // Eu vamos, Eu vamos ``` -The second argument is the `replacement` string. We can use special character combinations in it to insert fragments of the match: +O segundo argumento é a string de `substituição`. Podemos usar combinações especiais de caracteres para inserir fragmentos da correspondência: -| Symbols | Action in the replacement string | +| Símbolos | Ação na string de substituição | |--------|--------| -|`$&`|inserts the whole match| -|$`|inserts a part of the string before the match| -|`$'`|inserts a part of the string after the match| -|`$n`|if `n` is a 1-2 digit number, then it inserts the contents of n-th parentheses, more about it in the chapter | -|`$`|inserts the contents of the parentheses with the given `name`, more about it in the chapter | -|`$$`|inserts character `$` | +|`$&`|insere toda a correspondência| +|$`|insere uma parte da string antes da correspondência| +|`$'`|insere uma parte da string depois da correspondência| +|`$n`|se `n` for um número de 1-2 dígitos, ela inserirá o conteúdo dos enésimos parênteses, mais sobre sso no capítulo | +|`$`|insere o conteúdo dos parênteses com o `nome` fornecido, mais sobre isso no capítulo | +|`$$`|insere o caractere `$` | -An example with `pattern:$&`: +Um exemplo com o `padrão:$&`: ```js run -alert( "I love HTML".replace(/HTML/, "$& and JavaScript") ); // I love HTML and JavaScript +alert( "Eu amo HTML".replace(/HTML/, "$& and JavaScript") ); // Eu amo HTML and JavaScript ``` -## Testing: regexp.test +## Teste: regexp.test -The method `regexp.test(str)` looks for at least one match, if found, returns `true`, otherwise `false`. +O método `regexp.test(str)` procura pelo menos uma correspondência, se encontrada, retorna `true`, caso contrário,`false`. ```js run -let str = "I love JavaScript"; -let regexp = /LOVE/i; +let str = "Eu amo JavaScript"; +let regexp = /AMO/i; alert( regexp.test(str) ); // true ``` -Later in this chapter we'll study more regular expressions, walk through more examples, and also meet other methods. +Mais adiante neste capítulo, estudaremos mais expressões regulares, examinaremos mais exemplos e também conheceremos outros métodos. -Full information about the methods is given in the article . +Informações completas sobre os métodos são fornecidas no artigo . -## Summary +## Resumo -- A regular expression consists of a pattern and optional flags: `pattern:g`, `pattern:i`, `pattern:m`, `pattern:u`, `pattern:s`, `pattern:y`. -- Without flags and special symbols (that we'll study later), the search by a regexp is the same as a substring search. -- The method `str.match(regexp)` looks for matches: all of them if there's `pattern:g` flag, otherwise, only the first one. -- The method `str.replace(regexp, replacement)` replaces matches found using `regexp` with `replacement`: all of them if there's `pattern:g` flag, otherwise only the first one. -- The method `regexp.test(str)` returns `true` if there's at least one match, otherwise, it returns `false`. +- Uma expressão regular consiste em um padrão e opcionais flags: `padrão:g`, `padrão:i`, `padrão:m`, `padrão:u`, `padrão:s`, `padrão:y`. +- Sem flags e símbolos especiais (que estudaremos mais adiante), a pesquisa por uma regexp é igual à pesquisa de substring. +- O método `str.match(regexp)` procura por correspondências: todas elas se houver flag `padrão:g`, caso contrário, apenas o primeiro. +- O método `str.replace(regexp, substituição)` substitui as correspondências encontradas usando `regexp` por `replace`: todas elas se houver uma flag `padrão:g`, caso contrário, somente a primeira. +- O método `regexp.test(str)` retorna `true` se houver pelo menos uma correspondência, caso contrário, retorna `false`. \ No newline at end of file From e3fbf39156c03e1820f35bac45c884335299c721 Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Wed, 14 Jul 2021 20:35:04 +0100 Subject: [PATCH 03/13] Update 9-regular-expressions/01-regexp-introduction/article.md --- 9-regular-expressions/01-regexp-introduction/article.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md index ce4b5aa57..2566e9050 100644 --- a/9-regular-expressions/01-regexp-introduction/article.md +++ b/9-regular-expressions/01-regexp-introduction/article.md @@ -2,7 +2,7 @@ Expressões regulares são padrões que fornecem uma maneira poderosa de pesquisar e substituir no texto. -Em JavaScript, elas estão disponíveis através do objeto [RegExp](mdn:js/RegExp), além de serem integradas aos métodos de strings. +Em JavaScript, elas estão disponíveis através do objeto [RegExp](mdn:js/RegExp), além de estarem integradas em métodos de strings. ## Expressões regulares @@ -174,4 +174,4 @@ Informações completas sobre os métodos são fornecidas no artigo Date: Wed, 14 Jul 2021 20:35:23 +0100 Subject: [PATCH 04/13] Update 9-regular-expressions/01-regexp-introduction/article.md --- 9-regular-expressions/01-regexp-introduction/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md index 2566e9050..6439ff67f 100644 --- a/9-regular-expressions/01-regexp-introduction/article.md +++ b/9-regular-expressions/01-regexp-introduction/article.md @@ -25,7 +25,7 @@ regexp = /padrão/gmi; // com flags `g`, `m` e `i` (a ser abordado em breve) Barras `padrão:/.../` informam ao JavaScript que estamos criando uma expressão regular. Eles desempenham o mesmo papel que aspas para strings. -Em ambos os casos, a `regexp` se torna uma instância da classe interna `RegExp`. +Em ambos os casos, a `regexp` se torna numa instância da classe interna `RegExp`. A principal diferença entre essas duas sintaxes é que o padrão usando barras `/.../` não permite a inserção de expressões (como modelos de string literais com `${...}`). Eles são totalmente estáticos. From a27c352d74d1d4b08d89aced4cbd5e88cf0525dc Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Wed, 14 Jul 2021 20:36:06 +0100 Subject: [PATCH 05/13] Update 9-regular-expressions/01-regexp-introduction/article.md --- 9-regular-expressions/01-regexp-introduction/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md index 6439ff67f..48075ef0e 100644 --- a/9-regular-expressions/01-regexp-introduction/article.md +++ b/9-regular-expressions/01-regexp-introduction/article.md @@ -56,7 +56,7 @@ Existem apenas 6 delas em JavaScript: : Ativa o modo "dotall", que permite que um ponto `padrão:.` corresponda ao caractere de nova linha `\n` (abordado no capítulo ). `padrão:u` -: Ativa o suporte completo a unicode. A flag permite o processamento correto de pares substitutos. Mais sobre isso no capítulo . +: Ativa o suporte completo de Unicode. A flag permite o processamento correto de pares substitutos. Mais sobre isso no capítulo . `padrão:y` : Modo "Fixo": pesquisando na posição exata no texto (abordado no capítulo ) From 748179593a55a689dabd0e90c209127a5be45651 Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Wed, 14 Jul 2021 20:36:24 +0100 Subject: [PATCH 06/13] Update 9-regular-expressions/01-regexp-introduction/article.md --- 9-regular-expressions/01-regexp-introduction/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md index 48075ef0e..d72423b8d 100644 --- a/9-regular-expressions/01-regexp-introduction/article.md +++ b/9-regular-expressions/01-regexp-introduction/article.md @@ -59,7 +59,7 @@ Existem apenas 6 delas em JavaScript: : Ativa o suporte completo de Unicode. A flag permite o processamento correto de pares substitutos. Mais sobre isso no capítulo . `padrão:y` -: Modo "Fixo": pesquisando na posição exata no texto (abordado no capítulo ) +: Modo "fixo": pesquisando na posição exata no texto (abordado no capítulo ) ```smart header="Cores" A partir daqui, o esquema de cores é: From 9166ab4dc280d0245bb58002bf761be00d9d847e Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Wed, 14 Jul 2021 20:36:44 +0100 Subject: [PATCH 07/13] Update 9-regular-expressions/01-regexp-introduction/article.md --- 9-regular-expressions/01-regexp-introduction/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md index d72423b8d..339a4443e 100644 --- a/9-regular-expressions/01-regexp-introduction/article.md +++ b/9-regular-expressions/01-regexp-introduction/article.md @@ -65,7 +65,7 @@ Existem apenas 6 delas em JavaScript: A partir daqui, o esquema de cores é: - regexp -- `padrão:vermelho` -- string (onde pesquisamos) -- `sujeito:azul` +- string (onde pesquisamos) -- `fonte:azul` - result -- `correspondência:verde` ``` From c061b7a4aa52bceaf0716b54fa581d09967e44cb Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Wed, 14 Jul 2021 20:37:02 +0100 Subject: [PATCH 08/13] Update 9-regular-expressions/01-regexp-introduction/article.md --- 9-regular-expressions/01-regexp-introduction/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md index 339a4443e..771856a6f 100644 --- a/9-regular-expressions/01-regexp-introduction/article.md +++ b/9-regular-expressions/01-regexp-introduction/article.md @@ -143,7 +143,7 @@ O segundo argumento é a string de `substituição`. Podemos usar combinações |`$&`|insere toda a correspondência| |$`|insere uma parte da string antes da correspondência| |`$'`|insere uma parte da string depois da correspondência| -|`$n`|se `n` for um número de 1-2 dígitos, ela inserirá o conteúdo dos enésimos parênteses, mais sobre sso no capítulo | +|`$n`|se `n` for um número de 1-2 dígitos, ela inserirá o conteúdo dos enésimos parênteses, mais sobre isso no capítulo | |`$`|insere o conteúdo dos parênteses com o `nome` fornecido, mais sobre isso no capítulo | |`$$`|insere o caractere `$` | From 4f5464d9e65dc601aefd3e115d492d1d486fbad4 Mon Sep 17 00:00:00 2001 From: Osvaldo Dias dos Santos Date: Wed, 14 Jul 2021 20:37:38 +0100 Subject: [PATCH 09/13] Update 9-regular-expressions/01-regexp-introduction/article.md --- 9-regular-expressions/01-regexp-introduction/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md index 771856a6f..1bc392646 100644 --- a/9-regular-expressions/01-regexp-introduction/article.md +++ b/9-regular-expressions/01-regexp-introduction/article.md @@ -170,7 +170,7 @@ Informações completas sobre os métodos são fornecidas no artigo Date: Wed, 14 Jul 2021 20:37:51 +0100 Subject: [PATCH 10/13] Update 9-regular-expressions/01-regexp-introduction/article.md --- 9-regular-expressions/01-regexp-introduction/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md index 1bc392646..2d08b6539 100644 --- a/9-regular-expressions/01-regexp-introduction/article.md +++ b/9-regular-expressions/01-regexp-introduction/article.md @@ -171,7 +171,7 @@ Informações completas sobre os métodos são fornecidas no artigo Date: Wed, 14 Jul 2021 20:38:10 +0100 Subject: [PATCH 11/13] Update 9-regular-expressions/01-regexp-introduction/article.md --- 9-regular-expressions/01-regexp-introduction/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md index 2d08b6539..f4405ab97 100644 --- a/9-regular-expressions/01-regexp-introduction/article.md +++ b/9-regular-expressions/01-regexp-introduction/article.md @@ -172,6 +172,6 @@ Informações completas sobre os métodos são fornecidas no artigo Date: Wed, 14 Jul 2021 20:38:39 +0100 Subject: [PATCH 12/13] Update 9-regular-expressions/01-regexp-introduction/article.md --- 9-regular-expressions/01-regexp-introduction/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md index f4405ab97..ad1e68a41 100644 --- a/9-regular-expressions/01-regexp-introduction/article.md +++ b/9-regular-expressions/01-regexp-introduction/article.md @@ -173,5 +173,5 @@ Informações completas sobre os métodos são fornecidas no artigo Date: Sat, 20 Jan 2024 19:51:58 -0300 Subject: [PATCH 13/13] refactor: undo translations that shouldn't happen --- .../01-regexp-introduction/article.md | 40 +++++++++---------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/9-regular-expressions/01-regexp-introduction/article.md b/9-regular-expressions/01-regexp-introduction/article.md index ad1e68a41..cb886e1af 100644 --- a/9-regular-expressions/01-regexp-introduction/article.md +++ b/9-regular-expressions/01-regexp-introduction/article.md @@ -23,7 +23,7 @@ regexp = /padrão/; // sem flags regexp = /padrão/gmi; // com flags `g`, `m` e `i` (a ser abordado em breve) ``` -Barras `padrão:/.../` informam ao JavaScript que estamos criando uma expressão regular. Eles desempenham o mesmo papel que aspas para strings. +Barras `pattern:/.../` informam ao JavaScript que estamos criando uma expressão regular. Eles desempenham o mesmo papel que aspas para strings. Em ambos os casos, a `regexp` se torna numa instância da classe interna `RegExp`. @@ -43,30 +43,30 @@ Expressões regulares podem ter flags que afetam a pesquisa. Existem apenas 6 delas em JavaScript: -`padrão:i` +`pattern:i` : Com essa flag, a pesquisa não diferencia maiúsculas de minúsculas: não há diferença entre `A` e `a` (veja o exemplo abaixo). -`padrão:g` +`pattern:g` : Com essa flag, a pesquisa procura todas as correspondências, sem ela - somente a primeira correspondência é retornada. -`padrão:m` +`pattern:m` : Modo multilinha (abordado no capítulo ). -`padrão:s` -: Ativa o modo "dotall", que permite que um ponto `padrão:.` corresponda ao caractere de nova linha `\n` (abordado no capítulo ). +`pattern:s` +: Ativa o modo "dotall", que permite que um ponto `pattern:.` corresponda ao caractere de nova linha `\n` (abordado no capítulo ). -`padrão:u` +`pattern:u` : Ativa o suporte completo de Unicode. A flag permite o processamento correto de pares substitutos. Mais sobre isso no capítulo . -`padrão:y` +`pattern:y` : Modo "fixo": pesquisando na posição exata no texto (abordado no capítulo ) ```smart header="Cores" A partir daqui, o esquema de cores é: -- regexp -- `padrão:vermelho` -- string (onde pesquisamos) -- `fonte:azul` -- result -- `correspondência:verde` +- regexp -- `pattern:vermelho` +- string (onde pesquisamos) -- `subject:azul` +- result -- `match:verde` ``` ## Pesquisando: str.match @@ -77,13 +77,13 @@ O método `str.match(regexp)` encontra todas as correspondências de `regexp` na Possui 3 modos de trabalho: -1. Se a expressão regular tiver flag `padrão:g`, ela retornará uma matriz de todas as correspondências: +1. Se a expressão regular tiver flag `pattern:g`, ela retornará uma matriz de todas as correspondências: ```js run let str = "Nós vamos, nós vamos sacudir você"; alert( str.match(/nós/gi) ); // Nós, nós (uma matriz de 2 substrings que correspondem) ``` - Observe que ambas `correspondência:Nós` e `correspondência:nós` são encontradas, porque flag `padrão:i` torna a expressão regular sem distinção entre maiúsculas e minúsculas. + Observe que ambas `match:Nós` e `match:nós` são encontradas, porque flag `pattern:i` torna a expressão regular sem distinção entre maiúsculas e minúsculas. 2. Se não houver essa flag, ela retornará apenas a primeira correspondência na forma de uma matriz, com a correspondência completa no índice `0` e alguns detalhes adicionais nas propriedades: ```js run @@ -100,7 +100,7 @@ Possui 3 modos de trabalho: ``` A matriz pode ter outros índices, além de `0` se uma parte da expressão regular estiver entre parênteses. Abordaremos isso no capítulo . -3. E, finalmente, se não houver correspondências, `null` é retornado (não importa se há flags `padrão:g` ou não). +3. E, finalmente, se não houver correspondências, `null` é retornado (não importa se há flags `pattern:g` ou não). Esta é uma nuance muito importante. Se não houver correspondências, não receberemos uma matriz vazia, mas receberemos `null`. Esquecer isso pode levar a erros, por exemplo: @@ -124,7 +124,7 @@ Possui 3 modos de trabalho: ## Substituindo: str.replace -O método `str.replace(regexp, substituição)` substitui as correspondências encontradas usando `regexp` na string ` str` por `substituição` (todas as correspondências se houver flag `padrão:g`, caso contrário, apenas a primeira). +O método `str.replace(regexp, substituição)` substitui as correspondências encontradas usando `regexp` na string ` str` por `substituição` (todas as correspondências se houver flag `pattern:g`, caso contrário, apenas a primeira). Por exemplo: @@ -147,10 +147,10 @@ O segundo argumento é a string de `substituição`. Podemos usar combinações |`$`|insere o conteúdo dos parênteses com o `nome` fornecido, mais sobre isso no capítulo | |`$$`|insere o caractere `$` | -Um exemplo com o `padrão:$&`: +Um exemplo com o `pattern:$&`: ```js run -alert( "Eu amo HTML".replace(/HTML/, "$& and JavaScript") ); // Eu amo HTML and JavaScript +alert( "Eu amo HTML".replace(/HTML/, "$& e JavaScript") ); // Eu amo HTML e JavaScript ``` ## Teste: regexp.test @@ -170,8 +170,8 @@ Informações completas sobre os métodos são fornecidas no artigo