【Go基础】快速入门

Go基础入门

用20%的时间学习常用80%的语法

官方网址（下载安装/官方文档/官方类库）

• Download Go binaries from https://go.dev/dl/
• Reference the official Go documentation https://go.dev/doc/
• See all the the Go packages https://pkg.go.dev/
• Access the Go Playground https://go.dev/play/

编译运行与打包

package main
import "fmt"
func main() {
    fmt.Println("Hello, World!")
}
1
2
3
4
5

• go run hello.go

• <GOOS=[darwin|linux|windows] GOARCH=[386|amd64|arm]> go build hello.go

• GOPATH, the path to store models/libraries,default:$HOME/go

语言特性

• 空白格没有特殊意义，不像python，用缩进表示代码块
• 分号可以省略，像javascript

fmt.Println("Hello, World!")
1

• 注释

// 这是单行注释

/*
这是多行注释
*/
1
2
3
4
5

• 变量　大小写区分，由字母数字下划线组成，作用域：包级别／函数级别,变量声明后未使用会报错
• 常量使用 const

// 三种变量的声明与初始化
var　a = 10;　//自动检测类型
var b int; b = 11;// 手动声明类型
c:=10 // 简化声明
// 多变量声明
var a,b=10,"Jim"; 
a,b:=10,"Jim"
1
2
3
4
5
6
7

• 基本数据类型

  • 整型 int, int8, int16, int32, rune, int64, uint, uintptr, uint8, uint16, uint64
  • 浮点 float32 float64
  • 复数 complex32 complex64
  • 字节 byte,in ASCCI
  • 字符串 string,a set of byte vaules
  • 布尔 bool,true/false

• 字符串

var　str = "test";　//必须双引号
len(str) //4 求长度，使用内置len函数
str[0] //读取某个位置字符
str[:2] str[2:] str[:]//te st  test 读取部分子串
str[:2] + str[2:] //test 使用 + 拼接字符串
// 使用内置strings提供的函数库 https://pkg.go.dev/strings
strings.ToUpper() //转大写
strings.ToLower() //转小写
strings.HasPrefix(a, b) //判断a是否以b开始
strings.HasSuffix(a,b) //判断a是否以b结尾
strings.Contains(a,b) //判断a是否包含b子串
strings.Count(a,b) //计算b在a中出现多少次
strings.Join(a string[],sep) //将字符串数组a使用sep拼接起来
strings.Split(a,sep) //将字符串a按sep分隔成字符串数组
strings.ReplaceAll(a,old,new) //将a中所有old字符串替换成new字符串
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 数组

var arr [3]string //声明字符串数组
var arr = [3]string{"a","b","c"} //声明并且赋值
var arr = [...]string{"a","b","c"} 
arr[0] arr[1] //访问
arr[2] = "e" //更新 
len(arr)// 3 求元素数
//复制
a := [...]string{"first","second","third"}
b := a;
a[2]="another"
b[2] // third,保持不变
a[2] // another
1
2
3
4
5
6
7
8
9
10
11
12

• 分片(不同于数组，大小可调整)

//忽悠定义大小
var arr []string  // 声明不带大小
arr := []string{"first","second","third"} // 声明并赋值
arr0 := make([]string,0,10) // 通过make函数创建容量为10的空分片
arr1 := make([]string,3) // 通过make函数创建大小为3的分片
arr2 := append(arr,"forth","fifth")//通过append追加字符串，注意不能直接复制给原来分片
copy(arr1,arr)//将arr赋值给arr1
//来自同一个数组的所有分片共享一份数据，改动其中一个，其他分片受影响
myArray := [3]string{"First", "Second", "Third"} //定义数组
mySlice := myArray[:] //通过数组得到分片1，分片2
mySlice2 := myArray[:]
mySlice[0] = "test" // 改动分片1
mySlice2[0] // test 分片2受影响
1
2
3
4
5
6
7
8
9
10
11
12
13

• Maps

// 声明map,下面两行等价
myMap := make(map[string]int);myMap["a"]=1;// 声明，添加
myMap := map[string]int{"a":1}//声明初始化
myMap["a"]//访问
delete(myMap,"a")//删除
1
2
3
4
5

• 循环

for i:=0;i<10;i++ {
  fmt.Println(i)
}
// go 只有for,可以模拟while
i:=0
for i < 10 {
  fmt.Println(i)
  i++
}
// 省略条件的for,通过break跳出循环
for {
  fmt.Println(i)
  if(i >= 10){
    break
  }
  i++
}
// for 迭代数组使用range
numbers := []int{1,2,3,4,5}
for index,number := range numbers { //使用_替换index,如果不需要index
  fmt.Printf("%d: %d\n", index, number)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

• 条件

// if条件
if age < 12 {
  //child
} else if age < 18  {
  //teen
} else {
  //adult
}
// switch , 不需要break
switch age{
  case 0: fmt.Println("Zero years old")
  case 1: fmt.Println("One year old")
  case 2: fmt.Println("Two years old")
  case 3: fmt.Println("Three years old")
  default: fmt.Println(i + " years old")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 操作符

//比较操作符
== != > < >= <=
//算术运算符
+ - * / %
// 逻辑运算符
&& || !
// 字符串拼接
+
//自增自减
++ --
1
2
3
4
5
6
7
8
9
10

• 结构体(变量集合)

//定义结构体
type Person struct{
  Name string //大写表示public access,小写表示private
  Age int
}
//实例1
jim := Person{}
jim.Age = 20;
jim.Name = "Jim"
//实例2
jim := Person{"Jim",20} 
//实例3
jim := Person{Age:20,Name:"Jim"} 
jim := Person{Name:"Jim"} 

//访问
jim.Name // Jim
jim.Age //20

// 结构体嵌套结构体
type Class struct{
  Teacher Person // 这里　嵌套Person结构体
  NumberOfStudents int
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

• 函数(将代码组成块，并起了名字)

//声明函数(无返回值),调用
func doSomething(a int ,b int){

}
doSomething(1,2)
// 多返回值
func doSomething(a int ,b int) (int,int) {
  return b,a
}
a,b := doSomething(1,3);
// 接收可变参数
func sum(numbers ...int) int {
  total := 0
  for _,number := range numbers {
    total += number
  }
  return total
}
total := sum(1,2,3,4,5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 方法（绑定到结构体的函数）

type Person struct{
  Name string
  Age int
}
func (p Person) Speak(){
  fm.Println("Hello, I'm " + p.Name + "," + p.Age)
}
func (p *Person) Speak(){
  fm.Println("Hello, I'm " + p.Name + "," + p.Age)
}
1
2
3
4
5
6
7
8
9
10

• 指针

age := 20;
ageAddr := &age // 获取内存地址
age2 := *ageAddr // 获取地址对应值

func doSomething( i int){// 值传递
  i = 21;
}
doSomething(age) //没改变age

func doSomething(i *int){ // 指针传递
  *i = 21;
}
doSomething(age) // age 变成 21
1
2
3
4
5
6
7
8
9
10
11
12
13

• 接口(声明一个或多个方法签名)

//声明接口
type Speaker interface{
  Speak()
}
// 定义接收接口的函数
func doSomething(Speaker s){
  s.Speak()
}
//定义实现Speak方法的结构体
type Person strut{
  Name string
}
func (p Person) Speak(){
   fm.Println("Hello, I'm " + p.Name)
}
//实例结构体，并传入已经定义的函数
p := Person{Name:"jim"}
doSomething(p) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18