【Go】异常处理、泛型和文件操作

🌈 个人主页：Zfox_

🔥 系列专栏：Go

[一：🔥 异常处理](#一：🔥 异常处理)
- [🦋 常见的异常处理](#🦋 常见的异常处理)
- - [🎀 向上抛](#🎀 向上抛)
  - [🎀 中断程序](#🎀 中断程序)
  - [🎀 恢复程序](#🎀 恢复程序)
[二：🔥 泛型](#二：🔥 泛型)
- [🦋 泛型函数](#🦋 泛型函数)
- [🦋 泛型结构体](#🦋 泛型结构体)
- [🦋 泛型切片](#🦋 泛型切片)
- [🦋 泛型 map](#🦋 泛型 map)
[三：🔥 文件操作](#三：🔥 文件操作)
- [🦋 文件读取](#🦋 文件读取)
- [🦋 文件写入](#🦋 文件写入)
[四：🔥 共勉](#四：🔥 共勉)

一：🔥 异常处理

go的异常处理可能是这门语言唯一的一个诟病了吧

由于 go 语言没有捕获异常的机制，导致每调一个函数都要接一下这个函数的 error

网上有个梗，叫做 error 是 go 的一等公民

🦋 常见的异常处理

🎀 向上抛

将错误交给上一级处理

一般是用于框架层，有些错误框架层面不能擅做决定，将错误向上抛不失为一个好的办法

go 复制代码

package main

import (
  "errors"
  "fmt"
)

func Parent() error {
  err := method() // 遇到错误向上抛
  return err
}
func method() error {
  return errors.New("出错了")
}

func main() {
  fmt.Println(Parent())
}

🎀 中断程序

遇到错误直接停止程序

这种一般是用于初始化，一旦初始化出现错误，程序继续走下去也意义不大了，还不如中断掉

go 复制代码

package main

import (
  "fmt"
  "os"
)

func init() {
  // 读取配置文件中，结果路径错了
  _, err := os.ReadFile("xxx")
  if err != nil {
    panic(err.Error())
  }
}

func main() {
  fmt.Println("啦啦啦")
}

🎀 恢复程序

我们可以在一个函数里面，使用一个 defer，可以实现对 panic 的捕获

以至于出现错误不至于让程序直接崩溃

这种一般也是框架层的异常处理所做的

go 复制代码

package main

import (
  "fmt"
  "runtime/debug"
)

func read() {
  defer func() {
    if err := recover(); err != nil {
      fmt.Println(err) // 捕获异常，打印错误信息
      // 打印错误的堆栈信息
      s := string(debug.Stack())
      fmt.Println(s)
    }
  }()
  var list = []int{2, 3}
  fmt.Println(list[2]) // 肯定会有一个panic
}

func main() {

  read()
}

当然，这个用于捕获异常的 defer 的延迟函数可以在调用链路上的任何一个函数上，但是 main中捕获了会直接结束程序

panic 会层层向上抛，当前函数不处理，defer 放到 main 函数中也是会被处理的
一旦 panic 发生，即使被 recover() 捕获，当前调用栈的"正常流程"也会中断

二：🔥 泛型

从 1.18 版本开始，Go 添加了对泛型的支持，即类型参数

🦋 泛型函数

如果我们要实现一个对int类型的求和函数

go 复制代码

func add(a, b int) int {
  return a + b
}

但是这样写了之后，如果参数是 float 类型，int32 类型这些，就没办法使用了

难道要为每个类型都写一个这样的函数吗？

显然这就不合理

这个时候，泛型就上场了

go 复制代码

func add[T int | float64 | int32](a, b T) T {
  return a + b
}

type Number interface {
	int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64
}

func plus[T Number](n1, n2 T) T {
	return n1 + n2
}

🦋 泛型结构体

go 复制代码

package main

import (
  "encoding/json"
  "fmt"
)

type Response[T any] struct {
  Code int    `json:"code"`
  Msg  string `json:"msg"`
  Data T      `json:"data"`
}

func main() {
  type User struct {
    Name string `json:"name"`
  }

  type UserInfo struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
  }

  //user := Response{
  //  Code: 0,
  //  Msg:  "成功",
  //  Data: User{
  //    Name: "枫枫",
  //  },
  //}
  //byteData, _ := json.Marshal(user)
  //fmt.Println(string(byteData))
  //userInfo := Response{
  //  Code: 0,
  //  Msg:  "成功",
  //  Data: UserInfo{
  //    Name: "枫枫",
  //    Age:  24,
  //  },
  //}
  //byteData, _ = json.Marshal(userInfo)
  //fmt.Println(string(byteData))

  var userResponse Response[User]
  json.Unmarshal([]byte(`{"code":0,"msg":"成功","data":{"name":"枫枫"}}`), &userResponse)
  fmt.Println(userResponse.Data.Name)
  var userInfoResponse Response[UserInfo]
  json.Unmarshal([]byte(`{"code":0,"msg":"成功","data":{"name":"枫枫","age":24}}`), &userInfoResponse)
  fmt.Println(userInfoResponse.Data.Name, userInfoResponse.Data.Age)
}

🦋 泛型切片

go 复制代码

package main

type MySlice[T any] []T

func main() {
  var mySlice MySlice[string]
  mySlice = append(mySlice, "枫枫")
  var intSlice MySlice[int]
  intSlice = append(intSlice, 2)
}

🦋 泛型 map

go 复制代码

package main

import "fmt"

type MyMap[K string | int, V any] map[K]V

func main() {
  var myMap = make(MyMap[string, string])
  myMap["name"] = "枫枫"
  fmt.Println(myMap)
}

三：🔥 文件操作

🦋 文件读取

一次性读取

go 复制代码

byteData, _ := os.ReadFile("go_study/hello.txt")
fmt.Println(string(byteData))

获取当前go文件的路径

可以通过获取当前 go 文件的路径，然后用相对于当前 go 文件的路径去打开文件

go 复制代码

// GetCurrentFilePath 获取当前文件路径
func GetCurrentFilePath() string {
  _, file, _, _ := runtime.Caller(1)
  return file
}

分片读

go 复制代码

file, _ := os.Open("go_study/hello.txt")
defer file.Close()
for {
  buf := make([]byte, 1)
  _, err := file.Read(buf)
  if err == io.EOF {
    break
  }
  fmt.Printf("%s", buf)
}

带缓冲读

按行读

go 复制代码

file, _ := os.Open("go_study/hello.txt")
buf := bufio.NewReader(file)
for {
  line, _, err := buf.ReadLine()
  fmt.Println(string(line))
  if err != nil {
    break
  }
}

指定分割符

go 复制代码

file, _ := os.Open("go_study/hello.txt")
scanner := bufio.NewScanner(file)
scanner.Split(bufio.ScanWords) // 按照单词读
//scanner.Split(bufio.ScanLines) // 按照行读
//scanner.Split(bufio.ScanRunes) // 按照中文字符读
//scanner.Split(bufio.ScanBytes) // 按照字节读读，中文会乱码

for scanner.Scan() {
  fmt.Println(scanner.Text())
}

🦋 文件写入

一次性写

go 复制代码

err := os.WriteFile("go_study/file1.txt", []byte("这是内容"), os.ModePerm)
fmt.Println(err)

文件的打开方式

常见的一些打开模式

go 复制代码

// 如果文件不存在就创建
os.O_CREATE|os.O_WRONLY
// 追加写
os.O_APPEND|os.O_WRONLY
// 可读可写
os.O_RDWR

完整的模式

go 复制代码

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_SYNC   int = syscall.O_SYNC   // 同步打开
  O_TRUNC  int = syscall.O_TRUNC  // 打开时清空文件
)

文件的权限

主要用于linux系统，在windows下这个参数会被无视，代表文件的模式和权限位

文件复制

go 复制代码

io.Copy(dst Writer, src Reader) (written int64, err error)

将 src 文件的内容复制到 dst 文件

go 复制代码

read, _ := os.Open("go_study/file1.txt")
write, _ := os.Create("go_study/file3.txt") // 默认是 可读可写，不存在就创建，清空文件
n, err := io.Copy(write, read)
fmt.Println(n, err)

目录操作

go 复制代码

dir, _ := os.ReadDir("go_study")
for _, entry := range dir {
  info, _ := entry.Info()
  fmt.Println(entry.Name(), info.Size()) // 文件名，文件大小，单位比特
}

四：🔥 共勉

😋 以上就是我对 【Go】异常处理、泛型和文件操作 的理解, 觉得这篇博客对你有帮助的，可以点赞收藏关注支持一波~ 😉