So validieren Sie Benutzerkontodetails mit regulären Ausdrücken

Reguläre Ausdrücke sind ein integrales Programmierwerkzeug, das Sie für viele praktische Alltagsaufgaben verwenden können. Sie können reguläre Ausdrücke verwenden, um Text zu suchen, abzugleichen oder zu analysieren. Mit den richtigen Mustern können Sie einige der häufigsten Benutzerkontodetails validieren.

Sie können reguläre Ausdrücke mit vielen Sprachen oder Tools verwenden, einschließlich Python und JavaScript.

Regex zum Validieren eines Benutzernamens

Betrachten Sie einen Benutzernamen, der nur gültig ist, wenn er die folgenden Bedingungen erfüllt:

1. Die Anzahl der Zeichen muss zwischen 5 und 15 liegen. (Sie können Ihren Anforderungen entsprechend einen anderen Bereich angeben, nehmen Sie jedoch entsprechende Änderungen in der Regex vor.)
   instagram viewer
2. Die Zeichenfolge sollte nur alphanumerische Zeichen und/oder Unterstriche (_) enthalten.
3. Das erste Zeichen der Zeichenfolge sollte alphabetisch sein.

Die folgende Regex erfüllt die obigen Bedingungen und kann einen Benutzernamen validieren:

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

Wenn Sie sich mit dem obigen Ausdruck nicht wohlfühlen, sehen Sie sich das an Ein Leitfaden für Anfänger zu regulären Ausdrücken Erste. Dies ist ein Python-Ansatz, um einen Benutzernamen zu validieren:

importieren Betreff
defcheckBenutzername(Nutzername):
 regulärer Ausdruck = "^[A-Za-z]\\w{4,14}$"
 r = neu kompilieren (regex)
Wenn (Betreff.suchen(R, Nutzername)):
 drucken("Gültig")
anders:
 drucken("Ungültig")
Benutzername1 = "yuvraj_chandra"
checkBenutzername (Benutzername1)
Benutzername2 = "ja7&^%87"
checkBenutzername (Benutzername2)

Durch Ausführen dieses Codes wird bestätigt, dass der erste Benutzername gültig ist, der zweite jedoch nicht:

Ebenso können Sie einen Benutzernamen in JavaScript mit dem folgenden Code validieren:

FunktioncheckBenutzername(Benutzer) {
Wenn(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.test (Benutzer)) {
 Konsole.log ('Gültig');
 } anders {
 Konsole.log ('Ungültig');
 }
}
checkBenutzername('yuvraj_chandra');
checkBenutzername('ja7&^%87'); 

Sie können diesen Code verwenden Validieren Sie HTML-Formulare mit regulären Ausdrücken.

Regex zum Validieren einer E-Mail-Adresse

Die Regex zur Validierung einer E-Mail-Adresse ist nicht perfekt. Es gibt keine allgemein anerkannte Regex zur Validierung einer E-Mail-Adresse. Es läuft vollständig auf Ihre Definition von gültig hinaus.

Nachfolgend finden Sie eine Liste von Bedingungen, die die meisten E-Mail-Adressen validieren können:

1. Der Benutzername sollte nur alphanumerische Zeichen, Unterstriche, Bindestriche und/oder Punkte enthalten.
2. Die E-Mail-ID-Zeichenfolge muss ein @-Zeichen enthalten.
3. Der Domänenname sollte nur alphanumerische Zeichen, Unterstriche oder Bindestriche enthalten.
4. Nach dem Domänennamen muss ein Punkt stehen.
5. Die Domainendung darf nur alphanumerische Zeichen, Unterstriche oder Bindestriche enthalten.
6. Die Länge der Domain-Endung sollte zwischen 2 und 4 liegen.

Die folgende Regex erfüllt die oben genannten Bedingungen und kann eine E-Mail-Adresse validieren:

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

