go入门随手记

init 函数 和main总结

1、这两个函数都是go语言的保留函数， init 用于初始化信息 main 作为程序的入口

2、这两个函数定义的时候，都不能有参数，返回值。只能由go程序调用，不能被引用

3、init 函数可以定义在任意包中，可以有多个。 main 函数只能在main包下，并且只能有一个

4、执行顺序

a、先执行init 后执行main

b、对于同一个go文件调用顺序从上到下， 也就是说先被调用的先执行

c、对于同一个包下，将文件名按照字符串进行排序，之后调用各个文件中init函数

d、对于不同包下：

​ 如果不存在依赖，经按照main包中import顺序来调用对应包中init函数

​ 如果存在依赖， 最后被依赖的最优先被初始化

​ 导入顺序： main->A->B->C

​ 执行循序： C->B->A->main

5、存在依赖的包之间，不能循坏导入

6、一个被可以重复被多个包import,但只能初始化一次

7、只想执行某个包的init可以通过 空白标识符 _ 接收包

mysql数据库链接

package main

import (
	"database/sql"
	"fmt"

	_ "github.com/go-sql-driver/mysql"
)

func main() {
   
	db, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/test?charset=utf8")
	if err != nil {
   
		fmt.Println("err:", err)
		return
	}
	fmt.Println("连接成功:", db)

}

time包

package main

import (
	"fmt"
	"time"
)

func main() {
   

	/*
		time 包
		1年 = 365 天
		1天=24 小时
		1 小时 = 60分
	*/

	// 1 获取当前时间
	t1 := time.Now()
	fmt.Printf("type is %T\n value:%v\n", t1, t1)
	// 	type is time.Time
	//  value:2021-08-30 16:40:11.800883 +0800 CST m=+0.008589101

	// 2 获取指定时间
	t2 := time.Date(2008, 8, 30, 16, 42, 30, 0, time.Local)
	fmt.Println(t2)

	// 3 格式化时间 “2006年1月2号 15:04:05”为模板数字固定，纪念go语言诞生时间
	s1 := t1.Format("2006年1月2号 15:04:05")
	fmt.Println(s1)
	s2 := t1.Format("2006/1/2")
	fmt.Println(s2)

	// 4 字符串时间解析 解析格式需与待解析格式一致
	s3 := "2009年1月2号"
	t3, err := time.Parse("2006年1月2号", s3)
	if err != nil {
   
		fmt.Println("err:", err)
	}
	fmt.Printf("t3 type is %T\n", t3)
	fmt.Println(t3)

	// 5、根据时间获取指定内容
	year, month, day := t1.Date() // 年 月 日
	fmt.Println(year, month, day)

	hour, min, sec := t1.Clock()
	fmt.Println(hour, min, sec)
	fmt.Println("年", t1.Year())
	fmt.Println("月", t1.Month())
	fmt.Println("天", t1.Day())
	fmt.Println("星期", t1.Weekday())
	fmt.Println("时", t1.Hour())
	fmt.Println("分", t1.Minute())
	fmt.Println("秒：", t1.Unix())

	// 6、时间间隔
	t5 := t1.Add(time.Hour) // 一小时后
	fmt.Println(t5.Hour())

	// 7、睡眠
	time.Sleep(3 * time.Second) // 睡眠3分钟
}

文件操作

package main

import (
	"fmt"
	"os"
)

func main() {
   

	fileInfo, err := os.Stat("./test.txt")
	if err != nil {
   
		fmt.Println("err:", err)
		return
	}
	fmt.Printf("type:%T\n", fileInfo)
	// 文件名
	fmt.Println(fileInfo.Name())
	// 文件大小
	fmt.Println(fileInfo.Size())
	// 是否是目录
	fmt.Println(fileInfo.IsDir())
	// 文件修改时间
	fmt.Println(fileInfo.ModTime())

}

package main

import (
	"fmt"
	"os"
	"path/filepath"
)

