什么是go

什么是go - 图1

Go是 google 2009 年推出的一门新的系统编程语言

了解一下 Go 的作者和主要核心开发者们，图中是Go的三个作者从左到右分别是：Robert Griesemer, Rob Pike 和 Ken Thompson。

  • Robert Griesemer 在开发Go之前是Google V8、Chubby和HotSpot JVM的主要贡献者；
  • Rob Pike 主要是Unix、UTF-8、plan9的作者；
  • Ken Thompson 主要是B语言、C语言的作者、Unix之父。

GO语言特点

  • 静态编译
  • 垃圾回收
  • 简洁的符号和语法
  • 平坦的类型系统
  • 基于CSP的并发模型
  • 高效简单的工具链
  • 丰富的标准库

历史

  • 2007年开始设计
  • 2008年作为Google的20%项目开始实现
  • 2009年作为开源项目面向大众
  • 最新的是1.8版本

GO的思维方式

  • 最小心智负担原则
  • 最小特性
  • 最少惊异
  • 最小犯错机会

GO Next Java No，Next C

  • 少就是指数级的多
  • 最少特性原则：如果一个功能不对解决任何问题有显著价值，那么就不提供
  • 显示表达：所写即所得的语言
  • 极度简化但完备的OOP
  • 功能内聚：例如，强大的组合能力
  • 最友善的C语言的支持

以软件工程为目的的语言设计

  • 快速编译
  • 严格的依赖管理
  • 代码风格的强一致性
  • 偏向组合而不是继承

几个优秀的设计

  • if for switch 之类的语句不需要用括号了，但保留了大括号，方便定位语句块
  • 可以使用 ：=进行自动类型推导。再也不用写诸如list <int> :: iterator it =l.begin()之类的语法了。
  • 使用字母大小写设置可见性（letter case sets visibility）。省云了成员前面一堆的 public和private，直接看名字就可以辨认了。
  • 保留了指针操作，但去掉了指针算术，指针更安全了，同时留给了程序员使用值语义和引用语义的便利。
  • defer关键字。妈妈再也不担心句柄没有关闭了。

对OOP的支持

  • 返pu归真，没有继承，只有组合
  • 明确区分复用和抽象，复用使用组合，抽象使用
  • 所见即所得，明确的内存模型，没有vtable之类的东西
  • 鸭子类型，抽象更方便。

OOP的例子

  1. package main
  3. import "fmt"
  5. type Person struct {
  6.     Name string
  7.     Age int
  8. }
  10. func (p Person) String() string {
  11.     return fmt.Sprintf("%s %d", p.Name, p.Age)
  12. }
  14. type Stringer interface {
  15.     String() string
  16. }
  18. func main() {
  19.     var p = Person{"icexin", 20}
  20.     var s Stringer = p
  21.     fmt.Println(s.String())
  22. }

Go内置的并发

GO 的并发

基于协程（goroutine）和管道（channel）

  • goroutine：轻量的线程
  • channel：带类型的，协程安全的管道，类似unix里面pipe

并发的例子：

  1. # 斐波那契数列产生器
  2. # python
  4. def fib(n):
  5.     a, b =0, 1
  6.     for i n range(n):
  7.         a, b = b, a+b
  8.         yield a
  10. for x in fib(10):
  11.     print(x)

GO的版本

  1. func fib(c chan int, n int) {
  2.     a, b := 0, 1
  3.     for i :=0; i < n; i++ {
  4.         a, b = b, a+b
  5.         c <- a
  6.     }
  7.     close(c)
  8. }
  10. func main() {
  11.     c := make(chan int)
  12.     go fib(c, 10)
  14.     for x :=range c {
  15.         fmt.Println(x)
  16.     }
  17. }

GO解决c10k问题

  1. func handle(con net.Conn) {
  2.     fmt.Fprintf(conn, "%s", time.Now().String())
  3.     conn.Close()
  4. }
  6. func main() {
  7.     l, err := net.Listen("tcp", ":8000")
  8.     if err != nil {
  9.         log.Fatal(err)
  10.     }
  12.     for {
  13.         conn, err := l.Accept()
  14.         if err != nil {
  15.             log.Fatal(err)
  16.         }
  17.         go handler(conn)
  18.     }
  19. }

GO在工程上的设计

静态编译

  • 没有依赖地狱，甚至是glibc
  • 编译一次，随处copy，部署极为方便
  • 对比gitlab和gogs
    gitlab-ce

丰富的工具

  • 一键编译 go build
  • 一键测试 go test
  • 一键下载更新依赖并编译 go get
  • 自动文档工具 godoc

go和python对比

Go跟Python相似的地方:

  • 语法简单
  • 功能强大
  • 易于学习

不一样的地方:

  • 运行速度快
  • 并发支持
  • 静态类型