Cara menggunakan javascript findindex

Array menyediakan begitu banyak metode. Untuk mempermudah, pada bab ini metode dibagi menjadi beberapa kelompok

Kita sudah mengetahui metode yang menambah dan menghapus item dari awal atau akhir array

• let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 2 elemen pertama let removed = arr.splice(0, 2); alert( removed ); // "I", "study" <-- array yang berisi elemen-elemen yang dihapus4 – menambahkan item sampai akhir,
• let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 2 elemen pertama let removed = arr.splice(0, 2); alert( removed ); // "I", "study" <-- array yang berisi elemen-elemen yang dihapus5 – ekstrak item dari akhir,
• let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 2 elemen pertama let removed = arr.splice(0, 2); alert( removed ); // "I", "study" <-- array yang berisi elemen-elemen yang dihapus6 – ekstrak item dari awal,
• let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 2 elemen pertama let removed = arr.splice(0, 2); alert( removed ); // "I", "study" <-- array yang berisi elemen-elemen yang dihapus_7 – menambahkan item ke awal

Berikut adalah beberapa metode lainnya

Bagaimana cara menghapus elemen dari array?

Array adalah objek, jadi kita bisa mencoba menggunakan let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 2 elemen pertama let removed = arr.splice(0, 2); alert( removed ); // "I", "study" <-- array yang berisi elemen-elemen yang dihapus8

let arr = ["I", "go", "home"]; delete arr[1]; // menghapus "go" alert( arr[1] ); // undefined // kini arr = ["I", , "home"]; alert( arr.length ); // 3

Elemen telah dihapus, tetapi array masih memiliki 3 elemen, kita dapat melihat bahwa let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 2 elemen pertama let removed = arr.splice(0, 2); alert( removed ); // "I", "study" <-- array yang berisi elemen-elemen yang dihapus9

Itu wajar, karena let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"_0 menghapus nilai berdasarkan let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"1. Itulah yang dia lakukan. Tidak ada masalah untuk objek. Tapi untuk array kita biasanya ingin elemen yang tersisa bergeser dan mengisi ruang yang telah dikosongkan sebelumnya. Kami ingin memiliki array yang lebih pendek sekarang

Jadi, metode khusus harus digunakan

Metode arr. splice(start) adalah fungsi serbaguna untuk array. Sambatan dapat melakukan banyak hal. menyisipkan, menghapus dan mengganti elemen

Sintaksnya adalah

arr.splice(start[, deleteCount, elem1, ..., elemN])_

Mulai dari posisi let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"2. hapus elemen let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"3 lalu masukkan let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"4 di tempatnya masing-masing. Mengembalikan array yang diurutkan berdasarkan elemen yang dihapus

Metode ini mudah dipahami melalui contoh-contoh

Mari kita mulai dengan eliminasi

let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]

Mudah, bukan?

Pada contoh berikutnya kita menghapus 3 elemen dan menggantinya dengan 2 elemen lainnya

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 3 elemen pertama dan menggantinya dengan yang lain arr.splice(0, 3, "Let's", "dance"); alert( arr ) // sekarang ["Let's", "dance", "right", "now"]

Di sini kita dapat melihat bahwa let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"_7 mengembalikan array yang berisi elemen yang dihapus

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 2 elemen pertama let removed = arr.splice(0, 2); alert( removed ); // "I", "study" <-- array yang berisi elemen-elemen yang dihapus

Metode let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"_7 juga dapat menyisipkan elemen tanpa menghapus elemen yang sebelumnya ada. Untuk itu kita perlu mengatur let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"_3 sampai let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,50

let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"

Indeks numerik negatif diperbolehkan

Di sini dan dalam metode array lainnya, indeks negatif (numerik) diperbolehkan. Indeks menentukan posisi akhir array, seperti ini

let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,5

Metode arr. slice lebih sederhana dari metode serupa sebelumnya yaitu let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,51

Sintaksnya adalah

arr.slice([start], [end])

Metode ini mengembalikan array baru dari salinan semua item dari indeks let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,52 ke let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,53 (indeks let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,53 tidak termasuk). Baik let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,52 dan let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,53 bisa negatif, dalam hal ini posisi akhir array telah diasumsikan/diperkirakan

Mirip dengan metode string let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,5_7, tetapi membuat subarray alih-alih substring

Sebagai contoh

let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)

Kami juga dapat memanggil metode tanpa argumen. let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,58 membuat salinan dari let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,59. Metode seperti itu sering digunakan untuk mendapatkan salinan untuk transformasi lebih lanjut tanpa mempengaruhi larik aslinya

Metode arr. concat membuat larik baru yang sudah menyertakan nilai dari larik lain serta item tambahan

Sintaksnya adalah sebagai berikut

arr.concat(arg1, arg2...)

Sintaks menerima sejumlah argumen - bisa berupa array atau nilai

Hasilnya adalah larik yang berisi item dari let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,5_9, lalu arr.slice([start], [end])1, arr.slice([start], [end])2, dan seterusnya

Jika argumen arr.slice([start], [end])3 adalah sebuah array, maka semua elemennya akan disalin. Jika tidak, argumen itu sendiri akan disalin

Sebagai contoh

arr.splice(start[, deleteCount, elem1, ..., elemN])_0

Biasanya, metode ini hanya menyalin elemen dari array. Objek lain, meskipun objek tersebut terlihat seperti array, akan ditambahkan secara keseluruhan

arr.splice(start[, deleteCount, elem1, ..., elemN])_1

...Tetapi jika objek mirip-array memiliki properti khusus arr.slice([start], [end])4, maka objek diperlakukan sebagai larik dengan arr.slice([start], [end])5. elemen ditambahkan

arr.splice(start[, deleteCount, elem1, ..., elemN])_2

Metode arr. forEach memungkinkan kita menjalankan fungsi untuk setiap elemen dalam array

Sintaks

arr.splice(start[, deleteCount, elem1, ..., elemN])_3

Misalnya, kode berikut menampilkan setiap elemen dalam larik

arr.splice(start[, deleteCount, elem1, ..., elemN])_4

Dan kode ini lebih detail tentang posisi elemen-elemen tersebut di dalam array yang ditargetkan

arr.splice(start[, deleteCount, elem1, ..., elemN])_5

Hasil dari fungsi (jika mengembalikan sesuatu) dibuang dan diabaikan

Sekarang mari kita bahas metode yang bertugas mencari di dalam array

Metode arr. indexOf, arr. lastIndexOf dan arr. termasuk memiliki sintaks yang sama dan pada dasarnya keduanya menjalankan fungsi yang sama memiliki sintaks yang sama, tetapi untuk mengoperasikannya perlu diarahkan ke item bukan karakter

• arr.slice([start], [end])6 – mencari arr.slice([start], [end])7 mulai dari indeks arr.slice([start], [end])8, dan mengembalikan indeks tempat item yang dicari ditemukan, jika tidak maka akan mengembalikan arr.slice([start], [end])9
• let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)0 – serupa, tetapi mencari dari kiri ke kanan
• let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)1 – mencari arr.slice([start], [end])7 mulai dari indeks arr.slice([start], [end])8, mengembalikan let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)4 jika ditemukan

Sebagai contoh

arr.splice(start[, deleteCount, elem1, ..., elemN])_6

Perlu dicatat bahwa metode ini menggunakan perbandingan let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)5. Jadi, jika kita mencari let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)_6, metode ini akan secara akurat menemukan let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)6 dan bukan nol

Jika kita ingin mengecek join, dan tidak ingin mengetahui indeks yang tepat, maka disarankan untuk menggunakan let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)8

Juga, perbedaan kecil dari let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)9 adalah bahwa metode ini menangani arr.concat(arg1, arg2...)0 persis, tidak seperti arr.concat(arg1, arg2...)1

arr.splice(start[, deleteCount, elem1, ..., elemN])_7

Bayangkan kita memiliki array objek. Bagaimana kita menemukan objek dengan kondisi tertentu?

Inilah metode arr. find(fn) yang dapat dengan mudah digunakan

Sintaks

arr.splice(start[, deleteCount, elem1, ..., elemN])_8

Fungsi dipanggil untuk elemen-elemen dalam array, satu demi satu

• arr.slice([start], [end])_7 adalah elemen
• let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"2 adalah indeks elemen
• arr.concat(arg1, arg2...)_4 adalah array itu sendiri

Jika fungsi mengembalikan let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)4, pencarian dihentikan, maka arr.slice([start], [end])7 akan dikembalikan. Jika tidak ada yang ditemukan, arr.concat(arg1, arg2...)_7 dikembalikan

Misalnya, kami memiliki larik yang berisi elemen pengguna, setiap pengguna memiliki bidang arr.concat(arg1, arg2...)8 dan arr.concat(arg1, arg2...)9. Mari temukan pengguna dengan arr.splice(start[, deleteCount, elem1, ..., elemN])_00

arr.splice(start[, deleteCount, elem1, ..., elemN])_9

Dalam kehidupan nyata, array yang berisi objek adalah hal biasa, jadi metode arr.splice(start[, deleteCount, elem1, ..., elemN])01 sangat berguna

Ingat bahwa contoh yang kami berikan untuk menemukan (arr.splice(start[, deleteCount, elem1, ..., elemN])_01) fungsi arr.splice(start[, deleteCount, elem1, ..., elemN])03 hanya dengan satu argumen. Ini adalah hal yang umum, argumen lain untuk fungsi lain jarang digunakan

Metode arr. findIndex pada dasarnya sama, tetapi mengembalikan indeks tempat elemen ditemukan alih-alih elemen itu sendiri dan mengembalikan arr.slice([start], [end])9 ketika tidak ada yang ditemukan

Metode arr.splice(start[, deleteCount, elem1, ..., elemN])_01 mencari satu elemen (pertama) yang akan membuat fungsi kembali let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)4

Jika ada banyak elemen seperti itu, kita bisa menggunakan arr. filter(fn)

Sintaksnya mirip dengan arr.splice(start[, deleteCount, elem1, ..., elemN])01, tetapi arr.splice(start[, deleteCount, elem1, ..., elemN])08 mengembalikan larik yang berisi elemen yang cocok

let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]0

Sebagai contoh

let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]1

Mari beralih ke metode yang mengubah dan mengatur ulang array

Metode arr. peta adalah salah satu metode yang paling berguna dan paling sering digunakan

Metode ini memanggil fungsi untuk setiap elemen dalam larik dan mengembalikan hasilnya dalam bentuk larik

Sintaksnya adalah

let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]2

Misalnya, di sini kita mengubah setiap elemen dengan panjang string elemen

let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]3

Panggilan arr. sort() mengurutkan array dalam wadah, mengubah urutan elemennya

Metode ini juga mengembalikan array yang diurutkan, tetapi nilai yang dikembalikan biasanya diabaikan, mengingat let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,59 sendiri telah dimodifikasi/diubah

Sebagai contoh

let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]4

Sadarkah Anda akan keanehan hasil di atas?

Urutannya menjadi arr.splice(start[, deleteCount, elem1, ..., elemN])_10. Tidak benar. Tapi kenapa begitu?

Item pada dasarnya diurutkan sebagai string

Secara harfiah, semua elemen diubah menjadi string untuk perbandingan. Sedangkan pada string, ada penyortiran leksikografis dan memang benar arr.splice(start[, deleteCount, elem1, ..., elemN])11

Untuk menggunakan urutan tata letak kita sendiri, kita perlu meneruskan fungsi sebagai argumen ke arr.splice(start[, deleteCount, elem1, ..., elemN])12

Fungsi harus membandingkan dua nilai variabel dan mengembalikan (hasilnya)

let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]5

Contoh, untuk mengurutkan elemen sebagai angka

let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]6

Sekarang metode yang disebutkan berfungsi seperti yang diinginkan

Mari kita berhenti sejenak dan memikirkan apa yang terjadi. let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,59 bisa berupa array yang berisi apa saja, bukan? . Kami memiliki sekelompok beberapa item. Untuk mengurutkannya, kita memerlukan fungsi pengurutan yang mengetahui cara membandingkan elemen. Pengaturan awal adalah urutan string

Metode arr.splice(start[, deleteCount, elem1, ..., elemN])_14 mengimplementasikan algoritma pengurutan umum. Kami tidak benar-benar perlu mengetahui cara kerja algoritme (pengurutan cepat yang dioptimalkan setiap saat). Algoritme akan melalui array, membandingkan elemen menggunakan fungsi yang diberikan dan menyusun ulang elemen, yang perlu kita lakukan adalah memberikan arr.splice(start[, deleteCount, elem1, ..., elemN])15 yang akan melakukan operasi perbandingan

Omong-omong, jika kita ingin mengetahui elemen mana yang dibandingkan – beri peringatan saja

let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]7

Algoritme dapat membandingkan suatu elemen dengan banyak elemen lain dalam proses ini, tetapi algoritme akan mencoba membuat perbandingan sesedikit mungkin

Fungsi perbandingan dapat mengembalikan angka apa pun

Sebenarnya, fungsi perbandingan hanya perlu mengembalikan bilangan positif untuk menyatakan "lebih besar (dari)" dan bilangan negatif untuk menyatakan "lebih kecil (dari)"

Ini membuat penulisan fungsi lebih pendek

let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]8

Fungsi panah terbaik

Ingat fungsi panah?

let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]_9

Fungsi ini berfungsi sebaik metode versi yang lebih panjang

Metode arr. terbalik membalik urutan elemen di ________21______9

Sebagai contoh

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 3 elemen pertama dan menggantinya dengan yang lain arr.splice(0, 3, "Let's", "dance"); alert( arr ) // sekarang ["Let's", "dance", "right", "now"]_0

Metode ini juga mengembalikan array let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,5_9 setelah proses pembalikan

Ini adalah situasi dunia nyata. Kami menulis aplikasi perpesanan, dan orang tersebut memasukkan daftar penerima yang dipisahkan dengan koma, antara lain. arr.splice(start[, deleteCount, elem1, ..., elemN])_18. Tetapi bagi kami sebuah array yang berisi nama akan jauh lebih baik daripada sebuah string. Jadi bagaimana cara mendapatkannya?

Metode str. split(delim) melakukan persis seperti yang dijelaskan di atas. Metode ini memisahkan string menjadi array dengan pembatas (separator) arr.splice(start[, deleteCount, elem1, ..., elemN])19

Dalam contoh berikut, kami memisahkan elemen dengan koma diikuti dengan spasi

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 3 elemen pertama dan menggantinya dengan yang lain arr.splice(0, 3, "Let's", "dance"); alert( arr ) // sekarang ["Let's", "dance", "right", "now"]_1

Metode arr.splice(start[, deleteCount, elem1, ..., elemN])20 memiliki argumen numerik opsional kedua - batas panjang array. Jika batas diberikan, maka elemen tambahan (melebihi batas panjang array yang diberikan) akan diabaikan. Dalam praktiknya, ini jarang digunakan

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 3 elemen pertama dan menggantinya dengan yang lain arr.splice(0, 3, "Let's", "dance"); alert( arr ) // sekarang ["Let's", "dance", "right", "now"]_2

Dibagi menjadi huruf

Memanggil arr.splice(start[, deleteCount, elem1, ..., elemN])_21 dengan arr.splice(start[, deleteCount, elem1, ..., elemN])22 kosong akan membagi string menjadi array yang berisi huruf

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 3 elemen pertama dan menggantinya dengan yang lain arr.splice(0, 3, "Let's", "dance"); alert( arr ) // sekarang ["Let's", "dance", "right", "now"]_3

