Di materi ini kamu belajar do...while, yang merupakan variasi dari while. Konsepnya sebenarnya cukup sederhana, tetapi ada satu perbedaan yang sangat penting:

while mengecek kondisi terlebih dahulu. do...while menjalankan kode terlebih dahulu, baru mengecek kondisi.

Perbedaan urutan ini menyebabkan do...while pasti menjalankan kode minimal satu kali, meskipun kondisi sejak awal sudah false.

1. Mengingat kembali while

Dari materi sebelumnya, kita punya:

while (condition) {
    // kode
}

Contoh:

var x = 10

while (x < 5) {
    println(x)
    x++
}

Sekarang lihat kondisinya:

x = 10

10 < 5

Hasilnya:

false

Karena while mengecek kondisi sebelum masuk ke loop, maka kode:

println(x)

tidak akan pernah dijalankan.

Urutannya:

x = 10
   ↓
cek x < 5
   ↓
false
   ↓
STOP

Output:

tidak ada

2. Sekarang kita kenalkan do...while

Syntax-nya:

do {
    // kode yang diulang
} while (condition)

Perhatikan perbedaannya.

Pada while:

while (condition) {
    // kode
}

Kondisi di depan.

Pada do...while:

do {
    // kode
} while (condition)

Kondisi di belakang.

Jadi namanya memang:

DO → lakukan dulu
WHILE → selama kondisi masih true

3. Perbedaan paling penting

Ini yang sebaiknya benar-benar kamu hafalkan:

while

CEK
 ↓
true?
 ↓
jalankan

do...while

JALANKAN
 ↓
CEK
 ↓
true?
 ↓
ulangi

Atau lebih gampang:

while = cek dulu, lakukan kalau boleh

do...while = lakukan dulu, baru cek apakah perlu mengulang

4. Contoh paling sederhana

Mari kita gunakan angka yang sama.

Menggunakan while

var x = 10

while (x < 5) {
    println(x)
    x++
}

Kondisi:

10 < 5 → false

Maka tidak ada output.

Menggunakan do...while

var x = 10

do {
    println(x)
    x++
} while (x < 5)

Apa yang terjadi?

Pertama, Kotlin langsung menjalankan isi do:

println(x)
x++

Awalnya:

x = 10

Maka:

print 10

Kemudian:

x = 11

Baru setelah itu Kotlin mengecek:

11 < 5

Hasil:

false

Maka berhenti.

Output:

10

Nah, inilah perbedaan besarnya.

Walaupun kondisi dari awal tidak memungkinkan loop berlanjut, do...while tetap melakukan satu kali eksekusi.

5. Analogi sehari-hari

Bayangkan kamu punya pintu restoran.

while

Satpam berkata:

“Kalau restoran masih buka, silakan masuk.”

Kamu datang.

Restoran buka?
 ↓
YES → masuk
NO  → tidak masuk

Kondisi diperiksa sebelum masuk.

Ini seperti:

while (restaurantIsOpen) {
    enter()
}

do...while

Sekarang bayangkan:

Kamu masuk dulu, baru setelah itu dicek apakah restoran masih buka untuk kunjungan berikutnya.

Masuk dulu
   ↓
cek restoran buka?
   ↓
YES → lakukan lagi
NO  → berhenti

Itulah do...while.

Memang analoginya agak aneh di dunia nyata 😄, tetapi bagus untuk mengingat urutannya:

while     → cek → lakukan
doWhile   → lakukan → cek

6. Kenapa do...while bisa menghasilkan minimal satu output?

Karena bagian:

do {
    println(x)
} while (condition)

Kotlin tidak punya kesempatan untuk mengecek kondisi sebelum println().

Urutannya sudah ditentukan:

do
 ↓
jalankan isi
 ↓
while
 ↓
cek kondisi

Jadi isi do pasti dieksekusi setidaknya satu kali.

7. Contoh yang lebih mudah

var number = 1

do {
    println(number)
    number++
} while (number <= 5)

Output:

1
2
3
4
5

Mari kita lihat.

Putaran pertama

Awalnya:

number = 1

Langsung jalankan:

print 1
number = 2

Kemudian cek:

2 <= 5 → true

Ulangi.

Putaran kedua

number = 2

Jalankan:

print 2
number = 3

Cek:

3 <= 5 → true

Ulangi.

Putaran berikutnya

3 → print
4 → print
5 → print

Setelah 5 dicetak, number menjadi:

6

Kemudian:

6 <= 5 → false

Loop berhenti.

8. Bandingkan while dan do...while

Sekarang kita buat kondisi yang dari awal sudah false.

while

var x = 10

while (x < 5) {
    println(x)
}

Proses:

x = 10
 ↓
10 < 5 → false
 ↓
STOP

Output:

tidak ada

do...while

var x = 10

