Generate random string characters in JavaScript

Question

I want a 5 character string composed of characters picked randomly from the set  a-zA-Z0-9    What s the best way to do this with JavaScript

User · Answer

I have made a String prototype which can generate a random String with a given length.

You also can secify if you want special chars and you can avoid some.

/**
 * STRING PROTOTYPE RANDOM GENERATOR
 * Used to generate a random string
 * @param {Boolean} specialChars
 * @param {Number} length
 * @param {String} avoidChars
 */
String.prototype.randomGenerator = function (specialChars = false, length = 1, avoidChars = '') {
    let _pattern = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    _pattern += specialChars === true ? '(){}[]+-*/=' : '';
    if (avoidChars && avoidChars.length) {
        for (let char of avoidChars) {
            _pattern = _pattern.replace(char, '');
        }
    }
    let _random = '';
    for (let element of new Array(parseInt(length))) {
        _random += _pattern.charAt(Math.floor(Math.random() * _pattern.length));
    }
    return _random;
};

You can use like this :

// Generate password with specialChars which contains 10 chars and avoid iIlL chars
var password = String().randomGenerator(true, 10, 'iIlL');

Hope it helps.

User · Answer

This is what I used  A combination of a couple here  I use it in a loop  and each ID it produces is unique  It might not be 5 characters  but it s guaranteed unique   var newId        randomid          Math random      new Date    toString 36  replace    a-z   g

User · Answer

Crypto-Strong If you want to get crypto-strong string which meets your requirements  I see answer which use this but gives non valid answers  use let pass       crypto getRandomValues new Uint8Array 5        map  x i   gt  i x 255 61 0 String fromCharCode i  i gt 9 i gt 35 61 55 48     join     x000D   x000D  let pass       crypto getRandomValues new Uint8Array 5        map  x i   gt  i x 255 61 0 String fromCharCode i  i gt 9 i gt 35 61 55 48     join    console log pass   x000D   x000D   x000D

User · Answer

Here is a different approach with fixed length by base  without RegExp replace lack  based on  bendytree s answer    function rand base           default base 10     base    base  gt   2  amp  amp  base  lt   36    base   10      for  var i   0  ret       i  lt  base  i              ret i      Math random     base    0  toString base                 include 0-9a-zA-Z                  Math random    lt   5    toString     toUpperCase                return ret join

User · Answer

Generate a secure random alphanumeric Base-62 string   x000D   x000D  function generateUID length        return window btoa Array from window crypto getRandomValues new Uint8Array length   2    map  b    gt  String fromCharCode b   join      replace       g      substring 0  length      console log generateUID 22        yFg3Upv2cE9cKOXd7hHwWp  console log generateUID 5        YQGzP  x000D   x000D   x000D

User · Answer

Above All answers are perfect  but I am adding which is very good and rapid to generate any random string value   x000D   x000D  function randomStringGenerator stringLength    x000D    var randomString          Empty value of the selective variable x000D    const allCharacters              amp      -          lt  gt        ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789       listing of all alpha-numeric letters x000D    while  stringLength--    x000D      randomString    allCharacters substr Math floor  Math random     allCharacters length    1   1      selecting any value from allCharacters varible by using Math random   x000D      x000D    return randomString     returns the generated alpha-numeric string x000D    x000D   x000D  console log randomStringGenerator 10     call function by entering the random string you want x000D   x000D   x000D    or   x000D   x000D  console log Date now      it will produce random thirteen numeric character value every time  x000D  console log Date now   toString   length    print length of the generated string x000D   x000D   x000D

User · Answer

const c    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789  const s       Array 5   map     gt  c    Math random   c length    join

User · Answer

I know everyone has got it right already  but i felt like having a go at this one in the most lightweight way possible light on code  not CPU     x000D   x000D  function rand length  current    x000D    current   current   current       x000D    return length   rand --length   0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz  charAt Math floor Math random     60     current    current  x000D    x000D   x000D  console log rand 5    x000D   x000D   x000D    It takes a bit of time to wrap your head around  but I think it really shows how awesome javascript s syntax is

User · Answer

For a string with upper- and lowercase letters and digits  0-9a-zA-Z   this may be the version that minifies best   function makeId length      var id         var rdm62    while  length--          Generate random integer between 0 and 61  0 x works for Math floor x  in this case     rdm62   0   Math random     62         Map to ascii codes  0-9 to 48-57  0-9   10-35 to 65-90  A-Z   36-61 to 97-122  a-z     id    String fromCharCode rdm62    rdm62  lt  10   48   rdm62  lt  36   55   61          return id      The content of this function minifies to 97 bytes  while the top answer needs 149 bytes  because of the characters list

User · Answer

You could use base64   function randomString length        var rtn            do           rtn    btoa      Math floor Math random     100000   substring 0  length             while rtn length  lt  length        return rtn

User · Answer

Something like this should work  function randomString len  charSet        charSet   charSet     ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789       var randomString           for  var i   0  i  lt  len  i              var randomPoz   Math floor Math random     charSet length           randomString    charSet substring randomPoz randomPoz 1             return randomString      Call with default charset  a-zA-Z0-9  or send in your own   var randomValue   randomString 5    var randomValue   randomString 5   PICKCHARSFROMTHISSET

User · Answer

This stores 5 alphanumeric characters in variable c   for var c       c length  lt  5   c    Math random   toString 36  substr 2  1

User · Answer

Here s the method I created  It will create a string containing both uppercase and lowercase characters  In addition I ve included the function that will created an alphanumeric string too   Working examples  http   jsfiddle net greatbigmassive vhsxs    alpha only  http   jsfiddle net greatbigmassive PJwg8   alphanumeric   function randString x       var s           while s length lt x amp  amp x gt 0           var r   Math random            s   String fromCharCode Math floor r 26     r gt 0 5 97 65              return s      Upgrade July 2015 This does the same thing but makes more sense and includes all letters   var s       while s length lt x amp  amp x gt 0       v   Math random   lt 0 5 32 0      s    String fromCharCode Math round Math random     122-v - 97-v    97-v

