Golang

入门语法（一）

1.变量声明

var a int = 10 // 如果不指定值，默认赋值为 0
var b = 10 // 自动推断类型
c : = 10 // 只能在func函数体内实现

• 多变量声明

var a, b int
var c, d int = 1, 2
var e, f = 100, "hello" // 可以是不同类型
var (
    g int
    h bool
) // 这种分解写法，一般用于声明全局变量

2.常量

const LENGTH int = 10
const WIDTH int = 5

• 枚举

const (
    Unknown = 0
    Female = 1
    Male = 2
)

常量表达式中，函数必须是内置函数

const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)

unsafe.Sizeof(a)输出的结果是16。

字符串类型在 go 里是个结构, 包含指向底层数组的指针和长度,这两部分每部分都是 8 个字节，所以字符串类型大小为 16 个字节。

• iota自增长：简化了常量用于增长数字的定义

const (
    CategoryBooks = iota // 0
    CategoryHealth       // 1
    CategoryClothing     // 2
)

iota 和表达式：

type Allergen int


const (
    IgEggs Allergen = 1 << iota   // 1 << 0 which is 00000001
    IgChocolate                   // 1 << 1 which is 00000010
    IgNuts                        // 1 << 2 which is 00000100
    IgStrawberries                // 1 << 3 which is 00001000
    IgShellfish                   // 1 << 4 which is 00010000
)

type ByteSize float64


const (
    _           = iota                   // ignore first value by assigning to blank identifier
    KB ByteSize = 1 << (10 * iota)       // 1 << (10*1)
    MB                                   // 1 << (10*2)
    GB                                   // 1 << (10*3)
    TB                                   // 1 << (10*4)
    PB                                   // 1 << (10*5)
    EB                                   // 1 << (10*6)
    ZB                                   // 1 << (10*7)
    YB                                   // 1 << (10*8)
)

当把两个常量定义在一行时，iota 在下一行增长，而不是立即取得它的引用。

const (
    Apple, Banana = iota + 1, iota + 2
    Cherimoya, Durian
    Elderberry, Fig
)
// Apple: 1
// Banana: 2
// Cherimoya: 2
// Durian: 3
// Elderberry: 3
// Fig: 4

3.函数

• Go 函数可以返回多个值

func swap(x, y string) (string, string) {
 return y, x
}

• init、import、package、main：

  • Go 里面有两个保留的函数：init 函数（能够应用于所有的package）和main函数（只能应用于package main）。这两个函数在定义时不能有任何的参数和返回值；go程序会自动调用init()和main()。
  • 虽然一个package里面可以写任意多个init函数，为了可维护性，建议用户在一个package中，每个文件只写一个init函数。
  • 每个package中的init函数都是可选的，但package main必须包含一个main函数。
• 指针

指针引用写法

/* 定义交换值函数*/
func swap(x *int, y *int) {
   var temp int
   temp = *x    /* 保持 x 地址上的值 */
   *x = *y      /* 将 y 值赋给 x */
   *y = temp    /* 将 temp 值赋给 y */
}

调用：

swap(&a, &b)

4.defer 语句

defer语句被用于预定对一个函数的调用。可以把这类被defer语句调用的函数称为延迟函数。

如果一个函数中有多个defer语句，它们会以LIFO（后进先出）的顺序执行。

func Demo() {
    defer fmt.Println("1")
    defer fmt.Println("2")
    defer fmt.Println("3")
    defer fmt.Println("4")
}
func main() {
    Demo()
}
// output:
// 4
// 3
// 2
// 1

• recover错误拦截

运行时panic异常一旦被引发就会导致程序崩溃。Go语言提供了专用于“拦截”运行时panic的内建函数“recover”。它可以使当前的程序从运行时panic的状态中恢复并重新获得流程控制权。

recover只有在defer调用的函数中有效。

package main

import "fmt"

func Demo(i int) {
    //定义10个元素的数组
    var arr [10]int
    //错误拦截要在产生错误前设置
    defer func() {
        //设置recover拦截错误信息
        err := recover()
        //产生panic异常  打印错误信息
        if err != nil {
            fmt.Println(err)
        }
    }()
    //根据函数参数为数组元素赋值
    //如果i的值超过数组下标 会报错误：数组下标越界
    arr[i] = 10

}

func main() {
    Demo(10)
    //产生错误后 程序继续
    fmt.Println("程序继续执行...")
}