Validateur URL Regex Go

Le Validateur URL Regex Go de Qodex aide les développeurs à tester et valider rapidement si une chaîne est un lien web valide en utilisant des expressions régulières en Go. Cet outil est idéal pour construire ou déboguer des applications Go qui s'appuient sur l'analyse de liens, la validation d'entrées ou le scraping web. Combinez-le avec le Validateur Email Regex Go, le Validateur Numéro de Téléphone Regex Go et le Testeur Regex Go pour créer une logique de validation robuste et sécurisée.

Validateur URL Regex Go - Documentation

Qu'est-ce que URL Regex en Go ?

En Go (Golang), les expressions régulières sont gérées par le package intégré regexp. Un regex URL est un pattern utilisé pour correspondre à des liens web valides comme https://example.com/path.

Utilisez regex Go pour :

Valider des entrées web (liens, APIs)
Nettoyer des URLs extraites par scraping
Construire des correspondances de routes dans des systèmes backend
Analyser et extraire des composants d'URLs

Métacaractères utilisés dans URL Regex

^ : ancre le pattern au début de la chaîne.
$ : ancre le pattern à la fin de la chaîne.
. : correspond à tout caractère sauf saut de ligne.
+ : un ou plusieurs du token précédent.
* : zéro ou plusieurs du token précédent.
? : zéro ou un du token précédent.
[] : correspond à un caractère d'un ensemble.
() : groupe des tokens ensemble.
| : opérateur logique OU.
\\ : échappe un métacaractère.

Comment ça fonctionne

Saisissez votre pattern regex URL.
Collez la chaîne URL que vous souhaitez valider.
Cliquez sur «Valider» pour vérifier la correspondance.
Utilisez «Essayer un autre» pour répéter avec différents exemples.

Exemple 1 - Validateur URL de base en Go

Testez votre logique regex complète avec le Testeur Regex Go.

package main
import (
"fmt"
"regexp"
)
func isValidURL(url string) bool {
var pattern = ^(http|https)://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(/[a-zA-Z0-9-._~:?#@!$&amp;'()*+,;=]*)*$
urlRegex := regexp.MustCompile(pattern)
return urlRegex.MatchString(url)
}
func main() {
testURL := "https://www.example.com/search?q=test"
fmt.Println("Valid URL:", isValidURL(testURL))
}

Exemples :

Entrée : "https://www.example.com/search?q=test"
Sortie : Valid URL: true
Explication : Cette URL est correctement formatée et correspond au pattern de validation.
Entrée : "https://www.example.com/ ,search"
Sortie : Valid URL: false
Explication : Cette URL contient un espace après une virgule, ce qui la rend invalide selon le pattern.

Exemple 2 - Correspondance des URLs raccourcies

Testez aussi ce pattern dans le Testeur Regex JavaScript si vous travaillez sur la validation frontend.

