Padrão de correspondência de URL

Last Updated junho 2, 2026

Breve Visão Geral

O Match Patterns permite especificar grupos de URLs aos quais uma extensão do navegador deve ser aplicada. Cada padrão de correspondência corresponde a um conjunto específico de URLs.

Estrutura do Padrão de Correspondência

Todos os padrões de correspondência são especificados como strings e consistem em três partes: scheme, host e path. O esquema e o host são separados por ://.

<scheme>://<host><path>

Esquema

O esquema pode ser http ou https.

Host

O componente host assume uma de três formas:

  • * — Corresponde a qualquer host
  • *. seguido de parte do hostname — Corresponde ao host determinado e a qualquer um de seus subdomínios
  • Um hostname completo sem curingas — Corresponde apenas ao host indicado
Observação

O host não deve incluir um número de porta. O caractere curinga pode aparecer apenas no início.

Caminho

O caminho deve começar com /. Depois disso, ele pode conter qualquer combinação de * curinga e quaisquer caracteres permitidos em caminhos de URL ou strings de consulta. Ao contrário do host, o caminho pode conter o * curinga no meio ou no final, e os curingas podem aparecer mais de uma vez.

O caminho corresponde ao caminho do URL e à string de consulta de URL, incluindo o ? entre eles, se houver uma string de consulta.

Por exemplo, para combinar URLs em qualquer domínio onde o caminho termine em foo.bar, use um array de padrões de correspondência, como ['*://*/*foo.bar', '*://*/*foo.bar?*']. O ?* ancorará o final * na string de consulta, em vez de no caminho do URL.

Observação

  • Os identificadores de fragmentos de URL e o # que os precede não são considerados parte do caminho.
  • A string do padrão de caminho não deve incluir um número de porta. Adicionar uma porta — por exemplo, http://localhost:1234/* — faz com que o padrão de correspondência seja ignorado. No entanto, http://localhost:1234 corresponde a http://localhost/*.

Exemplos

Padrão Exemplos de correspondências Exemplos de não-correspondências

https://*/path

Corresponda URLs HTTPS em qualquer host, cujo caminho seja "path".

https://mozilla.org/path

https://a.mozilla.org/path

https://something.com/path

http://mozilla.org/path
(esquema incomparável) https://mozilla.org/path/
(caminho não correspondente) https://mozilla.org/a
(caminho não correspondente) https://mozilla.org/
(caminho não correspondente) https://mozilla.org/path?foo=1
(caminho incompatível devido à string de consulta de URL)

https://*/path/

Corresponda URLs HTTPS em qualquer host, cujo caminho seja "path/" e que não tenha uma string de consulta de URL.

https://mozilla.org/path/

https://a.mozilla.org/path/

https://something.com/path/

http://mozilla.org/path/
(schema sem correspondência) https://mozilla.org/path
(caminho não correspondente) https://mozilla.org/a
(caminho não correspondente) https://mozilla.org/
(caminho não correspondente) https://mozilla.org/path/?foo=1
(caminho incompatível devido à string de consulta de URL)

https://mozilla.org/*

Corresponde URLs HTTPS apenas em "mozilla.org", com qualquer caminho de URL e string de consulta de URL.

https://mozilla.org/

https://mozilla.org/path

https://mozilla.org/another

https://mozilla.org/path/to/doc

https://mozilla.org/path/to/doc?foo=1

http://mozilla.org/path
(esquema não correspondente) https://mozilla.com/path
(host não correspondente)

https://mozilla.org/a/b/c/

Corresponda apenas este URL ou este URL com qualquer fragmento de URL.

https://mozilla.org/a/b/c/

https://mozilla.org/a/b/c/#section1

Qualquer outra coisa.

https://mozilla.org/*/b/*/

Corresponda aos URLs HTTPS hospedados em "mozilla.org", cujo caminho contém um componente "b" em algum lugar no meio. Irá combinar URLs com strings de consulta, se a string terminar em /.

https://mozilla.org/a/b/c/

https://mozilla.org/d/b/f/

https://mozilla.org/a/b/c/d/