Dies ist ein Python-Ansatz zur Validierung einer E-Mail-Adresse:

importieren Betreff
defcheckEmailId(Email):
 regulärer Ausdruck = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = neu kompilieren (regex)
Wenn (Betreff.suchen(R, Email)):
 drucken("Gültig")
anders:
 drucken("Ungültig")
email1 = "[email protected]"
checkEmailId (E-Mail1)
email2 = "abc@def@gmail.kahscg"
checkEmailId (E-Mail2)

Auch hier bestätigt die Ausgabe, dass die erste E-Mail-Adresse gültig ist, während die zweite ungültig ist:

Sie können eine E-Mail in JavaScript mit dem folgenden Code validieren:

FunktioncheckEmailId(Email) {
Wenn (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.Test-Email)) {
Konsole.log('Gültig');
 } anders {
Konsole.log('Nicht gültig');
 }
}
checkEmailId("[email protected]");
checkEmailId("abc@[email protected]");

Überprüfen Sie die Passwortstärke mit regulären Ausdrücken

Starke Passwörter sind aus Sicherheitssicht unerlässlich. Sie müssen sicherstellen, dass Endbenutzer über ausreichend starke Kennwörter verfügen, damit andere nicht auf ihre Konten zugreifen können.

Die folgenden Regeln stellen sicher, dass die Passwortstärke Ihrer Anwendung stark ist:

1. Die Mindestanzahl von Zeichen muss 8 sein.
2. Die Zeichenfolge muss mindestens eine Ziffer haben.
3. Die Zeichenfolge muss mindestens einen Großbuchstaben enthalten.
4. Die Zeichenfolge muss mindestens einen Kleinbuchstaben enthalten.
5. Die Zeichenfolge muss mindestens ein Sonderzeichen enthalten.

Die folgende Regex erfüllt die oben genannten Bedingungen und kann helfen, ein stärkeres Passwort zu gewährleisten:

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

Sie können die Passwortstärke in Python mit dem folgenden Code überprüfen:

importieren Betreff
defcheckPasswordStrength(Passwort):
 regulärer Ausdruck = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})"
 r = neu kompilieren (regex)
Wenn (Betreff.suchen(R, Passwort)):
 drucken("Sicheres Passwort")
anders:
 drucken("Schwaches Passwort")
Passwort1 = "Hiuahd$5jawd"
checkPasswordStrength (Passwort1)
Passwort2 = "mein Passwort"
checkPasswordStrength (Passwort2)

Wenn Sie diesen Code ausführen, wird bestätigt, dass das erste Passwort stark ist, während das zweite schwach ist:

Sie können die Passwortstärke in JavaScript mit dem folgenden Code überprüfen:

FunktioncheckPasswordStrength(Passwort) {
Wenn (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.test (Passwort)) {
 Konsole.log ('Sicheres Passwort');
 } anders {
 Konsole.log ('Schwaches Passwort');
 }
}
checkPasswordStrength('Hiuahd$5jawd');
checkPasswordStrength('mein Passwort');

Regulärer Ausdruck zur Übereinstimmung mit einem gültigen Datum

Wenn Sie schnell überprüfen möchten, ob die angegebenen Daten im traditionellen Datumsformat vorliegen oder nicht, können Sie dies mit Regex tun.

Der folgende reguläre Ausdruck entspricht einem Datum in mm/tt/jjjj Format:

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

Der folgende Python-Code bestätigt, dass das Datum in ist mm/tt/jjjj Format:

importieren Betreff
defcheckDatumsformat(Datum):
 regulärer Ausdruck = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$"
 r = neu kompilieren (regex)
Wenn(Betreff.suchen(R, Datum)):
 drucken("Gültig")
anders:
 drucken("Ungültig")
Datum1 = "03/21/2002"
checkDatumFormat (Datum1)
Datum2 = "15/21/2002"
checkDatumsformat (Datum2)

