regulares - validar contraseña segura javascript

Regex para la contraseña debe contener al menos ocho caracteres, al menos un número y letras tanto mayúsculas como minúsculas y caracteres especiales

Question

Quiero una expresión regular para comprobar que:

Una contraseña contiene al menos ocho caracteres, incluido al menos un número e incluye letras en mayúsculas y minúsculas y caracteres especiales, por ejemplo # ? , ! .

No puede ser su contraseña anterior o contener su nombre de usuario, "password" o "websitename"

Y aquí está mi expresión de validación que es para ocho caracteres que incluyen una letra mayúscula, una letra minúscula y un número o un carácter especial.

(?=^.{8,}$)((?=.*/d)|(?=.*/W+))(?![./n])(?=.*[A-Z])(?=.*[a-z]).*$"

¿Cómo puedo escribirlo para que una contraseña tenga ocho caracteres, incluida una letra mayúscula, un carácter especial y caracteres alfanuméricos ?

Answer 1

Utilice el siguiente Regex para satisfacer las siguientes condiciones:

Conditions: 1] Min 1 special character.
            2] Min 1 number.
            3] Min 8 characters or More

Regex: ^(?=.*/d)(?=.*[#$@!%&*?])[A-Za-z/d#$@!%&*?]{8,}$

Puede probar en línea: https://regex101.com

Answer 2

@ClasG ya ha suggested :

^(?=/S*[a-z])(?=/S*[A-Z])(?=/S*/d)(?=/S*[^/w/s])/S{8,}$

pero no acepta _ (guión bajo) como un carácter especial (por ejemplo, Aa12345_).

Una mejorada es:

^(?=/S*[a-z])(?=/S*[A-Z])(?=/S*/d)(?=/S*([^/w/s]|[_]))/S{8,}$

Answer 3

En Java / Android, para probar una contraseña con al menos un número, una letra y un carácter especial en el siguiente patrón:

"^(?=.*[A-Za-z])(?=.*//d)(?=.*[$@$!%*#?&])[A-Za-z//d$@$!%*#?&]{8,}$"

Answer 4

Espero que el de abajo funcione. He intentado esto en la política personalizada de Azure.

^ (? =. [az]) (? =. [AZ]) (? =. / d) (? =. [@ # $% ^ & * -_ + = [] {} | /: '',? / ~"();!])([A-Za-z/d@#$%^&*/-_+=[/]{}|//:'',?/ ~ "(); !] |. (?! @)) {6,16} $

Answer 5

Importe el archivo jquery.validate.min.js JavaScript.

Puedes usar este método:

$.validator.addMethod("pwcheck", function (value) {
    return /[/@/#/$/%/^/&/*/(/)/_/+/!]/.test(value) && /[a-z]/.test(value) && /[0-9]/.test(value) && /[A-Z]/.test(value)
});

1. Al menos una letra mayúscula en inglés
2. Al menos una letra minúscula en inglés.
3. Al menos un dígito
4. Al menos un personaje especial.

Answer 6

Las expresiones regulares no tienen un operador AND, por lo que es bastante difícil escribir una expresión regular que coincida con contraseñas válidas, cuando la validez está definida por algo Y otra cosa Y algo más ...

Pero, las expresiones regulares tienen un operador OR, por lo que solo aplique el teorema de DeMorgan y escriba una expresión regular que coincida con contraseñas no válidas:

Cualquier cosa con menos de ocho caracteres O cualquier cosa sin números O cualquier cosa sin mayúscula O cualquier cosa sin minúscula O cualquier cosa sin caracteres especiales.

Asi que:

^(.{0,7}|[^0-9]*|[^A-Z]*|[^a-z]*|[a-zA-Z0-9]*)$

Si algo coincide con eso, entonces es una contraseña inválida.

Answer 7

Le respondería a Peter Mortensen, pero no tengo suficiente reputación.

Sus expresiones son perfectas para cada uno de los requisitos mínimos especificados. El problema con sus expresiones que no requieren caracteres especiales es que tampoco PERMITEN caracteres especiales, por lo que también hacen cumplir los requisitos máximos, lo que no creo que el OP haya solicitado. Normalmente, usted quiere permitir que sus usuarios hagan su contraseña tan fuerte como ellos quieren; ¿Por qué restringir contraseñas seguras?

Entonces, su expresión de "mínimo ocho caracteres, al menos una letra y un número":

^(?=.*[A-Za-z])(?=.*/d)[A-Za-z/d]{8,}$

alcanza el requisito mínimo, pero los caracteres restantes solo pueden ser letras y números. Para permitir (pero no requerir) caracteres especiales, debe usar algo como:

^(?=.*[A-Za-z])(?=.*/d).{8,}$ para permitir cualquier carácter

o

^(?=.*[A-Za-z])(?=.*/d)[A-Za-z/d$@$!%*#?&]{8,}$ para permitir caracteres especiales específicos

Del mismo modo, "un mínimo de ocho caracteres, al menos una letra mayúscula, una letra minúscula y un número:"

^(?=.*[az])(?=.*[AZ])(?=.*/d)[a-zA-Z/d]{8,}$

cumple ese requisito mínimo, pero solo permite letras y números. Utilizar:

^(?=.*[az])(?=.*[AZ])(?=.*/d).{8,}$ para permitir cualquier carácter

o

^(?=.*[az])(?=.*[AZ])(?=.*/d)[A-Za-z/d$@$!%*?&]{8,} para permitir Caracteres especiales específicos.

Answer 8

Mínimo ocho caracteres, al menos una letra y un número:

"^(?=.*[A-Za-z])(?=.*/d)[A-Za-z/d]{8,}$"

Mínimo de ocho caracteres, al menos una letra, un número y un carácter especial:

"^(?=.*[A-Za-z])(?=.*/d)(?=.*[@$!%*#?&])[A-Za-z/d@$!%*#?&]{8,}$"

Mínimo de ocho caracteres, al menos una letra mayúscula, una letra minúscula y un número:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*/d)[a-zA-Z/d]{8,}$"

Mínimo de ocho caracteres, al menos una letra mayúscula, una letra minúscula, un número y un carácter especial:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*/d)(?=.*[@$!%*?&])[A-Za-z/d@$!%*?&]{8,}$"

Mínimo de ocho y máximo de 10 caracteres, al menos una letra mayúscula, una letra minúscula, un número y un carácter especial:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*/d)(?=.*[@$!%*?&])[A-Za-z/d@$!%*?&]{8,10}$"

Answer 9

No responde directamente a la pregunta, pero ¿realmente tiene que ser una expresión regular?

Solía ​​hacer un montón de Perl, y me acostumbré a resolver problemas con expresiones regulares. Sin embargo, cuando se complican más con todos los avances y otras peculiaridades, debes escribir docenas de pruebas unitarias para matar a todos esos pequeños bichos.

Además, una expresión regular suele ser unas veces más lenta que una solución imperativa o funcional.

Por ejemplo, la siguiente función Scala (no muy FP) resuelve la pregunta original aproximadamente tres veces más rápido que la expresión regular de la respuesta más popular. Lo que hace también es tan claro que no necesita una prueba de unidad en absoluto:

def validatePassword(password: String): Boolean = {
  if (password.length < 8)
    return false

  var lower = false
  var upper = false
  var numbers = false
  var special = false

  password.foreach { c =>
    if (c.isDigit)       numbers = true
    else if (c.isLower)  lower = true
    else if (c.isUpper)  upper = true
    else                 special = true
  }

  lower && upper && numbers && special
}

Answer 10

Patrón para coincidir con al menos 1 carácter en mayúscula, 1 dígito y cualquier carácter especial y la longitud entre 8 y 63.

"^ (? =. [az]) (? =. [AZ]) (? =. * / d) [a-zA-Z / d / W] {8,63} $"

Este patrón fue utilizado para la programación JAVA.

Answer 11

Prueba este:

1. Mínimo seis caracteres
2. Al menos un carácter en mayúscula
3. Al menos un carácter en minúscula.
4. Al menos un personaje especial.

Expresión:

"/^(?=.*[a-z])(?=.*[A-Z])(?=.*/d)(?=.*[$@$!%*?&.])[A-Za-z/d$@$!%*?&.]{6, 20}/"

Caracteres especiales opcionales:

1. Al menos un personaje especial.
2. Al menos un numero
3. Los caracteres especiales son opcionales
4. Mínimo seis caracteres y máximo 16 caracteres.

Expresión:

"/^(?=.*/d)(?=.*[a-zA-Z]).{6,20}$/"

Si las condiciones mínimas y máximas no son necesarias, elimínelas .{6, 16}

• 6 es el límite de caracteres mínimo
• 20 es el límite máximo de caracteres
• ? = significa expresión coincidente

Answer 12

Prueba esto:

^.*(?=.{8,})(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])[a-zA-Z0-9@#$%^&+=]*$

Esta expresión regular funciona perfectamente para mí.

function myFunction() {
    var str = "c1TTTTaTTT@";
    var patt = new RegExp("^.*(?=.{8,})(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])[a-zA-Z0-9@#$%^&+=]*$");
    var res = patt.test(str);
    console.log("Is regular matches:", res);
}

Answer 13

Puede usar el siguiente patrón de expresión regular para verificar si la contraseña coincide con sus expectativas o no.

((?=.*//d)(?=.*[a-z])(?=.*[A-Z])(?=.*[~!@#$%^&*()]).{8,20})

Answer 14

Puedes usar esta expresión regular:

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

Esta expresión regular hará cumplir estas reglas:

• Al menos una letra mayúscula en inglés , (?=.*?[AZ])
• Al menos una letra minúscula en inglés, (?=.*?[az])
• Al menos un dígito, (?=.*?[0-9])
• Al menos un carácter especial, (?=.*?[#?!@$%^&*-])
• Mínimo ocho en longitud .{8,} (con los anclajes)

Answer 15

Según su necesidad, este patrón debería funcionar bien. Prueba esto,

^(?=(.*/d){1})(.*/S)(?=.*[a-zA-Z/S])[0-9a-zA-Z/S]{8,}

Simplemente cree una variable de cadena, asigne el patrón y cree un método booleano que devuelva verdadero si el patrón es correcto, o falso.

Muestra:

String pattern = "^(?=(.*/d){1})(.*/S)(?=.*[a-zA-Z/S])[0-9a-zA-Z/S]{8,}";
String password_string = "Type the password here"

private boolean isValidPassword(String password_string) {
    return password_string.matches(Constants.passwordPattern);
}

Answer 16

Solo podemos hacer esto usando HTML5.

Utilice el código de abajo en el atributo patrón,

pattern="(?=^.{8,}$)((?=.*/d)(?=.*/W+))(?![./n])(?=.*[A-Z])(?=.*[a-z]).*$"

Funcionará perfectamente.

Answer 17

Solo una pequeña mejora para la respuesta de @ anubhava: ya que los caracteres especiales están limitados a los del teclado, use esto para cualquier carácter especial:

^(?=.*?[AZ])(?=(.*[az]){1,})(?=(.*[/d]){1,})(?=(.*[/W]){1,})(?!.*/s).{8,}$

Esta expresión regular hará cumplir estas reglas:

• Al menos una letra mayúscula en inglés
• Al menos una letra minúscula en inglés.
• Al menos un dígito
• Al menos un personaje especial.
• Mínimo ocho en longitud

Answer 18

Tuve algunas dificultades para seguir la respuesta más popular para mis circunstancias. Por ejemplo, mi validación estaba fallando con caracteres como ; o [ . No estaba interesado en incluir en la lista blanca mis caracteres especiales, así que en lugar de eso aproveché [^/w/s] como prueba; simplemente puse coincidencias entre caracteres de palabras (incluido el número) y caracteres de espacios en blanco. Para resumir, aquí está lo que me funcionó ...

• al menos 8 caracteres
• al menos 1 carácter numérico
• al menos 1 letra minúscula
• al menos 1 letra mayúscula
• al menos 1 personaje especial

/^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[^/w/s]).{8,}$/

JSFiddle Link - demostración simple que cubre varios casos

Answer 19

Una solución que encontré en una de las respuestas anteriores como:

Mínimo de 8 caracteres al menos 1 alfabeto en mayúsculas, 1 alfabeto en minúsculas, 1 número y 1 carácter especial: "^ (? =. [Az]) (? =. [AZ]) (? =. / D) (? =. [ $ @ $!% ? &]) [A-Za-z / d $ @ $!% ? &] {8,} "

... no funcionó para mí, pero la siguiente es una versión simplificada y funciona muy bien (agregue cualquier carácter especial que desee, agregué # aquí), y agregue la regla del número como lo hace con las letras como:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[$@$!%*?&]){8,}"

Answer 20

Una versión más "genérica" ​​(?), Que no permite letras en inglés como caracteres especiales .

^(?=/S*[a-z])(?=/S*[A-Z])(?=/S*/d)(?=/S*[^/w/s])/S{8,}$

var pwdList = [
    ''@@V4-/3Z`zTzM{>k'',
    ''12qw!"QW12'',
    ''123qweASD!"#'',
    ''1qA!"#$%&'',
    ''Günther32'',
    ''123456789'',
    ''qweASD123'',
    ''qweqQWEQWEqw'',
    ''12qwAS!''
  ],
  re = /^(?=/S*[a-z])(?=/S*[A-Z])(?=/S*/d)(?=/S*[^/w/s])/S{8,}$/;
  
  pwdList.forEach(function (pw) {
    document.write(''<span style="color:''+ (re.test(pw) ? ''green'':''red'') + ''">'' + pw + ''</span><br/>'');
  });

Answer 21

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

Answer 22

Use the following Regex to satisfy the below conditions:

Conditions: 1] Min 1 uppercase letter.
            2] Min 1 lowercase letter.
            3] Min 1 special character.
            4] Min 1 number.
            5] Min 8 characters.
            6] Max 30 characters.

Regex: /^(?=.*[a-z])(?=.*[A-Z])(?=.*/d)(?=.*[#$@!%&*?])[A-Za-z/d#$@!%&*?]{8,30}$/