# Mengenal Select Statement di Golang

Halo teman-teman!  
Kita sudah belajar tentang **channel** dan **buffered channel**.  
Sekarang saatnya kita mengenal fitur keren lainnya di Golang: **select statement**.

`select` berguna untuk:

* Menunggu banyak channel sekaligus
    
* Membuat program lebih **responsif**
    
* Menangani **timeout** atau **multiple event**
    

Langsung kita bahas!

---

## Apa Itu Select Statement?

`select` adalah fitur spesial di Go yang mirip seperti `switch`,  
tetapi bukan memilih berdasarkan nilai **variabel**, melainkan berdasarkan **aktivitas channel**.

Artinya, `select` akan:

* Menunggu salah satu operasi channel yang **siap** (bisa menerima atau mengirim data)
    
* Menjalankan blok kode sesuai channel yang siap lebih dulu
    

---

## Struktur Dasar Select

```go
select {
case value := <-ch1:
    fmt.Println("Received from channel 1:", value)
case value := <-ch2:
    fmt.Println("Received from channel 2:", value)
default:
    fmt.Println("No data ready")
}
```

🧠 Artinya:

* Kalau ada data di `ch1`, ambil dari `ch1`.
    
* Kalau ada data di `ch2`, ambil dari `ch2`.
    
* Kalau **tidak ada data** di kedua channel, jalankan `default` (opsional).
    

---

## Contoh Sederhana Select

Yuk langsung ke contoh unit test:

```go
package goroutine_test

import (
	"fmt"
	"testing"
)

func TestSelectChannel(t *testing.T) {
	ch1 := make(chan string)
	ch2 := make(chan string)

	go func() {
		ch1 <- "Data from channel 1"
	}()

	go func() {
		ch2 <- "Data from channel 2"
	}()

	go func() {
		ch3 <- "Data from channel 3"
	}()

	received := 0
	for received < 3 {
    	select {
    	case data := <-ch1:
    		fmt.Println(data)
            received++ 
    	case data := <-ch2:
    		fmt.Println(data)
            received++
    	case data := <-ch3:
    		fmt.Println(data)
            received++
    	}
    }
}
```

### 🧠 Penjelasan:

* Hanya ada **1 goroutine** yang bertugas menerima data dari semua channel.
    
* Loop berjalan sampai kita menerima 3 data (`received < 3`).
    
* Lebih aman dan tidak menciptakan goroutine berlebih.
    
* Tetap sederhana dan sangat cocok untuk penggunaan dasar `select`.
    

---

## Select dan Timeout

Kadang kita ingin program **tidak menunggu terlalu lama**.  
Kita bisa menggunakan `select` dengan `time.After` untuk membuat **timeout**!

Contoh:

```go
package goroutine_test

import (
	"fmt"
	"testing"
	"time"
)

func TestSelectTimeout(t *testing.T) {
	ch := make(chan string)

	select {
	case data := <-ch:
		fmt.Println("Received:", data)
	case <-time.After(2 * time.Second):
		fmt.Println("Timeout! No data received")
	}
}
```

🧠 Penjelasan:

* Kalau dalam 2 detik tidak ada data masuk ke channel `ch`, maka akan keluar pesan "Timeout!".
    

---

## Kesimpulan

Hari ini kita sudah belajar:

* Apa itu **select statement**
    
* Cara menunggu banyak channel sekaligus
    
* Cara membuat **timeout** supaya program tidak nge-freeze
    
* Contoh penerapan dalam kode sederhana
    

Dengan `select`, program kita bisa:

* **Lebih responsif**
    
* **Lebih fleksibel**
    
* **Lebih kuat** untuk menangani berbagai kondisi bersamaan