golang time strings常用方法

time.Sleep

go用来指定睡眠时间的函数为time.Sleep。传入的为一个Duration，所以如果想睡眠5s钟，不能直接写 time.Sleep(5) ，而应该写time.Sleep(5 * time.Second)

其中time.Second就是一个Duration类型，表示1s的时间间隔，乘系数5就得到5s的时间间隔。

想要睡眠的时间可以使用自由组合，比如睡眠1小时10分5秒：

time.Sleep(1*time.Hour + 10*time.Minute + 5*time.Second)time.Sleep(time.Duration(5)*time.Second)

使用time.Since计算执行时间

想要获取计算某个任务从开始到结束的运行时间，我们可以使用time包中的Slice函数

package mainimport ("fmt""time"
)// 指定字段类型
func main() {start := time.Now() // 获取当前时间sum := 0for i := 0; i < 100000000; i++ {sum++}elapsed := time.Since(start).Seconds()fmt.Println(elapsed)
}

定时器NewTimer、NewTicker使用

定时任务每秒执行一次

package mainimport ("fmt""time"
)func main() {t1 := time.NewTicker(time.Second * 1)var i = 1for {if i == 10 {break}select {case <-t1.C: // 一秒执行一次的定时任务task1(i)i++}}
}
func task1(i int) {fmt.Println("task1执行了,第", i, "秒，当前时间：", time.Now().Format("2006-01-02 15:04:05"))
}

strings常用方法

package mainimport s "strings" //strings取个别名
import "fmt"//我们给 fmt.Println 一个短名字的别名，我们随后将会经常用到。
var p = fmt.Printlnfunc main() {//这是一些 strings 中的函数例子。注意他们都是包中的函数，不是字符串对象自身的方法，这意味着我们需要考虑在调用时传递字符作为第一个参数进行传递。p("Contains:  ", s.Contains("test", "es"))        //是否包含：truep("Count:     ", s.Count("test", "t"))            //包含字符数 ：2p("HasPrefix: ", s.HasPrefix("test", "te"))       //是否包含前缀：truep("HasSuffix: ", s.HasSuffix("test", "st"))       //是否包含后缀：truep("Index:     ", s.Index("test", "d"))            //字符存在的位置,不存在返回-1p("Join:      ", s.Join([]string{"a", "b"}, "-")) //拼接字符：a-bp("Repeat:    ", s.Repeat("abc", 5))              //复制字符几次：aaaaap("Replace:   ", s.Replace("foo", "o", "0", -1))  //替换所有存在的字符 f00p("Replace:   ", s.ReplaceAll("foo", "o", "0"))   //替换存在的字符p("Split:     ", s.Split("a-b-c-d-e", "-"))       //指定字符分隔字符串：[a b c d e]p("ToLower:   ", s.ToLower("TEST"))p("ToUpper:   ", s.ToUpper("test"))p("Len: ", len("hello"))p("Char:", "hello"[1])p("to []string:", s.Fields("hello")) //字符串变数组p("去除首尾空白", s.TrimSpace("   hell o  "))
}

TrimRight/TrimLeft和TrimSuffix的区别

TrimRight/TrimLeft 会将第二个参数字符串里面所有的字符拿出来处理，只要与其中任何一个字符相等，便会将其删除。想正确地截取字符串用TrimSuffix

• TrimRight：删除尾部连续的包含的字符串
• TrimLeft：  删除头部连续的包含的字符串

func main() {log.Println(strings.TrimRight("Hello world hello world", "Hello")) // Hello world hello worldlog.Println(strings.TrimRight("Hello worldhelloworld", "world")) // Hello worldhelog.Println(strings.TrimRight("abba", "ba"))                       // ""log.Println(strings.TrimLeft("abcdaaaaa", "abcd"))                //""log.Println(strings.TrimSuffix("abcddcba", "dcba"))                //"abcd"
}

golang 几种字符串的连接方式

1. 直接使用+运算符

func BenchmarkAddStringWithOperator(b *testing.B) {hello := "hello"world := "world"for i := 0; i < b.N; i++ {_ = hello + "," + world}
}

golang 里面的字符串都是不可变的，每次运算都会产生一个新的字符串，所以会产生很多临时的无用的字符串，不仅没有用，还会给 gc 带来额外的负担，所以性能比较差 

2. fmt.Sprintf()

func BenchmarkAddStringWithSprintf(b *testing.B) {hello := "hello"world := "world"for i := 0; i < b.N; i++ {_ = fmt.Sprintf("%s,%s", hello, world)}
}

内部使用 []byte 实现，不像直接运算符这种会产生很多临时的字符串，但是内部的逻辑比较复杂，有很多额外的判断，还用到了 interface，所以性能也不是很好 

3. strings.Join()

func BenchmarkAddStringWithJoin(b *testing.B) {hello := "hello"world := "world"for i := 0; i < b.N; i++ {_ = strings.Join([]string{hello, world}, ",")}
}

join会先根据字符串数组的内容，计算出一个拼接之后的长度，然后申请对应大小的内存，一个一个字符串填入，在已有一个数组的情况下，这种效率会很高，但是本来没有，去构造这个数据的代价也不小 

4. buffer.WriteString()

func BenchmarkAddStringWithBuffer(b *testing.B) {hello := "hello"world := "world"for i := 0; i < 1000; i++ {var buffer bytes.Bufferbuffer.WriteString(hello)buffer.WriteString(",")buffer.WriteString(world)_ = buffer.String()}
}

这个比较理想，可以当成可变字符使用，对内存的增长也有优化，如果能预估字符串的长度，还可以用 buffer.Grow() 接口来设置 capacity 

主要结论

1. 在已有字符串数组的场合，使用 strings.Join() 能有比较好的性能
2. 在一些性能要求较高的场合，尽量使用 buffer.WriteString() 以获得更好的性能
3. 性能要求不太高的场合，直接使用运算符，代码更简短清晰，能获得比较好的可读性
4. 如果需要拼接的不仅仅是字符串，还有数字之类的其他需求的话，可以考虑 fmt.Sprintf

golang 字符串修改

func main() {s := "hello"r := []rune(s) //[]byte(s)r[0] = '中' //注意单引号fmt.Println(string(r))
}

其实是将string复制了一份到切片，然后对切片进行修改，最后再把切片转换为string输出，这个过程发生了2次内存复制，第一次是把字符串复制给切片，第二次是把切片复制给字符串 

翻转含有中文、数字、英文字母的字符串

func main() {src := "你好aBc啊哈哈1"dst := reverse([]rune(src))fmt.Printf("%v\n", string(dst))
}func reverse(s []rune) []rune {for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {s[i], s[j] = s[j], s[i]}return s
}

go 打印时 %v %+v %#v 的区别？

• %v 只输出所有的值；
• %+v 先输出字段名字，再输出该字段的值；
• %#v 先输出结构体名字值，再输出结构体（字段名字+字段的值）；

  type student struct {id   int32name string
  }func main() {a := &student{id: 1, name: "微客鸟窝"}fmt.Printf("a=%v \n", a)  // a=&{1 微客鸟窝}fmt.Printf("a=%+v \n", a) // a=&{id:1 name:微客鸟窝}fmt.Printf("a=%#v \n", a) // a=&main.student{id:1, name:"微客鸟窝"}
  }

计算字符串长度:len()和RuneCountInString()

golang的内建函数len()，可以用来获取切片、字符串、通道(channel)等的长度。下面的代码可以用 len() 来获取字符串的长度。

len() 函数的返回值的类型为 int，表示字符串的 ASCII 字符个数或字节长度。这里的差异是由于golang的字符串都是以UTF-8格式保存，每个中文占用3个字节，因此使用 len() 获得两个中文文字对应的6个字节。

如果希望按习惯上的字符个数来计算，就需要使用 Go 语言中 UTF-8 包提供RuneCountInString() 函数，统计 Uncode 字符数量。

fmt.Println(utf8.RuneCountInString("忍者"))  //2
fmt.Println(utf8.RuneCountInString("龙忍出鞘,fight!")) //11

一般游戏中在登录时都需要输入名字，而名字一般有长度限制。考虑到国人习惯使用中文做名字，就需要检测字符串 UTF-8 格式的长度。

总结

• ASCII 字符串长度使用 len() 函数。
• Unicode 字符串长度使用 utf8.RuneCountInString() 函数。