Modèle de correspondance d’URL
Aperçu rapide
Les modèles de correspondance permettent de spécifier des groupes d'URL : un modèle de correspondance correspond à un ensemble spécifique d'URL.
Structure du modèle de correspondance
Tous les modèles de correspondance sont spécifiés sous forme de chaînes de caractères. Les modèles de correspondance se composent de trois parties : schéma, hôte et chemin d'accès. Le schéma et l'hôte sont séparés par ://.
<schéma>://<hôte><chemin d'accès>
schéma
Le composant schéma peut être l'un des éléments suivants : http ou https.
hôte
Le composant hôte peut prendre l'une des trois formes suivantes :
| Form | Correspondances |
| * | Tout autre hôte. |
| *. Suivi d'une partie du nom d'hôte | L'hôte en question et tous ses sous-domaines. |
| Un nom d'hôte complet sans caractères génériques | Uniquement l'hôte en question. |
L'hôte ne doit pas inclure de numéro de port.
* Notez que le caractère générique ne peut apparaître qu'au début.
chemin d'accès
Le composant chemin d'accès doit commencer par un /.
Ensuite, il peut contenir n'importe quelle combinaison du caractère générique * et de n'importe quel caractère autorisé dans les chemins d'accès aux URL ou les chaînes de requête. Contrairement à l'hôte , le composant chemin d'accès peut contenir le caractère générique * au milieu ou à la fin, et les caractères génériques * peuvent apparaître plus d'une fois.
La valeur du chemin d'accès est comparée à la chaîne qui est le chemin d'accès à l'URL plus la chaîne de requête de l'URL. Ceci inclut le ? entre les deux, si la chaîne de requête est présente dans l'URL.
Par exemple, si vous souhaitez faire correspondre des URL sur n'importe quel domaine dont le chemin d'accès se termine par foo.bar, vous devez utiliser un tableau de modèles de correspondance comme ['*://*/*foo.bar', '*://*/*foo.bar?*']. Le ?* est nécessaire, plutôt que simplement bar*, afin d'ancrer la terminaison * comme s'appliquant à la chaîne de requête de l'URL et non à une partie du chemin d'accès à l'URL.
Ni l'identifiant du fragment d'URL, ni le # qui le précède, ne sont considérés comme faisant partie du chemin d'accès.
Exemples
| Motif | Exemple de correspondance | Exemple de non-correspondance |
|
https://*/path Faire correspondre les URL HTTPS sur n'importe quel hôte, dont le chemin d'accès est « chemin d'accès ». |
https://mozilla.org/path https://a.mozilla.org/path https://something.com/path |
http://mozilla.org/path (schéma non apparié) https://mozilla.org/path/ (chemin d'accès non apparié) https://mozilla.org/a (chemin d'accès non correspondant) https://mozilla.org/ https://mozilla.org/path?foo=1 |
|
https://*/path/ Faire correspondre les URL HTTPS sur n'importe quel hôte, dont le chemin d'accès est « chemin d'accès/ » et qui n'a pas de chaîne de requête d'URL. |
https://mozilla.org/path/ https://a.mozilla.org/path/ https://something.com/path/ |
http://mozilla.org/path/ (schéma non apparié) https://mozilla.org/path (chemin d'accès non apparié) https://mozilla.org/a (chemin d'accès non correspondant) https://mozilla.org/ https://mozilla.org/path/?foo=1 |
|
https://mozilla.org/* Faire correspondre les URL HTTPS uniquement à « mozilla.org », avec n'importe quel chemin d'accès et chaîne de requête d'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 (schéma non apparié) https://mozilla.com/path (hôte non apparié) |
|
https://mozilla.org/a/b/c/ Faire correspondre uniquement cette URL ou cette URL avec n'importe quel fragment d'URL. |
https://mozilla.org/a/b/c/ https://mozilla.org/a/b/c/#section1 |
Tout autre élément. |
|
https://mozilla.org/*/b/*/ Faire correspondre les URL HTTPS hébergées sur « mozilla.org », dont le chemin d'accès contient un composant « b » quelque part au milieu. Fera correspondre les URL avec des chaînes de requête, si la chaîne se termine par un /. |
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/*/ (chemin non apparié) https://mozilla.org/a/b/ (chemin non apparié) https://mozilla.org/a/b/c/d/?foo=bar (chemin non apparié en raison de la chaîne de requête d'URL) |
Modèles de correspondance invalides
| Modèle non valide | Raison |
| resource://chemin d'accès/ | Schéma non pris en charge. |
| https://mozilla.org | Pas de chemin d'accès. |
| https://mozilla.*.org/ | Le caractère « * » dans l'hôte doit figurer au début. |
| https://*zilla.org/ | Le caractère « * » dans l'hôte doit être le seul caractère ou être suivi de « . ». |
| http*://mozilla.org/ | Le caractère « * » dans le schéma doit être le seul caractère. |
| https://mozilla.org:80/ | L'hôte ne doit pas inclure de numéro de port. |
| https://* | Chemin d'accès vide : il devrait s'agir de « https://*/* ». |
Modèle de correspondance d'URL vs Déclaration de Regex
WalkMe fournit deux options pour la configuration de l'extension : le modèle de correspondance d'URL et Regex. Chaque option a ses propres avantages, et vous trouverez ci-dessous un bref aperçu des deux outils.
Qu'est-ce que Regex et le modèle de correspondance d'URL ?
Le modèle de correspondance d'URL est un moyen d'indiquer à une extension de navigateur les pages web sur lesquelles elle doit travailler. Il utilise une syntaxe spéciale pour spécifier les URL auxquelles l'extension doit s'appliquer. C'est un moyen de définir des modèles qui correspondent aux URL. Ces modèles peuvent être utilisés pour déterminer les pages web avec lesquelles une extension doit interagir lors de l'application de fonctionnalités telles que des scripts de contenu ou des scripts d'arrière-plan. Les modèles de correspondance d'URL sont créés dans le but spécifique de gérer le comportement des extensions de navigateur en fonction des URL qu'elles trouvent.
Regex (expression régulière) Souvent abrégé en regex ou regexp, est une puissante séquence de caractères qui définit un modèle de recherche. Il est utilisé pour la correspondance de modèles dans les chaînes, ce qui vous permet d'effectuer des tâches comme la recherche de modèles spécifiques, l'extraction d'informations ou le remplacement de parties d'un texte. Regex est un outil polyvalent largement utilisé dans le traitement de texte, la validation des données et diverses tâches de programmation.
Comparaison
| Modèle de correspondance d'URL | Regex | |
| But | Créé et optimisé pour les navigateurs web afin de définir les URL auxquelles une extension ou une application de navigateur doit s'appliquer. | Outil puissant pour la correspondance des modèles dans les chaînes. Il vous permet de définir un modèle de recherche à l'aide d'une combinaison de caractères et de méta-caractères. |
| Utilisation | Utilisé par les extensions de navigateur pour spécifier les pages web sur lesquelles elles doivent fonctionner, comme les scripts de contenu ou les scripts d'arrière-plan. | Il peut être utilisé dans un large éventail d'applications tel que le traitement de texte, la validation des données, les opérations de recherche et de remplacement, et plus encore. |
| Syntaxe | Les modèles de correspondance d'URL utilisent une syntaxe spécifique qui comprend des caractères génériques tels que « * » et « ? » pour spécifier les modèles pour les URL. | Les modèles de Regex sont exprimés à l'aide d'une syntaxe spécifique qui comprend des métacaractères tels que « . » (correspond à n'importe quel caractère), « * » (correspond à zéro occurrence ou plus), « + » (correspond à une ou plusieurs occurrences), etc. |
| Exemple | Le modèle https://example.com/* correspondra à n'importe quelle URL qui commence par https://example.com/ . | Ce regex ^(http|https)://example\.com(? :/[^/?#]+)*$ correspond aux URL qui appartiennent au domaine example.com. |
Avantages et avantages
| Modèle de correspondance d'URL | Regex | |
| Pros |
Simplicité pour la correspondance d'URL : spécifiquement pensée pour la correspondance d'URL, ce qui la rend intuitive et facile à utiliser à cette fin. Facile à comprendre : les modèles de correspondance d'URL ont tendance à être plus lisibles et plus simples en comparaison aux regex, assez complexes. Créé pour les extensions de navigateur : l'utilisation de modèles de correspondance d'URL est souvent le moyen recommandé et standard de spécifier les URL avec lesquelles votre extension doit interagir. |
Objectif général: Extrêmement polyvalent et peut être utilisé pour un large éventail de tâches de correspondance de modèles au-delà des URL. C'est un outil puissant pour le traitement et la manipulation de texte. Une syntaxe riche : fournit un ensemble riche de métacaractères et d'expressions qui permettent une correspondance et une manipulation très précises des modèles. Flexibilité des motifs: peut gérer des modèles complexes qui vont au-delà des structures d'URL. Cela comprend la correspondance de caractères, de séquences ou d'ensembles de caractères spécifiques. |
| Cons |
Limité à la correspondance d'URL : spécifiques aux URL correspondantes et ne sont pas adaptées aux tâches de correspondance de modèles d'usage général. Absence de complexité: il manque un ensemble de fonctionnalités riche et une flexibilité des expressions régulières. Ils ne sont pas appropriés pour les tâches qui nécessitent une correspondance de modèles complexes au-delà des structures d'URL. Non approprié pour toutes les applications: ils sont spécifiquement adaptés aux extensions de navigateur web. Si vous travaillez sur des tâches en dehors de cette portée, elles peuvent ne pas être pertinentes. |
Complexité : l'écriture d'expressions régulières complexes peut être difficile et sujette aux erreurs. La maîtrise de la syntaxe peut prendre du temps. Frais généraux de performance : des modèles de regex extrêmement complexes peuvent entraîner un impact important sur les performances, surtout avec des entrées importantes. Lisibilité : les modèles de regex complexes peuvent être difficiles à lire et à comprendre, ce qui rend la maintenance et le débogage difficiles. |
Déclaration officielle WalkMe
WalkMe recommande d'utiliser un modèle de correspondance d'URL pour la configuration de l'extension, si le cas d'utilisation le permet. Nous envisageons Regex en dernier recours lorsqu'il y a un cas extrême. Le modèle de correspondance d'URL garantira une fonctionnalité d'extension transparente et minimisera la validation des règles en arrière-plan, ce qui améliorera également l'expérience de l'utilisateur.
Le modèle de correspondance d'URL est actuellement défini comme outil par défaut pour toute nouvelle configuration du système dans les paramètres d'extension du Centre d'administration.