Konversi Antar Tipe Data

Di bab-bab sebelumnya kita sudah mengaplikasikan beberapa cara konversi data, contohnya seperti konversi string ↔ int menggunakan strconv, dan time.Time ↔ string. Di bab ini kita akan belajar lebih banyak.

Konversi Menggunakan strconv

Package strconv berisi banyak fungsi yang sangat membantu kita untuk melakukan konversi. Berikut merupakan beberapa fungsi yang dalam package tersebut.

A.40.1.a. Fungsi strconv.Atoi()

Fungsi ini digunakan untuk konversi data dari tipe string ke int. strconv.Atoi() menghasilkan 2 buah nilai kembalian, yaitu hasil konversi dan error (jika konversi sukses, maka error berisi nil).

package main

import "fmt"
import "strconv"

func main() {
    var str = "124"
    var num, err = strconv.Atoi(str)

    if err == nil {
        fmt.Println(num) // 124
    }
}

A.40.1.b. Fungsi strconv.Itoa()

Merupakan kebalikan dari strconv.Atoi, berguna untuk konversi int ke string.

var num = 124
var str = strconv.Itoa(num)

fmt.Println(str) // "124"

A.40.1.c. Fungsi strconv.ParseInt()

Digunakan untuk konversi string berbentuk numerik dengan basis tertentu ke tipe numerik non-desimal dengan lebar data bisa ditentukan.

Pada contoh berikut, string "124" dikonversi ke tipe numerik dengan ketentuan basis yang digunakan 10 dan lebar datanya mengikuti tipe int64 (lihat parameter ketiga).

var str = "124"
var num, err = strconv.ParseInt(str, 10, 64)

if err == nil {
    fmt.Println(num) // 124
}

Contoh lainnya, string "1010" dikonversi ke basis 2 (biner) dengan tipe data hasil adalah int8.

var str = "1010"
var num, err = strconv.ParseInt(str, 2, 8)

if err == nil {
    fmt.Println(num) // 10
}

A.40.1.d. Fungsi strconv.FormatInt()

Berguna untuk konversi data numerik int64 ke string dengan basis numerik bisa ditentukan sendiri.

var num = int64(24)
var str = strconv.FormatInt(num, 8)

fmt.Println(str) // 30

A.40.1.e. Fungsi strconv.ParseFloat()

Digunakan untuk konversi string ke numerik desimal dengan lebar data bisa ditentukan.

var str = "24.12"
var num, err = strconv.ParseFloat(str, 32)

if err == nil {
    fmt.Println(num) // 24.1200008392334
}

Pada contoh di atas, string "24.12" dikonversi ke float dengan lebar tipe data float32. Hasil konversi strconv.ParseFloat adalah sesuai dengan standar IEEE Standard for Floating-Point Arithmetic.

A.40.1.f. Fungsi strconv.FormatFloat()

Berguna untuk konversi data bertipe float64 ke string dengan format eksponen, lebar digit desimal, dan lebar tipe data bisa ditentukan.

var num = float64(24.12)
var str = strconv.FormatFloat(num, 'f', 6, 64)

fmt.Println(str) // 24.120000

Pada kode di atas, Data 24.12 yang bertipe float64 dikonversi ke string dengan format eksponen fatau tanpa eksponen, lebar digit desimal 6 digit, dan lebar tipe data float64.

Ada beberapa format eksponen yang bisa digunakan. Detailnya bisa dilihat di tabel berikut.

Format Eksponen	Penjelasan
b	-ddddp±ddd, a, eksponen biner (basis 2)
e	-d.dddde±dd, a, eksponen desimal (basis 10)
E	-d.ddddE±dd, a, eksponen desimal (basis 10)
f	-ddd.dddd, tanpa eksponen
g	Akan menggunakan format eksponen e untuk eksponen besar dan f untuk selainnya
G	Akan menggunakan format eksponen E untuk eksponen besar dan f untuk selainnya

A.40.1.g. Fungsi strconv.ParseBool()

