Go最全Go 不同于其他语言的九个特性_go 相比其他语言的特点，2024年最新真香系列

本文链接：https://blog.csdn.net/2401_84919706/article/details/138759347

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新


上述函数接收 Foo 的副本并返回一个新的 Foo 对象。

// 通过引用传递
func MutateFoo(f *Foo ) error {
f.Field1 = “New val”
f.Field2 = 2
return nil
}


上面的函数接收一个指向 Foo 的指针并改变原始对象。


按值调用与按引用调用的这种明显区别使您的意图显而易见，并降低了调用函数无意中改变传入对象的可能性（当它不应该发生时（许多初学者开发人员很难做到这一点）握紧）。


正如麻省理工总结的：“可变性使得理解你的程序在做什么变得更加困难，并且更难以执行契约”


此外，按值调用显着减少了垃圾收集器的工作，这意味着应用程序更快、内存效率更高。这篇文章得出的结论是，指针追踪（从堆中检索指针值）比从连续堆栈中检索值慢 10 到 20 倍。要记住的一个很好的经验法则是：从内存中读取的最快方法是顺序读取，这意味着将随机存储在 RAM 中的指针数量减少到最少。


### 4. ‘defer’ 关键字


在NodeJS 中，在我开始使用knex.js之前，我会通过创建一个数据库池来手动管理我的代码中的数据库连接，然后在每个函数中从池中打开一个新连接，一旦所需的数据库 CRUD 功能已完成。


这有点像维护噩梦，因为如果我没有在每个函数结束时释放连接，未释放的数据库连接的数量会慢慢增长，直到池中没有更多可用连接，然后中断应用程序。


现实情况是，程序经常需要释放、清理和拆除资源、文件、连接等，因此 Go 引入了defer关键字作为管理这些的有效方式。


任何以defer开头的语句都会延迟对它的调用，直到周围的函数退出。这意味着您可以将清理/拆卸代码放在函数的顶部（很明显），知道一旦函数完成它就会如此。

func main() {
if len(os.Args) < 2 {
log.Fatal(“no file specified”)
}
f, err := os.Open(os.Args[1])
if err != nil {
log.Fatal(err)
}
defer f.Close()
data := make([]byte, 2048)
for {
count, err := f.Read(data)
os.Stdout.Write(data[:count])
if err != nil {
if err != io.EOF {
log.Fatal(err)
}
break
}
}
}


在上面的例子中，文件关闭方法被推迟了。我喜欢这种在函数顶部声明你的内务处理意图的模式，然后忘记它，知道一旦函数退出它就会完成它的工作。


### 5. Go 采用了函数式编程的最佳特性


函数式编程是一种高效且富有创造性的范式，幸运的是 Go 采用了函数式编程的最佳特性。在Go中：


* 函数是值，这意味着它们可以作为值添加到映射中，作为参数传递给其他函数，设置为变量，并从函数返回（称为“高阶函数”，在 Go 中经常使用装饰器创建中间件图案）。
* 可以创建和自动调用匿名函数。
* 在其他函数内声明的函数允许闭包（在函数内声明的函数能够访问和修改在外部函数中声明的变量）。在惯用的 Go 中，闭包被广泛使用来限制函数的范围，并设置函数然后在其逻辑中使用的状态。

func StartTimer (name string) func(){
t := time.Now()
log.Println(name, “started”)
return func() {
d := time.Now().Sub(t)
log.Println(name, “took”, d)
}
}
func RunTimer() {
stop := StartTimer(“My timer”)
defer stop()
time.Sleep(1 * time.Second)
}


上面是一个闭包的例子。‘StartTimer’ 函数返回一个新函数，它通过闭包可以访问在其出生范围内设置的 ‘t’ 值。然后，此函数可以将当前时间与“t”的值进行比较，从而创建一个有用的计时器。感谢Mat Ryer的这个例子。


### 6. Go 有隐式接口


任何阅读过有关SOLID编码和设计模式的文献的人都可能听说过“优先组合胜过继承”的口头禅。简而言之，这表明您应该将业务逻辑分解为不同的接口，而不是依赖于来自父类的属性和逻辑的分层继承。


另一个流行的方法是“为接口编程，而不是实现”： API 应该只发布其预期行为的契约（其方法签名），而不是有关如何实现该行为的详细信息。


这两者都表明接口在现代编程中的重要性。


因此，Go 支持接口也就不足为奇了。事实上，接口是 Go 中唯一的抽象类型。


然而，与其他语言不同，Go 中的接口不是显式实现的，而是隐式实现的。具体类型不声明它实现了接口。相反，如果为该具体类型设置的方法集包含底层接口的所有方法集，则Go 认为该对象实现了 interface。


这种隐式接口实现（正式称为结构类型）允许 Go 强制执行类型安全和解耦，保持动态语言中表现出的大部分灵活性。


相比之下，显式接口将客户端和实现绑定在一起，例如，在 Java 中替换依赖项比在 Go 中困难得多。

// 这是一个接口声明（称为Logic）
type Logic interface {
Process (data string) string
}

type LogicProvider struct {}
// 这是 LogicProvider 上名为“Process”的方法 struct
func (lp LogicProvider) Process (data string) string {
// 业务逻辑
}
// 这是具有 Logic 接口作为属性的客户端结构
type Client struct {
L Logic
}
func(c Client) Program() {
// 从某处获取数据
cLProcess(data)
}
func main() {
c := Client {
L: LogicProvider{},
}
c.Program()
}


LogicProvider 中没有任何声明表示它符合Logic接口。这意味着客户端将来可以轻松替换其逻辑提供程序，只要该逻辑提供程序包含底层接口 ( Logic ) 的所有方法集。


### 7.错误处理


Go 中的错误处理方式与其他语言大不相同。简而言之，Go 通过返回一个 error 类型的值作为函数的最后一个返回值来处理错误。


当函数按预期执行时，错误参数返回nil，否则返回错误值。调用函数然后检查错误返回值，并处理错误，或抛出自己的错误。

// 函数返回一个整数和一个错误
func calculateRemainder(numerator int, denominator int) ( int, error ) {
//
if denominator == 0 {
return 9, errors.New(“denominator is 0”
}
// 没有错误返回
return numerator / denominator, nil
}


Go 以这种方式运行是有原因的：它迫使编码人员考虑异常并正确处理它们。传统的 try-catch 异常还会在代码中添加至少一个新的代码路径，并以难以遵循的方式缩进代码。Go 更喜欢将“快乐路径”视为非缩进代码，在“快乐路径”完成之前识别并返回任何错误。


### 8.并发


可以说是 Go 最著名的特性，并发允许处理在机器或服务器上的可用内核数量上并行运行。当单独的进程不相互依赖（不需要顺序运行）并且时间性能至关重要时，并发性最有意义。这通常是 I/O 要求的情况，其中读取或写入磁盘或网络的速度比除最复杂的内存中进程之外的所有进程慢几个数量级。  
 函数调用前的“ go ”关键字将同时运行该函数。

func process(val int) int {