Bagaimana untuk mengira penyatuan tatasusunan JavaScript?-tutorial js-php.cn

Bagaimana untuk mengira penyatuan tatasusunan JavaScript?

王林

Lepaskan： 2023-09-10 18:49:09

ke hadapan

1162 orang telah melayarinya

如何计算 JavaScript 数组的并集？

Kita boleh mendapatkan gabungan dua tatasusunan dengan menggabungkan dua tatasusunan dan mengalih keluar elemen pendua, dan kesatuan memberikan elemen unik dalam kedua-dua tatasusunan.

Dalam tutorial ini, kita akan belajar mengira penyatuan tatasusunan JavaScript menggunakan pelbagai kaedah.

Gunakan struktur data set()

Kaedah pertama ialah menggunakan struktur data set(). Struktur data pengumpulan hanya boleh mengandungi elemen unik. Kita boleh menambah semua elemen kedua-dua tatasusunan pada set dan mencipta tatasusunan baharu daripada elemen set untuk mencipta kesatuan.

Tatabahasa

Pengguna boleh menggunakan struktur data yang ditetapkan untuk mengira penyatuan tatasusunan JavaScript mengikut sintaks berikut.

let union = [...new Set([...array1, ...array2])];

Salin selepas log masuk

Dalam sintaks di atas, kami menggunakan operator spread untuk menggabungkan dua tatasusunan dan mencipta koleksi baharu daripada tatasusunan yang terhasil. Selepas itu, kami menggunakan operator spread sekali lagi untuk menambah elemen koleksi pada tatasusunan.

Contoh 1

Dalam contoh di bawah, tatasusunan1 dan tatasusunan2 mengandungi beberapa nombor biasa. Mula-mula, kami menyambungkan array1 dan array2 menggunakan operator spread. Selepas itu, kami mencipta set daripada tatasusunan yang terhasil menggunakan pembina Set() baharu. Set hanya boleh mengandungi elemen unik. Oleh itu, ia mengandungi semua elemen dalam penyatuan dua tatasusunan.

Selepas itu, kami menggunakan operator spread untuk menambah semua elemen koleksi ke dalam tatasusunan bersekutu. Dalam output, pengguna boleh memerhatikan penyatuan dua tatasusunan.

<html>
<body>
   <h3> Using the <i> set() </i> data structure to compute the union of two arrays in JavaScript </h3>
   <div id = "output"> </div>
   <script>
      let output = document.getElementById('output');
      
      // using the set() to compute union
      let array1 = [1, 2, 3, 4, 5];
      let array2 = [4, 5, 6, 7, 8];
      let union = [...new Set([...array1, ...array2])];
      output.innerHTML = "The first array is " + array1 + "<br>";
      output.innerHTML += "The second array is " + array2 + "<br>";
      output.innerHTML += "The union of the two arrays is " + union + "<br>";
   </script>
</body>
</html>

Salin selepas log masuk

Kira penyatuan tatasusunan JavaScript menggunakan objek

Dalam kaedah ini kita boleh menambah nilai tatasusunan sebagai sifat objek. Objek sentiasa mengandungi kunci unik. Jadi kita boleh menggunakan elemen tatasusunan sebagai kunci objek dan sebarang nilai untuk kunci tertentu itu. Selepas itu kita boleh mendapatkan semua kunci objek untuk mendapatkan kesatuan tatasusunan.

Tatabahasa

Pengguna boleh menggunakan objek untuk mengira penyatuan tatasusunan mengikut sintaks berikut.

for () {
   union[names1[i]] = 1;
}
for (let key in the union) {
   finalArray.push(key);
}

Salin selepas log masuk

Dalam sintaks di atas, pertama, kami menolak semua elemen tatasusunan sebagai kunci objek. Selepas itu kita mendapat kunci dari objek dan menambahnya pada tatasusunan.

Contoh 2

Dalam contoh di bawah, kami mempunyai dua tatasusunan bernama names1 dan names2. Kami menambah elemen tatasusunan pertama sebagai kunci objek. Selepas itu, kami menambah elemen tatasusunan kedua sebagai kunci kepada objek.

