Jak zweryfikować dane konta użytkownika za pomocą wyrażeń regularnych

Wyrażenia regularne są integralnym narzędziem programistycznym, którego można używać do wielu praktycznych codziennych zadań. Możesz używać wyrażeń regularnych do wyszukiwania, dopasowywania lub analizowania tekstu. Dzięki odpowiednim wzorcom możesz zweryfikować niektóre z najczęstszych szczegółów konta użytkownika.

Możesz używać wyrażeń regularnych w wielu językach lub narzędziach, w tym w Pythonie i JavaScript.

Regex, aby zweryfikować nazwę użytkownika

Rozważ nazwę użytkownika, która jest ważna tylko wtedy, gdy spełnia następujące warunki:

1. Liczba znaków musi mieścić się w przedziale od 5 do 15. (Możesz określić inny zakres zgodnie ze swoimi wymaganiami, ale odpowiednio wprowadź zmiany w wyrażeniu regularnym).
instagram viewer
2. Ciąg powinien zawierać tylko znaki alfanumeryczne i/lub podkreślenia (_).
3. Pierwszy znak ciągu powinien być alfabetyczny.

Poniższe wyrażenie regularne spełnia powyższe warunki i może zweryfikować nazwę użytkownika:

^[A-Za-z]\\w{4,14}$

Jeśli nie czujesz się komfortowo z powyższym wyrażeniem, sprawdź przewodnik po wyrażeniach regularnych dla początkujących Pierwszy. To jest podejście Pythona do sprawdzania poprawności nazwy użytkownika:

import Odnośnie
pokSprawdź nazwę użytkownika(nazwa użytkownika):
 wyrażenie regularne = "^[A-Za-z]\\w{4,14}$"
 r = re.compile (regex)
Jeśli (Odnośnie.szukaj(R, nazwa użytkownika)):
 wydrukować("Ważny")
w przeciwnym razie:
 wydrukować("Nieważny")
nazwa użytkownika1 = "yuvraj_chandra"
sprawdź nazwę użytkownika (nazwa użytkownika1)
nazwa użytkownika2 = "ja7&^%87"
sprawdź nazwę użytkownika (nazwa użytkownika2)

Uruchomienie tego kodu potwierdzi, że pierwsza nazwa użytkownika jest prawidłowa, ale druga nie:

Podobnie możesz sprawdzić poprawność nazwy użytkownika w JavaScript, używając następującego kodu:

funkcjonowaćSprawdź nazwę użytkownika(użytkownik) {
Jeśli(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.test (użytkownik)) {
 log konsoli ('Ważny');
 } w przeciwnym razie {
 log konsoli ('Nieważny');
 }
}
sprawdź nazwę użytkownika ('yuvraj_chandra');
sprawdź nazwę użytkownika ('ja7&^%87'); 

Możesz użyć tego kodu do sprawdzać poprawność formularzy HTML za pomocą wyrażeń regularnych.

Regex do sprawdzania poprawności adresu e-mail

Wyrażenie regularne do sprawdzania poprawności adresu e-mail nie jest doskonałe. Nie ma powszechnie uzgodnionego wyrażenia regularnego do sprawdzania poprawności adresu e-mail. To całkowicie sprowadza się do twojej definicji ważności.

Poniżej znajduje się lista warunków, które mogą zweryfikować większość adresów e-mail:

1. Nazwa użytkownika powinna zawierać tylko znaki alfanumeryczne, podkreślenia, myślniki i/lub kropki.
2. Ciąg identyfikatora e-mail musi zawierać jeden znak @.
3. Nazwa domeny powinna zawierać tylko znaki alfanumeryczne, podkreślenia lub myślniki.
4. Po nazwie domeny musi być kropka.
5. Rozszerzenie domeny powinno zawierać tylko znaki alfanumeryczne, podkreślenia lub myślniki.
6. Długość rozszerzenia domeny powinna wynosić od 2 do 4.

Poniższe wyrażenie regularne spełnia powyższe warunki i może zweryfikować adres e-mail:

^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$

Oto podejście Pythona do sprawdzania poprawności adresu e-mail:

import Odnośnie
poksprawdź identyfikator e-maila(e-mail):
 wyrażenie regularne = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = re.compile (regex)
Jeśli (Odnośnie.szukaj(R, e-mail)):
 wydrukować("Ważny")
w przeciwnym razie:
 wydrukować("Nieważny")
e-mail1 = "[email protected]"
checkEmailId (email1)
email2 = "abc@def@gmail.kahscg"
checkEmailId (email2)

Ponownie dane wyjściowe potwierdzają, że pierwszy adres e-mail jest prawidłowy, a drugi jest nieprawidłowy:

Możesz sprawdzić poprawność wiadomości e-mail w JavaScript, używając następującego kodu:

funkcjonowaćsprawdź identyfikator e-maila(e-mail) {
Jeśli (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.test (e-mail)) {
konsola.log('Prawidłowy');
 } w przeciwnym razie {
konsola.log('Nieprawidłowy');
 }
}
checkEmailId("[email protected]");
checkEmailId("abc@[email protected]");

Sprawdź siłę hasła za pomocą wyrażeń regularnych

Silne hasła są niezbędne z punktu widzenia bezpieczeństwa. Musisz upewnić się, że użytkownicy końcowi mają wystarczająco silne hasła, aby inni nie mogli uzyskać dostępu do ich kont.

Poniższe zasady zapewniają, że siła hasła Twojej aplikacji jest silna:

1. Minimalna liczba znaków musi wynosić 8.
2. Ciąg musi zawierać co najmniej jedną cyfrę.
3. Ciąg musi zawierać co najmniej jedną wielką literę.
4. Ciąg musi zawierać co najmniej jedną małą literę.
5. Ciąg musi zawierać co najmniej jeden znak specjalny.

Poniższe wyrażenie regularne spełnia powyższe warunki i może pomóc w zapewnieniu silniejszego hasła:

(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})

Możesz sprawdzić siłę hasła w Pythonie, używając następującego kodu:

import Odnośnie
poksprawdźSiłaHasła(hasło):
 wyrażenie regularne = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})"
 r = re.compile (regex)
Jeśli (Odnośnie.szukaj(R, hasło)):
 wydrukować("Silne hasło")
w przeciwnym razie:
 wydrukować("Słabe hasło")
hasło1 = "Hiuahd$5jawd"
sprawdźSiłaHasła (hasło1)
hasło2 = "moje hasło"
sprawdźSiłaHasła (hasło2)

Uruchomienie tego kodu potwierdzi, że pierwsze hasło jest silne, a drugie słabe:

Możesz sprawdzić siłę hasła w JavaScript za pomocą następującego kodu:

funkcjonowaćsprawdźSiłaHasła(hasło) {
Jeśli (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.test (hasło)) {
 log konsoli ('Silne hasło');
 } w przeciwnym razie {
 log konsoli ('Słabe hasło');
 }
}
sprawdźSiłaHasła('Hiuahd$5jawd');
sprawdźSiłaHasła('moje hasło');

Wyrażenie regularne pasujące do prawidłowej daty

Jeśli chcesz szybko sprawdzić, czy podane daty są w tradycyjnym formacie daty, czy nie, możesz to zrobić za pomocą wyrażenia regularnego.

Następujące wyrażenie regularne pasuje do daty w mm/dd/rrrr format:

^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$

Poniższy kod Pythona sprawdza poprawność daty mm/dd/rrrr format:

import Odnośnie
pokSprawdźFormatDaty(data):
 wyrażenie regularne = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$"
 r = re.compile (regex)
Jeśli(Odnośnie.szukaj(R, data)):
 wydrukować("Ważny")
w przeciwnym razie:
 wydrukować("Nieważny")
data1 = "03/21/2002"
checkDateFormat (data1)
data2 = "15/21/2002"
checkDateFormat (data2)

Po raz kolejny dane wyjściowe potwierdzają, że pierwszy format daty jest prawidłowy, ale drugi jest nieprawidłowy:

Możesz zweryfikować datę w mm/dd/rrrr format w JavaScript przy użyciu następującego kodu:

