Skip to content

Go-basic-syntax.md

Latest commit

 

History

History
199 lines (143 loc) · 5.48 KB

Go-basic-syntax.md

File metadata and controls

199 lines (143 loc) · 5.48 KB

Go 基础语法

该教程主要针对：Go 基础语法 学习。

目录：

声明

变量

var 声明语句可以创建一个特定类型的变量，其一般语法如下：

// var 变量名字 类型 = 表达式
var a int = 3 // 单个变量 - int

其中 类型 和 表达式 两个可以省略其中一个：

  • 省略 类型：将根据初始化表达式来推导变量的类型信息。
  • 省略 表达式：将用零值初始化该变量。
    • 数值类型变量对应的零值是 0；
    • 布尔类型变量对应的零值是 false；
    • 字符串类型对应的零值是 ""，
    • 接口或引用类型（包括 slice、指针、map、chan 和函数）变量对应的零值是nil。
    • 数组或结构体等聚合类型对应的零值是每个元素或字段都是对应该类型的零值。

零值初始化机制可以确保每个声明的变量总是有一个良好定义的值，因此在 Go 语言中不存在未初始化的变量。

一个声明语句中同时声明一组变量，或用一组初始化表达式声明并初始化一组变量。

var i, j, k int                 // int, int, int
var b, f, s = true, 2.3, "four" // bool, float64, string

简短变量声明

在函数内部，可以用 名字 := 表达式 形式声明和初始化 局部变量。变量的类型根据表达式来自动推导。

和 var 形式声明语句一样，简短变量声明语句也可以用来声明和初始化一组变量：

i, j := 0, 1

指针

任何类型的指针的零值都是 nil。如果 p 指向某个有效变量，那么 p != nil 测试为真。

指针之间也是可以进行相等测试的，只有当它们指向同一个变量或全部是 nil 时才相等。

在 Go 语言中，返回函数中局部变量的地址也是安全的。例如下面的代码，调用 f 函数时创建局部变量 v，在局部变量地址被返回之后依然有效，因为指针 p 依然引用这个变量。

var p = f()

func f() *int {
    v := 1
    return &v
}

new 函数

表达式 new(T) 将创建一个 T 类型的匿名变量，初始化为 T 类型的零值，然后返回变量地址，返回的指针类型为 *T。

p := new(int)   // p, *int 类型, 指向匿名的 int 变量
fmt.Println(*p) // "0"

常量

常量的定义格式：

const identifier [type] = value

与变量类似，可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

常量还可以用作枚举：

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

扩展： iota

const (
        a = iota   //0
        b          //1
        c          //2
        d = "ha"   //独立值，iota += 1
        e          //"ha"   iota += 1
        f = 100    //iota +=1
        g          //100  iota +=1
        h = iota   //7,恢复计数
        i          //8
)
// 0 1 2 ha ha 100 100 7 8
fmt.Println(a,b,c,d,e,f,g,h,i)

赋值

元组赋值

元组赋值允许同时更新多个变量的值，在赋值之前，赋值语句右边的所有表达式将会先进行求值，然后再统一更新左边对应变量的值。

// 交换变量值
x, y = y, x

函数

函数声明：

函数声明包括函数名、形式参数列表、返回值列表（可省略）以及函数体。

func name(parameter-list) (result-list) {
    body
}

实参通过值的方式传递，因此函数的形参是实参的拷贝。对形参进行修改不会影响实参。但是，如果实参包括引用类型，如指针，slice(切片)、map、function、channel 等类型，实参可能会由于函数的间接引用被修改。

多返回值：

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

func main() {
   a, b := swap("Google", "Runoob")
   fmt.Println(a, b)
}

如果某个调用多返回值函数时，返回给调用者的是一组值，调用者必须显式的将这些值分配给变量，但值不被使用，可以将其分配给 blank identifier:

links, _ := findLinks(url)

可变参数：

在声明可变参数函数时，需要在参数列表的最后一个参数类型之前加上省略符号“...”，这表示该函数会接收任意数量的该类型参数。

func sum(vals ...int) int {
    total := 0
    for _, val := range vals {
        total += val
    }
    return total
}

sum 函数返回任意个 int 型参数的和。在函数体中，vals 被看作是类型为 [] int 的切片。sum 可以接收任意数量的 int 型参数：

fmt.Println(sum())           // "0"
fmt.Println(sum(3))          // "3"
fmt.Println(sum(1, 2, 3, 4)) // "10"

在上面的代码中，调用者隐式的创建一个数组，并将原始参数复制到数组中，再把数组的一个切片作为参数传给被调用函数。如果原始参数已经是切片类型，则可以通过以下方式调用：

values := []int{1, 2, 3, 4}
fmt.Println(sum(values...)) // "10"

参考链接