Setten rastgele seçilmiş karakterlerden oluşan 5 karakterli bir dize istiyorum [a-zA-Z0-9].

Bunu JavaScript ile yapmanın en iyi yolu nedir?

Bunun sizin için çalışacağını düşünüyorum:

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

Not: Yukarıdaki algoritma aşağıdaki zayıflıklara sahiptir:

• Kayan noktaları dize ederken sondaki sıfırların kaldırılması nedeniyle 0 ila 6 karakter arasında herhangi bir yerde üretilir.
• Dehşet verici derecede karmaşık olan kayan nokta sayılarını dizmek için kullanılan algoritmaya derinden bağlıdır. (Bkz. "Kayan Nokta Sayılarını Doğru Yazdırma" .)
• Math.random()uygulamaya bağlı olarak öngörülebilir ("rastgele görünümlü" ancak gerçekten rastgele olmayan) çıktılar üretebilir. Benzersizliği veya öngörülemezliği garanti etmeniz gerektiğinde ortaya çıkan dize uygun değildir.
• Düzgün rasgele, öngörülemeyen 6 karakter üretse bile, doğum günü paradoksu nedeniyle sadece yaklaşık 50.000 dize oluşturduktan sonra bir kopya görmeyi bekleyebilirsiniz . (sqrt (36 ^ 6) = 46656)

Math.random bu tür şeyler için kötü

seçenek 1

Bu sunucu tarafı yapabiliyorsanız , kripto modülünü -

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

// "bb5dc8842ca31d4603d6aa11448d1654"

Ortaya çıkan dize, oluşturduğunuz rasgele baytların iki katı kadar uzun olacaktır; onaltılık olarak kodlanan her bayt 2 karakterdir. 20 bayt, onaltılık 40 karakter olacaktır.

seçenek 2

Bu istemciyi yapmanız gerekiyorsa , belki uuid modülünü deneyin -

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

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

Seçenek 3

Bu istemciyi yapmanız gerekiyorsa ve eski tarayıcıları desteklemeniz gerekmiyorsa, bağımlılık olmadan yapabilirsiniz -

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

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

Hakkında daha fazla bilgi için crypto.getRandomValues -

crypto.getRandomValues()Yöntem şifrelenmiş güçlü ve rasgele değerleri elde etmenizi sağlar. Parametre olarak verilen dizi rastgele sayılarla (kriptografik anlamında rastgele) doldurulur.

İşte küçük bir konsol örneği -

> 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 desteği için şunları kullanabilirsiniz -

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

Tarayıcı kapsamı için bkz. Https://caniuse.com/#feat=getrandomvalues

Kısa, kolay ve güvenilir

Burada bulunan en yüksek puanlı yanıtların aksine, tam olarak 5 rastgele karakter döndürür.

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

İşte doubletap'ın mükemmel cevabında bir gelişme . Orijinal belgenin burada ele alınan iki dezavantajı vardır:

Birincisi, diğerlerinin de belirttiği gibi, kısa dizeler veya hatta rastgele bir dizgi (rastgele sayı 0 ise) üretme olasılığı düşüktür, bu da uygulamanızı bozabilir. İşte bir çözüm:

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

İkincisi, hem orijinal hem de yukarıdaki çözüm N dizesini 16 karakterle sınırlar. Aşağıdakiler, herhangi bir N için N boyutunda bir dize döndürecektir (ancak N> 16 kullanmanın rasgeleliği artırmayacağını veya çarpışma olasılığını azaltmayacağını unutmayın):

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

Açıklama:

1. [0,1) aralığında, yani 0 (dahil) ile 1 (hariç) arasında rastgele bir sayı seçin.
2. Sayıyı base-36 dizesine dönüştürün, örneğin 0-9 ve az karakterlerini kullanarak.
3. Sıfırlarla doldurma (ilk sorunu çözer).
4. Baştaki '0'ı dilimleyin. ön ek ve ekstra dolgu sıfırları.
5. İçinde en az N karakter olacak şekilde dizeyi tekrarlayın (boş dizeleri ayırıcı olarak kullanılan daha kısa rasgele dizeyle birleştirerek).
6. Dizeden tam olarak N karakter dilimleyin.

Diğer düşünceler:

• Bu çözüm büyük harf kullanmaz, ancak hemen hemen tüm durumlarda (cezalandırma amaçlı değildir) önemli değildir.
• Orijinal yanıttaki N = 16 değerindeki maksimum dize uzunluğu Chrome'da ölçülür. Firefox'ta N = 11'dir. Ancak açıklandığı gibi, ikinci çözüm, herhangi bir dize uzunluğunu desteklemekle ilgilidir, rastgele eklemekle ilgili değildir, bu yüzden çok fazla fark yaratmaz.
• Tüm döndürülen dizeler, en azından Math.random () tarafından döndürülen sonuçların eşit olarak dağıtıldığı kadar eşit bir şekilde döndürülme olasılığına sahiptir (bu, her durumda kriptografik güç rastgele değildir).
• N boyutundaki tüm olası dizeler döndürülemez. İkinci çözümde bu açıktır (daha küçük dize basitçe kopyalandığından), ancak orijinal cevapta da bu doğrudur çünkü base-36'ya dönüşümde son birkaç bit orijinal rastgele bitlerin bir parçası olmayabilir. Özellikle, Math.random (). ToString (36) sonucuna bakarsanız, son karakterin eşit olarak dağıtılmadığını fark edeceksiniz. Yine, neredeyse tüm durumlarda önemli değil, ancak kısa dizelerin (örn. N = 1) etkilenmemesi için rastgele dizenin sonundan ziyade son dizgiyi dilimliyoruz.

Güncelleme:

İşte size geldiğim birkaç diğer fonksiyonel tarzda tek gömlek. Yukarıdaki çözümden farklıdırlar:

• Açık bir keyfi alfabe kullanırlar (daha genel ve hem büyük hem de küçük harfler için sorulan orijinal soruya uygundur).
• Tüm N uzunluk dizeleri eşit bir geri dönme olasılığına sahiptir (yani ipler tekrar içermez).
• Bunlar, toString (36) hilesi yerine bir harita işlevine dayanır, bu da onları daha basit ve anlaşılması kolay hale getirir.

Yani, seçtiğiniz alfabenin

var s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

O zaman bu ikisi birbirine eşdeğerdir, böylece hangisinin size daha sezgisel olduğunu seçebilirsiniz:

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

ve

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

Düzenle:

Qubyte ve Martijn de Milliano'ya benziyorum ben bir şekilde cevapsız ikincisi benzer (şeref!) Çözümleri, ile geldi. Bir bakışta kısa görünmedikleri için, birinin gerçekten tek astarlı olmasını istemesi durumunda yine de burada bırakacağım :-)

Ayrıca, birkaç bayt daha tıraş etmek için tüm çözümlerde 'yeni Dizi'yi' Dizi 'ile değiştirdi.

En kompakt çözüm, çünkü slicedaha kısadır substring. Dizenin sonundan çıkarma, randomişlev tarafından oluşturulan kayan nokta sembolünün önlenmesine izin verir :

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

ya da

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

Güncelleme:btoa Yöntemi kullanarak bir yaklaşım daha eklendi :

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

Böyle bir şey işe yaramalı

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

Varsayılan karakter setiyle [a-zA-Z0-9] arayın veya kendi gönderiniz:

var randomValue = randomString(5);

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

Es6 spread operatörü ile daha yeni bir sürüm :

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

• 30Keyfi sayı, istediğiniz herhangi bir belirteç uzunluğu alabilirsiniz olduğu
• 36Eğer geçirebilirsiniz en radix sayısıdır numeric.toString () anlamına gelir, tüm numaraları ve az küçük harfleri
• 2Şöyle rastgele dizesinden 3th indeksi almak için kullanılır: "0.mfbiohx64i"biz sonra herhangi endeksi sürebilir0.

Rastgele Dize Oluşturucu (Alfa-Sayısal | Alfa | Sayısal)

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

Yukarıdakiler istenen A / N, A, N çıkışı için ek kontroller kullanıyor olsa da, daha iyi bir anlayış için onu temellere (sadece Alfa-Sayısal) ayıralım:

• Bir bağımsız değişkeni kabul eden bir işlev oluşturun (rastgele String sonucunun istenen uzunluğu)
• var str = "";Rastgele karakterleri birleştirmek gibi boş bir dize oluşturun
• Bir döngü içinde 0 ila 61 arasında bir randdizin numarası oluşturun (0..9 + A..Z + a..z = 62)
• Doğru sayıyı ve ilgili Karakteri geri almak için Ayarlamak / düzeltmek için (0..61 olduğu için) bir sayı kadar arttırarak (aşağıdaki örneklere bakın) bir koşullu mantık oluşturun .randCharCode
• Döngünün içinde strbirString.fromCharCode( incremented rand )

ASCII Karakter tablosu aralıklarını hayal edelim :

