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


448

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

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

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

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

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

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

Ответы:


1185

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

"^(?=.*[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}$"

46
"^ (= * [A-Za-Z]?.) (= * \ D?) . [A-Za-Z \ d] {8} $" не допускает символов в качестве одного из 8 символов
Ви

Я обнаружил, что следующие символы разрешены для всех символов (специальные и пунктуации), не делая их обязательными: "^ (? =. * [Az]) (? =. * [AZ]) (? =. * \ D) [a- zA-Z \ d \ w \ W] {8,} $ "
Гэвин

пароль всегда должен иметь одинаковый порядок. что-то более общее, что может начинаться с заглавных или специальных символов.
Ичинга Самуил

414

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

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

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

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

71

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

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

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

Так:

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

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


3
Хорошо, я боялся, что вы были одним из тех компьютерных ученых, которых мы иногда получаем, которые не понимают, что есть разница между регулярными выражениями и регулярными выражениями . ;) Это правда, что многие задачи регулярных выражений намного проще, если впоследствии вы можете отменить результат сопоставления, но это не всегда возможно. Это прекрасное регулярное выражение, хотя. Это не просто, это элегантно!
Алан Мур

1
Почему я раньше не задумывался? Отличный ответ (когда можно отрицать результат)
TeChn4K

2
этот позволяет пробелы, как проверить, что пароль не должен содержать пробел с вашим регулярным выражением? Я попробовал это /^(\s| .]0,7 coming|[^0-9]*|[^AZ]*|[^az]*|[^$#@%]*|\s)$/ .test ('aAa # a1a aa'); но это не работает
Гаурав

1
@Gaurav, добавить | [^ \ s] * \ s. *
Мэтт Тиммерманс

1
Любить это. Однако, чтобы это работало, мне пришлось удалить из него последний пункт |[a-zA-Z0-9]*.
17--16

36

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

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

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

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

1
Во вкусе JavaScript \Wсоответствует только символам ASCII. Таким образом, вы не изменили это, и теперь вам нужно отфильтровать пробельные символы. Кроме того, все {1,}добавленные вами круглые скобки и квантификаторы - чистый шум, и удаление ?операторов non-greedy ( ) было бессмысленным. Здесь нет никаких улучшений.
Алан Мур

И как избежать для пустой строки. Пустое регулярное выражение должно возвращать true. Я использовал следующее регулярное выражение (? =. * [0-9]) (? =. * [Az]) (? =. * [AZ]) (? =. * [@ # $% ^ & + =]) (? = \\ S + $). {8,15}
кодер

2
не для _ специального персонажа
Ахилеш

22

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

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

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

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


2
Хороший. но обнаружили одну проблему, что ваше регулярное выражение не примет _ (подчеркивание) в качестве специального символа :(.
user3217843

Хорошо, но немного ошибок. Он также принимает пробел, который не является действительным паролем, если мы используем пробел.
Dinesh.net

Мне действительно нравится этот ответ за исключением того, что он не может принять подчеркивание. Все , что я сделал , было заменить (?=.*?[^\w\s])с , (?=.*?([^\w\s]|[_]))чтобы добавить поддержку для подчеркивания и теперь он прекрасно работает. Также @ Dinish.net система, которую я использую, удаляет пробелы из строки пароля, когда мы ее получаем, поэтому использование метода vanilla JS String.prototype.trim () будет хорошо работать, если вы захотите использовать этот ответ.
Девин Карпентер

15

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

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


13

Импортируйте файл 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. Хотя бы один специальный символ

10

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

  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 - максимальный предел символов
  • ? = означает совпадение выражения

2
@Madhu Я обновил свой ответ для вашего условия для дополнительных специальных символов
ojus kulkarni

7

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

Я имел обыкновение делать много 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
}

7

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

Его выражения идеально подходят для каждого из указанных минимальных требований. Проблема с его выражениями, которые не требуют специальных символов, состоит в том, что они также НЕ ДОПУСКАЮТ специальных символов, поэтому они также обеспечивают максимальные требования, которые, как я полагаю, не запрашивал 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,} разрешить определенные специальные символы.


Спасибо за объяснение.
Hải Nguyễn

Это должно быть помечено как правильный ответ. Главный ответ неверен.
Джейк

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

2
Чем ваш ответ лучше других ответов, написанных много лет назад?
Сантос

@ JoshYates1980 Можете ли вы упомянуть «Специальный символ», для которого не удалось выполнить регулярное выражение. Позвольте мне проверить это и обновить его соответствующим образом. Но, насколько я знаю, это работает со всеми согласно условию мандата 1 специального символа. Жду от вас ответа ....
ШАШАНК ХОНРАО

1
@SHASHANKHONRAO Я обновил выражение: ^ (? =. * [Az]) (? =. * [AZ]) (? =. * \ D) (? =. * [$ @ $!% *? & + ~ |{}:;<>/])[A-Za-z\d$@$!%*?&+~| {}:; <> /] {8,15}, который будет включать следующие не буквенно-цифровые символы: (@ $!% *? & + ~ `| {}
:;

6

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

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

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

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

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


Ваше предлагаемое регулярное выражение и тот, который находится под ссылкой regex101, различается. Не должно ли это быть ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[\W\_])[A-Za-z\d\W\_]{8,}$?
CraZ

1
@CraZ Я отредактировал регулярное выражение, спасибо за ваше предложение.
Эмерсон Джоэл Рохас Солиз

3

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

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

3

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

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

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

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

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

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

Это регулярное выражение, даже когда пробелы находятся внутри пароля, у меня не сработало
Артур Мело


2

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

2

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

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">


2

Тестирование этого в 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}`);
    });
}


Как это лучше, чем принятый ответ?
Тото

@ Тото нет принятого ответа в этой теме, по крайней мере, я не вижу, есть ответы с большим количеством голосов, но я не вижу принятого ответа. Кроме того, я узнал об этом и прочитал об этом на regex101 для достоверности, поэтому поделился им с фрагментом кода, чтобы проверить достоверность.
Михир Кумар

1

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

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


1

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

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

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

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


1

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

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


1

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

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

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

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


Чем это отличается от принятого ответа?
Тото

0

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

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

0

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

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

0

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

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

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


0

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

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


0

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

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

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

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

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

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


0

Если вы хотите использовать регулярные выражения для проверки не менее восьми символов, как минимум одной заглавной буквы, хотя бы одной строчной буквы, хотя бы одного числа от 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
}

-1

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

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

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

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

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

1
Это количественная оценка позитивного взгляда.
ctwheels
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.