【Go】高效截取字符串的一些思考

時間  2019-11-16
標籤 高效 截取 字符串 一些 思考 欄目 Go 简体版
原文   原文鏈接

原文連接：https://blog.thinkeridea.com/...html

最近我在 Go Forum 中發現了 String size of 20 character 的問題，「hollowaykeanho」 給出了相關的答案，而我從中發現了截取字符串的方案並不是最理想的方法，所以作了一系列實驗並得到高效截取字符串的方法，這篇文章將逐步講解我實踐的過程。git

字節切片截取

這正是 「hollowaykeanho」 給出的第一個方案，我想也是不少人想到的第一個方案，利用 go 的內置切片語法截取字符串：github

s := "abcdef"
fmt.Println(s[1:4])

咱們很快就瞭解到這是按字節截取，在處理 ASCII 單字節字符串截取，沒有什麼比這更完美的方案了，中文每每佔多個字節，在 utf8 編碼中是3個字節，以下程序咱們將得到亂碼數據：golang

s := "Go 語言"
fmt.Println(s[1:4])

殺手鐗 - 類型轉換 []rune

「hollowaykeanho」 給出的第二個方案就是將字符串轉換爲 []rune，而後按切片語法截取，再把結果轉成字符串。shell

s := "Go 語言"
rs := []rune(s)
fmt.Println(strings(rs[1:4]))

首先咱們獲得了正確的結果，這是最大的進步。不過我對類型轉換一直比較謹慎，我擔憂它的性能問題，所以我嘗試在搜索引擎和各大論壇查找答案，可是我獲得最多的仍是這個方案，彷佛這已是惟一的解。編程

我嘗試寫個性能測試評測它的性能：併發

package benchmark

import (
    "testing"
)

var benchmarkSubString = "Go語言是Google開發的一種靜態強類型、編譯型、併發型，並具備垃圾回收功能的編程語言。爲了方便搜索和識別，有時會將其稱爲Golang。"
var benchmarkSubStringLength = 20

func SubStrRunes(s string, length int) string {
    if utf8.RuneCountInString(s) > length {
        rs := []rune(s)
        return string(rs[:length])
    }

    return s
}

func BenchmarkSubStrRunes(b *testing.B) {
    for i := 0; i < b.N; i++ {
        SubStrRunes(benchmarkSubString, benchmarkSubStringLength)
    }
}

我獲得了讓我有些吃驚的結果：編程語言

goos: darwin
goarch: amd64
pkg: github.com/thinkeridea/go-extend/exunicode/exutf8/benchmark
BenchmarkSubStrRunes-8            872253              1363 ns/op             336 B/op          2 allocs/op
PASS
ok      github.com/thinkeridea/go-extend/exunicode/exutf8/benchmark     2.120s

對 69 個的字符串截取前 20 個字符須要大概 1.3 微秒，這極大的超出了個人內心預期，我發現由於類型轉換帶來了內存分配，這產生了一個新的字符串，而且類型轉換須要大量的計算。ide

救命稻草 - utf8.DecodeRuneInString

我想改善類型轉換帶來的額外運算和內存分配，我仔細的梳理了一遍 strings 包，發現並無相關的工具，這時我想到了 utf8 包，它提供了多字節計算相關的工具，實話說我對它並不熟悉，或者說沒有主動（直接）使用過它，我查看了它全部的文檔發現 utf8.DecodeRuneInString 函數能夠轉換單個字符，並給出字符佔用字節的數量，我嘗試瞭如此下的實驗：函數

package benchmark

import (
    "testing"
    "unicode/utf8"
)

var benchmarkSubString = "Go語言是Google開發的一種靜態強類型、編譯型、併發型，並具備垃圾回收功能的編程語言。爲了方便搜索和識別，有時會將其稱爲Golang。"
var benchmarkSubStringLength = 20

func SubStrDecodeRuneInString(s string, length int) string {
    var size, n int
    for i := 0; i < length && n < len(s); i++ {
        _, size = utf8.DecodeRuneInString(s[n:])
        n += size
    }

    return s[:n]
}

func BenchmarkSubStrDecodeRuneInString(b *testing.B) {
    for i := 0; i < b.N; i++ {
        SubStrDecodeRuneInString(benchmarkSubString, benchmarkSubStringLength)
    }
}

