Kaedah Tatasusunan JavaScript, Di Bawah Hud, Bahagian

Artikel ini meneruskan penerokaan kaedah tatasusunan JavaScript kami. Jika anda baru dalam siri ini, anda boleh dapatkan Bahagian 1 di sini. Kami akan memeriksa beberapa kaedah tatasusunan biasa—Math.max(), Math.min(), .reverse(), .filter() dan .reduce()—dan menunjukkan cara untuk mencapai hasil yang sama menggunakan gelung for. Perbandingan ini diharapkan dapat menjelaskan cara kaedah ini berfungsi.

---

Math.min() dan Math.max()

Kaedah ini mencari nombor terkecil dan terbesar dalam satu set, masing-masing. Anda boleh memberikan nombor secara langsung sebagai argumen atau menggunakan tatasusunan dengan sintaks hamparan.

<code class="language-javascript">// FIND THE MINIMUM VALUE IN AN ARRAY:
// Using a 'for' loop:
function findMinValueInArray(array) {
  let min = array[0];
  for (let i = 1; i < array.length; i++) {
    if (array[i] < min) {
      min = array[i];
    }
  }
  return min;
}
findMinValueInArray([33, -5544, 66, 55]); // returns: -5544

// Using Math.min():
function findMinValueInArray(array) {
  return Math.min(...array);
}
findMinValueInArray([33, -5544, 66, 55]); // returns: -5544</code>

Math.min() jelas lebih ringkas dan kurang terdedah kepada kesilapan. Math.max() berfungsi sama, tetapi pelaksanaan gelung fornya berbeza sedikit:

<code class="language-javascript">// FIND THE MAXIMUM VALUE IN AN ARRAY:
// Using a 'for' loop:
function findMaxValueInArray(array) {
  let max = array[0];
  for (let i = 1; i < array.length; i++) {
    let currentNum = array[i];
    if (currentNum > max) {
      max = currentNum;
    }
  }
  return max;
}
findMaxValueInArray([33, -5544, 66, 55]); // returns: 66

// Using Math.max():
function findMaxValueInArray(array) {
  return Math.max(...array);
}
findMaxValueInArray([33, -5544, 66, 55]); // returns: 66</code>

`.reverse()`

Kaedah ini membalikkan susunan unsur dalam tatasusunan, mengubah suai tatasusunan asal.

<code class="language-javascript">// REVERSE ARRAY ELEMENTS
// Using a 'for' loop:
function reverseArray(array) {
  let reversedArray = [];
  for (let i = array.length - 1; i >= 0; i--) {
    reversedArray.push(array[i]);
  }
  return reversedArray;
}
reverseArray([1, 2, 3, 4, 5]); // returns: [5, 4, 3, 2, 1]

// Using .reverse():
function reverseArray(array) {
  return array.reverse();
}
reverseArray([1, 2, 3, 4, 5]); // returns: [5, 4, 3, 2, 1]</code>

Kaedah terbina dalam jauh lebih cekap dan boleh dibaca. Pendekatan gelung for memerlukan mencipta tatasusunan baharu dan menolak elemen secara manual, meningkatkan risiko ralat.

`.filter()`

Kaedah ini mencipta tatasusunan baharu yang mengandungi hanya elemen yang melepasi fungsi ujian yang disediakan.

Mari kita pertimbangkan pelbagai akaun bank, masing-masing dengan harta balance. Kami akan menapis untuk akaun dengan baki sifar.

<code class="language-javascript">// Using a 'for' loop:
function getClientWithNoMoney(array) {
  let acctsWithZeroBalance = [];
  for (let account of array) {
    if (account.balance === 0) {
      acctsWithZeroBalance.push(account);
    }
  }
  return acctsWithZeroBalance;
}

// Using .filter():
function getClientWithNoMoney(array) {
  return array.filter((account) => account.balance === 0);
}</code>

.filter() menyediakan penyelesaian yang lebih bersih dan ringkas. Gelung for memerlukan penciptaan tatasusunan manual dan menolak elemen, menjadikannya lebih terdedah kepada kesilapan.

`.kurangkan()`

.reduce() menggunakan fungsi secara kumulatif pada elemen tatasusunan, menghasilkan satu nilai.

Contoh mudah ialah menjumlahkan elemen tatasusunan, tetapi mari kita mengira purata:

<code class="language-javascript">// With 'for' loop:
function getAverage(array) {
  let sum = 0;
  for (let i = 0; i < array.length; i++) {
    sum += array[i];
  }
  return sum / array.length;
}

// Using .reduce():
function getAverage(array) {
  return array.reduce((cv, acc) => {
      return cv + acc;
    }) / array.length;
  );
}
getAverage([10, 20, 30, 40]); // returns: 25</code>

Walaupun penjimatan kod tidak dramatik di sini, .reduce() masih meningkatkan kebolehbacaan dan mengurangkan potensi ralat berbanding dengan pendekatan gelung for.

---

Contoh ini menggambarkan kelebihan menggunakan kaedah tatasusunan JavaScript terbina dalam. Walaupun gelung for menyediakan kawalan asas, kaedah tersebut menawarkan ketepatan, kebolehbacaan dan potensi ralat yang dikurangkan. Jika anda mempunyai soalan tentang kaedah tatasusunan lain, sila tinggalkan komen. Kongsi artikel ini jika anda rasa ia membantu! Bahagian 1 siri ini boleh didapati di sini.

Terima kasih kerana membaca!

Pada asalnya diterbitkan ke Medium untuk JavaScript dalam Bahasa Inggeris Biasa pada 13 Februari 2023

Atas ialah kandungan terperinci Kaedah Tatasusunan JavaScript, Di Bawah Hud, Bahagian. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!