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

Регулярные выражения — это неотъемлемый инструмент программирования, который можно использовать для решения многих практических повседневных задач. Вы можете использовать регулярные выражения для поиска, сопоставления или анализа текста. С помощью правильных шаблонов вы можете проверить некоторые из наиболее распространенных данных учетной записи пользователя.

Вы можете использовать регулярные выражения со многими языками и инструментами, включая Python и JavaScript.

Регулярное выражение для проверки имени пользователя

Рассмотрим имя пользователя, которое допустимо только в том случае, если оно удовлетворяет следующим условиям:

1. Количество символов должно быть от 5 до 15. (Вы можете указать другой диапазон в соответствии с вашими требованиями, но внесите соответствующие изменения в регулярное выражение.)
2. Строка должна содержать только буквенно-цифровые символы и/или символы подчеркивания (_).
3. Первый символ строки должен быть буквенным.

Следующее регулярное выражение удовлетворяет вышеуказанным условиям и может проверять имя пользователя:

^[A-Za-z]\\w{4,14}$

Если вам не нравится приведенное выше выражение, проверьте руководство для начинающих по регулярным выражениям первый. Это подход Python для проверки имени пользователя:

Импортировать ре
дефcheckUsername(имя пользователя):
 регулярное выражение = "^[A-Za-z]\\w{4,14}$"
 r = перекомпилировать (регулярное выражение)
если (ре.поиск(р, имя пользователя)):
 Распечатать("Действительный")
еще:
 Распечатать("Недействительно")
имя пользователя1 = "юврадж_чандра"
checkUsername (имя_пользователя1)
имя пользователя2 = "ja7&^%87"
checkUsername (имя_пользователя2)

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

Точно так же вы можете проверить имя пользователя в JavaScript, используя следующий код:

функцияcheckUsername(пользователь) {
если(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.тест (пользователь)) {
 console.log('Действительный');
 } еще {
 console.log('Недействительно');
 }
}
проверитьимя пользователя('юврадж_чандра');
проверитьимя пользователя('ja7&^%87'); 

Вы можете использовать этот код для проверять HTML-формы с помощью регулярных выражений.

Регулярное выражение для проверки адреса электронной почты

Регулярное выражение для проверки адреса электронной почты не идеально. Не существует общепринятого регулярного выражения для проверки адреса электронной почты. Это полностью сводится к вашему определению действительного.

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

1. Имя пользователя должно содержать только буквенно-цифровые символы, символы подчеркивания, тире и/или точки.
2. Строка идентификатора электронной почты должна содержать один символ @.
3. Имя домена должно содержать только буквенно-цифровые символы, символы подчеркивания или тире.
4. После имени домена должна стоять точка.
5. Расширение домена должно содержать только буквенно-цифровые символы, символы подчеркивания или тире.
6. Длина расширения домена должна быть от 2 до 4.

Следующее регулярное выражение удовлетворяет вышеуказанным условиям и может проверять адрес электронной почты:

^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$

Это подход Python к проверке адреса электронной почты:

Импортировать ре
дефcheckEmailId(электронная почта):
 регулярное выражение = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = перекомпилировать (регулярное выражение)
если (ре.поиск(р, электронная почта)):
 Распечатать("Действительный")
еще:
 Распечатать("Недействительно")
электронная почта1 = "[email protected]"
checkEmailId (email1)
электронная почта2 = "абв@деф@gmail.kahscg"
checkEmailId (email2)

Опять же, вывод подтверждает, что первый адрес электронной почты действителен, а второй недействителен:

Вы можете проверить электронную почту в JavaScript, используя следующий код:

функцияcheckEmailId(электронная почта) {
если (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.тест (электронная почта)) {
консоль.log('Действительно');
 } еще {
консоль.log('Недействительно');
 }
}
checkEmailId("[email protected]");
checkEmailId("abc@[email protected]");

Проверка надежности пароля с помощью регулярных выражений

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

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

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

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

(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})

Вы можете проверить надежность пароля в Python, используя следующий код:

Импортировать ре
дефпроверитьPasswordStrength(пароль):
 регулярное выражение = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})"
 r = перекомпилировать (регулярное выражение)
если (ре.поиск(р, пароль)):
 Распечатать("Надежный пароль")
еще:
 Распечатать("Слабый пароль")
