जावास्क्रिप्ट में यादृच्छिक स्ट्रिंग / वर्ण उत्पन्न करें

1777

मैं सेट से बेतरतीब ढंग से उठाए गए पात्रों से बना एक 5 चरित्र स्ट्रिंग चाहता हूं [a-zA-Z0-9]।

जावास्क्रिप्ट के साथ ऐसा करने का सबसे अच्छा तरीका क्या है?

javascript  random 
— टॉम लेहमैन
स्रोत
48
चेतावनी: जवाब में से कोई भी एक true-randomपरिणाम है! वे ही हैं pseudo-random। सुरक्षा या सुरक्षा के लिए यादृच्छिक तारों का उपयोग करते समय, उनमें से किसी का उपयोग न करें !!! इनमें से एक को आज़माएं: random.org
— रॉन वैन डेर हाइजेन
48
Math.random () .String (36) .replace (/ [^ az] + / g, '')
— Muaz Khan
13
कृपया घोल को एक घोल में डालें।
— chryss
214
Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 5);
— फ्रेडरिक
12
नोट HTML5 webcrypto randomness API वास्तविक यादृच्छिकता प्रदान करता है।
— मिकमेकसाना 16

जवाबों:

2430

मुझे लगता है कि यह आपके लिए काम करेगा:

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));
स्निपेट का विस्तार करें

— csharptest.net
स्रोत
117
यह शॉर्ट स्ट्रिंग्स के लिए ठीक है, लेकिन सावधान रहें, +=इस तरह के स्ट्रिंग्स का उपयोग करने से इसका O (n ^ 2) व्यवहार होता है। यदि आप लंबे समय तक तार बनाना चाहते हैं, तो आपको व्यक्तिगत पात्रों की एक सरणी बनानी चाहिए और अंत में उन्हें एक साथ जोड़ना चाहिए।
— dan_waterworth
97
@dan_waterworth यह शायद लगभग किसी भी मामले में मायने नहीं रखता है : codinghorror.com/blog/2009/01/…
— एलेक्स रीस
7
@dan_waterworth, वास्तव में, +=अक्सर किसी कारण के लिए तेज होता है, यहां तक ​​कि छोरों के अंदर भी इस्तेमाल किया जाता है - jsperf.com/join-vs-concatenation
— कोनराड बोरोस्की
18
@JonathanPaulson मुझे नंबर दिखाएं । पिछली टिप्पणी को jsperf लिंक या jsperf.com/sad-tragedy-of-microoptimization या sitepen.com/blog/2008/05/09/string-performance-an-analysis आदि के साथ देखें। इस प्रश्न में केवल 5 निष्कर्ष शामिल हैं। ।
— एलेक्स रीस
11
@codenamejames कृपया अपने पासवर्ड सलाटिंग में इसका उपयोग न करें। यह केवल छद्म यादृच्छिक सुरक्षित नहीं है। मान लें कि आप नोड का उपयोग कर रहे हैं (मुझे यह भी निश्चित नहीं है कि ग्राहक की तरफ से नमस्कार करने पर आपको कहां से शुरू करना है), cryptoइसके बजाय उपयोग करें ।
— हाइड्रोथर्मल
2330 

let r = Math.random().toString(36).substring(7);
console.log("random", r);
स्निपेट का विस्तार करें

नोट: उपरोक्त एल्गोरिथ्म में निम्नलिखित कमजोरियां हैं:

  • यह 0 और 6 वर्णों के बीच कहीं भी उत्पन्न होगा, इस तथ्य के कारण कि फ़्लोटिंग पॉइंट्स को सख्त करते समय ट्रेलिंग शून्य हटा दिए जाते हैं।
  • यह फ्लोटिंग पॉइंट संख्याओं को कठोर करने के लिए उपयोग किए जाने वाले एल्गोरिदम पर गहराई से निर्भर करता है, जो कि क्षैतिज रूप से जटिल है। (कागज को "फ़्लोटिंग-पॉइंट नंबर कैसे प्रिंट करें" देखें ।)
  • Math.random()कार्यान्वयन के आधार पर अनुमानित ("यादृच्छिक-दिखने वाला" लेकिन वास्तव में यादृच्छिक नहीं) उत्पादन हो सकता है। परिणामस्वरूप स्ट्रिंग उपयुक्त नहीं है जब आपको विशिष्टता या अप्रत्याशितता की गारंटी देने की आवश्यकता होती है।
  • यहां तक ​​कि अगर यह 6 समान रूप से यादृच्छिक, अप्रत्याशित वर्णों का उत्पादन करता है, तो आप जन्मदिन के विरोधाभास के कारण लगभग 50,000 स्ट्रिंग्स उत्पन्न करने के बाद एक डुप्लिकेट देखने की उम्मीद कर सकते हैं । (sqrt (36 ^ 6) = 46656)