_____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 )bir ara verir 0..61(ihtiyacımız olan şey).
Doğru charCode aralıklarını elde etmek için rastgele düzeltelim :

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

Koşullu işlem mantık tablo yukarıdan:

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

Yukarıdaki açıklamadan, sonuçta ortaya çıkan alfa-sayısal snippet :

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"

Veya şunları yapacaksanız:

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

En basit yol:

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

Bu, geçerli saate göre 5 karakterlik rastgele dizeler oluşturur. Örnek çıkışı 4mtxjya da 4mv90ya da4mwp1

Buradaki sorun, aynı saniyede iki kez çağırırsanız, aynı dizeyi üretmesidir.

Daha güvenli yol:

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

Bu, her zaman farklı olan 4 veya 5 karakterlik rastgele bir dize oluşturur. Örnek çıktı şuna benzer 30jzmveya 1r591veya4su1a

Her iki şekilde de ilk bölüm rastgele bir sayı üretir. .toString(36)Parçası bunun bir base36 (alphadecimal) gösterimi için sayı atama.

İşte bazı kolay tek gömlekler. new Array(5)Uzunluğu ayarlamak için değiştirin .

Dahil olmak üzere 0-9a-z

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

Dahil olmak üzere 0-9a-zA-Z

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

Herkesin zaten doğru olduğunu biliyorum, ama bu mümkün olan en hafif şekilde gitmek gibi hissettim (kod ışık, CPU değil):

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

console.log(rand(5));

Kafanızı sarmak biraz zaman alıyor, ancak bence gerçekten javascript'in sözdiziminin ne kadar harika olduğunu gösteriyor.

Eğer kullanıyorsanız Lodash veya alt çizgi , o zaman çok basit:

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

[A-zA-Z0-9] ve uzunluk = 5 gereksinimlerini karşılamak için

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

Küçük harfler, büyük harfler ve sayılar oluşur.

Herhangi bir kişinin hafızayı bir kerede tahsis eden (ancak kolaylık sağlamak için biçimlendirilmemiş olmasına rağmen) bir astarla ilgilenmesi durumunda (ancak küçük dizeler için gerçekten önemli olmadığını unutmayın) burada nasıl yapılacağıdır:

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

İstediğiniz 5dizenin uzunluğuyla değiştirebilirsiniz . Bu yazıdaki @AriyaHidayat sayesinde mapfonksiyonun yarattığı seyrek dizi üzerinde çalışmayan çözüm için teşekkürler Array(5).

İşte oluşturduğum yöntem.
Hem büyük hem de küçük harf içeren bir dize oluşturur.
Ayrıca alfasayısal bir dize oluşturacak işlevi ekledim.

Çalışma örnekleri:
http://jsfiddle.net/greatbigmassive/vhsxs/ (yalnızca alfa)
http://jsfiddle.net/greatbigmassive/PJwg8/ (alfasayısal)

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

Temmuz 2015'i Yükselt
Bu aynı şeyi yapıyor ancak daha anlamlı ve tüm harfleri içeriyor.

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

Kullanmak varsayarsak underscorejs o zarif sadece iki satır rasgele dize oluşturmak mümkündür:

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

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

Hızlı ve geliştirilmiş algoritma. Üniformayı garanti etmez (yorumlara bakın).

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

"Rastgele dizelere ihtiyacım var" sorularına (hangi dilde olursa olsun) yanıtlar ile ilgili sorun hemen hemen her çözüm dize uzunluğunun hatalı bir birincil belirtimini kullanır . Rasgele dizeleri ihtiyaç vardır neden soruları kendileri nadiren ortaya, ama nadiren kaçınılmaz bir ihtiyaç bazı sayıdır Ne 8. demek, bir uzunlukta rasgele dizeleri ihtiyaç sorun olur benzersiz dizeleri bazı amaçla tanımlayıcılar olarak kullanmak, örneğin,.

Kesinlikle benzersiz dizeler elde etmenin iki önde gelen yolu vardır : deterministik olarak (rastgele değil) ve depola / karşılaştır (zahmetli). Biz ne yaptık? Hayaleti bırakıyoruz. Onun yerine olasılıksal teklikle gidiyoruz . Yani, dizelerimizin benzersiz olmayacağı konusunda küçük (ancak küçük) bir risk olduğunu kabul ediyoruz. Çarpışma olasılığını ve entropiyi anlamak burada yardımcı olur.

