Base

2022-04-07  本文已影响0人  Never_Yg

Go 不是像 C ++，Java，Ruby 和 C＃一样的面向对象的（OO）语言。它没有对象和继承的概念，也没有很多与面向对象相关的概念，例如多态和重载。

Go没有类或者说面向对象的概念, 结构体就是Go里面的类

镜像复制

func main() {
goku := Saiyan{"Power", 9000}
Super(goku)
fmt.Println(goku.Power)
}

func Super(s Saiyan) {
s.Power += 10000
}
上面程序运行的结果是 9000，而不是 19000,。为什么？因为 Super 修改了原始值 goku 的复制版本，而不是它本身

&: 取地址符

func main() {
goku := &Saiyan{"Power", 9000}
Super(goku)
fmt.Println(goku.Power)
}

func Super(s *Saiyan) {
s.Power += 10000
}

这里注意到我们仍然传递了一个 goku 的值的副本给 Super，但这时 goku 的值其实是一个地址。所以这个副本值也是一个与原值相等的地址，
这就是我们间接传值的方式。想象一下，就像复制一个指向饭店的方向牌。你所拥有的是一个方向牌的副本，但是它仍然指向原来的饭店。

复制一个指针比复制一个复杂的结构的消耗小多了

Go结构体使用组合的方式, 代替面向对象中的继承

指针类型和值类型(指针类型就是类似对象了, 分配在堆上的内存)

当不确定要用值还是指针时, 就用指针

数组

在 Go 中，像其它大部分语言一样，数据的长度是固定的。我们在声明一个数组时需要指定它的长度，一旦指定了长度，那么它的长度值是不可以改变的了

var scores [10]int
scores[0] = 339

数组非常高效但是很死板

切片

在 Go 语言中，我们很少直接使用数组。取而代之的是使用切片。切片是轻量的包含并表示数组的一部分的结构。

//和数组声明不同的是，我们的切片没有在方括号中定义长度
scores := []int{1,4,293,4,9}

理解切片的长度和容量之间的关系

切片就是从数组切一段下来, 切片的长度就是标识切了多长的数组, 容量就是底层数组的长度
我们可以调整的切片大小最大范围是多少呢？达到它的容量, 就像例子中的10
这实际上并没有解决数组固定长度的问题。但是 append 是相当特别的。如果底层数组满了，它将创建一个更大的数组并且复制所有原切片中的值
Go 使用 2x 算法来增加数组长度(加倍容量)

四种方式创建切片

  1. names := []string{"leto", "jessica", "paul"} //字面量方式
  2. checks := make([]bool, 10) //知道容量
  3. var names []string //创建空切片
  4. scores := make([]int, 0, 20) //创建指定容量的切片

切片的内存理解

其他语言的切片 ---> 一个切片实际上是复制了原始值的新数组。

scores = [1,2,3,4,5]
slice = scores[2..4]
slice[0] = 999
puts scores
//答案是 [1, 2, 3, 4, 5] 。那是因为 slice 是一个新数组，并且复制了原有的值。

Go ---> 切片是指向原始数组的指针

scores := []int{1,2,3,4,5}
slice := scores[2:4]
slice[0] = 999
fmt.Println(scores)
//输出是 [1, 2, 999, 4, 5]

只有显示的使用copy内建函数, 才会复制新数组

总结
// 数组是连续存储的空间 切片只存放指针 没有存放数据 所以 指针的位置
// 只收上界影响，也就是数据的基址， 他的操作范围 只能从指针开始到连续的内存结束 如果超过容量 扩容后
// 就产生了新的数组和内存空间 切片的指针也会指向新的内存

映射

看错了, 以为是反射
映射就是字典, 使用 make 方法来创建

包管理

在 Go 语言中，包名遵循 Go 项目的目录结构。(意思是目录就是包名)

  1. 循环导入问题
  2. 可见性, 如果类型和函数的名字是大写就是外界可见的, 小写的名字就是外界不可见
  3. go get 库链接(会把下载下来的库, 放在工作目录GOPATH)
  4. 依赖管理 go get -u 包更新

go get的缺点: 无法指定版本

接口

目前为止，我们看到的类型都是具体的类型，一个具体的类型可以准确的描述它所代表的值。而接口类型是一种抽象的类型。它不会暴露出它所代表的对象的内部值的结构和这个对象支持的基础操作的集合；它们只会表现出它们自己的方法。也就是说当你有看到一个接口类型的值时，你不知道它是什么，唯一知道的就是可以通过它的方法来做什么。

type Namer interface {
    Method1(param_list) return_type
    Method2(param_list) return_type
    ...
}

接口有助于将代码与特定的实现进行分离(按照iOS的Delegate来理解)

接口就是一种协议，和现实中的接口一个道理。
一提到usbc你就知道那个接口长什么样，但是你不关心usbc芯片是什么样的，怎么接线。
代码通过接口定义来表明自己对外开放的能力，具体的实现则交给实现这个接口的类。
只要实现了这个接口的类，都一定存在对应的方法，那么我拿到这个类的实例对象的时候，就一定可以调用这个对象所实现的方法。
具体的好处需要多实践才好领会，
比如ios编程常见的委托，java常用的控制反转之类。
如果写过http接口，实际上也是一样的道理。

type Logger interface {
Log(message string)
}

错误处理

Go 首选错误处理方式是返回值，而不是异常。

作为最后一点，Go 确实有 panic 和 recover 函数。 panic 就像抛出异常，而 recover 就像 catch，它们很少使用。

defer

