Optimasi Sederhana: Membuat Kode Lebih Efisien - Perwira Learning Center

Raditya Fauzi Pratama Februari 01, 2026


1. LATAR BELAKANG

Pada pembelajaran terakhir dalam seri Problem Solving Dasar ini, saya mempelajari tentang optimasi kode. Setelah mampu memahami masalah, memecahnya, mengenali pola, dan melakukan testing, langkah selanjutnya adalah meningkatkan kualitas kode. Sebagai siswa SMK yang terus berkembang, saya menyadari bahwa kode yang bekerja dengan benar belum tentu kode yang baik - masih ada aspek efisiensi dan readability yang perlu diperhatikan.

Dalam dunia programming profesional, optimasi adalah proses continuous improvement. Developer tidak berhenti setelah kode berjalan, mereka terus mencari cara membuat kode lebih baik. Pembelajaran ini difokuskan pada prinsip-prinsip dasar optimasi yang applicable untuk pemula, bukan optimasi tingkat advanced.

2. ALAT DAN BAHAN

2.1 Perangkat Lunak

  • Visual Studio Code - Text editor untuk menulis kode JavaScript
  • Google Chrome / Mozilla Firefox - Browser dengan Developer Console untuk testing
  • Node.js - (Opsional) Runtime environment untuk menjalankan JavaScript

2.2 Perangkat Keras

  • Laptop/PC - Spesifikasi minimal: Processor dual-core, RAM 4GB, Storage 128GB
  • Koneksi Internet - Untuk mengakses dokumentasi dan referensi online

3. PEMBAHASAN

3.1 Pengertian Optimasi dalam Programming

Optimasi adalah proses memperbaiki kode agar lebih efisien dari segi performa (kecepatan), memory, dan kualitas (readability). Untuk pemula, fokus utama pada menghindari kesalahan umum yang membuat kode inefficient dan menjaga kode tetap clean.

Aspek-aspek Optimasi:

  1. Performance - Kode berjalan lebih cepat
  2. Memory - Penggunaan memory lebih efisien
  3. Readability - Kode mudah dibaca
  4. Maintainability - Kode mudah di-maintain

3.2 Prinsip Dasar Code Efficiency

DRY (Don't Repeat Yourself)

Jangan tulis kode yang sama berulang kali. Buat fungsi untuk logic yang dipakai berkali-kali.

KISS (Keep It Simple)

Jaga kode tetap simple. Jangan buat kompleks kalau ada cara sederhana.

Hindari Pengulangan Tidak Perlu

Jangan lakukan operasi yang sama berkali-kali jika hasilnya bisa disimpan.

Nama Variabel yang Jelas

Gunakan nama descriptive agar kode self-documenting.

3.3 Perbedaan Kode "Bekerja" vs "Efisien"

Kode yang bekerja = menghasilkan output benar Kode yang efisien = menghasilkan output benar dengan cara optimal

Contoh: Hitung Jumlah Angka Genap

TIDAK Efisien:

function hitungGenap(arr) {
  let arrayGenap = [];
  
  // Loop 1: cari semua genap
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] % 2 === 0) {
      arrayGenap.push(arr[i]);
    }
  }
  
  // Loop 2: hitung panjang (TIDAK PERLU!)
  let jumlah = 0;
  for (let i = 0; i < arrayGenap.length; i++) {
    jumlah++;
  }
  
  return jumlah;
}

Masalah: Loop 2x, buat array baru yang tidak perlu

Efisien:

function hitungGenap(arr) {
  let jumlah = 0;
  
  // Cukup 1 loop
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] % 2 === 0) {
      jumlah++;
    }
  }
  
  return jumlah;
}

Keuntungan: 1 loop, hemat memory, lebih simple

3.4 Teknik Optimasi Sederhana

Teknik 1: Gunakan Early Return

Jika sudah dapat jawaban, langsung return.

Buruk:

function cariNama(arr, nama) {
  let found = false;
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === nama) {
      found = true;
    }
  }
  return found;
}

Baik:

function cariNama(arr, nama) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === nama) {
      return true; // Langsung return
    }
  }
  return false;
}

Teknik 2: Hitung Sekali, Pakai Berkali-kali

Buruk:

for (let i = 0; i < arr.length; i++) { // arr.length dihitung terus!
  console.log(arr[i]);
}

Baik:

let len = arr.length; // Hitung sekali
for (let i = 0; i < len; i++) {
  console.log(arr[i]);
}

Teknik 3: Hindari Nested Loop Jika Tidak Perlu

Nested loop = complexity O(n²), bisa sangat lambat.

3.5 Contoh Penerapan: Optimasi Fungsi Analisis Data

Soal: "Buatlah fungsi analisis nilai siswa: hitung jumlah lulus (≥75), tidak lulus, rata-rata, dan nilai tertinggi."

Implementasi:

// PERBANDINGAN: INEFFICIENT VS EFFICIENT


// VERSI TIDAK EFISIEN (4 LOOPS!)
function analisisInefficient(nilaiArray) {
  // Loop 1: Hitung lulus
  let lulus = 0;
  for (let i = 0; i < nilaiArray.length; i++) {
    if (nilaiArray[i] >= 75) lulus++;
  }
  
  // Loop 2: Hitung tidak lulus
  let tidakLulus = 0;
  for (let i = 0; i < nilaiArray.length; i++) {
    if (nilaiArray[i] < 75) tidakLulus++;
  }
  
  // Loop 3: Hitung rata-rata
  let total = 0;
  for (let i = 0; i < nilaiArray.length; i++) {
    total += nilaiArray[i];
  }
  let rataRata = total / nilaiArray.length;
  
  // Loop 4: Cari tertinggi
  let tertinggi = nilaiArray[0];
  for (let i = 1; i < nilaiArray.length; i++) {
    if (nilaiArray[i] > tertinggi) {
      tertinggi = nilaiArray[i];
    }
  }
  
  return { lulus, tidakLulus, rataRata, tertinggi };
}