— दो बार टैप
स्रोत
276
Math.random().toString(36).substr(2, 5), क्योंकि .substring(7)यह 5 वर्णों से अधिक लंबा होता है। पूर्ण अंक, अभी भी!
— ड्रैगन
81
@ स्कोप toStringजावास्क्रिप्ट में एक संख्या प्रकार की विधि संख्या को दिए गए आधार में बदलने के लिए एक वैकल्पिक पैरामीटर लेती है। उदाहरण के लिए, यदि आप दो पास करते हैं, तो आप अपना नंबर बाइनरी में दर्शाएंगे। हेक्स (बेस 16) के समान, बेस 36 अंकों का उपयोग करता है, अंकों को 9. से परे का प्रतिनिधित्व करने के लिए। एक यादृच्छिक संख्या को आधार 36 में परिवर्तित करके, आप प्रतीत होता है यादृच्छिक अक्षरों और संख्याओं के एक समूह के साथ हवा करेंगे।
— क्रिस बेकर
76
सुंदर दिखता है लेकिन कुछ मामलों में यह खाली स्ट्रिंग उत्पन्न करता है! अगर यादृच्छिक रिटर्न 0, 0.5, 0.25, 0.125 ... परिणाम में खाली या छोटा स्ट्रिंग होगा।
— गर्टास
67
@gertas इससे बचा जा सकता है(Math.random() + 1).toString(36).substring(7);
— जॉर्ज रीथ
84
आदमी, यह लगभग बेकार है। इसे केवल 1000000 बार चलाएं और आप आमतौर पर लगभग 110000 दोहराव प्राप्त करते हैं: var मान = {}, i = 0, डुप्लिकेटाउंट = 0, वैल; जबकि (i <1000000) {val = Math.random () .String (36) .substring (7); अगर (मान [वैल]) {डुप्लिकेटाउंट ++; } मान [वैल] = 1; मैं ++; } कंसोल.लॉग ("कुल डुप्लिकेट्स", डुप्लिकेट);
— 15
463

इस तरह की चीज के लिए गणित.ऑर्गन खराब है

विकल्प 1

यदि आप इस सर्वर को करने में सक्षम हैं , तो क्रिप्टो मॉड्यूल का उपयोग करें -

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

// "bb5dc8842ca31d4603d6aa11448d1654"

परिणामस्वरूप स्ट्रिंग आपके द्वारा उत्पन्न यादृच्छिक बाइट्स से दो बार होगी; प्रत्येक बाइट hex को एन्कोडेड 2 वर्ण है। 20 बाइट्स हेक्स के 40 अक्षर होंगे।

विकल्प 2

