Regulärer Ausdruck in Android für das Passwortfeld

Lesezeit: 4 Minuten

Benutzeravatar von IntelliJ Amiya
IntelliJ Amiya

Wie kann ich die validieren EditText mit Regex durch das Zulassen bestimmter Zeichen . Mein Zustand ist:

Passwortregel:

  1. Einen Großbuchstaben

  2. Eine Nummer

  3. Ein Symbol (@,$,%,&,#,) welche normalen Symbole auch immer akzeptabel sind.

    Darf ich wissen, wie ich mein Ziel richtig erreiche?

Benutzeravatar von Biraj Zalavadia
Biraj Zalavadia

Versuchen Sie, dies kann helfen

^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{4,}$

Wie es funktioniert?

^                 # start-of-string
(?=.*[0-9])       # a digit must occur at least once
(?=.*[a-z])       # a lower case letter must occur at least once
(?=.*[A-Z])       # an upper case letter must occur at least once
(?=.*[@#$%^&+=])  # a special character must occur at least once you can replace with your special characters
(?=\\S+$)          # no whitespace allowed in the entire string
.{4,}             # anything, at least six places though
$                 # end-of-string

Wie wird implementiert?

public class MainActivity extends Activity {

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        final EditText editText = (EditText) findViewById(R.id.edtText);
        Button btnCheck = (Button) findViewById(R.id.btnCheck);

        btnCheck.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View arg0) {
                if (isValidPassword(editText.getText().toString().trim())) {
                    Toast.makeText(MainActivity.this, "Valid", Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(MainActivity.this, "InValid", Toast.LENGTH_SHORT).show();
                }
            }
        });

    }

    public boolean isValidPassword(final String password) {

        Pattern pattern;
        Matcher matcher;

        final String PASSWORD_PATTERN = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{4,}$";

        pattern = Pattern.compile(PASSWORD_PATTERN);
        matcher = pattern.matcher(password);

        return matcher.matches();

    }

}

  • @BirajZalavadia wissen Sie, wie man ( ” ), dh doppelte Anführungszeichen, in meine Liste der Regex-Sonderzeichen einfügt. Wenn ich “” einschließe, wird ein Fehler angezeigt.

    – Anish Kumar

    12. Mai 2017 um 7:16 Uhr

  • Was macht .{4,} bedeuten? Es hat eine 4, aber sagt “mindestens sechs Plätze”, was bedeutet das?

    – E. Akio

    23. Januar 2020 um 14:11 Uhr

  • Warum aber Leerzeichen verbieten?

    – Joffrey

    11. November 2021 um 13:02 Uhr

Benutzeravatar von KingSeg
KönigSeg

Und für die Kotlin Liebhaber:

fun isValidPassword(password: String?) : Boolean {
   password?.let {
       val passwordPattern = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{4,}$"
       val passwordMatcher = Regex(passwordPattern)

       return passwordMatcher.find(password) != null
   } ?: return false
}

Keines der oben genannten hat bei mir funktioniert.

Was für mich funktioniert hat:

fun isValidPasswordFormat(password: String): Boolean {
    val passwordREGEX = Pattern.compile("^" +
        "(?=.*[0-9])" +         //at least 1 digit
        "(?=.*[a-z])" +         //at least 1 lower case letter
        "(?=.*[A-Z])" +         //at least 1 upper case letter
        "(?=.*[a-zA-Z])" +      //any letter
        "(?=.*[@#$%^&+=])" +    //at least 1 special character
        "(?=\\S+$)" +           //no white spaces
        ".{8,}" +               //at least 8 characters
        "$");
    return passwordREGEX.matcher(password).matches()
}

Quelle: Codierung im Flow

Hoffe es hilft jemandem.

Versuche dies.

