Penjelasan tentang masalah rawak yang menyebabkan gelung JavaScript kedua mengulangi nombor yang sama

Gelagat Tidak Dijangka dengan Nombor Rawak dalam Gelung JavaScript

Menjana nombor rawak dalam JavaScript adalah tugas biasa apabila bekerja dengan tatasusunan. Walau bagaimanapun, hasil yang tidak dijangka kadangkala boleh berlaku apabila menggunakan gelung untuk operasi sedemikian. Isu yang ketara ialah apabila berbilang lelaran menjana nilai yang sama atau boleh diramal.

Artikel ini mengkaji masalah biasa di mana dua gelung untuk sepatutnya menghasilkan nombor rawak daripada dua tatasusunan berbeza. Walaupun gelung pertama berkelakuan dengan betul, gelung kedua nampaknya mengembalikan jujukan nilai yang sama setiap kali, khususnya nombor 30, 29, 28, 27, dan 26.

Kami akan meneroka punca masalah ini dan memahami mengapa gelung untuk kedua gagal menghasilkan rawak sebenar. Selain itu, artikel ini akan menyediakan penyelesaian untuk membetulkan kod dan memastikan setiap gelung berkelakuan secara bebas.

Dengan memahami perangkap logik rawak dan bagaimana kaedah seperti Math.random() bekerja, anda akan dapat menangani isu yang sama dalam projek masa hadapan. Mari kita mendalami kod untuk mengenal pasti kesilapan dan membincangkan cara untuk memperbaikinya.

Menganalisis Logik Di Sebalik Rawak Tatasusunan JavaScript

Penyelesaian yang disediakan menangani isu biasa di mana dua gelung cuba menjana nombor rawak daripada tatasusunan yang berbeza, tetapi satu gelung gagal memberikan hasil yang benar-benar rawak. Punca utama masalah ini terletak pada bagaimana Math.random() digunakan. Dalam skrip asal, pengiraan termasuk +1 apabila menentukan indeks rawak. Kesilapan halus ini menyebabkan atur cara kadangkala memilih indeks yang tidak sah, yang membawa kepada gelung kedua yang menghasilkan output bukan rawak seperti kira detik dari 30 hingga 26.

Penggunaan penyelesaian yang diperbetulkan Math.floor(Math.random() * array.length) untuk memastikan indeks yang dihasilkan adalah sah. Logik di sebalik formula ini adalah untuk mendarabkan hasil daripada Math.random() (iaitu antara 0 dan 1) mengikut panjang tatasusunan. The Math.floor() kaedah membundarkan hasil ke integer terdekat, yang memastikan indeks sentiasa berada dalam julat. Perubahan ini membetulkan isu, memastikan setiap lelaran gelung memilih elemen berbeza secara rawak.

Salah satu penyelesaian yang dipertingkatkan digunakan array.splice() untuk mendapatkan dan mengalih keluar elemen daripada tatasusunan. Kaedah ini menghalang pendua dengan mengubah suai tatasusunan asal secara langsung, memastikan elemen yang dipilih sebelum ini tidak lagi tersedia dalam lelaran berikutnya. Gelung pertama berfungsi dengan betul dengan logik ini, dan kini gelung kedua berkelakuan dengan cara yang sama selepas menggunakan pembetulan yang serupa. Setiap panggilan ke splice() mengembalikan elemen yang dialih keluar, yang kemudiannya dicetak ke konsol.

Satu lagi peningkatan utama melibatkan penciptaan fungsi boleh guna semula untuk memilih unsur rawak. Fungsi getRandomFromArray memudahkan proses dengan merangkum logik ke dalam satu blok yang boleh digunakan semula. Pendekatan ini menjadikan kod lebih mudah diselenggara dan lebih mudah difahami. Tambahan pula, ujian unit telah ditambah untuk mengesahkan ketepatan fungsi dalam persekitaran yang berbeza. Penggunaan tegaskan penyata membantu mengesahkan bahawa panjang tatasusunan yang dikembalikan sepadan dengan jangkaan dan semua elemen yang dipilih adalah unik. Dengan menstrukturkan kod dengan cara ini, penyelesaian bukan sahaja berfungsi tetapi juga teguh dan mudah disesuaikan dengan senario yang berbeza.

