කට්ටලයෙන් අහඹු ලෙස තෝරාගත් අක්ෂර 5 කින් යුත් අක්ෂර මාලාවක් මට අවශ්‍යය [a-zA-Z0-9].

ජාවාස්ක්‍රිප්ට් සමඟ මෙය කිරීමට හොඳම ක්‍රමය කුමක්ද?

මෙය ඔබට ප්‍රයෝජනවත් වනු ඇතැයි මම සිතමි:

function makeid(length) {
   var result           = '';
   var characters       = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
   var charactersLength = characters.length;
   for ( var i = 0; i < length; i++ ) {
      result += characters.charAt(Math.floor(Math.random() * charactersLength));
   }
   return result;
}

console.log(makeid(5));

let r = Math.random().toString(36).substring(7);
console.log("random", r);

සටහන: ඉහත ඇල්ගොරිතමයට පහත සඳහන් දුර්වලතා ඇත:

• පාවෙන ස්ථාන තද කරන විට පසුපස ශුන්‍ය ඉවත් වන නිසා එය අක්ෂර 0 ත් 6 ත් අතර ඕනෑම තැනක ජනනය වේ.
• එය බිහිසුණු ලෙස සංකීර්ණ වන පාවෙන ලක්ෂ්‍ය සංඛ්‍යා දැඩි කිරීමට භාවිතා කරන ඇල්ගොරිතම මත ගැඹුරින් රඳා පවතී. ( "පාවෙන ස්ථාන අංක නිවැරදිව මුද්‍රණය කරන්නේ කෙසේද" යන ලිපිය බලන්න .)
• Math.random()ක්‍රියාත්මක කිරීම මත පදනම්ව පුරෝකථනය කළ හැකි ("අහඹු පෙනුමක්" නමුත් ඇත්ත වශයෙන්ම අහඹු නොවේ) ප්‍රතිදානය නිපදවිය හැකිය. ඔබට අද්විතීයභාවය හෝ අනපේක්ෂිත බව සහතික කිරීමට අවශ්‍ය වූ විට ලැබෙන නූල සුදුසු නොවේ.
• එය ඒකාකාර අහඹු, අනපේක්ෂිත අක්ෂර 6 ක් නිෂ්පාදනය කළද, උපන් දින විරුද්ධාභාෂය හේතුවෙන් ඔබට නූල් 50,000 ක් පමණ උත්පාදනය කිරීමෙන් පසු අනුපිටපතක් දැකීමට අපේක්ෂා කළ හැකිය . (වර්ග (36 ^ 6) = 46656)

Math.random මේ වගේ දෙයකට නරකයි

විකල්ප 1

ඔබට මෙම සේවාදායකය පැත්තෙන් කළ හැකි නම්, ක්‍රිප්ටෝ මොඩියුලය භාවිතා කරන්න -

var crypto = require("crypto");
var id = crypto.randomBytes(20).toString('hex');

// "bb5dc8842ca31d4603d6aa11448d1654"

එහි ප්‍රති string ලයක් ලෙස ඔබ ජනනය කරන අහඹු බයිට් මෙන් දෙගුණයක් දිගු වේ; හෙක්ස් වෙත කේතනය කර ඇති සෑම බයිටයක්ම අක්ෂර 2 කි. බයිට් 20 ක් හෙක්ස් අක්ෂර 40 ක් වනු ඇත.

විකල්ප 2

ඔබට මෙම සේවාදායකයා පැත්තෙන් කළ යුතු නම්, සමහර විට uuid මොඩියුලය උත්සාහ කරන්න -

var uuid = require("uuid");
var id = uuid.v4();

// "110ec58a-a0f2-4ac4-8393-c866d813b8d1"

විකල්ප 3

ඔබට මෙම සේවාදායකයා පැත්තෙන් කළ යුතු අතර ඔබට පැරණි බ්‍රව්සර් සඳහා සහය දැක්විය යුතු නොවේ නම්, පරායත්තතාවයකින් තොරව ඔබට එය කළ හැකිය -

// dec2hex :: Integer -> String
// i.e. 0-255 -> '00'-'ff'
function dec2hex (dec) {
  return dec < 10
    ? '0' + String(dec)
    : dec.toString(16)
}

// generateId :: Integer -> String
function generateId (len) {
  var arr = new Uint8Array((len || 40) / 2)
  window.crypto.getRandomValues(arr)
  return Array.from(arr, dec2hex).join('')
}

console.log(generateId())
// "82defcf324571e70b0521d79cce2bf3fffccd69"

console.log(generateId(20))
// "c1a050a4cd1556948d41"

වැඩි විස්තර සඳහා crypto.getRandomValues-

