There are so many ways to generate random strings in JavaScript and it doesn't really matter which method is faster.

The method I like using most is `Math.random()`

I made a video on it:

Basically the idea is to use `Math.random()`

, then you can convert it to string and do some simple string manipulation on it.

To get random numbers, I would use something like below:

```
Math.ceil(Math.random()*10000)
```

To get random strings with numbers only, I would use:

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

Fortunate `.toString()`

has a param called `radix`

that you can pass in numbers between `2 - 36`

which will cast the generated numbers to the radix characters that fall between the given number. The `radix`

is also known as `base`

and its for representing numeric values

To get a random number between 0-1:

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

To get a random number between 0-5:

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

Starting from 11/12, it will start introducing letters. So to get a fully random string:

```
Math.random().toString(20).substr(2, 6)
```

With this you can now write your awesome random string generator:

```
const generateRandomString = function(){
return Math.random().toString(20).substr(2, 6)
}
```

To be able to change the length of the output:

```
const generateRandomString = function(length=6){
return Math.random().toString(20).substr(2, length)
}
```

One liner

```
const generateRandomString = (length=6)=>Math.random().toString(20).substr(2, length)
```

That's all.

If you know of any other faster ways, please I would love to see it in the comment section.

Thanks

## Discussion (6)

Nice function! But one thing I noticed is that this will only work for random alpha-numeric strings up to a certain length. If you want to have something longer, you should call the method recursively. Something like:

Yep, looks like it tops out at 12-13 characters for me, demo here: jsfiddle.net/mberwk8a/2/

Hi, thanks for the simple, straight-forward article! I just wanted to point out a small error in your one-liner. You define the

`length`

variable, but you still used a hard-coded "6" instead of it in the expression.Do you like base20 for something special?

No reason actually, I just like using it.

Just to clarify for people who don't know, the radix argument for

`toString`

goes from 2 to 36, and you need to use 36 to include all alphanumeric characters in the alphabet. Using 20 will omit more than half of the alphabetic letters from the output.