funkcjonowaćSprawdźFormatDaty(data) {
Jeśli(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\d\d$/.Data testu)) {
 log konsoli ('Ważny');
 } w przeciwnym razie {
 log konsoli ('Nieważny');
 }
}
SprawdźFormatDaty('03/21/2002');
SprawdźFormatDaty('15/21/2002');

Sprawdzanie poprawności pustych ciągów przy użyciu wyrażeń regularnych

Możesz sprawdzić, czy łańcuch jest pusty, używając następującego wyrażenia regularnego:

^$

Poniżej znajduje się podejście Pythona do sprawdzania poprawności pustych ciągów:

import Odnośnie
poksprawdź pusty ciąg(str):
 wyrażenie regularne = "^$"
 r = re.compile (regex)
Jeśli (Odnośnie.szukaj(R, ul)):
wydrukować(„Podany ciąg to pusty")
w przeciwnym razie:
wydrukować(„Podany ciąg nie jest pusty")
str1 = ""
checkEmptyString (str1)
str2 = "To nie jest pusty ciąg"
checkEmptyString (str2)

Poniższy wynik pokazuje, że pierwszy podany ciąg jest pusty, a drugi nie:

Użyj następującego kodu JavaScript, aby sprawdzić, czy łańcuch jest pusty, czy nie:

funkcjonowaćsprawdź pusty ciąg(ul) {
Jeśli (/^$/.test (str)) {
 log konsoli ('Podany ciąg jest pusty');
 } w przeciwnym razie {
 log konsoli ('Podany ciąg znaków nie jest pusty');
 }
}
SprawdźPustyCiąg('');
SprawdźPustyCiąg('To nie jest pusty ciąg'); 

RegEx w celu zweryfikowania kodu pocztowego (kod pocztowy USA)

Możesz zweryfikować kod pocztowy (kod pocztowy Stanów Zjednoczonych) zarówno w formacie pięciocyfrowym, jak i dziewięciocyfrowym (tzw. ZIP+4), używając następującego wyrażenia regularnego:

^[0-9]{5}(?:-[0-9]{4})?$

Poniżej znajduje się kod Pythona do sprawdzania poprawności kodów pocztowych:

import Odnośnie
pokzweryfikuj kod pocztowy(kod):
 wyrażenie regularne = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = re.compile (regex)
Jeśli (Odnośnie.szukaj(R, kod)):
 wydrukować("Ważny")
w przeciwnym razie:
 wydrukować("Nieważny")
kod1 = "76309"
sprawdź poprawność kodu pocztowego (kod1)
kod2 = "83468-2348"
sprawdź poprawność kodu pocztowego (kod2)
kod3 = "234445"
sprawdź poprawność kodu pocztowego (kod3)

Uruchomienie tego kodu potwierdzi, że pierwszy i drugi kod pocztowy są prawidłowe, ale trzeci nie:

Użyj następującego kodu JavaScript, aby zweryfikować kod pocztowy za pomocą wyrażenia regularnego:

funkcjonowaćzweryfikuj kod pocztowy(kod) {
Jeśli (/^[0-9]{5}(?:-[0-9]{4})?$/.test (kod)) {
 log konsoli ('Ważny');
 } w przeciwnym razie {
 log konsoli ('Nieważny');
 }
}
sprawdź kod pocztowy('76309');
sprawdź kod pocztowy('83468-2348');
sprawdź kod pocztowy('234445');

Weryfikuj dane wprowadzane przez użytkownika za pomocą solidnego kodu

Nauczyłeś się sprawdzać poprawność danych konta użytkownika za pomocą wyrażeń regularnych. Weryfikacja tych szczegółów sprawia, że ​​kod jest solidny i pomaga rozwiązać problemy z bezpieczeństwem i niechciane błędy. Solidny kod zapewnia użytkownikom bezpieczne środowisko.

Powinieneś upewnić się, że sprawdzasz poprawność danych wejściowych po stronie klienta lub po stronie serwera, aby zawsze być po bezpiecznej stronie przed hakerami.