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 main
import (
"fmt"
"time"
)
// 指定字段类型
func main() {
start := time.Now() // 获取当前时间
sum := 0
for i := 0; i < 100000000; i++ {
sum++
}
elapsed := time.Since(start).Seconds()
fmt.Println(elapsed)
}
定时器NewTimer、NewTicker使用
定时任务每秒执行一次
package main
import (
"fmt"
"time"
)
func main() {
t1 := time.NewTicker(time.Second * 1)
var i = 1
for {
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 main
import s "strings" //strings取个别名
import "fmt"
//我们给 fmt.Println 一个短名字的别名,我们随后将会经常用到。
var p = fmt.Println
func main() {
//这是一些 strings 中的函数例子。注意他们都是包中的函数,不是字符串对象自身的方法,这意味着我们需要考虑在调用时传递字符作为第一个参数进行传递。
p("Contains: ", s.Contains("test", "es")) //是否包含:true
p("Count: ", s.Count("test", "t")) //包含字符数 :2
p("HasPrefix: ", s.HasPrefix("test", "te")) //是否包含前缀:true
p("HasSuffix: ", s.HasSuffix("test", "st")) //是否包含后缀:true
p("Index: ", s.Index("test", "d")) //字符存在的位置,不存在返回-1
p("Join: ", s.Join([]string{"a", "b"}, "-")) //拼接字符:a-b
p("Repeat: ", s.Repeat("abc", 5)) //复制字符几次:aaaaa
p("Replace: ", s.Replace("foo", "o", "0", -1)) //替换所有存在的字符 f00
p("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 world
log.Println(strings.TrimRight("Hello worldhelloworld", "world")) // Hello worldhe
log.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.Buffer
buffer.WriteString(hello)
buffer.WriteString(",")
buffer.WriteString(world)
_ = buffer.String()
}
}
这个比较理想,可以当成可变字符使用,对内存的增长也有优化,如果能预估字符串的长度,还可以用 buffer.Grow()
接口来设置 capacity
主要结论
- 在已有字符串数组的场合,使用
strings.Join()
能有比较好的性能 - 在一些性能要求较高的场合,尽量使用
buffer.WriteString()
以获得更好的性能 - 性能要求不太高的场合,直接使用运算符,代码更简短清晰,能获得比较好的可读性
- 如果需要拼接的不仅仅是字符串,还有数字之类的其他需求的话,可以考虑
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 int32 name 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() 函数。