Cara menggunakan javascript findindex

Question

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

Table of Contents Show

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 dihapus

4 – 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 dihapus

5 – 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 dihapus

6 – 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 dihapus

8

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 dihapus

9

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,5

0

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,5

1

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,5

2 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,5

3 (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,5

3 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,5

2 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,5

3 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,5

8 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,5

9. 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,5

9 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,5

9 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

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,5

0, 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

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

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])

38

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

42resultthe first call

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

0

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

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"

5the second call

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

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

46

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

55the third call

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

55

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

55

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

58the fourth call

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

58

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

60

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

61the fifth call

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

61

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

63

arr.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 dihapus

0

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,5

2 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,5

3 (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,5

9 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 indeks

let 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,5

2 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,5

3 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

kode javascript

Cara menggunakan javascript findindex

Pos Terkait

Periklanan

BERITA TERKINI

Toplist Popular

Periklanan

Terpopuler

Periklanan

Tentang Kami

Legal

Dukungan

Social