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 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 

主要结论

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   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() 函数。