Cara menggunakan negative slice javascript

Question

Array menyediakan begitu banyak metode. Untuk mempermudah, dalam bab ini metode-metode tersebut dibagi menjadi beberapa kelompok.

Table of Contents Show

Kita sudah tahu metode-metode yang menambahkan dan menghapus item dari bagian 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 ke bagian 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 – mengekstrak sebuah item dari bagian 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 – mengekstrak sebuah item dari bagian 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 bagian awal.

Berikut ini ada beberapa metode lainnya.

Bagaimana cara untuk menghapus sebuah elemen dari array?

Array merupakan objek, jadi kita bisa coba 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 tersebut telah dihapus, tetapi array itu masih memiliki 3 elemen, kita bisa 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.

Hal itu alami, 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 menghilangkan sebuah 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 dilakukannya. Tidak masalah bagi objek. Tapi untuk array kita biasanya ingin elemen yang tersisa untuk bergeser dan mengisi ruang yang dikosongkan tadi. Kita ingin memiliki sebuah array yang lebih pendek sekarang.

Jadi, metode khusus harus digunakan.

Metode arr.splice(start) adalahs sebuah fungsi serbaguna untuk array. Splice bisa melakukan banyak hal: memasukkan, menghilangkan serta mengganti elemen.

Sintaksnya yakni:

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

Dimulai 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: menghapus 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 kemudian memasukkan

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 tersusun atas elemen yang dihapus.

Metode ini mudah untuk dipahami melalui contoh.

Mari mulai dengan penghapusan:

let arr = ["I", "study", "JavaScript"];

arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen

alert( arr ); // ["I", "JavaScript"]

Mudah, kan? Mulai dari indeks

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 metode ini menghilangkan elemen di indeks

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.

Dalam contoh selanjutnya kita menghilangkan 3 element dan menggantinya dengan 2 elemen lain:

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 terhapus:

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 mampu memasukkan elemen tanpa menghilangkan elemen apapun yang ada sebelumnya. 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 menjadi

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 berangka negatif diperbolehkan

Di sini dan di metode array lainnya, indeks (berangka) negatif diperbolehkan. Indeks-indeks tersebut menspesifikasikan posisi dari bagian akhir sebuah 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 daripada metode serupa sebelumnya yakni

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 sebuah sebuah array baru hasil salinan semua item yang ada 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 hingga

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 maupun

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 saja negatif, dalam kasus tersebut posisi dari bagian akhir array sudah 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, namun membuat subarray bukan substring.

Contohnya:

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)

Kita juga bisa memanggil metode tersebut 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 sebuah 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. Cara demikian seringkali digunakan untuk mendapatkan sebuah salinan untuk transformasi yang lebih jauh tanpa mempengaruhi array yang asli.

Metode arr.concat membuat sebuah array baru yang sudah termasuk nilai-nilai dari array lainnya serta item-item tambahan.

Sintaksnya sebagai berikut:

arr.concat(arg1, arg2...)

Sintaks tersebut menerima berapapun argumen – bisa jadi array atau nilai.

Hasilnya adalah sebuah array 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, kemudian

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

1,

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

2 dan sebagainya.

Jika sebuah argumen

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

3 adalah sebuah array, makan semua elemennya akan disalin. Jika tidak, argumen itu sendiri yang akan disalin.

Sebagai contoh:

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

0

Normalnya, metode ini hanya menyalin elemen-elemen dari array. Objek lainnya, bahkan jika objek-objek tersebut terlihat seperti array, akan ditambahkan secara keseluruhan:

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

1

…Tetapi jika sebuah objek mirip array memiliki sebuah properti khusus

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

4, maka objek tersebut diperlakukan sebagai sebuah array dengan

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

5: elemennya ditambahkan:

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

2

Metode arr.forEach membuat kita dapat menjalankan sebuah fungsi untuk setiap elemen yang ada di dalam array.

Sintaksnya:

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

3

Sebagai contoh, kode berikut ini menampilkan tiap elemen dalam array:

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

4

Dan kode ini lebih rinci tentang posisi elemen-elemen tersebut dalam array yang dituju:

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