User · Answer

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          will generate a random alpha-numeric string with the length of the first calling string

User · Answer

Put the characters as the thisArg in the map function will create a  one-liner    Array apply null  Array 5    map function         return this Math floor Math random   this length        abcdefghijklmnopqrstuvwxyz    join

User · Answer

Try this  what i use every time     x000D   x000D  function myFunction     x000D          var hash    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012346789   x000D          var random8       x000D          for var i   0  i  lt  5  i     x000D              random8    hash parseInt Math random   hash length    x000D            x000D          console log random8   x000D      document getElementById  demo   innerHTML    Your 5 character string     gt    random8  x000D            x000D           x000D   lt  DOCTYPE html gt  x000D   lt html gt  x000D   lt body gt  x000D   x000D   lt p gt Click the button to genarate 5 character random string   lt  p gt  x000D   x000D   lt button onclick  myFunction    gt Click me lt  button gt  x000D   x000D   lt p id  demo  gt  lt  p gt  x000D   x000D   x000D   x000D   lt  body gt  x000D   lt  html gt  x000D   x000D   x000D

User · Answer

Generate 10 characters long string  Length is set by parameter  default 10    function random string generator len    var len   len    10  var str       var i   0   for i 0  i lt 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

User · Answer

replace    g function    return  AzByC0xDwEv9FuGt8HsIrJ7qKpLo6MnNmO5lPkQj4RiShT3gUfVe2WdXcY1bZa  charAt Math floor Math random   62

User · Answer

Expanding on Doubletap s elegant example by answering the issues Gertas and Dragon brought up  Simply add in a while loop to test for those rare null circumstances  and limit the characters to five     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      Here s a jsfiddle alerting you with a result   http   jsfiddle net pLJJ7

User · Answer

Here is a test script for the  1 answer  thank you  csharptest net   the script runs makeid   1 million times and as you can see 5 isnt a very unique  running it with a char length of 10 is quite reliable  I ve ran it about 50 times and haven t seen a duplicate yet  -    note  node stack size limit exceeds around 4 million so you cant run this 5 million times it wont ever finish   function makeid         var text           var possible    ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789        for  var i 0  i  lt  5  i             text    possible charAt Math floor Math random     possible length         return text     ids     count   0 for  var i   0  i  lt  1000000  i          tempId   makeid        if  typeof ids tempId       undefined             ids tempId             if  ids tempId      2                count                       count         else          ids tempId    1          console log  there are   count    duplicate ids

User · Answer

The most compact solution  because slice is shorter than substring   Subtracting from the end of the string allows to avoid floating point symbol generated by the random function   Math random   toString 36  slice -5     or even    new Date  toString 36  slice -5     Update  Added one more approach using btoa method   btoa Math random    slice 0  5   btoa  new Date  slice -7  -2   btoa  new Date  substr -7  5      x000D   x000D     Using Math random and Base 36  x000D  console log Math random   toString 36  slice -5    x000D   x000D     Using new Date and Base 36  x000D  console log   new Date  toString 36  slice -5    x000D   x000D     Using Math random and Base 64  btoa   x000D  console log btoa Math random    slice 0  5    x000D   x000D     Using new Date and Base 64  btoa   x000D  console log btoa  new Date  slice -7  -2    x000D  console log btoa  new Date  substr -7  5    x000D   x000D   x000D

User · Answer

If you want just A-Z  randomAZ n  number   string         return Array n           fill null           map      gt  Math random   100 25    A  charCodeAt 0            map a   gt  String fromCharCode a            join

User · Answer

How about something like this  Date now   toString 36  Not very random  but short and quite unique every time you call it

User · Answer

A functional approach  This answer is only practical if the functional prerequisites can be leveraged in other parts of your app  The performance is probably junk  but it was super fun to write    x000D   x000D     functional prerequisites x000D  const U   f  gt  f  f  x000D  const Y   U  h  gt  f  gt  f  x  gt  h  h   f   x    x000D  const comp   f  gt  g  gt  x  gt  f  g  x   x000D  const foldk   Y  h  gt  f  gt  y  gt    x     xs    gt  x000D    x     undefined   y   f  y   x   y  gt  h  f   y   xs    x000D  const fold   f  gt  foldk  y  gt  x  gt  k  gt  k  f  y   x    x000D  const map   f  gt  fold  y  gt  x  gt      y  f  x         x000D  const char   x  gt  String fromCharCode x  x000D  const concat   x  gt  y  gt  y concat x  x000D  const concatMap   f  gt  comp  fold  concat         map  f   x000D  const irand   x  gt  Math floor Math random     x  x000D  const sample   xs  gt  xs  irand  xs length   x000D   x000D     range   make a range from x to y   x   y  x000D     Number - gt  Number - gt   Number  x000D  const range   Y  f  gt  r  gt  x  gt  y  gt  x000D    x  gt  y   r   f      r  x    x 1   y  x000D         x000D   x000D     srand   make random string from list or ascii code ranges x000D       Range a   - gt  Number - gt   a  x000D  const srand   comp  Y  f  gt  z  gt  rs  gt  x  gt  x000D    x     0   z   f  z   sample  rs    rs   x-1  x000D           concatMap  map  char    x000D   x000D     idGenerator   make an identifier of specified length x000D     Number - gt  String x000D  const idGenerator   srand    x000D    range  48   57       include 0-9 x000D    range  65   90       include A-Z x000D    range  97   122      include a-z x000D     x000D   x000D  console log  idGenerator  6        gt  TT688X x000D  console log  idGenerator  10       gt  SzaaUBlpI1 x000D  console log  idGenerator  20       gt  eYAaWhsfvLDhIBID1xRh x000D   x000D   x000D    In my opinion  it s hard to beat the clarity of idGenerator without adding magical  do-too-many-things functions   A slight improvement could be     ord   convert char to ascii code    Char - gt  Number const ord   x   gt  x charCodeAt 0      idGenerator   make an identifier of specified length    Number - gt  String const idGenerator   srand      range  ord  0     ord  9       range  ord  A     ord  Z       range  ord  a     ord  z         Have fun with it  Let me know what you like learn

