Regex pour les noms avec des caractères spéciaux (Unicode)

Ok, j'ai lu sur les regex tous les jours maintenant, et ne comprends toujours pas correctement. Ce que j'essaie de faire est de valider un nom, mais les fonctions que je peux trouver pour ça sur internet, utilisez uniquement [a-zA-Z]laissant les personnages que j'ai besoin d'accepter.

En gros, j'ai besoin d'une regex qui vérifie que le nom est d'au moins deux mots, et qu'il ne contient pas de chiffres ou de caractères spéciaux comme !"#¤%&/()=...cependant les mots peuvent contenir des caractères comme æ, é, Â et ainsi de suite...

Un exemple d'un nom accepté: "John Elkjærd" ou "André Svenson"
Un non-accepté le nom serait: "Hans", "H4nn3 Andersen" ou "Martin Henriksen!"

Si c'est important je utiliser le javascript .match() fonction côté client et que vous voulez utiliser php preg_replace() seulement "en négatif" côté serveur. (la suppression de la non-correspondance des caractères).

Toute aide serait grandement appréciée.

Mise à jour:
Ok, merci pour Alix Axel réponse j'ai la partie importante vers le bas, le côté serveur.

Mais comme la page de LightWing réponse l'indique, je ne suis pas en mesure de trouver quelque chose sur le support de l'unicode pour le javascript, je me suis donc retrouvé avec la moitié d'une solution pour le côté client, juste vérifier pour au moins deux mots et le minimum de 5 caractères comme ceci:

if(name.match(/\S+/g).length >= minWords && name.length >= 5) {
  //valid
}

Une alternative serait de spécifier tous les caractères unicode comme suggéré dans sournois de la réponseje pourrais faire la même chose, avec la solution ci-dessus, mais c'est un peu infaisable.

source d'informationauteur Kristoffer la Cour

Essayer l'expression régulière suivante:

