Estoy tratando de crear una prueba Regex en JavaScript que probará una cadena para contener cualquiera de estos caracteres:

!$%^&*()_+|~-=`{}[]:";'<>?,./

Más información si está interesado :)

Es para una aplicación de cambio de contraseña genial en la que estoy trabajando. En caso de que esté interesado, aquí está el resto del código.

Tengo una tabla que enumera los requisitos de contraseña y, a medida que los usuarios finales escriben la nueva contraseña, probará una matriz de expresiones regulares y colocará una marca de verificación en la fila de la tabla correspondiente si ... verifica :) Solo necesito agregar esta en lugar del cuarto elemento de la validationmatriz.

var validate = function(password){
    valid = true;

    var validation = [
        RegExp(/[a-z]/).test(password), RegExp(/[A-Z]/).test(password), RegExp(/\d/).test(password), 
        RegExp(/\W|_/).test(password), !RegExp(/\s/).test(password), !RegExp("12345678").test(password), 
        !RegExp($('#txtUsername').val()).test(password), !RegExp("cisco").test(password), 
        !RegExp(/([a-z]|[0-9])\1\1\1/).test(password), (password.length > 7)
    ]

    $.each(validation, function(i){
        if(this)
            $('.form table tr').eq(i+1).attr('class', 'check');
        else{
            $('.form table tr').eq(i+1).attr('class', '');
            valid = false
        }
    });

    return(valid);

}

Sí, también existe la correspondiente validación del lado del servidor.

La expresión regular para esto es realmente simple. Solo usa una clase de personaje. El guión es un carácter especial en las clases de caracteres, por lo que debe ser el primero:

/[-!$%^&*()_+|~=`{}\[\]:";'<>?,.\/]/

También necesita escapar de los otros metacaracteres de expresión regular.

Editar: el guión es especial porque se puede usar para representar un rango de caracteres. Esta misma clase de caracteres se puede simplificar con rangos a esto:

/[$-/:-?{-~!"^_`\[\]]/

Hay tres rangos. '$' a '/', ':' a '?' y '{' a '~'. la última cadena de caracteres no se puede representar más simplemente con un rango:! "^ _` [].

Use una tabla ACSII para encontrar rangos para clases de caracteres.

La forma más simple y corta de lograr esto:

/[^\p{L}\d\s@#]/u

Explicación

[^...] Coincide con un solo carácter que no está presente en la lista siguiente

• \p{L} => coincide con cualquier tipo de letra de cualquier idioma

• \d => coincide con un dígito del cero al nueve

• \s => coincide con cualquier tipo de carácter invisible

• @# => @y #personajes

No olvide pasar la ubandera (unicode).

Responder

/[\W\S_]/

Explicación

Esto crea una clase de carácter que elimina los caracteres de palabra, los espacios y vuelve a agregar el carácter de subrayado (como subrayado es un carácter de "palabra"). Todo lo que queda son los caracteres especiales. Las letras mayúsculas representan la negación de sus contrapartes minúsculas.

\Wseleccionará todos los caracteres que no sean de "palabra" equivalentes a [^a-zA-Z0-9_]
\Sseleccionará todos los caracteres que no sean "espacios en blanco" equivalentes a [ \t\n\r\f\v]
_seleccionará "_" porque lo negamos cuando usamos el \Wy necesitamos volver a agregarlo

// The string must contain at least one special character, escaping reserved RegEx characters to avoid conflict
  const hasSpecial = password => {
    const specialReg = new RegExp(
      '^(?=.*[!@#$%^&*"\\[\\]\\{\\}<>/\\(\\)=\\\\\\-_´+`~\\:;,\\.€\\|])',
    );
    return specialReg.test(password);
  };

Una forma sencilla de lograr esto es el conjunto negativo [^ \ w \ s]. Esto esencialmente atrapa:

• Todo lo que no sea un carácter alfanumérico (letras y números)
• Cualquier cosa que no sea un espacio, tabulación o salto de línea (denominados colectivamente espacios en blanco)

Por alguna razón, [\ W \ S] no funciona de la misma manera, no hace ningún filtrado. Un comentario de Zael sobre una de las respuestas proporciona una especie de explicación.

Reemplace todos los últimos de cualquier idioma en 'A', y si lo desea, por ejemplo, todos los dígitos a 0:

return str.replace(/[^\s!-@[-`{-~]/g, "A").replace(/\d/g, "0");