Go知识梳理

1. 了解全局：进行一个全局的了解，知道要学习什么
   1. 搜索，对学习的东西有一个基本的认识
2. 确定范围：集中精力，确定要学什么
   1. 考虑到时间
3. 定义目标：明确成功的含义
   1. 具体的，无二义性的
4. 寻找资源
5. 创建学习计划
6. 筛选资源
7. 开始学习，浅尝辄止
8. 动手操作，边学边玩
9. 全面掌握，学以致用
   1. 真实有用的项目
   2. 能够一直迭代维护的项目
10. 乐为人师，融会贯通

1. 诞生
2. 创造原因
3. 发展历程
4. 特点：
   1. 继承了c语言的很多理念，保留了和c一样的编译方法，但是同时弱化了指针
   2. 引入了包的概念，go的文件都要依赖于一个包
   3. 垃圾回收机制，不需要开发人员管理
   4. 天然并发（重要特点）
      1. 从语言方面实现，简单
      2. Gorutine，轻量级线程，可以实现大并发处理，高效利用多核
      3. 基于cps并发模型实现
   5. 管道机制
   6. 函数可以返回多个值
   7. 新的创新：切片，延时执行defer
5. 开发工具：
6. 格式：gofmt可以格式化

var a int  //声明后不赋值
var a = 10 //类型推导
a := 10  //类型推导

var (
  a int
    b string
    d bool
)

const pi = 3.14
const pi float32= 3.1

const(
  n1 = 100
  n2
  n3
)
//如果省略了，表示值和上面一行相同

const (
   n = iota  //0
   n1   //1
   n2   //2
)
//注意：多个iota定义在1行，值相同

a := string(b)

func main() {
  cs:=0
  s := "hello 你哈"
  for _, c := range s {
    if unicode.Is(unicode.Han,c){
      cs++
    }
  }
  fmt.Println(cs)
}

1. if else
2. for
3. for range
4. switch case
   1. fallthrough, 执行完这个case之后 ，会执行下个case
5. goto
6. break
7. continue

var a [3]int 

1. 使用初始化列表来设置数组元素的值
var a = [3]int{1,2}
2. 不设置值的时候，数组会自动初始化为int类型的零值
var a [3]int
3. 根据初始值的个数判断数组长度
var a = [...]int{1,2,34}
4. 类型推导的方式

for
for range

func sum (x [3]int) int{
  sum := 0
  for _,v := range x{
    sum += v
  }
  return sum
}
//这个函数只能接受[]int类型，其他的都不支持

a := [3]int{1,2,3}
//定义了三个元素了，就不能再就行往数组a中添加新元素了

var a []T

var a []T

a:= [5]int{1,2,3,4,5}
s:= a[1:3]
//做保

make([]T, size, cap)

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
  newcap = cap
} else {
  if old.len < 1024 {
    newcap = doublecap
  } else {
    // Check 0 < newcap to detect overflow
    // and prevent an infinite loop.
    for 0 < newcap && newcap < cap {
      newcap += newcap / 4
    }
    // Set newcap to the requested cap when
    // the newcap calculation overflowed.
    if newcap <= 0 {
      newcap = cap
    }
  }
}

  var a = [...]int{1, 2, 3, 4, 5}
  fmt.Printf("%T\n", a)
  b := a[0:3]
  fmt.Printf("%T\n", b)
  var c = make([]int, 10)
  copy(c, b)
  fmt.Println("==========")
  fmt.Println(a)
  fmt.Println(b)
  fmt.Println(c)