String di Golang: Split, Join, Contains, Replace, dan Lainnya

String di Go adalah urutan byte yang immutable, biasanya berupa teks UTF-8. Operator bekerja langsung pada string-nya (+, ==, <, indeks, slicing), dan semua hal lain ada di package standar strings.

package main

import (
	"fmt"
	"strings"
)

func main() {
	csv := "apple,banana,cherry"

	parts := strings.Split(csv, ",")
	fmt.Println(parts, len(parts))

	fmt.Println(strings.Join(parts, " | "))
	fmt.Println(strings.Contains(csv, "nan"))
	fmt.Println(strings.ReplaceAll(csv, ",", ";"))
	fmt.Println(strings.ToUpper(parts[0]))
	fmt.Println(strings.TrimSpace("   padded   ") + "!")
}

Memecah string

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Printf("%q\n", strings.Split("a,b,,c", ","))
	fmt.Printf("%q\n", strings.Split("", ","))
	fmt.Printf("%q\n", strings.Fields("  one  two\tthree\n"))
	fmt.Printf("%q\n", strings.SplitN("k=v=x", "=", 2))
	fmt.Printf("%q\n", strings.Split("go", ""))

	key, value, found := strings.Cut("timeout=30s", "=")
	fmt.Println(key, value, found)
}

Kasus Split("", ",") sering menjebak: input kosong menghasilkan slice dengan panjang 1, bukan 0. Saat memecah input pengguna, Fields atau pemeriksaan s == "" lebih dulu mencegah munculnya elemen kosong yang tidak diinginkan.

strings.Cut adalah cara paling rapi untuk memecah key=value, user@host, dan pasangan sejenis. Go 1.24 juga menambahkan versi iterator, strings.SplitSeq dan strings.FieldsSeq, yang menghasilkan bagian satu per satu tanpa membuat slice.

Mencari

Semua pencarian membedakan huruf besar dan kecil, kecuali EqualFold. Untuk mencari tanpa membedakannya, ubah kedua sisi menjadi huruf kecil, atau pakai EqualFold untuk membandingkan string secara utuh.

Mengubah string

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "  Hello, Gopher!  "

	fmt.Printf("%q\n", strings.TrimSpace(s))
	fmt.Printf("%q\n", strings.Trim("--go--", "-"))
	fmt.Printf("%q\n", strings.TrimPrefix("v1.2.3", "v"))
	fmt.Printf("%q\n", strings.TrimSuffix("report.pdf", ".pdf"))
	fmt.Printf("%q\n", strings.TrimLeft("xxhixx", "x"))

	fmt.Println(strings.ToLower("MiXeD"), strings.ToUpper("mixed"))
	fmt.Println(strings.Replace("a-b-c-d", "-", "+", 2))
	fmt.Println(strings.ReplaceAll("a-b-c-d", "-", ""))
	fmt.Println(strings.Repeat("=", 20))
}

Ada satu jebakan: Trim, TrimLeft, dan TrimRight menerima kumpulan karakter, bukan prefix. strings.TrimLeft("abcab", "ab") menghapus setiap a dan b di awal dan mengembalikan "cab". Untuk menghapus prefix atau suffix yang persis, pakai TrimPrefix dan TrimSuffix.

Penggabungan dan strings.Builder

+ menggabungkan string, dan fmt.Sprintf memformat nilai-nilai menjadi satu string. Keduanya mengalokasikan string baru setiap kali, karena string bersifat immutable. Itu tidak masalah untuk beberapa operasi saja, tetapi lambat di dalam perulangan, karena setiap += menyalin semua yang sudah dibangun sejauh ini. Pakai strings.Builder:

package main

import (
	"fmt"
	"strings"
)

func main() {
	var b strings.Builder
	for i := 1; i <= 5; i++ {
		fmt.Fprintf(&b, "row %d", i)
		if i < 5 {
			b.WriteString(", ")
		}
	}
	fmt.Println(b.String())
	fmt.Println("length:", b.Len())

	// joining a slice is simpler still
	names := []string{"Ana", "Ben", "Chen"}
	fmt.Println("Hello " + strings.Join(names, ", "))
}