(/^(?=.*\d)(?=.*[A-Z])([@$%&#])[0-9a-zA-Z]{4,}$/)


(/^
(?=.*\d)                //should contain at least one digit
(?=.*[@$%&#])           //should contain at least one special char
(?=.*[A-Z])             //should contain at least one upper case
[a-zA-Z0-9]{4,}         //should contain at least 8 from the mentioned characters
$/)

try {
    if (subjectString.matches("^(?=.*[@$%&#_()=+?»«<>£§€{}\\[\\]-])(?=.*[A-Z])(?=.*[a-z])(?=.*\\d).*(?<=.{4,})$")) {
        // String matched entirely
    } else {
        // Match attempt failed
    } 
} catch (PatternSyntaxException ex) {
    // Syntax error in the regular expression
}


(?=.*[@\$%&#_()=+?»«<>£§€{}.[\]-]) -> must have at least 1 special character
(?=.*[A-Z])   -> Must have at least 1 upper case letter
(?=.*[a-z])   -> Must have at least 1 lower case letter
(?=.*\\d)     -> Must have at least 1 digit
(?<=.{4,})$") -> Must be equal or superior to 4 chars.

Als Ergänzung zu den bereits gegebenen Antworten würde ich einen anderen Weg zur Identifizierung von Sonderzeichen vorschlagen und die Prüfung auch für die verschiedenen Regeln aufteilen.

Zuerst aufteilen: Anstatt eine große Regel zu erstellen, teilen Sie sie auf und überprüfen Sie jede Regel einzeln, damit Sie dem Benutzer Feedback geben können, was genau mit seinem Passwort nicht stimmt. Dies kann etwas länger dauern, aber bei so etwas wie einer Passwortüberprüfung wird dies nicht auffallen. Außerdem sind die Bedingungen auf diese Weise besser lesbar.

Zweitens, anstatt nach einer Liste mit Sonderzeichen zu suchen, könnten Sie sie umdrehen und prüfen, ob das Passwort Zeichen enthält, die weder Buchstaben des lateinischen Alphabets (a-zA-Z) noch Ziffern (0-9) sind. So „vergisst“ man keine Sonderzeichen. Nehmen wir zum Beispiel an, Sie prüfen gezielt, aber bei Ihrer Prüfung vergessen Sie ein Zeichen wie „{“. Mit diesem Ansatz kann dies nicht passieren. Sie können diese Liste um Dinge erweitern, die Sie nicht ausdrücklich als Sonderzeichen betrachten, z B. ein Leerzeichen kotlindas sähe so aus:

val errorText = when {
    /* Rule 1 */
    !password.contains(Regex("[A-Z]")) -> "Password must contain one capital letter"
    /* Rule 2 */
    !password.contains(Regex("[0-9]")) -> "Password must contain one digit"
    /* Rule 3, not counting space as special character */
    !password.contains(Regex("[^a-zA-Z0-9 ]")) -> "Password must contain one special character"
    else -> null
}

Abhängig von Ihrer Codierung können Sie auch Regex verwenden und Ihre Sonderzeichen mithilfe von Bereichen von Hex-Codes wie definieren

Reges("[\x00-\x7F]")

Ich bin zu spät um zu antworten, aber vielleicht hilft es dir trotzdem.

Ich habe mit gearbeitet Kotlin.

Fügen Sie folgende Funktion hinzu.

private fun isValidPassword(password: String): Boolean {
    val pattern: Pattern
    val matcher: Matcher
    val specialCharacters = "[email protected]%\\[\\}+'!/#$^?:;,\\(\"\\)~`.*=&\\{>\\]<_"
    val PASSWORD_REGEX = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[$specialCharacters])(?=\\S+$).{8,20}$"
    pattern = Pattern.compile(PASSWORD_REGEX)
    matcher = pattern.matcher(password)
    return matcher.matches()
}

Bedienungsanleitung:

  • (?=.*[0-9]) # eine Ziffer muss mindestens einmal vorkommen
  • (?=.*[a-z]) # ein Kleinbuchstabe muss mindestens einmal vorkommen
  • (?=.*[A-Z]) # ein Großbuchstabe muss mindestens einmal vorkommen
  • (?=.[[email protected]%[}+’!/#$^?:;,(“)~`.=&{>]<_]) # ein Sonderzeichen muss mindestens einmal vorkommen Ersetzen Sie es durch Ihre Sonderzeichen
  • (?=\S+$) # keine Leerzeichen im gesamten String erlaubt . {8,} # irgendetwas, aber mindestens sechs Stellen

Sie können es nach Bedarf ändern.

Ich hoffe es hilft.

1394280cookie-checkRegulärer Ausdruck in Android für das Passwortfeld

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy