Go的基础语法(上) ｜ 青训营笔记

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

平时一直都是在使用其他的语言，通过本次青训营接触到Go这门语言，在学习过程中带来了许多惊喜。

Go学习笔记

Go的基础语法(上)

变量

go中变量声明有两张方式

第一种

var 变量名 类型 = 值

它可以自动推断变量类型

var a = "Hello World"
var b = 95152
var c = 95.152
var d = true

也可以指定它的变量类型

var a string = "Hello World"
var b int = 95152
var c float64 = 95.152
var d bool = true

第二种

变量名 := 值

a := "Hello World"
b := 95152
c := 951.52
d := true`

分支结构

if-else结构

if 后面没有括号

num := 10
if num%2 == 0 {
    fmt.Println("This number is even")
} else {
    fmt.Println("This number is odd")
}

switch结构

每个分支后面不需要手动break

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")
}

循环

在go只有一种循环结构，就是for，通过for的三段条件不同也就能实现while，do-while等的功能

// 死循环
for {
    fmt.Println("loop")
    break
}

i := 0
for i <= 3 {
    fmt.Println("i value:", i)
    i++
}

for j := 0; j < 10; j++ {
    fmt.Println("j value:", j)
} 

数组

// 声明一个一维数组
var a [5]int
a[4] = 100

fmt.Println(a, len(a)) // [0 0 0 0 100] 5
// 声明并初始化
b := [5]int{1, 2, 3, 4, 5}
fmt.Println(b) // [1 2 3 4 5]

// 声明一个二维数组
var c [2][3]int
for i := 0; i < 2; i++ {
    for j := 0; j < 3; j++ {
        c[i][j] = i + j
    }
}
fmt.Println(c) // [[0 1 2] [1 2 3]]

切片

切片的长度是不固定的，相当于是一个动态的数组，使用场景更广， 在对切片执行追加(append)操作的时候，如果切片容量不够的话，它会拓展容量并返回一个新的切片， 所以每次执行追加操作的时候都要接收一下它的返回值

切片的声明方式

与声明数组类似，不过它不带长度，不过此时的切片的长度为0

// 数组的声明
var a [5]string
// 切片的声明
var a []string

也可以通过make()函数来制作切片，并设置切片的初始大小

s := make([]string, 3)

对切片执行追加操作

s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"
fmt.Println(s[2], len(s)) // c 3
s = append(s, "d")
s = append(s, "e", "f")
   
fmt.Println(s, len(s)) // [a b c d e f] 6

使用copy(目标, 源)复制切片

hi := []string{"h", "e", "l", "l", "o", ",", "w", "o", "r", "l", "d", "!"}
h := make([]string, len(hi))
copy(h, hi) 
fmt.Println(h) // [h e l l o , w o r l d !]
// 截取切片，左闭右开区间，但不支持负数
fmt.Println(hi[5:8]) // [w o]
fmt.Println(hi[:5]) // [h e l l o]
fmt.Println(hi[4:]) // [w o r l d !]

map

一种较为常用的数据结构

m := make(map[string]int)
m["one"] = 1
m["two"] = 2
fmt.Println(m["one"])
fmt.Println(m["unknown"]) // 0
// 检测map中是否有该键对应的值
r, ok := m["unknown"]
fmt.Println(r, ok) // 0, false 此时为false,即在map中没有键为unknown的值
r, ok = m["two"]
fmt.Println(r, ok) // 2, true 

range

通过 range可以遍历数组等结构，实现其他语言中的foreach结构

nums := []int{2, 3, 4}

for i, num := range nums {
    fmt.Println("index:", i, "num:", num)
}

函数

通过关键字func定义，与其他语言相比，结构上有所不同，它的返回类型后置，并且可以返回多个值

func add(a int, b int) int {
   return a + b
}

func exists(m map[string]string, k string) (v string, ok bool) {
   v, ok = m[k]
   return v, ok
}