//  VERSI EFISIEN (1 LOOP!)
function analisisEfficient(nilaiArray) {
  if (!nilaiArray || nilaiArray.length === 0) {
    return null;
  }
  
  let lulus = 0;
  let tidakLulus = 0;
  let total = 0;
  let tertinggi = nilaiArray[0];
  
  // HANYA 1 LOOP untuk semua perhitungan!
  for (let i = 0; i < nilaiArray.length; i++) {
    let nilai = nilaiArray[i];
    
    // Hitung lulus/tidak lulus
    if (nilai >= 75) {
      lulus++;
    } else {
      tidakLulus++;
    }
    
    // Akumulasi total
    total += nilai;
    
    // Update tertinggi
    if (nilai > tertinggi) {
      tertinggi = nilai;
    }
  }
  
  let rataRata = total / nilaiArray.length;
  
  return { lulus, tidakLulus, rataRata, tertinggi };
}


// TESTING & COMPARISON


console.log("=== PERBANDINGAN INEFFICIENT VS EFFICIENT ===\n");

let dataNilai = [85, 70, 90, 65, 88, 75, 92, 60, 95, 78];

console.log("Data:", dataNilai);
console.log();

// Test inefficient
console.log(">>> INEFFICIENT (4 loops):");
console.time("Inefficient");
let hasil1 = analisisInefficient(dataNilai);
console.timeEnd("Inefficient");
console.log(hasil1);
console.log();

// Test efficient
console.log(">>> EFFICIENT (1 loop):");
console.time("Efficient");
let hasil2 = analisisEfficient(dataNilai);
console.timeEnd("Efficient");
console.log(hasil2);
console.log();

// Test dengan data besar
console.log("=== TEST DENGAN DATA BESAR ===\n");

let dataBesar = [];
for (let i = 0; i < 100000; i++) {
  dataBesar.push(Math.floor(Math.random() * 100) + 1);
}

console.log(`Testing dengan ${dataBesar.length} data...\n`);

console.log(">>> INEFFICIENT:");
console.time("Inefficient (Big)");
analisisInefficient(dataBesar);
console.timeEnd("Inefficient (Big)");

console.log();

console.log(">>> EFFICIENT:");
console.time("Efficient (Big)");
analisisEfficient(dataBesar);
console.timeEnd("Efficient (Big)");

console.log("\n=== KESIMPULAN ===");
console.log("Versi EFFICIENT lebih cepat karena:");
console.log("✓ Hanya 1 loop (vs 4 loops)");
console.log("✓ Tidak ada pengulangan operasi");
console.log("✓ Memory usage lebih efisien");

console.log("\n=== SELESAI ===");

Penjelasan Optimasi:

  1. Single Loop: Semua perhitungan dalam 1 loop, bukan 4 terpisah
  2. Variable Caching: Nilai disimpan di variabel untuk akses lebih cepat
  3. Clear Names: Nama variabel descriptive dan mudah dipahami

Performance:

  • Data kecil: Perbedaan tidak terlalu terasa
  • Data besar (100,000 items): Versi efficient 3-4x lebih cepat!

3.6 Kendala dan Solusi

Kendala 1: Terlalu Fokus Optimasi Prematur

Menghabiskan banyak waktu optimasi kode yang sudah cukup efisien.

Solusi: Ikuti prinsip "Make it work, make it right, make it fast". Buat dulu sampai bekerja, pastikan benar, baru optimasi.

Kendala 2: Sulit Mengukur Efisiensi

Tidak tahu apakah optimasi benar-benar membuat perbedaan.

Solusi: Gunakan console.time() dan console.timeEnd() untuk ukur. Compare before dan after.

Kendala 3: Optimasi Membuat Kode Sulit Dibaca

Kode jadi kompleks untuk efisiensi.

Solusi: Balance antara efisiensi dan readability. Tambahkan komentar jika perlu.

4. KESIMPULAN

Optimasi kode adalah skill yang membedakan programmer pemula dan professional. Prinsip dasar seperti DRY, menghindari pengulangan, dan single loop untuk multiple operations adalah teknik sederhana namun powerful. Yang terpenting adalah membangun habit untuk review kode dan bertanya "Apakah ada cara lebih baik?" Balance antara efisiensi, readability, dan maintainability adalah kunci kode berkualitas.

Dengan menguasai kelima aspek problem solving dasar - memahami masalah, memecah masalah, mengenali pola, testing, dan optimasi - kita memiliki foundation solid untuk menjadi programmer professional.

5. DAFTAR PUSTAKA

Bentley, J. (1999). Programming Pearls. Addison-Wesley Professional.

Martin, R. C. (2008). Clean Code: A Handbook of Agile Software Craftsmanship. Prentice Hall.

Mozilla Developer Network. (2024). JavaScript Performance. Diakses dari https://developer.mozilla.org/en-US/docs/Web/Performance

W3Schools. (2024). JavaScript Best Practices. Diakses dari https://www.w3schools.com/js/js_best_practices.asp

Crockford, D. (2008). JavaScript: The Good Parts. O'Reilly Media.

Raditya Fauzi Pratama

Diposting oleh Raditya Fauzi Pratama

Posting Komentar

0 Komentar