crypto.getRandomValues()ගුප්ත විද්‍යාත්මකව ශක්තිමත් අහඹු අගයන් ලබා ගැනීමට මෙම ක්‍රමය ඔබට ඉඩ සලසයි. පරාමිතිය ලෙස ලබා දී ඇති අරාව අහඹු සංඛ්‍යා වලින් පිරී ඇත (අහඹු ලෙස එහි ගුප්ත ලේඛන අර්ථයෙන්).

මෙන්න කුඩා කොන්සෝල උදාහරණයක් -

> var arr = new Uint8Array(4) # make array of 4 bytes (values 0-255)
> arr
Uint8Array(4) [ 0, 0, 0, 0 ]

> window.crypto
Crypto { subtle: SubtleCrypto }

> window.crypto.getRandomValues()
TypeError: Crypto.getRandomValues requires at least 1 argument, but only 0 were passed

> window.crypto.getRandomValues(arr)
Uint8Array(4) [ 235, 229, 94, 228 ]

IE11 සහාය සඳහා ඔබට භාවිතා කළ හැකිය -

(window.crypto || window.msCrypto).getRandomValues(arr)

බ්‍රව්සර් ආවරණය සඳහා https://caniuse.com/#feat=getrandomvalues බලන්න

කෙටි, පහසු සහ විශ්වසනීය

මෙහි ඇති ඉහළම ශ්‍රේණිගත කළ පිළිතුරු වලට සාපේක්ෂව හරියටම අහඹු අක්ෂර 5 ක් ලබා දෙයි.

Math.random().toString(36).substr(2, 5);

මෙන්න ඩබල් ටැප් හි විශිෂ්ට පිළිතුරේ වැඩි දියුණු කිරීමක් . මුල් පිටපතෙහි අඩුපාඩු දෙකක් ඇත.

පළමුව, අනෙක් අය සඳහන් කර ඇති පරිදි, එයට කෙටි නූල් හෝ හිස් නූලක් නිපදවීමේ කුඩා සම්භාවිතාවක් ඇත (අහඹු අංකය 0 නම්), එමඟින් ඔබේ යෙදුම බිඳ දැමිය හැකිය. මෙන්න විසඳුමක්:

(Math.random().toString(36)+'00000000000000000').slice(2, N+2)

දෙවනුව, මුල් සහ විසඳුම යන දෙකම නූල් ප්‍රමාණය N අක්ෂර 16 කට සීමා කරයි. පහත දැක්වෙන්නේ ඕනෑම N සඳහා N ප්‍රමාණයේ නූලක් යවයි (නමුත් N> 16 භාවිතා කිරීමෙන් අහඹු බව වැඩි නොවන අතර isions ට්ටනවල සම්භාවිතාව අඩු නොවන බව සලකන්න):

Array(N+1).join((Math.random().toString(36)+'00000000000000000').slice(2, 18)).slice(0, N)

පැහැදිලි කිරීම:

1. [0,1) පරාසයේ අහඹු අංකයක් තෝරන්න, එනම් 0 (ඇතුළත්) සහ 1 (විශේෂිත) අතර.
2. අංකය පදනම් -36 නූල් බවට පරිවර්තනය කරන්න, එනම් 0-9 සහ az අක්ෂර භාවිතා කිරීම.
3. ශුන්‍ය සමග පෑඩ් (පළමු ගැටළුව විසඳයි).
4. ප්‍රමුඛ '0' කපා දමන්න උපසර්ගය සහ අමතර පෑඩින් ශුන්‍ය.
5. අවම වශයෙන් N අක්ෂර වත් තිබීම සඳහා ප්‍රමාණවත් වාරයක් නැවත නැවත කරන්න (පරිසීමකය ලෙස භාවිතා කරන කෙටි අහඹු නූල් සමඟ හිස් නූල් සමඟ සම්බන්ධ වීමෙන්).
6. නූලෙන් හරියටම N අක්ෂර කපා දමන්න.

වැඩිදුර අදහස්:

• මෙම විසඳුම ලොකු අකුරු භාවිතා නොකරයි, නමුත් සෑම අවස්ථාවකම පාහේ (කිසිදු ද pun ුවමක් අපේක්ෂා නොකරයි) එය වැදගත් නොවේ.
• මුල් පිළිතුරේ N = 16 හි උපරිම නූල් දිග මනිනු ලබන්නේ Chrome හි ය. ෆයර්ෆොක්ස් හි එය එන් = 11. නමුත් පැහැදිලි කළ පරිදි, දෙවන විසඳුම වන්නේ ඉල්ලූ ඕනෑම නූල් දිගකට සහය දැක්වීම මිස අහඹු ලෙස එකතු කිරීම ගැන නොවේ, එබැවින් එය වැඩි වෙනසක් නොකරයි.
• Math.random () විසින් ලබා දුන් ප්‍රති results ල ඒකාකාරව බෙදා හරින තාක් දුරට, ආපසු ලබා දුන් සියලුම නූල් වලට සමාන සම්භාවිතාවක් ඇත (මෙය ගුප්ත ලේඛන ශක්තිය අහඹු ලෙස නොවේ, කෙසේ වෙතත්).
• N ප්‍රමාණයේ හැකි සියලුම නූල් ආපසු ලබා දිය නොහැක. දෙවන විසඳුමේදී මෙය පැහැදිලිය (කුඩා නූල හුදෙක් අනුපිටපත් කර ඇති බැවින්), නමුත් මුල් පිළිතුරේ දී මෙය සත්‍ය වන්නේ පදනම් -36 බවට පරිවර්තනය කිරීමේදී අවසාන බිටු කිහිපය මුල් අහඹු බිටු වල කොටසක් නොවිය හැකි බැවිනි. Math.random () toString (36) හි ප්‍රති result ලය දෙස බැලුවහොත්, අවසාන අක්‍ෂරය ඒකාකාරව බෙදා හරිනු නොලැබේ. නැවතත්, සෑම අවස්ථාවකම පාහේ එය වැදගත් නොවේ, නමුත් අපි කෙටි නූල් (උදා: N = 1) බලපෑමට ලක් නොවන පරිදි අහඹු නූලක අවසානයට වඩා ආරම්භයේ සිට අවසාන නූල කපා දමමු.

යාවත්කාලීන කිරීම:

මෙන්න මම ඉදිරිපත් කළ තවත් ක්‍රියාකාරී විලාසිතාවේ එක්-ලයිනර් කිහිපයක්. ඉහත විසඳුමට වඩා ඒවා වෙනස් ය:

• ඔවුන් පැහැදිලි අත්තනෝමතික හෝඩියක් භාවිතා කරයි (වඩා සාමාන්‍ය, සහ ලොකු අකුරු සහ කුඩා අකුරු යන දෙකම ඇසූ මුල් ප්‍රශ්නයට සුදුසු ය).
• N හි සියලුම නූල් නැවත ලබා දීමට සමාන සම්භාවිතාවක් ඇත (එනම් නූල්වල පුනරාවර්තන නොමැත).
• ඒවා පදනම් වී ඇත්තේ toString (36) උපක්‍රමයට වඩා සිතියම් ශ්‍රිතයක් මත වන අතර එමඟින් ඒවා වඩාත් සරල හා තේරුම් ගැනීමට පහසු වේ.

එබැවින්, ඔබේ තේරීමේ හෝඩිය යැයි කියන්න

var s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

එවිට මේ දෙක එකිනෙකට සමාන වේ, එබැවින් ඔබට වඩා බුද්ධිමත් දේ තෝරා ගත හැකිය:

Array(N).join().split(',').map(function() { return s.charAt(Math.floor(Math.random() * s.length)); }).join('');

සහ

Array.apply(null, Array(N)).map(function() { return s.charAt(Math.floor(Math.random() * s.length)); }).join('');

සංස්කරණය කරන්න:

මට පෙනෙන්නේ ක්විබයිට් සහ මාටිජ්න් ඩි මිලියනෝ දෙවැන්න (කුඩෝස්!) හා සමාන විසඳුම් ඉදිරිපත් කළ අතර එය කෙසේ හෝ මග හැරුණි. ඔවුන් බැලූ බැල්මට කෙටියෙන් නොපෙනෙන හෙයින්, යමෙකුට එක ලයිනර් එකක් අවශ්‍ය නම් මම කෙසේ හෝ මෙහි තබමි :-)

එසේම, තවත් බයිට් කිහිපයක් රැවුල බෑම සඳහා සියලු විසඳුම්වල 'නව අරාව' වෙනුවට 'අරාව' ආදේශ කරන්න.

වඩාත්ම සංයුක්ත විසඳුම, sliceවඩා කෙටි නිසා substring. නූල් කෙළවරේ සිට අඩු කිරීමෙන් randomශ්‍රිතය මඟින් ජනනය වන පාවෙන ලක්ෂ්‍ය සංකේතය වළක්වා ගත හැකිය :

Math.random().toString(36).slice(-5);

හෝ පවා

(+new Date).toString(36).slice(-5);

යාවත්කාලීන කිරීම:btoa ක්‍රමය භාවිතා කරමින් තවත් එක් ප්‍රවේශයක් එක් කරන ලදි :

btoa(Math.random()).slice(0, 5);
btoa(+new Date).slice(-7, -2);
btoa(+new Date).substr(-7, 5);

// Using Math.random and Base 36:
console.log(Math.random().toString(36).slice(-5));

// Using new Date and Base 36:
console.log((+new Date).toString(36).slice(-5));

// Using Math.random and Base 64 (btoa):
console.log(btoa(Math.random()).slice(0, 5));

