JavaScript 어레이를 랜덤화(shuffle)하는 방법

programing

JavaScript 어레이를 랜덤화(shuffle)하는 방법

goodsources 2022. 11. 1. 00:04

JavaScript 어레이를 랜덤화(shuffle)하는 방법

다음과 같은 어레이가 있습니다.

var arr1 = ["a", "b", "c", "d"];

랜덤화/셔플하려면 어떻게 해야 하나요?

사실상의 비바이어스 셔플 알고리즘은 피셔-예이츠(Knuth) 셔플입니다.

여기에서는, 뛰어난 비주얼라이제이션(및 여기에 링크된 원래의 투고)을 확인할 수 있습니다.

function shuffle(array) {
  let currentIndex = array.length,  randomIndex;

  // While there remain elements to shuffle.
  while (currentIndex != 0) {

    // Pick a remaining element.
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex--;

    // And swap it with the current element.
    [array[currentIndex], array[randomIndex]] = [
      array[randomIndex], array[currentIndex]];
  }

  return array;
}

// Used like so
var arr = [2, 11, 37, 42];
shuffle(arr);
console.log(arr);

사용된 알고리즘에 대한 추가 정보.

다음은 Fisher-Yates의 최적화된 버전인 Durstenfeld shuffle의 JavaScript 구현입니다.