अगर आपको इस क्लाइंट को करना है , तो शायद uid मॉड्यूल आज़माएं -

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 ('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"
स्निपेट का विस्तार करें

अधिक जानकारी के लिए 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 ​​देखें

— धन्यवाद
स्रोत
4
बिल्कुल सही। जबकि एक UUID किसी चीज़ को ID असाइन करने के लिए ठीक है, इसे यादृच्छिक वर्णों की एक स्ट्रिंग के रूप में उपयोग करना इस (और शायद अन्य) कारणों के लिए एक महान विचार नहीं है।
— wmassingham
2
.map()विकल्प 3. Array.from(arr, dec2hex).join('')=== में कोई आवश्यकता नहीं है Array.from(arr).map(dec2hex).join('')। मुझे इन विशेषताओं से
— परिचित
6
आपको जवाब में उल्लेख करना चाहिए कि विकल्प 2 को भी काम करने के लिए नोड.जेएस की आवश्यकता है, यह शुद्ध जावास्क्रिप्ट नहीं है।
— Esko
5
अधिक क्रिप्टोग्राफिक रूप से सुरक्षित होने के बावजूद, यह वास्तव में प्रश्न की आवश्यकताओं को पूरा नहीं करता है क्योंकि यह केवल 0-9 और एफए (हेक्साडेसिमल) को आउटपुट करता है, और 0-9, एज़, एज़ेड को नहीं।
— qJake
1
क्या requireमॉड्यूल केवल सर्वर-साइड का उपयोग करने में सक्षम नहीं है ?
— aJetHorn
173

लघु, आसान और विश्वसनीय

शीर्ष 5 यादृच्छिक वर्णों की वापसी होती है, जैसा कि यहां पर दिए गए कुछ शीर्ष रेटेड उत्तरों के विपरीत है।

Math.random().toString(36).substr(2, 5);
— चाँदी का छल्ला
स्रोत
9
यदि Math.random().toString(36)5 से कम वर्णों वाली संख्या वापस आती है तो क्या होगा ?
— माइकल लिट्विन
3
ठीक है, यह @ Aperçu से एक दिलचस्प अभियोग है, मैं यह नहीं कह रहा हूं कि मैंने समाधान का आविष्कार किया है लेकिन मैं वर्षों से अपनी परियोजनाओं में इसका उपयोग कर रहा हूं। और इसका आपके द्वारा उल्लेखित टिप्पणी से कोई लेना-देना नहीं है। और मुझे पूरा यकीन है कि SO में कौन सी बात सही जगह पर सबसे उपयोगी जानकारी है और यहां तक ​​कि अगर यह पहले से ही किसी अन्य जगह पर भी मौजूद है। सौभाग्य से, ऐसा लगता है कि कम से कम 51 लोगों ने इस उत्तर को उपयोगी पाया है, आपका स्वागत है!
— सिल्वर रिंगवे
3
Math.random () रिटर्न के मामले में खाली स्ट्रिंग प्राप्त करने से बचने के लिए आप उपयोग कर सकते हैंfunction getRandomString() { var result = ''; while (!result) result = Math.random().toString(36).substring(2); return result; };
— mikep
5
@rinogo Math.random () 0 पर लौट सकते हैं लेकिन 1 डेवलपर
— pmillailla.org/en-US/docs/Web/JavaScript/Reference/…
6
मैंने इस कोड को 1,000,000,000 बार चलाया और अभी भी एक खाली स्ट्रिंग नहीं मिला: jsfiddle.net/mtp5730r मैं कहूंगा कि आप एक खाली स्ट्रिंग प्राप्त करने से बहुत सुरक्षित हैं।
— मैक्रोमैन
157

यहां डबलटैप के उत्कृष्ट उत्तर पर सुधार किया गया है । मूल में दो कमियां हैं जिन्हें यहां संबोधित किया गया है:

सबसे पहले, जैसा कि दूसरों ने उल्लेख किया है, इसमें छोटी तारों या यहां तक ​​कि एक खाली स्ट्रिंग (यदि यादृच्छिक संख्या 0 है) का उत्पादन करने की एक छोटी संभावना है, जो आपके आवेदन को तोड़ सकती है। यहाँ एक समाधान है:

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

दूसरा, मूल और समाधान दोनों उपरोक्त स्ट्रिंग आकार N को 16 वर्णों तक सीमित करते हैं। निम्नलिखित किसी भी एन के लिए आकार एन की एक स्ट्रिंग लौटाएगा (लेकिन ध्यान दें कि एन> 16 का उपयोग यादृच्छिकता में वृद्धि नहीं करेगा या टकराव की संभावना कम करेगा):

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 = 16 पर अधिकतम स्ट्रिंग लंबाई को क्रोम में मापा जाता है। फ़ायरफ़ॉक्स में यह एन = 11 है। लेकिन जैसा कि समझाया गया है, दूसरा समाधान किसी भी अनुरोध की गई स्ट्रिंग की लंबाई का समर्थन करने के बारे में है, यादृच्छिकता को जोड़ने के बारे में नहीं, इसलिए इससे बहुत फर्क नहीं पड़ता है।
  • सभी लौटाए गए तार वापस लौटने की एक समान संभावना है, कम से कम जहां तक ​​Math.random () द्वारा लौटाए गए परिणाम समान रूप से वितरित किए जाते हैं (यह किसी भी मामले में क्रिप्टोग्राफिक-शक्ति यादृच्छिकता नहीं है)।
  • आकार एन के सभी संभावित तारों को वापस नहीं किया जा सकता है। दूसरे समाधान में यह स्पष्ट है (चूंकि छोटी स्ट्रिंग को केवल डुप्लिकेट किया जा रहा है), लेकिन मूल उत्तर में भी यह सच है क्योंकि बेस -36 में रूपांतरण के बाद पिछले कुछ बिट्स मूल यादृच्छिक बिट्स का हिस्सा नहीं हो सकते हैं। विशेष रूप से, यदि आप Math.random () .String (36) के परिणाम को देखते हैं, तो आप देखेंगे कि अंतिम वर्ण समान रूप से वितरित नहीं है। फिर, लगभग सभी मामलों में यह कोई फर्क नहीं पड़ता है, लेकिन हम यादृच्छिक स्ट्रिंग के अंत के बजाय शुरुआत से अंतिम स्ट्रिंग को स्लाइस करते हैं ताकि छोटे तार (जैसे एन = 1) प्रभावित न हों।

अपडेट करें:

यहाँ कुछ अन्य कार्यात्मक-शैली वाले एक-लाइनर हैं, जिनके साथ मैं आया था। वे उपरोक्त समाधान से भिन्न हैं:

  • वे एक स्पष्ट मनमाना वर्णमाला का उपयोग करते हैं (अधिक सामान्य, और मूल प्रश्न के लिए उपयुक्त जो अपरकेस और लोअरकेस अक्षर दोनों के लिए पूछा गया था)।
  • लंबाई N के सभी तारों के वापस होने की एक समान संभावना है (अर्थात स्ट्रिंग्स में कोई पुनरावृत्ति नहीं होती है)।
  • वे एक नक्शे के कार्य पर आधारित हैं, न कि स्ट्रैसिंग (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('');

संपादित करें:

मुझे लगता है कि क्वेइते और मार्टिज़न डे मिलियानो बाद के (कुडोस!) के समान समाधान के साथ आए थे, जिसे मैंने किसी तरह याद किया। जब से वे एक नज़र में कम नहीं दिखते, मैं इसे वैसे भी छोड़ दूँगा जब कोई वास्तव में वन-लाइनर चाहता है :-)

इसके अलावा, कुछ और बाइट्स को हटाने के लिए सभी समाधानों में 'ऐरे' के साथ 'नए एरे' को बदल दिया।

— amichair
स्रोत
सिर्फ 1 क्यों नहीं जोड़ा? (Math.random()+1).toString(36).substring(7);
— 10
क्योंकि 1 जोड़ने से यहां चर्चा किए गए दो मुद्दों में से कोई भी हल नहीं होता है। उदाहरण के लिए, (1) .toString (36) .substring (7) एक खाली स्ट्रिंग पैदा करता है।
— अमीचिर
उपयोग करने Math.random().toString(36).substring(2,7)से एक अपेक्षित परिणाम मिलता है जो अधिक पसंद है.substring(2, n+2)
— जोसेफ रेक्स
Array.apply(null, {length: 5}).map(function() { return s.charAt(Math.floor(Math.random() * s.length)); }).join('')
— मुहम्मद उमेर
यह बहुत अच्छा है, लेकिन जब फ़ायरफ़ॉक्स को N = 16 के साथ निष्पादित किया जाता है, तो अंतिम ~ 6 अंक शून्य हो जाते हैं ... (लेकिन यह ओपी की इच्छा को 5 यादृच्छिक वर्णों को संतुष्ट करता है।)
— एडवर्ड नेवेल
126

सबसे कॉम्पैक्ट समाधान, क्योंकि 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));
स्निपेट का विस्तार करें

