Perulangan: for, for-in, while, do-while, serta break & continue

Bayangkan Anda diminta mencetak daftar tagihan untuk 500 pelanggan, menjumlahkan seluruh transaksi dalam satu bulan, atau mencoba menghubungkan ulang koneksi internet hingga berhasil. Menulis baris kode yang sama berulang-ulang secara manual tentu mustahil dilakukan dan rawan kesalahan. Dalam pemrograman, tugas berulang tersebut diselesaikan dengan struktur perulangan (looping). Dengan perulangan, kita cukup menuliskan instruksinya satu kali, lalu menentukan aturan kapan perulangan tersebut terus berjalan dan kapan harus berhenti. Materi ini membahas empat jenis perulangan di Dart 3 beserta cara mengendalikan iterasinya secara presisi.

Yang akan dipelajari

• Membedakan kapan harus menggunakan perulangan terhitung (for, for-in) dan perulangan berbasis kondisi (while, do-while).
• Menulis perulangan for standar menggunakan variabel penghitung (counter) dan menelusuri daftar elemen menggunakan for-in.
• Memahami perbedaan waktu evaluasi kondisi antara while (cek di awal) dan do-while (cek di akhir).
• Menghentikan perulangan lebih awal dengan break atau melompati satu putaran tertentu dengan continue.
• Mengenali penyebab infinite loop (perulangan tanpa henti) dan cara menghindarinya.

Memilih Jenis Perulangan yang Tepat

Sebelum melihat sintaks kode, mari kita pahami intuisi pemilihan jenis perulangan di Dart melalui tabel perbandingan berikut:

Jenis Loop	Karakteristik Utama	Kapan Sebaiknya Digunakan?
for	Memiliki penghitung awal, batas kondisi, dan perubahan nilai (increment/decrement)	Saat kita tahu pasti jumlah putarannya atau butuh nomor indeks (0, 1, 2, ...).
for-in	Mengambil elemen satu per satu dari suatu koleksi	Saat ingin membaca seluruh isi daftar dari awal sampai akhir tanpa peduli nomor indeksnya.
while	Memeriksa kondisi sebelum menjalankan isi blok	Saat jumlah putaran belum diketahui di awal dan bergantung pada suatu kondisi dinamis.
do-while	Menjalankan isi blok minimal 1 kali, baru memeriksa kondisi di akhir	Saat aksi wajib dieksekusi setidaknya satu kali sebelum dievaluasi (misal: menampilkan menu atau percobaan pertama).

Perulangan Terhitung: for dan for-in

1. Perulangan for standar

Struktur for terdiri dari tiga bagian di dalam tanda kurung yang dipisahkan oleh titik koma (;): for (inisialisasi; kondisiBerjalan; perubahanNilai)

1. Inisialisasi (int i = 1): Dijalankan satu kali di awal sebelum perulangan dimulai.
2. Kondisi Berjalan (i <= 5): Diperiksa sebelum setiap putaran; jika true, blok kode dijalankan; jika false, perulangan berhenti.
3. Perubahan Nilai (i++): Dijalankan setiap kali satu putaran selesai.

void main() {
  print('--- Jadwal Cicilan 4 Bulan ---');
  int pokokPinjaman = 1200000;
  int cicilanPerBulan = pokokPinjaman ~/ 4;

  for (int bulan = 1; bulan <= 4; bulan++) {
    int sisaPinjaman = pokokPinjaman - (cicilanPerBulan * bulan);
    print('Bulan ke-$bulan: Bayar Rp$cicilanPerBulan | Sisa: Rp$sisaPinjaman');
  }
}

// Output:
// --- Jadwal Cicilan 4 Bulan ---
// Bulan ke-1: Bayar Rp300000 | Sisa: Rp900000
// Bulan ke-2: Bayar Rp300000 | Sisa: Rp600000
// Bulan ke-3: Bayar Rp300000 | Sisa: Rp300000
// Bulan ke-4: Bayar Rp300000 | Sisa: Rp0

2. Perulangan for-in

Ketika kita memiliki sekumpulan data (seperti daftar nama mata kuliah) dan hanya ingin memproses setiap item di dalamnya dari awal sampai akhir, panduan Effective Dart sangat menyarankan penggunaan for-in karena lebih bersih dan bebas dari risiko salah tulis batas indeks:

void main() {
  List<String> daftarMataKuliah = [
    'Pemrograman Dasar',
    'Struktur Data',
    'Basis Data',
    'Pemrograman Berorientasi Objek',
  ];

  int totalSks = 0;

  // Membaca setiap elemen di dalam daftarMataKuliah secara berurutan
  for (final matkul in daftarMataKuliah) {
    totalSks += 3; // Asumsi tiap mata kuliah berbobot 3 SKS
    print('Terdaftar di: $matkul (Akumulasi: $totalSks SKS)');
  }
}

// Output:
// Terdaftar di: Pemrograman Dasar (Akumulasi: 3 SKS)
// Terdaftar di: Struktur Data (Akumulasi: 6 SKS)
// Terdaftar di: Basis Data (Akumulasi: 9 SKS)
// Terdaftar di: Pemrograman Berorientasi Objek (Akumulasi: 12 SKS)

Kita akan mempelajari List secara mendalam pada materi ke-6 setelah ini; untuk sekarang, cukup pahami bahwa [...] adalah wadah berisi deretan nilai berurutan yang sangat cocok ditelusuri dengan for-in.

Perulangan Berbasis Kondisi: while dan do-while

Berbeda dengan for yang jumlah langkahnya terukur sejak awal, while dan do-while terus berputar selama ekspresi kondisi di dalam tanda kurung bernilai true.

Perbedaan mendasar di antara keduanya terletak pada kapan syarat diperiksa:

• Pada while, syarat diperiksa di pintu masuk. Jika sejak awal syaratnya sudah false, blok kode di dalamnya tidak akan pernah dijalankan sama sekali (0 kali).
• Pada do-while, syarat diperiksa di pintu keluar. Blok kode di dalam do { ... } dijamin pasti berjalan minimal 1 kali, baru kemudian syarat while (...); diperiksa untuk menentukan apakah perlu mengulang lagi.

void main() {
  // 1. Contoh while: Mengisi daya baterai hingga mencapai 100%
  int kapasitasBaterai = 70;
  print('Mulai pengisian cepat (Fast Charging)...');

  while (kapasitasBaterai < 100) {
    kapasitasBaterai += 15;
    print('Baterai terisi: $kapasitasBaterai%');
  }

  print('\n--- Perbandingan do-while saat kondisi awal sudah false ---');
  int percobaanKoneksi = 1;
  bool sudahTerhubung = true; // Sejak awal sudah true

  // Blok do-while tetap berjalan 1 kali meskipun syarat (!sudahTerhubung) bernilai false
  do {
    print('Memeriksa ping jaringan (Percobaan ke-$percobaanKoneksi)... Status: OK');
    percobaanKoneksi++;
  } while (!sudahTerhubung);
}

// Output:
// Mulai pengisian cepat (Fast Charging)...
// Baterai terisi: 85%
// Baterai terisi: 100%
//
// --- Perbandingan do-while saat kondisi awal sudah false ---
// Memeriksa ping jaringan (Percobaan ke-1)... Status: OK

Waspada Infinite Loop (Perulangan Tak Berujung): Saat menggunakan while, pastikan di dalam blok perulangan ada pernyataan yang mengubah keadaan menuju berhentinya kondisi (seperti kapasitasBaterai += 15; di atas). Jika Anda lupa mengubah variabel pengendalinya, kondisi kapasitasBaterai < 100 akan bernilai true selamanya dan membuat peramban atau aplikasi Anda membeku (hang).

Mengendalikan Putaran: break dan continue

Terkadang kita tidak ingin perulangan berjalan kaku sampai selesai. Kita mungkin ingin segera keluar dari perulangan begitu data yang dicari sudah ditemukan, atau melewati data yang tidak valid tanpa menghentikan proses keseluruhan:

• break: Menghentikan seluruh perulangan saat itu juga dan langsung melompat ke baris kode setelah blok perulangan.
• continue: Mengabaikan sisa baris kode pada putaran saat ini saja, lalu langsung melanjut ke putaran berikutnya.

