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

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

"^(?=.*[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,} (с якорями)

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

Но регулярные выражения имеют оператор 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)
});

• Как минимум одна верхняя буква Английская буква
• По крайней мере, одна строчная английская буква
• Как минимум одна цифра
• Как минимум один специальный символ

Попробуйте следующее:

• Минимум шесть символов
• Как минимум один символ верхнего регистра
• Как минимум один строчный символ
• Как минимум один специальный символ

Выражение

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

Дополнительные специальные символы:

• Как минимум один специальный символ
• Как минимум одно число
• Специальные символы необязательны
• Минимум шесть символов и максимум 16 символов

Выражение

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

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

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

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

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

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

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

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

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

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

или же

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

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

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

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

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

или же

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

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

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

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

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

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
}

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

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

@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,}$

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

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

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

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

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

Регулярное выражение: ^(?=.*\d)(?=.*[#$@!%&*?])[A-Za-z\d#$@!%&*?]{8,}$

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

"^ (? =. [AZ]) (? =. [AZ]) (? =. *\Г) [A-Za-Z\д\W] {8,63} $"

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

Попробуйте следующее:

^.*(?=.{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);
}

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

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

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

Минимум 8 символов, по крайней мере, 1 алфавитный алфавит, 1 строчный алфавит, 1 номер и 1 специальный символ:    "^ (=\D?). (= [$ @$% & Усилитель!?;]?.) (= [Аз]?.) (= [AZ]?.) [A-Za-Z\d $@!? $% &] {8}"

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

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