Studi Mendalam tentang Jenis Data dalam Bahasa Go

1 Pengenalan tentang Tipe Data Bahasa Go

Dalam bahasa Go, tipe data merupakan dasar pemrograman yang menentukan bentuk data yang dapat disimpan oleh variabel. Tipe data dasar yang disediakan oleh bahasa Go terbagi menjadi kategori berikut:

Tipe-tipe ini dapat dipilih sesuai dengan kebutuhan berbeda, seperti perhitungan numerik, pemrosesan teks, atau pengendalian logis.

2 Tipe Data Integer

2.1 Tinjauan Tipe Integer

Bahasa Go memiliki multiple tipe data integer bawaan, yang diklasifikasikan sebagai berikut:

• Integer bertanda: int8, int16, int32 (atau rune), int64, dan int
• Integer tak bertanda: uint8 (atau byte), uint16, uint32, uint64, dan uint

Ukuran int dan uint adalah 4 byte pada sistem 32-bit dan 8 byte pada sistem 64-bit. Rentang nilai dari tipe data integer ditunjukkan dalam tabel berikut:

2.2 Penggunaan Variabel Integer

Sintaks dasar untuk mendeklarasikan variabel integer adalah sebagai berikut:

var nama_variabel tipe_data = nilai_awal

Contoh kode:

package main
import "fmt"

func main() {
    var a int = 10 // Variabel integer bertanda
    var b uint = 20 // Variabel integer tak bertanda
    var c int8 = -128 // Nilai int8 terkecil
    fmt.Println(a, b, c)
}

2.3 Operasi Integer

Bahasa Go mendukung operator aritmatika umum, seperti penambahan (+), pengurangan (-), perkalian (*), pembagian (/), dan modulo (%), serta operator bitwise seperti bitwise AND (&), OR (|), XOR (^), pergeseran kiri (<<), dan pergeseran kanan (>>).

package main
import "fmt"

func main() {
    x := 10
    y := 3

    // Operasi aritmatika
    fmt.Println(x + y) // Penambahan
    fmt.Println(x - y) // Pengurangan
    fmt.Println(x * y) // Perkalian
    fmt.Println(x / y) // Pembagian
    fmt.Println(x % y) // Modulo

    // Operasi bitwise
    fmt.Println(x & y)  // Bitwise AND
    fmt.Println(x | y)  // Bitwise OR
    fmt.Println(x ^ y)  // Bitwise XOR
    fmt.Println(x << 1) // Pergeseran kiri sebanyak 1
    fmt.Println(x >> 1) // Pergeseran kanan sebanyak 1
}

3 Tipe Data Floating Point

3.1 Gambaran Umum Jenis Data Floating Point

Pada bahasa Go, tipe floating-point mencakup float32 dan float64, yang masing-masing merupakan data floating-point 32-bit dan 64-bit. Secara umum, disarankan untuk menggunakan float64 karena tipe ini menyediakan rentang yang lebih besar dan presisi yang lebih akurat.

• float32 memiliki sekitar 23 bit signifikan, memberikan sekitar 7 digit desimal presisi.
• float64 memiliki sekitar 52 bit signifikan, memberikan sekitar 16 digit desimal presisi.

3.2 Penggunaan Variabel Floating Point

Variabel floating-point dapat dideklarasikan dengan langsung memberikan literal atau menggunakan kata kunci var:

package main
import "fmt"

func main() {
    var f1 float32 = 3.14 // Secara eksplisit menentukan tipe float32
    f2 := 3.14            // Ditentukan secara otomatis sebagai tipe float64
    fmt.Println(f1, f2)
}

3.3 Aritmetika Floating Point dan Masalah yang Terjadi

Aritmetika floating-point dapat menyebabkan kehilangan presisi. Melakukan operasi dengan presisi yang sangat tinggi adalah masalah umum, terutama saat mengurangkan dua angka yang sangat dekat.

package main
import "fmt"

func main() {
    f1 := .1
    f2 := .2
    f3 := f1 + f2
    fmt.Println(f3) // Output mungkin bukan .3 yang diharapkan karena masalah presisi

    // Memperbaiki masalah presisi menggunakan output yang diformat
    fmt.Printf("%.1f\n", f3) // Output diperbaiki menjadi .3
}

4 Tipe Data Boolean

4.1 Gambaran Umum Tipe Data Boolean

Boolean adalah tipe data paling sederhana, dan hanya dapat memiliki dua nilai: true (benar) dan false (salah). Tipe data ini memiliki posisi yang sangat penting dalam pernyataan kondisional dan struktur kontrol perulangan.

4.2 Penggunaan Variabel Boolean

Deklarasi dan penggunaan variabel boolean:

package main
import "fmt"

func main() {
    var sukses bool = true
    var gagal bool = false
    fmt.Println("Operasi berhasil:", sukses)
    fmt.Println("Operasi gagal:", gagal)
}

Nilai boolean sering digunakan dalam pernyataan kondisional:

package main
import "fmt"