User · Answer

As several people here have pointed out  passing the result of Math random   directly to  string 36  has several problems   It has poor randomness  The number of characters generated varies  and on average depends on the tricky details of how floating-point numbers work in Javascript  It seems to work if I am trying to generate 11 characters or fewer  but not with more than 11  And it is not flexible  There is no easy way to allow or prohibit certain characters   I have a compact solution  which doesn t have these problems  for anyone using lodash     range 11  map i   gt    sample  abcdefghijklmnopqrstuvwxyz0123456789    join       If you want to allow certain characters  such as uppercase letters  or prohibit certain characters  like ambiguous characters such as l and 1   modify the string above

User · Answer

x000D   x000D  function randomstring L    x000D    var s       x000D    var randomchar   function     x000D      var n   Math floor Math random     62   x000D      if  n  lt  10  return n    1-10 x000D      if  n  lt  36  return String fromCharCode n   55     A-Z x000D      return String fromCharCode n   61     a-z x000D      x000D    while  s length  lt  L  s    randomchar    x000D    return s  x000D    x000D  console log randomstring 5    x000D   x000D   x000D

User · Answer

x000D   x000D  let r   Math random   toString 36  substring 7   x000D  console log  random   r   x000D   x000D   x000D    Note  The above algorithm has the following weaknesses    It will generate anywhere between 0 and 6 characters due to the fact that trailing zeros get removed when stringifying floating points  It depends deeply on the algorithm used to stringify floating point numbers  which is horrifically complex   See the paper  How to Print Floating-Point Numbers Accurately    Math random   may produce predictable   random-looking  but not really random  output depending on the implementation  The resulting string is not suitable when you need to guarantee uniqueness or unpredictability  Even if it produced 6 uniformly random  unpredictable characters  you can expect to see a duplicate after generating only about 50 000 strings  due to the birthday paradox   sqrt 36 6    46656

User · Answer

If a library is a possibility  Chance js might be of help  http   chancejs com  string

User · Answer

Teach a man to fish   Programmers cut paper with lasers  not chainsaws  Using fringe  language specific methods to produce the smallest  most obfuscated code is cute and all  but will never offer a complete solution  You have to use the right tool for the job    What you want is a string of characters  and characters are represented by bytes  And  we can represent a byte in JavaScript using a number  So then  we should generate a list of these numbers  and cast them as strings  You don t need Date  or base64  Math random   will get you a number  and String fromCharCode   will turn it into a string  Easy   But  which number equals which character  UTF-8 is the primary standard used on the web to interpret bytes as characters  although JavaScript uses UTF-16 internally  they overlap   The programmer s way of solving this problem is to look into the documentation    UTF-8 lists all the keys on the keyboard in the numbers between 0 and 128  Some are non-printing  Simply pick out the characters you want in your random strings  and search for them  using randomly generated numbers   Bellow is a function that takes a virtually infinite length  generates a random number in a loop  and searches for all the printing characters in the lower 128 UTF-8 codes  Entropy is inherent  since not all random numbers will hit every time  non-printing characters  white space  etc   It will also perform faster as you add more characters   I ve included most of the optimizations discussed in the thread    The double tilde is faster than Math floor  if  statements are faster than regular expressions pushing to an array is faster than string concatenation    x000D   x000D  function randomID len    x000D    var char  x000D    var arr       x000D    var len   len    5  x000D   x000D    do   x000D      char      Math random     128   x000D   x000D      if    x000D           char  gt  47  amp  amp  char  lt  58        0-9 x000D           char  gt  64  amp  amp  char  lt  91        A-Z x000D           char  gt  96  amp  amp  char  lt  123     a-z x000D   x000D                 char  gt  32  amp  amp  char  lt  48           amp       -   x000D                 char  gt  59  amp  amp  char  lt  65      lt   gt    x000D                 char  gt  90  amp  amp  char  lt  97            x000D                 char  gt  123  amp  amp  char  lt  127          x000D          x000D          security conscious removals           x000D           amp  amp   char    34  amp  amp  char    39  amp  amp  char    92  amp  amp  char    96   x000D   x000D          arr push String fromCharCode char     x000D   x000D      while  arr length  lt  len   x000D   x000D    return arr join     x000D    x000D   x000D  var input   document getElementById  length    x000D   x000D  input onfocus   function     input value         x000D   x000D  document getElementById  button   onclick   function     x000D    var view   document getElementById  string    x000D    var is number   str   gt    Number isNaN  parseInt str    x000D       x000D    if   is number input value   x000D      view innerText   randomID input value   x000D    else x000D      view innerText    Enter a number   x000D    x000D   length   x000D    width  3em  x000D    color   484848  x000D    x000D   x000D   string   x000D    color   E83838  x000D    font-family   sans-serif   x000D    word-wrap  break-word  x000D    x000D   lt input id  length  type  text  value      gt  x000D   lt input id  button  type  button  value  Generate    gt  x000D   lt p id  string  gt  lt  p gt  x000D   x000D   x000D    Why do it in this tedious way  Because you can  You re a programmer  You can make a computer do anything  Besides  what if you want a string of Hebrew characters  It s not hard  Find those characters in the UTF-8 standard and search for them  Free yourself from these McDonald methods like toString 36    Sometimes  dropping down to a lower level of abstraction is what s needed to create a real solution  Understanding the fundamental principals at hand can allow you to customize your code how you d like  Maybe you want an infinitely generated string to fill a circular buffer  Maybe you want all of your generated strings to be palindromes  Why hold yourself back

