Validateur Regex Go de numéros de téléphone

Utilisez le Validateur Regex Go de numéros de téléphone pour tester et valider les formats de numéros de téléphone via le package regexp de Golang. Cet outil est idéal pour les développeurs et testeurs qui créent des flux d'inscription, des validations de formulaires ou des applications de télécommunication. Vérifiez instantanément si votre regex correspond correctement aux numéros mobiles, aux formats internationaux ou à des patterns de chiffres spécifiques, sans écrire de code supplémentaire.

Besoin de données de test supplémentaires ? Essayez notre Générateur de numéros de téléphone, notre Générateur de codes postaux ou notre Générateur d'adresses pour simuler des données de formulaires réalistes.

Validateur Regex Go de numéros de téléphone - Documentation

Qu'est-ce que le regex de numéros de téléphone en Go ?

En Go (Golang), les expressions régulières sont gérées via la bibliothèque standard regexp. La validation de numéros de téléphone consiste à vérifier des structures spécifiques telles que :

Indicatifs de pays (ex. +91, +1)
Indicatifs de zone
Séparateurs optionnels comme les tirets, espaces ou parenthèses
Longueurs variables selon le pays ou la région

Le regex de numéros de téléphone est particulièrement utile pour :

Les validations de formulaires lors des inscriptions
Les vérifications backend dans les API ou bases de données
Les systèmes de communication SMS/appels
Les logiciels de télécommunication et applications mobiles

Fonctionnalités et constructions du regex Go

Métacaractères

. : Correspond à n'importe quel caractère sauf le saut de ligne.
^ : Ancre au début de la chaîne.
$ : Ancre à la fin de la chaîne.
| : Opérateur OU. Exemple : /fixe|mobile/ correspond à l'un ou l'autre.

Classes de caractères

[0-9] : Correspond à tout chiffre de 0 à 9
[^0-9] : Correspond à tout caractère non numérique
[a-zA-Z] : Correspond à toute lettre

Classes prédéfinies

\d : Correspond à un chiffre. Équivalent à [0-9]
\D : Correspond à un caractère non numérique
\s : Correspond à un espace
\S : Correspond à tout caractère non blanc

Quantificateurs

* : Zéro occurrence ou plus
+ : Une occurrence ou plus
? : Zéro ou une occurrence (optionnel)
{n} : Exactement n fois
{n,} : Au moins n fois
{n,m} : Entre n et m fois

Limiter le nombre de correspondances

Pour que votre recherche regex en Go ne retourne qu'un nombre limité de correspondances, passez un entier positif comme second argument aux fonctions comme FindAllString ou FindAllStringSubmatch. Par exemple, FindAllString("peach punch pinch", 2) ne retourne que les deux premières correspondances.

Exemple de pattern regex pour numéros de téléphone

Pattern courant pour valider les numéros internationaux :

^\+?[1-9]\d{1,3}?[-.\s]?\(?\d{1,4}?\)?[-.\s]?\d{1,9}([-.\s]?\d{1,9})?$

Ce pattern correspond à :

Indicatifs de pays comme +91, +44, +1
Séparateurs optionnels : tirets, points et espaces
Parenthèses autour des indicatifs de zone

Méthodes principales des objets regexp en Go

MatchString / Match : Vérifie rapidement si le pattern correspond à une chaîne ou à un []byte.
FindString / Find : Retourne la première sous-chaîne correspondant au pattern.
FindStringIndex / FindIndex : Retourne les positions de début et de fin de la première correspondance.
FindStringSubmatch / FindSubmatch : Capture aussi les groupes de la correspondance principale.
FindAllString, FindAllStringSubmatch, etc. : Parcourent toute la chaîne et retournent toutes les correspondances. Vous pouvez limiter le nombre de résultats.
ReplaceAllString / ReplaceAll : Remplacent toutes les sous-chaînes correspondantes par une autre valeur.
ReplaceAllFunc : Applique une fonction à chaque correspondance pour une transformation dynamique.

Pour les variables globales de patterns regex, utilisez MustCompile plutôt que Compile afin de détecter les erreurs de syntaxe au démarrage du programme.

Exemples de code Go

Exemple 1 : Validation de base

package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile(^\+?[0-9]{10,15}$)
phone := "+14155552671"
fmt.Println("Valid Phone:", pattern.MatchString(phone))
}

Testez des patterns similaires dans le Testeur Regex Go

Exemple 2 : Numéros de téléphone avec séparateurs

package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile(^$begin:math:text$?\\d{3}$end:math:text$?[-.\s]?\d{3}[-.\s]?\d{4}$)
phone := "(415) 555-2671"
fmt.Println("Valid Format:", pattern.MatchString(phone))
}

Générez de vrais numéros avec le Générateur de numéros de téléphone

Exemple 3 : Test de champ de formulaire avec indicatif de zone

package main
import (
"fmt"
"regexp"
)
func main() {
input := "+91-9876543210"
regex := regexp.MustCompile(^\+91[-\s]?[6-9]\d{9}$)
fmt.Println("Indian Mobile Number Valid:", regex.MatchString(input))
}

Combinez avec le Générateur d'adresses pour des données de test complètes.

Obtenir les index des correspondances en Go

Pour récupérer les positions exactes de début et de fin des correspondances, utilisez la méthode FindStringSubmatchIndex. Par exemple :

fmt.Println(r.FindStringSubmatchIndex("peach punch"))

Trouver la première correspondance

Utilisez la méthode FindString() de Go pour récupérer la première sous-chaîne correspondant à votre regex :

pattern := regexp.MustCompile([a-zA-Z]+)
result := pattern.FindString("peach punch")
// result sera "peach"

Remplacer des sous-chaînes avec le regex en Go

Remplacement de base avec ReplaceAllString

package main
import (
"fmt"
"regexp"
)
func main() {
r := regexp.MustCompile(peach)
result := r.ReplaceAllString("a peach", "")
fmt.Println(result)
}

Remplacement avancé avec des fonctions personnalisées

package main
import (
"bytes"
"fmt"
"regexp"
)
func main() {
r := regexp.MustCompile([a-z]+)
text := []byte("a peach")
result := r.ReplaceAllFunc(text, bytes.ToUpper)
fmt.Println(string(result))
}

Travailler avec des tranches d'octets en Go

En Go, les méthodes regex fonctionnent aussi sur des tranches d'octets ([]byte). Utilisez Match() au lieu de MatchString() :

pattern := regexp.MustCompile(peach)
text := []byte("peach")
fmt.Println("Matches byte slice:", pattern.Match(text))

Conseils pro

Utilisez toujours regexp.MustCompile() pour les patterns statiques afin d'éviter les erreurs à l'exécution.
Utilisez FindStringSubmatch() pour extraire des parties comme les indicatifs de zone ou les extensions.
Évitez les expressions trop gourmandes comme .* ; préférez les quantificateurs comme {10,15} pour plus de précision.
Validez avec de vraies données de test issues d'outils comme le Générateur de numéros de téléphone.
Utilisez le préfixe (?i) pour une correspondance insensible à la casse si nécessaire.

Combiner avec ces outils

Générateur de numéros de téléphone : Générer des numéros fictifs pour la validation.
Générateur d'email : Associer avec un email pour les formulaires d'inscription.
Générateur de noms d'utilisateur : Utiliser pour la création de profils.
Générateur d'adresses : Simuler des formulaires de contact complets.
Générateur de mots de passe : Pour un test complet du flux d'inscription.
Générateur UUID : Combiner pour des identifiants d'appareils ou d'utilisateurs.