Die Ausgabe bestätigt erneut, dass das erste Datumsformat gültig ist, das zweite jedoch ungültig ist:

Sie können das Datum in validieren mm/tt/jjjj formatieren Sie in JavaScript mit dem folgenden Code:

FunktioncheckDatumsformat(Datum) {
Wenn(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\d\d$/.Testdatum)) {
 Konsole.log ('Gültig');
 } anders {
 Konsole.log ('Ungültig');
 }
}
checkDatumsformat('03/21/2002');
checkDatumsformat('15/21/2002');

Validierung leerer Zeichenfolgen mit regulären Ausdrücken

Mit dem folgenden regulären Ausdruck können Sie überprüfen, ob eine Zeichenfolge leer ist:

^$

Unten ist der Python-Ansatz für die Validierung leerer Zeichenfolgen:

importieren Betreff
defcheckEmptyString(str):
 regulärer Ausdruck = "^$"
 r = neu kompilieren (regex)
Wenn (Betreff.suchen(R, Str)):
drucken("Die angegebene Zeichenfolge ist leer")
anders:
drucken("Die angegebene Zeichenfolge ist nicht leer")
str1 = ""
checkEmptyString (str1)
str2 = "Dies ist keine leere Zeichenfolge"
checkEmptyString (str2)

Die folgende Ausgabe zeigt, dass die erste angegebene Zeichenfolge leer ist, die zweite jedoch nicht:

Verwenden Sie den folgenden JavaScript-Code, um zu überprüfen, ob die Zeichenfolge leer ist oder nicht:

FunktioncheckEmptyString(Str) {
Wenn (/^$/.test (str)) {
 Konsole.log ('Die angegebene Zeichenfolge ist leer');
 } anders {
 Konsole.log ('Die angegebene Zeichenfolge ist nicht leer');
 }
}
checkEmptyString('');
checkEmptyString('Dies ist keine leere Zeichenfolge'); 

RegEx zur Validierung der Postleitzahl (US-Postleitzahl)

Sie können eine Postleitzahl (US-Postleitzahl) sowohl im fünfstelligen als auch im neunstelligen Format (ZIP+4 genannt) validieren, indem Sie den folgenden regulären Ausdruck verwenden:

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

Unten ist der Python-Code zur Validierung von Postleitzahlen:

importieren Betreff
defvalidierenPostleitzahl(Code):
 regulärer Ausdruck = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = neu kompilieren (regex)
Wenn (Betreff.suchen(R, Code)):
 drucken("Gültig")
anders:
 drucken("Ungültig")
code1 = "76309"
validierenPostleitzahl (code1)
code2 = "83468-2348"
validierenPostleitzahl (code2)
code3 = "234445"
validierenPostleitzahl (code3)

Durch Ausführen dieses Codes wird bestätigt, dass die erste und zweite Postleitzahl gültig sind, die dritte jedoch nicht:

Verwenden Sie den folgenden JavaScript-Code, um die Postleitzahl mit Regex zu validieren:

FunktionvalidierenPostleitzahl(Code) {
Wenn (/^[0-9]{5}(?:-[0-9]{4})?$/.test (Code)) {
 Konsole.log ('Gültig');
 } anders {
 Konsole.log ('Ungültig');
 }
}
validierePostleitzahl('76309');
validierePostleitzahl('83468-2348');
validierePostleitzahl('234445');

Verifizieren Sie Benutzereingaben mit robustem Code

Sie haben gelernt, wie Sie Benutzerkontodetails mit regulären Ausdrücken validieren. Die Validierung dieser Details macht den Code robust und hilft, Sicherheitsprobleme und unerwünschte Fehler zu beheben. Robuster Code bietet Ihren Benutzern ein sicheres Erlebnis.

Sie sollten sicherstellen, dass Sie die Eingabedaten entweder auf der Client- oder der Serverseite validieren, um immer auf der sicheren Seite vor Hackern zu sein.