User · Answer

To meet requirement  a-zA-Z0-9  and length 5 use btoa Math random    substr 10  5    Lowercase letters  uppercase letters  and numbers will occur

User · Answer

in below code i am generating random code for 8 characters  function RandomUnique                        var charBank    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ012346789                       var random                          var howmanycharacters   8                      for  var i   0  i  lt  howmanycharacters   i                              random   charBank parseInt Math random     charBank lenght                                              return random                            var random   RandomUnique            console log random

User · Answer

Here is my approach  with TypeScript    I ve decided to write yet another response because I didn t see any simple solution using modern js and clean code   const DEFAULT ALPHABET    ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789    function getRandomCharFromAlphabet alphabet  string   string     return alphabet charAt Math floor Math random     alphabet length       function generateId idDesiredLength  number  alphabet   DEFAULT ALPHABET   string              Create n-long array and map it to random chars from given alphabet       Then join individual chars as string         return Array from  length  idDesiredLength   map      gt        return getRandomCharFromAlphabet alphabet        join         generateId 5      jNVv7

User · Answer

Short  easy and reliable  Returns exactly 5 random characters  as opposed to some of the top rated answers found here   Math random   toString 36  substr 2  5

User · Answer

I use var randId    rand    new Date   getTime

User · Answer

Review Many answers base on trick Math random   toString 36  but the problem of this approach is that Math random not always produce number which has at least 5 characters in base 36 e g   x000D   x000D  let testRnd   n   gt  console log  num dec    n   num base36    n toString 36    string    n toString 36  substr 2  5            Math random         and much more less than 0 5      0 5    0 50077160493827161    0 5015432098765432    0 5023148148148148    0 5030864197530864       and much more       0 9799597050754459   map n  gt testRnd n     console log      and so on    x000D  Each of below example  except first  numbers result with less than 5 characters  which not meet OP question requirements  x000D   x000D   x000D   Here is  quot generator quot  which allows manually find such numbers  x000D   x000D  function base36Todec hex      hex   hex split          return  parseInt hex 1  36    36  -hex 1  length     parseInt hex 0  36       function calc hex      let dec   base36Todec hex     msg innerHTML    dec   lt b gt   dec  lt  b gt  lt br gt hex test   lt b gt   dec toString 36   lt  b gt       function calc2 dec      msg2 innerHTML    dec   lt b gt   dec  lt  b gt  lt br gt hex test   lt b gt     dec  toString 36   lt  b gt       let init  0 za1   inp value init  calc init   x000D  Type number in range 0-1 using base 36  0-9 a-z  with less than 5 digits after dot lt br gt   lt input oninput  calc this value   id  inp    gt  lt div id  msg  gt  lt  div gt   lt br gt  If above  lt i gt hex test lt  i gt  give more digits than 5 after dot - then you can try to copy dec number to below field and join some digit to dec num right side and or change last digit - it sometimes also produce hex with less digits lt br gt   lt input oninput  calc2 this value     gt  lt br gt  lt div id  msg2  gt  lt  div gt  x000D   x000D   x000D   I already give answer here so I will not put here another solution

User · Answer

I think this will work for you    x000D   x000D  function makeid length    x000D     var result                 x000D     var characters          ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789   x000D     var charactersLength   characters length  x000D     for   var i   0  i  lt  length  i       x000D        result    characters charAt Math floor Math random     charactersLength    x000D       x000D     return result  x000D    x000D   x000D  console log makeid 5    x000D   x000D   x000D

User · Answer

Case Insensitive Alphanumeric Chars    x000D   x000D  function randStr len    x000D    let s       x000D    while  s length  lt  len  s    Math random   toString 36  substr 2  len - s length   x000D    return s  x000D    x000D   x000D     usage x000D  console log randStr 50    x000D   x000D   x000D    The benefit of this function is that you can get different length random string and it ensures the length of the string   Case Sensitive All Chars    x000D   x000D  function randStr len    x000D    let s       x000D    while  len--  s    String fromCodePoint Math floor Math random      126 - 33    33    x000D    return s  x000D    x000D   x000D     usage x000D  console log randStr 50    x000D   x000D   x000D    Custom Chars   x000D   x000D  function randStr len  chars  abc123     x000D    let s       x000D    while  len--  s    chars Math floor Math random     chars length    x000D    return s  x000D    x000D   x000D     usage x000D  console log randStr 50    x000D  console log randStr 50   abc     x000D  console log randStr 50   aab        more a than b x000D   x000D   x000D

User · Answer

Assuming you use underscorejs it s possible to elegantly generate random string in just two lines   var possible    ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789   var random     sample possible  5  join

User · Answer

A newer version with es6 spread operator      Array 30   map      gt  Math random   toString 36  2   join      The 30 is an arbitrary number  you can pick any token length you want The 36 is the maximum radix number you can pass to numeric toString    which means all numbers and a-z lowercase letters The 2 is used to pick the 3rd index from the random string which looks like this   quot 0 mfbiohx64i quot   we could take any index after 0

User · Answer