^(?:[\p{L}\p{Mn}\p{Pd}\'\x{2019}]+\s[\p{L}\p{Mn}\p{Pd}\'\x{2019}]+\s?)+$

En PHP cela se traduit par:

if (preg_match('~^(?:[\p{L}\p{Mn}\p{Pd}\'\x{2019}]+\s[\p{L}\p{Mn}\p{Pd}\'\x{2019}]+\s?)+$~u', $name) > 0)
{
    //valid
}

Vous devriez le lire comme ceci:

^   # start of subject
    (?:     # match this:
        [           # match a:
            \p{L}       # Unicode letter, or
            \p{Mn}      # Unicode accents, or
            \p{Pd}      # Unicode hyphens, or
            \'          # single quote, or
            \x{2019}    # single quote (alternative)
        ]+              # one or more times
        \s          # any kind of space
        [               #match a:
            \p{L}       # Unicode letter, or
            \p{Mn}      # Unicode accents, or
            \p{Pd}      # Unicode hyphens, or
            \'          # single quote, or
            \x{2019}    # single quote (alternative)
        ]+              # one or more times
        \s?         # any kind of space (0 or more times)
    )+      # one or more times
$   # end of subject

Honnêtement, je ne sais pas comment le port de cette, Javascript, je ne suis même pas sûr Javascript prend en charge Unicode propriétés, mais en PHP PCRE ce semble fonctionner parfaitement @ IDEOne.com:

$names = array
(
    'Alix',
    'André Svenson',
    'H4nn3 Andersen',
    'Hans',
    'John Elkjærd',
    'Kristoffer la Cour',
    'Marco d\'Almeida',
    'Martin Henriksen!',
);

foreach ($names as $name)
{
    echo sprintf('%s is %s' . "\n", $name, (preg_match('~^(?:[\p{L}\p{Mn}\p{Pd}\'\x{2019}]+\s[\p{L}\p{Mn}\p{Pd}\'\x{2019}]+\s?)+$~u', $name) > 0) ? 'valid' : 'invalid');
}

Je suis désolé je ne peux pas vous aider concernant la partie Javascript, mais probablement quelqu'un d'ici.

Valide:

Jean Elkjærd
André Svenson
Marco d'Almeida
Kristoffer la Cour

Invalide:

Hans
H4nn3 Andersen
Martin Henriksen!

Pour remplacer des caractères non valides, même si je ne suis pas sûr de savoir pourquoi vous avez besoin de cela, vous avez juste besoin de modifier légèrement:

$name = preg_replace('~[^\p{L}\p{Mn}\p{Pd}\'\x{2019}\s]~u', '$1', $name);

Exemples:

H4nn3 Andersen -> Hnn Andersen
Martin Henriksen! -> Martin Henriksen

Notez que vous devez toujours utiliser le u modificateur.

3

Concernant JavaScript, il est plus délicate, car JavaScript syntaxe Regex ne supporte pas les propriétés des caractères unicode. Une solution pragmatique serait de correspondre à ce genre de lettres:
```
[a-zA-Z\xC0-\uFFFF]
```
Cela permet des lettres dans toutes les langues et exclut les nombres et toutes les spéciales (non-lettre) caractères les plus couramment trouvés sur les claviers. Il est imparfaite, car elle permet également de l'unicode des symboles spéciaux qui ne sont pas des lettres, par exemple, des émoticônes, bonhomme de neige et ainsi de suite. Toutefois, étant donné que ces symboles ne sont généralement pas disponibles sur un clavier, je ne pense pas qu'ils seront entrés par accident. Donc, en fonction de vos exigences, il peut être une solution acceptable.
2

visiter cette page Les Caractères Unicode dans les Expression Régulière
2

vous pouvez ajouter le permis de caractères spéciaux pour les regex.

exemple:
```
[a-zA-ZßöäüÖÄÜæé]+
```
EDIT:

pas la meilleure solution, mais ce serait donner un résultat si il y en a au moins pour les mots.
```
[a-zA-ZßöäüÖÄÜæé]+\s[a-zA-ZßöäüÖÄÜæé]+
```
2

Voici une optimisation sur le fantastique réponse par @Alix ci-dessus. Il supprime la nécessité de définir le caractère de classe deux fois, et facilite la définition d'un certain nombre de mots.
```
^(?:[\p{L}\p{Mn}\p{Pd}\'\x{2019}]+(?:$|\s+)){2,}$
```
Elle peut être décomposée comme suit:
```
^         # start
  (?:       # non-capturing group
    [         # match a:
      \p{L}     # Unicode letter, or
      \p{Mn}    # Unicode accents, or
      \p{Pd}    # Unicode hyphens, or
      \'        # single quote, or
      \x{2019}  # single quote (alternative)
    ]+        # one or more times
    (?:       # non-capturing group
      $         # either end-of-string
    |         # or
      \s+       # one or more spaces
    )         # end of group
  ){2,}     # two or more times
$         # end-of-string
```
Essentiellement, c'est à dire que pour trouver un mot tel que défini par la classe de caractères, puis trouver un ou plusieurs espaces ou une fin de ligne. Le {2,} à la fin raconte qu'un minimum de deux mots doit être trouvé pour un match de réussir. Cela garantit l'OP "Hans" exemple ne correspondra pas.

Enfin, depuis que j'ai découvert à cette question tout en regardant pour une solution similaire pour les rubyvoici l'expression régulière que peut être utilisé à Ruby 1.9+
```
\A(?:[\p{L}\p{Mn}\p{Pd}\'\U+2019]+(?:\Z|\s+)){2,}\Z
```
Les principaux changements sont à l'aide de \A et \Z pour le début et la fin de la chaîne (au lieu de la ligne) et de Rubis de caractères Unicode notation.
0

Lors de la vérification de votre chaîne d'entrée vous pourriez
- trim() pour supprimer le avant/après des espaces
- match contre les [^\w\s] pour détecter les non-mot\non les espaces
- match contre \s+ pour obtenir le nombre de séparateurs de mots qui équivaut à un certain nombre de mots + 1.
Cependant, je ne suis pas sûr que le \w abréviation inclut les caractères accentués, mais il devrait tomber dans le "mot" personnages de la catégorie.
0

C'est le JS regex que j'utilise pour les noms de fantaisie composé avec max 3 mots (1 à 60 caractères), séparés par un espace unique/citation/signe moins
```
^([a-zA-Z\xC0-\uFFFF]{1,60}[ \-\']{0,1}){1,3}$
```

Vous devez vous connecter pour publier un commentaire.