Wyrażenie regularne dla znaków alfanumerycznych i znaków podkreślenia

Chciałbym mieć wyrażenie regularne, które sprawdza, czy łańcuch zawiera tylko wielkie i małe litery, cyfry i znaki podkreślenia.

Aby dopasować ciąg zawierający tylko te znaki (lub pusty ciąg), spróbuj

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

Działa to w przypadku wyrażeń regularnych .NET i prawdopodobnie także wielu innych języków.

Podział:

^ : 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

Jeśli nie chcesz zezwalać na puste ciągi, użyj + zamiast *.

Jak zauważyli inni, niektóre języki wyrażeń regularnych mają skróconą formę [a-zA-Z0-9_]. W języku regularnym .NET możesz włączyć zachowanie ECMAScript i używać go \wjako skrótu (wydajnego ^\w*$lub ^\w+$). Zauważ, że w innych językach, i domyślnie w .NET, \wjest nieco szerszy i będzie pasował również do innych rodzajów znaków Unicode (dzięki Janowi za zwrócenie na to uwagi). Jeśli więc naprawdę chcesz dopasować tylko te znaki, prawdopodobnie najlepiej jest użyć jawnej (dłuższej) formy.

Jest tu wiele gadatliwości i jestem głęboko temu przeciwny, więc moja rozstrzygająca odpowiedź brzmiałaby:

/^\w+$/

\wjest równoważne [A-Za-z0-9_], co jest prawie tym, czego chcesz. (chyba że wprowadzimy Unicode do miksu)

Za pomocą +kwantyfikatora dopasujesz jeden lub więcej znaków. Jeśli chcesz również zaakceptować pusty ciąg, użyj *zamiast tego.

Chcesz sprawdzić, czy każda postać spełnia twoje wymagania, dlatego używamy:

[A-Za-z0-9_]

I możesz nawet użyć wersji skróconej:

\w

Co jest równoważne (w niektórych odmianach wyrażeń regularnych, więc upewnij się, że sprawdziłeś przed użyciem). Następnie, aby wskazać, że cały ciąg musi pasować, użyj:

^

Aby wskazać, że ciąg musi zaczynać się od tego znaku, a następnie użyj

$

Aby wskazać, ciąg musi kończyć się tym znakiem. Następnie użyj

\w+ or \w*

Aby wskazać „1 lub więcej” lub „0 lub więcej”. Podsumowując, mamy:

^\w*$

Um ... pytanie: Czy musi mieć co najmniej jedną postać, czy nie? Czy może to być pusty ciąg?

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

Wykona co najmniej jedną wielką lub małą literę alfanumeryczną lub podkreślnik. Jeśli może mieć zerową długość, wystarczy zastąpić + znakiem *

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

Edytować:

Jeśli należy uwzględnić znaki diakrytyczne (takie jak cedilla - ç), należy użyć znaku słowa, który robi to samo co powyżej, ale zawiera znaki diakrytyczne:

^\w+$

Lub

^\w*$

