Class Lists

Menyisipkan item pada suatu posisi; item-item dari posisi itu dan seterusnya bergeser naik satu.

Contoh: [10, 20, 30, 40] dengan 99 pada indeks 2 -> [10, 20, 99, 30, 40]

Menyisipkan item yang sama pada beberapa posisi daftar asli.

Contoh: [10, 20, 30] dengan 99 pada indeks [0, 2] -> [99, 10, 20, 99, 30]

Menyisipkan beberapa item, yang pertama pada indeks pertama, yang kedua pada indeks kedua, dan seterusnya, semuanya dihitung pada daftar asli.

Indeks harus dalam urutan menaik dan harus ada satu per item, atau error dipicu. Contoh: [10, 20, 30] dengan item [88, 99] pada indeks [1, 2] -> [10, 88, 20, 99, 30]

Menambahkan item di akhir daftar.

Contoh: [10, 20, 30] menambahkan 40 -> [10, 20, 30, 40]

Menambahkan item di awal daftar.

Contoh: [10, 20, 30] menambahkan 5 di depan -> [5, 10, 20, 30]

Menambahkan item di awal atau di akhir daftar, sesuai pilihan.

Contoh: [10, 20, 30] menambahkan 5 di awal -> [5, 10, 20, 30]; di akhir -> [10, 20, 30, 5]

Menyambung beberapa daftar menjadi satu, ujung ke ujung.

Contoh: [[1, 2], [3, 4], [5, 6]] -> [1, 2, 3, 4, 5, 6]

Membuat daftar baru tanpa isi.

Contoh: -> []

Membuat daftar yang memuat item yang sama sejumlah kali.

Contoh: 5 tiga kali -> [5, 5, 5]

Mengulang pola item berulang-ulang sampai daftar mencapai panjang tertentu.

Contoh: [1, 2, 3] sampai panjang 7 -> [1, 2, 3, 1, 2, 3, 1]

Membalik urutan item-item.

Contoh: [1, 2, 3, 4, 5] -> [5, 4, 3, 2, 1]

Menempatkan item-item dalam urutan acak, berbeda pada setiap panggilan.

Contoh: [1, 2, 3, 4, 5] -> mungkin [3, 1, 5, 2, 4]

Memutar daftar dari daftar ke sisinya: baris menjadi kolom dan kolom menjadi baris.

Semua daftar dalam harus sama panjang. Contoh: [[0, 1, 2], [3, 4, 5]] -> [[0, 3], [1, 4], [2, 5]]

Membagi daftar menjadi kelompok-kelompok berisi n item.