strings.Builder yang masih berupa zero value sudah siap dipakai. Ia mengimplementasikan io.Writer, jadi fmt.Fprintf bisa langsung menulis ke dalamnya. Panggil b.Grow(n) lebih dulu kalau kamu tahu kira-kira seberapa besar hasilnya nanti. Jangan menyalin Builder setelah kamu menulis ke dalamnya; kirim pointer-nya.

String multibaris dan raw string

Go punya dua jenis string literal:

package main

import "fmt"

func main() {
	interpreted := "line one\nline two\ttabbed \"quoted\""
	raw := `C:\Users\ana\notes.txt
second line, \n stays literal`

	fmt.Println(interpreted)
	fmt.Println(raw)

	query := `
SELECT id, name
FROM users
WHERE active = true`
	fmt.Println(query)
}

String dengan tanda kutip ganda memproses escape (\n, \t, \", \\, \u00e9) dan harus muat dalam satu baris. Raw string dengan backquote mengambil semuanya apa adanya, termasuk baris baru, sehingga inilah cara menulis string multibaris, regular expression, JSON, dan path Windows. Raw string tidak bisa berisi backquote, dan carriage return di dalamnya dibuang. Perhatikan bahwa query di atas diawali baris baru, karena literal-nya dimulai tepat setelah backquote pembuka.

Panjang, indeks, dan substring

len(s) adalah jumlah byte. s[i] adalah sebuah byte, dan s[i:j] adalah substring berdasarkan posisi byte:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "naïve café"

	fmt.Println(len(s), utf8.RuneCountInString(s))
	fmt.Println(s[0], string(s[0]))
	fmt.Println(s[:5]) // first 5 bytes
	fmt.Println(s[6:]) // from byte 6 to the end

	r := []rune(s)
	fmt.Println(string(r[:5])) // first 5 characters
}

ï dan é masing-masing memakan dua byte, jadi string ini berukuran 12 byte dan 10 karakter. Slicing berdasarkan byte aman selama posisinya berasal dari strings.Index atau fungsi sejenis, yang mengembalikan offset byte di batas karakter. Untuk mengambil "n karakter pertama", ubah dulu menjadi []rune. Halaman rune dan byte menjelaskan UTF-8 secara mendalam.

String bersifat immutable

Kamu tidak bisa mengubah sebuah byte di tempat: s[0] = 'H' adalah error kompilasi (cannot assign to s[0] (neither addressable nor a map index expression)). Setiap fungsi di strings mengembalikan string baru. Untuk mengubah isi string, ubah menjadi []byte atau []rune, ubah slice-nya, lalu ubah kembali:

b := []byte("hello")
b[0] = 'H'
s := string(b) // "Hello"

Sifat immutable ini juga yang membuat substring murah: s[2:5] berbagi memori dengan s, bukan menyalinnya. Sisi buruknya, substring kecil dari string yang sangat besar membuat seluruh string besar itu tetap tersimpan di memori. Pakai strings.Clone (Go 1.20) saat kamu menyimpan potongan pendek dari input yang besar.

Membandingkan string

== dan != membandingkan isinya, sedangkan < dan > membandingkan byte demi byte, yang sama dengan urutan alfabet untuk ASCII. strings.Compare memang ada, tetapi jarang dibutuhkan; slices.Sort pada []string memakai <. Untuk pengurutan teks non-Inggris yang mengikuti aturan locale, pakai golang.org/x/text/collate.

Mengubah tipe lain

Angka menjadi string dengan strconv.Itoa, strconv.FormatFloat, atau fmt.Sprintf, dan string menjadi angka dengan strconv.Atoi dan strconv.ParseFloat. Jangan menulis string(42): hasilnya adalah karakter dengan code point 42, yaitu "*". Halaman konversi tipe punya tabel lengkapnya.

query := `SELECT id, name
FROM users
WHERE active = true`