Bootstrap

【Go学习】-02-1-标准库：fmt、os、time

【Go学习】-02-1-标准库：fmt、os、time

1 fmt标准库

go版本：1.18.1

主要分为向外输出内容和获取输入内容两大部分

1.1 输出

1.1.1 fmt.Print

print 有三个相关的函数：

func Print(a ...any) (n int, err error) {
	return Fprint(os.Stdout, a...)
}
func Println(a ...any) (n int, err error) {
	return Fprintln(os.Stdout, a...)
}
func Printf(format string, a ...any) (n int, err error) {
	return Fprintf(os.Stdout, format, a...)
}

可以看到，最终调用的都是Fprintf，os.Stdout代表标准输出，即控制台输出

示例：

package main

import (
	"fmt"
	"testing"
)

func TestPrint(t *testing.T) {
	fmt.Print("我是控制台打印，我不换行 可以自己控制换行\n")
}
func TestPrintln(t *testing.T) {
	fmt.Println("我是控制台打印，我换行")
}
func TestPrintf(t *testing.T) {
	fmt.Printf("我是控制台打印，%s \n", "这是格式化占位符信息,可以自己控制换行")
}


我是控制台打印，我不换行 可以自己控制换行
我是控制台打印，我换行
我是控制台打印，这是格式化占位符信息,可以自己控制换行

1.1.2 格式化占位符

1.1.2.1 通用占位符
占位符说明
%v值的默认格式表示
%+v类似%v，但输出结构体时会添加字段名
%#v值的Go语法表示
%T打印值的类型
%%百分号
type User struct {
	Id int64
}

func TestPrintf1(t *testing.T) {
	user := &User{Id: 1}
	fmt.Printf("%v\n", user)
	fmt.Printf("%+v\n", user)
	fmt.Printf("%#v\n", user)
	fmt.Printf("%T\n", user)
	fmt.Printf("%%\n")
}
func main() {
	TestPrintf1(nil)
}

&{1}
&{Id:1}
&main.User{Id:1}
*main.User
%
1.1.2.2 布尔型
占位符说明
%ttrue或false
func TestPrintf2(t *testing.T) {
	fmt.Printf("%t\n", true)
}
1.1.2.3 整型
占位符说明
%b表示为二进制
%c该值对应的unicode码值
%d表示为十进制
%o表示为八进制
%x表示为十六进制，使用a-f
%X表示为十六进制，使用A-F
%U表示为Unicode格式：U+1234，等价于”U+%04X”
%q该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示

在这里插入图片描述

func TestPrintf3(t *testing.T) {
	n := 180
	fmt.Printf("%b\n", n)
	fmt.Printf("%c\n", n)
	fmt.Printf("%d\n", n)
	fmt.Printf("%o\n", n)
	fmt.Printf("%x\n", n)
	fmt.Printf("%X\n", n)
	fmt.Printf("%U\n", n)
	a := 97
	fmt.Printf("%q\n", a)
	fmt.Printf("%q\n", 0x4E2D)
}

10110100
´
180
264
b4
B4
U+00B4
'a'
'中'
1.1.2.4 浮点数与复数
占位符说明
%b无小数部分、二进制指数的科学计数法，如-123456p-78
%e科学计数法，如-1234.456e+78
%E科学计数法，如-1234.456E+78
%f有小数部分但无指数部分，如123.456
%F等价于%f
%g根据实际情况采用%e或%f格式（以获得更简洁、准确的输出）
%G根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）
func TestPrintf4(t *testing.T) {
	f := 18.54
	fmt.Printf("%b\n", f)
	fmt.Printf("%e\n", f)
	fmt.Printf("%E\n", f)
	fmt.Printf("%f\n", f)
	fmt.Printf("%F\n", f)
	fmt.Printf("%g\n", f)
	fmt.Printf("%G\n", f)
}

5218546068215562p-48
1.854000e+01
1.854000E+01
18.540000
18.540000
18.54
18.54
1.1.2.5 字符串和[]byte
占位符说明
%s直接输出字符串或者[]byte
%q该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
%x每个字节用两字符十六进制数表示（使用a-f
%X每个字节用两字符十六进制数表示（使用A-F）
func TestPrintf5(t *testing.T) {
	s := "我是bblb"
	b := []byte{65, 66, 67}
	fmt.Printf("%s\n", s)
	fmt.Printf("%s\n", b)
	fmt.Printf("%q\n", s)
	fmt.Printf("%d\n", b)
	fmt.Printf("%q\n", b)
	fmt.Printf("%x\n", s)
	fmt.Printf("%X\n", s)
	fmt.Printf("%x\n", b)
	fmt.Printf("%X\n", b)
}

我是bblb
ABC
"我是bblb"
[65 66 67]
"ABC"
e68891e698af62626c62
E68891E698AF62626C62
414243
414243
1.1.2.6 指针
占位符说明
%p表示为十六进制，并加上前导的0x
func TestPrintf6(t *testing.T) {
    user := &User{Id: 1}
    fmt.Printf("%p\n", user)
}

0xc00000a0f8
1.1.2.7 宽度标识符
占位符说明
%10.2小数点前表示宽度，小数点后表示精度

