Regex untuk kata sandi harus mengandung setidaknya delapan karakter, setidaknya satu angka dan huruf kecil dan besar dan karakter khusus

Saya ingin ekspresi reguler untuk memeriksa bahwa:

Sandi mengandung setidaknya delapan karakter, termasuk setidaknya satu nomor dan mencakup lebih rendah dan huruf besar huruf dan karakter khusus, misalnya #, ?, !.

Itu tidak dapat berupa kata sandi lama Anda atau berisi nama pengguna Anda "password",, atau"websitename"

Dan ini adalah ekspresi validasi saya untuk delapan karakter termasuk satu huruf besar, satu huruf kecil, dan satu angka atau karakter khusus.

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

Bagaimana saya bisa menulisnya dengan kata sandi harus delapan karakter termasuk satu huruf besar, satu karakter khusus dan karakter alfanumerik ?

Minimal delapan karakter, setidaknya satu huruf dan satu angka:

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

Minimal delapan karakter, setidaknya satu huruf, satu angka, dan satu karakter khusus:

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

Minimal delapan karakter, setidaknya satu huruf besar, satu huruf kecil dan satu nomor:

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

Minimal delapan karakter, setidaknya satu huruf besar, satu huruf kecil, satu angka dan satu karakter khusus:

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

Minimum delapan dan maksimum 10 karakter, setidaknya satu huruf besar, satu huruf kecil, satu angka dan satu karakter khusus:

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

Anda dapat menggunakan regex ini dengan beberapa pernyataan lookahead (kondisi) :

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

Regex ini akan memberlakukan aturan ini:

• Setidaknya satu huruf besar huruf Inggris ,(?=.*?[A-Z])
• Setidaknya satu huruf bahasa Inggris huruf kecil, (?=.*?[a-z])
• Setidaknya satu digit, (?=.*?[0-9])
• Setidaknya satu karakter khusus, (?=.*?[#?!@$%^&*-])
• Panjang minimum delapan .{8,}(dengan jangkar)

Ekspresi reguler tidak memiliki operator DAN, jadi cukup sulit untuk menulis regex yang cocok dengan kata sandi yang valid, ketika validitas ditentukan oleh sesuatu DAN sesuatu yang lain DAN sesuatu yang lain ...

Tetapi, ekspresi reguler memiliki operator ATAU, jadi terapkan saja teorema DeMorgan, dan tuliskan regex yang cocok dengan kata sandi yang tidak valid:

Apa pun yang kurang dari delapan karakter ATAU apa pun tanpa angka ATAU apa pun tanpa huruf besar ATAU atau apa pun tanpa huruf kecil ATAU apa pun tanpa karakter khusus.

Begitu:

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

Jika ada yang cocok dengan itu, maka itu adalah kata sandi yang tidak valid.

Hanya sedikit peningkatan untuk jawaban @ anubhava: Karena karakter khusus terbatas pada yang ada di keyboard, gunakan ini untuk karakter khusus apa pun:

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

Regex ini akan memberlakukan aturan ini:

• Setidaknya satu huruf Inggris huruf besar
• Setidaknya satu huruf Inggris huruf kecil
• Setidaknya satu digit
• Setidaknya satu karakter khusus
• Panjang minimum delapan

Saya mengalami kesulitan mengikuti jawaban yang paling populer untuk keadaan saya. Misalnya, validasi saya gagal dengan karakter seperti ;atau [. Saya tidak tertarik pada daftar putih karakter khusus saya, jadi saya malah memanfaatkannya [^\w\s]sebagai tes - cukup cantumkan - cocokkan karakter non-kata (termasuk angka) dan karakter bukan spasi. Untuk meringkas, inilah yang bekerja untuk saya ...

• setidaknya 8karakter
• setidaknya 1karakter numerik
• setidaknya 1huruf kecil
• setidaknya 1huruf besar
• setidaknya 1karakter spesial

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

JSFiddle Link - demo sederhana yang mencakup berbagai kasus

Versi yang lebih "generik" (?), Memungkinkan tidak ada huruf bahasa Inggris sebagai karakter khusus .

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

Impor file JavaScript jquery.validate.min.js.

Anda dapat menggunakan metode ini:

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

1. Setidaknya satu huruf Inggris huruf besar
2. Setidaknya satu huruf Inggris huruf kecil
3. Setidaknya satu digit
4. Setidaknya satu karakter khusus

Coba yang ini:

1. Minimal enam karakter
2. Setidaknya satu karakter huruf besar
3. Setidaknya satu karakter huruf kecil
4. Setidaknya satu karakter khusus

Ekspresi:

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

Karakter Khusus opsional:

1. Setidaknya satu karakter khusus
2. Setidaknya satu nomor
3. Karakter khusus bersifat opsional
4. Minimal enam karakter dan maksimum 16 karakter

Ekspresi:

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

Jika kondisi minimum dan maksimum tidak diperlukan, hapus .{6, 16}

• 6 adalah batas karakter minimum
• 20 adalah batas karakter maksimum
• ? = Berarti ekspresi kecocokan

Tidak langsung menjawab pertanyaan, tetapi apakah itu benar-benar harus menjadi regex?

Saya biasa melakukan banyak Perl, dan terbiasa memecahkan masalah dengan regex. Namun, ketika mereka menjadi lebih rumit dengan semua pandangan-depan dan keanehan lainnya, Anda perlu menulis lusinan unit test untuk membunuh semua bug kecil itu.

Lebih jauh, suatu regex biasanya beberapa kali lebih lambat daripada solusi imperatif atau fungsional.

Misalnya, fungsi Scala berikut (tidak terlalu FP) memecahkan pertanyaan awal sekitar tiga kali lebih cepat daripada regex jawaban yang paling populer. Apa yang dilakukannya juga sangat jelas sehingga Anda tidak perlu tes unit sama sekali:

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
}

Saya akan membalas Peter Mortensen, tetapi saya tidak memiliki reputasi yang cukup.

Ekspresinya sempurna untuk setiap persyaratan minimum yang ditentukan. Masalah dengan ekspresinya yang tidak memerlukan karakter khusus adalah bahwa mereka juga tidak MENGIZINKAN karakter khusus, sehingga mereka juga memberlakukan persyaratan maksimum, yang saya tidak percaya OP diminta. Biasanya Anda ingin mengizinkan pengguna membuat kata sandi mereka sekuat yang mereka inginkan; mengapa membatasi kata sandi yang kuat?

Jadi, ekspresinya "minimum delapan karakter, setidaknya satu huruf dan satu angka":

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

mencapai persyaratan minimum, tetapi karakter yang tersisa hanya dapat berupa huruf dan angka. Untuk mengizinkan (tetapi tidak mengharuskan) karakter khusus, Anda harus menggunakan sesuatu seperti:

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

atau

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

Demikian juga, "minimum delapan karakter, setidaknya satu huruf besar, satu huruf kecil dan satu nomor:"

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

memenuhi persyaratan minimum itu, tetapi hanya membolehkan huruf dan angka. Menggunakan:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$ untuk mengizinkan karakter apa pun

atau

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

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

Bagaimana dengan mempertimbangkan solusi regex berikut:

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

Yang memvalidasi berikut ini:

1. Setidaknya satu huruf kecil
2. Setidaknya satu huruf besar
3. Setidaknya satu digit
4. Setidaknya satu karakter khusus
5. Setidaknya harus memiliki 8 karakter.

Lihat berfungsi di tautan berikut https://regex101.com/r/qPmC06/4/

Sesuai dengan kebutuhan Anda, pola ini seharusnya bekerja dengan baik. Coba ini,

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

Cukup buat variabel string, tetapkan pola, dan buat metode boolean yang mengembalikan true jika polanya benar, kalau tidak salah.

Sampel:

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

Saya menemukan banyak masalah di sini, jadi saya buat sendiri.

Ini dia semua kemuliaan, dengan tes:

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

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

Hal-hal yang harus diperhatikan:

1. tidak digunakan \wkarena itu termasuk _, yang saya uji.
2. Saya memiliki banyak masalah dengan simbol yang cocok, tanpa mencocokkan akhir baris.
3. Tidak menentukan simbol secara khusus, ini juga karena lokal yang berbeda mungkin memiliki simbol yang berbeda pada keyboard mereka yang mungkin ingin mereka gunakan.

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

@ClasG telah menyarankan :

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

tetapi tidak menerima _ (garis bawah) sebagai karakter khusus (mis. Aa12345_).

Yang ditingkatkan adalah:

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

Demo:

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

Menguji yang ini pada tahun 2020:

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

Verifikasikan diri Anda

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

Gunakan Regex berikut untuk memenuhi ketentuan di bawah ini:

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

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

Dapat Menguji Online: https://regex101.com

Hanya kita bisa melakukan ini dengan menggunakan HTML5.

Gunakan kode di bawah ini dalam atribut pattern,

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

Ini akan bekerja dengan sempurna.

Anda dapat menggunakan pola ekspresi reguler di bawah ini untuk memeriksa kata sandi apakah sesuai dengan harapan Anda atau tidak.

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

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

Tautan cek online https://regex101.com/r/mqGurh/1

Gunakan ini,

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

Ini akan memvalidasi untuk setidaknya satu huruf kecil, satu huruf besar, satu angka dan karakter khusus dari (!, @, #, $,%,?, =, *, &).

Panjang minimum adalah 8 dan panjang maksimum adalah 20

Di Java / Android, untuk menguji kata sandi dengan setidaknya satu angka, satu huruf, satu karakter khusus dalam pola berikut:

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

Coba ini:

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

Ungkapan reguler ini cocok untuk saya.

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

Pola untuk mencocokkan setidaknya 1 karakter huruf besar, 1 digit dan karakter khusus apa saja dan panjang antara 8 hingga 63.

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

Pola ini digunakan untuk pemrograman JAVA.

Semoga berhasil di bawah ini. Saya mencoba ini dalam kebijakan khusus Azure.

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

Saya sebenarnya baru saja menyalin jawaban pertama di sini dan mengubahnya menjadi regex lebih nyaman yang membutuhkan satu atas, satu lebih rendah dan setidaknya 8 karakter tetapi menerima semuanya "di antara".

Ini adalah contoh-regex yang membutuhkan

1. setidaknya 8 karakter
2. setidaknya satu huruf kecil
3. setidaknya satu huruf besar

PENTING : Regex ini juga akan mengecualikan semua karakter lain mis. Angka, karakter khusus seperti $, # ,! dll - selama aturan 1. hingga 3. cocok dengan string input

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

Pikirkan "." bahkan pada akhir regex. Ini akan cocok dengan hampir semua (dan afaik setiap karakter yang dapat dibaca)

Jika Anda ingin menggunakan ekspresi reguler untuk memeriksa minimum delapan karakter, setidaknya satu huruf besar, setidaknya satu huruf kecil, setidaknya satu angka dari 0 hingga 9, dan setidaknya satu karakter khusus dari:! @ # $% ^ & * _? DAN juga memberi pengguna sedikit informasi lebih lanjut tentang apa yang tidak ada dalam kata sandi, Anda dapat menggunakan kode berikut:

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
}

Solusi yang saya temukan di salah satu jawaban sebelumnya sebagai:

* Minimal 8 karakter setidaknya 1 Huruf Besar, 1 Huruf Kecil, 1 Angka dan 1 Karakter Khusus:

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

... tidak berfungsi untuk saya, tetapi yang berikut ini adalah versi yang disederhanakan dan berfungsi dengan baik (tambahkan karakter khusus yang Anda suka, saya tambahkan # di sini), dan tambahkan aturan angka seperti yang Anda lakukan dengan huruf-huruf sebagai:

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