Bagaimana untuk mencari kedalaman tatasusunan dalam JavaScript

Dalam pengaturcaraan JavaScript, kita selalunya perlu mengendalikan tatasusunan. Array ialah jenis data yang sangat biasa yang membolehkan kami menyimpan sejumlah besar data dan mengendalikannya secara fleksibel. Walau bagaimanapun, dalam beberapa kes kita perlu mendapatkan kedalaman tatasusunan untuk mengetahui bilangan subtatasusunan yang bersarang dalam tatasusunan. Dalam artikel ini, kami akan meneroka cara menyelesaikan kedalaman tatasusunan menggunakan JavaScript.

Apakah kedalaman tatasusunan?

Dalam JavaScript, tatasusunan boleh mengandungi tatasusunan lain. Pendekatan ini dipanggil tatasusunan bersarang atau tatasusunan berbilang dimensi. Sebagai contoh, tatasusunan berikut ialah tatasusunan bersarang yang mengandungi dua tatasusunan:

let nestedArray = [[1, 2], [3, 4]];

Dalam contoh ini, tatasusunan bersarang mengandungi dua subarray, setiap satunya mengandungi dua elemen. Kami memanggil ini kedalaman tatasusunan bersarang. Dalam contoh ini, kedalaman ialah 2.

Jika kita menyusun tatasusunan lebih jauh, kedalaman akan meningkat. Berikut ialah tatasusunan bersarang yang mengandungi tiga tatasusunan:

let deeplyNestedArray = [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]];

Dalam contoh ini, setiap subtatasusunan juga ialah tatasusunan bersarang, dengan kedalaman 3.

Oleh itu, kedalaman tatasusunan merujuk kepada bilangan semua subtatasusunan bersarang yang terkandung dalam tatasusunan. Untuk tatasusunan yang mengandungi berbilang tatasusunan bersarang, kita perlu mengira kedalaman maksimum.

Bagaimana untuk mengira kedalaman tatasusunan?

Dalam JavaScript, kita boleh menggunakan fungsi rekursif untuk mengira kedalaman tatasusunan. Rekursi ialah teknik di mana fungsi memanggil dirinya sendiri, apabila mengira kedalaman tatasusunan kita perlu menggunakan rekursi untuk mengakses semua sub-tatasusunan dan membandingkan kedalamannya.

Berikut ialah fungsi rekursif ringkas yang mengira kedalaman tatasusunan:

function getArrayDepth(array) {
  let depth = 1;
  if (Array.isArray(array)) {
    array.forEach(function(element) {
      if (Array.isArray(element)) {
        let nestedDepth = getArrayDepth(element) + 1;
        if (nestedDepth > depth) {
          depth = nestedDepth;
        }
      }
    });
  }
  return depth;
}

Fungsi ini menggunakan kaedah forEach() untuk melelaran melalui semua elemen dalam tatasusunan. Jika elemen ialah tatasusunan, kedalamannya dikira secara rekursif. Akhirnya, fungsi mengembalikan kedalaman maksimum.

Mari kami terangkan fungsi ini langkah demi langkah:

1. Mula-mula, kami tetapkan kedalaman kepada 1 dan semak sama ada tatasusunan parameter input ialah tatasusunan.
2. Jika tatasusunan ialah tatasusunan, kami menggunakan kaedah forEach() untuk mengulangi semua elemen.
3. Jika elemen semasa juga merupakan tatasusunan, fungsi getArrayDepth() dipanggil secara rekursif untuk mengira kedalamannya, dan hasilnya dinaikkan sebanyak 1 (kerana elemen semasa ialah induk kepada tahap tatasusunan bersarang seterusnya ). Akhir sekali, kami membandingkan kedalaman yang dikembalikan kepada kedalaman maksimum semasa dan mengemas kini kedalaman maksimum jika perlu.
4. Akhir sekali, fungsi mengembalikan kedalaman maksimum.

Fungsi ujian

Kita boleh menggunakan kod berikut untuk menguji fungsi getArrayDepth():

let array1 = [1, 2, [3, 4]];
let array2 = [[1, 2], [3, 4]];
let array3 = [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]];

console.log(getArrayDepth(array1)); //2
console.log(getArrayDepth(array2)); //2
console.log(getArrayDepth(array3)); //3

Dalam contoh ini, kami menggunakan tiga tatasusunan berbeza Untuk ujian. Berdasarkan output, kita dapat melihat bahawa fungsi getArrayDepth() berjaya mengira kedalaman tatasusunan ini.

Kesimpulan

Dalam artikel ini, kami meneroka cara menyelesaikan kedalaman tatasusunan dalam JavaScript. Kami menggunakan fungsi rekursif untuk mengakses semua sub-tatasusunan dan mengira kedalaman maksimum tatasusunan. Kedalaman ialah bilangan subarray bersarang yang terkandung dalam tatasusunan. Ini ialah teknik pengaturcaraan berguna yang berguna apabila bekerja dengan tatasusunan bersarang. Kami berharap artikel ini membantu anda memperoleh pemahaman yang lebih mendalam tentang teknik untuk bekerja dengan tatasusunan dalam JavaScript.

Atas ialah kandungan terperinci Bagaimana untuk mencari kedalaman tatasusunan dalam JavaScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!