宽度通过一个紧跟在百分号后面的十进制数指定，如果未指定宽度，则表示值时除必需之外不作填充。

精度通过（可选的）宽度后跟点号后跟的十进制数指定。如果未指定精度，会使用默认精度；如果点号后没有跟数字，表示精度为0。

占位符说明
%f默认宽度，默认精度
%10f宽度9，默认精度
%.2f默认宽度，精度2
%10.2f宽度9，精度2
%10.f宽度9，精度0
func TestPrintf6(t *testing.T) {
	n := 13.14
	fmt.Printf("%f\n", n)
	fmt.Printf("%10f\n", n)
	fmt.Printf("%10s\n", "我是字符串")
	fmt.Printf("%.2f\n", n)
	fmt.Printf("%10.2f\n", n)
	fmt.Printf("%10.f\n", n)
}

13.140000
 13.140000
     我是字符串
13.14
     13.14
        13
1.1.2.8 其他flag
占位符说明
+总是输出数值的正负号；对%q（%+q）会生成全部是ASCII字符的输出（通过转义）；
空格对数值，正数前加空格而负数前加负号；对字符串采用%x或%X时（% x或% X）会给各打印的字节之间加空格
-在输出右边填充空白而不是默认的左边（即从默认的右对齐切换为左对齐）；
#八进制数前加0（%#o），十六进制数前加0x（%#x）或0X（%#X），指针去掉前面的0x（%#p）对%q（%#q），对%U（%#U）会输出空格和单引号括起来的go字面值；
0使用0而不是空格填充，对于数值类型会把填充的0放在正负号后面；
func TestPrintf7(t *testing.T) {
	s := "我是字符串"
	fmt.Printf("%  d\n", 10)
	fmt.Printf("%s\n", s)
	fmt.Printf("%10s\n", s)
	fmt.Printf("%-10s\n", s)
	fmt.Printf("%10.2f\n", 10.14)
	fmt.Printf("%-10.2f\n", 10.14)
	fmt.Printf("%010s\n", s)
}

 10
我是字符串
     我是字符串
我是字符串
     10.14
10.14
00000我是字符串

1.1.3 Fprint

将内容输出到一个io.Writer接口类型的变量w中。

func Fprint(w io.Writer, a ...any) (n int, err error) {
	p := newPrinter()
	p.doPrint(a)
	n, err = w.Write(p.buf)
	p.free()
	return
}
func Fprintf(w io.Writer, format string, a ...any) (n int, err error) {
	p := newPrinter()
	p.doPrintf(format, a)
	n, err = w.Write(p.buf)
	p.free()
	return
}
func Fprintln(w io.Writer, a ...any) (n int, err error) {
	p := newPrinter()
	p.doPrintln(a)
	n, err = w.Write(p.buf)
	p.free()
	return
}

n是写入的字节数量，err是返回的错误

一般用在写文件中。

func TestFPrint(t *testing.T) {
	fmt.Fprintln(os.Stdout, "向标准输出写入字符串")
}

//0表示8进制 644表示权限 os.FileMode(0777).String()进行打印
	//- rwx rwx rwx -表示普通文件
	//r表示可读
	//w表示可写
	//x表示可执行
	//第1位：文件属性，一般常用的是"-"，表示是普通文件；"d"表示是一个目录。
	//第2～4位：文件所有者的权限rwx (可读/可写/可执行)。
	//第5～7位：文件所属用户组的权限rwx (可读/可写/可执行)。
	//第8～10位：其他人的权限rwx (可读/可写/可执行)。
	//在golang中，可以使用os.FileMode(perm).String()来查看权限标识：
	//os.FileMode(0777).String() //返回 -rwxrwxrwx  111 111 111
	//os.FileMode(0666).String() //返回 -rw-rw-rw-  110 110 110
	//os.FileMode(0644).String() //返回 -rw-r--r-- 
	//0777表示：创建了一个普通文件，所有人拥有所有的读、写、执行权限
	//0666表示：创建了一个普通文件，所有人拥有对该文件的读、写权限，但是都不可执行
	//0644表示：创建了一个普通文件，文件所有者对该文件有读写权限，用户组和其他人只有读权限，都没有执行权限
	s := os.FileMode(0777).String()
	fmt.Println(s)

func TestFPrint1(t *testing.T) {
	file, _ := os.OpenFile("test.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
	fmt.Fprintln(file, "追加写入")
	file.Close()
}

package main

import (
	"fmt"
	"net/http"
)

func main() {
	//输入
	http.ListenAndServe(":8088", &MyHandler{})
}

type MyHandler struct {
}

func (*MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "我是http返回的信息")
}

1.1.4 Sprint

把传入的数据生成并返回一个字符串

func Sprint(a ...any) string {
	p := newPrinter()
	p.doPrint(a)
	s := string(p.buf)
	p.free()
	return s
}
func Sprintf(format string, a ...any) string {
	p := newPrinter()
	p.doPrintf(format, a)
	s := string(p.buf)
	p.free()
	return s
}
func Sprintln(a ...any) string {
	p := newPrinter()
	p.doPrintln(a)
	s := string(p.buf)
	p.free()
	return s
}