Item-item yang tersisa di akhir dibuang kecuali keepRemainder aktif, yang menambahkannya sebagai kelompok terakhir yang lebih pendek. Contoh: [0, 1, 2, 3, 4, 5, 6, 7, 8] dalam kelompok 3 -> [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

Membaca item pada suatu posisi dalam daftar, dihitung dari 0.

Indeks di luar daftar memicu error. Contoh: [10, 20, 30, 40] pada indeks 2 -> 30

Membaca item pertama daftar.

Contoh: [10, 20, 30, 40] -> 10

Membaca item terakhir daftar.

Contoh: [10, 20, 30, 40] -> 40

Mempertahankan setiap item daftar dengan probabilitas tertentu dan membuang sisanya, sehingga hasilnya berbeda pada setiap panggilan.

Contoh: [1, 2, 3, 4, 5] dengan ambang 0.5 -> mungkin [1, 3, 5]

Memotong item-item dari indeks awal sampai, tetapi tidak termasuk, indeks akhir.

Contoh: [10, 20, 30, 40, 50] dari 1 sampai 4 -> [20, 30, 40]

Mempertahankan setiap item ke-n, mulai dari sebuah offset.

Contoh: [0, 1, 2, 3, 4, 5, 6, 7, 8] dengan nth 3 dan offset 0 -> [0, 3, 6]; dengan nth 2 dan offset 1 -> [1, 3, 5, 7]

Mempertahankan item-item di tempat pola true/false yang berulang menyatakan true dan membuang yang lain.

Pola dimulai lagi dari awal jika habis. Contoh: [0, 1, 2, 3, 4, 5] dengan pola [true, true, false] -> [0, 1, 3, 4]

Mengelompokkan ulang daftar-daftar bersarang menurut posisi: item pertama dari setiap daftar digabung bersama, lalu item kedua, dan seterusnya.

level menyatakan berapa banyak tingkat sarang yang diratakan di dalam setiap daftar terlebih dahulu; 0 mengelompokkan ulang apa adanya. Contoh: [[0, 1, 2], [3, 4, 5]] pada level 0 -> [[0, 3], [1, 4], [2, 5]]

Mengukur daftar terpanjang di antara beberapa daftar.

Contoh: [[1, 2], [3, 4, 5, 6], [7]] -> 4

Memberi tahu apakah sebuah item ada dalam daftar.

Item dibandingkan menurut identitas, sehingga objek hanya ditemukan jika objek yang persis sama ada dalam daftar. Contoh: [10, 20, 30, 40] memuat 30 -> true, memuat 50 -> false

Menemukan posisi kemunculan pertama sebuah item, atau -1 jika tidak ada dalam daftar.

Contoh: [10, 20, 30, 20, 40] mencari 20 -> 1, mencari 50 -> -1

Mengukur seberapa dalam daftar-daftar bersarang di dalam daftar.

Contoh: [1, 2, 3] -> 1, [[1, 2], [3, 4]] -> 2, [[[1]]] -> 3

Menghitung item-item dalam daftar.

Contoh: [10, 20, 30, 40, 50] -> 5, [] -> 0

Menghapus item pada suatu posisi.

Contoh: [10, 20, 30, 40, 50] menghapus indeks 2 -> [10, 20, 40, 50]

Menghapus item pertama.

Contoh: [10, 20, 30, 40] -> [20, 30, 40]

Menghapus item terakhir.

Contoh: [10, 20, 30, 40] -> [10, 20, 30]

Menghapus item yang dihitung dari akhir: indeks 0 adalah item terakhir, 1 yang sebelumnya.

Contoh: [10, 20, 30, 40, 50] menghapus indeks 1 dari akhir -> [10, 20, 30, 50]

Menghapus item-item pada beberapa posisi, semuanya dihitung pada daftar asli.

Contoh: [10, 20, 30, 40, 50] menghapus indeks [1, 3] -> [10, 30, 50]

Mengosongkan daftar yang diberikan, di tempat: array yang sama dikembalikan tanpa item di dalamnya.

Contoh: [10, 20, 30, 40] -> []

Menghapus setiap item ke-n, mulai dari sebuah offset.

Contoh: [0, 1, 2, 3, 4, 5, 6, 7, 8] dengan nth 3 dan offset 0 -> [1, 2, 4, 5, 7, 8]

Membuang setiap item daftar dengan probabilitas tertentu dan mempertahankan sisanya, sehingga hasilnya berbeda pada setiap panggilan.

Contoh: [1, 2, 3, 4, 5] dengan ambang 0.5 -> mungkin [2, 4]

Menghapus angka-angka yang berulang, mempertahankan kemunculan pertama masing-masing.

Contoh: [1, 2, 3, 2, 4, 3, 5] -> [1, 2, 3, 4, 5]

Menghapus angka-angka yang berada dalam toleransi dari angka yang sudah dipertahankan, sehingga nilai yang hanya berbeda oleh derau floating-point dihitung sama.

Contoh: [1.0, 1.001, 2.0, 2.002, 3.0] dengan toleransi 0.01 -> [1.0, 2.0, 3.0]

Menghapus item-item berulang jenis apa pun, mempertahankan kemunculan pertama masing-masing.

Item dibandingkan menurut identitas, sehingga dua objek yang tampak setara keduanya tetap ada. Contoh: ['a', 'b', 'c', 'a', 'd', 'b'] -> ['a', 'b', 'c', 'd']

Mengurutkan angka dari terendah ke tertinggi, atau dari tertinggi ke terendah.

Contoh: [5, 2, 8, 1, 9] menaik -> [1, 2, 5, 8, 9]; menurun -> [9, 8, 5, 2, 1]

Mengurutkan teks secara alfabetis, dari A ke Z atau dari Z ke A.

Contoh: ['dog', 'apple', 'cat'] menaik -> ['apple', 'cat', 'dog']

Mengurutkan objek-objek menurut angka yang dimuat salah satu propertinya.

Contoh: [{age: 30}, {age: 20}, {age: 25}] menurut 'age' menaik -> [{age: 20}, {age: 25}, {age: 30}]

Menjalin beberapa daftar menjadi satu dengan mengambil item pertama dari masing-masing secara bergiliran, lalu item kedua dari masing-masing, dan seterusnya.

Daftar yang lebih pendek begitu saja keluar setelah habis. Daftar dari daftar yang kosong memicu error. Contoh: [[0, 1, 2], [3, 4, 5]] -> [0, 3, 1, 4, 2, 5]