啪啪啪免费精品,最新中文字幕在线资源

生成MD5字符串

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

func main() {
str := "123456"
fmt.Print(Md5one(str))
fmt.Print("------------")
fmt.Print(Md5two(str))
}
//方法一
func Md5one(str string) (md5str string) {
data := []byte(str)
has := md5.Sum(data)
md5str = fmt.Sprintf("%x", has)
return
}
//方法二
func Md5two(str string) (md5str string) {
h := md5.New()
io.WriteString(h, str)
md5str = fmt.Sprintf("%x", h.Sum(nil))
return
}

生成UUID

方法一、自己寫(xiě)

package main

import (
    "fmt"
    "sync/atomic"
    "time"
)

type UUID [16]byte

var timeBase = time.Date(1582, time.October, 15, 0, 0, 0, 0, time.UTC).Unix()
var hardwareAddr []byte
var clockSeq uint32

func TimeUUID() UUID {
    return FromTime(time.Now())
}

func FromTime(aTime time.Time) UUID {
    var u UUID

    utcTime := aTime.In(time.UTC)
    t := uint64(utcTime.Unix()-timeBase)*10000000 + uint64(utcTime.Nanosecond()/100)
    u[0], u[1], u[2], u[3] = byte(t>>24), byte(t>>16), byte(t>>8), byte(t)
    u[4], u[5] = byte(t>>40), byte(t>>32)
    u[6], u[7] = byte(t>>56)&0x0F, byte(t>>48)

    clock := atomic.AddUint32(&clockSeq, 1)
    u[8] = byte(clock >> 8)
    u[9] = byte(clock)

    copy(u[10:], hardwareAddr)

    u[6] |= 0x10 // set version to 1 (time based uuid)
    u[8] &= 0x3F // clear variant
    u[8] |= 0x80 // set to IETF variant

    return u
}

func (u UUID) String() string {
    var offsets = [...]int{0, 2, 4, 6, 9, 11, 14, 16, 19, 21, 24, 26, 28, 30, 32, 34}
    const hexString = "0123456789abcdef"
    r := make([]byte, 36)
    for i, b := range u {
        r[offsets[i]] = hexString[b>>4]
        r[offsets[i]+1] = hexString[b&0xF]
    }
    r[8] = '-'
    r[13] = '-'
    r[18] = '-'
    r[23] = '-'
    return string(r)
}

func main() {
    out := TimeUUID()
    fmt.Printf("%s\n", out.String())
}

方法二、

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

func main() {
    // 創(chuàng)建
    u1 := uuid.NewV4()
    fmt.Printf("UUIDv4: %s\n", u1)

    // 解析
    u2, err := uuid.FromString("f5394eef-e576-4709-9e4b-a7c231bd34a4")
    if err != nil {
        fmt.Printf("Something gone wrong: %s", err)
        return
    }
    fmt.Printf("Successfully parsed: %s", u2)
}

方法三、

import (
    "fmt"
    "github.com/snluu/uuid"
)

func main() {
    var id UUID = uuid.Rand()
    fmt.Println(id.Hex())
    fmt.Println(id.Raw())


    id1, err := uuid.FromStr("1870747d-b26c-4507-9518-1ca62bc66e5d")
    id2 := uuid.MustFromStr("1870747db26c450795181ca62bc66e5d")
    fmt.Println(id1 == id2)
}

方法四、

若使用的是linux系統(tǒng)，可以直接使用uuidgen命令來(lái)獲取。

package main

import (
    "fmt"
    "log"
    "os/exec"
)

//run in linux
func main() {
    out, err := exec.Command("uuidgen").Output()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%s", out)
}

方法五:wuid

參考地址https://www.golangtc.com/t/5a72b4b34ce40d6b0f425ddb
說(shuō)是速度很快，在這里記錄一下

import "github.com/edwingeng/wuid/redis"
// Setup
g := wuid.NewWUID("default", nil)
g.LoadH24FromRedis("127.0.0.1:6379", "", "wuid")
// Generate
for i := 0; i < 10; i++ {
    fmt.Println(g.Next())
}

生成GUID

//生成Guid字串
func GetGuid() string {
    b := make([]byte, 48)
    if _, err := io.ReadFull(rand.Reader, b); err != nil {
        return ""
    }
    return GetMd5String(base64.URLEncoding.EncodeToString(b))
}

生成隨機(jī)字符串