func TestSPrint(t *testing.T) {
	s1 := fmt.Sprint("张三\n")
	name := "张三"
	age := 18
	s2 := fmt.Sprintf("name:%s,age:%d\n", name, age)
	s3 := fmt.Sprintln("张三")
	fmt.Print(s1)
	fmt.Print(s2)
	fmt.Print(s3)
}

张三
name:张三,age:18
张三

1.1.5 Errorf

根据format参数生成格式化字符串并返回一个包含该字符串的错误

func Errorf(format string, a ...any) error

func TestErrorf(t *testing.T) {
	err := fmt.Errorf("用户名格式不正确：%s", "@#￥哈哈")
	if err != nil {
		panic(err)
	}
}

1.2 输入

1.2.1 fmt.Scan

定义：

func Scan(a ...any) (n int, err error) {
	return Fscan(os.Stdin, a...)
}

含义：

从标准输入扫描文本，读取由空白符分隔的值保存到传递给本函数的参数中，换行符视为空白符

返回值：

本函数返回成功扫描的数据个数(n)和遇到的任何错误(error)

func main() {
	//空格 换行输入都可以
	var (
		name    string
		age     int
		married bool
	)
	fmt.Scan(&name, &age, &married)
	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
}

bblb 23 false
扫描结果 name:bblb age:23 married:false

1.2.2 fmt.Scanf

func Scanf(format string, a ...any) (n int, err error) {
	return Fscanf(os.Stdin, format, a...)
}

实际使用的是Fscanf

以format定义的格式来进行输入

func main() {
	var (
		name    string
		age     int
		married bool
	)
	fmt.Scanf("1:%s 2:%d 3:%t", &name, &age, &married)
	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
}

1:bblb 2:23 3:false
扫描结果 name:bblb age:23 married:false

1.2.3 fmt.Scanln

func Scanln(a ...any) (n int, err error) {
	return Fscanln(os.Stdin, a...)
}


func main() {
	var (
		name    string
		age     int
		married bool
	)
	fmt.Scanln(&name, &age, &married)
	fmt.Printf("扫描结果 name:%s age:%d married:%t \n", name, age, married)
}

遇到回车就结束扫描

1.2.4 fmt.Fsanf

func Fscanf(r io.Reader, format string, a ...any) (n int, err error) {
	s, old := newScanState(r, false, false)
	n, err = s.doScanf(format, a)
	s.free(old)
	return
}
func Fscan(r io.Reader, a ...any) (n int, err error) {
	s, old := newScanState(r, true, false)
	n, err = s.doScan(a)
	s.free(old)
	return
}
func Fscanln(r io.Reader, a ...any) (n int, err error) {
	s, old := newScanState(r, false, true)
	n, err = s.doScan(a)
	s.free(old)
	return
}

将内容从一个io.Reader接口类型的变量r中读取出来，将连续的以空格分隔的值存储到由格式确定的连续的参数中

  • **r io.Reader：**此参数包含扫描的指定文本。
  • **format string:**此参数包含用于接收元素的不同格式。
  • **a …any:**此参数是每个元素的指定变量。

**返回值：**它返回成功解析的项目数和错误

func main() {
	var (
		name    string
		age     int
		married bool
	)
	r := strings.NewReader("10 false 张三")

	n, err := fmt.Fscanf(r, "%d %t %s", &age, &married, &name)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Fscanf:%v\n", err)
	}

	fmt.Println(name, age, married)

	fmt.Println(n)
}

2 os标准库

os包提供了操作系统函数，但和操作系统无关。

os包的接口规定为在所有操作系统中都是一致的。

设计为Unix风格的。

2.1 权限说明

os标准库有大量的文件操作，在创建文件等操作中，需要指的perm。

在go语言中perm是一个uint32类型

在go语言中一般使用0777这样的形式进行表示。

  • 0代表是8进制

  • 777 是 - rwx rwx rwx的形式计算得出

权限项文件类型读写执行读写执行读写执行
字符表示（d|l|c|s|p）rwxrwxrwx
数字表示421421421
权限分配文件所有者文件所有者文件所有者文件所属组用户文件所属组用户文件所属组用户其他用户其他用户其他用户

第一位：

- : 代表这是一个普通文件(regular)
d：目录文件(directory)
l : 链接文件(link)
b: 块设备文件(block)
c: 字符设备文件(character)
s : 套接字文件(socket)
p: 管道文件(pipe)

一共有三组rwx

  • 第一组:该文件拥有者的权限
  • 第二组:该文件拥有者所在组的其他成员对该文件的操作权限
  • 第三组:其他用户组的成员对该文件的操作权限

计算过程如下:

rwxrwxrwx
111111111
777

go中的FileMode定义

type FileMode uint32

FileMode代表文件的模式和权限位。这些字位在所有的操作系统都有相同的含义，因此文件的信息可以在不同的操作系统之间安全的移植。不是所有的位都能用于所有的系统，唯一共有的是用于表示目录的ModeDir位。

