> For the complete documentation index, see [llms.txt](https://davidwinalda94.gitbook.io/mastering-golang/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://davidwinalda94.gitbook.io/mastering-golang/map.md).

# Map

Map adalah tipe data pada Go berbentuk *key-value pair*. `map` mirip seperti slice, hanya saja indeks yang digunakan untuk pengaksesan bisa ditentukan sendiri tipe-nya (indeks tersebut adalah key).

```go
package main

import (
	"fmt"
)

func main() {
	var batch map[string]int

	batch["adorable"] = 20
	batch["brilliant"] = 10

	fmt.Println("Jumlah anggota batch adorable", batch["adorable"])
	fmt.Println("Jumlah anggota batch brilliant", batch["brilliant"])
}
```

![Error pada output program](/files/-MSSh2INDJhSBooahQWU)

Pada kode di atas jika dijalankan akan muncuk error ini karena pada `map` nilai default adalah `nil` sehingga kita harus membuat inisialisasi nilai default di awal seperti ini:

```go
package main

import (
	"fmt"
)

func main() {
	var batch map[string]int
	batch = map[string]int{} // Inisialisasi nilai default
	
	batch["adorable"] = 20
	batch["brilliant"] = 10

	fmt.Println("Jumlah anggota batch adorable", batch["adorable"])
	fmt.Println("Jumlah anggota batch brilliant", batch["brilliant"])
}

```

![Berhasil menampilkan data yang ada pada map](/files/-MSShc11Pk8CkK0pyP3Y)

### Inisialisasi Nilai `map`

Kita juga bisa langsung memasukkan nilai pada variabel bertipe `map` dengan menggunakan literal `{}` seperti berikut ini:

```go
package main

import (
	"fmt"
)

func main() {
	batch := map[string]int{"adorable": 20, "brilliant": 10}

	fmt.Println("Jumlah anggota batch adorable", batch["adorable"])
	fmt.Println("Jumlah anggota batch brilliant", batch["brilliant"])
}
```

![Output program berisi nilai map pada variabel batch](/files/-MSSi_VwpU3qao1xoIkA)

### Looping pada `map`

Kita bisa menggunakan `for` - `range` untuk looping pada `map` . Cara penerapannya masih sama seperti pada slice, pembedanya data yang dikembalikan di tiap perulangan adalah key dan value, bukan indeks dan elemen.

```go
package main

import (
	"fmt"
)

func main() {
	batch := map[string]int{"adorable": 20, "brilliant": 10, "creative": 15}

	for key, val := range batch {
		fmt.Println(key, ":", val)
	}
}
```

![Menampilkan key dan value dari hasil looping variabel batch](/files/-MSSjwbiKgHgW5YTjyO2)

### Mutating Maps

Berikut adalah beberapa hal yang dapa kita lakukan pada `map` :

#### Insert or Update `map`

Untuk melakukan insert dan update data, kita dapat menggunakan cara berikut ini:

```go
m[key] = elem
```

Kita lihat bahwa kita harus mengetahui `key` dari `map` dan meng-assign nilai ke dalam `map` .

```go
package main

import (
	"fmt"
)

func main() {
	batch := map[string]int{"adorable": 20, "brilliant": 10, "creative": 15}

	// Update value dari key "adorable"
	batch["adorable"] = 8
	fmt.Println(batch["adorable"])
}
```

![Mengupdate value dari key adorable ](/files/-MSSsFKud7df9X6TCyNk)

### Retrieve the element

Kita dapat menyimpan `value` dari `key` pada `map` dengan cara seperti berikut ini:

```
elem = m[key]
```

```go
package main

import (
	"fmt"
)

func main() {
	batch := map[string]int{"adorable": 20, "brilliant": 10, "creative": 15}

	a := batch["adorable"]
	b := batch["brilliant"]
	c := batch["creative"]

	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
}

```

![Output program menampilkan nilai dari map batch](/files/-MSSt8RXIpHmYDmHehEZ)

#### Delete elemen pada map

Kita juga dapat menghapus elemen pada `map` menggunakan function built-in `delete` .

```
delete(m, key)
```

```go
package main

import (
	"fmt"
)

func main() {
	batch := map[string]int{"adorable": 20, "brilliant": 10, "creative": 15}

	delete(batch, "adorable")
	fmt.Println(batch["adorable"])
	fmt.Println(batch)
}
```

Dari kode di atas kita lihat bahwa kita menghapus elemen `map` pada `key` `adorable` sehingga jika kita akses `key` dari `adorable` dan isi dari map `batch` maka akan menghasilkan output seperti berikut ini:

![Output program dari penggunaan fungsi delete pada map](/files/-MSSv2c5Cv1QIc6cqkH2)

### Deteksi Keberadaan Item Dengan Key Tertentu <a href="#a175-deteksi-keberadaan-item-dengan-key-tertentu" id="a175-deteksi-keberadaan-item-dengan-key-tertentu"></a>

Ada cara untuk mengetahui apakah dalam sebuah variabel map terdapat item dengan key tertentu atau tidak, yaitu dengan memanfaatkan 2 variabel sebagai penampung nilai kembalian pengaksesan item

```
elem, ok = m[key]
```

```go
package main

import (
	"fmt"
)

func main() {
	batch := map[string]int{"adorable": 20, "brilliant": 10, "creative": 15}

	value, isExist := batch["dilligent"]

	if isExist {
		fmt.Println(value)
	} else {
		fmt.Println("item is not exists")
	}
}
```

![Tidak ditemukam value dari key dilligent](/files/-MSSwV8gwFJm9xNd4SXl)

### Slice of Map

Kita dapat menggunakan slice of map atau kombinasi antara slice dan map.

```go
package main

import (
	"fmt"
)

func main() {
	batch := []map[string]string{
		{"name": "adroable", "year": "2020"},
		{"name": "brilliant", "year": "2021"},
		{"name": "creative", "year": "2019"},
	}

	fmt.Println(batch)
}
```

Dari kode di atas dapat disimpulkan yaitu slice yang tipe tiap elemen-nya adalah `map[string]string` .

![Menampilkan isi slice bertipe map](/files/-MSSz4HUX_uiE3olp731)

Bagaimana jika kita ingin menghasilkan seluruh elemen slice yang bertipe map? kita daoat menggunakan looping `for` - `range` :

```go
package main

import (
	"fmt"
)

func main() {
	batch := []map[string]string{
		{"name": "adroable", "year": "2020"},
		{"name": "brilliant", "year": "2021"},
		{"name": "creative", "year": "2019"},
	}

	for _, value := range batch {
		fmt.Println(value["name"])
	}
}
```

![Hasil perulangan dari slice of map pada variabel batch](/files/-MSSzdHN9iT37NzAxUlL)