Random String Generator  Alpha-Numeric   Alpha   Numeric    x000D   x000D      x000D     Pseudo-random string generator x000D     http   stackoverflow com a 27872144 383904 x000D     Default  return a random alpha-numeric string x000D      x000D      param  Integer  len Desired length x000D      param  String  an Optional  alphanumeric    a   alpha    n   numeric  x000D      return  String  x000D      x000D  function randomString len  an    x000D    an   an  amp  amp  an toLowerCase    x000D    var str       x000D      i   0  x000D      min   an     a    10   0  x000D      max   an     n    10   62  x000D    for    i    lt  len     x000D      var r   Math random      max - min    min  lt  lt  0  x000D      str    String fromCharCode r    r  gt  9   r  lt  36   55   61   48   x000D      x000D    return str  x000D    x000D   x000D  console log randomString 10            i e   4Z8iNQag9v  x000D  console log randomString 10   a        i e   aUkZuHNcWw  x000D  console log randomString 10   n        i e   9055739230  x000D   x000D   x000D      While the above uses additional checks for the desired A N  A  N output  let s break it down the to the essentials  Alpha-Numeric only  for a better understanding    Create a function that accepts an argument  desired length of the random String result  Create an empty string like var str       to concatenate random characters Inside a loop create a rand index number from 0 to 61  0  9 A  Z a  z   62  Create a conditional logic to Adjust fix rand  since it s 0  61  incrementing it by some number  see examples below  to get back the right CharCode number and the related Character  Inside the loop concatenate to str a String fromCharCode  incremented rand     Let s picture the ASCII Character table ranges        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   gives a range from 0  61  what we need   Let s fix the random to get the correct charCode ranges             rand     charCode     0  61 rand    fix              charCode ranges   ------ ---------- ---------- -------------------------------- -----------------  0  9      0  9      48  57     rand    48                          48  57        A  Z     10  35     65  90     rand    55     90-35   55           65  90        a  z     36  61     97  122    rand    61    122-61   61           97  122         The conditional operation logic from the table above      rand    rand gt 9     rand lt 36   55   61     48      rand     true       true     55 else 61   else 48     From the explanation above  here s the resulting alpha-numeric snippet    x000D   x000D  function randomString len    x000D    var str                                         String result x000D    for  var i   0  i  lt  len  i                      Loop  len  times x000D      var rand   Math floor Math random     62      random  0  61 x000D      var charCode   rand    rand  gt  9    rand  lt  36   55   61    48     Get correct charCode x000D      str    String fromCharCode charCode           add Character to str x000D      x000D    return str     After all loops are done  return the concatenated string x000D    x000D   x000D  console log randomString 10       i e   7GL9F0ne6t  x000D   x000D   x000D    Or if you will    x000D   x000D  const randomString    n  r       gt    x000D    while  n--  r    String fromCharCode  r Math random   62 0  r  r gt 9  r lt 36 55 61  48    x000D    return r  x000D     x000D   x000D  console log randomString 10   x000D   x000D   x000D

User · Answer

Generate any number of hexadecimal character  e g  32     function max  let r    for let i 0 i lt max 13 i   r   Math random   1  toString 16  substring 2  return r substring 0 max  toUpperCase     32

User · Answer

Fast and improved algorithm  Does not guarantee uniform  see comments    function getRandomId length        if   length            return                const possible            ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789       let array       if   Uint8Array  in self  amp  amp   crypto  in self  amp  amp  length  lt   65536            array   new Uint8Array length           self crypto getRandomValues array         else           array   new Array length            for  let i   0  i  lt  length  i                  array i    Math floor Math random     62                        let result            for  let i   0  i  lt  length  i              result    possible charAt array i    62              return result

User · Answer

If you are using Lodash or Underscore  then it so simple   var randomVal     sample  ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789   5  join

User · Answer

I just write a simple package to generate a random token with given size  seed and mask  FYI    sibevin random-token - https   www npmjs com package  sibevin random-token  import   RandomToken   from   sibevin random-token   RandomToken gen   length  32       JxpwdIA37LlHan4otl55PZYyyZrEdsQT  RandomToken gen   length  32  seed   alphabet        NbbtqjmHWJGdibjoesgomGHulEJKnwcI  RandomToken gen   length  32  seed   number        33541506785847193366752025692500  RandomToken gen   length  32  seed   oct        76032641643460774414624667410327  RandomToken gen   length  32  seed   hex        07dc6320bf1c03811df7339dbf2c82c3  RandomToken gen   length  32  seed   abc        bcabcbbcaaabcccabaabcacbcbbabbac  RandomToken gen   length  32  mask   123abcABC        vhZp88dKzRZGxfQHqfx7DOL8jKTkWUuO

User · Answer

You can use coderain  It s a library to generate random codes according to given pattern  Use   as a placeholder for upper and lowercase characters as well as digits   var cr   new CodeRain           console log cr next       There are other placeholders like A for uppercase letters or 9 for digits   What may be useful is that calling  next   will always give you a unique result so you don t have to worry about duplicates   Here is a demo application that generates a list of unique random codes   Full disclosure  I m the author of coderain

User · Answer

Another nice way to randomize a string from the characters A-Za-z0-9   function randomString length        if   length  lt   0   return         var getChunk   function            var i    index iterator             rand   Math random   10e16    execute random once             bin   rand toString 2  substr 2 10     random binary sequence             lcase    rand toString 36   0000000000   substr 0 10     lower case random string             ucase   lcase toUpperCase      upper case random string             a    lcase ucase     position them in an array in index 0 and 1             str         the chunk string         b   rand toString 2  substr 2 10           for   i 0  i lt 10  i                 str    a bin i   i     gets the next character  depends on the bit in the same position as the character - that way it will decide what case to put next         return str             str         the result string     while   str length  lt  length            str    getChunk        str   str substr 0 length       return str

User · Answer

function generate length      var letters     quot a quot   quot b quot   quot c quot   quot d quot   quot e quot   quot f quot   quot g quot   quot h quot   quot i quot   quot j quot   quot k quot   quot l quot   quot m quot   quot n quot   quot o quot   quot p quot   quot q quot   quot r quot   quot s quot   quot t quot   quot u quot   quot v quot   quot w quot   quot x quot   quot y quot   quot z quot   quot A quot   quot B quot   quot C quot   quot D quot   quot E quot   quot F quot   quot G quot   quot H quot   quot I quot   quot J quot   quot K quot   quot L quot   quot M quot   quot N quot   quot O quot   quot P quot   quot Q quot   quot R quot   quot S quot   quot T quot   quot U quot   quot V quot   quot W quot   quot X quot   quot Y quot   quot Z quot   quot 0 quot   quot 1 quot   quot 2 quot   quot 3 quot   quot 4 quot   quot 5 quot   quot 6 quot   quot 7 quot   quot 8 quot   quot 9 quot      var IDtext    quot  quot     var i   0    while  i  lt  length        var letterIndex   Math floor Math random     letters length       var letter   letters letterIndex       IDtext   IDtext   letter      i          console log IDtext

