打印输出 | A-Zero

# 打印输出

import "fmt"

// Println 中间有空格 Print 没有
fmt.Println("go", "python", "php", "javascript") // go python php javascript
fmt.Print("go", "python", "php", "javascript") // gopythonphpjavascript

// Println 会自动换行，Print 不会
func main() {
	fmt.Println("hello")
	fmt.Println("world")
	// hello
	// world
	
	fmt.Print("hello")
	fmt.Print("world")
	// helloworld
}

// Printf 是格式化输出
a := 10
b := 20
c := 30
fmt.Println("a=", a, ",b=", b, ",c=", c) // a= 10 ,b= 20 ,c= 30
fmt.Printf("a=%d,b=%d,c=%d", a, b, c)   // a=10,b=20,c=30

# 时间处理

当前时间

now := time.Now() // 获取当前时间
fmt.Printf("当前时间:%v\n", now)
fmt.Printf("年:%v\n", now.Year())
fmt.Printf("月:%v\n", now.Month())
fmt.Printf("日:%v\n", now.Day())
fmt.Printf("时:%v\n", now.Hour())
fmt.Printf("分:%02d\n", now.Minute())
fmt.Printf("秒:%02d\n", now.Second())
fmt.Printf("星期:%v\n", now.Weekday())
fmt.Printf("纳秒:%v\n", now.Nanosecond())
fmt.Printf("时间戳:%v\n", now.Unix())

Format 方法格式化输出日期字符串

now := time.Now()
// 格式化的模板为 Go 的出生时间 2006 年 1 月 2 号 15 点 04 分Mon Jan
// 24 小时制
fmt.Println(now.Format("2006-01-02 15:04:05"))
// 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"))

时间戳转换为日期字符串

func unixToTime1(timestamp int64) {
	timeObj := time.Unix(timestamp, 0) // 将时间戳转为时间格式
	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)
}
func unixToTime2(timestamp int64) {
	timeObj := time.Unix(timestamp, 0) // 将时间戳转为时间格式
	fmt.Println(t.Format("2006-01-02 03:04:05")) // 日期格式化输出
}
func main() {
	unixToTime1(1587880013)
	unixToTime2(1587880013)
}

日期字符串转换成时间戳

t1 := "2019-01-08 13:50:30"
timeTemplate := "2006-01-02 15:04:05" // 常规类型
stamp, _ := time.ParseInLocation(timeTemplate , t1, time.Local)
fmt.Println(stamp.Unix())

时间操作函数

now := time.Now()
later := now.Add(time.Hour) // 当前时间加 1 小时后的时间
fmt.Println("1小时后的时间:", later)

difference := later.Sub(now)
fmt.Println("时间差:", difference.Hours())

later.Before(now) // 判断 later 是否在 now 之前
fmt.Println("later 是否在 now 之前:", later.Before(now))

定时器

// 使用 time.NewTicker(时间间隔)来设置定时器
ticker := time.NewTicker(time.Second) //定义一个 1 秒间隔的定时器
n := 0
for i := range ticker.C {
	fmt.Println(i) //每秒都会执行的任务
	n++
	if n > 5 {
		ticker.Stop()
		return
	}
}

// time.Sleep(time.Second) 来实现定时器
for {
	time.Sleep(time.Second)
	fmt.Println("我在定时执行任务")
}

# 文件操作

# 文件基本操作

打开和关闭文件

// os.Open()以只读方式打开一个文件，返回一个*File 和一个 err
// 操作完成文件对象以后一定要记得关闭文件
file, err := os.Open("./go.mod")
if err != nil {
	fmt.Println("open file failed!, err:", err)
	return
}
fmt.Println(file)  // &{0xc000078780}
// 为了防止文件忘记关闭，我们通常使用 defer 注册文件关闭语句
defer file.Close()

创建并写入文件

// 直接写入全部内容（会覆盖原有内容）
data := []byte("Hello, Go!\n第二行内容")
err := os.WriteFile("example.txt", data, 0644)
if err != nil {
	panic(err)
}

// 以追加模式打开并写入
f, err := os.OpenFile("example.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
	panic(err)
}
defer f.Close()
_, err = f.WriteString("\n追加一行")
if err != nil {
	panic(err)
}

读取文件

// 一次性读取整个文件
content, err := os.ReadFile("example.txt")
if err != nil {
	panic(err)
}
fmt.Println(string(content))

// 按行读取（使用 bufio）
f, err := os.Open("example.txt")
if err != nil {
	panic(err)
}
defer f.Close()

scanner := bufio.NewScanner(f)
for scanner.Scan() {
	fmt.Println("行:", scanner.Text())
}
if err := scanner.Err(); err != nil {
	panic(err)
}

删除文件

err := os.Remove("example.txt")
if err != nil {
    panic(err)
}

重命名

err := os.Rename("old.txt", "new.txt")
if err != nil {
    panic(err)
}

# 目录操作

// 创建单层目录
err := os.Mkdir("mydir", 0755)
if err != nil {
	panic(err)
}

// 创建多层目录
err = os.MkdirAll("path/to/deep/dir", 0755)
if err != nil {
	panic(err)
}

// 删除空目录
err := os.Remove("mydir")
if err != nil {
	panic(err)
}

// 递归删除整个目录树
err = os.RemoveAll("path/to/deep")
if err != nil {
	panic(err)
}

entries, err := os.ReadDir(".")
if err != nil {
	panic(err)
}
for _, entry := range entries {
	fmt.Printf("名称: %s, 是否目录: %v\n", entry.Name(), entry.IsDir())
	// 如需获取详细信息，可调用 entry.Info()
	info, _ := entry.Info()
	fmt.Printf("  大小: %d, 修改时间: %v\n", info.Size(), info.ModTime())
}

err := filepath.WalkDir(".", func(path string, d fs.DirEntry, err error) error {
	if err != nil {
		return err
	}
	fmt.Printf("路径: %s, 是否为目录: %v\n", path, d.IsDir())
	return nil
})
if err != nil {
	panic(err)
}

# 路径操作

路径拼接、拆分

// 平台无关的路径拼接
fullPath := filepath.Join("dir", "subdir", "file.txt")
fmt.Println(fullPath) // 输出: dir/subdir/file.txt (Windows 下为 dir\subdir\file.txt)

// 获取目录和文件名
dir, file := filepath.Split("dir/subdir/file.txt")
fmt.Printf("目录: %q, 文件: %q\n", dir, file) // 目录: "dir/subdir/", 文件: "file.txt"

// 获取绝对路径
abs, err := filepath.Abs(".")
if err != nil {
    panic(err)
}
fmt.Println("绝对路径:", abs)

检查路径是否存在

func pathExists(path string) (bool, error) {
    _, err := os.Stat(path)
    if err == nil {
        return true, nil
    }
    if os.IsNotExist(err) {
        return false, nil
    }
    return false, err
}

← 基础知识