どのようにランダム(シャッフル)JavaScriptの配列?

Question

い配列のようになります:

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

たいのですがランダマイズ/シャッフルです。

Answer 1

の事実上の偏りのないシャッフルアルゴリズムのフィッシャー-イェーツ（通称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);

一部の詳細情報 のアルゴリズム 使用します。

Answer 2

ここで Durstenfeldの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;
    }
}

フィッシャーイエーツアルゴリズムは、各元の配列要素のための1つのランダム要素をピッキングし、次のドローからそれを排除することにより作用します。ただ、ランダムにカードのデッキから取り出すような。

この除外は、現在の要素で採取要素を交換し、次に残りの部分から次のランダム要素を選ぶことにより（コンピュータで使用するためDurstenfeldによって発明）巧妙な方法で行われます。最適な効率のために、ループがランダムピックが簡略化されていること（それは常に0で開始することができます）、および他の選択肢はもう存在しないので、それが最後の要素をスキップ後方ように実行されます。

このアルゴリズムの実行時間はO（N）です。シャッフルは、インプレースで行われることに注意してください。あなたは元の配列を変更したくないのであれば、最初.slice(0)でそれのコピーを作成します。

ES6 / ECMAScriptのへの更新2015

新しいES6は、私たちは一度に2つの変数を割り当てることができます。私たちは1行のコードでそれを行うことができますように、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]];
    }
}

Answer 3

[コミュニティ編集：この答えは間違っています。コメントを参照してください。アイデアはその稀ではありませんので、それは今後の参考のためにここに残されている。

[1,2,3,4,5,6].sort(function() {
  return .5 - Math.random();
});

Answer 4

一つは、可能性（または必要があります）アレイからのプロトタイプとしてそれを使用します。クリストファーよります：

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

Answer 5

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

Answer 6

行うことができるので簡単に地図や並び替え:

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)

1. また配列内の各要素に、オブジェクトでは、ランダムソートキー
2. いうランダムキーの使用
3. まunmapに、元のオブジェクト

できるシャッフルで多型配列のソートはランダムとしてMath.ランダムである程度の良さです。

らの要素は、ソートに対し一貫したキーは再生して繰り返し、比較を引きから、同じ分布、乱数の発生源の流通Math.ランダムが解除されます。

Answer 7

NEW!

短&そらく*高速フィッシャー-イェイツシャッフルアルゴリズム

1. 使用すが---
2. ビット単位の階（数字10桁の半角数字(32bit))
3. 削除されunecessaryクロージャー-その他のもの

---

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として機能名90bytes

デモ http://jsfiddle.net/vvpoma8w/

*早くすべてのブラウザ以外のchrome.

ご質問のある方でお願いします。

編集

あり高速

性能： http://jsperf.com/fyshuffle

使用上の票を投じます。

編集 がありました計算の余ったな--c+1) および好気

短い4bytes)&速試験です！）

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() も若干上昇学三田キャンパスにて行われる大きなarrays.

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

可読版 (使用のバージョン。この遅varsは無駄なように、クロージャー-";"は、コードそのものが短...も読み取るこ どのように'minify'Javascriptコード ,ねることができずに圧縮もしくは、下記コードを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
 }
}

Answer 8

小さなアレイのための非常に簡単な方法は、単にこれです：

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>

Answer 9

一部の回答が短縮されることを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))];
};

ES6純用の配列になります。地図

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純用の配列になります。削減

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

---

稿型のための純粋な配列の機能ランダマイズ処理を施

どちらかをお使いいただけます。

type GetShuffledArr= <T>(arr:Array<T>) => Array<T> 
interface IGetShuffledArr{
    <T>(arr:Array<T>): Array<T>
}

Answer 10

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

Answer 11

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

Answer 12

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

Answer 13

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

Answer 14

この変異体作品を"投稿者によって削除されて"答えの複製はこの質問です。とは異なり、その他の回答が多くupvotesです:

1. 実際にランダム
2. ない場所までの shuffled 名によ shuffle)
3. 存在しないこと複数の異

このjsfiddleで使用.

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

Answer 15

あなたは簡単にそれを行うことができます：

// array
var fruits = ["Banana", "Orange", "Apple", "Mango"];
// random
fruits.sort(function(a, b){return 0.5 - Math.random()});
// out
console.log(fruits);

JavaScriptのソート配列する

で参照してください。