運行它以後我獲得了令我驚喜的結果：

goos: darwin
goarch: amd64
pkg: github.com/thinkeridea/go-extend/exunicode/exutf8/benchmark
BenchmarkSubStrDecodeRuneInString-8     10774401               105 ns/op               0 B/op          0 allocs/op
PASS
ok      github.com/thinkeridea/go-extend/exunicode/exutf8/benchmark     1.250s

較 []rune 類型轉換效率提高了 13倍，消除了內存分配，它的確使人激動和興奮，我火燒眉毛的回覆了 「hollowaykeanho」 告訴他我發現了一個更好的方法，並提供了相關的性能測試。

我有些小激動，興奮的瀏覽着論壇裏各類有趣的問題，在查看一個問題的幫助時 (忘記是哪一個問題了-_-||) ，我驚奇的發現了另外一個思路。

良藥不必定苦 - range 字符串迭代

許多人彷佛遺忘了 range 是按字符迭代的，並不是字節。使用 range 迭代字符串時返回字符起始索引和對應的字符，我馬上嘗試利用這個特性編寫了以下用例：

package benchmark

import (
    "testing"
)

var benchmarkSubString = "Go語言是Google開發的一種靜態強類型、編譯型、併發型，並具備垃圾回收功能的編程語言。爲了方便搜索和識別，有時會將其稱爲Golang。"
var benchmarkSubStringLength = 20

func SubStrRange(s string, length int) string {
    var n, i int
    for i = range s {
        if n == length {
            break
        }

        n++
    }

    return s[:i]
}

func BenchmarkSubStrRange(b *testing.B) {
    for i := 0; i < b.N; i++ {
        SubStrRange(benchmarkSubString, benchmarkSubStringLength)
    }
}

我嘗試運行它，這彷佛有着無窮的魔力，結果並無令我失望。

goos: darwin
goarch: amd64
pkg: github.com/thinkeridea/go-extend/exunicode/exutf8/benchmark
BenchmarkSubStrRange-8          12354991                91.3 ns/op             0 B/op          0 allocs/op
PASS
ok      github.com/thinkeridea/go-extend/exunicode/exutf8/benchmark     1.233s

它僅僅提高了13%，但它足夠的簡單和易於理解，這彷佛就是我苦苦尋找的那味良藥。

若是你覺得這就結束了，不、這對我來只是探索的開始。

終極時刻 - 本身造輪子

喝了 range 那碗甜的膩人的良藥，我彷佛冷靜下來了，我須要造一個輪子，它須要更易用，更高效。

因而乎我仔細觀察了兩個優化方案，它們彷佛都是爲了查找截取指定長度字符的索引位置，若是我能夠提供一個這樣的方法，是否就能夠提供用戶一個簡單的截取實現 s[:strIndex(20)] ，這個想法萌芽以後我就沒法再度擺脫，我苦苦思索兩天來如何來提供易於使用的接口。

以後我創造了 exutf8.RuneIndexInString 和 exutf8.RuneIndex 方法，分別用來計算字符串和字節切片中指定字符數量結束的索引位置。

我用 exutf8.RuneIndexInString 實現了一個字符串截取測試：

package benchmark

import (
    "testing"
    "unicode/utf8"

    "github.com/thinkeridea/go-extend/exunicode/exutf8"
)

var benchmarkSubString = "Go語言是Google開發的一種靜態強類型、編譯型、併發型，並具備垃圾回收功能的編程語言。爲了方便搜索和識別，有時會將其稱爲Golang。"
var benchmarkSubStringLength = 20

func SubStrRuneIndexInString(s string, length int) string {
    n, _ := exutf8.RuneIndexInString(s, length)
    return s[:n]
}

func BenchmarkSubStrRuneIndexInString(b *testing.B) {
    for i := 0; i < b.N; i++ {
        SubStrRuneIndexInString(benchmarkSubString, benchmarkSubStringLength)
    }
}

嘗試運行它，我對結果感到十分欣慰：

