javascript bukan kaedah tatasusunan

Dalam JavaScript, tatasusunan ialah struktur data yang sangat biasa. Ia digunakan secara meluas untuk menyimpan dan memanipulasi koleksi data yang dipesan. Walaupun terdapat banyak kaedah yang berguna dalam tatasusunan, sesetengah mungkin tertanya-tanya mengapa sesetengah kaedah (atau sifat) ini kelihatan tergolong dalam tatasusunan, tetapi sebenarnya kaedah (atau sifat) objek Tatasusunan dan bukannya kaedah (atau sifat) tatasusunan sendiri). Dalam artikel ini, kami akan membincangkan beberapa salah tanggapan dan kesilapan biasa serta menerangkan kaedah tatasusunan dan sifat dalam JavaScript.

Apakah itu tatasusunan?

Mari kita fahami apa itu tatasusunan. Tatasusunan dalam JavaScript ialah senarai tertib yang boleh menyimpan pelbagai jenis data, termasuk nombor, rentetan, objek, dsb. Sebagai contoh, berikut ialah tatasusunan mudah:

let myArray = [1, 2, 3, "four", { five: 5 }];

Dalam tatasusunan ini, kita mempunyai beberapa nombor, rentetan, objek, semuanya disimpan dalam tatasusunan dalam susunan tertentu. Untuk memanipulasi dan mengakses elemen dalam tatasusunan, JavaScript menyediakan satu set kaedah dan sifat terbina dalam yang membolehkan pembangun melakukan pelbagai operasi dengan mudah pada tatasusunan.

Kaedah yang manakah bukan kaedah tatasusunan?

Disenaraikan di bawah ialah beberapa kaedah objek Tatasusunan biasa yang kelihatan seperti kaedah tatasusunan, tetapi sebenarnya kaedah objek Tatasusunan kerana ia boleh digunakan pada mana-mana objek, bukan tatasusunan sahaja:

join()

Kaedah Array.join() boleh menggabungkan semua elemen dalam tatasusunan ke dalam rentetan. Secara khusus, kaedah ini menggabungkan semua elemen ke dalam rentetan dan memasukkan rentetan tertentu sebagai pemisah di antara mereka. Contoh: Kaedah

let myArray = ["a", "b", "c", "d"];
let joinedArray = myArray.join(",");
console.log(joinedArray); // "a,b,c,d"

indexOf() dan lastIndexOf()

Array.indexOf() mengembalikan indeks elemen pertama yang ditemui dalam tatasusunan, jika elemen itu tidak ditemui dalam tatasusunan, ia kembali -1. Kaedah Array.lastIndexOf() mula mencari dari hujung tatasusunan dan mengembalikan indeks elemen terakhir yang ditemui Jika elemen itu tidak ditemui dalam tatasusunan, ia mengembalikan -1. Contoh:

let myArray = [1, 2, 3, 2];
let index = myArray.indexOf(2); // 返回 1
let lastIndex = myArray.lastIndexOf(2); // 返回 3

toString()

Kaedah Array.toString() menukar tatasusunan kepada rentetan dan mengembalikan rentetan. Kaedah ini serupa dengan kaedah Array.join(), tetapi menggunakan koma sebagai pemisah untuk menggabungkan elemen dalam tatasusunan. Contoh:

let myArray = [1, 2, 3];
let strArray = myArray.toString(); // 返回 "1,2,3"

slice()

Kaedah Array.slice() mengembalikan tatasusunan baharu yang mengandungi elemen tatasusunan daripada indeks mula hingga indeks akhir (tidak termasuk indeks akhir). Contoh:

let myArray = [1, 2, 3, 4, 5];
let newArray = myArray.slice(2, 4); // 返回 [3, 4]

concat()

Kaedah Array.concat() menggabungkan dua atau lebih tatasusunan dan mengembalikan tatasusunan baharu. Contoh:

let firstArray = [1, 2, 3];
let secondArray = [4, 5, 6];
let newArray = firstArray.concat(secondArray); // 返回 [1, 2, 3, 4, 5, 6]

push() dan pop()

Kaedah Array.push() dan Array.pop() digunakan untuk menambah elemen pada penghujung tatasusunan dan memadam satu daripada hujung tatasusunan masing-masing. Contoh:

let myArray = ["one", "two"];
myArray.push("three"); // 返回 3，数组变成 ["one", "two", "three"]
let lastElement = myArray.pop(); // 返回 "three"，数组变成 ["one", "two"]

shift() dan unshift()

Kaedah Array.shift() dan Array.unshift() digunakan untuk memadam elemen dari permulaan tatasusunan dan menambah pada permulaan tatasusunan masing-masing. Contoh:

let myArray = ["one", "two"];
myArray.unshift("zero"); // 返回 3，数组变成 ["zero", "one", "two"]
let firstElement = myArray.shift(); // 返回 "zero"，数组变成 ["one", "two"]

Perbezaan antara kaedah tatasusunan dan kaedah objek Tatasusunan

Walaupun kaedah yang disenaraikan di atas kelihatan seperti kaedah tatasusunan, perbezaan yang paling penting ialah mereka tidak mengubah suai tatasusunan asal itu sendiri. Sebaliknya, mereka mengembalikan nilai tatasusunan, rentetan atau jenis primitif baharu. Sebagai contoh, dalam contoh berikut, kami menunjukkan perbezaan kaedah slice(). Ambil perhatian bahawa tatasusunan asal tidak diubah, tetapi tatasusunan baharu dicipta.

let myArray = ["a", "b", "c", "d", "e", "f"];
let newArray = myArray.slice(2, 4); // 返回 ["c", "d"]
console.log(myArray); // ["a", "b", "c", "d", "e", "f"]

Sebaliknya, jika kita menggunakan kaedah push() tatasusunan, kaedah itu akan mengubah suai tatasusunan itu sendiri dan akan menambah elemen baharu.

let myArray = ["a", "b", "c"];
myArray.push("d"); // push() 方法将修改原数组本身
console.log(myArray); // ["a", "b", "c", "d"]

Selain itu, kaedah tatasusunan seperti push(), pop(), shift(), dan unshift() menukar tatasusunan asal dan mengembalikan tatasusunan yang diubah, manakala kaedah objek Tatasusunan seperti concat( ), join(), indexOf() dan slice()) mengembalikan tatasusunan baharu, rentetan atau nilai jenis primitif dan tidak mengubah tatasusunan asal.

Kesimpulan

Walaupun tatasusunan dalam JavaScript mempunyai banyak kaedah yang berguna, perlu diingatkan bahawa beberapa kaedah yang nampaknya tergolong dalam tatasusunan sebenarnya kaedah bagi objek Tatasusunan. Walaupun kaedah ini boleh digunakan pada mana-mana objek, kaedah ini tidak mengubah suai objek asal dan hasil yang dikembalikan ialah tatasusunan, rentetan atau nilai jenis primitif baharu. Untuk lebih memahami tatasusunan dan objek Tatasusunan dalam JavaScript, pembangun perlu memahami dengan jelas perbezaan antara keduanya.

Atas ialah kandungan terperinci javascript bukan kaedah tatasusunan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!