Cara Menggunakan Kriteria untuk Memetakan Array JavaScript dari Indeks Tertentu

Bekerja dengan Pemetaan Array Berdasarkan Indeks dan Kondisi

Saat bekerja dengan Array JavaScript, terkadang Anda mungkin perlu mengubah data dengan hanya berfokus pada elemen yang dimulai dari indeks tertentu. Menggunakan metode seperti Array.peta() memungkinkan pengembang untuk melakukan iterasi secara efisien melalui array dan menerapkan transformasi. Namun, menentukan pendekatan terbaik saat memfilter berdasarkan kondisi dapat menimbulkan beberapa pertanyaan.

Pada artikel ini, kita akan mempelajari cara memetakan array mulai dari indeks tertentu dan memfilter elemennya berdasarkan indeks yang ditentukan kriteria. Misalnya, salah satu kebutuhan umum adalah mengekstrak indeks angka yang lebih kecil dari nilai tertentu. Topik ini menjadi sangat penting ketika bekerja dengan kumpulan data besar yang mengutamakan efisiensi.

Cuplikan kode yang diberikan menunjukkan upaya untuk menggunakan peta() berfungsi untuk mencapai hal ini. Namun, pengembang sering bertanya-tanya apakah itu benar Array.peta() adalah pilihan yang paling cocok untuk tugas ini atau jika ada alternatif yang lebih efisien. Kami akan menganalisis masalahnya untuk memandu Anda menuju pendekatan terbaik.

Di akhir diskusi ini, Anda akan mendapatkan pemahaman yang lebih baik tentang cara memanipulasi array berdasarkan keduanya indeks dan kondisi berbasis nilai. Kami juga akan melihat alternatif yang dapat menawarkan kinerja lebih baik, khususnya untuk array besar.

Pelajari Lebih Dalam Pemetaan Array dari Indeks Tertentu di JavaScript

Skrip pertama menunjukkan penggunaan Array.slice() dikombinasikan dengan Array.peta(). Pendekatan ini membantu kita mengekstrak sebagian array asli mulai dari indeks tertentu, lalu memetakan elemen lainnya berdasarkan kondisi tertentu. Metode irisan memastikan bahwa hanya elemen dari indeks awal yang dipilih dan seterusnya yang dipertimbangkan untuk diproses lebih lanjut. Fungsi peta, pada gilirannya, memeriksa setiap nilai dan mengembalikan indeksnya jika cocok dengan kriteria kurang dari 8, atau -1 jika tidak.

Contoh kedua berfokus pada pendekatan yang lebih mengoptimalkan kinerja dengan menggunakan pendekatan tradisional untuk lingkaran. Di sini, skrip memberi pengembang kendali penuh atas iterasi dengan memulai loop secara manual dari indeks yang diinginkan. Pendekatan ini menghindari overhead tambahan yang terkait dengan metode fungsional seperti peta dan filter. Setiap indeks yang valid dimasukkan langsung ke dalam array hasil. Manfaat metode ini menjadi jelas ketika bekerja dengan array besar, dimana mengurangi pemanggilan fungsi dapat meningkatkan kinerja secara signifikan.

Solusi ketiga menawarkan alternatif pemrograman fungsional dengan menggunakan Array.mengurangi(). Metode ini mengumpulkan indeks yang memenuhi kriteria ke dalam satu larik, memberikan cara ringkas untuk mencapai hasil yang sama. Fungsi pengurangan mengulangi setiap elemen mulai dari indeks yang ditentukan, dan jika elemen memenuhi kondisi, ia menambahkan indeks ke array akumulator. Metode pengurangan sangat berguna untuk transformasi kompleks yang memerlukan pemfilteran dan akumulasi dalam satu lintasan.

Terakhir, pengujian unit sangat penting untuk memvalidasi solusi ini, terutama ketika ukuran array bertambah atau kondisi berubah secara dinamis. Contohnya menggunakan Bersenda gurau kerangka kerja untuk menjalankan pengujian otomatis, memastikan setiap pendekatan menghasilkan keluaran yang benar untuk berbagai kasus. Pengujian membantu mengidentifikasi kasus-kasus edge dan memberikan keyakinan bahwa kode akan bekerja dalam skenario yang berbeda. Setiap pengujian unit memverifikasi apakah indeks yang dikembalikan oleh skrip cocok dengan keluaran yang diharapkan. Pendekatan komprehensif ini memastikan bahwa kinerja dan kebenaran dapat dicapai, apa pun metode yang dipilih.