— वैलेन्टिन पॉडकामेनी
स्रोत
Math.random().toString(36).slice(-5);- क्या Math.random()लौटा 0.0?
— एक्स-रे
@ एक्स-रे, आपको मिल जाएगा "0";)
— वैलेंटाइन पोडकामेनेई
2
बिल्कुल सही। ;) और अगर Math.random()रिटर्न 0.5परिणाम है "0.i"। यकीन नहीं होता कि दूसरे किनारे मामले हैं। केवल यह इंगित करना चाहता था कि यह प्रश्न का सही उत्तर नहीं है ([a-zA-Z0-9] से 5 वर्ण)।
— एक्स-रे
2
@ एक्स-रे, मैं यह नहीं कहने जा रहा हूं कि यह सही उत्तर है, मैं सिर्फ यह कह रहा हूं कि यह @doubletap उत्तर का एक कॉम्पैक्ट संस्करण है। मैं व्यक्तिगत रूप (+new Date + Math.random())से इस मामले को रोकने के लिए उपयोग करता हूं । वैसे भी, नोट के लिए धन्यवाद।
— वैलेन्टिन पोडकामेनेई
1
इस। मुझे नहीं पता कि अन्य उत्तरों के लिए इतने कोड की आवश्यकता क्यों है
— जॉन ktejik
100

कुछ इस तरह से काम करना चाहिए

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');
— CaffGeek
स्रोत
उदाहरण का एक संस्करण यहां पाया जा सकता है: Mediacollege.com/internet/javascript/number/random.html
— डेविड
1
साथ ही बस lenएक whileलूप में सीधे
— गिरावट
धन्यवाद, मैंने अभी इस उदाहरण के एक कॉफ़ीस्क्रिप्ट भिन्नता के नीचे पोस्ट किया है: stackoverflow.com/a/26682781/262379
— क्रूज़
यदि ये यौवन के लिए उपयोग किए जा रहे हैं, तो आपको संभवतः स्वरों को हटा देना चाहिए। थोड़ा कम एन्ट्रापी, लेकिन बहुत अधिक सुरक्षित क्योंकि आप किसी भी ऐसे शब्द को उत्पन्न नहीं कर सकते जो लोगों को अपमानित कर सकते हैं। यही कारण है कि मुझे यह पसंद है, क्योंकि मैं अपने चरित्र स्ट्रिंग में भेज सकता हूं। बहुत बढ़िया।
— नैट बन्नी
सुंदर कट्टर, मेरे लिए काम किया, धन्यवाद!
— जकी मोहम्मद
73

Es6 प्रसार ऑपरेटर के साथ एक नया संस्करण :

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

  • 30मनमाना संख्या, आप किसी भी टोकन लंबाई आप चाहते हैं चुन सकते हैं है
  • 36आप के लिए पारित कर सकते हैं अधिकतम मूलांक संख्या है numeric.toString () , जिसका अर्थ है सभी नंबरों और az छोटे अक्षरों
  • 2यादृच्छिक स्ट्रिंग जो इस तरह दिखता है से 3th सूचकांक लेने के लिए प्रयोग किया जाता है: "0.mfbiohx64i", हम के बाद किसी भी सूचकांक ले सकता है0.
— या डुआन
स्रोत
क्या आप समझाएँगे? विशेष रूप से क्यों आप 36 toString () पास करते हैं और आप 3 तत्व क्यों चुनते हैं?
— वुज़ डे
5
इस सबसे अच्छा समाधान है
— overcomer
अच्छा है, लेकिन इस समाधान में प्रश्न के रूप में [AZ] अक्षर शामिल नहीं हैं, केवल [a-z0-9]
— नाहुएल ग्रीको
71 

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));
स्निपेट का विस्तार करें

