Go 语言入门指南：基础语法和常用特性解析 ｜ 青训营

后知后觉402
61 阅读2分钟

Go 语言入门指南：基础语法和常用特性解析 ｜ 青训营

代码来源 github.com/wangkechun/…

1. Hello World

  • 代码示例：
goCopy code
package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

  • 笔记：

    • Go 程序的入口是 main 函数。
    • import "fmt" 导入了一个名为 fmt 的包，用于格式化输入输出。
    • fmt.Println() 用于将内容输出到控制台。

2. Values

  • 代码示例：
goCopy code
package main

import "fmt"

func main() {
    fmt.Println("go" + "lang")
    fmt.Println("1+1 =", 1+1)
    fmt.Println("7.0/3.0 =", 7.0/3.0)
    fmt.Println(true && false)
    fmt.Println(true || false)
    fmt.Println(!true)
}

  • 笔记：

    • Go 支持基本的字符串、整数、浮点数和布尔值类型。
    • 字符串可以通过 + 运算符连接。
    • 数值计算和逻辑运算的语法与其他编程语言类似。

3. Variables

  • 代码示例：
goCopy code
package main

import "fmt"

func main() {
    var a = "initial"
    fmt.Println(a)

    var b, c int = 1, 2
    fmt.Println(b, c)

    var d = true
    fmt.Println(d)

    var e int
    fmt.Println(e)

    f := "apple"
    fmt.Println(f)
}

  • 笔记：

    • 使用 var 关键字声明变量。
    • 可以在一行中声明多个变量。
    • 如果变量有初始值，可以省略类型，Go 会自动推断类型。
    • 声明变量但不初始化时，数值类型会被赋予零值，布尔类型为 false，字符串为空字符串。
    • 使用 := 语法可以在函数内部声明并初始化变量，且类型由右侧的值推断出。

4. Constants

  • 代码示例：
goCopy code
package main

import "fmt"

const s string = "constant"

func main() {
    fmt.Println(s)

    const n = 500000000
    const d = 3e20 / n
    fmt.Println(d)

    fmt.Println(int64(d))

    fmt.Println(math.Sin(n))
}

  • 笔记：

    • 使用 const 关键字定义常量。
    • Go 支持字符、字符串、布尔和数值类型的常量。
    • 常量表达式可以进行任意精度的计算。
    • 注意导入 math 包以使用 math.Sin() 函数。

5. Loops

  • 代码示例：
goCopy code
package main

import "fmt"

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

    for j := 7; j <= 9; j++ {
        fmt.Println(j)
    }

    for {
        fmt.Println("loop")
        break
    }
}

  • 笔记：

    • 使用 for 循环进行迭代，与 C 或 Java 类似。
    • for 循环也可以只使用条件语句，相当于 while 循环。
    • 使用 break 可以跳出循环。
    • 使用 for { ... } 可以创建一个无限循环。

6. Conditional Statements

  • 代码示例：
goCopy code
package main

import "fmt"

func main() {
    if 7%2 == 0 {
        fmt.Println("7 is even")
    } else {
        fmt.Println("7 is odd")
    }

    if 8%4 == 0 {
        fmt.Println("8 is divisible by 4")
    }

    if num := 9; num < 0 {
        fmt.Println(num, "is negative")
    } else if num < 10 {
        fmt.Println(num, "has 1 digit")
    } else {
        fmt.Println(num, "has multiple digits")
    }
}

  • 笔记：

    • 使用 if 条件语句进行条件判断。
    • 可以在条件语句前面添加一个初始化语句，作用范围仅在该条件语句内。
    • 可以有多个 else if 分支。
    • 如果没有匹配的分支，最后的 else 语句会被执行（可选）。

7. Switch Statements

  • 代码示例：
goCopy code
package main

import (
	"fmt"
	"time"
)

