Regex для пароля должно содержать не менее восьми символов, как минимум одно число, а также строчные и прописные буквы и специальные символы

Я хочу регулярное выражение, чтобы проверить, что:

Пароль содержит не менее восьми символов, в том числе , по крайней мере один номер и включает в себя как нижний и заглавные буквы и специальные символы, например #, ?, !.

Это не может быть ваш старый пароль или содержать ваше имя пользователя "password", или"websitename"

А вот мое проверочное выражение для восьми символов, включая одну заглавную букву, одну строчную букву и одну цифру или специальный символ.

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

Как я могу написать его, для пароля должно быть восемь символов, включая одну заглавную букву, один специальный символ и буквенно-цифровые символы ?

Минимум восемь символов, как минимум одна буква и одна цифра:

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

Минимум восемь символов, как минимум одна буква, одна цифра и один специальный символ:

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

Минимум восемь символов, как минимум одна заглавная буква, одна строчная буква и одна цифра:

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

Минимум восемь символов, как минимум одна заглавная буква, одна строчная буква, одна цифра и один специальный символ:

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

Минимум восемь и максимум 10 символов, как минимум одна заглавная буква, одна строчная буква, одна цифра и один специальный символ:

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

Вы можете использовать это регулярное выражение с несколькими проверочными утверждениями (условиями) :

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

Это регулярное выражение будет применять эти правила:

• Как минимум одна заглавная буква английского алфавита ,(?=.*?[A-Z])
• Хотя бы одну строчную английскую букву, (?=.*?[a-z])
• Хотя бы одна цифра, (?=.*?[0-9])
• По крайней мере, один специальный символ, (?=.*?[#?!@$%^&*-])
• Минимум восемь в длину .{8,}(с якорями)

Регулярные выражения не имеют оператора AND, поэтому довольно сложно написать регулярное выражение, которое соответствует действительным паролям, когда валидность определяется чем-то И чем-то другим И чем-то еще ...

Но в регулярных выражениях есть оператор OR, поэтому просто примените теорему Деморгана и напишите регулярное выражение, соответствующее недействительным паролям:

Все , что с менее восьми символов ИЛИ ничего без каких - либо цифр ИЛИ ничего с не прописными буквами OR или что - либо без какого - либо строчного ИЛИ ничего без каких - либо специальных символов.

Так:

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

Если что-то соответствует этому, то это неверный пароль.

Небольшое улучшение ответа @ anubhava: поскольку специальные символы ограничены теми, что на клавиатуре, используйте их для любых специальных символов:

^(?=.*?[A-Z])(?=(.*[a-z]){1,})(?=(.*[\d]){1,})(?=(.*[\W]){1,})(?!.*\s).{8,}$

Это регулярное выражение будет применять эти правила:

• Хотя бы одна заглавная английская буква
• Хотя бы одна строчная английская буква
• Хотя бы одна цифра
• Хотя бы один специальный символ
• Минимум восемь в длину

У меня возникли трудности с поиском наиболее популярного ответа на мои обстоятельства. Например, моя проверка не удалась с такими символами, как ;или [. Меня не интересовал белый список моих специальных символов, поэтому я вместо этого использовал [^\w\s]в качестве теста - проще говоря - сопоставления несловесных символов (включая числовые) и непробельных символов. Подводя итог, вот что сработало для меня ...

• хотя бы 8персонажи
• хотя бы 1числовой символ
• хотя бы 1строчная буква
• хотя бы 1заглавная буква
• хотя бы 1спецсимвол

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

JSFiddle Link - простая демонстрация, охватывающая различные случаи

Более «универсальная» версия (?), Не допускающая использования английских букв в качестве специальных символов .

^(?=\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/>');
  });

Импортируйте файл JavaScript jquery.validate.min.js.

Вы можете использовать этот метод:

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

1. Хотя бы одна заглавная английская буква
2. Хотя бы одна строчная английская буква
3. Хотя бы одна цифра
4. Хотя бы один специальный символ

Попробуй это:

1. Минимум шесть символов
2. Хотя бы один заглавный символ
3. Хотя бы один строчный символ
4. Хотя бы один специальный символ

Выражение:

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

Необязательные специальные символы:

1. Хотя бы один специальный символ
2. Хотя бы один номер
3. Специальные символы необязательны
4. Минимум шесть символов и максимум 16 символов

Выражение:

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

Если условие min и max не требуется, удалите .{6, 16}

• 6 - минимальный предел символов
• 20 - максимальный предел символов
• ? = означает совпадение выражения

Непосредственно не отвечая на вопрос, но действительно ли это должно быть регулярным выражением?

Я имел обыкновение делать много Perl, и привык к решению проблем с регулярными выражениями. Однако, когда они усложняются со всеми упущениями и прочими причудами, вам нужно написать десятки модульных тестов, чтобы убить все эти маленькие ошибки.

Кроме того, регулярное выражение обычно в несколько раз медленнее, чем императивное или функциональное решение.

Например, следующая (не очень FP) функция Scala решает исходный вопрос примерно в три раза быстрее, чем регулярное выражение самого популярного ответа. То, что он делает, также ясно, что вам вообще не нужен юнит-тест:

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
}

Я бы ответил Петру Мортенсену, но мне не хватает репутации.

Его выражения идеально подходят для каждого из указанных минимальных требований. Проблема с его выражениями, которые не требуют специальных символов, состоит в том, что они также НЕ ДОПУСКАЮТ специальных символов, поэтому они также обеспечивают максимальные требования, которые, как я полагаю, не запрашивал OP. Обычно вы хотите, чтобы ваши пользователи делали свои пароли настолько надежными, насколько им хочется; зачем ограничивать надежные пароли?

Итак, его выражение «минимум восемь символов, хотя бы одна буква и одна цифра»:

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

достигается минимальное требование, но остальные символы могут быть только буквой и цифрой. Чтобы разрешить (но не требовать) специальные символы, вы должны использовать что-то вроде:

^(?=.*[A-Za-z])(?=.*\d).{8,}$ разрешить любые символы

или

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d$@$!%*#?&]{8,}$ разрешить определенные специальные символы

Аналогично, «минимум восемь символов, как минимум одна заглавная буква, одна строчная буква и одна цифра:»

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

соответствует этому минимальному требованию, но допускает только буквы и цифры. Использование:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$ разрешить любые символы

или

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\d$@$!%*?&]{8,} разрешить определенные специальные символы.

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}$/    