пароль1 = "Hiuahd$5jawd"
checkPasswordStrength (пароль1)
пароль2 = "мой пароль"
checkPasswordStrength (пароль2)

Запуск этого кода подтвердит, что первый пароль надежный, а второй — слабый:

Вы можете проверить надежность пароля в JavaScript, используя следующий код:

функцияпроверитьPasswordStrength(пароль) {
если (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.тест (пароль)) {
 console.log('Надежный пароль');
 } еще {
 console.log('Слабый пароль');
 }
}
проверитьНадежность пароля('Hiuahd$5jawd');
проверитьНадежность пароля('мой пароль');

Регулярное выражение для соответствия действительной дате

Если вы хотите быстро проверить, соответствуют ли заданные даты традиционному формату даты, вы можете сделать это с помощью регулярного выражения.

Следующее регулярное выражение соответствует дате в мм/дд/гггг формат:

^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\д\д$

Следующий код Python проверяет дату в мм/дд/гггг формат:

Импортировать ре
дефcheckDateFormat(дата):
 регулярное выражение = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\д\д$"
 r = перекомпилировать (регулярное выражение)
если(ре.поиск(р, дата)):
 Распечатать("Действительный")
еще:
 Распечатать("Недействительно")
дата1 = "03/21/2002"
checkDateFormat (дата1)
дата2 = "15/21/2002"
checkDateFormat (дата2)

Еще раз вывод подтверждает, что первый формат даты действителен, а второй недействителен:

Вы можете проверить дату в мм/дд/гггг отформатируйте в JavaScript, используя следующий код:

функцияcheckDateFormat(дата) {
если(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\д\д$/.Дата испытаний)) {
 console.log('Действительный');
 } еще {
 console.log('Недействительно');
 }
}
проверить формат даты ('03/21/2002');
проверить формат даты ('15/21/2002');

Проверка пустой строки с использованием регулярных выражений

Вы можете проверить, пуста ли строка, используя следующее регулярное выражение:

^$

Ниже приведен подход Python для проверки пустой строки:

Импортировать ре
дефcheckEmptyString(ул.):
 регулярное выражение = "^$"
 r = перекомпилировать (регулярное выражение)
если (ре.поиск(р, ул)):
Распечатать("Данная строка пустой")
еще:
Распечатать("Данная строка не пустой")
стр1 = ""
checkEmptyString (str1)
стр2 = "Это не пустая строка"
checkEmptyString (str2)

Следующий вывод демонстрирует, что первая заданная строка пуста, а вторая — нет:

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

функцияcheckEmptyString(ул) {
если (/^$/.тест (стр)) {
 console.log('Данная строка пуста');
 } еще {
 console.log('Данная строка не пуста');
 }
}
проверитьпустуюстроку('');
проверитьпустуюстроку('Это не пустая строка'); 

RegEx для проверки почтового индекса (почтовый индекс США)

Вы можете проверить почтовый индекс (почтовый индекс США) как в пятизначном, так и в девятизначном формате (так называемый ZIP+4), используя следующее регулярное выражение:

^[0-9]{5}(?:-[0-9]{4})?$

Ниже приведен код Python для проверки почтовых индексов:

Импортировать ре
дефпроверитьZIPCode(код):
 регулярное выражение = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = перекомпилировать (регулярное выражение)
если (ре.поиск(р, код)):
 Распечатать("Действительный")
еще:
 Распечатать("Недействительно")
код1 = "76309"
проверитьZIPCode (code1)
код2 = "83468-2348"
проверитьZIPCode (code2)
код3 = "234445"
проверитьZIPCode (code3)

Запуск этого кода подтвердит, что первый и второй почтовые индексы действительны, а третий — нет:

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

функцияпроверитьZIPCode(код) {
если (/^[0-9]{5}(?:-[0-9]{4})?$/.тест (код)) {
 console.log('Действительный');
 } еще {
 console.log('Недействительно');
 }
}
проверитьZIPCode('76309');
проверитьZIPCode('83468-2348');
проверитьZIPCode('234445');

Проверка ввода пользователя с помощью надежного кода

Вы узнали, как проверять данные учетной записи пользователя с помощью регулярных выражений. Проверка этих деталей делает код надежным и помогает устранять проблемы безопасности и нежелательные ошибки. Надежный код обеспечивает безопасный и надежный опыт для ваших пользователей.

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