func main() {
	i := 2
	fmt.Print("Write ", i, " as ")
	switch i {
	case 1:
		fmt.Println("one")
	case 2:
		fmt.Println("two")
	case 3:
		fmt.Println("three")
	}

	switch time.Now().Weekday() {
	case time.Saturday, time.Sunday:
		fmt.Println("It's the weekend")
	default:
		fmt.Println("It's a weekday")
	}

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

  • 笔记：

    • 使用 switch 语句根据不同的条件进行不同的操作。
    • 可以匹配多个值，也可以使用逗号分隔。
    • switch 语句可以不带条件，这时它会匹配第一个为 true 的条件。
    • 使用 default 分支来处理没有匹配的情况。

8. Arrays

  • 代码示例：
goCopy code
package main

import "fmt"

func main() {
    var a [5]int
    fmt.Println("emp:", a)

    a[4] = 100
    fmt.Println("set:", a)
    fmt.Println("get:", a[4])

    fmt.Println("len:", len(a))

    b := [5]int{1, 2, 3, 4, 5}
    fmt.Println("dcl:", b)

    var twoD [2][3]int
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

  • 笔记：

    • 使用 var arr [size]type 声明数组，其中 size 为数组大小，type 为元素类型。
    • 使用索引访问数组元素，索引从 0 开始。
    • 使用 len() 获取数组的长度。
    • 使用 := 语法初始化数组。
    • 多维数组的声明和操作与一维数组类似。

9. Slices

  • 代码示例：
goCopy code
package main

import "fmt"

func main() {
    s := make([]string, 3)
    fmt.Println("emp:", s)

    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])

    fmt.Println("len:", len(s))

    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)

    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)

    l := s[2:5]
    fmt.Println("sl1:", l)

    l = s[:5]
    fmt.Println("sl2:", l)

    l = s[2:]
    fmt.Println("sl3:", l)

    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)

    twoD := make([][]int, 3)
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

  • 笔记：

    • 切片是对数组的一个引用，它可以自动扩容。
    • 使用 make([]T, length, capacity) 创建一个切片，T 为元素类型，length 为初始长度，capacity 为可选的预分配容量。
    • 使用 append() 函数可以向切片中添加元素。
    • 使用 copy(dst, src) 函数复制切片。
    • 切片的切割操作形式为 slice[low:high]。

10. Maps

  • 代码示例：
goCopy code
package main

import "fmt"

func main() {
    m := make(map[string]int)

    m["k1"] = 7
    m["k2"] = 13

    fmt.Println("map:", m)

    v1 := m["k1"]
    fmt.Println("v1:", v1)

    fmt.Println("len:", len(m))

    delete(m, "k2")
    fmt.Println("map:", m)

    _, prs := m["k2"]
    fmt.Println("prs:", prs)

    n := map[string]int{"foo": 1, "bar": 2}
    fmt.Println("map:", n)
}

  • 笔记：

    • 使用 make(map[keyType]valueType) 创建一个 map。
    • 使用 map[key] = value 语法添加键值对。
    • 使用 len() 获取 map 的长度。
    • 使用 delete(map, key) 删除键值对。
    • 使用 _ 忽略返回值，用于检查键是否存在。
    • 使用 map[key]value 语法可以初始化 map。

11. Range

  • 代码示例：
goCopy code
package main

import "fmt"

func main() {
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)

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

    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }

    for k := range kvs {
        fmt.Println("key:", k)
    }

    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

  • 笔记：

    • 使用 for range 迭代数组、切片、字符串和 map。
    • 对于数组和切片，第一个值是索引，第二个值是元素的拷贝。
    • 对于 map，第一个值是键，第二个值是对应的值。
    • 使用 _ 忽略索引或值。

12. Functions

  • 代码示例：
goCopy code
package main

import "fmt"

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

func plusPlus(a, b, c int) int {
    return a + b + c
}

func main() {
    res := plus(1, 2)
    fmt.Println("1+2 =", res)

    res = plusPlus(1, 2, 3)
    fmt.Println("1+2+3 =", res)
}

  • 笔记：

    • 使用 func 关键字声明函数。
    • 函数可以有参数和返回值，参数和返回值的类型都写在参数列表后面。
    • 多个连续参数的类型相同时，可以省略前面的类型声明。
    • 函数可以被调用并传入参数，返回计算结果。
avatar
文章
阅读
粉丝