const (
    // 单字符是被String方法用于格式化的属性缩写。
    ModeDir        FileMode = 1 << (32 - 1 - iota) // d: 目录
    ModeAppend                                     // a: 只能写入，且只能写入到末尾
    ModeExclusive                                  // l: 用于执行
    ModeTemporary                                  // T: 临时文件（非备份文件）
    ModeSymlink                                    // L: 符号链接（不是快捷方式文件）
    ModeDevice                                     // D: 设备
    ModeNamedPipe                                  // p: 命名管道（FIFO）
    ModeSocket                                     // S: Unix域socket
    ModeSetuid                                     // u: 表示文件具有其创建者用户id权限
    ModeSetgid                                     // g: 表示文件具有其创建者组id的权限
    ModeCharDevice                                 // c: 字符设备，需已设置ModeDevice
    ModeSticky                                     // t: 只有root/创建者能删除/移动文件
    // 覆盖所有类型位（用于通过&获取类型位），对普通文件，所有这些位都不应被设置
    ModeType = ModeDir | ModeSymlink | ModeNamedPipe | ModeSocket | ModeDevice
    ModePerm FileMode = 0777 // 覆盖所有Unix权限位（用于通过&获取类型位）
)

这些被定义的位是FileMode最重要的位。另外9个不重要的位为标准Unix rwxrwxrwx权限（任何人都可读、写、运行）。这些（重要）位的值应被视为公共API的一部分，可能会用于线路协议或硬盘标识：它们不能被修改，但可以添加新的位。

2.2 os.Create

func Create(name string) (file *File, err error)

Create采用模式0666（任何人都可读写，不可执行）创建一个名为name的文件，如果文件已存在会截断它（为空文件）。如果成功，返回的文件对象可用于I/O；对应的文件描述符具有O_RDWR模式。

如果出错，错误底层类型是*PathError

// 创建文件
func createFile() {
    f, err := os.Create("test.txt")
    if err != nil {
        fmt.Printf("err: %v\n", err)
    } else {
        fmt.Printf("f: %v\n", f)
    }
}

2.3 os.Mkdir

创建单个目录

func Mkdir(name string, perm FileMode) error {}

func mkdir() {
    err := os.Mkdir("ms", os.ModePerm)
    if err != nil {
        fmt.Printf("err: %v\n", err)
	} 
}

2.4 os.MkdirAll

创建多级目录

func MkdirAll(path string, perm FileMode) error {}

func mkdirAll() {
    err := os.MkdirAll("ms/one/two", os.ModePerm)
    if err != nil {
        fmt.Printf("err: %v\n", err)
    }
}

2.5 os.Remove

删除一个空的目录或一个文件

func Remove(name string) error {}

func removeFile() {
	err := os.Remove("test.txt")
	if err != nil {
		fmt.Printf("err: %v\n", err)
	}
}
func removeDir() {
	err := os.Remove("ms/one/two")
	if err != nil {
		fmt.Printf("err: %v\n", err)
	}
}

2.6 os.RemoveAll

强制删除目录以及目录汇中的文件

func RemoveAll(path string) error {
	return removeAll(path)
}


func removeAllDir() {
    err := os.RemoveAll("ms")
    if err != nil {
        fmt.Printf("err: %v\n", err)
    }
}

2.7 os.Getwd

获得工作目录

func Getwd() (dir string, err error) {}

func getWd() {
    dir, err := os.Getwd()
    if err != nil {
        fmt.Printf("err: %v\n", err)
    } else {
        fmt.Printf("dir: %v\n", dir)
    }
}

2.8 os.Chdir

修改工作目录

//改变工作目录到f，其中f必须为一个目录，否则便会报错
func (f *File) Chdir() error

func chDir() {
    err := os.Chdir("d:/go/project")
    if err != nil {
        fmt.Printf("err: %v\n", err)
    }
    fmt.Println(os.Getwd())
}

2.9 os.TempDir

获得临时目录

func TempDir() string {
	return tempDir()
}

func tempDir() {
    s := os.TempDir()
    fmt.Printf("s: %v\n", s)
}

2.10 os.Rename

重命名文件

func Rename(oldpath, newpath string) error {
	return rename(oldpath, newpath)
}

func renameFile() {
    err := os.Rename("test.txt", "test2.txt")
    if err != nil {
        fmt.Printf("err: %v\n", err)
    }
}
func renameDir() {
    err := os.Rename("ms", "ms1")
    if err != nil {
        fmt.Printf("err: %v\n", err)
    }
}

2.11 os.Chmod

修改文件权限

func Chmod(name string, mode FileMode) error { 
    return chmod(name, mode) 
}

func chmod() {
	err := os.Chmod("test2.txt", 0111)
	if err != nil {
		fmt.Printf("err: %v\n", err)
	}
}

打包linux测试

SET CGO_ENABLED=0
SET GOOS=linux
SET GOARCH=amd64
go build main.go

2.12 os.Chown

修改文件所有者

func Chown(name string, uid, gid int) error {}

cat /etc/passwd 查看uid和gid

func chown() {
	err := os.Chown("test2.txt", 10, 10)
	if err != nil {
		fmt.Printf("err: %v\n", err)
	}
}