/* Randomize array 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;
    }
}

각 원래 배열 요소에 대해 랜덤 요소를 선택하고 카드 덱에서 랜덤으로 선택하는 것과 같이 다음 추첨에서 제외합니다.

이 현명한 제외는 선택된 요소를 현재 요소와 스왑한 후 나머지 요소에서 다음 랜덤 요소를 선택하여 최적의 효율을 위해 뒤로 루프하고 랜덤 선택을 단순화(0에서 항상 시작할 수 있음)하여 최종 요소를 건너뜁니다.

은 " " " 입니다.O(n)shuffle은 즉석에서 이루어지기 때문에 원래 어레이를 변경하지 않을 경우 먼저 로 복사본을 만듭니다.

편집: ES6 / ECMAScript 2015로 업데이트

새로운 ES6에서는 2개의 변수를 동시에 할당할 수 있습니다.이 기능은 두 변수의 값을 한 줄의 코드로 교환할 수 있으므로 특히 유용합니다.이 기능을 사용한 같은 기능의 단축형을 다음에 나타냅니다.

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

지도와 정렬을 통해 쉽게 할 수 있습니다.

let unshuffled = ['hello', 'a', 't', 'q', 1, 2, 3, {cats: true}]

let shuffled = unshuffled
    .map(value => ({ value, sort: Math.random() }))
    .sort((a, b) => a.sort - b.sort)
    .map(({ value }) => value)
   
console.log(shuffled)

배열 내의 각 요소를 오브젝트에 배치하고 임의의 정렬 키를 부여합니다.
랜덤 키를 사용하여 정렬합니다.
원래 개체를 가져오기 위해 매핑을 해제합니다.

다형 배열을 혼합할 수 있으며, 정렬은 Math.random만큼 랜덤하므로 대부분의 용도로 적합합니다.

각 반복에서 재생성되지 않은 일관된 키에 따라 요소가 정렬되고 각 비교가 동일한 분포에서 풀되므로 Math.random 분포의 비랜덤성은 모두 취소됩니다.

속도

시간 복잡도는 O(N log N)로 빠른 정렬과 동일합니다.공간의 복잡도는 O(N)입니다.이것은 Fischer Yates 셔플만큼 효율적이지는 않지만, 제 생각에는 코드가 상당히 짧고 더 기능적입니다.대규모 어레이가 있는 경우에는 반드시 Fischer Yates를 사용해야 합니다.수백 개의 항목이 포함된 소규모 어레이가 있는 경우 이 작업을 수행할 수 있습니다.

경!!
이 알고리즘은 비효율적이고 편향성이 강하기 때문에 사용하지 않는 것이 좋습니다.주석을 참조해 주세요.그 아이디어는 드물지 않기 때문에 나중에 참고할 수 있도록 여기에 남겨져 있다.

[1,2,3,4,5,6].sort( () => .5 - Math.random() );

이 https://javascript.info/array-methods#shuffle-an-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;
}

언더스코어.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();

신기능!

짧고 *Fisher-Yates 셔플 알고리즘이 빠를 수 있습니다.

사용법은...-
bitwise to floor(최대 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/

* Chrome을 제외한 모든 브라우저에서 사용할 수 있습니다.

궁금한 게 있으면 그냥 물어보세요.

편집

그래, 그게 더 빨라요.

퍼포먼스: http://jsperf.com/fyshuffle

상위 투표 기능을 사용합니다.

EDIT 계산이 초과(필요 없음)되어 아무도 알아채지 못했습니다.

short(4바이트)&short(테스트!)

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에 런음음음 and를 사용하다rnd()또, 대규모 어레이의 퍼포먼스도 약간 향상합니다.

http://jsfiddle.net/vvpoma8w/2/

판독 가능한 버전(원본을 사용).이것은 느리고, 변수들은 쓸모가 없습니다.예를 들어 closures & ";"와 같이 코드 자체도 짧습니다.아마 이 Javascript code를 읽는 방법을 읽어보실 수 있습니다.Btw 위의 코드와 같은 Javascript minifier에서는 다음 코드를 압축할 수 없습니다.

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

어레이를 셔플하다

function shuffleArr (array){
    for (var i = array.length - 1; i > 0; i--) {
        var rand = Math.floor(Math.random() * (i + 1));
        [array[i], array[rand]] = [array[rand], array[i]]
    }
}

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

신뢰성 및 퍼포먼스 테스트

이 페이지의 일부 솔루션은 신뢰성이 낮습니다(어레이를 부분적으로 랜덤화할 뿐입니다).다른 솔루션은 효율성이 현저히 떨어집니다.★★★★★★★★★★★★★★★★ testShuffleArrayFun(아래 참조) 어레이 셔플링 기능의 신뢰성과 퍼포먼스를 테스트할 수 있습니다.

function testShuffleArrayFun(getShuffledArrayFun){
    const arr = [0,1,2,3,4,5,6,7,8,9]

    var 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 (var i=0 ; i<n ; i++){
        //   We'll call getShuffledArrayFun n times. 
        //   And for each iteration, we'll increment the counter. 
        var 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))];
};

ES6 array.map을 사용한 순수화

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]
    })
}

ES6 array.reduce를 사용한 순수화

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]
    )
}

편집: 이 답변은 올바르지 않습니다.

코멘트 및 https://stackoverflow.com/a/18650169/28234 를 참조해 주세요.아이디어가 드물지 않기 때문에 참고용으로 남겨져 있습니다.

스몰 어레이의 매우 심플한 방법은 다음과 같습니다.

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>

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

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();

나는 이 변종이 이 질문의 중복된 "작성자에 의해 삭제된" 대답에 걸려 있는 것을 발견했다.이미 많은 업보트가 있는 다른 답변과 달리 다음과 같습니다.

사실 랜덤
없음( "")shuffled보다 이름을 shuffle)
여기에는 여러 변종이 포함되어 있지 않습니다.

여기 사용 중인 jsfiddle이 있습니다.

Array.prototype.shuffled = function() {
  return this.map(function(n){ return [Math.random(), n] })
             .sort().map(function(n){ return n[1] });
}

//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

Math.random() - 0.5는 양수 또는 음수일 수 있는 난수이므로 정렬 함수는 요소를 랜덤하게 정렬합니다.

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

벤치마크

를 보고, 그 각 하겠습니다.shuffle -는 -

스플라이스가 느리다

「」를 사용한 splice ★★★★★★★★★★★★★★★★★」shift매우 느려질 것입니다.특히 어레이 크기를 늘리면 더욱 두드러집니다.는 -는 -는 -는 -는 -는 -입니다.

을 rand 위치, 위치,i 배열의 " " " "t
t[i]에 대해서
splice ★★★★★★★★★★★★★▼it

느린 효과를 과장하기 위해 100만 개의 요소 배열에서 이를 시연합니다.다음 스크립트는 거의 30초입니다.

const shuffle = t =>
  Array.from(sample(t, t.length))

function* sample(t, n)
{ let r = Array.from(t)
  while (n > 0 && r.length)
  { const i = rand(r.length) // 1
    yield r[i]               // 2
    r.splice(i, 1)           // 3
    n = n - 1
  }
}

const rand = n =>
  Math.floor(Math.random() * n)

function swap (t, i, j)
{ let q = t[i]
  t[i] = t[j]
  t[j] = q
  return t
}

const size = 1e6
const bigarray = Array.from(Array(size), (_,i) => i)
console.time("shuffle via splice")
const result = shuffle(bigarray)
console.timeEnd("shuffle via splice")
document.body.textContent = JSON.stringify(result, null, 2)

body::before {
  content: "1 million elements via splice";
  font-weight: bold;
  display: block;
}

팝은 빠르다

으로는 안 splice, 초효율적인 「초효율」을 해 주세요.pop하려면 , 의 「」「」를 splice you - 화,, 신--

i
t[i]요소인 ""를 합니다.t[t.length - 1]
t.pop()

, 이제 우리가 할 수 있어요.shuffle100밀리초 이내에 100만 개의 요소가 생성됩니다.

const shuffle = t =>
  Array.from(sample(t, t.length))

function* sample(t, n)
{ let r = Array.from(t)
  while (n > 0 && r.length)
  { const i = rand(r.length) // 1
    swap(r, i, r.length - 1) // 2
    yield r.pop()            // 3
    n = n - 1
  }
}

const rand = n =>
  Math.floor(Math.random() * n)

function swap (t, i, j)
{ let q = t[i]
  t[i] = t[j]
  t[j] = q
  return t
}

const size = 1e6
const bigarray = Array.from(Array(size), (_,i) => i)
console.time("shuffle via pop")
const result = shuffle(bigarray)
console.timeEnd("shuffle via pop")
document.body.textContent = JSON.stringify(result, null, 2)

body::before {
  content: "1 million elements via pop";
  font-weight: bold;
  display: block;
}

더 빨리

의 shuffle를 지정하면 새로운 출력 배열이 생성됩니다.입력 배열은 변경되지 않았습니다.이것은 내가 선호하는 작업 방식이지만, 제자리걸음을 하면 속도를 더 높일 수 있다.

★★shuffle10밀리초 이내에 100만 개의 요소가 생성됩니다.

function shuffle (t)
{ let last = t.length
  let n
  while (last > 0)
  { n = rand(last)
    swap(t, n, --last)
  }
}

const rand = n =>
  Math.floor(Math.random() * n)

function swap (t, i, j)
{ let q = t[i]
  t[i] = t[j]
  t[j] = q
  return t
}

const size = 1e6
const bigarray = Array.from(Array(size), (_,i) => i)
console.time("shuffle in place")
shuffle(bigarray)
console.timeEnd("shuffle in place")
document.body.textContent = JSON.stringify(bigarray, null, 2)

body::before {
  content: "1 million elements in place";
  font-weight: bold;
  display: block;
}

재귀적 해결 방법:

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

Javascript에서 Fisher-Yates 셔플.2개의 유틸리티 함수(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);
  }
}

ES6 기능을 사용한 최신 쇼트 인라인 솔루션:

['a','b','c','d'].map(x => [Math.random(), x]).sort(([a], [b]) => a - b).map(([_, x]) => x);

(교육용)

할 수 .1 : -1를 사용하여Math.random:

[1, 2, 3, 4].sort(() => (Math.random() > 0.5) ? 1 : -1)

다음 예제를 실행해 보겠습니다.

const array =  [1, 2, 3, 4];

// Based on the value returned by Math.Random,
// the decision is arbitrarily made whether to return 1 : -1

const shuffeled = array.sort(() => {
  const randomTrueOrFalse = Math.random() > 0.5;
  return randomTrueOrFalse ? 1 : -1
});

console.log(shuffeled);

여기 가장 쉬운 것이 있습니다.

function shuffle(array) {
  return array.sort(() => Math.random() - 0.5);
}

예를 들어, 여기서 확인할 수 있습니다.

먼저, javascript에서 다양한 정렬 방법을 시각적으로 비교하기 위해 여기를 참조하십시오.

번째, 위의 " " " , " " " " 가 됩니다.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 이가 더 큰 됩니다.indexOfO(n)에 대해서

다른 모든 응답은 Math.random()을 기반으로 합니다.이것은 고속이지만 암호 수준의 랜덤화에 적합하지 않습니다.

다음 코드는 well-known을 사용하고 있습니다.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));

소스 어레이를 변경하지 않는 셔플 기능

업데이트: 여기서는 비교적 심플한 (복잡한 관점에서 볼 수 없는) 짧은 알고리즘을 제안하고 있습니다.소형 어레이에서도 문제 없습니다만, 대규모 어레이를 취급하는 경우는, 종래의 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;
}

shuffling logic: 랜덤 인덱스를 선택한 후 결과 배열에 대응하는 요소를 추가하고 소스 배열 복사본에서 삭제합니다.소스 배열이 비워질 때까지 이 작업을 반복합니다.

그리고 만약 당신이 정말로 짧게 하고 싶다면, 내가 할 수 있는 것은 다음과 같습니다.

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 셔플 알고리즘 및 ES6 사용:

// Original array
let array = ['a', 'b', 'c', 'd'];

// Create a copy of the original array to be randomized
let shuffle = [...array];

// Defining function returning random value from i to N
const getRandomValue = (i, N) => Math.floor(Math.random() * (N - i) + i);

// Shuffle a pair of two elements at random position j
shuffle.forEach( (elem, i, arr, j = getRandomValue(i, arr.length)) => [arr[i], arr[j]] = [arr[j], arr[i]] );

console.log(shuffle);
// ['d', 'a', 'b', 'c']

다음과 같이 간단하게 할 수 있습니다.

// 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에서 참조하십시오.

2019년에도 어레이를 교환하고 있기 때문에, 다음과 같이 간단하게 어프로치를 실시합니다.

const src = [...'abcdefg'];

const shuffle = arr => 
  [...arr].reduceRight((res,_,__,s) => 
    (res.push(s.splice(0|Math.random()*s.length,1)[0]), res),[]);

console.log(shuffle(src));

.as-console-wrapper {min-height: 100%}

도움이 될 것 같았습니다.

const shuffle = (array: any[]) => {
    return array.slice().sort(() => Math.random() - 0.5);
  }
        
console.log(shuffle([1,2,3,4,5,6,7,8,9,10]));
// Output: [4, 3, 8, 10, 1, 7, 9, 2, 6, 5]

쿨의 간단한 변경AJ86의 답변은 원래 어레이를 수정하지 않습니다.

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

재능은 없지만 로다시의 경이로움을 접할 수 있는 사람에게는 로다시라는 것이 있습니다.섞다

엄밀한 모드를 사용한 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;
}

언급URL : https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array

'programing' 카테고리의 다른 글

jQuery를 사용하여 동적 HTML 요소에 이벤트를 첨부하려면 어떻게 해야 합니까? (0)	2022.11.10
MySql DateTime 스탬프를 JavaScript의 Date 형식으로 변환합니다. (0)	2022.11.01
시간 간격을 C로 측정하려면 어떻게 해야 하나요? (0)	2022.11.01
JavaScript를 사용하여 다크모드를 검출하려면 어떻게 해야 하나요? (0)	2022.11.01
JavaScript/JQuery: $(창).크기 조정이 완료된 후 실행 방법을 조정하시겠습니까? (0)	2022.11.01

현재글JavaScript 어레이를 랜덤화(shuffle)하는 방법

각종 프로그래밍 정보를 다루는 블로그입니다.

mariadb, jquery, angularjs, Wordpress, json, SQL-Server, Python, Vuex, Git, C, Oracle, spring-boot, javascript, MySQL, ReactJS, java, ASP.NET, vuejs2, php, Excel,

Today :
Yesterday :

goodsource

JavaScript 어레이를 랜덤화(shuffle)하는 방법

JavaScript 어레이를 랜덤화(shuffle)하는 방법

편집: ES6 / ECMAScript 2015로 업데이트

기타 솔루션

소스 어레이를 변경하지 않는 셔플 기능

'programing' 카테고리의 다른 글

'programing'의 다른글

티스토리툴바

« 2024/12 »
일	월	화	수	목	금	토
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31

JavaScript 어레이를 랜덤화(shuffle)하는 방법

JavaScript 어레이를 랜덤화(shuffle)하는 방법

편집: ES6 / ECMAScript 2015로 업데이트

기타 솔루션

소스 어레이를 변경하지 않는 셔플 기능

'programing' 카테고리의 다른 글

'programing'의 다른글

관련글

티스토리툴바