Pada artikel sebelumnya kita telah belajar apa itu package initialization pada bahasa pemrogaman go atau golang. apabila anda belum mengikuti artikel sebelumnya saya sarankan anda untuk membaca artikel sebelumnya tentang Golang – Pengenalan dan cara menggunakan package initialization. Dan artikel kali ini kita akan membahas package bawaan yang sudah tersedia pada bahasa pemrogaman go secara default.
Package bawaan
Package bawaan adalah sekumpulan package yang sudah tersedia secara default pada golang, kita bisa lengsung menggunakan package-package tersebut, contoh nya seperti package fmt yang sudah sering kita gunakan. Kali ini kita akan mencoba menggunakan package bawaan yang sering digunakan. Untuk detail package lainnya bisa di lihat pada https://pkg.go.dev/
Package OS
Golang telah menyediakan banyak sekali package bawaan, salah satunya adalah package os, jadi package os berisikan fungsionalitas untuk mengakses fitur sistem operasi secara independen (bisa digunakan di semua sistem operasi), artinya walau kita membuat aplikasi untuk mengakses fitur os di sistem operasi linux seperti yang saya gunakan, ini tetap dapat dijalankan di sistem operasi lain seperti windows atau mac. Untuk dokumentasi lengkap nya bisa di lihat di https://pkg.go.dev/os
Contoh penggunaan package os untuk mengambil argument saat program dijalankan
package main
import (
"fmt"
"os"
)
func main() {
args := os.Args
fmt.Println("Argument", args)
fmt.Println(args[1])
fmt.Println(args[2])
}
Perhatikan baris kode diatas, dimana pertama kita melakukan import package os kemudian kita menggunakan method Args dari os yang digunakan untuk mengambil argument saat program di jalankan dan menyimpan isinya pada variable args di baris 9. Coba jalankan baris kode diatas dengan menambahkan beberapa value di depannya.
Bisa di lihat hasilnya jika ter dapat 3 data, yang mana 2 data nya adalah nilai argument yang kita masukkan saat menjalankan program, untuk data pertama adalah data default yang mengembalikan tempat atau path program kita di build.
Package flag
Package flag erat kaitannya dengan package os yang sudah kita coba sebelumnya, yang dimana dengan package os kita bisa mengambil argument saat program kita dijalankan, nah dengan package flag kita bisa mempersing argument yang dikirim, misal jika kita ingin menambahkan --namaArgument di depan arugment agar lebih mudah dibaca dan digunakan maka kita bisa memanfaatkan package flag
package main
import (
"flag"
"fmt"
)
func main() {
var username string
var password string
flag.StringVar(&username, "username", "root", "Pass your username")
flag.StringVar(&password, "password", "root", "Pass your password")
flag.Parse()
fmt.Println(username)
fmt.Println(password)
}
Pada kode diatas kita membuat variable username & password yang digunakan untuk menampung data argument nantinya, nah untuk salah satu cara penggunaan nya cukup sederhana, kita bisa menggunakan method StringVar(&namavariable, "namaFlag", "nilaiDefault", "keterangan"). Selanjutnya jangan lupa memanggil method Parse di baris ke 15, karena jika tidak maka argument tidak akan di parse. Coba jalankan program seperti berikut
Package strings
Package string adalah package yang berisi function-function untuk memanipulasi data string. Ada banyak sekali function yang dapat kita gunakan, untuk detail nya bisa di cek pada laman https://pkg.go.dev/strings
Berikut kita akan mencoba beberapa function yang sering digunakan di package strings
| Function | Kegunaan |
|---|---|
| strings.Trim(string, cutset) | Memotong cutset di awal dan di akhir string |
| strings.ToLower(string) | Membuat semua karakter string menjadi lower case |
| strings.ToUpper(string) | Membuat semua karakter string menjadi upper case |
| strings.Split(string, separator) | Memotong string berdasarkan separator |
| strings.Contains(string, search) | Mengecek apakah string mengandung string lain |
| strings.ReplaceAll(string, from, to) | Mengubah semua string dari from ke to |
Contoh baris kode package strings
package main
import (
"fmt"
"strings"
)
func main() {
// Cek apakah terdapat kata rendy di dalam string, return bool
fmt.Println("Method Contains :", strings.Contains("rendy wijaya", "rendy"))
// Memecah data string menjadi slice dengan separator spasi
fmt.Println("Method Split :", strings.Split("Rendy Wijaya", " "))
// Merubah semua string menjadi lower case
fmt.Println("Method ToLower :", strings.ToLower("Rendy Wijaya"))
// Merubah semua string menjadi uppper case
fmt.Println("Method ToUpper :", strings.ToUpper("Rendy Wijaya"))
// Menghapus semua spasi yang ada di kanan dan kiri, biasanya untuk validasi input user
fmt.Println("Method Trim :", strings.Trim(" Rendy Wijaya ", " "))
// Mereplace semua kata rendy menjadi budi
fmt.Println("Method ToUpper :", strings.ReplaceAll("rendy rendy rendy rendy", "rendy", "budy"))
}
Coba jalankan kode diatas dan kita akan mendapat output seberti berikut
Package strconv
Sebelumnya kita telah belajar cara konversi tipe data, misal dari int32 ke int64. Nah terkadang kita perlu melakukan konversi yang tipe datanya berbeda misal dari int ke string atau sebaliknya. Hal tersebut bisa kita lakukan dengan bantuan package strconv. Detailnya bisa dilihat pada https://pkg.go.dev/strconv
| Function | Kegunaan |
|---|---|
| strconv.ParseBool(string) | Mengubah string ke bool |
| strconv.ParseFloat(string) | Mengubah string ke float |
| strconv.ParseInt(string) | Mengubah string ke int |
| strconv.FormatBool(string) | Mengubah bool ke string |
| strconv.FormatFloat(string, …) | Mengubah bool ke float |
| strconv.FormatInt(string, …) | Mengubah bool ke int |
Contoh baris kode merubah int ke string dan sebaliknya menggunakan cara tercepat, untuk cara lainnya bisa merujuk ke dokumentasi resmi pada link diatas
package main
import (
"fmt"
"strconv"
)
func main() {
// merubah string ke int
strToInt, _ := strconv.Atoi("1000000")
fmt.Println(strToInt)
// merubah int ke string
intToStr := strconv.Itoa(2000000)
fmt.Println(intToStr)
}
Package math
Package math merupakan package yang berisikan constant dan function untuk matematika. Untuk dokumentasi lengkap nya bisa dilihat di https://pkg.go.dev/math
Pada artikel ini kita akan mencoba beberapa function yang sering digunakan pada package math.
| Function | Kegunaan |
|---|---|
| math.Round(float64) | Membulatkan float64 ke atas atau ke bawah, sesuai dengan yang paling dekat |
| math.Floor(float64) | Membulatkan float64 kebawah |
| math.Ceil(float64) | Membulatkan float64 keatas |
| math.Max(float64, float64) | Mengembalikan nilai float64 paling besar |
| math.Min(float64, float64) | Mengembalikan nilai float64 paling kecil |
package main
import (
"fmt"
"math"
)
func main() {
// pembulatan round(paling dekat ke bawah atau ke atas tergantung value)
fmt.Println(math.Round(1.60))
// pembulatan ke atas
fmt.Println(math.Ceil(1.40))
// pembulatan ke bawah
fmt.Println(math.Floor(1.60))
// membandingkan dan mengembalikan nilai tertinggi
fmt.Println(math.Max(1, 2))
// membandingkan dan mengembalikan nilai terendah
fmt.Println(math.Min(1, 2))
}
Package sort
Package sort adalah package yang berisikan utilitas atau helper untuk proses perngurutan data, agar data kita bisa di urutkan kita harus mengimplementasikan kontrak di interface sort.Interface Untuk dokumentasi lengkap nya dapat di review di https://pkg.go.dev/sort
Untuk menggunakan sort, kita harus mengikuti kontrak pada sort.Interface yang isi nya terdapat function Len, Less, Swap. Berikut contohnya
package main
import (
"fmt"
"sort"
)
type User struct {
Name string
Age int
}
type UserSlice []User
func (value UserSlice) Len() int {
return len(value)
}
func (value UserSlice) Less(i int, j int) bool {
return value[i].Age < value[j].Age
}
func (value UserSlice) Swap(i int, j int) {
value[i], value[j] = value[j], value[i]
}
func main() {
users := []User{
{"Rendy", 22},
{"joko", 30},
{"Budi", 31},
{"Rudi", 25},
}
// sebelum di sort
fmt.Println(users)
sort.Sort(UserSlice(users))
// setelah di sort
fmt.Println(users)
}
Pada contoh kode diatas kita mengrutkan data slice users dari umur. Karena untuk menggunakan sort kita harus mengikuti kontrak yang sudah ada, maka kita hanya perlu membuat function yang sama dengan kontrak kemudian slice sudah bisa di urutkan secara otomatis.
Package time
Package time adalah package yang berisikan fungsionalitas untuk managemen waktu di golang. Untuk dokumentasi lebih lengkap bisa di lihat pada https://pkg.go.dev/time
| Function | Kegunaan |
|---|---|
| time.Now() | Untuk mendapatkan waktu saat ini |
| time.Date(…) | Untuk membuat waktu |
package main
import (
"fmt"
"time"
)
func main() {
// mendapatkan waktu saat ini
now := time.Now()
fmt.Println(now)
fmt.Println(now.Year())
fmt.Println(now.Month())
fmt.Println(now.Day())
fmt.Println(now.Hour())
fmt.Println(now.Minute())
fmt.Println(now.Second())
fmt.Println(now.Nanosecond())
// membuat waktu secara manual
utc := time.Date(2022, 10, 10, 10, 10, 10, 10, time.UTC)
fmt.Println(utc)
// mendapatkan timestamp
fmt.Println(now.Unix())
}
Pada kode diatas kita mencoba mendappatkan waktu saat ini, membuat waktu dan menampilkan beberapa output di terminal. Pada artikel ini saya tidak akan menjelaskan semua nya dengan detail karena semua sudah di jelaskan di dokumentasi resmi golang, untuk lebih jelas silakan me review dokumentasinya dari link diatas.
Package reflect
Dalam bahasa pemrogaman, biasanya ada fitur refelction, dimana kita bisa melihat struktur kode kita pada saat aplikasi sedang berjalan. Untuk detail package ini dapat di review pada dokumentasi resminya https://pkg.go.dev/reflect
Pada artikel ini kita akan mencoba mengambil tipe data dari sebuah variable dan mengambil nilai nya.
package main
import (
"fmt"
"reflect"
)
func main() {
name := "Rendy wijaya"
reflectValue := reflect.ValueOf(name)
// mengambil tipe variable dari value name
fmt.Println("Tipe variable name :", reflectValue.Type())
fmt.Println("Tipe variable name :", reflect.TypeOf(name))
// mengambil nilai dalam bentuk interface kosong
fmt.Println("Nilai variable name :", reflectValue.Interface())
}
Coba jalankan kode program diatas dan kita akan mendapat output seperti berikut
Penutup
Pada artikel kali ini kita telah belajar tentang beberapa package bawaan yang tersedia pada bahasa pemrogaman golang. Dan pada artikel selanjutnya saya akan membahas Go Modules pada golang.