2.13 文件

打开模式

const (
    O_RDONLY int = syscall.O_RDONLY // 只读模式打开文件
    O_WRONLY int = syscall.O_WRONLY // 只写模式打开文件
    O_RDWR   int = syscall.O_RDWR   // 读写模式打开文件
    O_APPEND int = syscall.O_APPEND // 写操作时将数据附加到文件尾部
    O_CREATE int = syscall.O_CREAT  // 如果不存在将创建一个新文件
    O_EXCL   int = syscall.O_EXCL   // 和O_CREATE配合使用，文件必须不存在
    O_SYNC   int = syscall.O_SYNC   // 打开文件用于同步I/O
    O_TRUNC  int = syscall.O_TRUNC  // 如果可能，打开时清空文件
)


 // 创建一个空文件，注意当文件已经存在时，会直接覆盖掉原文件，不会报错
func Create(name string) (file *File, err error)
// 打开一个文件,注意打开的文件只能读，不能写
func Open(name string) (file *File, err error) 
// 以指定的权限打开文件
func OpenFile(name string, flag int, perm FileMode) (file *File, err error) 
// 关闭文件，关闭后不可读写
func (f *File) Close() error

其实os.Create 等价于：OpenFile(name, O_RDWF|O_CREATE|O_TRUNK, 0666)

func openClose() {
	f, err := os.OpenFile("test2.txt", os.O_RDWR|os.O_CREATE, 0755)
	if err != nil {
		panic(err)
	}
	fmt.Println("file name : ", f.Name())
	defer f.Close()

}

2.13.1 文件读取

// 获取文件的信息，里面有文件的名称，大小，修改时间等
func (f *File) Stat() (fi FileInfo, err error) 
// 从文件中一次性读取b大小的数据，当读到文件结尾时，返回一个EOF错误
func (f *File) Read(b []byte) (n int, err error) 
// 从文件中指定的位置(off)一次性读取b大小的数据
func (f *File) ReadAt(b []byte, off int64) (n int, err error) 
// 读取目录并返回排好序的文件以及子目录名切片
func ReadDir(name string) ([]DirEntry, error) 
//Seek设置下一次读/写的位置。offset为相对偏移量，而whence决定相对位置：0为相对文件开头，1为相对当前位置，2为相对文件结尾。它返回新的偏移量（相对开头）和可能的错误。
func (f *File) Seek(offset int64, whence int) (ret int64, err error)


type FileInfo interface {
    Name() string       // 文件的名字（不含扩展名）
    Size() int64        // 普通文件返回值表示其大小；其他文件的返回值含义各系统不同
    Mode() FileMode     // 文件的模式位
    ModTime() time.Time // 文件的修改时间
    IsDir() bool        // 等价于Mode().IsDir()
    Sys() interface{}   // 底层数据来源（可以返回nil）
}

func fileStat() {
	f, err := os.OpenFile("test2.txt", os.O_RDWR|os.O_CREATE, 0755)
	if err != nil {
		panic(err)
	}
	defer f.Close()
	fileInfo, err := f.Stat()
	if err != nil {
		panic(err)
	}
	fmt.Printf("file info : %#v", fileInfo)
}

func fileRead() {
	f, err := os.OpenFile("test2.txt", os.O_RDWR|os.O_CREATE, 0755)
	if err != nil {
		panic(err)
	}
	defer f.Close()
	var body []byte
	for {
		buf := make([]byte, 4)
		n, err := f.Read(buf)
		if err == io.EOF {
			//读完了
			break
		}
		fmt.Printf("读到的位置:%d \n", n)
		body = append(body, buf[:n]...)
	}
	fmt.Printf("内容：%s \n", body)
}

func fileReadAt() {
	f, err := os.OpenFile("test2.txt", os.O_RDWR|os.O_CREATE, 0755)
	if err != nil {
		panic(err)
	}
	defer f.Close()
	buf := make([]byte, 5)
	n, err := f.ReadAt(buf, 6)
	fmt.Printf("内容：%s \n", buf[:n])
}

func fileReadDir() {
	f, err := os.Open("ms1")
	if err != nil {
		panic(err)
	}
	defer f.Close()
	//-1代表所有
	dirs, err := f.ReadDir(-1)
	if err != nil {
		panic(err)
	}
	for _, v := range dirs {
		fmt.Println("is dir:", v.IsDir())
		fmt.Println("dir name :", v.Name())
	}
}

func fileSeek() {
	f, err := os.OpenFile("test2.txt", os.O_RDWR|os.O_CREATE, 0755)
	if err != nil {
		panic(err)
	}
	defer f.Close()
	f.Seek(3, 0)
	buf := make([]byte, 10)
	n, _ := f.Read(buf)
	fmt.Printf("读取内容:%s\n", buf[:n])
}

2.13.2 文件写

