Dúvida sobre o ponto de interrogação

Oii Gabriel, tudo bem?

O ponto de interrogação (?) na expressão regular tem um papel muito importante. Quando colocado após um quantificador (como o asterisco *), ele transforma a busca de "gananciosa" (greedy) para "preguiçosa" (lazy).

Agora, o asterisco (*) e o mais (+) são quantificadores em expressões regulares. O asterisco significa "zero ou mais ocorrências do item anterior", enquanto o mais significa "uma ou mais ocorrências do item anterior".

No caso da expressão regular utilizada na aula, o * foi usado após o [^>]* para indicar que qualquer caracter que não seja o sinal de maior que (>) pode aparecer zero ou mais vezes. Se fosse usado o + no lugar do *, a expressão regular só encontraria correspondências se houvesse pelo menos um caracter que não fosse o sinal de maior que (>) após a tag h1 ou h2.

Espero ter ajudado.

Um abraço e bons estudos.

Olá, Lorena! Tudo bem?

Ainda não entendi o motivo de o ponto de interrogação quebrar as linhas ou sua funcionalidade. Inclusive ficou muito vago nessa aula do curso a diferença entre "greedy" e "lazy". Conseguiria explicar melhor?

Obrigado!

Oii Gabriel!

Claro que posso tentar explicar melhor!

Quanto à quebra de linhas no Colab, a utilização do ponto de interrogação pode afetar como as correspondências são feitas, e isso pode influenciar na quebra de linhas no resultado final. Sem o ponto de interrogação, a expressão pode tentar incluir quebras de linha na correspondência, resultando em uma única linha contendo várias quebras de linha. Com o ponto de interrogação, a correspondência é mais restrita, evitando quebras de linha.

Então, o ponto de interrogação ajuda a controlar o comportamento "ganancioso" ou "não ganancioso" da expressão regular, influenciando como ela lida com caracteres, incluindo quebras de linha, ao fazer correspondências entre tags.

Agora vamos falar sobre a diferença entre "greedy" (ganancioso) e "lazy" (não ganancioso) nas expressões regulares.

Quando você usa uma expressão regular sem o ponto de interrogação, ela se comporta de maneira "gananciosa". Isso significa que ela tenta fazer a correspondência com o maior número possível de caracteres. Veja esse exemplo::

<h1>.*</h1>

Essa expressão tentará corresponder ao texto entre <h1> e </h1>, incluindo o máximo possível de caracteres no meio, até encontrar a última ocorrência de </h1>.

Ao adicionar o ponto de interrogação após um quantificador (como *, +, ?), você torna a expressão regular "lazy". Isso significa que ela tentará corresponder com o menor número possível de caracteres.

<h1>.*?</h1>

Neste caso, a expressão tentará corresponder ao texto entre <h1> e </h1>, mas de uma forma mais restrita, pegando o menor número possível de caracteres até encontrar a primeira ocorrência de </h1>. Isso evita que a correspondência "ultrapasse" múltiplas tags de fechamento.

Sobre a aula ter sido vaga, peço que você ao final do curso você deixe um depoimento contando sobre como foi a sua experiência com o curso, pois as pessoas responsáveis estão sempre de olho nos comentários para sempre melhorarmos os conteúdos da plataforma.

Espero que tenha te ajudado.

Um abraço e bons estudos.

Olá, Lorena! Obrigado pela atenção.

Essa parte sobre "greedy" e "lazy" é compreensível, mas de uma forma muito subjetiva ainda. Por exemplo a regex utilizada na aula: <(h[1-2])[^>]*>(.*?)<\/(h[1-2])>

O ponto simboliza qualquer valor em sua versão "greedy", mas quando inserimos a interrogação ele se torna "lazy" e deixará de pegar alguns itens (pelo que entendi). Um desses itens que não serão pegos é algo que faz tudo ficar na mesma linha? Como eu sei o que não vai ser pego e o que vai ser pego?

Acho que estou entendendo um pouco melhor, mas ainda está um pouco "estranho" para mim, principalmente entender quando vou ou não usar essas funções de "greedy" ou "lazy".

Obrigado novamente! :D

Ola amigos!

Me metendo aqui Gabriel, mas escolher entre "greedy" e "lazy" vai depender do que você quer. Se quiser pegar tudo o que der, manda ver no "greedy". Mas se quiser pegar só o mínimo, o negócio é usar o "lazy". Na real, vai depender dos detalhes do seu conjunto de dados e do padrão que você tá tentando tirar.

Imagina que tu tem esse código HTML aqui:

<h1>Título 1 <span>com subtítulo</span></h1>
<h2>Título 2</h2>

A expressão regular sem o ponto de interrogação seria assim:

<(h[1-2])[^>]*>(.*)<\/(h[1-2])>

Essa expressão tenta pegar o texto todo entre o primeiro <h1> e o último </h2>. Mas a pegadinha é que ela é "gananciosa" e acaba pegando todas as tags dentro, tipo o <span>com subtítulo</span>, também. sacas?

Agora, se tu usar a expressão regular com o ponto de interrogação :

<(h[1-2])[^>]*>(.*?)<\/(h[1-2])>

Essa expressão, quando achar a primeira tag <h1>, tenta pegar o menor número de caracteres possível até achar a primeira tag de fechamento </h1>. Resumindo, ela só pega o conteúdo direto dentro da tag <h1>, sem ficar enrolando com o conteúdo das tags aninhadas.No fim das contas.... a diferença prática entre "gananciosa" e "não tão gananciosa" nessa situação específica é quanto ela pega de conteúdo dentro de tags aninhadas. A versão "gananciosa" quer pegar tudo, enquanto a versão "não tão gananciosa" só quer o essencial, o que geralmente é mais útil quando lidamos com HTML e queremos evitar pegar conteúdo de tags enroscadas.

Olá! Tudo bem?

Eu, utilizando o regex101 fiz o teste, mas os resultados são exatamente os mesmos. Não era para a tag span sumir então (no lazy)?

Imagem 1: lazy Imagem 2: greedy

Oi! que estranho! o "famoso" na minha máquina funcionou hahah!

mas você conseguiu entender a teoria?

Olá, Gabriel e Estudante.

A explicação do Gabriel funciona bem mas a Regex pode ser demonstrada da seguinte maneira.

Com a Regex em JavaScript a seguir, temos um greedy:

/<(h[1-2])[^>]*>(.*)>/g

Seu retorno será todo o conteúdo:

<h1>Título 1 <span>com subtítulo</span></h1>
<h2>Título 2</h2>

Após a inserção do ? na Regex, temos um lazy:

/<(h[1-2])[^>]*>(.*?)>/g

Que vai capturar apenas 2 matches:

<h1>Título 1 <span>
<h2>Título 2</h2>

Você pode conferir no gif abaixo:

Se o desejo é Não capturar o < span >, você pode adicionar um grupo de não captura.

Acesse o link para testar: https://regex101.com/r/l7iLlX/1