字符串函数

package main

import (
    "github.com/satori/go.uuid"
    "fmt"
)

func main(){
    u1 := uuid.Must(uuid.NewV4())
    fmt.Printf("UUIDv4:%s\n", u1)

    u2, err := uuid.FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
    if err != nil {
        fmt.Printf("Something went wrong: %s", err)
        return
    }
    fmt.Printf("Successfully parsed: %s", u2)
}

//1. 按指定字符拆分
s := "iiaiibiiciiiidiiii"
sep:="ii"
arr:=strings.Split(s,sep)
fmt.Println("arr:",arr)

//2. 按空格拆分
s:=" ab cd          ef gh ij kl "
arr:=strings.Fields(s)
fmt.Printf("arr:%q\n",arr)

//github.com/axgle/mahonia
func ConvertToString(src string, srcCode string, tagCode string) string {
    srcCoder := mahonia.NewDecoder(srcCode)
    srcResult := srcCoder.ConvertString(src)
    tagCoder := mahonia.NewDecoder(tagCode)
    _, cdata, _ := tagCoder.Translate([]byte(srcResult), true)
    result := string(cdata)
    return result
}
func main() {
    //gbk编码的中文，用16进制字符串表示
    hex_str := "4d6f646275732e58464a2e3330462ec0e4c4fdcbaec5c5cbaeb1c3"
    hex_data, _ := hex.DecodeString(hex_str)
    // 将 byte 转换 为字符串 输出结果
    str := ConvertToString(string(hex_data), "gbk", "utf-8")
    fmt.Println(str)

    //先试试这个，一般就可以了
    s1 := "4d6f646275732e58464a2e3330462ec0e4c4fdcbaec5c5cbaeb1c3"
    hex_data, _ := hex.DecodeString(s1)
    srcCoder := mahonia.NewDecoder("gbk")
    srcResult := srcCoder.ConvertString(string(hex_data))
    fmt.Println(srcResult)
}

package main

import (
"crypto/md5"
"fmt"
"io"
)

func main() {
str := "abc123"

//方法一
data := []byte(str)
has := md5.Sum(data)
md5str1 := fmt.Sprintf("%x", has) //将[]byte转成16进制

fmt.Println(md5str1)

//方法二

w := md5.New()
io.WriteString(w, str)   //将str写入到w中
md5str2: = fmt.Sprintf("%x", w.Sum(nil))  //w.Sum(nil)将w的hash转成[]byte格式

fmt.Println(mdtstr2)
}

package main

import (
   "encoding/base64"
   "fmt"
)

func main()  {

   //标准base64编码
   data:="abckagfd*^&&^*fadf";

   sEnc:=base64.StdEncoding.EncodeToString([]byte(data))

   fmt.Println(sEnc)

   sDec,_:=base64.StdEncoding.DecodeString(sEnc)

   fmt.Println(string(sDec))

   //兼容base64编码
   uEnc:=base64.URLEncoding.EncodeToString([]byte(data))

   fmt.Println(uEnc)

   uDec,_:=base64.URLEncoding.DecodeString(uEnc)
   fmt.Println(string(uDec))

}

package main

import (
    "fmt"
    "reflect"
    "time"
    "unsafe"
)

//零拷贝字符串转字节数组
func string2bytes(s string) []byte {
    stringHeader := (*reflect.StringHeader)(unsafe.Pointer(&s))
    var b []byte
    pbytes := (*reflect.SliceHeader)(unsafe.Pointer(&b))
    pbytes.Data = stringHeader.Data
    pbytes.Len = stringHeader.Len
    pbytes.Cap = stringHeader.Len
    return b
}

//零拷贝字节数组转字符串
func bytes2string(b []byte) string {
    bHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
    var s string
    stringHeader := (*reflect.StringHeader)(unsafe.Pointer(&s))
    stringHeader.Data = bHeader.Data
    stringHeader.Len = bHeader.Len
    return s
}

func main() {
    s := "零拷贝转换字符串和字节数组"
    t1 := time.Now().Nanosecond()
    v := string2bytes(s)
    t2 := time.Now().Nanosecond()
    fmt.Println(v)

    t3 := time.Now().Nanosecond()
    data := []byte(s)
    t4 := time.Now().Nanosecond()
    fmt.Println(data)

    fmt.Println("method1 time", t2-t1)
    fmt.Println("method2 time", t4-t3)

    t5 := time.Now().Nanosecond()
    s1 := bytes2string(v)
    t6 := time.Now().Nanosecond()
    fmt.Println(s1)

    t7 := time.Now().Nanosecond()
    s2 := string(v)
    t8 := time.Now().Nanosecond()
    fmt.Println(s2)
    fmt.Println("method3 time", t6-t5)
    fmt.Println("method4 time", t8-t7)
}