User · Answer

The problem with responses to  I need random strings  questions  in whatever language  is practically every solution uses a flawed primary specification of string length  The questions themselves rarely reveal why the random strings are needed  but I would challenge you rarely need random strings of length  say 8  What you invariably need is some number of unique strings  for example  to use as identifiers for some purpose   There are two leading ways to get strictly unique strings  deterministically  which is not random  and store compare  which is onerous   What do we do  We give up the ghost  We go with probabilistic uniqueness instead  That is  we accept that there is some  however small  risk that our strings won t be unique  This is where understanding collision probability and entropy are helpful   So I ll rephrase the invariable need as needing some number of strings with a small risk of repeat  As a concrete example  let s say you want to generate a potential of 5 million IDs  You don t want to store and compare each new string  and you want them to be random  so you accept some risk of repeat  As example  let s say a risk of less than 1 in a trillion chance of repeat  So what length of string do you need   Well  that question is underspecified as it depends on the characters used  But more importantly  it s misguided  What you need is a specification of the entropy of the strings  not their length  Entropy can be directly related to the probability of a repeat in some number of strings  String length can t   And this is where a library like EntropyString can help  To generate random IDs that have less than 1 in a trillion chance of repeat in 5 million strings using 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 uses a character set with 32 characters by default  There are other predefined characters sets  and you can specify your own characters as well  For example  generating IDs with the same entropy as above but using hex characters   import  Random  Entropy  charSet16  from    entropy-string   const random   new Random charSet16  const bits   Entropy bits 5e6  1e12   const string   random string bits        27b33372ade513715481f    Note the difference in string length due to the difference in total number of characters in the character set used  The risk of repeat in the specified number of potential strings is the same  The string lengths are not  And best of all  the risk of repeat and the potential number of strings is explicit  No more guessing with string length

User · Answer

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          This is as clean as it will get  It is fast too  http   jsperf com ay-random-string

User · Answer

Here is an example in CoffeeScript   String  add Random Letters      size  - gt                                           charSet    abcdefghijklmnopqrstuvwxyz                                                charSet Math floor Math random     charSet length    for i in  1  size   join       which can be used  value    abc   value with exta 5 random letters   value add Random Letters 5

User · Answer

This is for firefox chrome code  addons and the like   It can save you a few hours of research   function randomBytes  amount         let bytes   Cc    mozilla org security random-generator 1              getService           Ci nsIRandomGenerator            generateRandomBytes  amount                       return bytes reduce  bytes2Number         function bytes2Number  previousValue  currentValue  index  array               return Math pow  256  index     currentValue   previousValue           Use it as   let   strlen     5       radix      36       filename   randomBytes  strlen   toString  radix   splice  - strlen

User · Answer

Here s Coffeescript version one line of code  genRandomString    length set  - gt   0   length  map  - gt  set charAt Math floor Math random     set length   join       Usage    genRandomString 5   ABCDEFTGHIJKLMNOPQRSTUVWXYZ    Output    FHOOV    random string of length 5 in possible set A Z

User · Answer

You can loop through an array of items and recursively add them to a string variable  for instance if you wanted a random DNA sequence    x000D   x000D  function randomDNA len    x000D    len   len    100 x000D    var nuc   new Array  A    T    C    G   x000D    var i   0 x000D    var n   0 x000D    s      x000D    while  i  lt   len - 1    x000D      n   Math floor Math random     4  x000D      s    nuc n  x000D      i   x000D      x000D    return s x000D    x000D   x000D  console log randomDNA 5    x000D   x000D   x000D

User · Answer

Also based upon doubletap s answer  this one handles any length of random required characters  lower only   and keeps generating random numbers until enough characters have been collected   function randomChars len        var chars            while  chars length  lt  len            chars    Math random   toString 36  substring 2                 Remove unnecessary additional characters      return chars substring 0  len

User · Answer

In case anyone is interested in a one-liner  although not formatted as such for your convenience  that allocates the memory at once  but note that for small strings it really does not matter  here is how to do it   Array apply 0  Array 5   map function         return  function charset           return charset charAt Math floor Math random     charset length          ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789        join       You can replace 5 by the length of the string you want  Thanks to  AriyaHidayat in this post for the solution to the map function not working on the sparse array created by Array 5

User · Answer

How about this compact little trick   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        You need the Array apply there to trick the empty array into being an array of undefineds   If you re coding for ES2015  then building the array is a little simpler   var randomString   Array from   length  stringLength    pickRandom  join

User · Answer

Improved  Andrew s answer above   Array from   length   1         gt  Math random   toString 36  2   join       Base 36 conversion of the random number is inconsistent  so selecting a single indice fixes that  You can change the length for a string with the exact length desired

User · Answer

I loved the brievety of doubletap s Math random   toString 36  substring 7  answer  but not that it had so many collisions as hacklikecrack correctly pointed out   It generated 11-chacter strings but has a duplicate rate of 11  in a sample size of 1 million   Here s a longer  but still short  and slower alternative that had only 133 duplicates in a sample space of 1 million   In rare cases the string will still be shorter than 11 chars   Math abs Math random   toString   split          reduce function p c  return  p lt  lt 5 -p c    toString 36  substr 0 11

User · Answer

This is a slightly improved version of doubletap s answer  It considers gertas s comment about the case  when Math random   returns 0  0 5  0 25  0 125  etc     Math random   3 Number MIN VALUE  Math PI  toString 36  slice -5     It prevents that zero gets passed to toString my adding the smallest float to Math random    It ensures that the number passed to toString has enough digits by dividing through an almost irrational number