do {
    println(x)
} while (x < 5)

Proses:

x = 10
 ↓
print 10
 ↓
cek 10 < 5
 ↓
false
 ↓
STOP

Output:

10

Jadi tabelnya:

Ini adalah inti utama lesson ini.

9. Sekarang kita pahami contoh dari video

Subtitle-nya agak kacau. Bagian yang dimaksud kemungkinan melibatkan dua loop:

var x = 10

while (x < 5) {
    x = x + x + 1
    println(x)
}

do {
    x = x + x + 1
    println(x)
} while (x < 10)

Mari kita analisis.

Awalnya:

x = 10

Loop pertama: while

Kode:

while (x < 5) {
    ...
}

Kotlin langsung mengecek:

10 < 5

Hasil:

false

Jadi isi while tidak dijalankan sama sekali.

x tetap:

10

10. Masuk ke do...while

Sekarang:

do {
    x = x + x + 1
    println(x)
} while (x < 10)

Ingat:

Jangan cek x < 10 dulu!

Karena ini do...while.

Langsung jalankan:

x = x + x + 1

x sekarang adalah 10.

Jadi:

x = 10 + 10 + 1

Hasil:

x = 21

Kemudian:

println(x)

Output:

21

Baru setelah itu kondisi diperiksa:

21 < 10

Hasil:

false

Maka loop berhenti.

Output:

21

Inilah kemungkinan asal angka 21 yang disebutkan di subtitle.

11. Perhatikan urutannya

Untuk kode:

do {
    x = x + x + 1
    println(x)
} while (x < 10)

Urutannya:

x = 10
   ↓
DO
   ↓
x = 10 + 10 + 1
   ↓
x = 21
   ↓
print 21
   ↓
cek 21 < 10
   ↓
false
   ↓
STOP

Kalau ini adalah while biasa:

while (x < 10) {
    x = x + x + 1
    println(x)
}

maka:

x = 10
   ↓
10 < 10 → false
   ↓
STOP

Tidak ada 21.

Itulah perbedaan yang sedang diajarkan video.

12. Kenapa do...while berguna?

do...while berguna ketika kita memang ingin:

melakukan suatu proses setidaknya sekali, kemudian menentukan apakah harus mengulang.

Contoh yang sangat umum adalah menu program.

Misalnya:

===== MENU =====
1. Lihat saldo
2. Transfer
3. Keluar

Kita ingin menu ditampilkan minimal sekali.

Konsepnya:

do {
    tampilkanMenu()
    bacaPilihan()
} while (pilihan != 3)

Artinya:

Tampilkan menu terlebih dahulu, kemudian kalau user belum memilih “Keluar”, tampilkan lagi.

Ini cocok sekali dengan sifat do...while.

13. Contoh lain: meminta input

Misalnya kita ingin meminta user memasukkan angka positif.

Konsepnya:

do {
    println("Masukkan angka positif:")
    // baca input
} while (angka <= 0)

Kenapa do...while cocok?

Karena kita pasti perlu meminta input minimal satu kali.

Tidak masuk akal untuk mengecek:

“Apakah angka yang dimasukkan user tidak valid?”

sebelum user memasukkan angka.

Jadi:

minta input
   ↓
cek input
   ↓
salah?
 ↓    ↓
yes   no
 ↓     ↓
ulang  selesai

14. while lebih cocok kapan?

while cocok ketika kita ingin mengatakan:

“Kalau kondisi dari awal sudah tidak terpenuhi, jangan lakukan apa-apa.”

Contoh:

while (battery > 0) {
    useBattery()
}

Kalau:

battery = 0

maka tidak perlu melakukan proses sama sekali.

15. do...while lebih cocok kapan?

do...while cocok ketika kita ingin mengatakan:

“Lakukan proses ini minimal satu kali, kemudian kalau kondisi masih terpenuhi, ulangi.”

Contohnya:

do {
    showMenu()
    getChoice()
} while (choice != 3)

16. Perbandingan secara visual

while

       START
         ↓
   ┌─────────────┐
   │ cek kondisi │
   └──────┬──────┘
          ↓
     true? ──────── false
       ↓              ↓
   jalankan          STOP
      kode
       ↓
       └──────────→ cek lagi

do...while

       START
         ↓
   jalankan kode
         ↓
   ┌─────────────┐
   │ cek kondisi │
   └──────┬──────┘
          ↓
     true? ──────── false
       ↓              ↓
     ulang           STOP
       │
       └────────→ jalankan lagi

Perbedaannya hanya posisi pengecekan, tetapi dampaknya sangat penting.

17. Hubungannya dengan Boolean

Kamu sebelumnya sudah belajar bahwa comparison menghasilkan Boolean.

Misalnya:

x < 10

menghasilkan:

true

atau:

false

while menggunakan Boolean tersebut:

while (x < 10) {
    ...
}