//生成隨機(jī)數(shù)
func RandNumberString(n int) string {
    letters := []rune("0123456789")
    b := make([]rune, n)
    r := rand.New(rand.NewSource(time.Now().UnixNano()))
    for i := range b {
        b[i] = letters[r.Intn(len(letters))]
    }
    return string(b)
}
//生成隨機(jī)字符串
func GetRandomString(lenth int) string{
    str := "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    bytes := []byte(str)
    result := []byte{}
    r := rand.New(rand.NewSource(time.Now().UnixNano()))
    for i := 0; i < lenth; i++ {
        result = append(result, bytes[r.Intn(len(bytes))])
    }
    return string(result)
}
const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
const (
    letterIdxBits = 6                    // 6 bits to represent a letter index
    letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
    letterIdxMax  = 63 / letterIdxBits   // # of letter indices fitting in 63 bits
)
//生成隨機(jī)字符串
func RandString(n int) string {
    src := rand.NewSource(time.Now().UnixNano())

    b := make([]byte, n)
    // A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
    for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
        if remain == 0 {
            cache, remain = src.Int63(), letterIdxMax
        }
        if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
            b[i] = letterBytes[idx]
            i--
        }
        cache >>= letterIdxBits
        remain--
    }

    return string(b)
}
//  生成一個(gè)區(qū)間范圍的隨機(jī)數(shù)
func GenerateRangeNum(min, max int) int {
    r := rand.New(rand.NewSource(time.Now().UnixNano()))
    randNum := r.Intn(max - min)
    randNum = randNum + min
    return randNum
}

strings包

判斷兩個(gè)字符串是否相等

strings.EqualFold(str1, str2)//判斷兩個(gè)字符串是否相等

判斷字符串url中是否包含字符串

strings.Contains(url, "http://")//判斷字符串url中是否包含字符串http://

判斷字符串中是否包含字符a(rune('a')為字符的阿斯克碼值)

strings.ContainsRune("widuua", rune('a'))//判斷字符串中是否包含字符a(rune('a')為字符的阿斯克碼值)

判斷字符串str中是否包含字符w(多個(gè)只要有一個(gè)符合就返回true)

strings.ContainsAny(str, "W")//判斷字符串str中是否包含字符w(多個(gè)只要有一個(gè)符合就返回true)

在一段字符串中有多少匹配到的字符或字符串

strings.Count("widuu", "uu")//在一段字符串中有多少匹配到的字符或字符串

//判斷字符串str是否以He開(kāi)頭

strings.HasPrefix(str, "He")//判斷字符串str是否以He開(kāi)頭

判斷字符串str是否以He結(jié)尾

strings.LastIndexAny("widuu", "He")//判斷字符串str是否以He結(jié)尾

判斷字符或者字符串s第一次在字符串中的位置

Index(s, sep string) //判斷字符或者字符串s第一次在字符串中的位置

字符串第一次出現(xiàn)的位置，如果不存在就返回-1

strings.IndexAny("widuu", "u")//字符串第一次出現(xiàn)的位置，如果不存在就返回-1

判斷字符x第一次在字符串中的位置

strings.IndexByte("hello xiaowei", 'x')//判斷字符x第一次在字符串中的位置

判斷字符或字符串最后一次出現(xiàn)的位置

strings.LastIndex("widuu", "uu")//判斷字符或字符串最后一次出現(xiàn)的位置

將字符串按空格分割成數(shù)組

strings.Fields(str)//將字符串按空格分割成數(shù)組

把切片轉(zhuǎn)換成字符串。

str1 := strings.Join(s," ") //把切片轉(zhuǎn)換成字符串。

利用string的修改操作，對(duì)str操作，用新字符串替代舊字符串。

strings.Replace(str,oldstr,newstr,n)  
    //用新字符串替代舊字符串,n為替換的個(gè)數(shù)，n:=strings.Count(json, "\\u0026")可獲取。

使用特定規(guī)則對(duì)字符串進(jìn)行替換操作

    var replacer = strings.NewReplacer(
        "&", "&amp;",
        "<", "&lt;",
        ">", "&gt;",
        // "&#34;" is shorter than "&quot;".
        `"`, "&#34;",
        // "&#39;" is shorter than "&apos;" and apos was not in HTML until HTML5.
        "'", "&#39;",
    )
    str:=replacer.Replace("<>&\"'")
    fmt.Println(str)

截取字符串

在對(duì)字符串處理的時(shí)候，突然發(fā)現(xiàn)字符串打印出來(lái)的長(zhǎng)度要不自己讀出來(lái)的長(zhǎng)，這個(gè)長(zhǎng)度其實(shí)就是字符串的字節(jié)長(zhǎng)度，如果其中有漢字，截取起來(lái)就非常的麻煩，找到一個(gè)方法記錄一下
s := "a我cd"
s = string([]rune(s)[:3])
fmt.Println(s) //得到 "a我c"

strconv包

string轉(zhuǎn)換為“雙引號(hào)”引起來(lái)的字符串

