这是我参与「第五届青训营 」伴学笔记创作活动的第 1 天

Go 程序的结构

1. package
   • 每个源文件都以一条 package 声明语句开始，这个例子里就是 package main，表示该文件属于哪个包
2. Import 包
3. 程序主体

Go 基础用法

1. 变量

• 两种声明方式
  • var 声明（一般用于全局变量）
    • 格式： var name type = expr
    • 可以显示定义 type ，也可以忽略 type，编译器从 expr 自动推断
      • var d = true
      • var e float 64
    • type 和 =expr 至少存在一个
    • 可以同时声明多个变量
      • var b,c int = 1,2
  • 短变量声明（一般用于局部变量）
    • 格式：name := expr
    • 短变量会自动根据表达式进行推断
    • 注意：:= 是声明语句，而 = 是赋值语句
• const 声明（如果没有固定说明，const 会自动推断类型）
  • const s string = "constant"
  • const h = 50000

2. for

• 首先，go 中只有 for 一种循环语句
• 基本格式如下

for init;condition;post{
	statements
}

init 部分可使用短变量的声明方式
for n:=0;n<5;n++{
	if n%2==0{
		continue
	}
	fmt.Println(n)
}

• 如果只有 condition，则可视为 while 循环

for i <= 3 {
	fmt.Println(i)
	i = i + 1
}

3. Switch

• 相较于 C 语言的 switch，go 的 switch 语句有了很大的增强
  • 可以接受变量
  • 甚至可以什么都没有，一般用来进行错误判断，替换 if else

a := 2
switch a {
case 1:
	fmt.Println("one")
case 2:
	fmt.Println("two")
case 3:
	fmt.Println("three")
case 4, 5:
	fmt.Println("four or five")
default:
	fmt.Println("other")
}

  

t := time.Now()
switch {
case t.Hour() < 12:
	fmt.Println("It's before noon")
default:
	fmt.Println("It's after noon")
}

4. array

• Array 在 go 中不常用，slice 会更方便
• 格式：var name [size1][size2]type
  • var a [5]int
  • var twoD [2][3]int
• 相关函数
  • len：求这个维度上的长度
  • 可以通过下标访问：a[2]

5. slice

• 类似于 C++里的 vector, 可变长度的数组
• 基本格式：s := make([]type,size)
  • 常量声明：name := []type{element1,element2,...}
    • good := []string{"g", "o", "o", "d"}
• 函数
  • append：尾部添加
    • s=append(s,"d") ：在 s 这个字符串后面加了一个 d
    • s=append(s,"e","f") ：在 s 这个字符串后面加了 e 和 f
  • copy（target, source）：复制内容
  • 切片式访问 s[start:end] ：左闭右开
    • s[2:5] ：下标 2 到 4 的元素
    • s[:5] ：第一个元素到下标 4 的元素
    • s[2:] ：下标 2 的元素到最后一个元素

6. map

• 格式：name := make(map[key]value)
  • m := make(map[string]int)

7. range

• 类似于 python 的 range
• 如果 range 后跟的是一个一维数组

for num:= range nums{
	//num代表按顺序拿出的元素
}

for i,num := range nums{
	//i代表自动生成的索引
}

• 如果 range 后跟的是像 map 这类有索引的

for k,v:= range m{
	//k代表键，map的访问顺序随机
	//v代表K对应的值
}

for k := range m{
	//只有一个就只拿索引
}

8. Struct

• 基本格式

type user struct{
	name string
	password string
}

• 声明方式，可以显示写出绑定属性名字，也可以按默认顺序声明

a := user{name: "wang", password: "1024"}
b := user{"wang", "1024"}
c := user{name: "wang"}

• 可以通过 obj. attribute 的方式访问或修改属性

var d user
d.name = "wang"
d.password = "1024"

9. func

• 基本格式：func function_name(args1 type,args2 type)(return1 type,return2 type)
• 如果是成员函数，则将属于的对象提到 func 后，name 前
  • func (args1 type)function_name(args2 type) (return1 type,return2 type)
• 由于 Go 对 C 的语法做了非常多的简化，所以指针一般只是用在函数参数中，代表传入的值可修改
  • func add2ptr(n *int)

10. String

• 使用时需要 import "strings" 包
• 一些基本用法，如下

func main() {

    a := "hello"
    fmt.Println(strings.Contains(a, "ll"))                // true
    fmt.Println(strings.Count(a, "l"))                    // 2
    fmt.Println(strings.HasPrefix(a, "he"))               // true
    fmt.Println(strings.HasSuffix(a, "llo"))              // true
    fmt.Println(strings.Index(a, "ll"))                   // 2
    fmt.Println(strings.Join([]string{"he", "llo"}, "-")) // he-llo
    fmt.Println(strings.Repeat(a, 2))                     // hellohello
    fmt.Println(strings.Replace(a, "e", "E", -1))         // hEllo
    fmt.Println(strings.Split("a-b-c", "-"))              // [a b c]
    fmt.Println(strings.ToLower(a))                       // hello
    fmt.Println(strings.ToUpper(a))                       // HELLO
    fmt.Println(len(a))                                   // 5
    b := "你好"
    fmt.Println(len(b)) // 6

}

# 11. Fmt

• Println：输出会自动换行
• Printf：输出
  • %v 可以代表一切类型
  • %+v 输出详细一点的内容
  • %#v 输出非常详细的内容
  • %.2f 输出两位小数

个人思考

• Go 从 C 语言继承了相似的表达式语法、控制流结构、基础数据类型、调用参数传值、指针等很多思想,做了很大的简化，但却保持了C 语言的高性能，并且将高并发实现为自身的库，可以很方便的写出满足高并发需求的网络程序