go string与time标准包使用简介

Go语言的标准库覆盖网络、系统、加密、编码、图形等各个方面，可以直接使用标准库的 http 包进行 HTTP 协议的收发处理；网络库基于高性能的操作系统通信模型（Linux 的 epoll、Windows 的 IOCP）；所有的加密、编码都内建支持，不需要再从第三方开发者处获取

Go 语言的编译器也是标准库的一部分，通过词法器扫描源码，使用语法树获得源码逻辑分支等。Go 语言的周边工具也是建立在这些标准库上。在标准库上可以完成几乎大部分的需求

Go 语言的标准库以包的方式提供支持，下表是 Go 语言标准库中常见的包及其功能

Go语言标准库包名功能
bufio 带缓冲的 I/O 操作
bytes 实现字节操作
container 封装堆、列表和环形列表等容器
crypto 加密算法
database 数据库驱动和接口
debug 各种调试文件格式访问及调试功能
encoding 常见算法如 JSON、XML、Base64 等
flag 命令行解析
fmt 格式化操作
go Go 语言的词法、语法树、类型等。可通过这个包进行代码信息提取和修改
html HTML 转义及模板系统
image 常见图形格式的访问及生成
io 实现 I/O 原始访问接口及访问封装
math 数学库
net 网络库，支持 Socket、HTTP、邮件、RPC、SMTP 等
os 操作系统平台不依赖平台操作封装
path 兼容各操作系统的路径操作实用函数
plugin Go 1.7 加入的插件系统。支持将代码编译为插件，按需加载
reflect 语言反射支持。可以动态获得代码中的类型信息，获取和修改变量的值
regexp 正则表达式封装
runtime 运行时接口
sort 排序接口
strings 字符串转换、解析及实用函数
time 时间接口
text 文本模板及 Token 词法器

fmt（格式化操作）
字符串格式化时常用动词及功能
动词功能
%v 按值的本来值输出
%+v 在 %v 基础上，对结构体字段名和值进行展开
%#v 输出 Go 语言语法格式的值
%T 输出 Go 语言语法格式的类型和值
%% 输出 % 本体
%b 整型以二进制方式显示
%o 整型以八进制方式显示
%d 整型以十进制方式显示
%x 整型以十六进制方式显示
%X 整型以十六进制、字母大写方式显示
%U Unicode 字符
%f 浮点数完整精度输出；%.2f 2位精度输出
%p 指针，十六进制方式显示

strings（字符串操作）

package main
 
import (
    "fmt"
    "strings"
    "strconv"
)
 