User · Answer

creates a random code which is 10 in lenght you can change it to yours at your will  function createRandomCode length        let randomCodes           let characters    ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789       let charactersLength   characters length      for  let i   0  i  lt  length  i               randomCodes    characters charAt Math floor Math random     charactersLength             console log  your reference code is    toLocaleUpperCase     randomCodes        createRandomCode 10

User · Answer

How about this below    this will produce the really random values   function getRandomStrings length      const value    ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789     const randoms         for let i 0  i  lt  length  i           randoms push value Math floor Math random   value length           return randoms join          But if you looking for a shorter syntax one in ES6   const getRandomStrings   length   gt  Math random   toString 36  substr -length

User · Answer

This one combines many of the answers give    x000D   x000D  var randNo   Math floor Math random     100    2        new Date   getTime      Math floor Math random     100    2    Math random   toString 36  replace    a-zA-Z   g      substr 0  5    x000D   x000D  console log randNo   x000D   x000D   x000D    I have been using it for 1 month with great results

User · Answer

Here s an improvement on doubletap s excellent answer  The original has two drawbacks which are addressed here   First  as others have mentioned  it has a small probability of producing short strings or even an empty string  if the random number is 0   which may break your application  Here is a solution    Math random   toString 36   00000000000000000   slice 2  N 2    Second  both the original and the solution above limit the string size N to 16 characters  The following will return a string of size N for any N  but note that using N   16 will not increase the randomness or decrease the probability of collisions    Array N 1  join  Math random   toString 36   00000000000000000   slice 2  18   slice 0  N    Explanation    Pick a random number in the range  0 1   i e  between 0  inclusive  and 1  exclusive   Convert the number to a base-36 string  i e  using characters 0-9 and a-z  Pad with zeros  solves the first issue   Slice off the leading  0   prefix and extra padding zeros  Repeat the string enough times to have at least N characters in it  by Joining empty strings with the shorter random string used as the delimiter   Slice exactly N characters from the string    Further thoughts    This solution does not use uppercase letters  but in almost all cases  no pun intended  it does not matter  The maximum string length at N   16 in the original answer is measured in Chrome  In Firefox it s N   11  But as explained  the second solution is about supporting any requested string length  not about adding randomness  so it doesn t make much of a difference  All returned strings have an equal probability of being returned  at least as far as the results returned by Math random   are evenly distributed  this is not cryptographic-strength randomness  in any case   Not all possible strings of size N may be returned  In the second solution this is obvious  since the smaller string is simply being duplicated   but also in the original answer this is true since in the conversion to base-36 the last few bits may not be part of the original random bits  Specifically  if you look at the result of Math random   toString 36   you ll notice the last character is not evenly distributed  Again  in almost all cases it does not matter  but we slice the final string from the beginning rather than the end of the random string so that short strings  e g  N 1  aren t affected    Update   Here are a couple other functional-style one-liners I came up with  They differ from the solution above in that    They use an explicit arbitrary alphabet  more generic  and suitable to the original question which asked for both uppercase and lowercase letters   All strings of length N have an equal probability of being returned  i e  strings contain no repetitions   They are based on a map function  rather than the toString 36  trick  which makes them more straightforward and easy to understand    So  say your alphabet of choice is  var s    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789     Then these two are equivalent to each other  so you can pick whichever is more intuitive to you   Array N  join   split      map function     return s charAt Math floor Math random     s length       join        and  Array apply null  Array N   map function     return s charAt Math floor Math random     s length       join        Edit   I seems like qubyte and Martijn de Milliano came up with solutions similar to the latter  kudos    which I somehow missed  Since they don t look as short at a glance  I ll leave it here anyway in case someone really wants a one-liner  -   Also  replaced  new Array  with  Array  in all solutions to shave off a few more bytes

User · Answer

Simple method   function randomString length        let chars       output           for  let i   32  i  lt  127  i               chars push String fromCharCode i              for  let i   0  i  lt  length  i               output    chars Math floor Math random     chars length               return output      If you want more or less characters change the  127  to something else

User · Answer

This is not a perfect solution  but it should work  If you ever get any error  then increase the value given in Uint8Array   constructor  The advantage of this method is it uses getRandomValues   method that generates cryptographically strong random values   x000D   x000D  var array   new Uint8Array 20   crypto getRandomValues array   var arrayEncoded    btoa String fromCharCode    array   split      var arrayFiltered   arrayEncoded filter value   gt        switch  value       case               return false      case               return false      case               return false      default         return true           var password   arrayFiltered slice 0 5  join      console log password   x000D   x000D   x000D   A compact Version  x000D   x000D  var array   new Uint8Array 20   crypto getRandomValues array   var password   btoa String fromCharCode    array   split     filter value   gt            return                  includes value      slice 0 5  join      console log password   x000D   x000D   x000D

User · Answer

The simplest way is     new Date 9e6  toString 36    This generate random strings of 5 characters based on the current time  Example output is 4mtxj or 4mv90 or 4mwp1  The problem with this is that if you call it two times on the same second  it will generate the same string    The safer way is     0 Math random   9e6  toString 36    This will generate a random string of 4 or 5 characters  always diferent  Example output is like 30jzm or 1r591 or 4su1a  In both ways the first part generate a random number  The  toString 36  part cast the number to a base36  alphadecimal  representation of it

User · Answer

The following code will produce a cryptographically secured random string of size containing  a-zA-Z0-9   using an npm package crypto-random-string  Install it using  npm install crypto-random-string  To get a random string of 30 characters in the set  a-zA-Z0-9   const cryptoRandomString   require  crypto-random-string    cryptoRandomString  length  100  type   base64    replace        g     substr -30    Summary  We are replacing         in a large random base64 string and getting the last N characters  PS  Use -N in substr

User · Answer

The npm module anyid provides flexible API to generate various kinds of string ID   code   const id   anyid   encode  Aa0   length 5  random   id