//Write向文件中写入len(b)字节数据。它返回写入的字节数和可能遇到的任何错误。如果返回值n!=len(b)，本方法会返回一个非nil的错误。
func (f *File) Write(b []byte) (n int, err error)
//WriteString类似Write，但接受一个字符串参数。
func (f *File) WriteString(s string) (ret int, err error)
//WriteAt在指定的位置（相对于文件开始位置）写入len(b)字节数据。它返回写入的字节数和可能遇到的任何错误。如果返回值n!=len(b)，本方法会返回一个非nil的错误。
func (f *File) WriteAt(b []byte, off int64) (n int, err error)


func fileWrite() {
	f, err := os.OpenFile("test2.txt", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0755)
	if err != nil {
		panic(err)
	}
	defer f.Close()
	f.Write([]byte("hello golang~\n"))
	f.WriteString("hello golang~\n")
}

func fileWriteAt() {
	f, err := os.OpenFile("test2.txt", os.O_RDWR|os.O_CREATE, 0755)
	if err != nil {
		panic(err)
	}
	defer f.Close()
	_, err = f.WriteAt([]byte(" insert content~\n"), 5)
	fmt.Println(err)
}

2.14 进程相关

// 让当前程序以给出的状态码（code）退出。一般来说，状态码0表示成功，非0表示出错。程序会立刻终止，defer的函数不会被执行。
func Exit(code int) 
// 获取调用者的用户id
func Getuid() int 
// 获取调用者的有效用户id
func Geteuid() int 
 // 获取调用者的组id
func Getgid() int
// 获取调用者的有效组id
func Getegid() int 
// 获取调用者所在的所有组的组id
func Getgroups() ([]int, error) 
// 获取调用者所在进程的进程id
func Getpid() int 
// 获取调用者所在进程的父进程的进程id
func Getppid() int 


func osInfo() {
	// 获得当前正在运行的进程id
	fmt.Println("---------")
	fmt.Printf("os.Getpid(): %v\n", os.Getpid())
	// 父id
	fmt.Printf("os.Getppid(): %v\n", os.Getppid())

	// 设置新进程的属性
	attr := &os.ProcAttr{
		// files指定新进程继承的活动文件对象
		// 前三个分别为，标准输入、标准输出、标准错误输出
		Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
		// 新进程的环境变量
		Env: os.Environ(),
	}

	// 开始一个新进程
	p, err := os.StartProcess("c:\\windows\\system32\\notepad.exe", []string{"c:\\windows\\system32\\notepad.exe", "d:\\test.txt"}, attr)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(p)
	fmt.Println("进程ID：", p.Pid)

	// 通过进程ID查找进程
	p2, _ := os.FindProcess(p.Pid)
	fmt.Println(p2)

	// 等待10秒，执行函数
	time.AfterFunc(time.Second*10, func() {
		// 向p进程发出退出信号
		p.Signal(os.Kill)
	})

	// 等待进程p的退出，返回进程状态
	ps, _ := p.Wait()
	fmt.Println(ps.String())
}

type Signal

type Signal interface {
    String() string
    Signal() // 用来区分其他实现了Stringer接口的类型
}

Signal代表一个操作系统信号。一般其底层实现是依赖于操作系统的：在Unix中，它是syscall.Signal类型。

var (
    Interrupt Signal = syscall.SIGINT
    Kill      Signal = syscall.SIGKILL
)

仅有的肯定会被所有操作系统提供的信号，Interrupt（中断信号）和Kill（强制退出信号）。

var (
    ErrInvalid    = errors.New("invalid argument")
    ErrPermission = errors.New("permission denied")
    ErrExist      = errors.New("file already exists")
    ErrNotExist   = errors.New("file does not exist")
)

一些可移植的、共有的系统调用错误。

var (
    Stdin  = NewFile(uintptr(syscall.Stdin), "/dev/stdin")
    Stdout = NewFile(uintptr(syscall.Stdout), "/dev/stdout")
    Stderr = NewFile(uintptr(syscall.Stderr), "/dev/stderr")
)

Stdin、Stdout和Stderr是指向标准输入、标准输出、标准错误输出的文件描述符。

var Args []string

Args保管了命令行参数，第一个是程序名。

2.14.1 Signal

func main() {
	go a()
	go b()
	ch := make(chan os.Signal)
	signal.Notify(ch, os.Kill, os.Interrupt)
	c := <-ch
	log.Println(c)
}

func b() {
	fmt.Println("b")
}

func a() {
	fmt.Println("a")
}

2.15 环境相关

// 获取主机名
func Hostname() (name string, err error) 
// 获取某个环境变量
func Getenv(key string) string  
// 设置一个环境变量,失败返回错误，经测试当前设置的环境变量只在 当前进程有效（当前进程衍生的所有的go程都可以拿到，子go程与父go程的环境变量可以互相获取）；进程退出消失
func Setenv(key, value string) error 
// 删除当前程序已有的所有环境变量。不会影响当前电脑系统的环境变量，这些环境变量都是对当前go程序而言的
func Clearenv() 