Digunakan untuk konversi string ke bool.

var str = "true"
var bul, err = strconv.ParseBool(str)

if err == nil {
    fmt.Println(bul) // true
}

A.40.1.h. Fungsi strconv.FormatBool()

Digunakan untuk konversi bool ke string.

var bul = true
var str = strconv.FormatBool(bul)

fmt.Println(str) // 124

A.40.2. Konversi Data Menggunakan Casting

Keyword tipe data bisa digunakan untuk casting. Cara penggunaannya adalah dengan menuliskan tipe data sebagai fungsi dan menyisipkan data yang akan dikonversi sebagai parameternya.

var a float64 = float64(24)
fmt.Println(a) // 24

var b int32 = int32(24.00)
fmt.Println(b) // 24

A.40.3. Casting string ↔ byte

String sebenarnya adalah slice/array byte. Di Golang sebuah karakter biasa (bukan unicode) direpresentasikan oleh sebuah elemen slice byte. Tiap elemen slice berisi data int dengan basis desimal, yang merupakan kode ASCII dari karakter dalam string.

Cara mendapatkan slice byte dari sebuah data string adalah dengan meng-casting-nya ke tipe []byte.

var text1 = "halo"
var b = []byte(text1)

fmt.Printf("%d %d %d %d \n", b[0], b[1], b[2], b[3])
// 104 97 108 111

Pada contoh di atas, string dalam variabel text1 dikonversi ke []byte. Tiap elemen slice byte tersebut kemudian ditampilkan satu-per-satu.

Contoh berikut ini merupakan kebalikan dari contoh di atas, data bertipe []byte akan dicari bentuk string-nya.

var byte1 = []byte{104, 97, 108, 111}
var s = string(byte1)

fmt.Printf("%s \n", s)
// halo

Pada contoh di-atas, beberapa kode byte dituliskan dalam bentuk slice, ditampung variabel byte1. Lalu, nilai variabel tersebut di-cast ke string, untuk kemudian ditampilkan.

Selain itu, tiap karakter string juga bisa di-casting ke bentuk int, hasilnya adalah sama yaitu data byte dalam bentuk numerik basis desimal, dengan ketentuan literal string yang digunakan adalah tanda petik satu (').

Juga berlaku sebaliknya, data numerik jika di-casting ke bentuk string dideteksi sebagai kode ASCII dari karakter yang akan dihasilkan.

var c int64 = int64('h')
fmt.Println(c) // 104

var d string = string(104)
fmt.Println(d) // h

A.40.4. Konversi Data interface{} Menggunakan Teknik Type Assertions

Type assertions merupakan teknik casting data interface{} ke segala jenis tipe (dengan syarat data tersebut memang bisa di-casting ke tipe tujuan).

Berikut merupakan contoh penerapannya. Variabel data disiapkan bertipe map[string]interface{}, berisikan beberapa item dengan tipe data value nya berbeda satu sama lain.

var data = map[string]interface{}{
    "nama":    "john wick",
    "grade":   2,
    "height":  156.5,
    "isMale":  true,
    "hobbies": []string{"eating", "sleeping"},
}

fmt.Println(data["nama"].(string))
fmt.Println(data["grade"].(int))
fmt.Println(data["height"].(float64))
fmt.Println(data["isMale"].(bool))
fmt.Println(data["hobbies"].([]string))

Statement data["nama"].(string) maksudnya adalah, nilai data["nama"] dicasting sebagai string.

Tipe asli data pada variabel interface{} bisa diketahui dengan cara meng-casting ke tipe type. Namun casting ke tipe type hanya bisa dilakukan pada switch.

for _, val := range data {
    switch val.(type) {
    case string:
        fmt.Println(val.(string))
    case int:
        fmt.Println(val.(int))
    case float64:
        fmt.Println(val.(float64))
    case bool:
        fmt.Println(val.(bool))
    case []string:
        fmt.Println(val.([]string))
    default:
        fmt.Println(val.(int))
    }
}