Please log in to continue
WalkMe stores your data in the region chosen during account setup.
We have data centers in the US and EU that follow local privacy and compliance laws. If you're not sure which region to select, check with your admin.
Os padrões de correspondência são uma maneira de especificar grupos de URLs: um padrão de correspondência corresponde a um conjunto específico de URLs.
Todos os padrões de correspondência são especificados como strings. Os padrões de correspondência consistem em três partes: schema , host e caminho. O esquema e o host são separados por ://.
<scheme>://<host><path>
O componente do esquema pode ser um dos seguintes: http ou https.
O componente host pode assumir uma das três formas:
| Formulário | Corresponde |
| * | Qualquer host. |
| *. Seguido de parte do nome do host | O host dado e qualquer um dos seus subdomínios. |
| Um nome de host completo sem curingas | Apenas o host especificado. |
O host não deve incluir um número de porta.
* Observe que o curinga pode aparecer apenas no início.
O componente caminho deve começar com um /.
Depois disso, ele pode conter qualquer combinação do curinga * e qualquer um dos caracteres permitidos nos caminhos de URL ou nas strings de consulta. Ao contrário host , o componente caminho pode conter o curinga * no meio ou no final, e os curingas * podem aparecer mais de uma vez.
O valor do caminho corresponde à string, que é o caminho do URL mais a string de consulta do URL. Isso inclui o ? entre os dois, se a string de consulta estiver presente no URL.
Por exemplo, se você quiser corresponder URLs em qualquer domínio onde o caminho da URL termine com foo.bar, será necessário usar uma matriz de padrões de correspondência, como ['*://*/*foo.bar', '*://*/*foo.bar?*']. O ?* é necessário, em vez de apenas barra*, para ancorar o término * como se aplicando à string de consulta de URL e não a alguma parte do caminho do URL.
Nem o identificador do fragmento de URL nem o # que o precede são considerados parte do caminho.
| 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 incomparável) https://mozilla.org/ https://mozilla.org/path?foo=1 |
|
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/ (esquema incomparável) https://mozilla.org/path (caminho não correspondente) https://mozilla.org/a (caminho incomparável) https://mozilla.org/ https://mozilla.org/path/?foo=1 |
|
https://mozilla.org/* Compare URLs HTTPS apenas em "mozilla.org", com qualquer caminho de URL e cadeia 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 incomparável) https://mozilla.com/path (host incomparável) |
|
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ão inválido | Motivo |
| resource://path/ | Esquema não suportado. |
| https://mozilla.org | Sem caminho. |
| https://mozilla.*.org/ | "*" em host deve estar no início. |
| https://*zilla.org/ | "*" em host deve ser o único caractere ou ser seguido de ".". |
| http*://mozilla.org/ | "*" no 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://*/*". |
O WalkMe fornece duas opções para configuração da extensão - padrão de correspondência de URL e Regex. Cada opção tem suas próprias vantagens, e abaixo está uma breve visão geral de ambas as ferramentas.
O padrão de correspondência de URL é uma maneira de informar a uma extensão do navegador em quais páginas da Web ela deve funcionar. Ele usa uma sintaxe especial para especificar os URLs aos quais a extensão deve ser aplicada. É uma maneira de definir padrões que correspondem aos URLs. Esses padrões podem ser usados para determinar com quais páginas da Web uma extensão deve interagir ao aplicar recursos como scripts de conteúdo ou scripts de plano de fundo. Os padrões de correspondência de URL são projetados com o objetivo específico de controlar o comportamento das extensões do navegador com base nos URLs que encontram.
Regex (Expressão regular) Frequentemente abreviado como regex ou regexp, é uma poderosa sequência de caracteres que define um padrão de pesquisa. Ele é usado para correspondência de padrões dentro de strings, permitindo que você execute tarefas como pesquisar padrões específicos, extrair informações ou substituir partes de um texto. Regex é uma ferramenta versátil amplamente usada no processamento de texto, validação de dados e várias tarefas de programação.
| Padrão de correspondência de URL | Regex | |
| Finalidade | Criado e otimizado para navegadores da Web para definir a quais URLs uma extensão ou aplicativo do navegador deve se aplicar. | Ferramenta poderosa para correspondência de padrões em strings. Ele permite definir um padrão de pesquisa usando uma combinação de caracteres e metacaracteres. |
| Uso | Usado pelas extensões do navegador para especificar em quais páginas da Web devem operar, como scripts de conteúdo ou scripts de plano de fundo. | Pode ser usado em uma ampla gama de aplicativos, como processamento de texto, validação de dados, operações de pesquisa e substituição e muito mais. |
| Sintaxe | Os padrões de correspondência de URL usam uma sintaxe específica que inclui caracteres curingas como '*' e '?' para especificar padrões para URLs. | Os padrões Regex são expressos usando uma sintaxe específica que inclui metacaracteres como '. ' (corresponde a qualquer caractere), '*' (corresponde a zero ou mais ocorrências), '+' (corresponde a uma ou mais ocorrências), etc. |
| Exemplo | O padrão https://example.com/* corresponderá a qualquer URL que comece com https://example.com/ . | Esse regex ^(http|https)://example\.com(?:/[^/?#]+)*$ corresponde aos URLs que pertencem ao domínio example.com. |
| Padrão de correspondência de URL | Regex | |
| Prós |
Simplicidade para correspondência de URLs: projetado especificamente para correspondência de URLs, tornando-o intuitivo e fácil de usar para essa finalidade. Fácil de entender: os padrões de correspondência de URL tendem a ser mais legíveis e diretos em comparação com os regex complexos. Projetado para extensões de navegador: usar padrões de correspondência de URL é geralmente a maneira recomendada e padrão de especificar com quais URLs sua extensão deve interagir. |
Finalidade geralExtremamente versátil e pode ser usado para uma ampla gama de tarefas de correspondência de padrões além de apenas URLs. É uma ferramenta poderosa para processamento e manipulação de texto. Sintaxe rica: fornece um conjunto rico de metacaracteres e expressões que permitem a correspondência e manipulação de padrões altamente precisas. Flexibilidade do padrão: Pode lidar com padrões complexos que vão além das estruturas de URL. Isso inclui a correspondência de caracteres, sequências ou conjuntos de caracteres específicos. |
| Contras |
Limitado à correspondência de URLs: específico para correspondência de URLs e não adequado para tarefas de correspondência de padrões de uso geral. Falta de complexidade: Falta o rico conjunto de recursos e a flexibilidade das expressões regulares. Eles não são adequados para tarefas que exigem correspondência de padrões intrincados além das estruturas de URL. Não é adequado para todas as aplicações: Eles são adaptados especificamente para extensões de navegador da web. Se você estiver trabalhando em tarefas fora desse escopo, elas podem não ser relevantes. |
Complexidade: Escrever expressões regulares complexas pode ser desafiador e propenso a erros. Pode levar tempo para dominar a sintaxe. Sobredespesas de desempenho: padrões de regex extremamente complexos podem levar a um impacto severo no desempenho, especialmente com entradas grandes. Legibilidade: padrões complexos de regex podem ser difíceis de ler e entender, dificultando a manutenção e a depuração. |
O WalkMe recomenda usar o padrão de correspondência de URL para a configuração da extensão, se o caso de uso permitir. Consideramos o Regex como um último recurso quando há uma necessidade extrema. O padrão de correspondência de URL garantirá a funcionalidade perfeita da extensão e minimizará a validação das regras nos bastidores, o que também proporcionará uma melhor experiência ao usuário.
O padrão de correspondência de URL está definido atualmente como ferramenta padrão para qualquer nova configuração do sistema nas configurações de extensão da Central de Administração.