Panggilan arr. join(lem) melakukan pembalikan ke arr.splice(start[, deleteCount, elem1, ..., elemN])20. Panggilan ini membuat string let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,5_9 item yang digabungkan dengan arr.splice(start[, deleteCount, elem1, ..., elemN])25 (lem) di antara item

Sebagai contoh

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 3 elemen pertama dan menggantinya dengan yang lain arr.splice(0, 3, "Let's", "dance"); alert( arr ) // sekarang ["Let's", "dance", "right", "now"]_4

Ketika kita perlu mengulang array – kita dapat menggunakan arr.splice(start[, deleteCount, elem1, ..., elemN])26, arr.splice(start[, deleteCount, elem1, ..., elemN])27 atau arr.splice(start[, deleteCount, elem1, ..., elemN])28

Saat kami perlu mengulang dan mengembalikan data setiap elemen – ​​kami menggunakan arr.splice(start[, deleteCount, elem1, ..., elemN])29

Metode arr. kurangi dan metode arr. reduceRight juga termasuk dalam kelompok metode, tetapi sedikit lebih rumit. Kedua metode ini digunakan untuk menghitung satu nilai berdasarkan array

Sintaksnya adalah

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 3 elemen pertama dan menggantinya dengan yang lain arr.splice(0, 3, "Let's", "dance"); alert( arr ) // sekarang ["Let's", "dance", "right", "now"]_5

Fungsi di atas diterapkan ke semua elemen array satu per satu dan "melanjutkan" hasil perhitungan ke panggilan berikutnya

Argumennya adalah

• arr.splice(start[, deleteCount, elem1, ..., elemN])_30 – adalah hasil dari pemanggilan fungsi sebelumnya, sama dengan arr.splice(start[, deleteCount, elem1, ..., elemN])31 pertama kali (jika arr.splice(start[, deleteCount, elem1, ..., elemN])31 diberikan)
• arr.slice([start], [end])_7 – adalah item array saat ini
• let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"2 – adalah posisi barang
• arr.concat(arg1, arg2...)_4 – adalah array

Jika fungsi sudah diimplementasikan, massa dari pemanggilan fungsi sebelumnya diteruskan ke pemanggilan berikutnya sebagai argumen pertama

Kedengarannya rumit, tetapi tidak seperti yang Anda pikirkan tentang argumen pertama sebagai "akumulator" yang menyimpan dan menggabungkan hasil dari semua eksekusi sebelumnya. Dan pada akhirnya, itu menjadi hasil dari arr.splice(start[, deleteCount, elem1, ..., elemN])36

Cara termudah untuk memahami metode ini adalah dengan melihat contoh

Di sini kita mendapatkan total dari sebuah array dalam satu baris

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 3 elemen pertama dan menggantinya dengan yang lain arr.splice(0, 3, "Let's", "dance"); alert( arr ) // sekarang ["Let's", "dance", "right", "now"]_6

Fungsi yang diteruskan ke arr.splice(start[, deleteCount, elem1, ..., elemN])_36 hanya membutuhkan 2 argumen, itu cukup istimewa

Mari kita lihat detail dari apa yang terjadi

1. Pada proses pertama, arr.splice(start[, deleteCount, elem1, ..., elemN])_38 adalah nilai arr.splice(start[, deleteCount, elem1, ..., elemN])31 (argumen terakhir dari arr.splice(start[, deleteCount, elem1, ..., elemN])36), sama dengan let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,50, dan arr.splice(start[, deleteCount, elem1, ..., elemN])42 adalah elemen pertama dari array, yang sama dengan let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"5. Jadi hasil dari fungsi tersebut adalah let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"5
2. Pada proses kedua, arr.splice(start[, deleteCount, elem1, ..., elemN])_45, kita menambahkan elemen kedua dari array (arr.splice(start[, deleteCount, elem1, ..., elemN])46) dan mengembalikan hasilnya
3. Pada putaran ketiga, arr.splice(start[, deleteCount, elem1, ..., elemN])_47 dan kami menambahkan satu elemen lagi, dan seterusnya…

Aliran perhitungan

