在 Go 語言中，字串是最常見的資料型別之一，廣泛用於處理文字資料。然而，許多開發者在操作字串時容易犯一些常見錯誤，導致程式執行異常或效能問題。例如，字串的不可變性、拼接操作的效率問題以及對字元編碼的誤解等，都是新手容易忽視的地方。
本模組將著重分析 Go 語言在字串操作中的常見錯誤，幫助開發者更好地理解如何有效地處理字串，避免由於錯誤使用而帶來的潛在風險。掌握這些細節，不僅能提升程式碼的質量，還能顯著最佳化程式的效能。
錯誤三十六：沒有理解 rune (#36)
示例程式碼：
package main
import (
"fmt"
)
func main() {
s := "FunTester 演示"
fmt.Printf("FunTester: 字串長度為 %d bytes\n", len(s))
for i, char := range s {
fmt.Printf("FunTester: 字元 %d 是 %c\n", i, char)
}
}
錯誤說明：
在 Go 語言中，rune 型別代表一個 Unicode 碼點，每個 rune 實際上是一個多位元組的序列，而不是一個單獨的 byte。許多開發者可能誤以為 rune 和 byte 是等價的，導致在處理包含多位元組字元的字串時出現問題。
可能的影響：
未正確理解 rune 型別及其與 byte 的區別，會導致字串處理中的邏輯錯誤。例如，計算字串長度時使用 len(s) 返回的是位元組數而不是字元數，可能導致介面顯示問題或資料截斷。
最佳實踐：
深入理解 rune 與 byte 的區別，尤其是在處理包含多位元組字元的字串時。使用 []rune 來處理字元級別的操作，確保對每個字元的正確處理。
改進後的程式碼：
package main
import (
"fmt"
)
func main() {
s := "FunTester 演示"
runes := []rune(s)
fmt.Printf("FunTester: 字串長度為 %d 字元\n", len(runes))
for i, char := range runes {
fmt.Printf("FunTester: 字元 %d 是 %c\n", i, char)
}
}
輸出結果：
FunTester: 字串長度為 12 字元
FunTester: 字元 0 是 F
FunTester: 字元 1 是 u
FunTester: 字元 2 是 n
FunTester: 字元 3 是 T
FunTester: 字元 4 是 e
FunTester: 字元 5 是 s
FunTester: 字元 6 是 t
FunTester: 字元 7 是 e
FunTester: 字元 8 是 r
FunTester: 字元 9 是 演
FunTester: 字元 10 是 示
錯誤三十七：不正確的字串遍歷 (#37)
示例程式碼：
package main
import (
"fmt"
)
func main() {
s := "FunTester 演示"
// 錯誤的字串遍歷
for i := 0; i < len(s); i++ {
fmt.Printf("FunTester: 字元 %d 是 %c\n", i, s[i])
}
}
錯誤說明：
使用 for 迴圈和索引直接遍歷字串時，開發者往往忽略了字串中的 rune 是多位元組的。這會導致對於多位元組字元，每次迭代只處理部分位元組，可能出現亂碼或意外的字元顯示。
可能的影響：
不正確的字串遍歷方式會導致程式輸出不正確的字元，尤其是包含多位元組字元的字串。例如，列印或處理這些字元時會出現亂碼，甚至可能引發程式崩潰。
最佳實踐：
在需要逐字元遍歷字串時，推薦使用 range 迴圈，它會自動按 rune 進行迭代，確保每個字元都被完整處理。
改進後的程式碼：
package main
import (
"fmt"
)
func main() {
s := "FunTester 演示"
for i, char := range s {
fmt.Printf("FunTester: 字元 %d 是 %c\n", i, char)
}
}
輸出結果：
FunTester: 字元 0 是 F
FunTester: 字元 1 是 u
FunTester: 字元 2 是 n
FunTester: 字元 3 是 T
FunTester: 字元 4 是 e
FunTester: 字元 5 是 s
FunTester: 字元 6 是 t
FunTester: 字元 7 是 e
FunTester: 字元 8 是 r
FunTester: 字元 9 是 演
FunTester: 字元 10 是 示
錯誤三十八：誤用 trim 函式 (#38)
示例程式碼：
package main
import (
"fmt"
"strings"
)
func main() {
s := "***FunTester***"
// 誤用 TrimRight 試圖移除 "*" 符號
trimmed := strings.TrimRight(s, "*")
fmt.Println("FunTester: Trimmed string =", trimmed)
// 誤用 TrimSuffix 試圖移除 "***"
trimmedSuffix := strings.TrimSuffix(s, "***")
fmt.Println("FunTester: Trimmed with TrimSuffix =", trimmedSuffix)
}
錯誤說明：
在 Go 語言中，strings.TrimLeft 和 strings.TrimRight 函式會移除字串開頭或結尾出現的任意一個在指定集合中的字元，而不是移除特定的字首或字尾。這導致開發者誤用這些函式進行特定字元或字串的刪除，結果可能與預期不符。
可能的影響：
誤用 TrimLeft 或 TrimRight 進行特定字串的移除，會導致部分字元意外被移除，可能破壞字串的完整性。
最佳實踐：
在需要移除特定字首或字尾時，應該使用 strings.TrimPrefix 和 strings.TrimSuffix 函式。這些函式專門用於移除特定的字串字首或字尾，避免誤刪其他字元。
改進後的程式碼：
package main
import (
"fmt"
"strings"
)
func main() {
s := "***FunTester***"
// 使用 TrimPrefix 移除字首 "***"
trimmedPrefix := strings.TrimPrefix(s, "***")
fmt.Println("FunTester: Trimmed with TrimPrefix =", trimmedPrefix)
// 使用 TrimSuffix 移除字尾 "***"
trimmedSuffix := strings.TrimSuffix(s, "***")
fmt.Println("FunTester: Trimmed with TrimSuffix =", trimmedSuffix)
// 如果確實需要移除任意 "*" 符號，可以使用 TrimLeft 和 TrimRight
trimmedAny := strings.TrimLeft(s, "*")
trimmedAny = strings.TrimRight(trimmedAny, "*")
fmt.Println("FunTester: Trimmed any '*' characters =", trimmedAny)
}
輸出結果：
FunTester: Trimmed with TrimPrefix = FunTester***
FunTester: Trimmed with TrimSuffix = ***FunTester
FunTester: Trimmed any '*' characters = FunTester
錯誤三十九：不經最佳化的字串拼接操作 (#39)
示例程式碼：
package main
import (
"fmt"
)
func main() {
parts := []string{"Fun", "Tester", "是", "測試", "工具"}
fullString := ""
for _, part := range parts {
fullString += part
}
fmt.Println("FunTester: 拼接後的字串 =", fullString)
}
錯誤說明：
在 Go 語言中，字串是不可變的，每次使用 + 運算子進行拼接時，都會建立一個新的字串物件，並複製原有內容。這種頻繁的字串拼接操作會導致效能下降。
可能的影響：
大量的字串拼接操作會導致程式效能下降，尤其是在處理大規模資料時。此外，頻繁的記憶體分配和複製操作會增加垃圾回收的壓力，影響程式的整體效率和響應速度。
最佳實踐：
在需要高效拼接大量字串時，應該使用 strings.Builder 或 bytes.Buffer，它們提供了高效的緩衝機制，避免了頻繁的記憶體分配和複製操作。
改進後的程式碼：
package main
import (
"fmt"
"strings"
)
func main() {
parts := []string{"Fun", "Tester", "是", "測試", "工具"}
var builder strings.Builder
for _, part := range parts {
builder.WriteString(part)
}
fullString := builder.String()
fmt.Println("FunTester: 拼接後的字串 =", fullString)
}
輸出結果：
FunTester: 拼接後的字串 = FunTester是測試工具
錯誤四十：無用的字串轉換 (#40)
示例程式碼：
package main
import (
"bytes"
"fmt"
)
func main() {
s := "FunTester 演示"
// 無用的字串到 []byte 再回到字串的轉換
b := []byte(s)
s2 := string(b)
fmt.Println("FunTester: 原始字串 =", s)
fmt.Println("FunTester: 轉換後的字串 =", s2)
}
錯誤說明：
在 Go 語言中，bytes 和 strings 包提供了許多相似的函式，用於處理 []byte 和 string 型別的資料。在不需要進行明確的型別轉換時，頻繁地在 []byte 和 string 之間轉換會導致程式碼冗餘和效能開銷。
可能的影響：
無用的字串轉換不僅使程式碼變得冗長，還可能導致不必要的效能損失，特別是在處理大量資料時。
最佳實踐：
在處理字串和 []byte 型別的資料時，明確其用途，避免不必要的型別轉換。利用 bytes 和 strings 包中提供的靈活函式，直接操作需要的型別，提升程式碼的簡潔性和效能。
改進後的程式碼：
package main
import (
"fmt"
"strings"
)
func main() {
s := "FunTester 演示"
// 直接使用 strings 包的函式，無需進行型別轉換
upper := strings.ToUpper(s)
fmt.Println("FunTester: 大寫字串 =", upper)
// 若確實需要處理位元組資料，再進行轉換
b := []byte(s)
b = append(b, '!') // 示例修改
s2 := string(b)
fmt.Println("FunTester: 修改後的字串 =", s2)
}
輸出結果：
FunTester: 大寫字串 = FUNTESTER 演示
FunTester: 修改後的字串 = FunTester 演示!
錯誤四十一：子字串和記憶體洩漏 (#41)
示例程式碼：
package main
import (
"fmt"
)
func main() {
s := "FunTester 演示記憶體洩漏"
subs := s[0:8] // 獲取子字串
fmt.Println("FunTester: 子字串 =", subs)
// 原字串仍然被引用，無法被垃圾回收
// 如果原字串很大，而子字串只使用其中一部分，會導致不必要的記憶體佔用
}
錯誤說明：
在 Go 語言中，字串是基於底層陣列的切片操作。透過 s[low:high] 獲取子字串時，新的字串仍然引用了原字串的底層陣列。如果原字串非常大，而只需要其中一小部分，未及時釋放對原字串的引用，可能導致記憶體洩漏。
可能的影響：
長時間執行的程式中，頻繁地建立子字串而不釋放原字串的引用，會導致記憶體佔用不斷增加，最終耗盡系統資源，影響程式的效能和穩定性。
最佳實踐：
如果只需要子字串的一部分，並且不再需要原字串，可以透過建立新的字串來避免引用原字串的底層陣列。使用 copy 函式將子字串的內容複製到新的 []rune 或 []byte，然後轉換為字串。這確保了新字串不再依賴於原字串，允許垃圾回收器正確回收原始記憶體。
改進後的程式碼：
package main
import (
"fmt"
)
func main() {
s := "FunTester 演示記憶體洩漏"
subs := s[0:8] // 獲取子字串
// 建立新的字串，複製子字串的內容
runes := []rune(subs)
subsCopy := string(runes)
fmt.Println("FunTester: 子字串 =", subsCopy)
// 現在，subsCopy 不再引用原字串的底層陣列
// 如果不再有其他引用，原字串可以被垃圾回收
}
輸出結果：
FunTester: 子字串 = FunTester
FunTester 原創精華
【連載】從 Java 開始效能測試
故障測試與 Web 前端
服務端功能測試
效能測試專題
Java、Groovy、Go
白盒、工具、爬蟲、UI 自動化
理論、感悟、影片