// Approach 1: Using Array.slice() and Array.map() for Partial Mapping
const array = [4, 2, 8, 3, 4, 6];
const startIndex = 1;  // Starting index for filtering
const result = array.slice(startIndex).map((x, i) => (x < 8 ? i + startIndex : -1))
                .filter(index => index !== -1);
console.log(result);  // Output: [1, 3, 4, 5]
// This method uses slice() to extract the subarray from index 1
// and map() to find indexes of elements meeting the criteria.

// Approach 2: Using a for loop for better control and optimization
const array = [4, 2, 8, 3, 4, 6];
const startIndex = 1;
const result = [];
for (let i = startIndex; i < array.length; i++) {
    if (array[i] < 8) result.push(i);
}
console.log(result);  // Output: [1, 3, 4, 5]
// This approach provides better performance with large arrays
// by avoiding the overhead of map() and filter().

// Approach 3: Functional approach using Array.reduce()
const array = [4, 2, 8, 3, 4, 6];
const startIndex = 1;
const result = array.reduce((acc, val, i) => {
    if (i >= startIndex && val < 8) acc.push(i);
    return acc;
}, []);
console.log(result);  // Output: [1, 3, 4, 5]
// Array.reduce() offers a concise and functional way to collect
// the indexes matching the criteria without additional filtering.

// Unit tests for all three approaches using Jest
const { test, expect } = require('@jest/globals');
const array = [4, 2, 8, 3, 4, 6];

test('Approach 1: Slice and Map', () => {
    const result = array.slice(1).map((x, i) => (x < 8 ? i + 1 : -1)).filter(i => i !== -1);
    expect(result).toEqual([1, 3, 4, 5]);
});

test('Approach 2: For Loop', () => {
    const result = [];
    for (let i = 1; i < array.length; i++) {
        if (array[i] < 8) result.push(i);
    }
    expect(result).toEqual([1, 3, 4, 5]);
});

test('Approach 3: Reduce', () => {
    const result = array.reduce((acc, val, i) => {
        if (i >= 1 && val < 8) acc.push(i);
        return acc;
    }, []);
    expect(result).toEqual([1, 3, 4, 5]);
});

Menjelajahi Teknik Pemetaan Array Tingkat Lanjut dalam JavaScript

Pendekatan yang menarik di luar penggunaan Array.peta() atau untuk loop sedang memanfaatkan Array.findIndex() metode untuk menemukan elemen secara dinamis berdasarkan kondisi. Metode ini mengembalikan indeks pertama yang memenuhi kondisi tertentu, sehingga berguna ketika Anda perlu memetakan array tetapi berhenti segera setelah elemen yang cocok ditemukan. Meskipun ini sedikit berbeda dengan melakukan iterasi pada seluruh array, ini menawarkan alternatif yang berfungsi dengan baik untuk kasus penggunaan tertentu, terutama ketika hanya indeks pencocokan pertama yang diperlukan.

Alternatif lain untuk meningkatkan keterbacaan adalah Array.flatMap(). Metode ini sangat membantu jika logika pemetaan melibatkan pembuatan beberapa keluaran untuk satu masukan, atau jika Anda perlu meratakan hasil yang disarangkan ke dalam array satu dimensi. Berbeda dengan standar peta(), yang mengembalikan array dengan panjang yang sama, peta datar() menggabungkan operasi pemetaan dan perataan dalam satu lintasan. Meskipun mungkin tidak umum digunakan, ini dapat menyederhanakan kode Anda dalam skenario yang lebih kompleks.

Terakhir, jika kinerja menjadi perhatian utama, maka digunakan pendekatan hybrid untukSetiap() karena iterasi yang dikombinasikan dengan logika push berbasis kondisi dapat menawarkan kecepatan dan kesederhanaan. Ini menghilangkan pemanggilan fungsi yang tidak perlu dan menjaga logika Anda tetap sederhana. Sejak untukSetiap() tidak mengembalikan array baru, ini ideal bila tujuannya adalah efek samping (seperti menambahkan nilai ke array eksternal). Kombinasi ini memastikan performa tinggi dengan tetap menjaga kejelasan kode, terutama saat bekerja dengan kumpulan data besar.