Atau dalam bentuk tabel, dimana setiap baris mewakili pemanggilan fungsi pada elemen array berikutnya

arr.splice(start[, deleteCount, elem1, ..., elemN])38arr.splice(start[, deleteCount, elem1, ..., elemN])42resultthe first calllet arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,50let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"5let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"5the second calllet arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"5arr.splice(start[, deleteCount, elem1, ..., elemN])46arr.splice(start[, deleteCount, elem1, ..., elemN])55the third callarr.splice(start[, deleteCount, elem1, ..., elemN])55arr.splice(start[, deleteCount, elem1, ..., elemN])55arr.splice(start[, deleteCount, elem1, ..., elemN])58the fourth callarr.splice(start[, deleteCount, elem1, ..., elemN])58arr.splice(start[, deleteCount, elem1, ..., elemN])60arr.splice(start[, deleteCount, elem1, ..., elemN])61the fifth callarr.splice(start[, deleteCount, elem1, ..., elemN])61arr.splice(start[, deleteCount, elem1, ..., elemN])63arr.splice(start[, deleteCount, elem1, ..., elemN])64

Di sini kita dapat melihat dengan jelas bagaimana hasil dari panggilan sebelumnya menjadi argumen pertama dari panggilan berikutnya

Kita juga bisa mengalikan nilai awal (initial)

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 3 elemen pertama dan menggantinya dengan yang lain arr.splice(0, 3, "Let's", "dance"); alert( arr ) // sekarang ["Let's", "dance", "right", "now"]_7

Hasilnya sama. Itu karena tidak ada nilai awal, maka arr.splice(start[, deleteCount, elem1, ..., elemN])36 mengambil elemen pertama dari array sebagai nilai awal dan mulai mengulang dari elemen kedua

Tabel perhitungannya sama dengan yang di atas, tanpa baris pertama

Namun, penggunaan seperti itu membutuhkan perhatian lebih. Jika array kosong, maka memanggil arr.splice(start[, deleteCount, elem1, ..., elemN])36 tanpa nilai awal akan menghasilkan kesalahan

Ini sebuah contoh

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 3 elemen pertama dan menggantinya dengan yang lain arr.splice(0, 3, "Let's", "dance"); alert( arr ) // sekarang ["Let's", "dance", "right", "now"]_8

Jadi sangat disarankan untuk selalu menentukan nilai awal

Metode arr. reduceRight melakukan hal yang sama, tetapi beroperasi dari kanan ke kiri

Array tidak membentuk bahasa tipe mereka sendiri. Array dibentuk berdasarkan objek

Jadi arr.splice(start[, deleteCount, elem1, ..., elemN])_67 tidak membantu membedakan objek biasa dari array

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 3 elemen pertama dan menggantinya dengan yang lain arr.splice(0, 3, "Let's", "dance"); alert( arr ) // sekarang ["Let's", "dance", "right", "now"]_9

...Tapi array miring digunakan sampai ada metode khusus untuk ini. Himpunan. isArray(nilai). Metode ini mengembalikan let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)4 jika arr.splice(start[, deleteCount, elem1, ..., elemN])69 adalah array, dan let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)6 jika sebaliknya

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 2 elemen pertama let removed = arr.splice(0, 2); alert( removed ); // "I", "study" <-- array yang berisi elemen-elemen yang dihapus0

Hamppir semua metode array yang memanggil fungsi – seperti arr.splice(start[, deleteCount, elem1, ..., elemN])01, arr.splice(start[, deleteCount, elem1, ..., elemN])08, arr.splice(start[, deleteCount, elem1, ..., elemN])29, dengan pengecualian arr.splice(start[, deleteCount, elem1, ..., elemN])74, menerima parameter tambahan yaitu arr.splice(start[, deleteCount, elem1, ..., elemN])75

Parameter tersebut tidak dijelaskan pada bab sebelumnya, karena jarang digunakan. Tapi untuk kelengkapan kita harus menutupi metodenya