Как насчет рассмотрения следующего решения регулярных выражений:

^(?=.*[\w])(?=.*[\W])[\w\W]{8,}$

Что подтверждает следующее:

1. Хотя бы одна строчная
2. Хотя бы одна заглавная
3. Хотя бы одна цифра
4. Хотя бы один специальный символ
5. По крайней мере, он должен иметь длину 8 символов.

Проверьте это, работая по следующей ссылке https://regex101.com/r/qPmC06/4/

В соответствии с вашими потребностями этот шаблон должен работать просто отлично. Попробуй это,

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

Просто создайте строковую переменную, назначьте шаблон и создайте логический метод, который возвращает true, если шаблон правильный, иначе false.

Образец:

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);
}

Я нашел много проблем здесь, поэтому я сделал свой собственный.

Вот он, во всей красе, с тестами:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*([^a-zA-Z\d\s])).{9,}$

https://regex101.com/r/DCRR65/4/tests

На что обращать внимание:

1. не использует, \wпотому что это включает в себя _, что я проверяю.
2. У меня было много проблем, связанных с символами, без соответствия конца строки.
3. Символы не указываются конкретно, это также потому, что разные локали могут иметь разные символы на своих клавиатурах, которые они могут использовать.

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

@ClasG уже предложил :

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

но он не принимает _ (подчеркивание) в качестве специального символа (например, Aa12345_).

Улучшенный это:

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

Демо-версия:

function password_check() {
  pass = document.getElementById("password").value;
  console.log(pass);
  regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
  if (regex.exec(pass) == null) {
    alert('invalid password!')
  }
  else {
    console.log("valid");
  }
}

