Expression régulière pour les caractères alphanumériques et les soulignements

pour correspondre à une chaîne qui contient seulement ces caractères (ou une chaîne vide), essayez

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

cela fonctionne pour les expressions régulières .NET, et probablement aussi beaucoup d'autres langues.

en le décomposant:

^ : 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 voulez pas autoriser les chaînes vides, utilisez + au lieu de *.

MODIFIER Comme d'autres l'ont souligné, certains les langues regex ont une forme abrégée pour [a-zA-Z0-9_] . Dans le langage. net regex, vous pouvez activer le comportement ECMAScript et utiliser \w comme raccourci (donnant ^\w*$ ou ^\w+$ ). Notez que dans d'autres langues, et par défaut dans .NET, \w est un peu plus large, et va correspondre à d'autres types de caractères unicode aussi bien (merci à Jan pour avoir souligné ce point). Donc, si vous avez vraiment l'intention de faire correspondre seulement ces caractères, en utilisant l'explicite (plus) est probablement le meilleur.

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

/^\w+$/

\w est l'équivalent de [A-Za-z0-9_] , ce qui est à peu près ce que vous voulez. (à moins que nous n'introduisions unicode dans le mix)

en utilisant le quantificateur + , vous correspondrez à un ou plusieurs caractères. Si vous voulez accepter une chaîne vide aussi, utilisez * à la place.

vous voulez vérifier que chaque caractère correspond à vos besoins, c'est pourquoi nous utilisons:

[A-Za-z0-9_]

et vous pouvez même utiliser la version abrégée:

\w

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

^

pour indiquer la chaîne doit commencer par ce caractère, puis utiliser

$

pour indiquer la chaîne doit se terminer avec ce caractère. Puis utiliser

\w+ or \w*

Pour indiquer "1" ou "0". En unissant tout, nous avons:

^\w*$

bien qu'il 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 ), donc je dirais:

^[[:alnum:]_]+$

cependant, alors que la documentation sur les liens ci - dessus indique que \w va "correspondre à n'importe quel caractère dans la gamme 0 - 9, A - Z et a-z (équivalent de POSIX [:alnum:])", Je n'ai pas trouvé que ce soit vrai. Pas avec grep -P en tout cas. 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+$

ainsi que la lisibilité, en utilisant les classes de caractères POSIX ( http://www.regular-expressions.info/posixbrackets.html ) signifie que votre regex peut fonctionner sur des chaînes non ASCII, ce que les regexes basés sur la gamme ne feront pas puisqu'ils s'appuient sur l'ordre sous-jacent de les caractères ASCII qui peuvent être différents des autres jeux de caractères et excluront donc certains caractères non-ASCII (lettres comme œ) que vous pourriez vouloir capturer.

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

doit comporter au moins un caractère alphanumérique ou un caractère de soulignement en majuscules ou en minuscules. Si la longueur peut être zéro, il suffit de remplacer le + par le *

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

Edit:

Si les signes diacritiques (comme la cédille - ç), vous devez utiliser le mot de caractère qui fait la même chose que ci-dessus, mais comprend les caractères diacritiques:

^\w+$

ou

^\w*$

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

Voici comment vous feriez cela:

testé sous php:

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

ou de prendre ce

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

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

Que Diriez-vous de:

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

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

^\w+$

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

utilisez lookheads pour faire "au moins un" truc. Croyez-moi il est beaucoup plus facile.

voici un exemple qui exigerait 1-10 caractères, contenant au moins un chiffre et une lettre:

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

NOTE: aurait pu utiliser \w mais alors les considérations ECMA/Unicode entrent en jeu en augmentant la couverture des caractères du "caractère word".

essayez ces extensions multilingues que j'ai faites pour string.

IsAlphaNumeric - Chaîne doit contenir au moins 1 alpha (lettre en Unicode gamme, spécifié dans charSet) et au moins 1 numéro (spécifié dans numSet). En outre, la chaîne de caractères ne doit comprendre que des lettres et des chiffres.

Isalpha-String doit contenir au moins 1 alpha (dans le jeu de caractères langue spécifié) et ne comporter que de l'alpha.

IsNumeric - Chaîne doit contenir au moins un numéro (dans la langue indiquée) et ne comporter que des numéros.

il est possible de spécifier la plage de charSet/numSet pour la langue désiré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();

le regex suivant correspond aux caractères alphanumériques et au caractère 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";
}

Pour moi, il y a une question que je veux distinguer entre alpha, numérique et alphanumérique, de sorte à assurer une chaîne alphanumérique contient au moins une lettre et au moins un numérique, j'ai utilisé :

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

pour ceux d'entre vous qui cherchent une correspondance alphanumérique unicode, vous pourriez vouloir faire quelque chose comme:

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

http://unicode.org/reports/tr18 / et à http://www.regular-expressions.info/unicode.html

voici le regex pour 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}

les diacritiques correspondantes dans un regexp ouvrent une boîte entière de vers, surtout si L'on prend en considération Unicode. Vous voudrez peut-être lire à propos de Posix locales en particulier.

pour vérifier la chaîne entière et ne pas permettre des chaînes vides, essayez

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

cela fonctionne pour moi, vous pouvez essayer [\p{Alnum}_]

^w * $ fonctionnera pour la combinaison ci-dessous Un Cents vingt trois 1av Pro av1