1 基础简介

go语言基础包括如下几个部分

包声明
引入包
函数
变量
语句 & 表达式
注释

go程序始于package main。main函数是执行入口，fmt.Println用于输出。Go有25个关键字和36个预定义标识符。
go语言特点包括接口的水平和垂直组合，隐式接口，内存零值初始化。挑战涉及包管理、泛型、错误处理等。
推荐遵循idiomatic Go的项目结构，利用go.mod管理依赖。
错误处理通过if err != nil检查，panic和recover用于异常控制。

2 基本结构说明

首先定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包。

  package main     

输入输出， import “fmt” 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。

  import "fmt"

执行入口，func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。

func main() {
   /* 第一个程序 */
   fmt.Println("Hello, World!")
}

其中， /…/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，在程序执行时一般将被忽略。

实际程序只有一个打印输出到控制台。 fmt.Println(…) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。

执行。 如果您已经安装go语言程序，那么打开 cmd(windows平台) 或 shell(linux平台)，新建并保存以上代码到hello.go 文件

  $ go run hello.go
  Hello, World!

也可以编译后，执行

$ go build hello.go 
$ dir // 或者在linux执行 ls
  hello    hello.go
$ ./hello 
  Hello, World!

3 标识符和关键字。

golang默认有25个关键字

  break	default	func	interface	select
  case	defer	go	map	struct
  chan	else	goto	package	switch
  const	fallthrough	if	range	type
  continue	for	import	return	var

golang 默认有36个预定义标识符

  append	bool	byte	cap	close	complex	complex64	complex128	uint16
  copy	false	float32	float64	imag	int	int8	int16	uint32
  int32	int64	iota	len	make	new	nil	panic	uint64
  print	println	real	recover	string	true	uint	uint8	uintptr

程序一般由关键字、常量、变量、运算符、类型和函数组成。

程序中可能会使用到这些分隔符：括号 ()，中括号 [] 和大括号 {}。

程序中可能会使用到这些标点符号：.、,、;、: 和 …

• 并且没有解析符号表。
• const 常量是数字，首字母大小决定结构体属性的可见性。
• 没有子类型继承。
• 隐式的接口，implements 声明
• 内存总是初始化零值

4 go1规范和使用挑战中的概念

• go1 规范：

    interface 水平组合， 满足依赖抽象，里氏替换，接口隔离
  
    type embedding 垂直组合， 通过方法名 匹配和调用函数。
      通过 例程 goroutine + channel 组合实现类似 unix pipe 的功能。
  

并发有关代码结构。
并行有关执行的结构。

解决了性能问题，单靠cpu主频提高以提高性能不总是有效的。
大型程序中，操作系统调度切换线程代价不小。
所谓自带电池是指，内建的标准库丰富。

• 使用go的挑战

   1 包管理
   2 相似的语言特征
   3 泛型支持
   4 客户端GUI支持
   5 错误处理
   6 调试和库支持
  

5 go的标准项目结构

  原生编程思维 --->  idiomatic go   内建工具链，go语言语法
                                   标准库
                                   三方库、工具

  项目结构，go 风格  --->  api 
                          lib
                          src  -->  cmd  ---> cgo, gc,gofmt,yacc ...
                                    pkg  --->  fmt/, go/, io/, math/, syscall/,unsafe/,...
                                    vandor...

  go项目推荐 module-ware风格 ---> go.mod
                                 go.num
                                 lib.go
                                 lib1
                                 lib2

缓存失效和命名的问题

  命名：  --->  var 变量声明聚类，同类型的相同前后缀
           const 常量命名，整合了c的风格  --->  宏定义常量， 枚举常量
                                              const 只读变量，为类型安全的。

无类型常量

      const  SearchStart = 1

有类型常量

      const  SearchEnd int  = 10

枚举类型 iota是 Go的一个预定义标识符，它表示const 声明块，包括单行声明的每个常量所处位置在块中的偏移量（从0开始）。

6 零值可用类型

某些数据类型可以支持零值可用，但是功能受限

* 切片   零值切片可添加元素，但是不能使用下标。

* 互斥锁和池 sync.Mutex  sync.Pool   

  有大并发需求的创建，使用读写锁。 RWMutex

* io 缓冲  bytes.Buffer  避免值复制错误

创建切片的cap参数

 St := make([]int, 0)
 size := 10
 Se := make([]int, 0, size)

使用cap容量规定切片最大有多少元素，可以预知切片最大容量，提高 40%的性能。

函数的可变参数， 如下 Call函数有可变参数类型，在函数最后可以使用，不传或传多个。

 func Call(name, ...String) {...}

7 错误处理

 1 构造错误值对象  fmt.Errorf(...), errors.New(...)
 2 透明错误处理,实现低耦合   if err != nil {...}   
 3 哨兵处理方式    

    if err != nil {
      switch err.Error() {
      case "bufio:negative...":
      ...
      case ....
    }
    }

• 错误类型检视

       switch err := err.(type) {
       case * unmarshal.TypeError{
       ...
     }
     }
  

• 错误行为检查

    将错误封装到结构体
  
        type OpError struct {
          ...
          err error
        }
  
        type temp interface {
          Temp() 
        }
  
    func (eop *OpError) Temp() bool {
      if ne, ok := eop.Err.(* os.Syscall.Error); ok {
      t, ok := ne.Err.(temp)
      return ok && t.Temp
    }
    }
  

• panic 恐慌的使用场景

       1 充当断言
       2 简化错误处理
       3 recover 捕获 panic， 防止协程退出
       由于在go中，多例程时，无论哪个例程退出，整个go程序都将失败。
  
       panic 常常都被用于程序栈跟踪。