// Using new Date and Base 64 (btoa):
console.log(btoa(+new Date).slice(-7, -2));
console.log(btoa(+new Date).substr(-7, 5));

මේ වගේ දෙයක් වැඩ කළ යුතුයි

function randomString(len, charSet) {
    charSet = charSet || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    var randomString = '';
    for (var i = 0; i < len; i++) {
        var randomPoz = Math.floor(Math.random() * charSet.length);
        randomString += charSet.substring(randomPoz,randomPoz+1);
    }
    return randomString;
}

පෙරනිමි අක්ෂර කට්ටලය සමඟ අමතන්න [a-zA-Z0-9] හෝ ඔබේම දෑ වලින් යවන්න:

var randomValue = randomString(5);

var randomValue = randomString(5, 'PICKCHARSFROMTHISSET');

Es6 පැතිරුම් ක්‍රියාකරු සමඟ නවතම අනුවාදය :

[...Array(30)].map(() => Math.random().toString(36)[2]).join('')

• මෙම 30අත්තනෝමතික අංකය, ඔබට අවශ්ය ඕනෑම සංකේත දිග ලබා ගත හැක
• මෙම 36ඔබ උරුම විය හැකි උපරිම radix අංකය numeric.toString () , ඉන් අදහස් වන්නේ, සියලු අංක සහ az සිම්පල් අකුරු
• මෙම 2වන 3th දර්ශකය මේ වගේ වන අහඹු string සිට රැගෙන කිරීම සඳහා භාවිතා වේ: "0.mfbiohx64i"අපි පසු ඕනෑම දර්ශකය ගත විය හැකි0.

සසම්භාවී නූල් උත්පාදක යන්ත්රය (ඇල්ෆා-සංඛ්යා | ඇල්ෆා | සංඛ්යාත්මක)

/**
 * Pseudo-random string generator
 * http://stackoverflow.com/a/27872144/383904
 * Default: return a random alpha-numeric string
 * 
 * @param {Integer} len Desired length
 * @param {String} an Optional (alphanumeric), "a" (alpha), "n" (numeric)
 * @return {String}
 */
function randomString(len, an) {
  an = an && an.toLowerCase();
  var str = "",
    i = 0,
    min = an == "a" ? 10 : 0,
    max = an == "n" ? 10 : 62;
  for (; i++ < len;) {
    var r = Math.random() * (max - min) + min << 0;
    str += String.fromCharCode(r += r > 9 ? r < 36 ? 55 : 61 : 48);
  }
  return str;
}

console.log(randomString(10));      // i.e: "4Z8iNQag9v"
console.log(randomString(10, "a")); // i.e: "aUkZuHNcWw"
console.log(randomString(10, "n")); // i.e: "9055739230"

ඉහත දැක්වෙන්නේ අපේක්ෂිත දේ සඳහා අතිරේක චෙක්පත් භාවිතා කරන අතර A / N, A, N ප්‍රතිදානය කරන අතර, වඩා හොඳ අවබෝධයක් සඳහා එය අත්‍යවශ්‍ය දෑ (ඇල්ෆා-සංඛ්‍යාත්මකව පමණි) බිඳ දමමු:

• තර්කයක් පිළිගන්නා ශ්‍රිතයක් සාදන්න (අහඹු සංගීත ප්‍රති result ලයේ අපේක්ෂිත දිග)
• වැනි හිස් නූලක් සාදන්න var str = "";අහඹු අක්ෂර සංයුක්ත කිරීමට
• ලූපයක් තුළ සිට දර්ශක අංකයක් සාදන්නrand 0 සිට 61 (0..9 + A..Z + a..z = 62)
• නිර්මාණය කරන්න , කොන්දේසි තර්ක කිරීමට / විසඳුමක් ගැළපුම්randනිවැරදි CharCodeඅංකය සහ අදාළ අක්‍ෂරය නැවත ලබා ගැනීම සඳහා එය (එය 0..61 බැවින්) එය යම් සංඛ්‍යාවකින් වැඩි කිරීම (පහත උදාහරණ බලන්න) .
• ලූපය තුළට සමපාත වේ str aString.fromCharCode( incremented rand )

ASCII අක්‍ෂර වගු පරාසය පින්තාරු කරමු :

_____0....9______A..........Z______a..........z___________  Character
     | 10 |      |    26    |      |    26    |             Tot = 62 characters
    48....57    65..........90    97..........122           CharCode ranges

Math.floor( Math.random * 62 )0..61(අපට අවශ්‍ය දේ) සිට පරාසයක් ලබා දෙයි .
නිවැරදි වර්‍ග කේත පරාසයන් ලබා ගැනීම සඳහා අහඹු ලෙස සකස් කරමු :

      |   rand   | charCode |  (0..61)rand += fix            = charCode ranges |