https://mozilla.org/a/b/c/d/#section1

https://mozilla.org/a/b/c/d/?foo=/

https://mozilla.org/a?foo=21314&bar=/b/&extra=c/

https://mozilla.org/b/*/
(caminho não correspondente) https://mozilla.org/a/b/
(caminho não correspondente) https://mozilla.org/a/b/c/d/?foo=bar
(caminho não correspondente devido à string de consulta URL)

Padrões de correspondência inválidos

  • resource://path/ — Scheme não suportado.
  • https://mozilla.org — Sem caminho.
  • https://mozilla.org/* em host deve estar no início.
  • https://*zilla.org/* em host deve conter o único caractere ou ser seguido de ..
  • http*://mozilla.org/* em esquema deve ser o único caractere.
  • https://mozilla.org:80/ — O Host não deve incluir um número de porta.
  • https://* — Caminho vazio: deve ser https://*/*.

Padrão de correspondência de URL vs Regex

O WalkMe permite configurar extensões usando o padrão de correspondência de URL ou o Regex. Veja como eles se comparam.

Padrão de correspondência de URL

O padrão de correspondência de URL é criado especificamente para extensões de navegador. Ele usa uma sintaxe simples com caracteres curingas para definir a quais URLs uma extensão deve ser aplicada — por exemplo, scripts de Conteúdo ou scripts de plano de fundo.

Regex

O Regex (expressão regular) é uma ferramenta poderosa e de uso geral para correspondência de padrões dentro de strings. Ele permite pesquisar, extrair ou substituir texto usando uma combinação de caracteres e metacaracteres. É amplamente utilizado no processamento de texto, validação de dados e programação.

Comparação

O padrão de correspondência de URL de finalidade é criado e otimizado para navegadores da Web para definir a quais URLs uma extensão de navegador deve ser aplicada.
O Regex é uma ferramenta poderosa para comparar padrões em strings, usando uma combinação de caracteres e metacaracteres.

O padrão de correspondência de URL de uso é utilizado por extensões de navegador para especificar em quais páginas da Web elas devem operar.
O Regex pode ser usado em uma ampla gama de aplicativos, como processamento de texto, validação de dados e operações de pesquisa e substituição.

O padrão de correspondência de URL de sintaxe usa caracteres curingas como * e ? para especificar padrões de URL. O Regex usa metacaracteres como . (qualquer caractere), * (zero ou mais ocorrências) e + (uma ou mais ocorrências).

Exemplo de padrão de correspondência de URL: https://example.com/* corresponde a qualquer URL começando por https://example.com/. Regex: ^(http|https)://example\.com(?:/[^/?#]+)*$ corresponde aos URLs pertencentes a example.com.

Prós e contras

Padrão de correspondência de URL — prós

  • Simples e intuitivo para correspondência de URLs
  • Mais legível do que regex complexos
  • O padrão recomendado para extensões do navegador

Padrão de correspondência de URL — contras

  • Limitado apenas à correspondência de URLs
  • Não é adequado para correspondência de padrões de propósito geral
  • Adaptado especificamente para extensões de navegador

Regex — prós

  • Versátil em uma ampla gama de tarefas de correspondência de padrões
  • Sintaxe avançada para correspondência altamente precisa
  • Pode lidar com padrões complexos além das estruturas de URL

Regex — contras

  • Expressões complexas podem ser desafiadoras e propensas a erros
  • Padrões extremamente complexos podem causar problemas de desempenho
  • Difícil de ler e manter

Recomendação do WalkMe

O WalkMe recomenda usar o padrão de correspondência de URL para a configuração da extensão sempre que possível. O Regex deve ser um último recurso para casos extremos. O padrão de correspondência de URL garante a funcionalidade perfeita da extensão, minimiza a validação de regras nos bastidores e oferece uma experiência geral melhor.

O padrão de correspondência de URL é o padrão para qualquer nova configuração do sistema nos Ajustes da extensão do Admin.

Was this article helpful?

Thanks for your feedback!

Faça parte de algo maior.

Interaja com colegas, tire dúvidas e compartilhe ideias.

Explore nossa comunidade
×