func main(){
    
    
    var strTest string = " http://www.cnblog.com/kaichenkai "
 
    // 是否以 http:// 开头
    ret1 := strings.HasPrefix(strTest, "http://")
    fmt.Println("HasPrefix result:", ret1)  // HasPrefix result: false
 
    // 是否以 .com 结尾
    ret2 := strings.HasSuffix(strTest, ".com")
    fmt.Println("HasSuffix result:", ret2)  // HasSuffix result: false
 
    // 返回 k 在字符串中首次出现的位置，没有则返回 -1
    ret3 := strings.Index(strTest, "k")
    fmt.Println("Index is:", ret3)  // Index is: 23
 
    // 返回 k 在字符串中最后出现的位置，没有则返回 -1
    ret4 := strings.LastIndex(strTest, "k")
    fmt.Println("LastIndex is:", ret4)  // LastIndex is: 30
 
    // 将 kai 换成 空格，替换1次，返回操作后的结果字符串
    ret5 := strings.Replace(strTest, "kai", " ", 1)
    fmt.Println("replace complete, strTest is:", ret5)  // replace complete, strTest is:  http://www.cnblog.com/ chenkai
 
    // 统计子字符串 kai 的出现次数
    ret6 := strings.Count(strTest, "kai")
    fmt.Println("Count is:", ret6)  // Count is: 2
 
    // 将字符串重复 n 次，返回操作后的结果字符串
    ret7 := strings.Repeat(strTest, 2)
    fmt.Println("Repeat result is:", ret7)  // Repeat result is:  http://www.cnblog.com/kaichenkai  http://www.cnblog.com/kaichenkai
 
    // 转小写
    ret8 := strings.ToLower(strTest)
    fmt.Println("Lower result is:", ret8)  // Lower result is:  http://www.cnblog.com/kaichenkai
 
    // 转大写
    ret9 := strings.ToUpper(strTest)
    fmt.Println("Upper result is:", ret9)  // Upper result is:  HTTP://WWW.CNBLOG.COM/KAICHENKAI
 
    // 去掉收尾空白字符，返回操作后的结果字符串
    ret10 := strings.TrimSpace(strTest)
    fmt.Println("TrimSpace:", ret10)  // TrimSpace: http://www.cnblog.com/kaichenkai
 
    // 去掉首尾指定字符，返回操作后的结果字符串
    ret11 := strings.Trim(strTest, "http://")
    fmt.Println("Trim:", ret11)  // Trim:  http://www.cnblog.com/kaichenkai
 
    // 去掉左侧指定字符，返回操作后的结果字符串
    ret12 := strings.TrimLeft(strTest, " http://")
    fmt.Println("TrimLeft:", ret12)  // TrimLeft: www.cnblog.com/kaichenkai
 
    // 去掉右侧指定字符，返回操作后的结果字符串
    ret13 := strings.TrimRight(strTest, "kai ")
    fmt.Println("TrimRight:", ret13)  // TrimRight:  http://www.cnblog.com/kaichen
 
    // 以空格分割，返回子串的 slice
    ret14 := strings.Fields(strTest)
    fmt.Println("Fields:", ret14)  // Fields: [http://www.cnblog.com/kaichenkai]
 
    // 以 .（点）进行分割，返回子串的 slice
    ret15 := strings.Split(strTest, ".")
    fmt.Println("Split:", ret15)  // Split: [ http://www cnblog com/kaichenkai ]
 
    // 以 $ 将 slice 中的元素进行拼接
    ret16 := strings.Join(ret15, "$")
    fmt.Println("Join:", ret16)  // Join:  http://www$cnblog$com/kaichenkai
 
    // 将整数转换为字符串
    ret17 := strconv.Itoa(1000)
    fmt.Println("Itoa:", ret17)  // Itoa: 1000
 
    // 将字符串转换为数字，前提是字符串是纯数字组成，不然会报错
    ret18, error := strconv.Atoi("100")
    if error == nil{
    
    
        fmt.Println("Atoi:", ret18)  // Atoi: 100
    }
}

time 包中的常量

const (
    Nanosecond  Duration = 1
    Microsecond  = 1000 * Nanosecond
    Millisecond  = 1000 * Microsecond
    Second       = 1000 * Millisecond
    Minute       = 60 * Second
    Hour         = 60 * Minute
)

时间的类型为 Duration，而 Duration 实际是一个 int64 的类型，可以转换；

Duration.String() 可以将 Duration 的值转为字符串

now := time.Now()
fmt.Printf("type:%T \n", now)
fmt.Printf("value:%v \n", now)
 
运行结果：
type:time.Time
value:2019-05-25 17:57:57.9463214 +0800 CST m=+0.003026301

自定义时间

格式：func Parse(layout, value string) (Time, error)

Parse 解析一个格式化的时间字符串并返回它代表的时间。
layout 定义输入的时间格式，value 的时间格式需与 layout 保持一致

t, error := time.Parse("2006-01-02 15:04:05", "2019-05-25 19:00:00")
if error == nil{
    
    
    fmt.Printf("%T \n", t)
    fmt.Printf("%v \n", t)
}
 
运行结果：
time.Time
2019-05-25 19:00:00 +0000 UTC

获取time.Time 类型的年，月，日，时，分，秒

year := time.Now().Year()
month := time.Now().Month()
day := time.Now().Day()
hour := time.Now().Hour()
minute := time.Now().Minute()
second := time.Now().Second()

// 秒级
timestamp := time.Now().Unix()
fmt.Println(timestamp)
 
// 毫秒
milliTimestamp := time.Now().UnixNano() / 1e6
fmt.Println(milliTimestamp)
 
// 纳秒
NanoTimestamp := time.Now().UnixNano()
fmt.Println(NanoTimestamp)
 
 
运行结果：
1558782662
1558782662752
1558782662755344000

Demo：统计程序运行耗时

func stats(){
    
    
    time.Sleep(time.Second)
}
 
func main(){
    
    
    var startTime int64 = time.Now().UnixNano() / 1e6
    stats()
    var endTime int64 = time.Now().UnixNano() / 1e6
    fmt.Println("use time:", endTime - startTime)
}
 
运行结果：
1001

go string与time标准包使用简介

猜你喜欢