JavaScript 배열을 무작위 화 (셔플)하는 방법은 무엇입니까?
다음과 같은 배열이 있습니다.
var arr1 = ["a", "b", "c", "d"];
무작위 화 / 셔플은 어떻게하나요?
사실상 무 편향 셔플 알고리즘은 Fisher-Yates (일명 Knuth) 셔플입니다.
참조 https://github.com/coolaj86/knuth-shuffle를
여기 에서 멋진 시각화를 볼 수 있습니다 (그리고 여기에 링크 된 원본 게시물 ).
function shuffle(array) {
var currentIndex = array.length, temporaryValue, randomIndex;
// While there remain elements to shuffle...
while (0 !== currentIndex) {
// Pick a remaining element...
randomIndex = Math.floor(Math.random() * currentIndex);
currentIndex -= 1;
// And swap it with the current element.
temporaryValue = array[currentIndex];
array[currentIndex] = array[randomIndex];
array[randomIndex] = temporaryValue;
}
return array;
}
// Used like so
var arr = [2, 11, 37, 42];
arr = shuffle(arr);
console.log(arr);사용 된 알고리즘에 대한 추가 정보 .
다음은 Fisher-Yates의 컴퓨터 최적화 버전 인 Durstenfeld shuffle 의 JavaScript 구현입니다 .
/**
* Randomize array element order in-place.
* Using Durstenfeld shuffle algorithm.
*/
function shuffleArray(array) {
for (var i = array.length - 1; i > 0; i--) {
var j = Math.floor(Math.random() * (i + 1));
var temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
Fisher-Yates 알고리즘은 각 원래 배열 요소에 대해 하나의 임의 요소를 선택하고 다음 그리기에서 제외하는 방식으로 작동합니다. 카드 한 벌에서 무작위로 선택하는 것과 같습니다.
이 제외는 선택한 요소를 현재 요소로 교체 한 다음 나머지 요소에서 다음 임의의 요소를 선택하여 (Durstenfeld가 컴퓨터에서 사용하기 위해 발명 한) 영리한 방법으로 수행됩니다. 최적의 효율성을 위해 루프는 역방향으로 실행되어 임의 선택이 단순화되고 (항상 0에서 시작할 수 있음) 더 이상 다른 선택이 없기 때문에 마지막 요소를 건너 뜁니다.
이 알고리즘의 실행 시간은 O (n)입니다. 셔플은 제자리에서 수행됩니다. 따라서 원래 배열을 수정하지 않으려면 먼저 .slice(0).
ES6 / ECMAScript 2015로 업데이트
새로운 ES6를 사용하면 한 번에 두 개의 변수를 할당 할 수 있습니다. 이것은 우리가 한 줄의 코드로 할 수 있기 때문에 두 변수의 값을 바꾸고 싶을 때 특히 편리합니다. 다음은이 기능을 사용하는 동일한 기능의 짧은 형식입니다.
function shuffleArray(array) {
for (let i = array.length - 1; i > 0; i--) {
const j = Math.floor(Math.random() * (i + 1));
[array[i], array[j]] = [array[j], array[i]];
}
}
[커뮤니티 편집 :이 답변은 올바르지 않습니다. 주석을 참조하십시오. 아이디어가 그렇게 드물지 않기 때문에 향후 참조를 위해 여기에 남겨두고 있습니다.]
[1,2,3,4,5,6].sort(function() {
return .5 - Math.random();
});
Array에서 프로토 타입으로 사용할 수 있거나 사용해야합니다.
ChristopheD에서 :
Array.prototype.shuffle = function() {
var i = this.length, j, temp;
if ( i == 0 ) return this;
while ( --i ) {
j = Math.floor( Math.random() * ( i + 1 ) );
temp = this[i];
this[i] = this[j];
this[j] = temp;
}
return this;
}
underscore.js 라이브러리를 사용하십시오. _.shuffle()이 경우에는 방법 이 좋습니다. 다음은 메서드의 예입니다.
var _ = require("underscore");
var arr = [1,2,3,4,5,6];
// Testing _.shuffle
var testShuffle = function () {
var indexOne = 0;
var stObj = {
'0': 0,
'1': 1,
'2': 2,
'3': 3,
'4': 4,
'5': 5
};
for (var i = 0; i < 1000; i++) {
arr = _.shuffle(arr);
indexOne = _.indexOf(arr, 1);
stObj[indexOne] ++;
}
console.log(stObj);
};
testShuffle();
지도 및 정렬로 쉽게 할 수 있습니다.
let unshuffled = ['hello', 'a', 't', 'q', 1, 2, 3, {cats: true}]
let shuffled = unshuffled
.map((a) => ({sort: Math.random(), value: a}))
.sort((a, b) => a.sort - b.sort)
.map((a) => a.value)
- 배열의 각 요소를 객체에 넣고 임의의 정렬 키를 제공합니다.
- 무작위 키를 사용하여 정렬합니다.
- 원래 객체를 얻기 위해 매핑을 해제합니다.
다형성 배열을 섞을 수 있으며 정렬은 Math.random만큼 무작위로 대부분의 목적에 충분합니다.
요소가 반복 될 때마다 재생성되지 않는 일관된 키에 대해 정렬되고 각 비교가 동일한 분포에서 가져 오기 때문에 Math.random 분포에서 임의성이 아닌 것은 모두 취소됩니다.
새로운!
더 짧고 아마도 * 빠른 Fisher-Yates 셔플 알고리즘
- 그것은 동안 사용 ---
- 비트 단위에서 바닥까지 (최대 10 진수 (32 비트)까지의 숫자)
- 불필요한 폐쇄 및 기타 항목 제거
function fy(a,b,c,d){//array,placeholder,placeholder,placeholder
c=a.length;while(c)b=Math.random()*(--c+1)|0,d=a[c],a[c]=a[b],a[b]=d
}
스크립트 크기 (함수 이름으로 fy 포함) : 90 바이트
데모 http://jsfiddle.net/vvpoma8w/
* 크롬을 제외한 모든 브라우저에서 더 빠릅니다.
질문이 있으면 물어보십시오.
편집하다
네 더 빠릅니다
성능 : http://jsperf.com/fyshuffle
최고 투표 기능을 사용합니다.
편집 초과 계산이 있었고 (-c + 1 필요 없음) 아무도 알아 차리지 못했습니다.
짧게 (4 바이트) & 빠르게 (테스트 해보세요!).
function fy(a,b,c,d){//array,placeholder,placeholder,placeholder
c=a.length;while(c)b=Math.random()*c--|0,d=a[c],a[c]=a[b],a[b]=d
}
다른 곳에 캐싱 var rnd=Math.random한 다음 사용 rnd()하면 대형 어레이의 성능이 약간 향상됩니다.
http://jsfiddle.net/vvpoma8w/2/
읽을 수있는 버전 (원래 버전을 사용하십시오. 이것은 더 느리고, vars는 클로저 & ";"처럼 쓸모 없고, 코드 자체도 더 짧습니다. ... 아마도 이것을 읽으십시오. 자바 스크립트 코드를 '축소'하는 방법 , btw 당신은 할 수 없습니다 위와 같은 javascript minifiers에서 다음 코드를 압축하십시오.)
function fisherYates( array ){
var count = array.length,
randomnumber,
temp;
while( count ){
randomnumber = Math.random() * count-- | 0;
temp = array[count];
array[count] = array[randomnumber];
array[randomnumber] = temp
}
}
작은 배열을위한 아주 간단한 방법은 다음과 같습니다.
const someArray = [1, 2, 3, 4, 5];
someArray.sort(() => Math.random() - 0.5);
아마도 그다지 효율적이지 않지만 작은 배열의 경우 잘 작동합니다. 여기에 예제가 있으므로 그것이 얼마나 무작위인지 아닌지, 그리고 그것이 당신의 사용 사례에 맞는지 여부를 볼 수 있습니다.
const resultsEl = document.querySelector('#results');
const buttonEl = document.querySelector('#trigger');
const generateArrayAndRandomize = () => {
const someArray = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
someArray.sort(() => Math.random() - 0.5);
return someArray;
};
const renderResultsToDom = (results, el) => {
el.innerHTML = results.join(' ');
};
buttonEl.addEventListener('click', () => renderResultsToDom(generateArrayAndRandomize(), resultsEl));<h1>Randomize!</h1>
<button id="trigger">Generate</button>
<p id="results">0 1 2 3 4 5 6 7 8 9</p>답변 중 일부는 ES6 구문을 사용하여 단축 할 수 있습니다.
ES6 순수, 반복
const getShuffledArr = arr => {
const newArr = arr.slice()
for (let i = newArr.length - 1; i > 0; i--) {
const rand = Math.floor(Math.random() * (i + 1));
[newArr[i], newArr[rand]] = [newArr[rand], newArr[i]];
}
return newArr
};
개인적으로이 기능은 순수하고 상대적으로 간단하며 Google Chrome에서의 테스트에 따르면 가장 효율적이기 때문에 사용합니다 (다른 순수 버전에 비해).
배열 순서 섞기
function shuffledArr (array){
for (let i = array.length - 1; i > 0; i--) {
const rand = Math.floor(Math.random() * (i + 1));
[array[i], array[rand]] = [array[rand], array[i]]
}
}
신뢰성과 성능
이 페이지에서 볼 수 있듯이 과거에는 여기에 잘못된 솔루션이 제공되었습니다. 따라서 안정성과 성능을 염두에두고 순수한 (부작용이없는) 배열 무작위 함수를 테스트하기 위해 다음 함수를 작성했습니다. 이 답변에 제시된 모든 옵션을 테스트하는 데 사용했습니다.
function testShuffledArrayFun(getShuffledArrayFun){
const arr = [0,1,2,3,4,5,6,7,8,9]
let countArr = arr.map(el=>{
return arr.map(
el=> 0
)
}) // For each possible position in the shuffledArr and for
// each possible value, we'll create a counter.
const t0 = performance.now()
const n = 1000000
for (let i=0 ; i<n ; i++){
// We'll call getShuffledArrayFun n times.
// And for each iteration, we'll increment the counter.
const shuffledArr = getShuffledArrayFun(arr)
shuffledArr.forEach(
(value,key)=>{countArr[key][value]++}
)
}
const t1 = performance.now()
console.log(`Count Values in position`)
console.table(countArr)
const frequencyArr = countArr.map( positionArr => (
positionArr.map(
count => count/n
)
))
console.log("Frequency of value in position")
console.table(frequencyArr)
console.log(`total time: ${t1-t0}`)
}
다른 옵션
ES6 순수, 재귀
const getShuffledArr = arr => {
if (arr.length === 1) {return arr};
const rand = Math.floor(Math.random() * arr.length);
return [arr[rand], ...getShuffledArr(arr.filter((_, i) => i != rand))];
};
array.map을 사용하는 ES6 Pure
function getShuffledArr (arr){
return [...arr].map( (_, i, arrCopy) => {
var rand = i + ( Math.floor( Math.random() * (arrCopy.length - i) ) );
[arrCopy[rand], arrCopy[i]] = [arrCopy[i], arrCopy[rand]]
return arrCopy[i]
})
}
array.reduce를 사용하는 ES6 Pure
function getShuffledArr (arr){
return arr.reduce(
(newArr, _, i) => {
var rand = i + ( Math.floor( Math.random() * (newArr.length - i) ) );
[newArr[rand], newArr[i]] = [newArr[i], newArr[rand]]
return newArr
}, [...arr]
)
}
Typescript-순수 배열 랜덤 화 함수의 유형
다음 중 하나를 사용할 수 있습니다.
type GetShuffledArr= <T>(arr:Array<T>) => Array<T>
interface IGetShuffledArr{
<T>(arr:Array<T>): Array<T>
}
@Laurens Holsts 답변에 추가. 이것은 50 % 압축됩니다.
function shuffleArray(d) {
for (var c = d.length - 1; c > 0; c--) {
var b = Math.floor(Math.random() * (c + 1));
var a = d[c];
d[c] = d[b];
d[b] = a;
}
return d
};
//one line solution
shuffle = (array) => array.sort(() => Math.random() - 0.5);
//Demo
let arr = [1, 2, 3];
shuffle(arr);
alert(arr);
https://javascript.info/task/shuffle
ES2015에서는 다음을 사용할 수 있습니다.
Array.prototype.shuffle = function() {
let m = this.length, i;
while (m) {
i = (Math.random() * m--) >>> 0;
[this[m], this[i]] = [this[i], this[m]]
}
return this;
}
용법:
[1, 2, 3, 4, 5, 6, 7].shuffle();
var shuffle = function(array) {
temp = [];
originalLength = array.length;
for (var i = 0; i < originalLength; i++) {
temp.push(array.splice(Math.floor(Math.random()*array.length),1));
}
return temp;
};
이 질문의 중복에 대한 "작성자가 삭제함"답변에서이 변종이 걸려있는 것을 발견했습니다. 이미 많은 찬성 투표가있는 다른 답변과 달리 다음은 다음과 같습니다.
- 실제로 무작위
- 제자리에 있지 않음 (따라서
shuffled이름이 아니라shuffle) - 여기에 여러 변형이 아직 없습니다.
다음은 사용중인 jsfiddle 입니다.
Array.prototype.shuffled = function() {
return this.map(function(n){ return [Math.random(), n] })
.sort().map(function(n){ return n[1] });
}
다음과 같이 쉽게 할 수 있습니다.
// array
var fruits = ["Banana", "Orange", "Apple", "Mango"];
// random
fruits.sort(function(a, b){return 0.5 - Math.random()});
// out
console.log(fruits);JavaScript Sorting Arrays를 참조하십시오.
재귀 솔루션 :
function shuffle(a,b){
return a.length==0?b:function(c){
return shuffle(a,(b||[]).concat(c));
}(a.splice(Math.floor(Math.random()*a.length),1));
};
소스 배열을 변경하지 않는 셔플 함수
업데이트 : 여기에서는 비교적 단순하고 ( 복잡한 관점 에서 가 아니라 ) 짧은 알고리즘을 제안하고 있는데, 이는 작은 크기의 배열로 잘 작동하지만, 거대한 배열을 다룰 때 고전적인 Durstenfeld 알고리즘 보다 훨씬 더 많은 비용이들 것 입니다. 이 질문에 대한 상위 답변 중 하나 에서 Durstenfeld 를 찾을 수 있습니다 .
원래 답변 :
당신이 경우 원하지 않는 돌연변이 당신의 셔플 기능을 소스 배열을 , 당신은 간단한으로 나머지를 로컬 변수에 복사 할 수 있습니다 셔플 논리 .
function shuffle(array) {
var result = [], source = array.concat([]);
while (source.length) {
let index = Math.floor(Math.random() * source.length);
result.push(source[index]);
source.splice(index, 1);
}
return result;
}
셔플 링 로직 : 임의의 인덱스를 선택한 다음 해당 요소를 결과 배열에 추가 하고 소스 배열 사본 에서 삭제합니다 . 소스 배열이 비워 질 때까지이 작업을 반복합니다 .
그리고 정말 짧게하고 싶다면 여기에 내가 얻을 수있는 거리가 있습니다.
function shuffle(array) {
var result = [], source = array.concat([]);
while (source.length) {
let index = Math.floor(Math.random() * source.length);
result.push(source.splice(index, 1)[0]);
}
return result;
}
Fisher-Yates 는 자바 스크립트에서 셔플합니다. 두 가지 유틸리티 함수 (swap 및 randInt)를 사용하면 여기에 다른 답변과 비교하여 알고리즘이 명확하기 때문에 여기에 게시하고 있습니다.
function swap(arr, i, j) {
// swaps two elements of an array in place
var temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
function randInt(max) {
// returns random integer between 0 and max-1 inclusive.
return Math.floor(Math.random()*max);
}
function shuffle(arr) {
// For each slot in the array (starting at the end),
// pick an element randomly from the unplaced elements and
// place it in the slot, exchanging places with the
// element in the slot.
for(var slot = arr.length - 1; slot > 0; slot--){
var element = randInt(slot+1);
swap(arr, element, slot);
}
}
우선, 여기 에서 자바 스크립트의 다양한 정렬 방법을 시각적으로 비교할 수 있습니다.
둘째, 위의 링크를 빠르게 살펴보면 random order정렬이 다른 방법에 비해 상대적으로 잘 수행되는 반면 아래와 같이 구현하기가 매우 쉽고 빠르다는 것을 알 수 있습니다.
function shuffle(array) {
var random = array.map(Math.random);
array.sort(function(a, b) {
return random[array.indexOf(a)] - random[array.indexOf(b)];
});
}
편집 : @gregers가 지적했듯이 비교 함수는 인덱스가 아닌 값으로 호출되므로 indexOf. 이러한 변경으로 인해 코드 indexOf가 O (n) 시간에 실행되므로 더 큰 배열에 적합하지 않습니다 .
엄격한 모드를 사용하는 Fisher-Yates의 또 다른 구현 :
function shuffleArray(a) {
"use strict";
var i, t, j;
for (i = a.length - 1; i > 0; i -= 1) {
t = a[i];
j = Math.floor(Math.random() * (i + 1));
a[i] = a[j];
a[j] = t;
}
return a;
}
다른 모든 답변은 빠르지 만 암호화 수준 무작위 화에 적합하지 않은 Math.random ()을 기반으로합니다.
아래의 코드는 잘 알려진 사용 Fisher-Yates이용하면서 알고리즘을 Web Cryptography API위해 임의의 레벨 암호화 .
var d = [1,2,3,4,5,6,7,8,9,10];
function shuffle(a) {
var x, t, r = new Uint32Array(1);
for (var i = 0, c = a.length - 1, m = a.length; i < c; i++, m--) {
crypto.getRandomValues(r);
x = Math.floor(r / 65536 / 65536 * m) + i;
t = a [i], a [i] = a [x], a [x] = t;
}
return a;
}
console.log(shuffle(d));ES6 기능을 사용하는 최신 짧은 인라인 솔루션 :
['a','b','c','d'].map(x => [Math.random(), x]).sort(([a], [b]) => a - b).map(([_, x]) => x);
(교육 목적)
파이에 손가락 하나만 넣으려고. 여기에서는 Fisher Yates 셔플의 재귀 구현을 제시합니다. 균일 한 임의성을 제공합니다.
참고 : ~~(이중 물결표 연산자)는 실제로 Math.floor()양의 실수 처럼 작동 합니다. 그냥 지름길입니다.
var shuffle = a => a.length ? a.splice(~~(Math.random()*a.length),1).concat(shuffle(a))
: a;
console.log(JSON.stringify(shuffle([0,1,2,3,4,5,6,7,8,9])));원래 배열을 수정하지 않는 CoolAJ86의 답변에 대한 간단한 수정 :
/**
* Returns a new array whose contents are a shuffled copy of the original array.
* @param {Array} The items to shuffle.
* https://stackoverflow.com/a/2450976/1673761
* https://stackoverflow.com/a/44071316/1673761
*/
const shuffle = (array) => {
let currentIndex = array.length;
let temporaryValue;
let randomIndex;
const newArray = array.slice();
// While there remains elements to shuffle...
while (currentIndex) {
randomIndex = Math.floor(Math.random() * currentIndex);
currentIndex -= 1;
// Swap it with the current element.
temporaryValue = newArray[currentIndex];
newArray[currentIndex] = newArray[randomIndex];
newArray[randomIndex] = temporaryValue;
}
return newArray;
};
이미 많은 구현이 권장되었지만 forEach 루프를 사용하여 더 짧고 쉽게 만들 수 있다고 생각하므로 배열 길이 계산에 대해 걱정할 필요가 없으며 임시 변수 사용을 안전하게 피할 수 있습니다.
var myArr = ["a", "b", "c", "d"];
myArr.forEach((val, key) => {
randomIndex = Math.ceil(Math.random()*(key + 1));
myArr[key] = myArr[randomIndex];
myArr[randomIndex] = val;
});
// see the values
console.log('Shuffled Array: ', myArr)
최단 arrayShuffle기능
function arrayShuffle(o) {
for(var j, x, i = o.length; i; j = parseInt(Math.random() * i), x = o[--i], o[i] = o[j], o[j] = x);
return o;
}
이론적 관점에서 가장 우아한 방법은 0 과 n! -1 사이 의 단일 난수 를 얻고 모든 순열 에서 일대일 매핑을 계산하는 것 입니다 . 큰 편향없이 그러한 숫자를 얻을 수있을만큼 신뢰할 수있는 (의사) 난수 생성기를 사용할 수있는 한, 다른 난수 없이도 원하는 것을 얻을 수있는 충분한 정보가 있습니다.{0, 1, …, n!-1}(0, 1, 2, …, n-1)
IEEE754 배정 밀도 부동 숫자로 계산할 때 임의 생성기가 약 15 개의 소수를 제공 할 것으로 예상 할 수 있습니다. 당신이 있기 때문에 15! = 1,307,674,368,000 (13 자리), 당신은 배열 (15 개) 요소까지 포함하고 배열 (14 개) 요소까지 포함와 유의 한 바이어스가 없을 것입니다 가정에 다음과 같은 기능을 사용할 수 있습니다. 이 셔플 작업을 여러 번 계산해야하는 고정 크기 문제에 대해 작업 하는 경우 한 번만 사용하므로 다른 코드보다 빠를 수 있는 다음 코드를 시도 할 수 있습니다 Math.random(하지만 여러 복사 작업이 포함됨).
다음 기능은 사용되지 않지만 어쨌든 제공합니다. (0, 1, 2, …, n-1)이 메시지에 사용 된 일대일 매핑에 따라 주어진 순열의 인덱스를 반환합니다 (순열을 열거 할 때 가장 자연스러운 매핑). 최대 16 개의 요소와 함께 작동하도록되어 있습니다.
function permIndex(p) {
var fact = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000];
var tail = [];
var i;
if (p.length == 0) return 0;
for(i=1;i<(p.length);i++) {
if (p[i] > p[0]) tail.push(p[i]-1);
else tail.push(p[i]);
}
return p[0] * fact[p.length-1] + permIndex(tail);
}
이전 함수의 역수 (자신의 질문에 필요함)는 다음과 같습니다. 최대 16 개의 요소와 함께 작동하도록되어 있습니다. 이 주문의 순열 반환 N 의를 (0, 1, 2, …, s-1):
function permNth(n, s) {
var fact = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000];
var i, j;
var p = [];
var q = [];
for(i=0;i<s;i++) p.push(i);
for(i=s-1; i>=0; i--) {
j = Math.floor(n / fact[i]);
n -= j*fact[i];
q.push(p[j]);
for(;j<i;j++) p[j]=p[j+1];
}
return q;
}
이제 원하는 것은 다음과 같습니다.
function shuffle(p) {
var fact = [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000, 20922789888000];
return permNth(Math.floor(Math.random()*fact[p.length]), p.length).map(
function(i) { return p[i]; });
}
이론적 인 편견이 거의없는 최대 16 개의 요소에 대해 작동해야합니다 (실용적인 관점에서는 눈에 띄지 않지만). 15 개 요소에 대해 완전히 사용 가능하다고 볼 수 있습니다. 14 개 미만의 요소를 포함하는 배열의 경우 편향이 전혀 없다고 안전하게 고려할 수 있습니다.
재미있게도 비 돌연변이 재귀 답변이 없었습니다.
var shuffle = arr => {
const recur = (arr,currentIndex)=>{
console.log("What?",JSON.stringify(arr))
if(currentIndex===0){
return arr;
}
const randomIndex = Math.floor(Math.random() * currentIndex);
const swap = arr[currentIndex];
arr[currentIndex] = arr[randomIndex];
arr[randomIndex] = swap;
return recur(
arr,
currentIndex - 1
);
}
return recur(arr.map(x=>x),arr.length-1);
};
var arr = [1,2,3,4,5,[6]];
console.log(shuffle(arr));
console.log(arr);array.splice ()를 사용하여 배열 무작위 화
function shuffleArray(array) {
var temp = [];
var len=array.length;
while(len){
temp.push(array.splice(Math.floor(Math.random()*array.length),1)[0]);
len--;
}
return temp;
}
//console.log("Here >>> "+shuffleArray([4,2,3,5,8,1,0]));
Array.prototype.shuffle=function(){
var len = this.length,temp,i
while(len){
i=Math.random()*len-- |0;
temp=this[len],this[len]=this[i],this[i]=temp;
}
return this;
}
참고 URL : https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
'Programing' 카테고리의 다른 글
| jQuery로 확인란이 선택되어 있는지 확인하십시오. (0) | 2020.09.27 |
|---|---|
| Python에서 MySQL 데이터베이스에 어떻게 연결합니까? (0) | 2020.09.27 |
| git 저장소에서 디렉토리를 제거하는 방법은 무엇입니까? (0) | 2020.09.27 |
| 쉬운 인터뷰 질문이 더 어려워졌습니다 : 주어진 숫자 1..100, 정확히 주어진 k가없는 누락 된 숫자 찾기 (0) | 2020.09.27 |
| LF는 git에서 CRLF로 대체됩니다-그게 무엇이며 중요합니까? (0) | 2020.09.27 |