javascript - हरण - हिंदी में जावास्क्रिप्ट परिचय




जावास्क्रिप्ट में यादृच्छिक स्ट्रिंग/अक्षर जेनरेट करें (20)

यादृच्छिक स्ट्रिंग जेनरेटर (अल्फा-न्यूमेरिक | अल्फा | न्यूमेरिक)

/**
 * RANDOM STRING GENERATOR
 *
 * Info:      http://stackoverflow.com/a/27872144/383904
 * Use:       randomString(length [,"A"] [,"N"] );
 * Default:   return a random alpha-numeric string
 * Arguments: If you use the optional "A", "N" flags:
 *            "A" (Alpha flag)   return random a-Z string
 *            "N" (Numeric flag) return random 0-9 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;
}
randomString(10);        // "4Z8iNQag9v"
randomString(10, "A");   // "aUkZuHNcWw"
randomString(10, "N");   // "9055739230"

मज़े करो। जेएसबीन डेमो

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

  • एक ऐसा फ़ंक्शन बनाएं जो तर्क स्वीकार करता है (यादृच्छिक स्ट्रिंग परिणाम की वांछित लंबाई)
  • var str = ""; जैसी खाली स्ट्रिंग बनाएं var str = ""; यादृच्छिक पात्रों को संयोजित करने के लिए
  • एक लूप के अंदर 0 से 61 (0..9 + ए..जेड + ए..जे = 62) से rand इंडेक्स नंबर बनाएं
  • सही CharCode संख्या और संबंधित कैरेक्टर को वापस पाने के लिए कुछ संख्या (नीचे उदाहरण देखें) द्वारा इसे बढ़ाने के लिए rand समायोजित / ठीक करने के लिए एक सशर्त तर्क बनाएं (चूंकि यह 0..61 है)।
  • एक String.fromCharCode( incremented rand ) लिए लूप concatenate के अंदर। String.fromCharCode( incremented rand )

आइए कैरेक्टर टेबल और उनकी श्रेणियों को चित्रित करें:

_____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 से एक रेंज देता है (हमें क्या चाहिए)। सही 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     |

उपरोक्त तालिका से सशर्त ऑपरेशन तर्क :

   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) ); // "7GL9F0ne6t"

या यदि आप करेंगे:

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

मैं सेट [a-zA-Z0-9] सेट से यादृच्छिक रूप से चुने गए वर्णों से बना 5 वर्ण स्ट्रिंग चाहता हूं।

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


छोटा, आसान और भरोसेमंद

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

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

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

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

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

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

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

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

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


इस कॉम्पैक्ट छोटी चाल के बारे में कैसे?

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

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

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

आपको Array.apply की आवश्यकता है। खाली सरणी को अपरिभाषित की सरणी में Array.apply वहां क्लिक करें।

यदि आप ES2015 के लिए कोडिंग कर रहे हैं, तो सरणी बनाना थोड़ा आसान है:

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

एक कार्यात्मक दृष्टिकोण। यह उत्तर केवल व्यावहारिक है यदि कार्यात्मक पूर्वापेक्षाएँ आपके ऐप के अन्य हिस्सों में लीवरेज की जा सकती हैं। प्रदर्शन शायद जंक है, लेकिन यह लिखने के लिए बहुत मजेदार था।

// functional prerequisites
const U = f=> f (f)
const Y = U (h=> f=> f (x=> h (h) (f) (x)))
const comp = f=> g=> x=> f (g (x))
const foldk = Y (h=> f=> y=> ([x, ...xs])=>
  x === undefined ? y : f (y) (x) (y=> h (f) (y) (xs)))
const fold = f=> foldk (y=> x=> k=> k (f (y) (x)))
const map = f=> fold (y=> x=> [...y, f (x)]) ([])
const char = x=> String.fromCharCode(x)
const concat = x=> y=> y.concat(x)
const concatMap = f=> comp (fold (concat) ([])) (map (f))
const irand = x=> Math.floor(Math.random() * x)
const sample = xs=> xs [irand (xs.length)]

// range : make a range from x to y; [x...y]
// Number -> Number -> [Number]
const range = Y (f=> r=> x=> y=>
  x > y ? r : f ([...r, x]) (x+1) (y)
) ([])

// srand : make random string from list or ascii code ranges
// [(Range a)] -> Number -> [a]
const srand = comp (Y (f=> z=> rs=> x=>
  x === 0 ? z : f (z + sample (rs)) (rs) (x-1)
) ([])) (concatMap (map (char)))

// idGenerator : make an identifier of specified length
// Number -> String
const idGenerator = srand ([
  range (48) (57),  // include 0-9
  range (65) (90),  // include A-Z
  range (97) (122)  // include a-z
])

console.log (idGenerator (6))  //=> TT688X
console.log (idGenerator (10)) //=> SzaaUBlpI1
console.log (idGenerator (20)) //=> eYAaWhsfvLDhIBID1xRh

मेरी राय में, idGeneratorजादुई, बहुत-बहुत-चीजें काम किए बिना स्पष्टता को हरा करना मुश्किल है ।

मामूली सुधार हो सकता है

// ord : convert char to ascii code
// Char -> Number
const ord = x => x.charCodeAt(0)

// idGenerator : make an identifier of specified length
// Number -> String
const idGenerator = srand ([
  range (ord('0')) (ord('9')),
  range (ord('A')) (ord('Z')),
  range (ord('a')) (ord('z'))
])

इसके साथ मजे करो। मुझे बताएं कि आप क्या पसंद करते हैं / सीखें ^ _ ^


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

function rndStr() {
    x=Math.random().toString(36).substring(7).substr(0,5);
    while (x.length!=5){
        x=Math.random().toString(36).substring(7).substr(0,5);
    }
    return x;
}

परिणाम के साथ आपको सतर्क करने वाला एक jsfiddle यहां है: http://jsfiddle.net/pLJJ7/


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

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

    const possible =
        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    let result = '';
    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);
        }
    }

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

    return result;
}

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

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

console.log(rand(5));

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


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

function makeid() {
  var text = "";
  var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

  for (var i = 0; i < 5; i++)
    text += possible.charAt(Math.floor(Math.random() * possible.length));

  return text;
}

console.log(makeid());


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

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

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


यदि पुस्तकालय एक संभावना है, तो Chance.js मदद की हो सकती है: http://chancejs.com/#string


यहां कुछ आसान एक लाइनर हैं। लंबाई निर्धारित करने के लिए 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"]();});

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

कार्य उदाहरण:
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)));
}

सबसे आसान तरीका यह है:

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

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

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

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

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

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

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


सबसे कॉम्पैक्ट समाधान, क्योंकि slice substring से छोटा है। स्ट्रिंग के अंत से घटाना developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… फ़ंक्शन द्वारा उत्पन्न फ़्लोटिंग पॉइंट प्रतीक से बचने की अनुमति देता है:

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

या और भी

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

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

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


एएस 6 फैल ऑपरेटर के साथ एक नया संस्करण:

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

  • 30 मनमानी संख्या है, आप अपनी इच्छित टोकन लंबाई चुन सकते हैं
  • 36 अधिकतम रेडिक्स संख्या है जिसे आप numeric.toString() पास कर सकते हैं, जिसका अर्थ है कि सभी संख्याएं और numeric.toString() लोअरकेस अक्षर
  • 3 को यादृच्छिक स्ट्रिंग से तीसरा नंबर चुनने के लिए उपयोग किया जाता है जो इस तरह दिखता है: "0.mfbiohx64i" , हम 0. बाद कोई इंडेक्स ले सकते हैं 0.

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

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

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

दूसरा, मूल और समाधान दोनों ऊपर स्ट्रिंग आकार एन से 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 और एज़ का उपयोग करें।
  3. शून्य के साथ पैड (पहला मुद्दा हल करता है)।
  4. अग्रणी '0.' से टुकड़ा उपसर्ग और अतिरिक्त पैडिंग शून्य।
  5. इसमें कम से कम एन अक्षर होने के लिए स्ट्रिंग को पर्याप्त बार दोहराएं (डेलिमीटर के रूप में उपयोग की जाने वाली छोटी यादृच्छिक स्ट्रिंग के साथ खाली तारों में शामिल हों)।
  6. स्ट्रिंग से बिल्कुल एन अक्षर स्लाइस।

आगे विचार:

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

अद्यतन करें:

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

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

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

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

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


"12345".split('').map(function(){return 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'.charAt(Math.floor(62*Math.random()));}).join('');

//or

String.prototype.rand = function() {return this.split('').map(function(){return 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'.charAt(Math.floor(62*Math.random()));}).join('');};

पहली / कॉलिंग स्ट्रिंग की लंबाई के साथ एक यादृच्छिक अल्फा-न्यूमेरिक स्ट्रिंग उत्पन्न करेगा


Math.random().toString(36).substring(7);





random