// Quote 將字符串 s 轉(zhuǎn)換為“雙引號(hào)”引起來(lái)的字符串
// 其中的特殊字符將被轉(zhuǎn)換為“轉(zhuǎn)義字符”
// “不可顯示的字符”將被轉(zhuǎn)換為“轉(zhuǎn)義字符”
func Quote(s string) string

func main() {
    fmt.Println(strconv.Quote(`C:\Windows`))
    // "C:\\Windows"
}

string轉(zhuǎn)換為“雙引號(hào)”引起來(lái)的字符串，并將結(jié)果追加到 dst 的尾部

// AppendQuote 將字符串 s 轉(zhuǎn)換為“雙引號(hào)”引起來(lái)的字符串，
// 并將結(jié)果追加到 dst 的尾部，返回追加后的 []byte
// 其中的特殊字符將被轉(zhuǎn)換為“轉(zhuǎn)義字符”
func AppendQuote(dst []byte, s string) []byte

func main() {
    s := `C:\Windows`
    b := make([]byte, 0)
    b = strconv.AppendQuote(b, s)
    fmt.Printf("%s", b) // "C:\\Windows"
}

將字符串 s 轉(zhuǎn)換為“雙引號(hào)”引起來(lái)的 ASCII 字符串

// QuoteToASCII 將字符串 s 轉(zhuǎn)換為“雙引號(hào)”引起來(lái)的 ASCII 字符串
// “非 ASCII 字符”和“特殊字符”將被轉(zhuǎn)換為“轉(zhuǎn)義字符”
func QuoteToASCII(s string) string

func main() {
    fmt.Println(strconv.QuoteToASCII("Hello 世界！"))
    // "Hello \u4e16\u754c\uff01"
}

將字符串 s 轉(zhuǎn)換為“雙引號(hào)”引起來(lái)的 ASCII 字符串，并將結(jié)果追加到 dst 的尾部

// AppendQuoteToASCII 將字符串 s 轉(zhuǎn)換為“雙引號(hào)”引起來(lái)的 ASCII 字符串，
// 并將結(jié)果追加到 dst 的尾部，返回追加后的 []byte
// “非 ASCII 字符”和“特殊字符”將被轉(zhuǎn)換為“轉(zhuǎn)義字符”
func AppendQuoteToASCII(dst []byte, s string) []byte

func main() {
    s := "Hello 世界！"
    b := make([]byte, 0)
    b = strconv.AppendQuoteToASCII(b, s)
    fmt.Printf("%s", b) // "Hello \u4e16\u754c\uff01"
}

將 Unicode 字符轉(zhuǎn)換為“單引號(hào)”引起來(lái)的字符串

// QuoteRune 將 Unicode 字符轉(zhuǎn)換為“單引號(hào)”引起來(lái)的字符串
// “特殊字符”將被轉(zhuǎn)換為“轉(zhuǎn)義字符”
func QuoteRune(r rune) string

func main() {
    fmt.Println(strconv.QuoteRune('好'))
    // '好'
}

將 Unicode 字符轉(zhuǎn)換為“單引號(hào)”引起來(lái)的字符串，并將結(jié)果追加到 dst 的尾部

// AppendQuoteRune 將 Unicode 字符轉(zhuǎn)換為“單引號(hào)”引起來(lái)的字符串，
// 并將結(jié)果追加到 dst 的尾部，返回追加后的 []byte
// “特殊字符”將被轉(zhuǎn)換為“轉(zhuǎn)義字符”
func AppendQuoteRune(dst []byte, r rune) []byte

func main() {
    b := make([]byte, 0)
    b = strconv.AppendQuoteRune(b, '好')
    fmt.Printf("%s", b) // '好'
}

將 Unicode 字符轉(zhuǎn)換為“單引號(hào)”引起來(lái)的 ASCII 字符串

// QuoteRuneToASCII 將 Unicode 字符轉(zhuǎn)換為“單引號(hào)”引起來(lái)的 ASCII 字符串
// “非 ASCII 字符”和“特殊字符”將被轉(zhuǎn)換為“轉(zhuǎn)義字符”
func QuoteRuneToASCII(r rune) string

func main() {
    fmt.Println(strconv.QuoteRuneToASCII('好'))
    // '\u597d'
}

將 Unicode 字符轉(zhuǎn)換為“單引號(hào)”引起來(lái)的 ASCII 字符串，并將結(jié)果追加到 dst 的尾部

// AppendQuoteRune 將 Unicode 字符轉(zhuǎn)換為“單引號(hào)”引起來(lái)的 ASCII 字符串，
// 并將結(jié)果追加到 dst 的尾部，返回追加后的 []byte
// “非 ASCII 字符”和“特殊字符”將被轉(zhuǎn)換為“轉(zhuǎn)義字符”
func AppendQuoteRuneToASCII(dst []byte, r rune) []byte