User · Answer

In case you cannot type out a charset  using String fromCharCode and a ranged Math random allows you to create random strings in any Unicode codepoint range  For example  if you want 17 random Tibetan characters  you can input ranstr 17 0xf00 0xfff   where  0xf00 0xfff  corresponds to the Tibetan Unicode block  In my implementation  the generator will spit out ASCII text if you do not specify a codepoint range   x000D   x000D      function ranchar a b           a    a     undefined   0   a          b    b     undefined   127   b          return String fromCharCode Math floor Math random      b - a    a                    function ranstr len a b          a   a    32        var result             for var i   0  i  lt  len  i             result    ranchar a b                return result            Here are some examples from random Unicode blocks console log  In Latin Basic block     ranstr 10 0x0000 0x007f   console log  In Latin-1 Supplement block     ranstr 10 0x0080 0x0ff   console log  In Currency Symbols block      ranstr 10 0x20a0 0x20cf   console log  In Letterlike Symbols block      ranstr 10 0x2100 0x214f   console log  In Dingbats block     ranstr 10 0x2700 0x27bf   x000D   x000D   x000D

User · Answer

Math random is bad for this kind of thing Option 1 If you re able to do this server-side  just use the crypto module - var crypto   require  quot crypto quot    var id   crypto randomBytes 20  toString  hex         quot bb5dc8842ca31d4603d6aa11448d1654 quot   The resulting string will be twice as long as the random bytes you generate  each byte encoded to hex is 2 characters  20 bytes will be 40 characters of hex   Option 2 If you have to do this client-side  perhaps try the uuid module - var uuid   require  quot uuid quot    var id   uuid v4         quot 110ec58a-a0f2-4ac4-8393-c866d813b8d1 quot    Option 3 If you have to do this client-side and you don t have to support old browsers  you can do it without dependencies -  x000D   x000D     dec2hex    Integer - gt  String    i e  0-255 - gt   00 - ff  function dec2hex  dec      return dec toString 16  padStart 2   0         generateId    Integer - gt  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  x000D   x000D   x000D    For more information on crypto getRandomValues -  The crypto getRandomValues   method lets you get cryptographically strong random values  The array given as the parameter is filled with random numbers  random in its cryptographic meaning    Here s a little console example -  gt  var arr   new Uint8Array 4    make array of 4 bytes  values 0-255   gt  arr Uint8Array 4    0  0  0  0     gt  window crypto Crypto   subtle  SubtleCrypto     gt  window crypto getRandomValues   TypeError  Crypto getRandomValues requires at least 1 argument  but only 0 were passed   gt  window crypto getRandomValues arr  Uint8Array 4    235  229  94  228    For IE11 support you can use -  window crypto    window msCrypto  getRandomValues arr   For browser coverage see https   caniuse com  feat getrandomvalues

User · Answer

One liner   Array 15  fill null  map      gt  Math random   toString 36  substr 2   join        Outputs  0h61cbpw96y83qtnunwme5lxk1i70a6o5r5lckfcyh1dl9fffydcfxddd69ada9tu9jvqdx864xj1ul3wtfztmh2oz2vs3mv6ej0fe58ho1cftkjcuyl2lfkmxlwua83ibotxqc4guyuvrvtf60naob26t6swzpil

User · Answer

very simple  function getRandomColor      var color       while color length lt 6       color Math floor Math random   16777215  toString 16         return     color

User · Answer

This works for sure   lt script language  javascript  type  text javascript  gt  function randomString      var chars    0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz    var string length   8   var randomstring        for  var i 0  i lt string length  i        var rnum   Math floor Math random     chars length     randomstring    chars substring rnum rnum 1       document randform randomfield value   randomstring     lt  script gt

User · Answer

How about extending the String object like so  String prototype random   function length       var result          for  var i   0  i  lt  length  i            result    this charAt Math floor Math random     this length             return result       using it  console log  quot ABCDEFG quot  random 5

User · Answer

Random unicode string  This method will return a random string with any of the supported unicode characters  which is not 100  what OP asks for  but what I was looking for   function randomUnicodeString length       return Array from  length  length       gt           return String fromCharCode Math floor Math random      65536           join         Rationale  This is the top result of google when searching for  random string javascript   but OP asks for a-zA-Z0-9 only

User · Answer

recursive solution   function generateRamdomId  seedStr    const len   seedStr length console log  possibleStr   seedStr     len    len  if len  lt   1       return seedStr   const randomValidIndex    Math floor Math random     len  const randomChar   seedStr randomValidIndex  const chunk1   seedStr slice 0  randomValidIndex  const chunk2   seedStr slice randomValidIndex  1  const possibleStrWithoutRandomChar   chunk1 concat chunk2   return randomChar   generateRamdomId possibleStrWithoutRandomChar       you can use with the seed you want   dont repeat chars if you dont rea   Example   generateRandomId  ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789

User · Answer

Random numeric value  up to 16 digits          Random numeric value  up to 16 digits      returns  String      function randomUid        return String Math floor Math random     9e15         randomUid   - gt   3676724552601324

User · Answer

I did not find a clean solution for supporting both lowercase and uppercase characters   Lowercase only support   Math random   toString 36  substr 2  5   Building on that solution to support lowercase and uppercase   Math random   toString 36  substr 2  5  split     map c   gt  Math random    lt  0 5   c toUpperCase     c  join       Change the 5 in substr 2  5  to adjust to the length you need

User · Answer

Here are some easy one liners  Change new Array 5  to set the length   Including 0-9a-z  new Array 5  join   replace        g  function   return   Math random   36  0  toString 36       Including 0-9a-zA-Z  new Array 5  join   replace        g  function   return   Math random   36  0  toString 36  Math random   lt  5  toString   toUpperCase

[javascript] Generate random string/characters in JavaScript

Examples related to javascript

Examples related to string

Examples related to random