Berikut ini adalah sintaks lengkap dari metode

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 2 elemen pertama let removed = arr.splice(0, 2); alert( removed ); // "I", "study" <-- array yang berisi elemen-elemen yang dihapus_1

Nilai parameter arr.splice(start[, deleteCount, elem1, ..., elemN])75 menjadi arr.splice(start[, deleteCount, elem1, ..., elemN])77 untuk arr.splice(start[, deleteCount, elem1, ..., elemN])78

Misalnya, di sini kita menggunakan metode dengan objek arr.splice(start[, deleteCount, elem1, ..., elemN])79 sebagai filter, dan arr.splice(start[, deleteCount, elem1, ..., elemN])75 meneruskan konteks

let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 2 elemen pertama let removed = arr.splice(0, 2); alert( removed ); // "I", "study" <-- array yang berisi elemen-elemen yang dihapus_2

Jika dalam contoh di atas kita menggunakan arr.splice(start[, deleteCount, elem1, ..., elemN])81, maka arr.splice(start[, deleteCount, elem1, ..., elemN])82 akan dapat dipanggil sebagai fungsi sendiri, dengan arr.splice(start[, deleteCount, elem1, ..., elemN])83, yang selalu menyebabkan kesalahan sesaat

Panggilan ke arr.splice(start[, deleteCount, elem1, ..., elemN])_84 dapat diganti dengan arr.splice(start[, deleteCount, elem1, ..., elemN])85, yang melakukan hal yang sama. Cara yang pertama (arr.splice(start[, deleteCount, elem1, ..., elemN])_84) lebih sering digunakan, karena sedikit lebih mudah dipahami oleh banyak orang

Lembar contekan tentang metode array

• Untuk menambah/menghapus elemen

  • arr.splice(start[, deleteCount, elem1, ..., elemN])_87 – menambahkan item sampai akhir,
  • arr.splice(start[, deleteCount, elem1, ..., elemN])_88 – ekstrak item dari akhir,
  • arr.splice(start[, deleteCount, elem1, ..., elemN])_89 – ekstrak item dari awal,
  • arr.splice(start[, deleteCount, elem1, ..., elemN])_90 – tambahkan item ke awal
  • arr.splice(start[, deleteCount, elem1, ..., elemN])_91 – pada indeks arr.splice(start[, deleteCount, elem1, ..., elemN])92 hapus elemen let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"3 dan sisipkan arr.splice(start[, deleteCount, elem1, ..., elemN])94
  • arr.splice(start[, deleteCount, elem1, ..., elemN])_95 – buat array baru, salin elemen dari posisi let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,52 ke let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,53 (tidak termasuk) ke dalam array baru
  • arr.splice(start[, deleteCount, elem1, ..., elemN])_98 --mengembalikan array baru. menyalin semua anggota array saat ini dan menambahkan arr.splice(start[, deleteCount, elem1, ..., elemN])94 ke dalamnya. Jika arr.splice(start[, deleteCount, elem1, ..., elemN])_94 adalah sebuah array, maka elemennya akan diambil

• Untuk mencari antar elemen

  • let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]01 – mencari arr.slice([start], [end])7 mulai dari posisi arr.splice(start[, deleteCount, elem1, ..., elemN])92, mengembalikan indeksnya atau arr.slice([start], [end])9 jika tidak ditemukan
  • let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]05 – mengembalikan let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)4 jika array memiliki arr.splice(start[, deleteCount, elem1, ..., elemN])69, jika tidak maka akan mengembalikan let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)6
  • let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]09 – elemen filter menggunakan fungsi, mengembalikan nilai awal/semua nilai yang membuat hasil pengembalian let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)4
  • let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]11 seperti arr.splice(start[, deleteCount, elem1, ..., elemN])01, tetapi mengembalikan indeks, bukan nilai

• Untuk mengulang sebuah elemen

  • let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]13 – memanggil arr.splice(start[, deleteCount, elem1, ..., elemN])78 untuk setiap elemen, tidak mengembalikan apa pun