------+----------+----------+--------------------------------+-----------------+
0..9  |   0..9   |  48..57  |  rand += 48                    =     48..57      |
A..Z  |  10..35  |  65..90  |  rand += 55 /*  90-35 = 55 */  =     65..90      |
a..z  |  36..61  |  97..122 |  rand += 61 /* 122-61 = 61 */  =     97..122     |

මෙම කොන්දේසි ක්රියාත්මක තර්ක ඉහත වගුවේ සිට:

   rand += rand>9 ? ( rand<36 ? 55 : 61 ) : 48 ;
// rand +=  true  ? (  true   ? 55 else 61 ) else 48 ;

ඉහත පැහැදිලි කිරීමෙන්, මෙහි ප්‍රති ing ලයක් ලෙස ඇල්ෆා සංඛ්‍යාත්මක ස්නිපටය :

function randomString(len) {
  var str = "";                                // String result
  for (var i = 0; i < len; i++) {              // Loop `len` times
    var rand = Math.floor(Math.random() * 62); // random: 0..61
    var charCode = rand += rand > 9 ? (rand < 36 ? 55 : 61) : 48; // Get correct charCode
    str += String.fromCharCode(charCode);      // add Character to str
  }
  return str; // After all loops are done, return the concatenated string
}

console.log(randomString(10)); // i.e: "7GL9F0ne6t"

නැතහොත් ඔබට අවශ්‍ය නම්:

const randomString = (n, r='') => {
  while (n--) r += String.fromCharCode((r=Math.random()*62|0, r+=r>9?(r<36?55:61):48));
  return r;
};

console.log(randomString(10))

සරලම ක්‍රමය නම්:

(new Date%9e6).toString(36)

මෙය වත්මන් කාලය මත පදනම්ව අක්ෂර 5 ක අහඹු නූල් ජනනය කරයි. නිදර්ශන ප්‍රතිදානය 4mtxjහෝ 4mv90හෝ4mwp1

මෙහි ඇති ගැටළුව නම්, ඔබ එය එකම තත්පරයකට දෙවරක් අමතන්නේ නම්, එය එකම නූලක් ජනනය කරනු ඇත.

ආරක්ෂිත ක්‍රමය නම්:

(0|Math.random()*9e6).toString(36)

මෙය අහඹු ලෙස අක්ෂර 4 ක් හෝ 5 ක් උත්පාදනය කරනු ඇත, සෑම විටම වෙනස් වේ. නිදර්ශන ප්‍රතිදානය සමාන 30jzmහෝ 1r591හෝ4su1a

දෙයාකාරයෙන්ම පළමු කොටස අහඹු සංඛ්‍යාවක් ජනනය කරයි. මෙම .toString(36)කොටස එය ක base36 (alphadecimal) නියෝජන කිරීමට සංඛ්යාව දමති.

මෙන්න පහසු එක් ලයිනර් කිහිපයක්. වෙනස් කරන්නnew Array(5)දිග සැකසීමට .

ඇතුළුව 0-9a-z

new Array(5).join().replace(/(.|$)/g, function(){return ((Math.random()*36)|0).toString(36);})

ඇතුළුව 0-9a-zA-Z

new Array(5).join().replace(/(.|$)/g, function(){return ((Math.random()*36)|0).toString(36)[Math.random()<.5?"toString":"toUpperCase"]();});

සෑම කෙනෙකුම දැනටමත් එය නිවැරදිව ලබාගෙන ඇති බව මම දනිමි, නමුත් මට හැඟී ගියේ හැකි තරම් සැහැල්ලු ආකාරයකින් මෙය කළ හැකි බවයි (කේතයේ ආලෝකය, CPU නොවේ):

