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

Ответ 1

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

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

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

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

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

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

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

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

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

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

Ответ 2

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

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

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

• Как минимум одна заглавная буква английского алфавита, (?=.*?[AZ])
• Как минимум одна строчная английская буква, (?=.*?[az])
• Хотя бы одна цифра, (?=.*?[0-9])
• По крайней мере, один специальный символ, (?=.*?[#[email protected]$%^&*-])
• Длина минимум восемь .{8,} (с якорями)

Ответ 3

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

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

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

Итак:

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

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

Ответ 4

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

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

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

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

Ответ 5

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

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

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

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

Ответ 6

Импортировать файл 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)
});

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

Ответ 7

Более "родовая" версия (?), не позволяющая ни одному английскому письму как специальные символы.

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

Ответ 8

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

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

Выражение

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

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

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

Выражение

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

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

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

Ответ 9

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

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

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

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

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

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

или же

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

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

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

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

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

или же

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

Ответ 10

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)(?=.*[#[email protected]!%&*?])[A-Za-z\d#[email protected]!%&*?]{8,30}$/    

Ответ 11

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

Я использовал много 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
}

Ответ 12

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

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

Ответ 13

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

Ответ 14

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

Ответ 15

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

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

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

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

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

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

Ответ 16

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

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

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

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

Ответ 17

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

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

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

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

Ответ 18

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

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

Ответ 19

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

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

Ответ 20

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

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

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

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

Ответ 21

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

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

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

Ответ 22

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

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

Ответ 23

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

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

Ответ 24

На самом деле я только что скопировал первый ответ здесь и превратил его в более удобное регулярное выражение ux-convenient regex, которому нужен один верхний, один нижний и как минимум 8 символов, но все принимается "между".

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

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

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

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

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

Ответ 25

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

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

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

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