var shortURL = "http://bit.ly/3abc"
var regex = regexp.MustCompile(^https?://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(/[a-zA-Z0-9-]*)?$)
fmt.Println("Valid short URL:", regex.MatchString(shortURL))

Exemples :

Entrée : "http://bit.ly/3abc"
Sortie : Valid short URL: true
Explication : Cette URL raccourcie correspond au pattern pour les liens raccourcis.
Entrée : "http://bit.ly/ 3abc"
Sortie : Valid short URL: false
Explication : Un espace après le domaine entraîne l'échec de la validation.

Conseil : Que vous construisiez un backend Go ou un frontend JavaScript, adaptez toujours vos expressions régulières au format d'entrée attendu et testez-les rigoureusement avec des exemples réels.

Exemple 3 - Vérification d'un slash final optionnel

Besoin d'un domaine ou d'une IP réaliste pour les tests ? Utilisez notre Générateur de noms de domaine ou le Générateur IPv4.

var urlWithSlash = "https://qodex.ai/"
var regex = regexp.MustCompile(^https?://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/?$)
fmt.Println("URL has optional trailing slash:", regex.MatchString(urlWithSlash))

Exemples :

Entrée : "https://qodex.ai/"
Sortie : true
Explication : Cette URL se termine par un slash, ce qui est autorisé par le pattern.
Entrée : "https://qodex.ai"
Sortie : true
Explication : Le slash final est optionnel, les deux formes sont valides.

Complexité temporelle et spatiale pour la validation URL

Complexité temporelle : O(N) où N est la longueur de l'URL en entrée, le moteur regex examinant chaque caractère une fois.
Complexité spatiale : O(1), aucune mémoire supplémentaire significative n'est nécessaire au-delà de quelques variables.

Les vérifications d'URL par regex sont rapides et légères, adaptées aussi bien aux vérifications de formulaire instantanées qu'aux outils d'analyse de données à grande échelle.

Bonnes pratiques pour URL Regex en Go

Ancrez toujours les patterns avec ^ et $ pour éviter les correspondances partielles.
Échappez le . en \. pour correspondre aux points littéraux dans les noms de domaine.
Utilisez https? pour autoriser les protocoles HTTP et HTTPS.
Utilisez + pour autoriser plusieurs caractères de chemin.
Validez les URLs complètes incluant les chaînes de requête et les chemins pour une vérification robuste.

Cas d'utilisation courants

Validation des entrées de formulaire (URLs soumises par les utilisateurs)
Nettoyage des sorties de scraper web
Analyse d'URL API
Validation de liens CMS
Validation de trackers de campagne marketing

Exemple - Validation URL en Python

Les expressions régulières ne sont pas réservées à Go ! Si vous construisez des backends Python, vous pouvez valider des URLs avec le module re en quelques lignes.

import re
def is_valid_url(url):
# Basic URL validation regex
pattern = r'^(https?://)?[a-zA-Z0-9.-]+.[a-zA-Z]{2,}(/[^\s]*)?$'
return re.match(pattern, url) is not None
Example usage
test_url = "https://www.example-site.org/path?query=123"
print("Valid URL:", is_valid_url(test_url))

Quelques points à garder en tête :

Le https?:// rend le protocole optionnel ou autorise HTTP et HTTPS.
Les points sont échappés pour n'accepter que de vrais segments de domaine.
Ce pattern autorise des chemins ou des chaînes de requête optionnels après le domaine racine.
Pour une validation très stricte (incluant ports, IPs, domaines Unicode, etc.), envisagez d'étendre le regex ou d'utiliser des bibliothèques dédiées.

Validation URL en Java avec des expressions régulières

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class URLValidator {
public static boolean isValidURL(String url) {
// Basic URL regex for http/https with optional www and path
String regex = "^(https?://)(www\.)?[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(/[a-zA-Z0-9-._~:/?#@!$&'()+,;=])?$";
Pattern pattern = Pattern.compile(regex);
if (url == null) return false;
Matcher matcher = pattern.matcher(url);
return matcher.matches();
}
public static void main(String[] args) {
    String testURL = "https://www.admin.google.com/";
    System.out.println("Is valid URL? " + isValidURL(testURL));
}

}

Comment ça fonctionne :

Le pattern regex prend en charge http et https, avec ou sans www.
Il correspond aux noms de domaine avec les extensions standard et autorise les caractères URL courants dans le chemin.
Appelez simplement isValidURL() avec votre chaîne d'entrée pour vérifier si elle correspond au format URL attendu.

Combinez avec ces outils

Validateur Email Regex Go - Validez les emails avec regex
Générateur de numéros de téléphone - Obtenez des numéros fictifs pour les tests de formulaire
Générateur de noms d'utilisateur - Générez des noms d'utilisateur de test pour des profils complets
Générateur de noms de domaine - Utilisez avec URL regex pour tester les sous-domaines
Générateur de mots de passe - Créez des simulations de connexion complètes