Expression régulière pour les caractères alphanumériques et les traits de soulignement

Je voudrais avoir une expression régulière qui vérifie si une chaîne ne contient que des lettres majuscules et minuscules, des chiffres et des traits de soulignement.

Pour faire correspondre une chaîne qui ne contient que ces caractères (ou une chaîne vide), essayez

"^[a-zA-Z0-9_]*$"

Cela fonctionne pour les expressions régulières .NET, et probablement pour beaucoup d'autres langages également.

Décomposer:

^ : start of string
[ : beginning of character group
a-z : any lowercase letter
A-Z : any uppercase letter
0-9 : any digit
_ : underscore
] : end of character group
* : zero or more of the given characters
$ : end of string

Si vous ne souhaitez pas autoriser les chaînes vides, utilisez + au lieu de *.

Comme d'autres l'ont souligné, certaines langues d'expression régulière ont une forme abrégée pour [a-zA-Z0-9_]. Dans le langage regex .NET, vous pouvez activer le comportement ECMAScript et l'utiliser \wcomme raccourci (cédant ^\w*$ou ^\w+$). Notez que dans d'autres langues, et par défaut dans .NET, \west un peu plus large, et correspondra également à d'autres sortes de caractères Unicode (merci à Jan de l'avoir signalé). Donc, si vous avez vraiment l'intention de ne faire correspondre que ces caractères, il est probablement préférable d'utiliser la forme explicite (plus longue).

Il y a beaucoup de verbosité ici, et je suis profondément contre, donc, ma réponse concluante serait:

/^\w+$/

\west équivalent à [A-Za-z0-9_], ce qui est à peu près ce que vous voulez. (sauf si nous introduisons unicode dans le mix)

En utilisant le +quantificateur, vous associez un ou plusieurs caractères. Si vous souhaitez également accepter une chaîne vide, utilisez *plutôt.

Vous souhaitez vérifier que chaque personnage correspond à vos besoins, c'est pourquoi nous utilisons:

[A-Za-z0-9_]

Et vous pouvez même utiliser la version raccourcie:

\w

Ce qui est équivalent (dans certaines versions regex, assurez-vous donc de vérifier avant de l'utiliser). Ensuite, pour indiquer que la chaîne entière doit correspondre, vous utilisez:

^

Pour indiquer que la chaîne doit commencer par ce caractère, puis utilisez

$

Pour indiquer que la chaîne doit se terminer par ce caractère. Ensuite, utilisez

\w+ or \w*

Pour indiquer "1 ou plus" ou "0 ou plus". Dans l'ensemble, nous avons:

^\w*$

Um ... question: faut-il avoir au moins un personnage ou pas? Peut-il s'agir d'une chaîne vide?

^[A-Za-z0-9_]+$

Fera au moins une majuscule ou une minuscule alphanumérique ou un soulignement. S'il peut être de longueur nulle, remplacez simplement le + par *

^[A-Za-z0-9_]*$

Éditer:

Si des signes diacritiques doivent être inclus (tels que cedilla - ç), vous devrez utiliser le mot caractère qui fait la même chose que ci-dessus, mais inclut les caractères diacritiques:

^\w+$

Ou

^\w*$

Bien que ce soit plus verbeux que \w, j'apprécie personnellement la lisibilité des noms de classe de caractères POSIX complets ( http://www.zytrax.com/tech/web/regex.htm#special ), alors je dirais:

^[[:alnum:]_]+$

Cependant, bien que la documentation des liens ci-dessus indique que \w"Correspondra à n'importe quel caractère compris entre 0 - 9, A - Z et a - z (équivalent de POSIX [: alnum:])", je n'ai pas trouvé que c'était vrai . Pas de grep -Ptoute façon. Vous devez inclure explicitement le trait de soulignement si vous utilisez [:alnum:]mais pas si vous utilisez \w. Vous ne pouvez pas battre ce qui suit pour court et doux:

^\w+$

En plus de la lisibilité, l'utilisation des classes de caractères POSIX ( http://www.regular-expressions.info/posixbrackets.html ) signifie que votre expression régulière peut fonctionner sur des chaînes non ASCII, ce que les expressions régulières basées sur la plage ne feront pas car elles s'appuient sur l'ordre sous-jacent des caractères ASCII qui peut être différent des autres jeux de caractères et exclura donc certains caractères non ASCII (lettres comme œ) que vous voudrez peut-être capturer.

En informatique, une valeur alphanumérique signifie souvent que le premier caractère n'est pas un nombre mais est un alphabet ou un trait de soulignement. Par la suite , le caractère peut être 0-9, A-Z, a-zou underscore ( _).

Voici comment procéder:

Testé sous php:

$regex = '/^[A-Za-z_][A-Za-z\d_]*$/'

ou prenez ça

^[A-Za-z_][A-Za-z\d_]*$

et placez-le dans votre langage de développement.

Que diriez-vous:

^([A-Za-z]|[0-9]|_)+$

... si vous voulez être explicite, ou:

^\w+$

... si vous préférez concis (syntaxe Perl).

utilisez des lookaheads pour faire "au moins un" truc. Croyez-moi, c'est beaucoup plus facile.

Voici un exemple qui nécessiterait de 1 à 10 caractères, contenant au moins un chiffre et une lettre:

^(?=.*\d)(?=.*[A-Za-z])[A-Za-z0-9]{1,10}$

REMARQUE: aurait pu utiliser \ w mais des considérations ECMA / Unicode entrent en jeu augmentant la couverture de caractères du \ w "caractère de mot".

Essayez ces extensions multilingues que j'ai faites pour la chaîne.

IsAlphaNumeric - La chaîne doit contenir au moins 1 alpha (lettre dans la plage Unicode, spécifiée dans charSet) et au moins 1 nombre (spécifié dans numSet). De plus, la chaîne ne doit comprendre que des caractères alpha et numériques.

IsAlpha - La chaîne doit contenir au moins 1 alpha (dans le langage charSet spécifié) et ne comprendre que de l'alpha.

IsNumeric - La chaîne doit contenir au moins 1 nombre (dans la langue numSet spécifiée) et comprendre uniquement des nombres.

La plage charSet / numSet pour la langue souhaitée peut être spécifiée. Les gammes Unicode sont disponibles sur le lien ci-dessous:

http://www.ssec.wisc.edu/~tomw/java/unicode.html

API:

    public static bool IsAlphaNumeric(this string stringToTest)
    {
        //English
        const string charSet = "a-zA-Z";
        const string numSet = @"0-9";

        //Greek
        //const string charSet = @"\u0388-\u03EF";            
        //const string numSet = @"0-9";

        //Bengali
        //const string charSet = @"\u0985-\u09E3";
        //const string numSet = @"\u09E6-\u09EF";

        //Hindi
        //const string charSet = @"\u0905-\u0963";
        //const string numSet = @"\u0966-\u096F";

        return Regex.Match(stringToTest, @"^(?=[" + numSet + @"]*?[" + charSet + @"]+)(?=[" + charSet + @"]*?[" + numSet + @"]+)[" + charSet + numSet +@"]+$").Success;
    }

    public static bool IsNumeric(this string stringToTest)
    {
        //English
        const string numSet = @"0-9";

        //Hindi
        //const string numSet = @"\u0966-\u096F";

        return Regex.Match(stringToTest, @"^[" + numSet + @"]+$").Success;
    }

    public static bool IsAlpha(this string stringToTest)
    {
        //English
        const string charSet = "a-zA-Z";

        return Regex.Match(stringToTest, @"^[" + charSet + @"]+$").Success;
    }

Utilisation:

        //English
        string test = "AASD121asf";

        //Greek
        //string test = "Ϡϛβ123";

        //Bengali
        //string test = "শর৩৮";

        //Hindi
        //string test = @"क़लम३७ख़";

        bool isAlphaNum = test.IsAlphaNumeric();

L'expression rationnelle suivante correspond aux caractères alphanumériques et au trait de soulignement:

^[a-zA-Z0-9_]+$

Par exemple, en Perl:

#!/usr/bin/perl -w

my $arg1 = $ARGV[0];

# check that the string contains *only* one or more alphanumeric chars or underscores
if ($arg1 !~ /^[a-zA-Z0-9_]+$/) {
  print "Failed.\n";
} else {
    print "Success.\n";
}

Cela devrait fonctionner dans la plupart des cas.

/^[\d]*[a-z_][a-z\d_]*$/gi

Et par la plupart je veux dire,

abcd       True
abcd12     True
ab12cd     True
12abcd     True

1234       False

Explication

1. ^ ... $ - faire correspondre le motif commençant et finissant par
2. [\d]* - correspondre à zéro ou plusieurs chiffres
3. [a-z_] - correspondre à un alphabet ou à un trait de soulignement
4. [a-z\d_]* - correspondre à un alphabet ou un chiffre ou un trait de soulignement
5. /gi - correspondre globalement à travers la chaîne et insensible à la casse

Pour moi, il y avait un problème en ce que je voulais faire la distinction entre alpha, numérique et alpha numérique, donc pour m'assurer qu'une chaîne alphanumérique contient au moins un alpha et au moins un numérique, j'ai utilisé:

^([a-zA-Z_]{1,}\d{1,})+|(\d{1,}[a-zA-Z_]{1,})+$

Voici l'expression régulière de ce que vous voulez avec un quantificateur pour spécifier au moins 1 caractère et pas plus de 255 caractères

[^a-zA-Z0-9 _]{1,255}

Pour ceux d'entre vous qui recherchent une correspondance alphanumérique unicode, vous voudrez peut-être faire quelque chose comme:

^[\p{L} \p{Nd}_]+$

Lectures complémentaires sur http://unicode.org/reports/tr18/ et sur http://www.regular-expressions.info/unicode.html

Je crois que vous ne prenez pas de caractères latins et Unicode dans vos matchs. Par exemple, si vous devez utiliser les caractères "ã" ou "ü", l'utilisation de "\ w" ne fonctionnera pas.

Vous pouvez également utiliser cette approche:

^[A-ZÀ-Ýa-zà-ý0-9_]+$

J'espère que cela aide!

Pour vérifier la chaîne entière et ne pas autoriser les chaînes vides, essayez

^[A-Za-z0-9_]+$

^\w*$ fonctionnera pour les combinaisons ci-dessous

1
123
1av
pRo
av1

cela fonctionne pour moi, vous pouvez essayer

[\\p{Alnum}_]

Cela fonctionne pour moi, trouvé cela dans le "Mastering Regular Expressions" de O'Reilly:

/^\w+$/

Explication:

• ^ affirme la position au début de la chaîne
  • \ w + correspond à n'importe quel caractère de mot (égal à [a-zA-Z0-9_])
  • Quantificateur "+" - Correspond entre une fois et un nombre illimité, autant de fois que possible, en redonnant selon les besoins (gourmand)
• $ affirme la position à la fin de la chaîne

Vérifiez vous-même:

const regex = /^\w+$/;
const str = `nut_cracker_12`;
let m;

if ((m = regex.exec(str)) !== null) {
    // The result can be accessed through the `m`-variable.
    m.forEach((match, groupIndex) => {
        console.log(`Found match, group ${groupIndex}: ${match}`);
    });
}