— Kennebec
स्रोत
मुझे यह सबसे अच्छा लगता है। आप अतिरिक्त मापदंडों को स्वीकार करने के लिए आसानी से संशोधित कर सकते हैं और केवल अंक, कम या कैप वापस कर सकते हैं। मुझे नहीं लगता कि अल्ट्रा-संपीड़ित शैली आवश्यक हैwhile(s.length< L) s+= randomchar();
— mastalasta
3
यह भी while(L--)करेंगे
— vsync
1
'A'.charCodeAt(0)मैजिक नंबर 55(और इसी तरह 61) के बजाय अधिक मजबूत उपयोग करने के लिए बेहतर है । विशेष रूप से, मेरे मंच पर वैसे भी, जादुई संख्या जो वापस आती है 65। यह कोड बेहतर होने के साथ ही स्व-दस्तावेज भी होगा।
— ग्रुमड्रिग
मैंने आपके कार्यान्वयन का अनुकूलित (46 बाइट्स छोटा) वैरिएंट यहाँ बनाया: stackoverflow.com/a/52412162
— वारुयामा
सौभाग्य है कि कभी भी… Thats क्या webpack के लिए है!
— डायलन वॉटसन
61

रैंडम स्ट्रिंग जेनरेटर (अल्फा-न्यूमेरिक | अल्फा | न्यूमेरिक)