Begitu juga do...while:

do {
    ...
} while (x < 10)

Jadi konsepnya tetap:

comparison
    ↓
Boolean
    ↓
true / false
    ↓
loop menentukan lanjut atau berhenti

Bedanya hanya kapan Boolean tersebut diperiksa.

18. Hubungan dengan if

Ini juga bagus untuk menghubungkan materi.

if:

if (condition) {
    // lakukan
}

Artinya:

Kalau kondisi benar, lakukan.

while:

while (condition) {
    // lakukan berulang
}

Artinya:

Selama kondisi benar, lakukan berulang.

do...while:

do {
    // lakukan
} while (condition)

Artinya:

Lakukan dulu, lalu selama kondisi benar, ulangi.

Jadi:

if
↓
cek → lakukan paling banyak sekali

while
↓
cek → lakukan → cek → lakukan → ...

do while
↓
lakukan → cek → lakukan → cek → ...

19. Jangan tertukar dengan do...while

Banyak pemula membaca:

do {
    ...
} while (condition)

lalu berpikir:

“Oh, berarti kondisi while harus true supaya blok do pertama dijalankan.”

Tidak.

Justru:

do
 ↓
langsung jalankan
 ↓
baru while mengecek

Jadi meskipun:

while (false)

isi do tetap pernah dijalankan satu kali.

Contoh:

do {
    println("Hello")
} while (false)

Output:

Hello

Setelah itu berhenti.

20. do...while(false)?

Secara teknis bisa saja:

do {
    println("Hello")
} while (false)

Hasilnya tetap:

Hello

Karena:

1. Jalankan do
2. Print "Hello"
3. Cek false
4. Stop

Tetapi dalam program normal, pola seperti ini bukan penggunaan do...while yang umum. Ini hanya contoh untuk memahami mekanismenya.

21. Kesalahan yang sering dilakukan pemula

Misalnya:

var x = 1

do {
    println(x)
} while (x < 5)

Apa yang salah?

x tidak pernah berubah.

Akibatnya:

x = 1
 ↓
print 1
 ↓
1 < 5 → true
 ↓
print 1
 ↓
1 < 5 → true
 ↓
print 1
 ↓
...

Terjadi infinite loop.

Solusinya:

var x = 1

do {
    println(x)
    x++
} while (x < 5)

Sekarang:

1 → 2 → 3 → 4 → 5

Ketika kondisi akhirnya false, loop berhenti.

22. Hal yang perlu diluruskan dari subtitle

Ada beberapa bagian subtitle yang cukup membingungkan karena hasil transkripsi audio.

1. “condition is evaluated at the end”

Ini benar.

Untuk do...while:

do {
    // code
} while (condition)

kondisi diperiksa setelah body dijalankan.

2. “even if the condition is not true”

Maksud yang lebih tepat:

Body do tetap dijalankan satu kali meskipun kondisi while ternyata false setelah eksekusi pertama.

Bukan berarti kondisi diabaikan selamanya.

Contoh:

do {
    println("Hello")
} while (false)

Hello dicetak sekali, lalu berhenti.

3. Perhitungan di subtitle banyak yang salah

Bagian seperti:

“five plus one is equal to 10”

atau angka yang berubah-ubah dalam transkrip adalah kesalahan transkripsi.

Untuk operasi:

x = x + x + 1

kalau:

x = 5

maka:

5 + 5 + 1 = 11

bukan 10.

Kalau:

x = 10

maka:

10 + 10 + 1 = 21

Inilah yang menjelaskan output 21.

23. Ringkasan super penting

Kamu bisa mengingat dua loop ini dengan satu kalimat:

while

“Boleh masuk?” → cek dulu.

while (condition) {
    // code
}

do...while

“Lakukan dulu, nanti baru kita cek perlu lanjut atau tidak.”

do {
    // code
} while (condition)

Perbandingan:

🧠 Cara paling mudah mengingat

Bayangkan:

WHILE

"Apakah boleh?"
   ↓
YES → lakukan
NO  → jangan lakukan

Sedangkan:

DO WHILE

"Lakukan dulu."
   ↓
"Apakah harus mengulang?"
   ↓
YES → lakukan lagi
NO  → selesai

Dan kalau kita gabungkan dengan materi yang sudah kamu pelajari:

Variable
   ↓
Comparison
   ↓
Boolean (true / false)
   ↓
        ┌─────────────┐
        │             │
      while       do...while
        │             │
     cek dulu      lakukan dulu
        │             │
        └──────┬──────┘
               ↓
          ulang / stop

Kunci lesson ini bukan menghafal syntax-nya, tetapi memahami urutannya. Kalau kamu sudah benar-benar paham bahwa while cek → jalan, sedangkan do...while jalan → cek, maka perbedaan keduanya akan jauh lebih mudah dipahami.