Merge pull request #1 from vadimInshakov/main

add conversion from byte slice to string

Author: umputun

stringutils.go

@@ -2,7 +2,9 @@ package stringutils
 
 import (
 	"fmt"
+	"reflect"
 	"strings"
+	"unsafe"
 )
 
 // Contains string in slice
@@ -27,6 +29,9 @@ func ContainsAnySubstring(s string, subStrings []string) bool {
 
 // DeDup remove duplicates from slice. optimized for performance, good for short slices only!
 func DeDup(keys []string) []string {
+	if len(keys) == 0 {
+		return nil
+	}
 	l := len(keys) - 1
 	for i := 0; i < l; i++ {
 		for j := i + 1; j <= l; j++ {
@@ -43,6 +48,9 @@ func DeDup(keys []string) []string {
 
 // DeDupBig remove duplicates from slice. Should be used instead of DeDup for large slices
 func DeDupBig(keys []string) (result []string) {
+	if len(keys) == 0 {
+		return nil
+	}
 	result = make([]string, 0, len(keys))
 	visited := map[string]bool{}
 	for _, k := range keys {
@@ -56,13 +64,28 @@ func DeDupBig(keys []string) (result []string) {
 
 // SliceToString converts slice of any to slice of string
 func SliceToString(s []any) []string {
+	if len(s) == 0 {
+		return nil
+	}
 	strSlice := make([]string, len(s))
 	for i, v := range s {
+		if vb, ok := v.([]byte); ok {
+			strSlice[i] = bytesToString(vb)
+			continue
+		}
 		strSlice[i] = fmt.Sprintf("%v", v)
 	}
 	return strSlice
 }
 
+func bytesToString(bytes []byte) string {
+	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&bytes))
+	return *(*string)(unsafe.Pointer(&reflect.StringHeader{
+		Data: sliceHeader.Data,
+		Len:  sliceHeader.Len,
+	}))
+}
+
 // HasCommonElement checks if any element of the second slice is in the first slice
 func HasCommonElement(a, b []string) bool {
 	for _, second := range b {

stringutils_test.go

@@ -1,6 +1,7 @@
 package stringutils
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -48,6 +49,8 @@ func TestDeDup(t *testing.T) {
 		keys []string
 		want []string
 	}{
+		{"nil input", nil, nil},
+		{"empty input", []string{}, nil},
 		{"removes duplicates", []string{"test", "test", "example"}, []string{"test", "example"}},
 		{"no duplicates", []string{"test", "test2", "example"}, []string{"test", "test2", "example"}},
 	}
@@ -65,6 +68,8 @@ func TestDeDupBig(t *testing.T) {
 		keys []string
 		want []string
 	}{
+		{"nil input", nil, nil},
+		{"empty input", []string{}, nil},
 		{"removes duplicates", []string{"test", "test", "example"}, []string{"test", "example"}},
 		{"no duplicates", []string{"test", "test2", "example"}, []string{"test", "test2", "example"}},
 	}
@@ -82,8 +87,11 @@ func TestSliceToString(t *testing.T) {
 		in   []interface{}
 		want []string
 	}{
+		{"nil input", nil, nil},
+		{"empty input", []any{}, nil},
 		{"converts number to string", []any{1, 2, 3}, []string{"1", "2", "3"}},
 		{"converts mixed slice to string", []any{1, "aaa", true, 0.55}, []string{"1", "aaa", "true", "0.55"}},
+		{"converts slice of byte slices to string", []any{[]byte("hi"), []byte("there")}, []string{"hi", "there"}},
 	}
 
 	for _, tt := range tests {
@@ -169,3 +177,47 @@ func TestHasSuffixSlice(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkSliceToString(b *testing.B) {
+	tmpl := []any{[]byte("fdjndfg")}
+	b.Run("unsafe (small slice)", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			SliceToString(tmpl)
+		}
+	})
+	b.Run("type assert (small slice)", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			sliceToStringAllocs(tmpl)
+		}
+	})
+
+	for i := 0; i < 20; i++ {
+		tmpl = append(tmpl, tmpl...)
+	}
+
+	b.Run("unsafe (big slice)", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			SliceToString(tmpl)
+		}
+	})
+	b.Run("type assert (big slice)", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			sliceToStringAllocs(tmpl)
+		}
+	})
+}
+
+func sliceToStringAllocs(s []any) []string {
+	if len(s) == 0 {
+		return nil
+	}
+	strSlice := make([]string, len(s))
+	for i, v := range s {
+		if vb, ok := v.([]byte); ok {
+			strSlice[i] = string(vb)
+			continue
+		}
+		strSlice[i] = fmt.Sprintf("%v", v)
+	}
+	return strSlice
+}