golang time strings常用方法

本文介绍了Go语言中time包的使用,包括time.Sleep用于指定延迟执行,time.Since计算运行时间,以及定时器NewTimer和NewTicker的使用。此外,还详细讲解了strings包的各种方法,如Contains、Count、Join等,并对比了不同字符串连接方式的性能。最后,讨论了Go语言中字符串的修改、翻转和长度计算,并展示了%v、%+v、%#v在打印时的区别。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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() 函数。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值