5

Hasil dari fungsi tersebut (jika mengembalikan sesuatu) dibuang dan diabaikan.

Kini mari membahas metode-metode yang bertugas mencari dalam array.

Metode arr.indexOf, arr.lastIndexOf dan arr.includes memiliki sintaks yang sama dan pada dasarnya keduanya melakukan fungsi yang samahave the same syntax, namun untuk mengoperasikannya perlu ditujukan item bukan karakter:

```
arr.slice([start], [end])
```
6 – mencari
```
arr.slice([start], [end])
```
7 dimulai dari indeks
```
arr.slice([start], [end])
```
8, dan mengembalikan indeks dimana item yang dicari itu ditemukan, jika tidak 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, namun 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 dimulai dari indeks

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

8, mengembalkikan

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 yang dicari itu ditemukan.

Contohnya:

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

6

Perlu diperhatikan bahwa metode tersebut 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 tepat 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 dan bukan nol.

Jika kita ingin memeriksa pencantuman, dan tidak ingin tahu indeks yang persis, maka direkomendasikan 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 yakni metode ini menangani

arr.concat(arg1, arg2...)

0 dengan tepat, tidak seperti

arr.concat(arg1, arg2...)

1:

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

7

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

Berikut ini ada metode arr.find(fn) yang dapat mudah digunakan.

Sintaksnya:

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

8

Fungsi tersebut dipanggil untuk elemen-elemen dalam array, satu sama lainnya:

```
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 tersebut.

```
arr.concat(arg1, arg2...)
```
4 adalah array itu sendiri.

Jika fungsi tersebut 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, lalu

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

7 akan dikembalikan. Jika tidak ditemukan apa-apa,

arr.concat(arg1, arg2...)

7 yang dikembalikan.

Sebagai contoh, kita memiliki sebuah array berisi elemen pengguna, tiap pengguna memiliki field

arr.concat(arg1, arg2...)

8 dan

arr.concat(arg1, arg2...)

9. Mari cari pengguna dengan

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

00:

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

9

Pada kehidupan nayata array berisi objek adalah hal yang umum, jadi metode

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

01 sangatlah berguna.

Ingat bahwa contoh yang kami berikan untuk mencari (

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

01) fungsi

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

03 hanya dengan satu argumen. Ini adalah hal umum, argumen lainnya pada fungsi lainnya jarang digunakan.

Metode arr.findIndex pada dasarnya sama, namun mengembalikan indeks dimana elemen tersebut ditemukan bukan elemen itu sendiri serta mengembalikan

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

9 ketika tidak ditemukan apapun.

Metode

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

01 mencari sebuah elemen tunggal (pertama) yang akan membuat fungsi tersebut 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 ada banyak elemen demikian, kita bisa menggunakanarr.filter(fn).

Sintaksnya mirip dengan

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

01, tetapi

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

08 mengembalikan array yang berisi elemen-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 lanjutkan ke metode-metode yang mengubah dan mengatur ulang array.

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

Metode ini memanggil fungsi untuk tiap elemen di array dan mengembalikan hasilnya dalam bentuk array.

Sintaksnya yakni:

let arr = ["I", "study", "JavaScript"];

arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen

alert( arr ); // ["I", "JavaScript"]

2

Sebagai contoh, di sini kita mengubah setiap elemen menjadi panjang (length) dari string elemen tersebut:

let arr = ["I", "study", "JavaScript"];

arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen

alert( arr ); // ["I", "JavaScript"]

3

Panggilan arr.sort() menata array dalam wadah, mengubah urutan elemen yang ada.

Metode ini juga mengembalikan array yang sudah tertata, 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 itu sendiri sudah termodifikasi/diubah.

Contohnya:

let arr = ["I", "study", "JavaScript"];

arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen

alert( arr ); // ["I", "JavaScript"]

4

Apa kamu menyadari adanya keanehan dari hasil di atas?

Urutannya menjadi

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

10. Tidak benar. Tapi mengapa demikian?

Item-item tersebut diurutkan sebagai string secara pada dasarnya.

Secara harfiah, semua elemen dikonversi menjadi string untuk dibandingkan. Sedangkan pada string, berlaku pengurutan leksikograpis dan memang benar bahwa

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

11.

Untuk menggunakan urutan penataan kita sendiri, kita perlu memberikan sebuah fungsi sebagai argumen pada

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

12.

Fungsi tersebut harus membandingkan dua nilai yang berubah-ubah 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

Kini metode tersebu berfungsi seperti yang diinginkan.

Mari berhenti sejenak dan pikirkan 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 jadi array berisi apapun, benar? Array itu bisa saja berisi angka atau string atau objek atau apapun. Kita memiliki sekumpulan beberapa item. Untuk mengurutkannya, kita perlu sebuah fungsi pengurutan yang tahu bagaimana cara untuk membandingkan elemen-elemen. Setelan awalnya adalah sebuah urutan string.

Metode

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

14 mengimplementasikan sebuah algoritma pengurutan yang umum. Kita tidak perlu benar-benar tahu bagaimana algoritma itu bekerja (sebuah cara cepat/quicksort yang sudah teroptimasi sepanjang waktu). Algoritma itu akan menyusuri array, membandungkan elemen-elemennya menggunakan fungsi yang diberikan dan mengurutkan ulang elemen-elemen tersebut, yang perlu kita lakukan yakni memberikan

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

15 yang mana akan melakukan operasi perbandingan.

Ngomong-omong, jika kita pernah ingin tahu elemen mana saja yang dibandingkan – cukup dengan cara memberi alert:

let arr = ["I", "study", "JavaScript"];

arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen

alert( arr ); // ["I", "JavaScript"]

7

Algoritma tersebut dapat membandingkan sebuah elemen dengan banyak elemen lainnya dalam proses ini, tapi algoritma itu akan mencoba membuat sedikit mungkin perbandingan.

Sebuah fungsi perbandingan dapat mengembalikan angka manapun

Sebenarnya, sebuah fungsi perbandingan hanya perlu untuk mengembalikan sebuah angka positif untuk mengatakan “lebih besar (dari)” dan angka negatif untuk mengatakan “kurang (dari)”.

Hal tersebut membuat penulisan fungsi jadi lebih pendek:

let arr = ["I", "study", "JavaScript"];

arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen

alert( arr ); // ["I", "JavaScript"]

8

Fungsi arrow yang terbaik

Ingat fungsi arrow? Kita dapat menggunakan fungsi arrow di sini untuk pengurutan yang lebih rapi:

let arr = ["I", "study", "JavaScript"];

arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen

alert( arr ); // ["I", "JavaScript"]

9

Fungsi ini berfungsi samahalnya dengan metode versi yang lebih panjang di atasnya.

Metode arr.reverse membalikkan urutan elemen di dalam

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.

Contohnya:

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 dari dunia nyata. Kita menulis sebuah aplikasi olahpesan, dan orang tersebut memasukkan ke dalam daftar penerima yang dipisahkan oleh tanda koma, antara lain:

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

18. Namun bagi kita array yang berisi nama akan jauh lebih apik ketimbang sebuah string. Jadi bagaiman cara mendapatkannya?

Metode str.split(delim) melakukan tepat hal yang dijelaskan di atas. Metode ini memisahkan string ke dalam array dengan delimiter (pemisah)

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

19.

Dalam contoh berikut ini, kita memisahkan elemen dengan tanda koma yang diikuti oleh 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 oposional kedua – sebuah batas pada panjang (length) array. Jika batasan itu diberikan, maka elemen ekstra (lebih dari batas panjang array yang diberikan) akan diabaikan. Dalam praktiknya, hal 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

Pisah menjadi huruf

Panggilan

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

21 dengan

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

22 yang kosong akan memisahkan string menjadi array yang berisi huruf-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(glue) melalukan pembalikan ke

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

20. Panggilan ini membuat sebuah string item-item

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 digabungkan oleh

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

25 (lem) diantara item tersebut.

Contohnya:

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-ulang sebuah 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.

Ketika kita perlu mengulang dan mengembalikan data setiap elemen – kita menggunakan

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

29.

Metode arr.reduce dan metode arr.reduceRight juga termasuk ke dalam kelompok metode-metode tadi, tapi ada sedikit lebih rumit. Kedua metode ini digunakan untuk menghitung sebuah nilai tunggal berdasarkan array.

Sintaksnya yakni:

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 pada semua elemen array satu sama lainnya dan “melanjutkan” hasil perhitungannya ke panggilan berikutnya.

Argument-argumennya yakni:

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

30 – adalah hasil dari dari pemanggilan fungsi sebelumnya, sama dengan

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

31 pertama kalinya (jika

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

31 diberikan).

```
arr.slice([start], [end])
```
7 – adalah item array yang sekarang.

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 item tersebut.

```
arr.concat(arg1, arg2...)
```
4 – adalah array-nya.

Jika fungsi sudah diterapkan, masil dari panggilan fungsi sebelumnya dioper ke panggilan selanjutnya sebagai argumen pertama.

Memang terdengar rumit, tapi tidak seperti yang kamu pikirkan tentang argumen pertama sebagai “akumulator” yang menyimpan dan menggabungkan jasil dari semua eksekusi sebelumnya. Serta pada akhirnya, itu menjadi hasil dari

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

36.

Cara termudah untuk memahami metode ini adalah dengan melihat contohnya.

Di sini kita mendapat jumlah 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 dioper ke

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

36 hanya menggunakan 2 argumen, itu cukup khas.

Mari lihat rincian dari apa yang terjadi.

Pada run 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 array tersebut, 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 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 run ke-dua,

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

45, kita tambahkan elemen kedua dari array (

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

46) dan mengembalikan hasilnya.

Pada run ke-tiga,
```
arr.splice(start[, deleteCount, elem1, ..., elemN])
```
47 dan kita menambahkan satu elemen lagi, dan seterusnya…

Alur perhitungannya:

ATau dalam bentuk sebuah tabel, dimana setiap baris merepresentasikan sebuah panggilan fungsi pada elemen array selanjutnya:

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 bisa dengan jelas melihat bagaimana hasil dari panggilan sebelumnya menjadi argumen pertama pada panggilan berikutnya.

Kita bisa juga mengjilangkan 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 array sebagai nilai awal dan memulai pengulangan dari elemen ke-dua.

Tabel perhitungan tersebut sama dengan yang di atas, tanpa baris pertama.

Akan tetapi, penggunaan yang demikian membutuhkan perhatian lebih. Jika array kosong, maka panggilan

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

36 tanpa nilai awal akan menghasilkan error.

Berikut ini contohnya:

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 menspesifikasikan nilai awal.

Metode arr.reduceRight melaksanakan hal yang sama, tapi beroperasi dari kanan ke kiri.

Array tidak membentuk sebuah bahasa tipe sendiri. Array terbentuk berdasarkan objek.

Jadi

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

67 tidak membantu membedakan sebuah objek polos dari sebuah 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

…Tetapi array serung diguakan hingga ada metode khusus untuk hal ini: Array.isArray(value). 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 sebuah 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 paramater tambahan yakni

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

75.

Parameter itu tidak dijelaskan pada bab sebelumnya, karena jarang digunakan. Tetapi demi kelengkapan kita harus menutupi metodenya.

Berikut ini adalah sintkas lengkap dari metode-metode tersebut:

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 dari paramater

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

75 menjadi

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

77 untuk

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

78.

Contohnya, di sini kita menggunakan metode dengan objek

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

79 sebagai penyaringnya, dan

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

75 mengoper konteksnya:

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 bisa dipanggil sebagai fungsi yang berdisi sendiri, dengan

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

83, itu smeua berujung pada error seketika.

Sebuah panggilan ke

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

84 bisa diganti dengan

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

85, yang mana melakukan hal yang sama. Metode yang pertama (

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

84) lebih sering digunakan, karena sedikit lebih mudah dimengerti oleh banyak orang.

Cheat sheet tentang metode-metode array:

Untuk menambah/menghilangkan elemen:

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

87 – menambah item ke bagian akhir,

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

88 – mengekstrak sebuah item dari bagian akhir,

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

89 – mengekstrak sebuah item dari bagian awal,

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

90 – menambah item ke bagian awal.

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

91 – pada indeks

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

92 menghapus 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 dam memasukkan

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

94.

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

95 – membuat array baru, menyalin 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 hingga

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 inklusif) ke dalam array baru tersebut.

```
arr.splice(start[, deleteCount, elem1, ..., elemN])
```
98 --mengembalikan sebuah array baru: menyalin semua anggota array yang sekarang dan menambahkan
```
arr.splice(start[, deleteCount, elem1, ..., elemN])
```
94 ke dalamnya. Jika
```
arr.splice(start[, deleteCount, elem1, ..., elemN])
```
94 adalah sebuah array, maka elemennya yang akan diambil.

Untuk mencari di antara elemen-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 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 – menyaring elemen dengan menggunakan fungsi, mengembalikan nilai awal/semua nilai yang membuat hasil return-nya menjadi

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, namun mengembalikan indeks bukan nilai.

Untuk mengulang 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 apapun.

Untuk mengubah array:

let arr = ["I", "study", "JavaScript"];

arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen

alert( arr ); // ["I", "JavaScript"]

15 – membuat sebuah 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 dalam-tempatnya, 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 dalam-tempatnya, lalu mengembalikan hasilnya.

let arr = ["I", "study", "JavaScript"];

arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen

alert( arr ); // ["I", "JavaScript"]

19 – mengonversi sebuah 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 sebuah nilai tunggal pada array dengan cara memanggil

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

78 untuk setiap elemen dan mengoper hasil tersebut di antara panggilan.

Sebagai 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 merupakan array atau bukan.

Tolong diingat 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-metode ini adalah yang paling sering digunakan, mencakupi 99% kasus penggunaan. Namun masih ada beberapa metode lainnya:

arr.some(fn)/arr.every(fn) memeriksa array terseebut.

Fungsi

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

15 dipanggil pada tiap elemen array yang serupa dengan

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

29. Jika beberapa/semua hasilnya

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

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 yang sebenarnya,

let arr = ["I", "study", "JavaScript"];

arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen

alert( arr ); // ["I", "JavaScript"]

35segera 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 melakukan iterasi pada item lainnya; jika

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

15 mengembalikan nilai yang salah,

let arr = ["I", "study", "JavaScript"];

arr.splice(1, 1); // dari indeks 1 menghapus 1 elemen

alert( arr ); // ["I", "JavaScript"]

38segera 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 dan juga menghentikan iterasi pada item lainnya.

Kita bisa 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.fill(value, start, end) – mengisi 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) – menyalin 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 hingga 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 (menumpuk/overwrite elemen yang ada).

arr.flat(depth)/arr.flatMap(fn) buat array baru dari array multidimensi.

Untuk daftar lengkapnya, lihat manual.

Sejak pandangan pertama mungkin terlihat ada begitu banyak metode, cukup sulit untuk diingat. Namun sebenarnya hal itu jauh lebih mudah.

Lihat cheat sheet hanya untuk sekedar tahu semua metode tersebut. Lalu selesaikan task bab ini sebagai latihan, jadi kamu memiliki pengalaman mengenai metode array.

Sesudah itu kapan pun kamu perlu melakukan sesuatu dengan array, dan tidak tahu bagaimana caranya – datanglah ke halaman ini, lihat cheat sheet dan temukan metode yang tepat. Contoh-contoh yang diberikan akan membantumu dalam penulisan sintaks yang benar. Setelah itu kamu akan secara otomatis mengingat metode-metode tersebut, tanpa usaha yang terlalu rumit.

kode javascript

Cara menggunakan negative slice javascript

Pos Terkait

Periklanan

BERITA TERKINI

Toplist Popular

Periklanan

Terpopuler

Token Data

Periklanan

Tentang Kami

Legal

Dukungan

Social