func osEnv() {
	// 获得所有环境变量
	s := os.Environ()
	fmt.Printf("s: %v\n", s)
	// 获得某个环境变量
	s2 := os.Getenv("GOPATH")
	fmt.Printf("s2: %v\n", s2)
	// 设置环境变量
	os.Setenv("env1", "env1")
	s2 = os.Getenv("aaa")
	fmt.Printf("s2: %v\n", s2)
	fmt.Println("--------------")

	// 查找
	s3, b := os.LookupEnv("env1")
	fmt.Printf("b: %v\n", b)
	fmt.Printf("s3: %v\n", s3)

	// 清空环境变量# 
	// os.Clearenv()
}

3 time标准库

时间在日常编程中使用非常多。time标准库中日历的计算采用的是公历

3.1 Time类型

  • Time代表一个纳秒精度的时间点。

  • 程序中应使用Time类型值来保存和传递时间，而不能用指针。就是说，表示时间的变量和字段，应为time.Time类型，而不是*time.Time.类型。

  • 一个Time类型值可以被多个goroutine同时使用。

  • 时间点可以使用Before、After和Equal方法进行比较。

  • Sub方法让两个时间点相减，生成一个Duration类型值（代表时间段）。

  • Add方法给一个时间点加上一个时间段，生成一个新的Time类型时间点。

  • Time零值代表时间点January 1, year 1, 00:00:00.000000000 UTC。因为本时间点一般不会出现在使用中，IsZero方法提供了检验时间是否显式初始化的一个简单途径。

  • 每一个时间都具有一个地点信息（及对应地点的时区信息），当计算时间的表示格式时，如Format、Hour和Year等方法，都会考虑该信息。

  • Local、UTC和In方法返回一个指定时区（但指向同一时间点）的Time。修改地点/时区信息只是会改变其表示；不会修改被表示的时间点，因此也不会影响其计算。

func timeDemo() {
	now := time.Now() //获取当前时间
	fmt.Printf("current time:%v\n", now)

	year := now.Year()     //年
	month := now.Month()   //月
	day := now.Day()       //日
	hour := now.Hour()     //小时
	minute := now.Minute() //分钟
	second := now.Second() //秒
	//02d输出的整数不足两位 用0补足
	fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}

current time:2025-01-07 15:17:37.3931982 +0800 CST m=+0.000503101

3.2 时间戳

时间戳是自1970年1月1日0时0分0秒至当前时间的总毫秒数。它也被称为Unix时间戳（UnixTimestamp）。

这里指的是UTC时间，比北京时间晚8个小时。

func timestampDemo() {
    now := time.Now()            //获取当前时间
    timestamp1 := now.Unix()     //时间戳
    timestamp2 := now.UnixNano() //纳秒时间戳
    fmt.Printf("current timestamp1:%v\n", timestamp1)
    fmt.Printf("current timestamp2:%v\n", timestamp2)
}

current timestamp1:1736234366
current timestamp2:1736234366304093900

3.3 Parse解析时间

func Parse(layout, value string) (Time, error)

解析一个格式化的时间字符串并返回它代表的时间，如果缺少表示时区的信息，Parse会将时区设置为UTC。

func ParseInLocation(layout, value string, loc *Location) (Time, error)

ParseInLocation类似Parse但有两个重要的不同之处。第一，当缺少时区信息时，Parse将时间解释为UTC时间，而ParseInLocation将返回值的Location设置为loc；第二，当时间字符串提供了时区偏移量信息时，Parse会尝试去匹配本地时区，而ParseInLocation会去匹配loc。

layout的时间必须是"2006-01-02 15:04:05"这个时间，当然格式不一定是这个，时间一定得是，这是go诞生的时间

func timeParse() {
	t, err := time.Parse("2006-01-02 15:04:05", "2022-07-28 18:06:00")
	if err != nil {
		panic(err)
	}
	fmt.Println(t)
	now := time.Now()
	fmt.Println(now)
	// 加载时区
	loc, err := time.LoadLocation("Asia/Shanghai")
	if err != nil {
		fmt.Println(err)
		return
	}
	// 按照指定时区和指定格式解析字符串时间
	timeObj, err := time.ParseInLocation("2006/01/02 15:04:05", now.Format("2006/01/02 15:04:05"), loc)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(timeObj)

}

2025-01-07 18:06:00 +0000 UTC
2025-01-07 15:20:56.4819929 +0800 CST m=+0.000503901
2025-01-07 15:20:56 +0800 CST

3.4 格式化时间

func (t Time) Format(layout string) string

Format根据layout指定的格式返回t代表的时间点的格式化文本表示。

func timeFormat() {
	now := time.Now()
	// 格式化的模板为Go的出生时间2006年1月2号15点04分05秒
	// 24小时制
	fmt.Println(now.Format("2006-01-02 15:04:05.000"))
	// 12小时制
	fmt.Println(now.Format("2006-01-02 03:04:05"))
	fmt.Println(now.Format("2006/01/02 15:04"))
	fmt.Println(now.Format("15:04 2006/01/02"))
	fmt.Println(now.Format("2006/01/02"))
}

2025-01-07 16:03:25.198
2025-01-07 04:03:25
2025/01/07 16:03
16:03 2025/01/07
2025/01/07

3.5 time.Unix()

func Unix(sec int64, nsec int64) Time

Unix创建一个本地时间，对应sec和nsec表示的Unix时间（从January 1, 1970 UTC至该时间的秒数和纳秒数）。

