Mempertimbangkan:

var myArray = ['January', 'February', 'March'];    

Bagaimana saya bisa memilih nilai acak dari array ini menggunakan JavaScript?

Ini adalah one-liner sederhana

const randomElement = array[Math.floor(Math.random() * array.length)];

Contoh

const months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
const randomMonth = months[Math.floor(Math.random() * months.length)];

console.log("random month =>", randomMonth);

Jika Anda sudah mendapat garis bawah atau tanda lahir yang termasuk dalam proyek Anda, Anda dapat menggunakannya _.sample.

// will return one item randomly from the array
_.sample(['January', 'February', 'March']);

Jika Anda perlu mendapatkan lebih dari satu item secara acak, Anda dapat meneruskannya sebagai argumen kedua dalam garis bawah:

// will return two items randomly from the array using underscore
_.sample(['January', 'February', 'March'], 2);

atau gunakan _.sampleSizemetode ini di lodash:

// will return two items randomly from the array using lodash
_.sampleSize(['January', 'February', 'March'], 2);

Metode Prototipe

Jika Anda berencana untuk mendapatkan nilai acak banyak, Anda mungkin ingin mendefinisikan fungsi untuk itu.

Pertama, letakkan ini di kode Anda di suatu tempat:

Array.prototype.sample = function(){
  return this[Math.floor(Math.random()*this.length)];
}

Sekarang:

[1,2,3,4].sample() //=> a random element

Kode dirilis ke domain publik di bawah ketentuan lisensi CC0 1.0 .

~~jauh lebih cepat daripada Math.Floor(), jadi ketika datang ke optimasi kinerja sambil menghasilkan output menggunakan elemen UI, ~~memenangkan permainan. INFO LEBIH LANJUT

var rand = myArray[~~(Math.random() * myArray.length)];

Tetapi jika Anda tahu bahwa array akan memiliki jutaan elemen daripada Anda mungkin ingin mempertimbangkan kembali antara Operator Bitwise dan Math.Floor(), sebagai operator bitwise berperilaku aneh dengan jumlah besar. Lihat contoh di bawah ini dijelaskan dengan output. INFO LEBIH LANJUT

var number = Math.floor(14444323231.2); // => 14444323231
var number = 14444323231.2 | 0; // => 1559421343

Katakanlah Anda ingin memilih item acak yang berbeda dari yang terakhir kali (tidak benar-benar acak, tetapi masih merupakan persyaratan umum) ...

Membangun berdasarkan jawaban oleh @ Markus, kita dapat menambahkan fungsi prototipe lain:

Array.prototype.randomDiffElement = function(last) {
   if (this.length == 0) {
      return;
   } else if (this.length == 1) {
      return this[0];
   } else {
      var num = 0;
      do {
         num = Math.floor(Math.random() * this.length);
      } while (this[num] == last);
      return this[num];
   }
}

Dan implementasikan seperti ini:

var myRandomDiffElement = myArray.randomDiffElement(lastRandomElement)

Jika Anda memiliki nilai tetap (seperti daftar nama bulan) dan ingin solusi satu baris

var result = ['January', 'February', 'March'][Math.floor(Math.random() * 3)]

Bagian kedua dari array adalah operasi akses seperti yang dijelaskan dalam Mengapa [5,6,8,7] [1,2] = 8 dalam JavaScript?

Versi terpendek:

var myArray = ['January', 'February', 'March']; 
var rand = myArray[(Math.random() * myArray.length) | 0]

Jika Anda ingin menulisnya pada satu baris, seperti solusi Pascual, solusi lain adalah menuliskannya menggunakan fungsi find ES6 (berdasarkan pada fakta, bahwa kemungkinan memilih secara acak salah satu nitem adalah 1/n):

var item = ['A', 'B', 'C', 'D'].find((_, i, ar) => Math.random() < 1 / (ar.length - i));
console.log(item);