void main() {
  List<int> riwayatTransaksi = [50000, -10000, 120000, 0, 999999, 75000];
  int totalValid = 0;

  for (final nominal in riwayatTransaksi) {
    // 1. Lewati transaksi bernilai 0 atau negatif (data tidak valid)
    if (nominal <= 0) {
      print('[SKIP] Mengabaikan nominal tidak valid: Rp$nominal');
      continue; // Langsung lanjut ke angka berikutnya di dalam list
    }

    // 2. Hentikan seluruh pemeriksaan jika menemukan kode darurat 999999
    if (nominal == 999999) {
      print('[STOP] Kode pembatalan darurat ditemukan! Menghentikan proses.');
      break; // Keluar sepenuhnya dari perulangan for
    }

    totalValid += nominal;
    print('[OK] Memproses transaksi: Rp$nominal (Subtotal: Rp$totalValid)');
  }

  print('Total Akhir Transaksi Valid: Rp$totalValid');
}

// Output:
// [OK] Memproses transaksi: Rp50000 (Subtotal: Rp50000)
// [SKIP] Mengabaikan nominal tidak valid: Rp-10000
// [OK] Memproses transaksi: Rp120000 (Subtotal: Rp170000)
// [SKIP] Mengabaikan nominal tidak valid: Rp0
// [STOP] Kode pembatalan darurat ditemukan! Menghentikan proses.
// Total Akhir Transaksi Valid: Rp170000

Perhatikan bagaimana angka 75000 di urutan paling akhir tidak pernah diproses karena perulangan sudah dihentikan paksa oleh break saat bertemu angka 999999.

Coba sendiri

Buka dartpad.dev dan salin contoh kode tentang break dan continue di atas. Lakukan eksperimen berikut:

1. Ubah angka 999999 di dalam riwayatTransaksi menjadi 80000, lalu klik Run. Perhatikan bagaimana seluruh transaksi kini diproses sampai elemen terakhir (75000) karena kondisi break tidak pernah terpicu.
2. Tambahkan perulangan for hitung mundur di bagian akhir main() dari angka 5 turun ke 1 menggunakan for (int i = 5; i >= 1; i--). Pastikan Anda menggunakan operator >= dan i-- (bukan i++ agar tidak terjadi infinite loop!).

Kesalahan yang sering terjadi

Kesalahan Pemula	Penyebab	Solusi yang Benar
Terjebak Infinite Loop pada while atau for hitung mundur	Lupa menulis counter++ di dalam blok while, atau menulis i++ padahal syaratnya i >= 0.	Selalu periksa apakah perubahan variabel di setiap putaran semakin mendekati syarat berhentinya loop.
Kesalahan batas satu angka (Off-by-one error)	Bingung antara < dan <= (misal menulis i <= daftar.length padahal indeks dimulai dari 0).	Saat menelusuri indeks mulai dari 0, gunakan < panjangData, atau lebih baik gunakan for-in jika tidak butuh indeks.
Mendeklarasikan variabel penampung total (int total = 0;) di dalam blok perulangan	Variabel total selalu ter-reset kembali menjadi 0 pada setiap putaran baru.	Deklarasikan variabel akumulator/penampung di luar (sebelum) baris for atau while.
Tertukar antara fungsi break dan continue	Mengira continue akan menghentikan perulangan, atau sebaliknya.	Ingat: break = berhenti total keluar dari loop; continue = lompati putaran ini saja dan lanjut ke putaran berikutnya.

Kaitannya dengan Flutter / Dunia Nyata: Di Flutter, konsep perulangan hadir ketika kita merender daftar antarmuka dinamis—seperti daftar pesan obrolan di WhatsApp, katalog produk di aplikasi e-commerce, atau daftar riwayat transaksi. Misalnya, komponen ListView.builder(itemCount: produk.length, itemBuilder: (context, index) => ...) bekerja persis seperti perulangan for berbasis indeks di balik layar untuk menggambar setiap kartu produk di layar ponsel secara efisien.

Latihan

Kerjakan tiga latihan berikut di DartPad untuk menguji pemahaman Anda tentang perulangan:

1. Latihan 1 (Deret Angka dan Filter Kelipatan dengan for & continue): Buatlah perulangan for dari angka 1 hingga 15. Jika angka tersebut merupakan kelipatan 4 (gunakan modulo angka % 4 == 0), lewati angka tersebut menggunakan continue. Untuk angka lainnya, cetak angkanya dan hitung jumlah total semua angka yang berhasil dicetak.
2. Latihan 2 (Simulasi Penarikan Tabungan dengan while): Seorang mahasiswa memiliki saldo tabungan int saldo = 500000;. Setiap minggu ia menarik uang sebesar int penarikanMingguan = 120000;. Gunakan perulangan while untuk menampilkan proses penarikan dari minggu ke-1 dan seterusnya selama saldo masih cukup untuk ditarik (saldo >= penarikanMingguan). Di akhir program, tampilkan sudah berapa minggu ia berhasil menarik uang dan berapa sisa saldo akhirnya.
3. Latihan 3 (Pencarian Barang di Gudang dengan for-in & break): Diberikan daftar kode barang di rak gudang: List<String> rakGudang = ['A01', 'A02', 'RUSAK', 'B01', 'TARGET-X', 'B02', 'C01'];. Telusuri daftar tersebut menggunakan for-in. Jika kode bernilai 'RUSAK', lewati dengan continue. Jika menemukan 'TARGET-X', cetak pesan bahwa barang ditemukan dan segera hentikan pencarian menggunakan break.

Kunci jawaban dan pembahasan

Latihan 1

void main() {
  int totalJumlah = 0;

  for (int angka = 1; angka <= 15; angka++) {
    if (angka % 4 == 0) {
      continue; // Lewati angka 4, 8, dan 12
    }
    print('Angka aktif: $angka');
    totalJumlah += angka;
  }

  print('Total penjumlahan (tanpa kelipatan 4): $totalJumlah');
}

// Output:
// Angka aktif: 1
// Angka aktif: 2
// Angka aktif: 3
// Angka aktif: 5
// Angka aktif: 6
// Angka aktif: 7
// Angka aktif: 9
// Angka aktif: 10
// Angka aktif: 11
// Angka aktif: 13
// Angka aktif: 14
// Angka aktif: 15
// Total penjumlahan (tanpa kelipatan 4): 96

Pembahasan: Variabel totalJumlah dideklarasikan di luar perulangan for agar nilainya terus terakumulasi. Saat angka bernilai 4, 8, dan 12, ekspresi angka % 4 == 0 bernilai true sehingga continue langsung melompati baris print dan penjumlahan di bawahnya.

Latihan 2

void main() {
  int saldo = 500000;
  const int penarikanMingguan = 120000;
  int minggu = 0;

  while (saldo >= penarikanMingguan) {
    minggu++;
    saldo -= penarikanMingguan;
    print('Minggu ke-$minggu: Tarik Rp$penarikanMingguan | Sisa Saldo: Rp$saldo');
  }

  print('--- Ringkasan ---');
  print('Total penarikan berhasil : $minggu minggu');
  print('Sisa saldo akhir         : Rp$saldo');
}

// Output:
// Minggu ke-1: Tarik Rp120000 | Sisa Saldo: Rp380000
// Minggu ke-2: Tarik Rp120000 | Sisa Saldo: Rp260000
// Minggu ke-3: Tarik Rp120000 | Sisa Saldo: Rp140000
// Minggu ke-4: Tarik Rp120000 | Sisa Saldo: Rp20000
// --- Ringkasan ---
// Total penarikan berhasil : 4 minggu
// Sisa saldo akhir         : Rp20000

Pembahasan: Perulangan while sangat tepat untuk kasus ini karena kita bergantung pada kondisi kecukupan saldo (saldo >= penarikanMingguan). Setelah minggu ke-4, sisa saldo menjadi Rp20000 (kurang dari 120000), sehingga kondisi while bernilai false dan perulangan berhenti dengan aman.

Latihan 3

void main() {
  List<String> rakGudang = ['A01', 'A02', 'RUSAK', 'B01', 'TARGET-X', 'B02', 'C01'];

  for (final kode in rakGudang) {
    if (kode == 'RUSAK') {
      print('Melewati barang berlabel RUSAK...');
      continue;
    }

    print('Memeriksa kode barang: $kode');

    if (kode == 'TARGET-X') {
      print('--> Barang TARGET-X ditemukan! Menghentikan pencarian.');
      break;
    }
  }
}

// Output:
// Memeriksa kode barang: A01
// Memeriksa kode barang: A02
// Melewati barang berlabel RUSAK...
// Memeriksa kode barang: B01
// Memeriksa kode barang: TARGET-X
// --> Barang TARGET-X ditemukan! Menghentikan pencarian.

Pembahasan: Kombinasi for-in, continue, dan break membuat pencarian berjalan efisien. Elemen 'RUSAK' dilewati tanpa diinspeksi lebih lanjut, dan begitu 'TARGET-X' ditemukan, break menghemat waktu komputasi dengan tidak perlu lagi memeriksa 'B02' dan 'C01'.