尽管 Go 有一个垃圾回收器，一些资源仍然需要我们显式地释放他们。例如，我们需要在使用完文件之后 Close() 他们。
这种代码总是很危险。一方面来说，当我们在写一个函数的时候，很容易忘记关闭我们声明了 10 行的东西。
另一方面，一个函数可能有多个返回点。Go 给出的解决方案是使用 defer 关键字：

无论什么情况，在函数返回之后（本例中为 main() ），defer 将被执行。这使您可以在初始化的位置附近释放资源并处理多个返回点。

go fmt

格式化代码
当你在一个项目内的时候，你可以运用格式化规则到这个项目及其所有子目录：
go fmt ./...

空接口和转换

字符串和字节数组

函数类型

函数是一种类型：
type Add func(a int, b int) int
可以作为参数传递

并发

Go 通常被描述为一种并发友好的语言。 原因是它提供了两种强大机制的简单语法： 协程 和 通道

package main

import (
  "fmt"
  "time"
)

func main() {
  fmt.Println("start")
  go process()
  time.Sleep(time.Millisecond * 10) // this is bad, don't do this!
  fmt.Println("done")
}

func process() {
  fmt.Println("processing")
}

同步

并发编程中的问题:

  1. 变量会被其他线程读写, 如果保证读写安全
  2. 加锁的效率问题: 需要个优雅的锁操作； 否则，我们最终会把多条快速通道走成单车道的。
  3. 加锁死锁的问题: 当协程 A 拥有锁 lockA ，想去访问锁 lockB ，同时协程 B 拥有锁 lockB 并需要访问锁 lockA 。

解决办法:

  1. 有一个常见的锁叫读写互斥锁。它主要提供了两种锁功能：一个锁定读取和一个锁定写入。它的区别是允许多个同时读取，同时确保写入是独占的。在 Go 中， sync.RWMutex 就是这种锁。
  2. 通道 旨在让并发编程更简洁和不容易出错。(加锁容易出问题)

通道

而Go是通过一种特殊的类型，通道（channel），一个可以用于发送类型化数据的管道，由其负责协程之间的通信，从而避开所有由共享内存导致的陷阱；这种通过通道进行通信的方式保证了同步性。数据在通道中进行传递：在任何给定时间，一个数据被设计为只有一个协程可以对其访问，所以不会发生数据竞争。 数据的所有权（可以读写数据的能力）也因此被传递。

并发编程的最大调整源于数据的共享。如跨多个请求共享数据。内存缓存和数据库

换而言之，一个协程可以通过一个通道向另外一个协程传递数据。因此，在任意时间点，只有一个协程可以访问数据。

c := make(chan int)

也就是，当我们从一个通道接收的时候， goroutine 将会直到数据可用才会继续执行。类似地，当我们往通道发送数据的时候，goroutine 会等到数据接收到之后才会继续执行。

通道阻塞

默认情况下，通信是同步且无缓冲的：在有接受者接收数据之前，发送不会结束。

一个无缓冲的通道在没有空间来保存数据的时候：必须要一个接收者准备好接收通道的数据然后发送者可以直接把数据发送给接收者。
所以通道的发送/接收操作在对方准备好之前是阻塞的：

  1. 对于同一个通道，发送操作（协程或者函数中的）在接收者准备好之前是阻塞的：如果ch中的数据无人接收，就无法再给通道传入其他数据：新的输入无法在通道非空的情况下传入。所以发送操作会等待 ch 再次变为可用状态：就是通道值被接收时就可以再传入变量。
  2. 对于同一个通道，接收操作是阻塞的（协程或函数中的），直到发送者可用：如果通道中没有数据，接收者就阻塞了。

缓冲通道

一个无缓冲通道只能包含 1 个元素，有时显得很局限。我们给通道提供了一个缓存，可以在扩展的 make 命令中设置它的容量

buf := 100
ch1 := make(chan string, buf)

通道注意事项:

  1. channel 在 Golang 中是一等公民，它是线程安全的，面对并发问题，应首先想到 channel
  2. 关闭一个未初始化的 channel 会产生 panic
  3. 重复关闭同一个 channel 会产生 panic
  4. 向一个已关闭的 channel 发送消息会产生 panic
  5. 从已关闭的 channel 读取消息不会产生 panic，且能读出 channel 中还未被读取的消息，若消息均已被读取，则会读取到该类型的零值。
  6. 从已关闭的 channel 读取消息永远不会阻塞，并且会返回一个为 false 的值，用以判断该 channel 是否已关闭（x,ok := <- ch）
  7. 关闭 channel 会产生一个广播机制，所有向 channel 读取消息的 goroutine 都会收到消息

Select

select 是 Go 中的一个控制结构。select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。

Select语句的作用(注意：它仅能用于channel的相关操作,select 里的 case 表达式要求是对信道的操作)

当我们需要同时从多个通道接收数据时，如果通道里没有数据将会发生阻塞。为了应对这种场景，Go内置了select关键字，可以同时响应多个通道的操作。

package main

import (
    "fmt"
)

func main() {
    c1 := make(chan string, 1)
    c2 := make(chan string, 1)

    c2 <- "hello"

    select {
    case msg1 := <-c1:
        fmt.Println("c1 received: ", msg1)
    case msg2 := <-c2:
        fmt.Println("c2 received: ", msg2)
    default:
        fmt.Println("No data received.")
    }
}
//c2 received:  hello

select语句的处理逻辑：case随机选择处理列出的多个通信情况中的一个

  1. select 的 case 是随机的，而 switch 里的 case 是顺序执行；
  2. select 里没有类似 switch 里的 fallthrough 的用法；
  3. select 里的 case 表达式要求是对信道的操作，不能像 switch 一样接函数或其他表达式；

超时

上一篇下一篇

猜你喜欢

热点阅读