Chociaż jest to bardziej szczegółowe \w, osobiście doceniam czytelność pełnych nazw klas znaków POSIX ( http://www.zytrax.com/tech/web/regex.htm#special ), więc powiedziałbym:

^[[:alnum:]_]+$

Jednak podczas gdy dokumentacja w powyższych linkach stwierdza, że \w„Dopasuje dowolny znak z zakresu 0–9, A – Z i a – z (odpowiednik POSIX [: alnum:])”, nie stwierdziłem, że jest to prawdą . W grep -Pkażdym razie nie. Musisz użyć podkreślenia, jeśli używasz, [:alnum:]ale nie jeśli używasz \w. W skrócie i na słodko nie możesz:

^\w+$

Oprócz czytelności użycie klas znaków POSIX ( http://www.regular-expressions.info/posixbrackets.html ) oznacza, że ​​wyrażenie regularne może działać na ciągach znaków innych niż ASCII, czego nie będą robić wyrażenia regularne oparte na zakresie, ponieważ polegają na podstawowa kolejność znaków ASCII, która może różnić się od innych zestawów znaków, a zatem wyklucza niektóre znaki inne niż ASCII (litery takie jak -), które możesz chcieć przechwycić.

W informatyce wartość alfanumeryczna często oznacza, że ​​pierwszym znakiem nie jest liczba, ale alfabet lub znak podkreślenia. Następnie postać może być 0-9, A-Z, a-z, lub podkreślenia ( _).

Oto jak to zrobiłbyś:

Testowane pod php:

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

lub weź to

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

i umieść go w języku programowania.

Co powiesz na:

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

... jeśli chcesz być jawny lub:

^\w+$

... jeśli wolisz zwięzły (składnia Perla).

użyj lookaheads, aby wykonać „co najmniej jedną” czynność. Zaufaj mi, to dużo łatwiejsze.

Oto przykład, który wymagałby 1-10 znaków, zawierający co najmniej jedną cyfrę i jedną literę:

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

UWAGA: można było użyć \ w, ale następnie rozważania ECMA / Unicode zwiększają zasięg znaków w „znaku słowa”.

Wypróbuj te wielojęzyczne rozszerzenia, które stworzyłem dla łańcucha.

IsAlphaNumeric - Ciąg musi zawierać co najmniej 1 alfa (literę w zakresie Unicode, określoną w charSet) i co najmniej 1 liczbę (określoną w numSet). Łańcuch powinien również składać się wyłącznie z liter i cyfr.

IsAlpha - Łańcuch powinien zawierać co najmniej 1 alfa (w określonym języku charSet) i składać się tylko z alfa.

IsNumeric - Łańcuch powinien zawierać co najmniej 1 liczbę (w określonym języku numSet) i zawierać tylko liczby.

Można określić zakres charSet / numSet dla żądanego języka. Zakresy Unicode są dostępne pod poniższym linkiem:

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;
    }

Stosowanie :

        //English
        string test = "AASD121asf";

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

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

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

        bool isAlphaNum = test.IsAlphaNumeric();

Następujące wyrażenie regularne pasuje do znaków alfanumerycznych i znaku podkreślenia:

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

Na przykład w Perlu:

#!/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";
}

Powinno to działać w większości przypadków.

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

I przez większość mam na myśli

abcd       True
abcd12     True
ab12cd     True
12abcd     True

1234       False

Wyjaśnienie

1. ^ ... $ - dopasuj wzór zaczynając i kończąc na
2. [\d]* - dopasuj zero lub więcej cyfr
3. [a-z_] - dopasuj alfabet lub podkreślnik
4. [a-z\d_]* - dopasuj alfabet lub cyfrę lub podkreślnik
5. /gi - dopasowuje globalnie ciąg i nie rozróżnia wielkości liter

Dla mnie był problem polegający na tym, że chcę rozróżnić między alfą, liczbami i alfą, więc aby zapewnić, że ciąg alfanumeryczny zawiera przynajmniej jedną alfę i przynajmniej jedną cyfrę, użyłem:

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

Oto regex dla tego, co chcesz z kwantyfikatorem, aby określić co najmniej 1 znak i nie więcej niż 255 znaków

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

Dla tych z Was, którzy szukają alfanumerycznego dopasowywania unicode, warto zrobić coś takiego:

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

Dalsza lektura na http://unicode.org/reports/tr18/ i na http://www.regular-expressions.info/unicode.html

Wierzę, że nie bierzesz znaków łacińskich i Unicode w swoich dopasowaniach. Na przykład, jeśli chcesz wziąć znaki „ã” lub „ü”, użycie „\ w” nie będzie działać.

Alternatywnie możesz użyć tego podejścia:

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

Mam nadzieję, że to pomoże!

Aby sprawdzić cały ciąg i nie zezwalać na puste ciągi, spróbuj

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

^\w*$ będzie działać dla poniższych kombinacji

1
123
1av
pRo
av1

to działa dla mnie, możesz spróbować

[\\p{Alnum}_]

To działa dla mnie, znalazłem to w „Mastering Regular Expressions” O'Reilly:

/^\w+$/

Wyjaśnienie:

• ^ potwierdza pozycję na początku łańcucha
  • \ w + dopasowuje dowolny znak słowa (równy [a-zA-Z0-9_])
  • Kwantyfikator „+” - dopasowuje od jednego do nieograniczonego czasu, tyle razy, ile to możliwe, zwracając w razie potrzeby (zachłanny)
• $ zapewnia pozycję na końcu ciągu

Sprawdź siebie:

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}`);
    });
}