## DEV Community 👩‍💻👨‍💻 is a community of 966,904 amazing developers

We're a place where coders share, stay up-to-date and grow their careers.

sk9

Posted on

# Why I don't like JavaScript

When I want to get a unique random sequence ...

### R

``````print(sample(1:10, 10))
``````

### Python

``````import random
l = list(range(1, 10 + 1))
print(random.sample(l, 10))
``````

### JavaScript

``````function getRandomInt(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}

function getRandomArray(min, max) {
let result = [];
for (i = min; i <= max; i++) {
while (true) {
let v = getRandomInt(min, max);
if (!result.includes(v)) {
result.push(v);
break;
}
}
}
return result;
}

console.log(getRandomArray(1, 10));
``````

## Top comments (8)

While I get that this is a joke, that `getRandomArray`-function is a bit verbose. This does the same thing:

``````new Array(10).fill(0).map(() => getRandomInt(1, 10))
``````

Edit: unique list:

``````new Array(10).fill(1).map((n, i) => n + i).sort(() => Math.random() - 0.5)
``````

Avalander

Not really, since the intent of the original implementation is to generate a sequence of unique elements, and your implementation can yield duplicated values.

A better approach would be to just generate the sequence in order and shuffle it:

``````const range = (from, to) => {
const data = []
for (let i = from; i <= to; i++) data.push(i)
return data
}

const randSeq = (min, max) => {
const data = range(min, max)
data.sort(() => Math.random() - 0.5)
return data
}
``````

The `data.sort` trick doesn't produce a lot of variations, though. A better way is to generate the sorted array and pick elements from a random index and add them to a new array.

``````const randSeq2 = (min, max) => {
const data = range(min, max)
const result = []
while (data.length > 0) {
const i = randInt(0, data.length - 1)
result.push(data[i])
data.splice(i, 1)
}
return result
}
``````

At this point the implementation is equally verbose to the original, so ¯\_(ツ)_/¯. But it avoids unnecessary iterations when duplicated values are generated.

Stephen Ramthun

Nice catch, thanks! Didn't realise that the list had to be unique. Could you explain what you mean by `.sort()` not producing a lot of variations?

Thread

Avalander • Edited on

`[].sort(() => Math.random() - 0.5)` tends to not displace elements in the array a lot. An element might be moved a few positions forward or backward, but it will generally stay close to its original position. Therefore, when used to shuffle an array, the result will be more similar to the original array than with other algorithms.

As an example, here's the output of three runs with `randSeq` and three runs with `randSeq2`:

``````# randSeq
[ 1, 3, 4, 5, 9, 7, 6, 8, 2, 10 ]
[ 7, 1, 2, 3, 6, 8, 4, 5, 9, 10 ]
[ 2, 3, 1, 4, 6, 9, 8, 5, 7, 10 ]

# randSeq2
[ 5, 1, 7, 10, 4, 6, 3, 9, 8, 2 ]
[ 7, 1, 6, 9, 5, 8, 3, 4, 10, 2 ]
[ 2, 6, 4, 10, 9, 8, 5, 3, 1, 7 ]
``````

You can notice that with the `randSeq` the array is less shuffled than with `randSeq2` and the elements show a clear tendency to be larger the further back they are in the array.

Thread

Stephen Ramthun

Makes sense. Thanks!

ayrbox

That's a weird reason for liking and not liking a language. 🤦‍♂️😂

Maarten Demeyer

That R implementation is too verbose as well, just `sample(10)` will do! 😛

joon • Edited on

Import lodash and use their sample...

It gets pretty much as short as the python version

## Visualizing Promises and Async/Await 🤯

☝️ Check out this all-time classic DEV post