func main() {
    b := make([]byte, 0)
    b = strconv.AppendQuoteRuneToASCII(b, '好')
    fmt.Printf("%s", b) // '\u597d'
}

判斷字符串 s 是否可以表示為一個(gè)單行的“反引號(hào)”字符串

// CanBackquote 判斷字符串 s 是否可以表示為一個(gè)單行的“反引號(hào)”字符串
// 字符串中不能含有控制字符（除了 \t）和“反引號(hào)”字符，否則返回 false
func CanBackquote(s string) bool

func main() {
    b := strconv.CanBackquote("C:\\Windows\n")
    fmt.Println(b) // false
    b = strconv.CanBackquote("C:\\Windows\r")
    fmt.Println(b) // false
    b = strconv.CanBackquote("C:\\Windows\f")
    fmt.Println(b) // false
    b = strconv.CanBackquote("C:\\Windows\t")
    fmt.Println(b) // true
    b = strconv.CanBackquote("C:\\`Windows`")
    fmt.Println(b) // false
}

將 s 中的第一個(gè)字符“取消轉(zhuǎn)義”并解碼

// UnquoteChar 將 s 中的第一個(gè)字符“取消轉(zhuǎn)義”并解碼
//
// s：轉(zhuǎn)義后的字符串
// quote：字符串使用的“引號(hào)符”（用于對(duì)引號(hào)符“取消轉(zhuǎn)義”）
//
// value：解碼后的字符
// multibyte：value 是否為多字節(jié)字符
// tail：字符串 s 除去 value 后的剩余部分
// error：返回 s 中是否存在語(yǔ)法錯(cuò)誤
//
// 參數(shù) quote 為“引號(hào)符”
// 如果設(shè)置為單引號(hào)，則 s 中允許出現(xiàn) ' 字符，不允許出現(xiàn)單獨(dú)的 ' 字符
// 如果設(shè)置為雙引號(hào)，則 s 中允許出現(xiàn) " 字符，不允許出現(xiàn)單獨(dú)的 " 字符
// 如果設(shè)置為 0，則不允許出現(xiàn) ' 或 " 字符，可以出現(xiàn)單獨(dú)的 ' 或 " 字符
func UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err error)

func main() {
    s := `\"大\\家\\好！\"`
    c, mb, sr, _ := strconv.UnquoteChar(s, '"')
    fmt.Printf("%-3c %v\n", c, mb)
    for ; len(sr) > 0; c, mb, sr, _ = strconv.UnquoteChar(sr, '"') {
        fmt.Printf("%-3c %v\n", c, mb)
    }
    // " false
    // 大 true
    // \ false
    // 家 true
    // \ false
    // 好 true
    // ！ true
}

將“帶引號(hào)的字符串” s 轉(zhuǎn)換為常規(guī)的字符串（不帶引號(hào)和轉(zhuǎn)義字符）

// Unquote 將“帶引號(hào)的字符串” s 轉(zhuǎn)換為常規(guī)的字符串（不帶引號(hào)和轉(zhuǎn)義字符）
// s 可以是“單引號(hào)”、“雙引號(hào)”或“反引號(hào)”引起來(lái)的字符串（包括引號(hào)本身）
// 如果 s 是單引號(hào)引起來(lái)的字符串，則返回該該字符串代表的字符
func Unquote(s string) (t string, err error)

func main() {
    sr, err := strconv.Unquote(`"\"大\t家\t好！\""`)
    fmt.Println(sr, err)
    sr, err = strconv.Unquote(`'大家好！'`)
    fmt.Println(sr, err)
    sr, err = strconv.Unquote(`'好'`)
    fmt.Println(sr, err)
    sr, err = strconv.Unquote("`大\\t家\\t好！`")
    fmt.Println(sr, err)
}

IsPrint 判斷 Unicode 字符 r 是否是一個(gè)可顯示的字符

// IsPrint 判斷 Unicode 字符 r 是否是一個(gè)可顯示的字符
// 可否顯示并不是你想象的那樣，比如空格可以顯示，而\t則不能顯示
// 具體可以參考 Go 語(yǔ)言的源碼
func IsPrint(r rune) bool

func main() {
    fmt.Println(strconv.IsPrint('a'))  // true
    fmt.Println(strconv.IsPrint('好'))  // true
    fmt.Println(strconv.IsPrint(' '))  // true
    fmt.Println(strconv.IsPrint('\t')) // false
    fmt.Println(strconv.IsPrint('\n')) // false
    fmt.Println(strconv.IsPrint(0))    // false
}

字符串?dāng)?shù)組排序

aa := []string{"ab", "aw", "ap", "aa"}
sort.Strings(aa)
fmt.Println(aa)

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

golang字符串的一般操作