Saya ingin string 5 karakter yang terdiri dari karakter yang dipilih secara acak dari set [a-zA-Z0-9].

Apa cara terbaik untuk melakukan ini dengan JavaScript?

Saya pikir ini akan bekerja untuk Anda:

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

Catatan: Algoritma di atas memiliki kelemahan berikut:

• Ini akan menghasilkan di mana saja antara 0 dan 6 karakter karena fakta bahwa trailing nol dihapus ketika meratakan floating point.
• Ini sangat tergantung pada algoritma yang digunakan untuk merumuskan angka floating point, yang sangat kompleks. (Lihat kertas "Cara Mencetak Angka Titik Apung dengan Akurat" .)
• Math.random()dapat menghasilkan output yang dapat diprediksi ("tampak acak" tetapi tidak benar-benar acak) tergantung pada implementasinya. String yang dihasilkan tidak cocok ketika Anda perlu menjamin keunikan atau ketidakpastian.
• Bahkan jika itu menghasilkan 6 karakter acak yang seragam dan tidak dapat diprediksi, Anda dapat berharap untuk melihat duplikat setelah menghasilkan hanya sekitar 50.000 string, karena paradoks ulang tahun . (sqrt (36 ^ 6) = 46656)

Math.random buruk untuk hal semacam ini

Pilihan 1

Jika Anda dapat melakukan ini di sisi server , cukup gunakan modul kripto -

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

// "bb5dc8842ca31d4603d6aa11448d1654"

String yang dihasilkan akan dua kali lebih lama dari byte acak yang Anda hasilkan; setiap byte yang dikodekan ke hex adalah 2 karakter. 20 byte akan menjadi 40 karakter hex.

pilihan 2

Jika Anda harus melakukan ini di sisi klien , mungkin coba modul uuid -

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

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

Opsi 3

Jika Anda harus melakukan ini di sisi klien dan Anda tidak harus mendukung browser lama, Anda dapat melakukannya tanpa ketergantungan -

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

Untuk informasi lebih lanjut tentang crypto.getRandomValues -

Itu crypto.getRandomValues() Metode memungkinkan Anda mendapatkan nilai acak cryptographically kuat. Array yang diberikan sebagai parameter diisi dengan angka acak (acak dalam arti kriptografisnya).

Ini contoh konsol kecil -

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

Untuk dukungan IE11, Anda dapat menggunakan -

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

Untuk jangkauan browser, lihat https://caniuse.com/#feat=getrandomvalues

Singkat, mudah, dan andal

Mengembalikan tepat 5 karakter acak, yang bertentangan dengan beberapa jawaban berperingkat teratas yang ditemukan di sini.

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

Berikut perbaikan pada jawaban doubletap ini sangat baik . Dokumen asli memiliki dua kelemahan yang dibahas di sini:

Pertama, seperti yang disebutkan orang lain, ia memiliki kemungkinan kecil untuk menghasilkan string pendek atau bahkan string kosong (jika angka acaknya adalah 0), yang dapat merusak aplikasi Anda. Ini solusinya:

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

Kedua, baik yang asli dan solusi di atas membatasi ukuran string N hingga 16 karakter. Berikut ini akan mengembalikan string ukuran N untuk setiap N (tetapi perhatikan bahwa menggunakan N> 16 tidak akan meningkatkan keacakan atau mengurangi kemungkinan tabrakan):

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

Penjelasan:

1. Pilih angka acak dalam kisaran [0,1), yaitu antara 0 (inklusif) dan 1 (eksklusif).
2. Konversi angka menjadi string base-36, yaitu menggunakan karakter 0-9 dan az.
3. Pad dengan nol (memecahkan masalah pertama).
4. Potong pemimpin '0.' awalan dan nol bantalan tambahan.
5. Ulangi string cukup kali untuk memiliki setidaknya N karakter di dalamnya (dengan Menggabungkan string kosong dengan string acak pendek yang digunakan sebagai pembatas).
6. Potong persis N karakter dari string.

Pikiran lebih lanjut:

• Solusi ini tidak menggunakan huruf besar, tetapi dalam hampir semua kasus (tidak ada kata pun dimaksudkan) itu tidak masalah.
• Panjang string maksimum pada N = 16 dalam jawaban asli diukur dalam Chrome. Di Firefox itu N = 11. Tapi seperti yang dijelaskan, solusi kedua adalah tentang mendukung panjang string yang diminta, bukan tentang menambahkan keacakan, sehingga tidak membuat banyak perbedaan.
• Semua string yang dikembalikan memiliki probabilitas yang sama untuk dikembalikan, setidaknya sejauh hasil yang dikembalikan oleh Math.random () didistribusikan secara merata (dalam hal apa pun, ini bukan keacakan kekuatan-kriptografi, dalam hal apa pun).
• Tidak semua string ukuran N yang mungkin dapat dikembalikan. Dalam solusi kedua ini jelas (karena string yang lebih kecil hanya diduplikasi), tetapi juga dalam jawaban asli ini benar karena dalam konversi ke basis-36 beberapa bit terakhir mungkin tidak menjadi bagian dari bit acak asli. Khususnya, jika Anda melihat hasil Math.random (). ToString (36), Anda akan melihat bahwa karakter terakhir tidak terdistribusi secara merata. Sekali lagi, dalam hampir semua kasus itu tidak masalah, tetapi kami mengiris string terakhir dari awal daripada akhir string acak sehingga string pendek (misalnya N = 1) tidak terpengaruh.

Memperbarui:

Berikut adalah beberapa gaya-gaya lain yang saya buat. Mereka berbeda dari solusi di atas dalam hal:

• Mereka menggunakan alfabet arbitrer eksplisit (lebih umum, dan cocok untuk pertanyaan asli yang meminta huruf besar dan kecil).
• Semua string dengan panjang N memiliki probabilitas yang sama untuk dikembalikan (yaitu string tidak mengandung pengulangan).
• Mereka didasarkan pada fungsi peta, daripada trik toString (36), yang membuatnya lebih mudah dan mudah dimengerti.

Jadi, katakan alfabet pilihan Anda adalah

var s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

Maka keduanya setara satu sama lain, sehingga Anda dapat memilih mana yang lebih intuitif bagi Anda:

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

dan

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

Edit:

Saya sepertinya qubyte dan Martijn de Milliano datang dengan solusi yang mirip dengan yang terakhir (pujian!), Yang entah bagaimana saya lewatkan. Karena mereka tidak melihat sepintas sekilas, saya akan meninggalkannya di sini kalau-kalau seseorang benar-benar menginginkan satu-liner :-)

Juga, ganti 'Array baru' dengan 'Array' di semua solusi untuk mengurangi beberapa byte lagi.

Solusi paling ringkas, karena slicelebih pendek dari substring. Mengurangkan dari ujung string memungkinkan untuk menghindari simbol floating point yang dihasilkan oleh randomfungsi:

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

atau bahkan

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

Pembaruan: Menambahkan satu lagi pendekatan menggunakan btoametode:

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

Sesuatu seperti ini seharusnya bekerja

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

Hubungi dengan charset default [a-zA-Z0-9] atau kirim sendiri:

var randomValue = randomString(5);

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

Versi yang lebih baru dengan operator penyebaran es6 :

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

• Itu 30 adalah nomor arbitrer, Anda dapat memilih token yang Anda inginkan
• Ini 36adalah nomor radix maksimum yang dapat Anda lewati ke numeric.toString () , yang artinya semua angka dan huruf kecil a
• Ini 2digunakan untuk memilih indeks ke-3 dari string acak yang terlihat seperti ini:, "0.mfbiohx64i"kita bisa mengambil indeks apa pun setelah0.

Pembuat String Acak (Alpha-Numeric | Alpha | Numeric)

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

Sementara di atas menggunakan pemeriksaan tambahan untuk A / N, A, N yang diinginkan output , mari kita pilah sampai ke esensi (hanya Alpha-Numeric) untuk pemahaman yang lebih baik:

• Buat fungsi yang menerima argumen (panjang yang diinginkan dari hasil String acak)
• Buat string kosong seperti var str = ""; untuk menggabungkan karakter acak
• Di dalam lingkaran, buat randnomor indeks dari 0 hingga 61 (0..9 + A..Z + a..z = 62)
• Buat logika kondisional untuk Menyesuaikan / memperbaikirand (karena 0..61) menambahkannya dengan beberapa nomor (lihat contoh di bawah) untuk mendapatkan kembali hak.CharCode nomor yang dan Karakter terkait.
• Di dalam loop menyatu dengan str aString.fromCharCode( incremented rand )

Mari kita gambarkan rentang tabel Karakter 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 )memberikan rentang dari 0..61(apa yang kita butuhkan).
Mari kita perbaiki acak untuk mendapatkan rentang kode karakter yang benar :

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

The bersyarat operasi logika dari tabel di atas:

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

Dari penjelasan di atas, inilah cuplikan alpha-numeric yang dihasilkan :

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"

Atau jika Anda akan:

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

Cara paling sederhana adalah:

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

Ini menghasilkan string acak 5 karakter berdasarkan waktu saat ini. Contoh output adalah 4mtxjatau 4mv90atau4mwp1

Masalah dengan ini adalah bahwa jika Anda memanggilnya dua kali pada detik yang sama, itu akan menghasilkan string yang sama.

Cara yang lebih aman adalah:

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

Ini akan menghasilkan string acak 4 atau 5 karakter, selalu berbeda. Contoh outputnya seperti 30jzmatau 1r591atau4su1a

Dalam kedua cara bagian pertama menghasilkan angka acak. Bagian .toString(36)melemparkan nomor ke representasi base36 (alfabet).

Berikut adalah beberapa kalimat yang mudah. Ubah new Array(5)untuk mengatur panjangnya.

Termasuk 0-9a-z

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

Termasuk 0-9a-zA-Z

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

Saya tahu semua orang sudah melakukannya dengan benar, tetapi saya merasa ingin mencoba yang ini dengan cara yang paling ringan (ringan pada kode, bukan 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));

Dibutuhkan sedikit waktu untuk membungkus kepala Anda, tapi saya pikir itu benar-benar menunjukkan betapa mengagumkannya sintaks javascript.

Jika Anda menggunakan Lodash atau Underscore , maka sangat sederhana:

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

Untuk memenuhi persyaratan [a-zA-Z0-9] dan panjang = 5 gunakan

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

Huruf kecil, huruf besar, dan angka akan muncul.

Jika ada yang tertarik dengan satu-liner (meskipun tidak diformat untuk kenyamanan Anda) yang mengalokasikan memori sekaligus (tetapi perhatikan bahwa untuk string kecil itu benar-benar tidak masalah) di sini adalah bagaimana melakukannya:

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

Anda dapat mengganti 5dengan panjang string yang Anda inginkan. Terima kasih kepada @AriyaHidayat dalam posting ini untuk solusi untuk mapfungsi yang tidak bekerja pada array yang jarang dibuat oleh Array(5).

Inilah metode yang saya buat.
Ini akan membuat string yang berisi karakter huruf besar dan kecil.
Selain itu saya telah menyertakan fungsi yang akan membuat string alfanumerik juga.

Contoh kerja:
http://jsfiddle.net/greatbigmassive/vhsxs/ (hanya alfa)
http://jsfiddle.net/greatbigmassive/PJwg8/ (alfanumerik)

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

Tingkatkan Juli 2015
Ini melakukan hal yang sama tetapi lebih masuk akal dan mencakup semua surat.

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

Dengan asumsi Anda menggunakan underscorejs dimungkinkan untuk menghasilkan string acak secara elegan hanya dalam dua baris:

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

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

Algoritma yang cepat dan ditingkatkan. Tidak menjamin seragam (lihat komentar).

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

Masalah dengan respons terhadap pertanyaan "Saya perlu string acak" (dalam bahasa apa pun) praktis setiap solusi menggunakan spesifikasi primer cacat panjang string . Pertanyaan-pertanyaan itu sendiri jarang mengungkapkan mengapa string acak diperlukan, tetapi saya akan menantang Anda jarang membutuhkan string acak panjang, katakan 8. Apa yang Anda selalu butuhkan adalah sejumlah string unik , misalnya, untuk digunakan sebagai pengidentifikasi untuk beberapa tujuan.