Bu yüzden, değişmez ihtiyacı küçük bir tekrarlama riski olan bir dizi dizeye ihtiyaç duyduğu şeklinde yeniden ifade edeceğim. Somut bir örnek olarak, 5 milyon kimlik potansiyeli oluşturmak istediğinizi varsayalım. Her yeni dizeyi saklamak ve karşılaştırmak istemezsiniz ve rastgele olmasını istersiniz, bu nedenle tekrarlama riskini kabul edersiniz. Örneğin, bir trilyon tekrarlama şansında 1'den az bir risk olduğunu varsayalım. Peki, ne kadar uzunluğa ihtiyacınız var? Bu soru, kullanılan karakterlere bağlı olduğu için yeterince belirsiz. Ama daha da önemlisi, yanlış yönlendirilmiş. İhtiyacınız olan şey, dizelerin entropisinin uzunluğu değil bir spesifikasyonu. Entropi, bazı dizelerde tekrarlanma olasılığı ile doğrudan ilişkili olabilir. Dize uzunluğu olamaz.

EntropyString gibi bir kütüphane bu noktada yardımcı olabilir. 5 milyon dizede 1 trilyondan daha az tekrarlama şansına sahip rastgele kimlikleri kullanarak 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-stringvarsayılan olarak 32 karakterden oluşan bir karakter seti kullanır. Önceden tanımlanmış başka karakter setleri de vardır ve kendi karakterlerinizi de belirleyebilirsiniz. Örneğin, yukarıdaki gibi aynı entropiye sahip ancak onaltılık karakterler kullanan kimlikler oluşturma:

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

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

const string = random.string(bits)

"27b33372ade513715481f"

Kullanılan karakter kümesindeki toplam karakter sayısındaki farktan dolayı dize uzunluğu farkına dikkat edin. Belirtilen sayıda potansiyel dizede tekrarlama riski aynıdır. Dize uzunlukları değildir. Ve en önemlisi, tekrarlama riski ve potansiyel dizi sayısı açıktır. Dize uzunluğu ile artık tahmin yok.

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

Bu alacak kadar temiz. Ayrıca hızlı, http://jsperf.com/ay-random-string .

Bir öğe dizisi arasında döngü oluşturabilir ve örneğin rastgele bir DNA dizisi istiyorsanız, bunları bir dize değişkenine yinelemeli olarak ekleyebilirsiniz:

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

Hem küçük hem de büyük harfleri desteklemek için temiz bir çözüm bulamadım.

Yalnızca küçük harf desteği:

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

Küçük ve büyük harfleri desteklemek için bu çözümü temel alan:

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

İhtiyacınız olan uzunluğa ayarlamak için 5girişi değiştirin substr(2, 5).

Bir astar:

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

Bu kesinlikle işe yarıyor

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

Böyle bir şeye ne dersiniz: Date.now().toString(36) Çok rastgele değil, her seferinde kısa ve oldukça benzersiz.

Büyük / Küçük Harfe Duyarsız Alfanümerik Karakterler:

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

Bu işlevin yararı, farklı uzunluktaki rastgele dizeyi alabilmeniz ve dizenin uzunluğunu garanti etmesidir.

Büyük / Küçük Harfe Duyarlı Tüm Karakterler:

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

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

Özel Karakterler

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

10 karakter uzunluğunda dize oluşturun. Uzunluk parametre ile ayarlanır (varsayılan 10).

function random_string_generator(len) {
var len = len || 10;
var str = '';
var i = 0;

for(i=0; i<len; i++) {
    switch(Math.floor(Math.random()*3+1)) {
        case 1: // digit
            str += (Math.floor(Math.random()*9)).toString();
        break;

        case 2: // small letter
            str += String.fromCharCode(Math.floor(Math.random()*26) + 97); //'a'.charCodeAt(0));
        break;

        case 3: // big letter
            str += String.fromCharCode(Math.floor(Math.random()*26) + 65); //'A'.charCodeAt(0));
        break;

        default:
        break;
    }
}
return str;
}

Coderain kullanabilirsiniz . Verilen desene göre rastgele kodlar oluşturmak için bir kütüphane. #Büyük ve küçük harfler ve rakamlar için yer tutucu olarak kullanın :

var cr = new CodeRain("#####");
console.log(cr.next());

ABüyük harfler veya 9rakamlar gibi başka yer tutucular da vardır .

Yararlı olabilecek şey, .next() size her zaman benzersiz bir sonuç vereceğidir, böylece kopyalar hakkında endişelenmenize gerek yoktur.

İşte benzersiz rastgele kodların bir listesini üreten bir demo uygulaması .

Tam açıklama: Ben Coderain yazarım.