/**
 * 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"
स्निपेट का विस्तार करें

यद्यपि उपरोक्त वांछित ए / एन, ए, एन आउटपुट के लिए अतिरिक्त चेक का उपयोग करता है , चलो इसे बेहतर समझ के लिए आवश्यक (केवल अल्फा-न्यूमेरिक) के लिए तोड़ दें:

  • एक फ़ंक्शन बनाएं जो एक तर्क स्वीकार करता है (यादृच्छिक स्ट्रिंग परिणाम की वांछित लंबाई)
  • var str = "";यादृच्छिक वर्णों को समेटने के लिए एक रिक्त स्ट्रिंग बनाएं
  • लूप के अंदर 0 से 61 तक एक randइंडेक्स नंबर बनाएं (0..9 + A..Z + a..z = 62)
  • समायोजित करने / ठीक करने के लिए एक सशर्त तर्क बनाएं (क्योंकि यह 0..61 है) इसे सही संख्या और संबंधित वर्ण वापस पाने के लिए कुछ संख्या (नीचे उदाहरण देखें) के द्वारा बढ़ाएँ ।randCharCode
  • लूप के अंदर strएक को समेटनाString.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 ;

ऊपर दिए गए स्पष्टीकरण से, यहाँ परिणामी अल्फा-न्यूमेरिक स्निपेट है :

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))
स्निपेट का विस्तार करें

— रोको सी। बुल्जन
स्रोत
33

सबसे सरल तरीका है: 

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

यह वर्तमान समय के आधार पर 5 वर्णों के यादृच्छिक तार उत्पन्न करता है। उदाहरण आउटपुट है 4mtxjया 4mv90या4mwp1

इसके साथ समस्या यह है कि यदि आप इसे एक ही सेकंड में दो बार कॉल करते हैं, तो यह एक ही स्ट्रिंग उत्पन्न करेगा।

सुरक्षित तरीका है: 

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

यह हमेशा अलग-अलग 4 या 5 अक्षरों का एक यादृच्छिक स्ट्रिंग उत्पन्न करेगा। उदाहरण आउटपुट है की तरह 30jzmया 1r591या4su1a

दोनों तरह से पहला भाग एक यादृच्छिक संख्या उत्पन्न करता है। .toString(36)भाग इसके बारे में एक base36 (alphadecimal) प्रतिनिधित्व करने के लिए संख्या डाली।

— MasqueradeCircus
स्रोत
मुझे पूरा यकीन नहीं है कि यह सवाल का जवाब कैसे देता है; यह 7 साल पुराना सवाल है, जिसमें पहले से ही कई वैध जवाब हैं। यदि आप एक नया उत्तर प्रदान करना चुनते हैं, तो आपको यह सुनिश्चित करने के लिए अतिरिक्त सावधानी बरतनी चाहिए कि आपका उत्तर अच्छी तरह से समझाया और प्रलेखित है।
— क्लेम
1
यदि आप दिनांक का उपयोग करते हैं, तो आप इसका उपयोग क्यों नहीं करते हैं:(+new Date).toString(36)
— ज्येष्ठ उपसर्ग
मुझे आपका यादृच्छिक संख्या समाधान पसंद है लेकिन 9e6 5 अंक (36 ^ 5) के लिए 60.4 लाख लोगों पर केवल 9 लाखों संभावनाएं देता है ताकि आप इसे (0|Math.random()*6.04e7).toString(36)कवर करने के साथ बदल सकें।
— Le Droid
1
मैं एक कम-से-संभव दिनचर्या (एक कोड डेमो के लिए) के साथ एक लंबे समय तक यादृच्छिक स्ट्रिंग चाहता था जिसे क्रिप्टोग्राफिक रूप से आश्चर्यजनक होने की आवश्यकता नहीं है, बस कुछ अच्छा यादृच्छिक दृश्य "फ़्लफ़" का उत्पादन करें। मुझे यह उत्तर सबसे अच्छा लगता है (आपका दूसरा), इसलिए धन्यवाद। मेरे दो सेंट: मैं इसे एक कम कीस्ट्रोके के साथ लघुता के लिए हरा सकता हूं, और यह आमतौर पर 13 यादृच्छिक वर्णों (एक अवधि के बिना) का उत्पादन करेगा (Math.random()*1e20).toString(36):।
— एंड्रयू विल्म्स
इस उत्तर के साथ मेरे पास एक गुण यह है कि यह [AZ] का उपयोग नहीं करेगा जो कि मूल प्रश्न में होता है।
— user.friendly
22

यहाँ कुछ आसान एक लाइनर हैं। 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"]();});
— bendytree
स्रोत
20

मुझे पता है कि सभी को यह पहले से ही मिल गया है, लेकिन मुझे ऐसा महसूस हुआ कि इस तरह से सबसे अधिक हल्के तरीके से संभव हो सकता है (कोड पर प्रकाश, सीपीयू नहीं):

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

console.log(rand(5));
स्निपेट का विस्तार करें

आपके सिर को चारों ओर लपेटने में थोड़ा समय लगता है, लेकिन मुझे लगता है कि यह वास्तव में दिखाता है कि जावास्क्रिप्ट का सिंटैक्स कितना भयानक है।

— रॉड्रिक
स्रोत
20
यदि आप कोड को छोटा रखने की कोशिश कर रहे हैं, current = current ? current : '';तो जब आप लिख सकते हैं तो क्यों लिखें current = current || '';
— CaffGeek
9
चूँकि हम यहाँ माइक्रो ऑप्टिमाइज़ेशन की बात कर रहे हैं, मैं वास्तव में वैरिएबल असाइनमेंट को पूरी तरह से छोड़ने की सलाह current || (current = '');
— दूंगा
"अच्छा" का उपयोग करते समय सूक्ष्म अनुकूलन का प्रयास करना, लेकिन संसाधन को पुनरावर्ती एल्गोरिथ्म को बर्बाद करना कोई मतलब नहीं है :-) लूप के लिए अभी भी जावास्क्रिप्ट में सबसे अच्छा है और पुनरावृत्ति के बड़े समय तक धड़कता है, जब तक कि रनिंग अपराधों के अनुकूलन कोड में वास्तव में बड़ी प्रगति नहीं होती है।
— मोर
17

यदि आप लोदाश या अंडरस्कोर का उपयोग कर रहे हैं , तो यह इतना सरल है:

var randomVal = _.sample('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', 5).join('');
— विनीत
स्रोत
6
Lodash का उपयोग करता है_.sampleSize('asdfgh',5).join('')
— Marlo
2
यह वास्तव में एक अच्छा समाधान नहीं है, क्योंकि डॉक्स के अनुसार प्रत्येक वर्ण एक अद्वितीय सूचकांक से है। इसका मतलब है कि यह वास्तव में यादृच्छिक नहीं है, क्योंकि कोई भी चरित्र कभी भी दोहराएगा नहीं।
— random_user_name 21
16

आवश्यकता को पूरा करने के लिए [a-zA-Z0-9] और लंबाई = 5 का उपयोग करें

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

लोअरकेस अक्षर, अपरकेस अक्षर और संख्याएँ घटित होंगी।

— सर्जियो कैब्रल
स्रोत
1
मुझे लगता है, Math.random () बहुत कुछ वर्णों के साथ एक base64- स्ट्रिंग के लिए नेतृत्व कर सकता है।
— लीफ
14

मामले में किसी को भी एक लाइनर में दिलचस्पी है (हालांकि आपकी सुविधा के लिए इस तरह के स्वरूपित नहीं) जो एक ही बार में स्मृति आवंटित करता है (लेकिन ध्यान दें कि छोटे तारों के लिए यह वास्तव में कोई फर्क नहीं पड़ता) यहां यह है कि यह कैसे करना है:

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

आप अपनी 5इच्छित स्ट्रिंग की लंबाई से बदल सकते हैं। इस पद के लिए @AriyaHidayat का धन्यवाद कि इसmap समारोह के समाधान के लिए विरल सरणी पर काम नहीं कर रहा है Array(5)।

— मार्टिज़न डे मिलियानो
स्रोत
13
प्रत्येक जावास्क्रिप्ट प्रोग्राम एक 'वन-लाइनर' है, यदि आप इसे इस तरह से प्रारूपित करते हैं
— hacklikecrack
13

यहां मैंने जो विधि बनाई है।
यह एक स्ट्रिंग बनाएगा जिसमें अपरकेस और लोअरकेस अक्षर दोनों होंगे।
इसके अलावा, मैंने उस फ़ंक्शन को शामिल किया है जो एक अल्फ़ान्यूमेरिक स्ट्रिंग भी बनाएगा।

काम के उदाहरण:
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)));
}
— एडम
स्रोत
इस फ़ंक्शन के साथ, आपको कभी भी 'M' से बड़ा अक्षर नहीं मिल सकता है या 'n' की तुलना में लोअरकेस अक्षर कम होगा।
— एर्केनील्डिज़
वास्तव में? उह! शायद इसे और अधिक परीक्षण करेंगे। हम्म, हालांकि, इसे एक यादृच्छिक स्ट्रिंग दिया गया है और हम वास्तव में परवाह नहीं करते हैं कि इसमें कौन से अक्षर हैं (जब तक वे यादृच्छिक हैं) तब भी यह वही करता है जो हम इसे करना चाहते हैं जो यह सब मायने रखता है लेकिन हां, एक प्रदान करेगा उन्नयन, धन्यवाद।
— एडम
12

मान लें कि आप अंडरस्कोरज का उपयोग करते हैं, तो यह केवल दो लाइनों में यादृच्छिक स्ट्रिंग उत्पन्न करना संभव है:

var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
var random = _.sample(possible, 5).join('');
— Tiktak
स्रोत
6
यह कर देगा लौटे मूल्य सभी अद्वितीय आकर्षण है। इसके अलावा, स्ट्रिंग की लंबाई को सीमित किया जा सकता है।
— यिफु
10

तेज और बेहतर एल्गोरिथ्म। वर्दी की गारंटी नहीं है (टिप्पणी देखें)।

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;
}
— यारोस्लाव
स्रोत
2
महान जवाब, लेकिन संभावना एक समान नहीं है। 62 संभावित वर्ण हैं और crypto.getRandomValues256 अद्वितीय मानों में से एक देता है। क्योंकि 256 को 62 से विभाजित नहीं किया जाता है, इसलिए आप वर्ण AH प्राप्त करने की थोड़ी अधिक संभावना रखते हैं। मुझे लगता है कि सबसे अच्छा समाधान यह है कि YouTube ने क्या किया है, और सिर्फ 2 अतिरिक्त वर्ण (संभवतः -और _) को charset में जोड़ें। वैसे भी, महान काम - इस जवाब को बहुत अधिक प्यार की आवश्यकता है :)
— TeWu
जोड़ना - और _ एक बेहतरीन विचार है क्योंकि इससे आपको पूरा url-safe base64 सेट मिल जाएगा
— काउबर्ट
8

के लिए प्रतिक्रियाओं के साथ समस्या "मैं यादृच्छिक तार की जरूरत है" सवाल (जो भी भाषा में) हर समाधान की एक त्रुटिपूर्ण प्राथमिक विनिर्देशन का उपयोग करता व्यावहारिक रूप है स्ट्रिंग की लंबाई । सवाल खुद ही शायद ही कभी प्रकट करते हैं कि यादृच्छिक तार की आवश्यकता क्यों है, लेकिन मैं चुनौती देता हूं कि आपको शायद ही कभी लंबाई के यादृच्छिक तार की आवश्यकता होगी, कहते हैं 8. आपको क्या आवश्यकता है कुछ अद्वितीय तार की संख्या है , उदाहरण के लिए, किसी उद्देश्य के लिए पहचानकर्ता के रूप में उपयोग करने के लिए।

कड़ाई से अद्वितीय स्ट्रिंग्स प्राप्त करने के लिए दो प्रमुख तरीके हैं: नियतात्मक रूप से (जो यादृच्छिक नहीं है) और स्टोर / तुलना (जो कि शानदार है)। हम क्या करें? हम भूत छोड़ देते हैं। हम इसके बजाय संभाव्य विशिष्टता के साथ जाते हैं । यही है, हम स्वीकार करते हैं कि कुछ (हालांकि छोटा) जोखिम है कि हमारे तार अद्वितीय नहीं होंगे। यह वह जगह है जहां टकराव की संभावना और एन्ट्रॉपी को समझना मददगार है।

इसलिए मैं पुनरावृत्ति की आवश्यकता को फिर से दोहराऊंगा क्योंकि दोहराने के एक छोटे जोखिम के साथ तार की कुछ संख्या की आवश्यकता होती है। एक ठोस उदाहरण के रूप में, मान लें कि आप 5 मिलियन आईडी की क्षमता उत्पन्न करना चाहते हैं। आप प्रत्येक नए स्ट्रिंग को स्टोर और तुलना नहीं करना चाहते हैं, और आप चाहते हैं कि वे यादृच्छिक हो, इसलिए आप दोहराने के कुछ जोखिम को स्वीकार करते हैं। उदाहरण के लिए, मान लें कि एक ट्रिलियन रिपीट के 1 से कम जोखिम है। तो आपको किस लंबाई की स्ट्रिंग की आवश्यकता है? ठीक है, यह प्रश्न अस्वाभाविक है क्योंकि यह इस्तेमाल किए गए पात्रों पर निर्भर करता है। लेकिन इससे भी महत्वपूर्ण बात यह है कि यह गुमराह है। आपको जो चाहिए वह स्ट्रिंग्स के एन्ट्रापी का एक विनिर्देश है, न कि उनकी लंबाई। एन्ट्रापी सीधे कुछ संख्याओं में दोहराने की संभावना से संबंधित हो सकती है। स्ट्रिंग की लंबाई नहीं हो सकती।

और यह वह जगह है जहां EntropyString जैसी लाइब्रेरी मदद कर सकती है। रैंडम आईडी उत्पन्न करने के लिए जिसमें 5 मिलियन स्ट्रिंग्स में दोहराने के ट्रिलियन संभावना में 1 से कम है 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"

उपयोग किए गए वर्ण सेट में वर्णों की कुल संख्या के अंतर के कारण स्ट्रिंग की लंबाई में अंतर पर ध्यान दें। संभावित तारों की निर्दिष्ट संख्या में दोहराने का जोखिम समान है। स्ट्रिंग की लंबाई नहीं है। और सबसे अच्छा, दोहराने का जोखिम और तारों की संभावित संख्या स्पष्ट है। स्ट्रिंग की लंबाई के साथ कोई अनुमान नहीं है।

— डिंगो आकाश
स्रोत
7 
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 ।

— Gajus
स्रोत
मेरे लिए यह हमेशा के साथ यादृच्छिक तार उत्पन्न करता है strLength - 1 : - /
— xanderiel
3
से स्विच कर रहा --strLengthहैstrLength--मेरे लिए इसे ठीक करना।
— xanderiel
7

आप मदों की एक सरणी के माध्यम से लूप कर सकते हैं और फिर से उन्हें एक स्ट्रिंग चर में जोड़ सकते हैं, उदाहरण के लिए यदि आप एक यादृच्छिक डीएनए अनुक्रम चाहते थे:

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));
स्निपेट का विस्तार करें

— एंडी
स्रोत
6

मुझे लोअरकेस और अपरकेस वर्णों के समर्थन के लिए एक स्वच्छ समाधान नहीं मिला।

लोअरकेस केवल समर्थन:

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

अपनी ज़रूरत की लंबाई में समायोजित करने के लिए 5में बदलें substr(2, 5)।

— ravishi
स्रोत
6

एक लाइन:

Array(15).fill(null).map(() => Math.random().toString(36).substr(2)).join('')
// Outputs: 0h61cbpw96y83qtnunwme5lxk1i70a6o5r5lckfcyh1dl9fffydcfxddd69ada9tu9jvqdx864xj1ul3wtfztmh2oz2vs3mv6ej0fe58ho1cftkjcuyl2lfkmxlwua83ibotxqc4guyuvrvtf60naob26t6swzpil
— एंड्रयू
स्रोत
इसे कम Array(15)मूल्य में छोटे परिवर्तन तर्क बनाने के लिए। उदाहरण के लिए: Array(4)।
— एंड्रयू
मैं वास्तव में इस समाधान को प्यार करता हूं, सरल और स्पष्ट। यह 0 और 1 के बीच 15 यादृच्छिक संख्या उत्पन्न कर रहा है, हेक्साडेसिमल उत्पन्न करता है, और फिर पहले दो वर्ण हटाता है। अंत में यह सभी को एक साथ मिला रहा है।
— सिसकिया
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>
— विग्नेश
स्रोत
5

इस तरह से कुछ के बारे में कैसे: Date.now().toString(36) बहुत यादृच्छिक नहीं है, लेकिन छोटी और काफी अनोखी हर बार जब आप इसे कहते हैं।

— Swergas
स्रोत
1
दुर्भाग्य से यह अद्वितीय नहीं होगा, क्योंकि इसमें Date.now()केवल मिलीसेकंड रिज़ॉल्यूशन है। जब एक साधारण लूप में चलते हैं, उदाहरण के लिए, आपको बहुत सारे डुप्लिकेट मिलेंगे। for (let i = 0; i < 10; ++i) { console.log(Date.now().toString(36)); }।
— नट
5

केस असंवेदनशील अक्षरांकीय चार्ट:

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
स्निपेट का विस्तार करें

— अली
स्रोत
यह उत्तर मेरे उपयोग के मामले के लिए अधिक उपयुक्त है। यदि आप var possibleस्वीकृत उत्तर में एक जोड़ सकते हैं तो यह अच्छा होगा , इसलिए फ़ंक्शन का परिणाम अधिक कॉन्फ़िगर करने योग्य है।
— डेनिस.शबोलोटनी
4

10 वर्ण लंबे स्ट्रिंग उत्पन्न करें। लंबाई पैरामीटर (डिफ़ॉल्ट 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;
}
— ropsiU
स्रोत
4

आप कोडरन का उपयोग कर सकते हैं । यह दिए गए पैटर्न के अनुसार यादृच्छिक कोड उत्पन्न करने के लिए एक पुस्तकालय है। #ऊपरी और निचले वर्णों के साथ ही अंकों के लिए प्लेसहोल्डर के रूप में उपयोग करें :

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

अन्य प्लेसहोल्डर हैं जैसे Aअपरकेस अक्षर या 9अंकों के लिए।

जो उपयोगी हो सकता है, वह है कॉलिंग .next() आपको हमेशा एक अनूठा परिणाम देगी ताकि आपको डुप्लिकेट के बारे में चिंता न करनी पड़े।

यहां एक डेमो एप्लिकेशन है जो अद्वितीय यादृच्छिक कोड की एक सूची बनाता है ।

पूर्ण प्रकटीकरण: मैं कोडरैन का लेखक हूं।

— लुकाज़ विकटोर
स्रोत
कोई नहीं नहीं - देशी तरीकों का उपयोग करें।
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.