<input type="text" id="password" value="Sample@1">
<input type="button" id="submit" onclick="password_check()" value="submit">

Тестирование этого в 2020 году:

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

Проверьте себя

const regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
const str = `some12*Nuts`;
let m;

if ((m = regex.exec(str)) !== null) {
    // The result can be accessed through the `m`-variable.
    m.forEach((match, groupIndex) => {
        console.log(`Found match, group ${groupIndex}: ${match}`);
    });
}

Используйте следующее регулярное выражение для выполнения следующих условий:

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

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

Можно проверить онлайн: https://regex101.com

Просто мы можем сделать это с помощью HTML5.

Используйте приведенный ниже код в атрибуте pattern,

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

Это будет работать отлично.

Вы можете использовать шаблон регулярного выражения ниже, чтобы проверить пароль, соответствует ли он вашим ожиданиям или нет.

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

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

Ссылка проверить онлайн https://regex101.com/r/mqGurh/1

Использовать этот,

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

Он будет проверять как минимум одну строчную букву, одну заглавную букву, одно число и специальные символы (!, @, #, $,%,?, =, *, &).

Минимальная длина 8 и максимальная длина 20

В Java / Android для проверки пароля, по крайней мере, с одним числом, одной буквой и одним специальным символом в следующем шаблоне:

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

Попробуй это:

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

Это регулярное выражение работает для меня отлично.

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);
}

Шаблон, соответствующий как минимум 1 заглавным буквам, 1 цифре и любым специальным символам и длиной от 8 до 63.

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

Этот шаблон был использован для программирования JAVA.

Надеюсь, что ниже работает. Я пробовал это в пользовательской политике Azure.

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

На самом деле, я просто скопировал первый ответ здесь и превратил его в более удобное для пользователя регулярное выражение, которому нужен один верхний, один нижний и как минимум 8 символов, но он принимает все «между».

Это пример-регулярное выражение, которое требует

1. длина не менее 8 символов
2. хотя бы одна строчная буква
3. не менее одной заглавной буквы

ВАЖНО : Это регулярное выражение также будет исключать все остальные символы, например цифры, специальные символы, такие как $, # ,! и т.д. - до тех пор, пока правила 1. до 3. соответствуют входной строке

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

Следите за "." почти в конце регулярного выражения Это будет соответствовать практически любому (и любому другому читаемому) персонажу

Если вы хотите использовать регулярные выражения для проверки не менее восьми символов, как минимум одной заглавной буквы, хотя бы одной строчной буквы, хотя бы одного числа от 0 до 9 и хотя бы одного специального символа из:! @ # $% ^ & * _? И также дать пользователю немного больше информации о том, чего ему не хватает в пароле, вы можете использовать следующий код:

let password = "@Aa3a4d$";

//  Check every single condition separately
let lowercase = password.match((/[a-z]+/g));
let uppercase = password.match((/[A-Z]+/g));
let digits = password.match((/[\d]+/g));
let special = password.match((/[!@#$%^&*_]+/g));
let lenght = password.match((/[A-Za-z\d!@#$%^&*_]{8,}/g));

//  Array to store information about any mismatches in the string
let errors = [];

if (password === '' ) {
    errors.push('Password is required');
}
if (lowercase === null) {
    errors.push('Password must include at least one lowercase letter');
}
if (uppercase === null) {
    errors.push('Password must include at least one uppercase letter');
}
if (digits === null) {
    errors.push('Password must include at least one digit from 0 to 9');
}
if (special  === null) {
    errors.push('Password must include at least one special character');
}
if (lenght === null) {
    errors.push('Password must include at least 8 characters');
}
if (errors.length > 0) {
    console.log(errors);
    return;
} else {
    // Process your password
}

Решение, которое я нашел в одном из предыдущих ответов:

* Минимум 8 символов, минимум 1 заглавный алфавит, 1 строчный алфавит, 1 цифра и 1 специальный символ:

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

... не работает для меня, но следующее является упрощенной версией и прекрасно работает (добавьте любой понравившийся вам специальный символ, я добавил # здесь), и добавьте правило чисел, как вы делаете с буквами как:

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