連接幾個[]字節的最快方式是什麼？

Question

現在我正在使用下面的代碼（如BenchmarkEncoder()），它很快，但我想知道是否有更快，更有效的方式。我與GOMAXPROCS=1和

sudo -E nice -n -20 go test -bench . -benchmem -benchtime 3s 

基準。

package blackbird 

import (
    "testing" 
    "encoding/hex" 
    "log" 
    "bytes" 
    "encoding/json" 
) 

var (
    d1, d2, d3, d4, outBytes []byte 
    toEncode [][]byte 
) 

func init() { 
    var err interface{} 
    d1, err = hex.DecodeString("6e5438fd9c3748868147d7a4f6d355dd") 
    d2, err = hex.DecodeString("0740e2dfa4b049f2beeb29cc304bdb5f") 
    d3, err = hex.DecodeString("ab6743272358467caff7d94c3cc58e8c") 
    d4, err = hex.DecodeString("7411c080762a47f49e5183af12d87330e6d0df7dd63a44808db4e250cdea0a36182fce4a309842e49f4202eb90184dd5b621d67db4a04940a29e981a5aea59be") 
    if err != nil { 
     log.Fatal("hex decoding failed: %v", err) 
    } 
    toEncode = [][]byte{d1, d2, d3, d4} 

} 

func Encode(stuff [][]byte) []byte { 
    return bytes.Join(stuff, nil) 
} 

func BenchmarkEncoderDirect(b *testing.B) { 
    for i := 0; i < b.N; i++ { 
     bytes.Join(toEncode, nil) 
    } 
} 

func BenchmarkEncoder(b *testing.B) { 
    for i := 0; i < b.N; i++ { 
     Encode(toEncode) 
    } 
} 

func BenchmarkJsonEncoder(b *testing.B) { 
    for i := 0; i < b.N; i++ { 
     outBytes, _ = json.Marshal(toEncode) 

    } 
} 

什麼是連接幾個[]byte在一起的最快方式？

Answer 1

bytes.Join()非常快，但它會在可追加的字節片段之間附加分隔符做一些額外的工作。即使分隔符是空的或nil切片也是如此。因此，如果您關心最佳性能（儘管它會有輕微的改進），您可以在不添加（空）分隔符的情況下執行以下操作：分配一個足夠大的字節片，並將每個片複製到結果中使用內置的copy()功能。

嘗試它的Go Playground：

func Join(s ...[]byte) []byte { 
    n := 0 
    for _, v := range s { 
     n += len(v) 
    } 

    b, i := make([]byte, n), 0 
    for _, v := range s { 
     i += copy(b[i:], v) 
    } 
    return b 
} 

使用它：

concatenated := Join(d1, d2, d3, d4) 

改進：

如果你事先知道總規模（或者你可以計算出它比循環切片快），提供它，你可以避免不得不遍歷切片，以計算所需要的尺寸：

func JoinSize(size int, s ...[]byte) []byte { 
    b, i := make([]byte, size), 0 
    for _, v := range s { 
     i += copy(b[i:], v) 
    } 
    return b 
} 

在您的情況使用它：

concatenated := JoinSize(48 + len(d4), d1, d2, d3, d4) 

注：

但是，如果最終你的目標是要將連接的字節片段寫入io.Writer，性能上最好不要連接它們，而是分別將它們寫入它們中。

Answer 2

一般來說，@ icza的答案是正確的。爲了您的具體使用情況，但是，你可以分配一次，並更有效地解碼到該緩衝區：

Like this:

package main 

import (
    "encoding/hex" 
) 

func main() { 
    h1 := []byte("6e5438fd9c3748868147d7a4f6d355dd") 
    h2 := []byte("0740e2dfa4b049f2beeb29cc304bdb5f") 
    h3 := []byte("ab6743272358467caff7d94c3cc58e8c") 
    h4 := []byte("7411c080762a47f49e5183af12d87330e6d0df7dd63a44808db4e250cdea0a36182fce4a309842e49f4202eb90184dd5b621d67db4a04940a29e981a5aea59be") 

    tg := make([]byte, 16+16+16+(1024*1024)) // allocate enough space for the 3 IDs and a max 1MB of extra data 

    hex.Decode(tg[:16], h1) 
    hex.Decode(tg[16:32], h2) 
    hex.Decode(tg[32:48], h3) 
    l, _ := hex.Decode(tg[48:], h4) 

    tg = tg[:48+l] 
} 

在代碼的結束，tg持有3點的ID加上可變長度第四塊數據，解碼，連續。