func main() {
    a := 10
    b := 20
    fmt.Println("a == b:", a == b) // false
    fmt.Println("a < b:", a < b)   // true
}

5 Tipe Data String

5.1 Gambaran Umum String

Sebuah string merupakan kumpulan karakter. Dalam bahasa Go, string bersifat tidak dapat diubah. Setiap string terdiri dari dua bagian: sebuah pointer ke susunan byte yang mendasarinya dan sebuah panjang. String dapat berisi data apa pun, termasuk byte.

5.2 Penggunaan Variabel String

Variabel string biasanya dideklarasikan menggunakan tanda kutip ganda " untuk membuat, namun Anda juga dapat menggunakan tanda kutip balik ``` untuk membuat string multi-baris:

package main
import "fmt"

func main() {
    var s1 string = "hello"
    s2 := "world"
    s3 := `Ini adalah
    string beberapa
    baris`
    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(s3)
}

Setelah sebuah string dibuat, kontennya tidak dapat diubah. Operasi berikut tidak sah dan akan mengakibatkan kesalahan kompilasi:

s := "hello"
s[] = 'H` // Kesalahan kompilasi: konten string bersifat tidak dapat diubah

5.3 Operasi String

String sangat umum dan penting dalam pemrograman. Bahasa Go menyediakan serangkaian fungsi bawaan yang kaya untuk memanipulasi string. Berikut adalah beberapa operasi yang sering digunakan.

5.3.1 Penggabungan String

Dalam bahasa Go, Anda dapat menggunakan operator tanda tambah (+) untuk menggabungkan string, yang merupakan metode paling langsung. Selain itu, saat menangani penggabungan string yang sering, disarankan untuk menggunakan strings.Builder untuk kinerja yang lebih baik.

package main

import (
    "fmt"
    "strings"
)

func main() {
    // Menggabungkan string menggunakan +
    halo := "Halo, "
    dunia := "Dunia!"
    hasil := halo + dunia
    fmt.Println(hasil) // Output: Halo, Dunia!

    // Menggabungkan string menggunakan strings.Builder
    var sb strings.Builder
    sb.WriteString("Halo, ")
    sb.WriteString("Dunia!")
    fmt.Println(sb.String()) // Output: Halo, Dunia!
}

5.3.2 Memisahkan String

Memisahkan string dapat dilakukan menggunakan fungsi strings.Split, yang memisahkan string menjadi potongan-potongan berdasarkan delimiter yang ditentukan.

package main

import (
    "fmt"
    "strings"
)

func main() {
    // Mendefinisikan sebuah string
    kalimat := "Go adalah bahasa pemrograman open source"

    // Memisahkan string berdasarkan spasi
    kataKata := strings.Split(kalimat, " ")
    for _, kata := range kataKata {
        fmt.Printf("%s\n", kata)
    }
    // Output:
    // Go
    // adalah
    // bahasa
    // pemrograman
    // open
    // source
}

5.3.3 Akses Indeks

Dalam Go, sebuah string merupakan urutan byte yang tidak dapat diubah. Anda dapat menggunakan indeks untuk mengakses byte khusus dalam sebuah string. Namun, perlu diingat bahwa karena sebuah string dapat berisi karakter-karakter multi-byte (seperti karakter-karakter yang dienkripsi dalam bentuk UTF-8), pengindeksan secara langsung mungkin tidak menghasilkan satu karakter yang diharapkan.

package main

import "fmt"

func main() {
    s := "Hello, 世界"
    for i := range s {
        fmt.Printf("%d: %x\n", i, s[i])
    }
    // Catatan: ini akan menghasilkan representasi heksadesimal dari byte, bukan karakter
}

Untuk mengiterasi melalui string per karakter, Anda dapat menggunakan perulangan dengan range.

package main

import "fmt"

func main() {
    s := "Hello, 世界"
    for indeks, nilaiRune := range s {
        fmt.Printf("%d: %U '%c'\n", indeks, nilaiRune, nilaiRune)
    }
    // Output: indeks, enkoding Unicode, dan karakter itu sendiri untuk setiap karakter
}

5.3.4 Mendapatkan Panjang

Fungsi len dapat memperoleh panjang dari sebuah string, yaitu panjang dari urutan byte yang mendasarinya. Untuk string UTF-8, jika Anda perlu memperoleh jumlah karakter (rune), Anda sebaiknya menggunakan fungsi utf8.RuneCountInString. Hal ini dapat menangani dengan benar karakter-karakter multi-byte.

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "Hello, 世界"
    fmt.Println("Panjang byte:", len(s)) // Output panjang byte
    fmt.Println("Panjang karakter:", utf8.RuneCountInString(s)) // Output panjang karakter
}

Dari contoh di atas, kita dapat melihat bahwa bahasa Go menyediakan fungsi pustaka yang kaya untuk operasi-operasi string, sehingga mudah untuk menyelesaikan berbagai tugas pemrosesan string. Ketika melakukan pengkodean, penting untuk memperhatikan perbedaan antara byte dan karakter, terutama saat berurusan dengan set karakter non-ASCII.