// Solution 1: Correcting the Random Selection Logic
let col1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
let col2 = [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30];

for (let i = 0; i < 5; i++) {
  const random = Math.floor(Math.random() * col1.length);
  const number = col1.splice(random, 1)[0];
  console.log(number);
}

for (let i = 0; i < 5; i++) {
  const random = Math.floor(Math.random() * col2.length);
  const number = col2.splice(random, 1)[0];
  console.log(number);
}

// Solution 2: Functional Approach with Reusable Functions
const getRandomFromArray = (array, count) => {
  const result = [];
  for (let i = 0; i < count; i++) {
    const random = Math.floor(Math.random() * array.length);
    result.push(array.splice(random, 1)[0]);
  }
  return result;
};

const col1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
const col2 = [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30];

console.log(getRandomFromArray(col1, 5));
console.log(getRandomFromArray(col2, 5));

// Solution 3: Simple Unit Test to Verify Random Output
const assert = (condition, message) => {
  if (!condition) {
    throw new Error(message || "Assertion failed");
  }
};

const testRandomFunction = () => {
  const array = [1, 2, 3, 4, 5];
  const result = getRandomFromArray([...array], 5);
  assert(result.length === 5, "Result length should be 5");
  assert(new Set(result).size === 5, "All numbers should be unique");
};

testRandomFunction();
console.log("All tests passed!");

Konsep Lanjutan: Mengelakkan Kesilapan Biasa dalam Pemilihan Tatasusunan Rawak

Dalam JavaScript, menggunakan penjanaan nombor rawak dalam gelung memerlukan pelaksanaan yang teliti untuk mengelakkan perangkap biasa. Satu isu kritikal berlaku apabila pengiraan indeks yang tidak betul mengakibatkan pemilihan elemen yang tidak diingini atau berulang. Apabila menjana nombor rawak, pembangun mesti memastikan indeks kekal dalam julat sah tatasusunan. Dalam kod asal, menambah +1 kepada panjang dalam formula rawak secara tidak sengaja melebihi sempadan tatasusunan, yang membawa kepada tingkah laku yang tidak dapat diramalkan dalam gelung kedua.

Satu lagi isu yang diabaikan ialah pilihan kaedah manipulasi tatasusunan. manakala splice() berkesan untuk membuang unsur tanpa meninggalkan jurang, menggunakan indexOf() salah boleh pecah logik. Jika nilai yang dijana secara rawak tidak ditemui dalam tatasusunan, fungsi akan kembali -1, berpotensi membawa kepada ralat. Dengan penyambungan terus menggunakan indeks yang dihasilkan oleh Math.floor(), kod tersebut mengelakkan isu ini sepenuhnya, kerana hanya indeks yang sah diakses.

Selain itu, kebolehgunaan semula dan modulariti adalah amalan utama dalam pembangunan profesional. Kefungsian merangkum dalam fungsi boleh guna semula memastikan kebolehselenggaraan yang lebih baik. Ia juga mengelakkan pertindihan kod dan meningkatkan kebolehbacaan. Menggunakan ujian unit ialah satu lagi amalan berkuasa untuk memastikan hasil yang konsisten, terutamanya apabila bekerja dengan unsur rawak. Mengesahkan keputusan melalui penegasan membantu menangkap tingkah laku yang tidak dijangka lebih awal. Dengan menggabungkan amalan baik, pembangun boleh menulis kod JavaScript yang mantap yang bukan sahaja memenuhi keperluan fungsian tetapi juga berfungsi dengan cekap merentas pelbagai senario.