Seterusnya, kami melingkari objek, dapatkan kunci objek dan tolak ke FinalArray. FinalArray mengandungi gabungan tatasusunan Name1 dan Name2.

<html>
<body>
   <h3> Using the <i> object </i> to compute the union of two arrays in JavaScript </h3>
   <div id = "output"> </div>
   <script>
      let output = document.getElementById('output');
      
      // using the object to compute the union of two arrays
      let names1 = ["John", "Peter", "Sally", "Jane", "Mark"];
      let names2 = ["Peter", "Sally", "Greg"];
      let union = {};
      
      //Add all the elements of the first array to the object
      for (let i = 0; i < names1.length; i++) {
         union[names1[i]] = 1;
      }
      for (let i = 0; i < names2.length; i++) {
         union[names2[i]] = 1;
      }
      
      //Convert the object to an array
      let finalArray = [];
      for (let key in union) {
         finalArray.push(key);
      }
      output.innerHTML = "First array: " + JSON.stringify(names1) + "<br>";
      output.innerHTML += "Second array: " + JSON.stringify(names2) + "<br>";
      output.innerHTML += "The union of the two arrays: " + JSON.stringify(finalArray) + "<br>";
   </script>
</body>
</html>

Salin selepas log masuk

Gunakan kaedah Penapis() dan Concat()

Kaedah

concat() digunakan untuk menggabungkan dua atau lebih tatasusunan. Kita boleh menggunakan kaedah penapis() untuk menggabungkan dua tatasusunan dan menapis elemen unik. Dengan cara ini, kita boleh menggunakan kaedah concat() dan filter() untuk mengira penyatuan tatasusunan.

Tatabahasa

Pengguna boleh menggunakan kaedah penapis() dan concat() untuk mengira penyatuan tatasusunan mengikut sintaks berikut.

let cities = cities1.concat(cities2);
cities.sort();
let unionCities = cities.filter((value, index) => cities.indexOf(value) === index);

Salin selepas log masuk

Dalam sintaks di atas, kami mula-mula menggabungkan dua tatasusunan, mengisihnya dan kemudian menapis elemen unik menggunakan kaedah penapis().

Contoh 3

Dalam contoh di bawah, tatasusunan city1 dan citites2 mengandungi beberapa nama bandar, beberapa daripadanya adalah biasa. Tatasusunan bandar mengandungi unsur tatasusunan kedua-dua tatasusunan.

Selepas itu, kami menggunakan kaedah sort() untuk mengisih tatasusunan bandar. Seterusnya, kami menggunakan kaedah penapis() untuk menapis nilai unik daripada tatasusunan bandar. Dalam kaedah penapis(), kami lulus fungsi panggil balik sebagai parameter, yang menyemak sama ada indeks bandar semasa adalah sama dengan indeks semasa untuk mengalih keluar elemen pendua.

<html>
<body>
   <h3> Using the <i> filter() and concat() methods </i> to compute the union of two arrays in JavaScript </h3>
   <div id = "output"> </div>
   <script>
      let output = document.getElementById('output');
      let cities1 = ["Surat", "Ahmedabad", "Rajkot", "Vadodara", "Pune"];
      let cities2 = ["Mumbai", "Pune", "Nagpur", "Nashik", "Rajkot"];
      let cities = cities1.concat(cities2);
      cities.sort();
      
      // filter unique values in the array
      let unionCities = cities.filter((value, index) => cities.indexOf(value) === index);
      output.innerHTML = "First array: " + JSON.stringify(cities1) + "<br>";
      output.innerHTML += "Second array: " + JSON.stringify(cities2) + "<br>";
      output.innerHTML += "The union of the two arrays: " + JSON.stringify(unionCities) + "<br>";
   </script>
</body>
</html>

Salin selepas log masuk

Kesimpulan

Pengguna mempelajari tiga cara berbeza untuk mengira penyatuan tatasusunan dalam JavaScript. Pendekatan pertama memerlukan kod linear menggunakan struktur data koleksi. Kaedah kedua menggunakan objek dan kaedah ketiga menggunakan kaedah penapis() dan concat().

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