goos: darwin
goarch: amd64
pkg: github.com/thinkeridea/go-extend/exunicode/exutf8/benchmark
BenchmarkSubStrRuneIndexInString-8      13546849                82.4 ns/op             0 B/op          0 allocs/op
PASS
ok      github.com/thinkeridea/go-extend/exunicode/exutf8/benchmark     1.213s

性能較 range 提高了 10%，讓我很欣慰能夠再次得到新的提高，這證實它是有效的。

它足夠的高效，可是卻不夠易用，我截取字符串須要兩行代碼，若是我想截取 10~20之間的字符就須要4行代碼，這並非用戶易於使用的接口，我參考了其它語言的 sub_string 方法，我想我應該也設計一個這個樣的接口給用戶。

exutf8.RuneSubString 和 exutf8.RuneSub 是我認真思索後編寫的方法：

func RuneSubString(s string, start, length int) string

它有三個參數：

  • s : 輸入的字符串
  • start : 開始截取的位置，若是 start 是非負數，返回的字符串將從 string 的 start 位置開始，從 0 開始計算。例如，在字符串 「abcdef」 中，在位置 0 的字符是 「a」，位置 2 的字符串是 「c」 等等。 若是 start 是負數，返回的字符串將從 string 結尾處向前數第 start 個字符開始。 若是 string 的長度小於 start，將返回空字符串。
  • length：截取的長度，若是提供了正數的 length，返回的字符串將從 start 處開始最多包括 length 個字符（取決於 string 的長度）。 若是提供了負數的 length，那麼 string 末尾處的 length 個字符將會被省略（若 start 是負數則從字符串尾部算起）。若是 start 不在這段文本中，那麼將返回空字符串。 若是提供了值爲 0 的 length，返回的子字符串將從 start 位置開始直到字符串結尾。

我爲他們提供了別名，根據使用習慣你們更傾向去 strings 包尋找這類問題的解決方法，我建立了exstrings.SubString 和 exbytes.Sub 做爲更易檢索到的別名方法。

最後我須要再作一個性能測試，確保它的性能：

package benchmark

import (
    "testing"

    "github.com/thinkeridea/go-extend/exunicode/exutf8"
)

var benchmarkSubString = "Go語言是Google開發的一種靜態強類型、編譯型、併發型，並具備垃圾回收功能的編程語言。爲了方便搜索和識別，有時會將其稱爲Golang。"
var benchmarkSubStringLength = 20

func SubStrRuneSubString(s string, length int) string {
    return exutf8.RuneSubString(s, 0, length)
}

func BenchmarkSubStrRuneSubString(b *testing.B) {
    for i := 0; i < b.N; i++ {
        SubStrRuneSubString(benchmarkSubString, benchmarkSubStringLength)
    }
}

運行它，不會讓我失望：

goos: darwin
goarch: amd64
pkg: github.com/thinkeridea/go-extend/exunicode/exutf8/benchmark
BenchmarkSubStrRuneSubString-8          13309082                83.9 ns/op             0 B/op          0 allocs/op
PASS
ok      github.com/thinkeridea/go-extend/exunicode/exutf8/benchmark     1.215s

雖然相較 exutf8.RuneIndexInString 有所降低，但它提供了易於交互和使用的接口，我認爲這應該是最實用的方案，若是你追求極致仍然可使用 exutf8.RuneIndexInString，它依然是最快的方案。

總結

當看到有疑問的代碼，即便它十分的簡單，依然值得深究，並不停的探索它，這並不枯燥和乏味，反而會有極多收穫。

從起初 []rune 類型轉換到最後本身造輪子，不只獲得了16倍的性能提高，我還學習了utf8包、加深了range 遍歷字符串的特性 以及爲 go-extend 倉庫收錄了多個實用高效的解決方案，讓更多 go-extend 的用戶獲得成果。

go-extend 是一個收錄實用、高效方法的倉庫，讀者們若是好的函數和通用高效的解決方案，期待大家不吝嗇給我發送 Pull request，你也可使用這個倉庫加快功能實現及提高性能。

轉載：

本文做者： 戚銀（thinkeridea）

本文連接： https://blog.thinkeridea.com/201910/go/efficient_string_truncation.html

版權聲明： 本博客全部文章除特別聲明外，均採用 CC BY 4.0 CN協議 許可協議。轉載請註明出處！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程