func main() {
   

	path1 := "D:/Golang/src/demo/utils/utils.go"
	path2 := "./test.txt"

	// 获取文件是否是绝对路径路径
	fmt.Println(filepath.IsAbs(path1))
	fmt.Println(filepath.IsAbs(path2))
	// 获取文件的绝对路径
	fmt.Println(filepath.Abs(path1))
	// 获取文件的父级目录
	fmt.Println("获取父级目录：", filepath.Join(path1, ".."))
	// 创建目录 // 在文件夹不存在情况下 只能创建一层
	err0 := os.Mkdir("D:/Golang/src/demo/test", os.ModePerm)
	if err0 != nil {
   
		fmt.Println("err:", err0)
		return
	}
	// 递归创建文件夹 能创建多层
	err := os.MkdirAll("D:/Golang/src/demo/test1/lala", os.ModePerm)
	if err != nil {
   
		fmt.Println("err:", err)
		return
	}
	// 创建文件 文件路径：绝对或相对路径都可以
	file1, err := os.Create("./test.go")
	if err != nil {
   
		fmt.Println("err:", err)
		return
	}
	fmt.Println(file1)
	//创建文件 文件路径：绝对或相对路径都可以
	file2, err := os.Create("./test.go")
	if err != nil {
   
		fmt.Println("err:", err)
		return
	}
	fmt.Println(file2)
	// O_RDONLY int = syscall.O_RDONLY // open the file read-only.
	// O_WRONLY int = syscall.O_WRONLY // open the file write-only.
	// O_RDWR   int = syscall.O_RDWR   // open the file read-write.
	// // The remaining values may be or'ed in to control behavior.
	// O_APPEND int = syscall.O_APPEND // append data to the file when writing.
	// O_CREATE int = syscall.O_CREAT  // create a new file if none exists.
	// O_EXCL   int = syscall.O_EXCL   // used with O_CREATE, file must not exist.
	// O_SYNC   int = syscall.O_SYNC   // open for synchronous I/O.
	// O_TRUNC  int = syscall.O_TRUNC  // truncate regular writable file when opened.

	// 打开文件
	file2, err2 := os.OpenFile("./test.go", os.O_RDONLY|os.O_WRONLY, os.ModePerm)
	if err2 != nil {
   
		fmt.Println("err:", err)
		return
	}
	//关闭文件
	file2.Close()

	// 删除空文件夹
	err3 := os.Remove("./test.go")
	if err3 != nil {
   
		fmt.Println("err:", err3)
		return
	}

	// 递归删除 [慎重]
	err4 := os.RemoveAll("./utils")
	if err4 != nil {
   
		fmt.Println("err:", err4)
		return
	}
}

IO读数据

package main

import (
	"fmt"
	"io"
	"os"
)

func main() {
   
	/*
		io 包
		文件操作
		1、打开文件
		2、读取数据
		3、关闭文件
	*/
	fileName := "./test.txt"
	file, err := os.Open(fileName)
	if err != nil {
   
		fmt.Println("err:", err)
		return
	}

	//defer 关闭文件
	defer file.Close()

	bs := make([]byte, 4, 4)
	/*
		n, err := file.Read(bs)
		if err != nil {
			fmt.Println("err:", err)
			return
		}
		第一次
		fmt.Println(err)
		fmt.Println(n)
		fmt.Println(string(bs))
		第二次
		n, err = file.Read(bs)
		fmt.Println(err)
		fmt.Println(n)
		fmt.Println(string(bs))
		第三次
		n, err = file.Read(bs)
		fmt.Println(err)
		fmt.Println(n)
		fmt.Println(string(bs))
		第四次
		n, err = file.Read(bs)
		fmt.Println(err)
		fmt.Println(n)
		fmt.Println(string(bs))
	*/
	// n := -1
	for {
   
		n, err := file.Read(bs)
		if n == 0 || err == io.EOF {
   
			fmt.Println("文件读取...end")
			break
		}
		fmt.Println(string(bs[:n]))
	}
}

IO写数据

package main

import (
	"fmt"
	"os"
)

func main() {
   
	/*
		io 写入数据
		文件操作
		1、打开文件
		2、读取数据
		3、关闭文件
	*/
	fileName := "./test1.txt"
	// 读取，不能写入
	// file, err := os.Open(fileName)
	// 设置写、新建权限方式
	// os.O_APPEND 文件末尾追加   os.O_WRONLY 文件写入 【不追加时会重头覆盖写入】 os.O_CREAT 不存在创建
	file, err := os.OpenFile(fileName, os.O_WRONLY|os.O_CREATE|os.O_APPEND, os.ModePerm)

	if err != nil {
   
		fmt.Println("err:", err)
		return
	}
	defer file.Close()

	// bs := []byte{65, 66, 67, 68} // A/B/C/D 对应的字节编码
	bs := []byte{
   97, 98, 99, 100} // a/b/c/d 对应的字节编码

	n, err := file.Write(bs)
	fmt.Println(err)
	fmt.Println(n)

	// 换行
	file.WriteString("\n")
	n, err = file.WriteString("hello world !")
	fmt.Println(err)
	fmt.Println(n)
	// 写入字节
	n, err = file.Write([]byte("today"))
	fmt.Println(err)
	fmt.Println(n)
}



func CopyFile1(srcFile, destFile string) (int, error) {
   
	file1, err := os.Open(srcFile)
	if err != nil {