Gunakan pendekatan itu untuk tujuan pengujian dan jika ada alasan bagus untuk tidak menyimpan array dalam variabel terpisah saja. Kalau tidak, jawaban lain ( floor(random()*lengthdan menggunakan fungsi terpisah) adalah jalan Anda.

Faker.js memiliki banyak fungsi utilitas untuk menghasilkan data uji acak. Ini adalah opsi yang baik dalam konteks test suite:

const Faker = require('faker');
Faker.random.arrayElement(['January', 'February', 'March']);

Seperti yang disebutkan oleh komentator, Anda biasanya tidak boleh menggunakan perpustakaan ini dalam kode produksi.

Mengedit prototipe Array bisa berbahaya. Ini dia fungsi sederhana untuk melakukan pekerjaan itu.

function getArrayRandomElement (arr) {
  if (arr && arr.length) {
    return arr[Math.floor(Math.random() * arr.length)];
  }
  // The undefined will be returned if the empty array was passed
}

Pemakaian:

// Example 1
var item = getArrayRandomElement(['January', 'February', 'March']);

// Example 2
var myArray = ['January', 'February', 'March'];
var item = getArrayRandomElement(myArray);

Fungsi rekursif, mandiri yang dapat mengembalikan sejumlah item (identik dengan lodash.sampleSize ):

function getRandomElementsFromArray(array, numberOfRandomElementsToExtract = 1) {
    const elements = [];

    function getRandomElement(arr) {
        if (elements.length < numberOfRandomElementsToExtract) {
            const index = Math.floor(Math.random() * arr.length)
            const element = arr.splice(index, 1)[0];

            elements.push(element)

            return getRandomElement(arr)
        } else {
            return elements
        }
    }

    return getRandomElement([...array])
}

Untuk mendapatkan penggunaan array item acak crypto-strong

let rndItem = a=> a[rnd()*a.length|0];
let rnd = ()=> crypto.getRandomValues(new Uint32Array(1))[0]/2**32;

var myArray = ['January', 'February', 'March'];

console.log( rndItem(myArray) )

Ini mirip dengan, tetapi lebih umum daripada, solusi @ Jacob Relkin:

Ini ES2015:

const randomChoice = arr => {
    const randIndex = Math.floor(Math.random() * arr.length);
    return arr[randIndex];
};

Kode berfungsi dengan memilih angka acak antara 0 dan panjang array, lalu mengembalikan item pada indeks itu.

var item = myArray[Math.floor(Math.random()*myArray.length)];

atau versi yang lebih pendek yang setara:

var item = myArray[(Math.random()*myArray.length)|0];

Kode sampel:

var myArray = ['January', 'February', 'March'];    
var item = myArray[(Math.random()*myArray.length)|0];
console.log('item:', item);

Fungsi sederhana:

var myArray = ['January', 'February', 'March'];
function random(array) {
     return array[Math.floor(Math.random() * array.length)]
}
random(myArray);

ATAU

var myArray = ['January', 'February', 'March'];
function random() {
     return myArray[Math.floor(Math.random() * myArray.length)]
}
random();

ATAU

var myArray = ['January', 'February', 'March'];
function random() {
     return myArray[Math.floor(Math.random() * myArray.length)]
}
random();

Menurut pendapat saya, lebih baik daripada bermain-main dengan prototipe, atau mendeklarasikannya tepat waktu, saya lebih suka mengeksposnya ke jendela:

window.choice = function() {
  if (!this.length || this.length == 0) return;
  if (this.length == 1) return this[0];
  return this[Math.floor(Math.random()*this.length)];
}

Sekarang di mana saja di aplikasi Anda Anda menyebutnya seperti:

var rand = window.choice.call(array)

Dengan cara ini Anda masih bisa menggunakan for(x in array)loop dengan benar

Saya telah menemukan cara mengatasi komplikasi jawaban teratas, hanya dengan menggabungkan rand variabel ke variabel lain yang memungkinkan angka tersebut ditampilkan di dalam pemanggilan myArray [] ;. Dengan menghapus array baru yang dibuat dan mempermainkan komplikasinya, saya telah menghasilkan solusi yang berfungsi:

<!DOCTYPE html>
<html>
<body>

<p id="demo"></p>

<script>

var myArray = ['January', 'February', 'March', 'April', 'May'];    

var rand = Math.floor(Math.random() * myArray.length);

var concat = myArray[rand];

function random() {
   document.getElementById("demo").innerHTML = (concat);
}
</script>

<button onClick="random();">
Working Random Array generator
</button>

</body>
</html>

static generateMonth() { 
const theDate = ['January', 'February', 'March']; 
const randomNumber = Math.floor(Math.random()*3);
return theDate[randomNumber];
};

Anda menetapkan variabel konstan ke array, Anda kemudian memiliki konstanta lain yang memilih secara acak antara tiga objek dalam array dan kemudian fungsinya mengembalikan hasil.

Cara umum untuk mendapatkan elemen acak:

let some_array = ['Jan', 'Feb', 'Mar', 'Apr', 'May'];
let months = random_elems(some_array, 3);

console.log(months);

function random_elems(arr, count) {
  let len = arr.length;
  let lookup = {};
  let tmp = [];

  if (count > len)
    count = len;

  for (let i = 0; i < count; i++) {
    let index;
    do {
      index = ~~(Math.random() * len);
    } while (index in lookup);
    lookup[index] = null;
    tmp.push(arr[index]);
  }

  return tmp;
}

randojs membuat ini sedikit lebih sederhana dan mudah dibaca:

console.log( rando(['January', 'February', 'March']).value );

<script src="https://randojs.com/1.0.0.js"></script>

Berikut adalah contoh cara melakukannya:

$scope.ctx.skills = data.result.skills;
    $scope.praiseTextArray = [
    "Hooray",
    "You\'re ready to move to a new skill", 
    "Yahoo! You completed a problem", 
    "You\'re doing great",  
    "You succeeded", 
    "That was a brave effort trying new problems", 
    "Your brain was working hard",
    "All your hard work is paying off",
    "Very nice job!, Let\'s see what you can do next",
    "Well done",
    "That was excellent work",
    "Awesome job",
    "You must feel good about doing such a great job",
    "Right on",
    "Great thinking",
    "Wonderful work",
    "You were right on top of that one",
    "Beautiful job",
    "Way to go",
    "Sensational effort"
  ];

  $scope.praiseTextWord = $scope.praiseTextArray[Math.floor(Math.random()*$scope.praiseTextArray.length)];

metode lain yang mudah:

var myArray = ['keke','keko','cano','halo','zirto'];

var randomValue = myArray[Math.round((Math.random()*1000))%myArray.length];

Buat satu nilai acak dan berikan ke array

Silakan coba kode berikut ..

//For Search textbox random value
var myPlaceHolderArray = ['Hotels in New York...', 'Hotels in San Francisco...', 'Hotels Near Disney World...', 'Hotels in Atlanta...'];
var rand = Math.floor(Math.random() * myPlaceHolderArray.length);
var Placeholdervalue = myPlaceHolderArray[rand];

alert(Placeholdervalue);