Chcę ciąg 5 znaków złożony ze znaków wybranych losowo ze zbioru [a-zA-Z0-9]
.
Jak najlepiej to zrobić za pomocą JavaScript?
Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 5);
Chcę ciąg 5 znaków złożony ze znaków wybranych losowo ze zbioru [a-zA-Z0-9]
.
Jak najlepiej to zrobić za pomocą JavaScript?
Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 5);
Odpowiedzi:
Myślę, że to zadziała dla ciebie:
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));
+=
na takich ciągach powoduje, że ma zachowanie O (n ^ 2). Jeśli chcesz tworzyć dłuższe ciągi, powinieneś utworzyć tablicę pojedynczych znaków i połączyć je razem na końcu.
+=
jest często z jakiegoś powodu szybszy, nawet używany wewnątrz pętli - jsperf.com/join-vs-concatenation
crypto
zamiast tego.
let r = Math.random().toString(36).substring(7);
console.log("random", r);
Uwaga: powyższy algorytm ma następujące słabości:
Math.random()
może generować przewidywalny („wyglądający losowo”, ale nie tak naprawdę losowy) wynik w zależności od implementacji. Powstały ciąg nie jest odpowiedni, gdy trzeba zagwarantować niepowtarzalność lub nieprzewidywalność.Math.random().toString(36).substr(2, 5)
, ponieważ .substring(7)
powoduje, że ma on więcej niż 5 znaków. Nadal pełne punkty!
toString
Metoda typu liczbowego w javascript pobiera opcjonalny parametr do konwersji liczby na daną bazę. Jeśli na przykład zdasz dwa, zobaczysz, że Twój numer jest reprezentowany w postaci binarnej. Podobnie jak hex (podstawa 16), podstawa 36 używa liter do reprezentowania cyfr poza 9. Przekształcając liczbę losową na podstawę 36, skończysz z wiązką pozornie losowych liter i cyfr.
(Math.random() + 1).toString(36).substring(7);
Math.random jest zły dla tego rodzaju rzeczy
opcja 1
Jeśli możesz zrobić to po stronie serwera , po prostu użyj modułu kryptograficznego -
var crypto = require("crypto");
var id = crypto.randomBytes(20).toString('hex');
// "bb5dc8842ca31d4603d6aa11448d1654"
Wynikowy ciąg będzie dwa razy dłuższy niż generowane losowe bajty; każdy bajt zakodowany w postaci szesnastkowej ma 2 znaki. 20 bajtów będzie 40 znakami szesnastkowymi.
Opcja 2
Jeśli musisz zrobić to po stronie klienta , być może spróbuj modułu uuid -
var uuid = require("uuid");
var id = uuid.v4();
// "110ec58a-a0f2-4ac4-8393-c866d813b8d1"
Opcja 3
Jeśli musisz to zrobić po stronie klienta i nie musisz obsługiwać starych przeglądarek, możesz to zrobić bez zależności -
// 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"
Aby uzyskać więcej informacji na temat crypto.getRandomValues
-
Ta
crypto.getRandomValues()
metoda pozwala uzyskać kryptograficznie silne losowe wartości. Tablica podana jako parametr jest wypełniona liczbami losowymi (losowymi w znaczeniu kryptograficznym).
Oto mały przykład konsoli -
> 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 ]
Do obsługi IE11 możesz użyć -
(window.crypto || window.msCrypto).getRandomValues(arr)
Aby zapoznać się z zasięgiem przeglądarki, patrz https://caniuse.com/#feat=getrandomvalues
.map()
w opcji 3. Array.from(arr, dec2hex).join('')
=== Array.from(arr).map(dec2hex).join('')
. Dziękujemy za
require
moduł nie może być używany tylko po stronie serwera?
Zwraca dokładnie 5 losowych znaków, w przeciwieństwie do niektórych najwyżej ocenianych odpowiedzi tutaj.
Math.random().toString(36).substr(2, 5);
Math.random().toString(36)
zwróci liczbę składającą się z mniej niż 5 znaków?
function getRandomString() { var result = ''; while (!result) result = Math.random().toString(36).substring(2); return result; };
Oto poprawa doskonałej odpowiedzi doubleletap . Oryginał ma dwie wady, które są tutaj omówione:
Po pierwsze, jak wspomnieli inni, ma małe prawdopodobieństwo wytworzenia krótkich lub nawet pustych łańcuchów (jeśli liczba losowa to 0), co może zepsuć twoją aplikację. Oto rozwiązanie:
(Math.random().toString(36)+'00000000000000000').slice(2, N+2)
Po drugie, zarówno oryginał, jak i powyższe rozwiązanie ograniczają rozmiar ciągu N do 16 znaków. Poniższe zwróci ciąg o rozmiarze N dla dowolnego N (ale należy pamiętać, że użycie N> 16 nie zwiększy losowości ani nie zmniejszy prawdopodobieństwa kolizji):
Array(N+1).join((Math.random().toString(36)+'00000000000000000').slice(2, 18)).slice(0, N)
Wyjaśnienie:
Dalsze przemyślenia:
Aktualizacja:
Oto kilka innych funkcjonalnych stylów, które wymyśliłem. Różnią się od powyższego rozwiązania tym, że:
Powiedzmy, że twoim alfabetem jest
var s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
Te dwa są sobie równe, więc możesz wybrać, który z nich jest bardziej intuicyjny:
Array(N).join().split(',').map(function() { return s.charAt(Math.floor(Math.random() * s.length)); }).join('');
i
Array.apply(null, Array(N)).map(function() { return s.charAt(Math.floor(Math.random() * s.length)); }).join('');
Edytować:
Wygląda na to, że qubyte i Martijn de Milliano wymyślili rozwiązania podobne do tych drugich (kudos!), Których jakoś przegapiłem. Ponieważ na pierwszy rzut oka nie wyglądają tak krótko, zostawię to tutaj, na wypadek, gdyby ktoś naprawdę chciał mieć liniówkę :-)
Ponadto zastąpiono „new Array” „Array” we wszystkich rozwiązaniach, aby zmniejszyć liczbę kolejnych bajtów.
(Math.random()+1).toString(36).substring(7);
Math.random().toString(36).substring(2,7)
daje oczekiwany wynik, który bardziej przypomina.substring(2, n+2)
Array.apply(null, {length: 5}).map(function() { return s.charAt(Math.floor(Math.random() * s.length)); }).join('')
Najbardziej kompaktowe rozwiązanie, ponieważ slice
jest krótsze niż substring
. Odejmowanie od końca łańcucha pozwala uniknąć symbolu zmiennoprzecinkowego generowanego przez random
funkcję:
Math.random().toString(36).slice(-5);
lub nawet
(+new Date).toString(36).slice(-5);
Aktualizacja: Dodano jeszcze jedno podejście przy użyciu btoa
metody:
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));
Math.random().toString(36).slice(-5);
- Co jeśli Math.random()
powróci 0.0
?
"0"
;)
Math.random()
zwraca 0.5
wynik jest "0.i"
. Nie jestem pewien, czy istnieją inne przypadki krawędzi. Chciałem tylko zaznaczyć, że nie jest to poprawna odpowiedź na pytanie (5 znaków z [a-zA-Z0-9]).
(+new Date + Math.random())
aby zapobiec tej sprawie. W każdym razie dzięki za notatkę.
Coś takiego powinno działać
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;
}
Dzwoń z domyślnym zestawem znaków [a-zA-Z0-9] lub wysyłaj własny:
var randomValue = randomString(5);
var randomValue = randomString(5, 'PICKCHARSFROMTHISSET');
len
bezpośrednio w while
pętli
Nowsza wersja z operatorem rozprzestrzeniania es6 :
[...Array(30)].map(() => Math.random().toString(36)[2]).join('')
30
to dowolna liczba, możesz wybrać dowolną długość tokena36
to maksymalna liczba podstawowa, jaką możesz przekazać do numeric.toString () , co oznacza wszystkie cyfry i małe litery az2
Służy do piłki 3th indeks z losowy ciąg, który wygląda tak: "0.mfbiohx64i"
, możemy podjąć wszelkie indeksu po0.
function randomstring(L) {
var s = '';
var randomchar = function() {
var n = Math.floor(Math.random() * 62);
if (n < 10) return n; //1-10
if (n < 36) return String.fromCharCode(n + 55); //A-Z
return String.fromCharCode(n + 61); //a-z
}
while (s.length < L) s += randomchar();
return s;
}
console.log(randomstring(5));
while(s.length< L) s+= randomchar();
while(L--)
to zrobi
'A'.charCodeAt(0)
niż magicznej liczby 55
(i podobnie w przypadku 61
). Zwłaszcza, że i tak na mojej platformie magiczna liczba, która powraca, to 65
. Ten kod również będzie lepiej dokumentował się sam.
/**
* 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"
Podczas gdy powyższe wykorzystuje dodatkowe kontrole pożądanego wyjścia A / N, A, N , podzielmy je na najważniejsze (tylko alfanumeryczne) dla lepszego zrozumienia:
var str = "";
aby połączyć losowe znakirand
numer indeksu od 0 do 61 (0..9 + A..Z + a..z = 62)rand
(ponieważ wynosi 0..61), zwiększając ją o pewną liczbę (patrz przykłady poniżej), aby odzyskać właściwą CharCode
liczbę i powiązany znak.str
zString.fromCharCode( incremented rand )
Wyobraźmy sobie zakresy tabeli znaków 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 )
daje zakres od 0..61
(czego potrzebujemy).
Naprawmy losowy, aby uzyskać prawidłowe zakresy charCode :
| 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 |
Warunkowa operacja logiczna z powyższej tabeli:
rand += rand>9 ? ( rand<36 ? 55 : 61 ) : 48 ;
// rand += true ? ( true ? 55 else 61 ) else 48 ;
Z powyższego wyjaśnienia oto wynikowy fragment alfanumeryczny :
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"
Lub jeśli:
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))
Najprostszym sposobem jest:
(new Date%9e6).toString(36)
Generuje losowe ciągi 5 znaków na podstawie aktualnego czasu. Przykładowy wynik to 4mtxj
lub 4mv90
lub4mwp1
Problem polega na tym, że jeśli wywołasz go dwa razy w tej samej sekundzie, wygeneruje ten sam ciąg.
Bezpieczniejszy sposób to:
(0|Math.random()*9e6).toString(36)
To wygeneruje losowy ciąg 4 lub 5 znaków, zawsze inny. Przykładowy wynik to: 30jzm
lub 1r591
lub4su1a
W obu przypadkach pierwsza część generuje liczbę losową. Część .toString(36)
rzutuje liczbę na podstawową 36 (alfadecymalną) reprezentację.
(+new Date).toString(36)
(0|Math.random()*6.04e7).toString(36)
aby je zakryć.
(Math.random()*1e20).toString(36)
.
Oto kilka prostych wkładek. Zmień, new Array(5)
aby ustawić długość.
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"]();});
Wiem, że wszyscy już to zrobili, ale miałem ochotę spróbować tego w jak najlżejszy sposób (światło na kod, a nie procesor):
function rand(length, current) {
current = current ? current : '';
return length ? rand(--length, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz".charAt(Math.floor(Math.random() * 60)) + current) : current;
}
console.log(rand(5));
Zajmuje trochę czasu, ale myślę, że to naprawdę pokazuje, jak niesamowita jest składnia javascript.
current = current ? current : '';
po co pisać, kiedy możesz pisać current = current || ''
;
current || (current = '');
Jeśli używasz Lodash lub Underscore , to takie proste:
var randomVal = _.sample('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', 5).join('');
_.sampleSize('asdfgh',5).join('')
Aby spełnić wymaganie [a-zA-Z0-9] i długość = 5, użyj
btoa(Math.random()).substr(5, 5);
Pojawią się małe litery, wielkie litery i cyfry.
Jeśli ktoś jest zainteresowany liniowcem (choć nie jest sformatowany jako taki dla Twojej wygody), który przydziela pamięć od razu (ale pamiętaj, że w przypadku małych łańcuchów to naprawdę nie ma znaczenia), oto jak to zrobić:
Array.apply(0, Array(5)).map(function() {
return (function(charset){
return charset.charAt(Math.floor(Math.random() * charset.length))
}('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'));
}).join('')
Możesz zastąpić żądaną 5
długością łańcucha. Dzięki @AriyaHidayat w tym poście za rozwiązanie map
funkcji nie działającej na rzadkiej tablicy utworzonej przez Array(5)
.
Oto metoda, którą stworzyłem.
Utworzy ciąg zawierający zarówno wielkie, jak i małe litery.
Dodatkowo zawarłem funkcję, która utworzy również ciąg alfanumeryczny.
Przykłady robocze:
http://jsfiddle.net/greatbigmassive/vhsxs/ (tylko w wersji alfa)
http://jsfiddle.net/greatbigmassive/PJwg8/ (alfanumeryczny)
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;
}
Aktualizacja lipca 2015 r.
To samo robi, ale ma większy sens i obejmuje wszystkie litery.
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)));
}
Zakładając, że używasz podkreślników, możesz elegancko wygenerować losowy ciąg w dwóch liniach:
var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
var random = _.sample(possible, 5).join('');
const c = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
const s = [...Array(5)].map(_ => c[~~(Math.random()*c.length)]).join('')
Szybki i ulepszony algorytm. Nie gwarantuje jednolitości (patrz komentarze).
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;
}
crypto.getRandomValues
zwraca jedną z 256 unikalnych wartości. Ponieważ 256 nie jest dzielone przez 62, w rezultacie masz nieco większe prawdopodobieństwo otrzymania znaków AH. Myślę, że najlepszym rozwiązaniem jest zrobienie tego, co zrobił YouTube, i dodanie 2 dodatkowych znaków (ewentualnie -
i _
) do zestawu znaków. W każdym razie świetna robota - ta odpowiedź wymaga o wiele więcej miłości :)
Problem z odpowiedziami na pytania „Potrzebuję losowych ciągów” (w dowolnym języku) polega na tym, że praktycznie każde rozwiązanie wykorzystuje wadliwą podstawową specyfikację długości łańcucha . Same pytania rzadko ujawniają, dlaczego potrzebne są losowe ciągi, ale rzuciłbym wyzwanie, że rzadko potrzebujesz losowych ciągów, powiedzmy 8. To, czego zawsze potrzebujesz, to pewna liczba unikatowych ciągów , na przykład do wykorzystania jako identyfikatory w jakimś celu.
Istnieją dwa wiodące sposoby uzyskania ściśle unikatowych ciągów: deterministycznie (co nie jest losowe) i przechowywanie / porównywanie (co jest uciążliwe). Co robimy? Porzucamy ducha. Idziemy z probabilistycznego wyjątkowości zamiast. To znaczy, akceptujemy, że istnieje pewne (choć niewielkie) ryzyko, że nasze łańcuchy nie będą unikalne. W tym przypadku pomocne jest zrozumienie prawdopodobieństwa zderzenia i entropii .
Dlatego zmienię niezmienną potrzebę jako wymagającą pewnej liczby ciągów z niewielkim ryzykiem powtórzenia. Jako konkretny przykład, powiedzmy, że chcesz wygenerować potencjał 5 milionów identyfikatorów. Nie chcesz przechowywać i porównywać każdego nowego łańcucha i chcesz, aby były losowe, więc akceptujesz ryzyko powtórzenia. Jako przykład, powiedzmy, że ryzyko jest mniejsze niż 1 przy trylionach szansy na powtórzenie. Jakiej długości sznurka potrzebujesz? To pytanie jest nieokreślone, ponieważ zależy od użytych znaków. Ale co ważniejsze, jest to mylące. Potrzebujesz specyfikacji entropii łańcuchów, a nie ich długości. Entropia może być bezpośrednio związana z prawdopodobieństwem powtórzenia w pewnej liczbie ciągów. Długość łańcucha nie może.
I tu może pomóc biblioteka taka jak EntropyString . Aby wygenerować losowe identyfikatory, które mają mniej niż 1, z bilionem szansy na powtórzenie w 5 milionach ciągów przy użyciu 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
używa domyślnie zestawu znaków zawierającego 32 znaki. Istnieją inne predefiniowane zestawy znaków, a także możesz określić własne znaki. Na przykład generowanie identyfikatorów z taką samą entropią jak powyżej, ale przy użyciu znaków szesnastkowych:
import {Random, Entropy, charSet16} from './entropy-string'
const random = new Random(charSet16)
const bits = Entropy.bits(5e6, 1e12)
const string = random.string(bits)
„27b33372ade513715481f”
Zwróć uwagę na różnicę długości łańcucha wynikającą z różnicy w całkowitej liczbie znaków w użytym zestawie znaków. Ryzyko powtórzenia w określonej liczbie potencjalnych ciągów jest takie samo. Długości łańcucha nie są. A co najważniejsze, ryzyko powtórzenia i potencjalna liczba ciągów jest wyraźna. Nigdy więcej zgadywania przy długości łańcucha.
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('');
}
To jest tak czyste, jak to możliwe. Jest również szybki, http://jsperf.com/ay-random-string .
strLength - 1
: - /
--strLength
na strLength--
to naprawia dla mnie.
Możesz przeglądać tablicę elementów i rekurencyjnie dodawać je do zmiennej łańcuchowej, na przykład jeśli chcesz losową sekwencję DNA:
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));
Nie znalazłem czystego rozwiązania do obsługi zarówno małych, jak i wielkich liter.
Obsługa tylko małych liter:
Math.random().toString(36).substr(2, 5)
Opierając się na tym rozwiązaniu do obsługi małych i wielkich liter:
Math.random().toString(36).substr(2, 5).split('').map(c => Math.random() < 0.5 ? c.toUpperCase() : c).join('');
Zmień 5
w, substr(2, 5)
aby dopasować do potrzebnej długości.
Jedna wkładka:
Array(15).fill(null).map(() => Math.random().toString(36).substr(2)).join('')
// Outputs: 0h61cbpw96y83qtnunwme5lxk1i70a6o5r5lckfcyh1dl9fffydcfxddd69ada9tu9jvqdx864xj1ul3wtfztmh2oz2vs3mv6ej0fe58ho1cftkjcuyl2lfkmxlwua83ibotxqc4guyuvrvtf60naob26t6swzpil
Array(15)
na mniejszą wartość. Np Array(4)
. :
To na pewno działa
<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>
A może coś takiego: Date.now().toString(36)
niezbyt losowe, ale krótkie i dość wyjątkowe za każdym razem, gdy to nazwiesz.
Date.now()
ma rozdzielczość tylko milisekundową. Na przykład w prostej pętli otrzymasz wiele duplikatów. for (let i = 0; i < 10; ++i) { console.log(Date.now().toString(36)); }
.
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));
Zaletą tej funkcji jest to, że można uzyskać losowy ciąg różnej długości i zapewnia on długość łańcucha.
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
var possible
podobny do akceptowanej odpowiedzi, więc wynik funkcji jest bardziej konfigurowalny.
Wygeneruj ciąg znaków o długości 10 znaków. Długość jest ustawiana przez parametr (domyślnie 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;
}
Możesz użyć coderain . Jest to biblioteka do generowania losowych kodów według podanego wzorca. Użyj #
jako symbolu zastępczego dla wielkich i małych liter oraz cyfr:
var cr = new CodeRain("#####");
console.log(cr.next());
Istnieją inne symbole zastępcze, takie jak A
wielkie litery lub9
cyfry.
Przydatne może być to wywołanie .next()
zawsze daje unikalny wynik, więc nie musisz się martwić o duplikaty.
Oto aplikacja demonstracyjna, która generuje listę unikalnych losowych kodów .
Pełne ujawnienie: jestem autorem coderain.
true-random
rezultatu! Oni są tylkopseudo-random
. Używając losowych ciągów do ochrony lub bezpieczeństwa, nie używaj żadnego z nich !!! Wypróbuj jeden z tych interfejsów API: random.org