• Untuk mengubah susunan

  • let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]15 – membuat array dari hasil pemanggilan arr.splice(start[, deleteCount, elem1, ..., elemN])78 untuk setiap elemen
  • let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]17 – mengurutkan array di tempat, lalu mengembalikan hasilnya
  • let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]18 – membalikkan array di tempat, lalu mengembalikan hasilnya
  • let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]19 – mengubah string menjadi array dan sebaliknya
  • let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]20 – menghitung nilai tunggal dalam array dengan memanggil arr.splice(start[, deleteCount, elem1, ..., elemN])78 untuk setiap elemen dan meneruskan hasilnya di antara panggilan

• Tambahan

  • let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]22 memeriksa apakah let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,59 adalah array atau bukan

Harap dicatat bahwa metode arr.splice(start[, deleteCount, elem1, ..., elemN])74, let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]25 dan let arr = ["I", "study", "JavaScript"]; // dari indeks 2 // menghapus 0 // kemudian masukkan "complex" dan "language" arr.splice(2, 0, "complex", "language"); alert( arr ); // "I", "study", "complex", "language", "JavaScript"7 memodifikasi array itu sendiri

Metode ini adalah yang paling sering digunakan, mencakup 99% kasus penggunaan. Tapi masih ada beberapa metode lain

• arr. beberapa (fn)/arr. setiap (fn) memeriksa array

  Fungsi arr.splice(start[, deleteCount, elem1, ..., elemN])_15 dipanggil pada setiap elemen larik mirip dengan arr.splice(start[, deleteCount, elem1, ..., elemN])29. Jika beberapa/semua hasil adalah let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)_4, maka akan mengembalikan let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)4, jika tidak akan mengembalikan let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)6

  Metode ini berperilaku seperti operator let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]_32 dan let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]33. jika arr.splice(start[, deleteCount, elem1, ..., elemN])_15 mengembalikan nilai sebenarnya, let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]35 segera mengembalikan let arr = ["t", "e", "s", "t"]; alert( arr.slice(1, 3) ); // e,s (disalin dari 1 sampai 3) alert( arr.slice(-2) ); // s,t (disalin dari -2 sampai bagian akhir)4 dan berhenti mengulangi item lainnya;

  Kita dapat menggunakan let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]_40 untuk membandingkan array

  let arr = ["I", "study", "JavaScript", "right", "now"]; // menghilangkan 2 elemen pertama let removed = arr.splice(0, 2); alert( removed ); // "I", "study" <-- array yang berisi elemen-elemen yang dihapus_3

• arr. isi(nilai, awal, akhir) – isi array dengan let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]41 berulang dari indekslet arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]42 hingga let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]43

• arr. copyWithin(target, start, end) – salin elemen dari posisi let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,52 ke posisi let arr = [1, 2, 5]; // dari indeks -1 (satu langkah dari bagian akhir) // menghaous 0 element, // lalu memasukka 3 dan 4 arr.splice(-1, 0, 3, 4); alert( arr ); // 1,2,3,4,53 ke dalam array itu sendiri, pada posisi let arr = ["I", "study", "JavaScript"]; arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen alert( arr ); // ["I", "JavaScript"]46 (tumpuk/timpa elemen yang ada)

• arr. datar (kedalaman)/arr. flatMap(fn) membuat larik baru dari larik multidimensi

Untuk daftar lengkap, lihat manual

Karena sekilas mungkin tampak begitu banyak metode, cukup sulit untuk diingat. Tapi sebenarnya itu jauh lebih mudah

Lihat lembar contekan hanya untuk mengetahui semua metode. Kemudian selesaikan tugas bab ini sebagai latihan, sehingga Anda memiliki pengalaman tentang metode larik

Setelah itu kapan pun Anda perlu melakukan sesuatu dengan array, dan tidak tahu caranya - buka halaman ini, lihat lembar contekan dan temukan metode yang tepat. Contoh yang diberikan akan membantu Anda dalam menulis sintaks yang benar. Setelah itu Anda akan secara otomatis mengingat metodenya, tanpa terlalu banyak usaha yang rumit