Generuokite atsitiktines eilutes / simbolius javascript

Man reikia 5 simbolių eilutės, kurią sudaro simboliai, atsitiktinai parinkti iš rinkinio [a-zA-Z0-9] .

Koks yra geriausias būdas tai padaryti naudojant „JavaScript“?

1330 m
29 авг. nustatė Tom Lehman rugpjūčio 29 d 2009-08-29 00:14 '09 ne 0:14 2009-08-29 00:14
ответ 61 atsakymas
  • 1
  • 2
  • 3

Manau, kad tai bus jums naudinga:

1835 m
29 авг. atsakymą pateikė csharptest.net 29 rug . 2009-08-29 00:21 '09 ne 0:21 2009-08-29 00:21

„Kaip teisingai spausdinti slankiojo kablelio numerius .  ) 
  • Math.random() gali sukurti nuspėjamą („atsitiktinį“, bet ne atsitiktinį) rezultatą, priklausomai nuo įgyvendinimo. Gauta eilutė nėra tinkama, kai reikia garantuoti unikalumą ar nenuspėjamumą.
  • Net jei ji pagamino 6 vienodus atsitiktinius, nenuspėjamus simbolius, galite tikėtis, kad po gimtadienio paradokso atsiras tik apie 50 000 eilučių. (sqrt (36 ^ 6) = 46656)
  • 1938 m
    10 нояб. atsakymas duotas dvigubai 2011-11-10 21:12 '11, 21:12, 2011-11-10 21:12

    Math.random yra tokio pobūdžio dalykas

    1 galimybė

    Jei galite tai padaryti serverio pusėje, tiesiog naudokite šifravimo modulį

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

    Gauta eilutė bus dvigubai ilgesnė nei atsitiktiniai baitai, kuriuos sukuriate; kiekvienas baitas, užkoduotas šešiakampiu, yra 2 simboliai. 20 baitų bus 40 simbolių šešioliktainiu formatu.


    2 galimybė

    Jei reikia tai padaryti kliento pusėje, galbūt išbandykite „uuid“ modulį

     var uuid = require("uuid"); var id = uuid.v4(); // "110ec58a-a0f2-4ac4-8393-c866d813b8d1" 

    3 galimybė

    Jei reikia atlikti šią kliento pusę ir jums nereikia palaikyti senų naršyklių, galite tai padaryti be priklausomybės

    295
    02 янв. atsakymą pateikė user633183 02 jan. 2015-01-02 22:18 '15, 10:18 pm 2015-01-02 22:18

    Trumpas, paprastas ir patikimas

    Grąžina lygiai 5 atsitiktinius simbolius, skirtingai nuo kai kurių populiariausių čia rastų atsakymų.

     Math.random().toString(36).substr(2, 5); 
    143
    27 июля '16 в 23:24 2016-07-27 23:24 atsakymas pateikiamas „ Sidabrinis žiedas“ liepos 27 d. 16 d. 23:24 2016-07-27 23:24

    Čia tobulinimas padvigubina optimalų atsakymą . Originale yra du trūkumai, kurie aptariami čia:

    Pirma, kaip pažymėjo kiti, ji turi nedidelę galimybę sukurti trumpas eilutes arba net tuščią eilutę (jei atsitiktinis skaičius yra 0), o tai gali sutrikdyti jūsų taikomąją programą. Čia pateikiamas sprendimas:

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

    Antra, tiek originalūs, tiek pirmiau minėti sprendimai apriboja eilutės N dydį iki 16 simbolių. Toliau bus rodoma N dydžio eilutė bet kuriam N (tačiau atkreipkite dėmesį, kad naudojant N> 16 nepadidins atsitiktinumo arba nesumažins susidūrimo tikimybės):

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

    Paaiškinimas:

    • Pasirinkite atsitiktinį skaičių intervale [0,1], ty tarp 0 (imtinai) ir 1 (išskirtinis).
    • Konvertuokite numerį į pagrindinę eilutę 36, ty, naudodami simbolius 0-9 ir az.
    • Aplankas su nuliais (išsprendžia pirmąją problemą).
    • Iškirpkite viršų „0.“ priešdėlis ir papildomi nuliai.
    • Pakartokite eilutę pakankamai laiko, kad joje būtų bent N simboliai (derinant tuščias eilutes su trumpesne atsitiktine seka, naudojama kaip ribotuvas).
    • Iš eilės pieškite tiksliai N simbolius.

    Kitos mintys:

    • Šis sprendimas nenaudojamas didžiosiomis raidėmis, tačiau beveik visais atvejais (be numatyto tikslo) nesvarbu.
    • Maksimalus eilutės ilgis N = 16 pirminiame atsakyme matuojamas „Chrome“. „Firefox“ tai yra N = 11. Tačiau, kaip paaiškinta, antrasis sprendimas yra paremti bet kokį norimą eilutės ilgį, o ne pridėti atsitiktinumą, todėl tai nėra didelis dalykas.
    • Visos grįžtančios eilutės turi vienodą grįžimo tikimybę, bent jau tol, kol Math.random () grąžinti rezultatai bus tolygiai paskirstyti (tai bet kuriuo atveju nėra kriptografinė jėga).
    • Ne visas galimas N dydžio eilutes galima grąžinti. Antrajame sprendime tai yra akivaizdu (nes mažesnė linija yra tiesiog dubliuojama), bet ir pirminiame atsakyme, tai yra tiesa, nes konvertuojant į 36 bazę paskutiniai keli bitai negali būti originalių atsitiktinių bitų dalis. Visų pirma, jei žiūrite į Math.random () rezultatą. „ToString“ (36) pastebėsite, kad paskutinis simbolis nėra tolygiai paskirstytas. Vėlgi, beveik visais atvejais nesvarbu, bet mes supjaustome galutinę liniją nuo pradžios, o ne atsitiktinės linijos pabaigoje, kad nebūtų paveiktos trumpos linijos (pvz., N = 1).

    Atnaujinti:

    Štai keletas kitų funkcinių stilių su vienu sluoksniu, kurį atėjau. Jie skiriasi nuo pirmiau pateikto sprendimo:

    • Jie naudoja aiškią savavališką abėcėlę (bendresnę ir tinkančią pradiniam klausimui, kuris prašo ir didžiųjų, ir mažųjų raidžių).
    • Visos N ilgio eilutės turi vienodą grįžimo tikimybę (t. Y. Eilutės nėra dvigubos).
    • Jie grindžiami kortelės funkcija, o ne „ToString“ (36) triku, todėl jie tampa suprantamesni ir suprantamesni.

    Taigi, pasakykime savo pasirinktą abėcėlę

     var s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; 

    Tuomet šie du elementai yra vienodi, todėl galite pasirinkti, kas jums patogesnė:

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

    ir

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

    Redaguoti:

    Man atrodo, kad qubyte ir Martijn de Milliano pateikė sprendimus, panašius į paskutinius (garbės!), Kuriuos aš kažkaip praleidau. Kadangi jie neatrodo trumpi, aš vis tiek čia apsistosiu, jei kas nors tikrai nori vienos eilutės: -)

    Be to, visuose sprendimuose „naują masyvą“ pakeiskite „Array“, kad sujungtumėte dar kelis baitus.

    139
    14 нояб. Atsakymas pateikiamas amichair 14 nov. 2013-11-14 00:18 '13, 0:18, 2013-11-14 00:18

    Kažkas panašaus turėtų veikti.

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

    Skambinkite su numatytuoju simbolių rinkiniu [a-zA-Z0-9] arba atsiųskite jį sau:

     var randomValue = randomString(5); var randomValue = randomString(5, 'PICKCHARSFROMTHISSET'); 
    88
    29 авг. atsakymas pateikiamas „ CaffGeek“ 29 rug . 2009-08-29 00:28 '09 - 0:28 2009-08-29 00:28

    65
    29 авг. atsakymas pateikiamas kennebec 29 rug . 2009-08-29 05:41 '09, 5:41 val. 2009-08-29 05:41

    Labiausiai kompaktiškas sprendimas, nes slice trumpesnis nei substring . Atimant iš eilutės pabaigos išvengiama random funkcijos generuojamo kintamo taško pobūdžio:

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

    ar netgi

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

    58
    15 окт. atsakymas duotas Valentino spalio 15 d 2015-10-15 14:11 '15 14:11 2015-10-15 14:11

    Atsitiktinės eilutės generatorius (skaitmeninis skaitmeninis);

      function randomString(len, an){ an = an 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" 

    Smagiai. jsBin demo


    Pirmiau pateiktame pavyzdyje papildomi patikrinimai naudojami norimam (A / N, A, N) išėjimui, leiskite jam suskaidyti į pagrindinį (tik alfa-skaitmeninis), kad geriau suprastumėte:

    • Sukurkite funkciją, kuri priima argumentą (norimą ilgio eilutės rezultato trukmę)
    • Sukurkite tuščią eilutę, pavyzdžiui, var str = ""; derinti atsitiktinius simbolius
    • Sukurkite kilpą nuo 0 iki 61 (0..9 + A..Z + a..z = 62)
    • Sukurti sąlyginę logiką Sureguliuokite / pataisykite rand (pradedant nuo 0..61), padidindami jį tam tikru skaičiumi (žr. Toliau pateiktus pavyzdžius), kad grąžintumėte CharCode numerį ir atitinkamą simbolį.
    • Viduje kilpa, susieti String.fromCharCode( incremented rand )

    Įsivaizduokite simbolių lentelės ir jų ribų vaizdą:

     _____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 ) suteikia intervalą nuo 0..61 (ko mums reikia). Kaip pataisyti (prieaugis) atsitiktinai, kad gautumėte teisingus charCode intervalus ?

      | 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  = 65..90 | a..z | 36..61 | 97..122 | rand += 61  = 97..122 | 

    sąlyginės operacijos logika iš pirmiau pateiktos lentelės:

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

    Jei atliksite pirmiau pateiktą paaiškinimą, galite sukurti šį raidinį ir skaitmeninį fragmentą :

    jsBin demo

     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" 

    Arba jei:

     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; } 
    44
    10 янв. Atsakymas, kurį pateikė Roko C. Buljan 10 Jan 2015-01-10 05:09 '15, 5:09 2015-01-10 05:09

    Naujesnė versija su es6 platintoju :

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

    • 30 yra savavališkas skaičius, galite pasirinkti bet kokį norimą žetonų ilgį.
    • 36 yra didžiausias spindulio numeris, kurį galite perkelti į numerinį .toString () , o tai reiškia visus skaičius ir mažąsias raides az
    • 3 naudojamas trečiajam skaičiui pasirinkti iš atsitiktinės eilutės, kuri atrodo taip: "0.mfbiohx64i" , galime imtis bet kurio indekso po 0.
    33
    26 нояб. atsakymą pateikė Or Duan 26 lapkritis 2017-11-26 16:17 '17, 16:17 pm 2017-11-26 16:17

    Lengviausias būdas:

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

    Tai generuoja atsitiktines 5 simbolių eilutes, priklausomai nuo dabartinio laiko. Išvesties pavyzdys: 4mtxj arba 4mv90 arba 4mwp1

    Problema ta, kad jei tą pačią sekundę pavadinate du kartus, tai sukurs tą pačią eilutę.

    Saugesnis būdas:

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

    Taip bus sukurta atsitiktinė 4 arba 5 simbolių eilutė, kuri visuomet skiriasi. Pavyzdžio išvestis yra panaši į 30jzm arba 1r591 arba 4su1a

    Abiem atvejais pirmoji dalis sukuria atsitiktinį skaičių. .toString(36) dalis .toString(36) perdavė numerį bazinio 36 (raidinis ir skaitmeninis) atvaizdavimui.

    29
    12 марта '15 в 0:43 2015-03-12 00:43 atsakymą pateikė „ Masquerade Circus “ kovo 15 d. 15 val. 0:43 2015-03-12 00:43

    Štai keletas paprastų įdėklų. Pakeiskite new Array(5) kad nustatytumėte ilgį.

    Įskaitant 0-9a-z

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

    Įskaitant 0-9a-zA-Z

     new Array(5).join().replace(/(.|$)/g, function(){return ((Math.random()*36)|0).toString(36)[Math.random()<.5?"toString":"toUpperCase"]();}); 
    20
    17 июля '14 в 20:47 2014-07-17 20:47 atsakymas pateikiamas bendytree liepos 17 d. 14 val. 20:47 2014-07-17 20:47

    Jei naudojatės Lodash arba Underscore , tai yra taip paprasta:

     var randomVal = _.sample('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789', 5).join(''); 
    15
    20 апр. Atsakymas pateikiamas vineet 20 Bal. 2016-04-20 08:39 '16 at 8:39 2016-04-20 08:39

    Žinau, kad kiekvienas padarė viską teisingai, bet aš manau, kad tai kuo geresnė (šviesos kodas, o ne procesorius):

    15
    04 мая '11 в 18:00 2011-05-04 18:00 atsakymą pateikė Roderick , gegužės 04 d., 11 val., 6:00, 2011-05-04 18:00

    Čia yra sukurtas metodas.
    Taip bus sukurta eilutė, kurioje yra ir didžiosios, ir mažosios raidės.
    Be to, įtraukiau funkciją, kuria taip pat bus sukurta raidinė ir skaitmeninė eilutė.

    Darbo pavyzdžiai:
    http://jsfiddle.net/greatbigmassive/vhsxs/ (tik alfa)
    http://jsfiddle.net/greatbigmassive/PJwg8/ (raidiniai ir skaitmeniniai)

     function randString(x){ var s = ""; while(s.length<x var r = Math.random(); s+= String.fromCharCode(Math.floor(r*26) + (r>0.5?97:65)); } return s; } 

    2015 m. Liepos mėn. Atnaujinimas
    Jis daro tą patį, bet jis yra prasmingesnis ir apima visas raides.

     var s = ""; while(s.length<x v = Math.random()<0.5?32:0; s += String.fromCharCode(Math.round(Math.random()*((122-v)-(97-v))+(97-v))); } 
    13
    28 авг. atsakymas, kurį pateikė Adam 28 rug. 2013-08-28 17:50 '13, 17:50, 2013-08-28 17:50

    Darant prielaidą, kad naudojate „ underscorejs“ , galite elegantiškai generuoti atsitiktinę eilutę tik dviejose eilutėse:

     var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'; var random = _.sample(possible, 5).join(''); 
    12
    18 мая '15 в 14:48 2015-05-18 14:48 atsakymas pateikiamas tiktak gegužės 18 d., 15 val. 14:48 2015-05-18 14:48

    Kad atitiktų [a-zA-Z0-9] reikalavimus ir ilgį = 5, naudokite

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

    Bus mažos raidės, didžiosios raidės ir skaičiai.

    11
    18 июня '18 в 4:50 2018-06-18 04:50 atsakė Sergio Cabralui birželio 18 d. 18 val. 4:50 2018-06-18 04:50

    Jei kas nors domisi viena eilute (nors ir nesuformatuota kaip patogi), kuri nedelsdama skiria atmintį (tačiau atkreipkite dėmesį, kad mažoms linijoms tikrai nesvarbu), kaip tai padaryti:

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

    5 galite pakeisti norimos eilutės ilgiu. Ačiū @AriyaHidayat šiame pranešime, kad išspręstumėte map funkciją, kuri neveikia su retu masyvu, sukurtu „ Array(5) .

    11
    18 февр. Atsakymą pateikė Martijn de Milliano vasario 18 d. 2013-02-18 22:56 '13, 22:56 pm 2013-02-18 22:56

    Greitas ir patobulintas algoritmas. Negarantuoja vienodumo (žr. Pastabas).

     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; } 
    8
    16 сент. atsakymas duotas Jaroslavo 16 sep . 2016-09-16 19:36 '16 at 19:36 pm 2016-09-16 19:36

    Galite slinkti elementų grupę ir rekursyviai pridėti juos prie eilutės kintamojo, pavyzdžiui, jei norite atsitiktinės DNR sekos:

    7
    02 янв. atsakymas duotas Andy 02 Jan 2012-01-02 00:24 '12 prie 0:24 2012-01-02 00:24

    Neradau švaraus sprendimo, kad būtų palaikomos ir mažosios, ir didžiosios raidės.

    Tik mažųjų raidžių palaikymas:

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

    Remiantis šiuo sprendimu palaikyti mažas ir dideles raides:

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

    Pakeiskite 5 į substr(2, 5) norėdami nustatyti norimą ilgį.

    6
    06 февр. Atsakymas pateikiamas ravishi 06 Feb. 2018-02-06 00:17 '18 prie 0:17 2018-02-06 00:17
     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(''); } 

    Jis yra kuo švaresnis. Tai taip pat greita, http://jsperf.com/ay-random-string .

    6
    10 янв. atsakymą pateikė Gajus sausio 10 d 2013-01-10 04:39 '13, 4:39, 2013-01-10 04:39

    Kaip apie kažką panašaus: Date.now().toString(36) Ne labai atsitiktinis, bet trumpas ir visiškai unikalus kiekvieną kartą, kai jį vadinate.

    4
    16 нояб. Atsakymą pateikė Swergas lapkričio 16 d. 2017-11-16 17:21 '17, 17:21 pm 2017-11-16 17:21

    Problemų, susijusių su atsakymais į klausimus „Man reikia atsitiktinių styginių“ (bet kuria kalba) beveik kiekviename sprendime naudoja netinkamą pradinės eilutės specifikacijos specifikaciją. Klausimai patys retai parodo, kodėl reikalingi atsitiktiniai stygos, bet norėčiau iššūkį, kai retai reikia atsitiktinių ilgių eilių, tarkim, 8. Tai, ko jums tikrai reikia, yra tam tikras skaičius unikalių stygų, pavyzdžiui, tam, kad būtų naudojami kaip identifikatoriai tam tikram tikslui. .

    Yra du pagrindiniai būdai, kaip gauti griežtai unikalias eilutes: deterministiškai (kas nėra atsitiktinai) ir saugoti / palyginti (kuri yra sunki). Ką mes darome? Mes mesti vaiduoklis. Vietoj to, mes einame tikimybiniu unikalumu. Tai yra, mes sutinkame, kad yra (nors ir maža) rizika, kad mūsų stygos nebus unikalios. Čia naudinga suprasti susidūrimo ir entropijos tikimybę .

    Taigi, aš perrašysiu nuolatinį poreikį, nes jums reikia tam tikro skaičiaus linijų, turinčių nedidelę pasikartojimo riziką. Pavyzdžiui, tarkime, kad norite sukurti 5 mln. Identifikatorių potencialą. Jūs nenorite saugoti ir palyginti kiekvienos naujos eilutės ir norite, kad jos būtų atsitiktinės, taigi jūs sutinkate su pakartojimo rizika. Pavyzdžiui, tarkime, kad rizika yra mažesnė nei 1 trilijonas atsinaujinimo galimybių. Taigi, kokio ilgio reikia eilutės? Na, šis klausimas pateikiamas žemiau, nes jis priklauso nuo naudojamų simbolių. Bet dar svarbiau, jis buvo neteisingas. Jums reikia styginių entropijos specifikacijos, o ne jų ilgio. Entropija gali būti tiesiogiai susijusi su pasikartojimo tikimybe tam tikru eilių skaičiumi. Stygos ilgis negali.

    Ir čia gali padėti EntropyString biblioteka. Norėdami generuoti atsitiktinius identifikatorius, kurių tikimybė, kad pasikartotų 5 mln.

     import {Random, Entropy} from 'entropy-string' const random = new Random() const bits = Entropy.bits(5e6, 1e12) const string = random.string(bits) 

    "44hTNghjNHGGRHqH9"

    entropy-string yra numatytasis simbolių rinkinys, turintis 32 simbolius. Yra ir kitų iš anksto nustatytų simbolių rinkinių, taip pat galite nurodyti savo simbolius. Pvz., Generuojant identifikatorius su ta pačia entropija, kaip ir anksčiau, bet naudojant šešioliktainius simbolius:

     import {Random, Entropy, charSet16} from './entropy-string' const random = new Random(charSet16) const bits = Entropy.bits(5e6, 1e12) const string = random.string(bits) 

    "27b33372ade513715481f"

    Atkreipkite dėmesį į eilutės ilgio skirtumą dėl skirtingo simbolių rinkinio skaičiaus skirtumo. Atsiradimo rizika nurodytame potencialių eilučių skaičiuje yra tokia pati. Stygos ilgis nėra. Ir svarbiausia, kad pasikartojimo ir galimo eilučių skaičiaus rizika yra aiški. Negalima atspėti eilutės ilgio.

    4
    03 сент. atsakymas dingo dangaus 03 sep. 2017-09-03 00:10 '17 ne 0:10 2017-09-03 00:10

    Sukurkite 10 simbolių ilgio eilutę. Ilgį nurodo parametras (numatytasis 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; } 
    4
    11 янв. Atsakymas pateikiamas ropsiU sausio 11 d 2013-01-11 13:54 '13, 13:54, 2013-01-11 13:54

    Tai tiesa.

     <script > 
    4
    03 дек. Atsakymas pateikiamas Vignesh 03 dec. 2009-12-03 11:48 '09, 11:48, 2009-12-03 11:48

    Galite naudoti koderį . Tai biblioteka atsitiktinių kodų generavimui pagal tam tikrą modelį. Naudokite # kaip didžiųjų ir mažųjų raidžių, taip pat skaičių:

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

    Yra ir kitų vietų, pvz., A - didžiosios raidės arba 9 - numeriai.

    Kas gali būti naudinga yra tai, kad .next() skambutis visada suteiks jums unikalų rezultatą, taigi jums nereikės nerimauti dublikatų.

    Čia yra demo programa, kuri sukuria unikalių atsitiktinių kodų sąrašą .

    Visiškas atskleidimas: esu kodavimo autorius.

    4
    09 янв. atsakymas pateikiamas Lukasz Wiktor 09 Jan 2017-01-09 17:54 '17 at 17:54 2017-01-09 17:54

    Raidiniai ir skaitmeniniai atvejai nejautrūs simboliai:

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

    Individualūs simboliai

    3
    ответ дан Ali 23 сент. '18 в 11:46 2018-09-23 11:46