Suponha que eu pegue uma string como:

can cats eat plants?

O uso de guloso c.*sirá corresponder a toda a string desde que comece ce termine com s, sendo um operador guloso ele continua a corresponder até a ocorrência final de s.

Considerando que usar o lazy c.*?sirá corresponder apenas até que a primeira ocorrência de sseja encontrada, ou seja, string can cats.

A partir do exemplo acima, você pode deduzir que:

"Greedy" significa corresponder à string mais longa possível. "Preguiçoso" significa corresponder à string mais curta possível. Adicionar a ?a um quantificador como *, +, ?ou {n,m}torna-o preguiçoso.

Ashok já apontou a diferença entre .*e .*?, então vou apenas fornecer algumas informações adicionais.

grep(assumindo a versão GNU) suporta 4 maneiras de combinar strings:

• Strings fixas, com a -Fopção
• Expressões regulares básicas (BRE), padrão
• Expressões regulares estendidas (ERE), com a -Eopção
• Expressões regulares compatíveis com Perl (PCRE), com a -Popção em GNU grep

grepusa BRE por padrão.

BRE e ERE estão documentados no capítulo Expressões Regulares do POSIX e PCRE está documentado em seu site oficial . Observe que os recursos e a sintaxe podem variar entre as implementações.

Vale dizer que nem o BRE nem o ERE suportam a preguiça :

O comportamento de vários símbolos de duplicação adjacentes ( '+', '*', '?' e intervalos) produz resultados indefinidos.

Portanto, se você quiser usar esse recurso, precisará usar o PCRE:

# PCRE greedy
$ grep -P -o 'c.*s' <<< 'can cats eat plants?'
can cats eat plants

# PCRE lazy
$ grep -P -o 'c.*?s' <<< 'can cats eat plants?'
can cats

Você poderia explicar um pouco sobre .*vs .*??

• .*é usado para corresponder ao padrão ¹ "mais longo" possível.

• .*?é usado para corresponder ao padrão ¹ "mais curto" possível.

Na minha experiência, o comportamento mais desejado é geralmente o segundo.

Por exemplo, digamos que temos a seguinte string e queremos apenas corresponder às tags html ² , não ao conteúdo entre elas:

<title>My webpage title</title>

Agora compare .*com .*?:

# Greedy
$ grep -P -o '<.*>' <<< '<title>My webpage title</title>'
<title>My webpage title</title>

# Lazy
$ grep -P -o '<.*?>' <<< '<title>My webpage title</title>'
<title>
</title>

<sup>1. O significado de "mais longo" e "mais curto" em um contexto regex é um pouco complicado, como Kusalananda apontou . Consulte a documentação oficial para obter mais informações.
2. Não é recomendado analisar html com regex . Este é apenas um exemplo para fins educacionais, não o use em produção.</sup>

Uma string pode ser correspondida de várias maneiras (do simples ao mais complexo):

1. Como uma string estática (assume var='Hello World!'):

   shell [ "$var" = "Hello World!" ] && echo yes
   grep echo "$var" | grep -F "Hello"
   bashgrep -F "Hello" <<<"$var"

2. Como um globo:

   shellecho ./* # lista todos os arquivos em pwd.
   shell case $var in (*Worl*) echo yes;; (*) echo no;; esac
   bash[[ "$var" == *"Worl"* ]] && echo yes

   Existem globs básicos e estendidos. O caseexemplo usa globs básicos. O exemplo bash [[usa globs estendidos. A primeira correspondência de arquivo pode ser básica ou estendida em algum shell, como configuração extglobno bash. Ambos são idênticos neste caso. Grep não pôde usar globs.

   O asterisco em um glob significa algo diferente de um asterisco em um regex :

   glob * matches any number (including none) ofquaisquer caracteres . elemento precedente
   regex .* matches any number (including none) of the

3. Como uma expressão regular básica (BRE):

   sedecho "$var" | sed 's/W.*d//' # imprimir: Olá!
   grepgrep -o 'W.*d' <<<"$var" # print Mundo !

   Não há BRE em shells (básicos) ou awk.

4. Expressões regulares estendidas (ERE):

   bash[[ "$var" =~ (H.*l) ]] # match: Hello Worl
   sedecho "$var" | sed -E 's/(d|o)//g' # print: Hell Wrl!
   awkawk '/W.*d/{print $1}' <<<"$var" # print: Hello
   grepgrep -oE 'H.*l' <<<"$var" # print: Hello Worl

5. Expressões regulares compatíveis com Perl:

   grepgrep -oP 'H.*?l # imprimir: Hel

Somente em um PCRE a *?tem algum significado de sintaxe específico.
Isso torna o asterisco preguiçoso (sem ganância): preguiça em vez de ganância .

$ grep -oP 'e.*l' <<<"$var"
ello Worl

$ grep -oP 'e.*?l' <<<"$var"
el

Isso é só a ponta do iceberg, existem gananciosos, preguiçosos e dóceis ou possessivos . Há também lookahead e lookbehind, mas esses não se aplicam ao asterisco *.

Existe uma alternativa para obter o mesmo efeito de um regex não ganancioso:

$ grep -o 'e[^o]*o' <<<"$var"
ello

A ideia é muito simples: não use um ponto ., negue o próximo caractere correspondente [^o]. Com uma etiqueta da web:

$ grep -o '<[^>]*>' <<<'<script type="text/javascript">document.write(5 + 6);</script>'
<script type="text/javascript">
</script>

O acima deve esclarecer completamente todos os comentários do @Bob 3. Parafraseando:

• A .* é um regex comum, não um glob.
• Apenas um regex pode ser compatível com PCRE.
• No PCRE: a ? modifique o quantificador *. .*é ganancioso .*?não é.

Perguntas

• Quais são as diferenças no uso de . ? vs. ?

  • A .*?é válido apenas na sintaxe PCRE.
  • A .*é mais portátil.
  • O mesmo efeito de uma correspondência não gananciosa pode ser feito substituindo o ponto por um intervalo de caracteres negado:[^a]*

• Qual é melhor e em que circunstâncias? Forneça exemplos.
  Melhor? Depende do objetivo. Não há melhor, cada um é útil para propósitos diferentes. Eu forneci vários exemplos acima. Precisa de mais?