Chuỗi trong Golang: Split, Join, Contains, Replace, Trim

Chuỗi (string) trong Go là một dãy byte bất biến, thường là văn bản UTF-8. Các toán tử làm việc trực tiếp trên chuỗi (+, ==, <, truy cập theo chỉ số, cắt chuỗi), còn mọi thứ khác nằm trong package chuẩn 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   ") + "!")
}

Tách chuỗi

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)
}

Trường hợp Split("", ",") hay làm người ta vấp: đầu vào rỗng cho ra slice độ dài 1, không phải 0. Khi tách dữ liệu người dùng nhập, dùng Fields hoặc kiểm tra s == "" trước để tránh một phần tử rỗng ma.

strings.Cut là cách gọn nhất để tách key=value, user@host và các cặp tương tự. Go 1.24 còn thêm phiên bản iterator, strings.SplitSeq và strings.FieldsSeq, trả về từng phần một mà không dựng slice.

Tìm kiếm

Mọi phép tìm kiếm đều phân biệt hoa thường, trừ EqualFold. Để tìm không phân biệt hoa thường, hãy đổi cả hai bên sang chữ thường hoặc dùng EqualFold khi so sánh cả chuỗi.

Biến đổi chuỗi

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))
}

Một cái bẫy: Trim, TrimLeft và TrimRight nhận một tập ký tự, không phải tiền tố. strings.TrimLeft("abcab", "ab") bỏ mọi a và b ở đầu và trả về "cab". Để bỏ đúng một tiền tố hay hậu tố, hãy dùng TrimPrefix và TrimSuffix.

Nối chuỗi và strings.Builder

+ nối các chuỗi, còn fmt.Sprintf định dạng các giá trị thành một chuỗi. Cả hai đều cấp phát chuỗi mới mỗi lần, vì chuỗi là bất biến. Với vài thao tác thì không sao, nhưng trong vòng lặp sẽ chậm, vì mỗi lần += sao chép mọi thứ đã ghép được. Hãy dùng 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, ", "))
}

Một strings.Builder ở giá trị zero là dùng được ngay. Nó cài đặt io.Writer, nên fmt.Fprintf ghi thẳng vào nó. Gọi b.Grow(n) trước nếu bạn biết đại khái kết quả lớn cỡ nào. Đừng sao chép một Builder sau khi đã ghi vào nó; hãy truyền con trỏ.

Chuỗi nhiều dòng và chuỗi raw

Go có hai loại literal chuỗi:

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)
}

Chuỗi trong dấu nháy kép xử lý ký tự thoát (\n, \t, \", \\, \u00e9) và phải nằm trên một dòng. Chuỗi raw trong dấu backquote giữ nguyên mọi thứ, kể cả xuống dòng, nên đây là cách viết chuỗi nhiều dòng, biểu thức chính quy, JSON và đường dẫn Windows. Chuỗi raw không thể chứa dấu backquote, và ký tự carriage return bên trong bị loại bỏ. Lưu ý câu truy vấn ở trên bắt đầu bằng một dòng trống, vì literal bắt đầu ngay sau dấu backquote mở.

Độ dài, chỉ số và chuỗi con

len(s) là số byte. s[i] là một byte, và s[i:j] là chuỗi con theo vị trí 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
}

ï và é mỗi ký tự chiếm hai byte, nên chuỗi dài 12 byte và có 10 ký tự. Cắt theo byte là an toàn miễn là vị trí lấy từ strings.Index hoặc hàm tương tự, vốn trả về vị trí byte nằm đúng ranh giới ký tự. Để lấy "n ký tự đầu tiên", hãy chuyển sang []rune trước. Trang rune và byte giải thích UTF-8 chi tiết.

Chuỗi là bất biến

Bạn không thể sửa một byte tại chỗ: s[0] = 'H' là lỗi biên dịch (cannot assign to s[0] (neither addressable nor a map index expression)). Mọi hàm trong strings đều trả về chuỗi mới. Để sửa, hãy chuyển sang []byte hoặc []rune, thay đổi slice, rồi chuyển ngược lại:

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

Tính bất biến cũng là lý do chuỗi con rất rẻ: s[2:5] dùng chung bộ nhớ với s thay vì sao chép. Mặt trái là một chuỗi con nhỏ của một chuỗi khổng lồ sẽ giữ cả chuỗi khổng lồ đó trong bộ nhớ. Hãy dùng strings.Clone (Go 1.20) khi bạn giữ lại một đoạn ngắn của một đầu vào lớn.

So sánh chuỗi

== và != so sánh nội dung, còn <, > so sánh từng byte, tức là theo thứ tự bảng chữ cái với ASCII. strings.Compare có tồn tại nhưng hiếm khi cần; slices.Sort trên []string dùng <. Để sắp xếp văn bản không phải tiếng Anh theo quy tắc ngôn ngữ, hãy dùng golang.org/x/text/collate.

Chuyển đổi từ kiểu khác

Số được chuyển thành chuỗi bằng strconv.Itoa, strconv.FormatFloat hoặc fmt.Sprintf, còn chuỗi thành số bằng strconv.Atoi và strconv.ParseFloat. Đừng viết string(42): nó tạo ra ký tự có code point 42, tức "*". Trang về chuyển đổi kiểu có bảng đầy đủ.

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