Ada dua cara utama untuk mendapatkan string unik yang unik : secara deterministik (yang tidak acak) dan menyimpan / membandingkan (yang memberatkan). Apa yang kita lakukan? Kami menyerah hantu. Kami pergi dengan keunikan probabilistik sebagai gantinya. Yaitu, kami menerima bahwa ada beberapa (betapapun kecil) risiko bahwa string kami tidak akan menjadi unik. Di sinilah memahami probabilitas tabrakan dan entropi sangat membantu.

Jadi saya akan ulangi kebutuhan yang tidak berubah sebagai membutuhkan sejumlah string dengan risiko pengulangan yang kecil. Sebagai contoh nyata, katakanlah Anda ingin menghasilkan potensi 5 juta ID. Anda tidak ingin menyimpan dan membandingkan setiap string baru, dan Anda ingin mereka menjadi acak, sehingga Anda menerima risiko berulang. Sebagai contoh, katakanlah risiko kurang dari 1 dalam satu triliun peluang berulang. Jadi berapa panjang tali yang Anda butuhkan? Nah, pertanyaan itu tidak ditentukan karena tergantung pada karakter yang digunakan. Tapi yang lebih penting, ini salah arah. Yang Anda butuhkan adalah spesifikasi entropi string, bukan panjangnya. Entropi dapat secara langsung terkait dengan probabilitas pengulangan dalam sejumlah string. Panjang string tidak bisa.

Dan di sinilah perpustakaan seperti EntropyString dapat membantu. Untuk menghasilkan ID acak yang memiliki peluang kurang dari 1 dalam satu triliun untuk diulang dalam 5 juta string menggunakan 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-stringmenggunakan set karakter dengan 32 karakter secara default. Ada set karakter yang telah ditentukan sebelumnya, dan Anda dapat menentukan karakter Anda sendiri juga. Misalnya, membuat ID dengan entropi yang sama seperti di atas tetapi menggunakan karakter hex:

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

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

const string = random.string(bits)

"27b33372ade513715481f"

Perhatikan perbedaan panjang string karena perbedaan jumlah karakter dalam set karakter yang digunakan. Risiko pengulangan dalam jumlah string potensial yang ditentukan adalah sama. Panjang string tidak. Dan yang paling penting, risiko pengulangan dan potensi jumlah string adalah eksplisit. Tidak perlu lagi menebak dengan panjang tali.

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

Ini sebersih yang akan didapat. Itu juga cepat, http://jsperf.com/ay-random-string .

Anda dapat mengulang melalui array item dan menambahkannya secara berulang ke variabel string, misalnya jika Anda ingin urutan DNA acak:

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

Saya tidak menemukan solusi bersih untuk mendukung karakter huruf kecil dan besar.

Huruf kecil hanya mendukung:

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

Membangun solusi untuk mendukung huruf kecil dan besar:

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

Ubah 5in substr(2, 5)untuk menyesuaikan dengan panjang yang Anda butuhkan.

Satu liner:

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

Ini pasti berhasil

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

Bagaimana dengan sesuatu seperti ini: Date.now().toString(36) Tidak terlalu acak, tetapi pendek dan cukup unik setiap kali Anda menyebutnya.

Karakter alfanumerik yang tidak peka huruf besar-kecil:

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

Manfaat dari fungsi ini adalah Anda bisa mendapatkan string acak panjang yang berbeda dan memastikan panjang string.

Case Sensitive All Chars:

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

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

Karakter Kustom

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

Hasilkan string 10 karakter. Panjangnya diatur oleh parameter (default 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;
}

Anda bisa menggunakan coderain . Itu perpustakaan untuk menghasilkan kode acak sesuai dengan pola yang diberikan. Gunakan #sebagai pengganti untuk karakter huruf besar dan kecil serta digit:

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

Ada penampung lain seperti Auntuk huruf besar atau9 angka.

Yang mungkin berguna adalah panggilan itu .next() akan selalu memberi Anda hasil yang unik sehingga Anda tidak perlu khawatir tentang duplikat.

Berikut adalah aplikasi demo yang menghasilkan daftar kode acak unik .

Pengungkapan penuh: Saya penulis coderain.