daily commit

Golang/Golang基础.md

@@ -462,6 +462,363 @@
 
     }
     ```
+- ## Golang中的方法
+  - 虽然Golang中并不像其他语言一样存在类（class），但是我们可以在Golang中为类型（type）定义方法
+  - 在Golang中，为类型（type）定义方法是定义一个接受特定类型参数的函数
+  ```Golang
+  type Point struct {
+    X,Y float64
+  }
 
+  // 为Point类型定义方法
+  func (p Point) Abs() float64 {
+    return math.Sqrt(p.X*p.X+p.Y*p.Y)
+  }
 
+  // 可以通过如下形式调用为类型定义的方法
+  p := Point{3,4}
+  fmt.Println(p.Abs())
+  ```
+  - 在Golang中，不仅可以为struct类型指定方法，而且可以为基本类型指定方法（例如type MyFloat float64后，为MyFloat类型指定方法）
+  - 在Golang中，只能够为位于同一个包中的类型指定方法，无法为位于其他包中的类型指定方法
+  ```Golang
+  type MyFloat float64
 
+  func (f MyFloat) fuck() {
+    fmt.Println("fucking float64")
+  }
+  ```
+  - 在Golang中，除了可以为类型指定方法外，还可以为类型的指针指定方法，此时特殊参数接受一个指针，可以通过指针修改传输类型的值
+  ```Golang
+  type Point struct {
+    X,Y float64
+  }
+
+  // 定义函数接受一个Point类型的指针
+  func (p *Point) modify() {
+    p.X *= 10
+    p.Y *= 10
+  }
+
+  // 调用时无需先将类型对象转化为指针，可以直接在对象上调用
+  p := Point{3,4}
+  p.modify()
+  // 调用后p为{30,40}
+
+  // 接受一个Point类型的拷贝
+  func (p Point) modifyCopy() {
+    p.X *= 10
+    p.Y *= 10
+  }
+
+  // 调用时传入函数的是对象的一个拷贝，不会修改原先对象的值
+  p := Point{3,4}
+  p.modifyCopy()
+  // 调用后仍然为{3,4}，修改的只是拷贝对象的值
+  ```
+  - 在Golang中，普通函数参数，必须向接受指针的形参中传入指针，向接受值的形参中传入值；但是在接受特殊参数的位置，如果想要接受的是值类型，那么传入指针和传入值均可；如果想在特殊参数位置接受指针类型，那么传入指针和传入值类型也均可
+  ```Golang
+  func (p *Point) modify() {
+    // func body
+  }
+
+  // 对于如下调用形式均可
+  p := Point{3,4}
+  
+  p.modify() // 可行的调用方式
+  (&p).modify() //可行的调用方式
+
+  func (p Point) modifyCopy() {
+    // func
+  }
+
+  p := Point{3,4}
+  // 对接受值的特殊参数，下列调用方式也均可
+  p.modifyCopy() // 可行
+  (&p).modifyCopy() //可行
+  ```
+- ## Golang中的接口
+  - 在Golang中，interface中定义了一系列的方法签名，对于实现了interface中定义所有方法签名的类型，其都可以被赋值给interface类型
+  - 如果对一个类型的指针实现了interface接口，那么只能将该类型的指针赋值给interface变量，无法将该类型赋值给interface变量
+  ```Golang
+  type Car interface {
+    drive()
+  }
+
+  type AE86 struct {
+  }
+
+  // 为AE86类型的指针实现接口中drive方法
+  func (car *AE86) drive() {
+
+  }
+
+  // 此时，可以将*AE86类型赋值给Car，但是无法将AE86赋值给Car
+  var car Car
+  car = AE86{} // 失败
+  car = &AE86{} // 成功
+  ```
+  - 接口中保存的信息通常可以看做一个二元组：（具体的值，值的类型）
+  ```Golang
+  // 接口中保存的值如果是nil，但是其类型已经确定，那么接口的值就不为nil
+  var car Car
+  car=(*AE86)(nil)
+  fmt.Println(car==nil) // 输出为false
+  // 此时，虽然car仍然不指向具体的对象，但是其指向的类型确定为Car，故而其不为nil
+  // 在明确接口所指向的具体类型后，即使其值仍然为nil，但仍可以调用类型的具体方法
+  car.drive() // 调用成功
+  // 虽然car作为interface值时car==nil并不成立
+  // 但是调用car.drive()时，向drive函数中传递的*AE86类型的特殊参数仍然是nil
+  // 故而在func (car *AE86) drive() {}函数的实现中，需要显式定义空指针判断
+  func (car *AE86) drive() {
+    if car==nil {
+      // operations if nil...
+    }
+    // operations if non-nil...
+  }
+  ```
+  - 如果在接口中，及没有保存值，也没有保存类型，那么接口值为nil，在为nil的接口值上调用方法会引发空指针异常
+  ```Golang
+  var car Car
+  // 此时car接口中既没有值信息，又没有类型信息
+  fmt.Println(car==nil) // 输出结果为true
+
+  // 抛出空指针异常
+  // 由于car接口中并没有保存当前的值和类型信息
+  // 故而不知道应该对那个类型的drive方法进行调用
+  car.drvie()
+  ```
+  - 空接口类型interface{}
+    - 由于interface{}接口中没有定义任何方法，故而任何类型都实现了interface{}中所有的方法，interface{}接口可以持有仍和类型的值
+    - 通常，可以在函数形参中接受interface{}类型的变量，代表接受任何类型的值
+  ```Golang
+  // 定义新的类型any，其相当于interface{}，可接受任何类型的值
+  type any interface{}
+  ```
+   - Golang中的类型断言
+     - 在Golang中，接口可以在运行时持有不同类型的值，类似与面向对象中的多态
+     - 通过类型断言，可以在运行时动态的判断interface持有值的类型
+  ```Golang
+  // 运行时动态判断接口中持有值的类型
+  var car Car=(*AE86)(nil)
+  // 断言判断
+  // 1.如果interface中持有的值不是指定类型，抛出panic
+  val := car.(*FD) // 此时会抛出panic，终止程序
+
+  // 2.判断interface中持有的值是否是制定类型，如果不是，不抛出panic继续运行
+  val,ok := car.(*FD)
+  // 如果是，ok为true，如果不是，ok为false
+  if ok {
+    // val为持有的值
+  } else {
+    // val为该*FD类型的默认值，指针类型默认值为nil
+  }
+  ```
+  - Golang中根据接口持有类型来进行switch
+  ```Golang
+  // 进行type switch
+  var car Car=&AE86{}
+
+  switch v := car.(type) {
+    case *AE86:
+      // 如果car接口持有的类型是*AE86，则v的类型是*AE86，值为car持有的值
+    case *FD:
+      // 如果car接口持有的类型是*FD，那么v的类型是*FD，值为car持有的值
+    default：
+      // 如果car接口持有的类型不是上述类型，那么v的类型仍然是接口类型，值为car持有的值
+  }
+  ```
+  - Golang中的Stringer接口
+    - Golang中通常通过Stringer中的String()方法来返回一个描述自身的字符串，而fmt包在打印信息时通常通过调用该接口的String方法来实现的
+  ```Golang
+  type Waifu struct{
+    firstName,lastName string
+  }
+
+  func (waifu Waifu) String() string {
+    return "my waifu: "+waifu.firstName+" "+waifu.lastName
+  }
+
+  fmt.Println(Waifu{"touma","kazusa"})
+  ```
+- ## Golang中的错误处理
+  - Golang中，通常在方法执行时，都会返回一个error值，调用方通过检查error返回值是否为nil来判断执行是否出错
+  ```Golang
+  i,err := strconv.Atoi("1")
+  if err==nil {
+		// 转换成功
+		fmt.Println(i)
+	} else {
+    // 转换失败
+		fmt.Println(err)
+	}
+  ```
+  - 在Golang中，通常通过error接口来获取失败的错误信息
+  ```Golang
+  type error interface {
+    Error() string
+  }
+  ```
+- ## Golang中的字节流
+  - Golang中，通过io.Reader接口来完成对文件的读取
+  ```Golang
+  type Reader interface {
+    // Reader接口中含有一个read方法
+    // read方法接受一个字节slice作为参数
+    // 并且，其会将读取的字节填充到slice中
+    // read方法的返回值为n和err
+    // n为读取的字节数
+    // err为返回的异常信息，如果err返回的值是io.EOF，则代表读取到字节流的末尾
+    Read(b []byte) (n int,err error)
+  }
+  ```
+- ## Golang中的泛型
+  - Golang中，支持泛型函数，可以为函数指定一个类型参数，指定函数接受参数的类型
+  ```Golang
+  // 定义泛型参数，添加对类型的约束条件，要求其可以比较
+  func firstIndex[T comparable](arr []T,t T) int {
+    for i,v := range arr {
+      if v==t {
+        return i
+      }
+    }
+    return -1
+  }
+
+  fmt.Println(firstIndex[int]([]int{1,3,2,5,4},5))// 输出3
+  ```
+  - Golang中，除了支持泛型函数，还支持泛型struct
+  ```Golang
+  // 通过泛型struct定义单链表节点
+  type Node[T any] struct {
+    val T
+    next *Node[T]
+  }
+  ```
+- ## Golang中的并发
+  - Goroutine：
+    - Goroutine是由Go的运行时环境所管理的轻量级线程
+      - Goroutine运行在相同的地址空间中，故而在Goroutinue在对地址中资源进行访问时，需要对其进行同步
+    - Goroutine的开启：
+    ```Golang
+    // 开启一个新的Goroutine
+    // 其中，f、x、y、z的计算发生在当前的Goroutine中
+    //  但是，f(x,y,z)的执行发生在新创建的Goroutine中
+    go f(x,y,z)
+    ```
+  - Channel：
+    - Channel是一个类型化的管道，通过<-操作符，可以从Channel中接收数据或向Channel发送数据
+    - Channel的创建可以通过make函数来实现
+    ```Golang
+    // 创建channel
+    ch := make(chan int)
+
+    // 与channel的数据传输
+    ch<-v // 将v中的数据发送到channel管道
+    v := <-ch // 从channel中读取数据，并且将其赋值给v
+    ```
+    - Channel中发送和接收的同步
+      - 默认情况下(没有缓冲时），向channel发送数据时，需要确认接受数据的一方已经准备好
+      - 在从channel接受数据时，需要确认发送数据的一端已经准备好
+      - 通过上述条件，可以让Goroutine在没有显式锁和条件变量的情况下完成同步
+    - 在创建channel时，可以为channel指定一个缓冲区大小
+      - 当缓冲区中的数据满之后，向缓冲区填充数据的Goroutine将会被阻塞
+      - 当缓冲区中的数据为空时，从缓冲区读取数据的Goroutine将会被阻塞
+    ```Golang
+    // 如果在同一个Goroutine中，多次向channel中加入数据导致缓冲区被填满
+    // 并且没有其他Goroutine来取出数据，那么当前添加数据的Goroutine将会
+    // 被一直阻塞，从而产生死锁
+    func main {
+      ch := make(chan int,2)
+      ch <- 1
+      ch <- 2
+      ch <- 3 // 此时缓冲区已满，会阻塞当前Golang，造成死锁
+    }
+    ```
+    - Channel的关闭和range迭代
+      - Channel的发送方可以调用close函数对channel进行关闭
+      - 向已经关闭的channel发送数据，会抛出panic
+      - 从已经关闭的channel中读取数据时，第二个参数ok返回为false
+      - 在对panic进行读取操作时，也可以用第二个参数来读取channel是否被关闭
+    ```Golang
+    ch := make(chan int,2)
+    ch <- 1
+    ch <- 2
+
+    close(ch)
+
+    // 可以通过读取channel时的第二个参数来读取channel是否被关闭
+    i,ok := <-ch
+    // 此时，ok代表是否ch已经关闭，i代表读取的值
+    fmt.Println(i,ok) // 1 true
+    i,ok = <-ch
+    fmt.Println(i,ok) // 2 true
+    i,ok =<-ch
+    fmt.Println(i,ok) // 0 false
+
+    // 可以对channel中的所有数据进行range循环
+    // 该循环会遍历channel中所有元素，直到channel被关闭
+    for i := range ch {
+      fmt.Println(i)
+    }
+    ```
+  - Golang中的select块
+    - Golang中select块可含有多个被阻塞的通信操作，当任意一个通信操作结束时，select结束阻塞并且执行其通信操作。
+    - 如果在select块中有多个通信操作都处于就绪状态，其随机选择一个执行
+    - 如果在select块中存在default，则在其他case均未处于就绪状态时default条件下被执行
+  ```Golang
+  select {
+    case v:=<-ch:
+      fmt.Println(v)
+    case <-quit
+      return
+    default:
+      fmt.Println("waiting...")
+      time.Sleep(time.Second * 1)
+  }
+  ```
+ - Golang中的互斥锁
+   - Golang中为了保证临界区共享资源的安全，可以通过sync.Mutex来保证多个Goroutine访问临界资源时的并发安全
+   - Mutex有Lock和Unlock方法，用于加锁和释放锁
+   - 为了保证解锁的方法一定被执行，可以指定Unlock方法为defer，此时即使发生了panic，也会保证defer的Unlock方法一定被执行，锁资源被释放
+    ```Golang
+    mut := sync.Mutex{}
+    cur := 0
+    go func() {
+      for cur<9 {
+        mut.Lock()
+        if cur<9 && cur%3 == 0 {
+          fmt.Println("Goroutine 1")
+          cur++
+        }
+        mut.Unlock()
+      }
+    }()
+    go func() {
+      for cur<9 {
+        mut.Lock()
+        if cur<9 && cur%3 == 1 {
+          fmt.Println("Goroutine 2")
+          cur++
+        }
+        mut.Unlock()
+      }
+    }()
+    go func() {
+      for cur<9 {
+        mut.Lock()
+        if cur<9 && cur%3 == 2 {
+          fmt.Println("Goroutine 3")
+          cur++
+        }
+        mut.Unlock()
+      }
+    }()
+    // 输出会显示如下
+    // 1
+    // 2
+    // 3
+    // 1
+    // 2
+    // 3
+    ```