nsec的值在[0, 999999999]范围内是合法的。

func timestampDemo2(timestamp int64) {
    timeObj := time.Unix(timestamp, 0) //将时间戳转为时间格式
    fmt.Println(timeObj)
    year := timeObj.Year()     //年
    month := timeObj.Month()   //月
    day := timeObj.Day()       //日
    hour := timeObj.Hour()     //小时
    minute := timeObj.Minute() //分钟
    second := timeObj.Second() //秒
    fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}

timestampDemo2(1609430400)
2021-01-01 00:00:00 +0800 CST
2021-01-01 00:00:00

3.6 时间间隔

time.Duration是time包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。time.Duration表示一段时间间隔，可表示的最长时间段大约290年。

time包中定义的时间间隔类型的常量如下：

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

例如：time.Duration表示1纳秒，time.Second表示1秒。

3.7 时间计算

3.7.1 Add

func (t Time) Add(d Duration) Time

Add返回时间点t+d。

func main() {
    now := time.Now()
    later := now.Add(time.Hour) // 当前时间加1小时后的时间
    fmt.Println(later)
}

3.7.2 Sub

求两个时间之间的差值

    func (t Time) Sub(u Time) Duration

返回一个时间段t-u。如果结果超出了Duration可以表示的最大值/最小值，将返回最大值/最小值。

要获取时间点t-d（d为Duration），可以使用t.Add(-d)。

func main() {
    now := time.Now()
    later := now.Add(time.Hour) // 当前时间加1小时后的时间
    ret := later.Sub(now)
    fmt.Println(ret)
}

3.7.3 Equal

func (t Time) Equal(u Time) bool

判断两个时间是否相同，会考虑时区的影响，因此不同时区标准的时间也可以正确比较。

本方法和用t==u不同，这种方法还会比较地点和时区信息。

3.7.4 Before

func (t Time) Before(u Time) bool

如果t代表的时间点在u之前，返回真；否则返回假。

3.7.5 After

func (t Time) After(u Time) bool

如果t代表的时间点在u之后，返回真；否则返回假。

3.8 定时器

使用time.Tick(时间间隔)来设置定时器，定时器的本质上是一个通道（channel）

func tickDemo() {
    ticker := time.Tick(time.Second) //定义一个1秒间隔的定时器
    for i := range ticker {
        fmt.Println(i)//每秒都会执行的任务
    }
}

time.AfterFunc(time.Second*10, func() {
		 fmt.Println("10秒后执行")
})

func main() {
	var wg sync.WaitGroup
	wg.Add(2)
	//NewTimer 创建一个 Timer，它会在最少过去时间段 d 后到期，向其自身的 C 字段发送当时的时间
	//2秒后触发
	timer1 := time.NewTimer(2 * time.Second)

	//NewTicker 返回一个新的 Ticker，该 Ticker 包含一个通道字段，并会每隔时间段 d 就向该通道发送当时的时间。它会调
	//整时间间隔或者丢弃 tick 信息以适应反应慢的接收者。如果d <= 0会触发panic。关闭该 Ticker 可
	//以释放相关资源。
	//每隔2秒触发一次
	ticker1 := time.NewTicker(2 * time.Second)

	go func(t *time.Ticker) {
		defer wg.Done()
		for {
			<-t.C
			fmt.Println("get ticker1", time.Now().Format("2006-01-02 15:04:05"))
		}
	}(ticker1)

	go func(t *time.Timer) {
		defer wg.Done()
		for {
			<-t.C
			fmt.Println("get timer", time.Now().Format("2006-01-02 15:04:05"))
			//Reset 使 t 重新开始计时，（本方法返回后再）等待时间段 d 过去后到期。如果调用时t
			//还在等待中会返回真；如果 t已经到期或者被停止了会返回假。
			//重置定时器，相当于使其变成周期性定时器
			t.Reset(2 * time.Second)
		}
	}(timer1)

	wg.Wait()
}

sync.WaitGroup：

  • sync.WaitGroup 用来等待一组 goroutine 完成。wg.Add(2) 表示等待 2 个 goroutine 完成任务，wg.Done() 用来标记 goroutine 完成，wg.Wait() 用来阻塞当前 goroutine，直到所有 goroutine 完成。

time.Timer 和 time.Ticker：

  • time.NewTimer(d)：创建一个定时器，等待 d 时间后向其 C 通道发送当前时间（只会触发一次）。
  • time.NewTicker(d)：创建一个定时器，每隔 d 时间向其 C 通道发送当前时间。它会持续触发，直到显式停止。

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
Java中怎样将Json字符串转换成实体类
css基础属性及BootStrap的引入
MYSQL 多表创建视图
【网络篇】计算机网络——网络层详述（笔记）
springboot+maven+tomcat问题
晨辉考试抽签软件的两种抽签方法之一：批量抽签
判断完全二叉树
C语言常见字符函数和字符串函数精讲
超详解|yoloV8训练自己的数据集|训练|测试|部署
VUE+Ant Design Vue+.Net Core搭建后台框架-(10)系统登录
;