function rand(length, current) {
  current = current ? current : '';
  return length ? rand(--length, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz".charAt(Math.floor(Math.random() * 60)) + current) : current;
}

console.log(rand(5));

ඔබේ හිස එතීමට මඳ වේලාවක් ගත වේ, නමුත් මම සිතන්නේ එය සැබවින්ම ජාවාස්ක්‍රිප්ට් හි වාක්‍ය ඛණ්ඩය කෙතරම් විශිෂ්ටද යන්න පෙන්නුම් කරයි.

ඔබ භාවිතා කරන්නේ නම් Lodash හෝ Underscore , එය ඉතා සරළ:

var randomVal = _.sample('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', 5).join('');

අවශ්‍යතාවය සපුරාලීම සඳහා [a-zA-Z0-9] සහ දිග = 5 භාවිතය

btoa(Math.random()).substr(5, 5);

කුඩා අකුරු, ලොකු අකුරු සහ අංක සිදුවනු ඇත.

මතකය එකවර වෙන් කරන එක් ලයිනර් එකක් (ඔබේ පහසුව සඳහා ආකෘතිකරණය කර නොතිබුණද) යමෙකු උනන්දු වන්නේ නම් (නමුත් කුඩා නූල් සඳහා එය ඇත්ත වශයෙන්ම වැදගත් නොවන බව සලකන්න) මෙහි එය කරන්නේ කෙසේද:

Array.apply(0, Array(5)).map(function() {
    return (function(charset){
        return charset.charAt(Math.floor(Math.random() * charset.length))
    }('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'));
}).join('')

ඔබට අවශ්‍ය නූලෙහි 5දිග අනුව ප්‍රතිස්ථාපනය කළ හැකිය . විසින් නිර්මාණය කරන ලද විරල අරාව මත ක්‍රියා නොකිරීමේ ශ්‍රිතයට විසඳුම ලබා දීම සඳහා මෙම ලිපියේ riAriyaHidayat ට ස්තූතියි .mapArray(5)

මෙන්න මම නිර්මාණය කළ ක්රමය.
එය ලොකු අකුරු සහ කුඩා අකුරු අඩංගු නූලක් නිර්මාණය කරයි.
ඊට අමතරව මම අක්ෂරාංක නූලක් නිර්මාණය කරන ශ්‍රිතයද ඇතුළත් කර ඇත්තෙමි.

වැඩ කරන උදාහරණ:
http://jsfiddle.net/greatbigmassive/vhsxs/ (ඇල්ෆා පමණි)
http://jsfiddle.net/greatbigmassive/PJwg8/ (අක්ෂරාංක)

function randString(x){
    var s = "";
    while(s.length<x&&x>0){
        var r = Math.random();
        s+= String.fromCharCode(Math.floor(r*26) + (r>0.5?97:65));
    }
    return s;
}

උත්ශ්‍රේණි කිරීම ජූලි 2015
මෙය එකම දේ කරන නමුත් වඩා අර්ථවත් වන අතර සියලු අක්ෂර ඇතුළත් වේ.

var s = "";
while(s.length<x&&x>0){
    v = Math.random()<0.5?32:0;
    s += String.fromCharCode(Math.round(Math.random()*((122-v)-(97-v))+(97-v)));
}

ඔබ යටි ඉරි ලකුණු භාවිතා කරයි යැයි උපකල්පනය කිරීමෙන් පේළි දෙකකින් අහඹු ලෙස නූල් උත්පාදනය කළ හැකිය:

var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
var random = _.sample(possible, 5).join('');

const c = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
const s = [...Array(5)].map(_ => c[~~(Math.random()*c.length)]).join('')

වේගවත් හා වැඩිදියුණු කළ ඇල්ගොරිතම. නිල ඇඳුම සහතික නොකරයි (අදහස් බලන්න).

function getRandomId(length) {
    if (!length) {
        return '';
    }

    const possible =
        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    let array;

    if ('Uint8Array' in self && 'crypto' in self && length <= 65536) {
        array = new Uint8Array(length);
        self.crypto.getRandomValues(array);
    } else {
        array = new Array(length);

        for (let i = 0; i < length; i++) {
            array[i] = Math.floor(Math.random() * 62);
        }
    }

    let result = '';

    for (let i = 0; i < length; i++) {
        result += possible.charAt(array[i] % 62);
    }

    return result;
}

එක් ලයිනර්:

Array(15).fill(null).map(() => Math.random().toString(36).substr(2)).join('')
// Outputs: 0h61cbpw96y83qtnunwme5lxk1i70a6o5r5lckfcyh1dl9fffydcfxddd69ada9tu9jvqdx864xj1ul3wtfztmh2oz2vs3mv6ej0fe58ho1cftkjcuyl2lfkmxlwua83ibotxqc4guyuvrvtf60naob26t6swzpil

"මට අහඹු නූල් අවශ්‍යයි" ප්‍රශ්න වලට ප්‍රතිචාර දැක්වීමේ ගැටළුව (ඕනෑම භාෂාවකින්) ප්‍රායෝගිකව සෑම විසඳුමක්ම නූල් දිගෙහි දෝෂ සහිත ප්‍රාථමික පිරිවිතරයක් භාවිතා කරයි . අහඹු නූල් අවශ්‍ය වන්නේ මන්දැයි ප්‍රශ්න විසින්ම හෙළි කරන්නේ කලාතුරකිනි, නමුත් මම ඔබට අභියෝග කරන්නේ කලාතුරකින් අහඹු ලෙස දිග අවශ්‍ය වන බව පවසන්න. 8 ඔබට නොකඩවා අවශ්‍ය වන්නේ අද්විතීය නූල් කිහිපයක් , උදාහරණයක් ලෙස, සමහර සඳහා හඳුන්වන ලෙස භාවිතා කිරීමට.

තදින් අද්විතීය නූල් ලබා ගැනීම සඳහා ප්‍රමුඛ ක්‍රම දෙකක් තිබේ : නිර්ණායක වශයෙන් (එය අහඹු නොවේ) සහ ගබඩා කිරීම / සංසන්දනය කිරීම (එය බරයි). අපි මොකද කරන්නේ? අපි අවතාරය අත්හරින්නෙමු. අපි ඒ වෙනුවට සම්භාවිතා සුවිශේෂත්වය සමඟ යමු . එනම්, අපගේ නූල් අද්විතීය නොවන බවට යම් (කෙසේ වෙතත් කුඩා) අවදානමක් ඇති බව අපි පිළිගනිමු. Ision ට්ටන සම්භාවිතාව සහ එන්ට්‍රොපිය අවබෝධ කර ගැනීම මෙහිදීය ප්‍රයෝජනවත් .

එබැවින් නැවත නැවත කිරීමේ කුඩා අවදානමක් ඇති නූල් කිහිපයක් අවශ්‍ය බැවින් වෙනස් කළ නොහැකි අවශ්‍යතාව මම නැවත ලියමි. සංයුක්ත උදාහරණයක් ලෙස, ඔබට හැඳුනුම්පත් මිලියන 5 ක විභවයක් ජනනය කිරීමට අවශ්‍ය යැයි කියමු. සෑම නව නූලක්ම ගබඩා කර සංසන්දනය කිරීමට ඔබට අවශ්‍ය නැති අතර ඒවා අහඹු ලෙස වීමට ඔබට අවශ්‍යය, එබැවින් ඔබ නැවත නැවත වීමේ අවදානමක් පිළිගනී. උදාහරණයක් ලෙස, නැවත කියවීමේ අවස්ථාව ට්‍රිලියන 1 ට 1 ට වඩා අඩු අවදානමක් යැයි කියමු. ඉතින් ඔබට අවශ්‍ය නූල් දිග කුමක්ද? හොඳයි, එම ප්‍රශ්නය අවතක්සේරු කර ඇත්තේ එය භාවිතා කරන අක්ෂර මත රඳා පවතින බැවිනි. නමුත් වඩා වැදගත් දෙය නම් එය නොමඟ යවන සුළුය. ඔබට අවශ්‍ය වන්නේ නූල් වල එන්ට්‍රොපියෙහි පිරිවිතරයක් මිස ඒවායේ දිග නොවේ. එන්ට්‍රොපිය කෙඳි ගණනාවක පුනරාවර්තනයේ සම්භාවිතාව සමඟ කෙලින්ම සම්බන්ධ විය හැකිය. නූල් දිගට බැහැ.

එන්ට්‍රොපි ස්ට්‍රිං වැනි පුස්තකාලයකට උදව් කළ හැකි ස්ථානය මෙයයි. ට්‍රිලියන 1 ට වඩා අඩු අහඹු හැඳුනුම්පත් උත්පාදනය කිරීම සඳහා නූල් මිලියන 5 කින් පුනරාවර්තනය වීමට entropy-string:

import {Random, Entropy} from 'entropy-string'

const random = new Random()
const bits = Entropy.bits(5e6, 1e12)

const string = random.string(bits)

"44hTNghjNHGGRHqH9"

entropy-stringපෙරනිමියෙන් අක්ෂර 32 ක් සහිත අක්ෂර කට්ටලයක් භාවිතා කරයි. වෙනත් පූර්ව නිශ්චිත අක්ෂර කට්ටල ඇත, ඔබට ඔබේම අක්ෂරද නියම කළ හැකිය. උදාහරණයක් ලෙස, ඉහත ආකාරයටම එන්ට්‍රොපිය සමඟ හැඳුනුම්පත් උත්පාදනය කිරීම, නමුත් හෙක්ස් අක්ෂර භාවිතා කිරීම:

import {Random, Entropy, charSet16} from './entropy-string'

const random = new Random(charSet16)
const bits = Entropy.bits(5e6, 1e12)

const string = random.string(bits)

"27b33372ade513715481f"

භාවිතා කරන ලද අක්ෂර කට්ටලයේ මුළු අක්ෂර ගණනෙහි වෙනස හේතුවෙන් නූල් දිගෙහි වෙනස සැලකිල්ලට ගන්න. නිශ්චිත විභව නූල් ගණන පුනරාවර්තනය වීමේ අවදානම සමාන වේ. නූල් දිග නොවේ. සියල්ලටම වඩා, පුනරාවර්තනයේ අවදානම සහ විභව නූල් ගණන පැහැදිලිය. නූල් දිග සමඟ තවත් අනුමාන කිරීමක් නැත.

function randomString (strLength, charSet) {
    var result = [];

    strLength = strLength || 5;
    charSet = charSet || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

    while (--strLength) {
        result.push(charSet.charAt(Math.floor(Math.random() * charSet.length)));
    }

    return result.join('');
}

මෙය ලැබෙන තරමටම පිරිසිදුයි. එය ද වේගවත් ය, http://jsperf.com/ay-random-string .

ඔබට අයිතම රාශියක් හරහා ලූප් කර ඒවා විචල්‍ය විචල්‍යයකට පුනරාවර්තනය කළ හැකිය, උදාහරණයක් ලෙස ඔබට අහඹු ඩීඑන්ඒ අනුක්‍රමයක් අවශ්‍ය නම්:

function randomDNA(len) {
  len = len || 100
  var nuc = new Array("A", "T", "C", "G")
  var i = 0
  var n = 0
  s = ''
  while (i <= len - 1) {
    n = Math.floor(Math.random() * 4)
    s += nuc[n]
    i++
  }
  return s
}

console.log(randomDNA(5));

මේ වගේ දෙයක් ගැන කොහොමද: Date.now().toString(36) අහඹු ලෙස නොවේ, නමුත් ඔබ එය අමතන සෑම අවස්ථාවකම කෙටි හා සුවිශේෂී වේ.

කුඩා අකුරු සහ ලොකු අකුරු සඳහා සහය දැක්වීම සඳහා පිරිසිදු විසඳුමක් මට හමු නොවීය.

සිම්පල් පමණක් සහාය:

Math.random().toString(36).substr(2, 5)

සිම්පල් සහ ලොකු අකුරු සඳහා ආධාර කිරීම සඳහා එම විසඳුම මත ගොඩනැගීම:

Math.random().toString(36).substr(2, 5).split('').map(c => Math.random() < 0.5 ? c.toUpperCase() : c).join('');

ඔබට අවශ්‍ය දිගට හැඩගැසීමට 5in වෙනස් කරන්න substr(2, 5).

මෙය නිසැකවම ක්රියා කරයි

<script language="javascript" type="text/javascript">
function randomString() {
 var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
 var string_length = 8;
 var randomstring = '';
 for (var i=0; i<string_length; i++) {
  var rnum = Math.floor(Math.random() * chars.length);
  randomstring += chars.substring(rnum,rnum+1);
 }
 document.randform.randomfield.value = randomstring;
}
</script>

මෙම සංයුක්ත කුඩා උපක්‍රමය ගැන කුමක් කිව හැකිද?

var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
var stringLength = 5;

function pickRandom() {
    return possible[Math.floor(Math.random() * possible.length)];
}

var randomString = Array.apply(null, Array(stringLength)).map(pickRandom).join('');

Array.applyහිස් අරාව නිර්වචනය නොකළ පෙළක් බවට පත් කිරීමට ඔබට එහි අවශ්‍ය වේ.

ඔබ ES2015 සඳහා කේත කරන්නේ නම්, අරාව තැනීම ටිකක් සරල ය:

var randomString = Array.from({ length: stringLength }, pickRandom).join('');

සිද්ධි සංවේදී අක්ෂරාංක අක්ෂර:

function randStr(len) {
  let s = '';
  while (s.length < len) s += Math.random().toString(36).substr(2, len - s.length);
  return s;
}

// usage
console.log(randStr(50));

මෙම ශ්‍රිතයේ වාසිය නම් ඔබට විවිධ දිග අහඹු නූල් ලබා ගත හැකි අතර එය නූල් වල දිග සහතික කරයි.

සිද්ධි සංවේදී සියලු අක්ෂර:

function randStr(len) {
  let s = '';
  while (len--) s += String.fromCodePoint(Math.floor(Math.random() * (126 - 33) + 33));
  return s;
}

// usage
console.log(randStr(50));

අභිරුචි අක්ෂර

function randStr(len, chars='abc123') {
  let s = '';
  while (len--) s += chars[Math.floor(Math.random() * chars.length)];
  return s;
}

// usage
console.log(randStr(50));
console.log(randStr(50, 'abc'));
console.log(randStr(50, 'aab')); // more a than b

මෙන්න මගේ ප්‍රවේශය (ටයිප්ස්ක්‍රිප්ට් සමඟ).

නවීන js සහ පිරිසිදු කේත භාවිතා කරමින් සරල විසඳුමක් මා නොදකින නිසා තවත් ප්‍රතිචාරයක් ලිවීමට මම තීරණය කර ඇත්තෙමි.

const DEFAULT_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

function getRandomCharFromAlphabet(alphabet: string): string {
  return alphabet.charAt(Math.floor(Math.random() * alphabet.length));
}

function generateId(idDesiredLength: number, alphabet = DEFAULT_ALPHABET): string {
  /**
   * Create n-long array and map it to random chars from given alphabet.
   * Then join individual chars as string
   */
  return Array.from({length: idDesiredLength}).map(() => {
    return getRandomCharFromAlphabet(alphabet);
  }).join('');
}

generateId(5); // jNVv7