Go语言程序结构结构

Go语言结构

Go语言的基础组成包括：

• 包声明
• 引入包
• 函数
• 变量
• 语句&表达式
• 注释

例如：

package main

import "fmt"

func main() {
   /* 输出Hello，World！*/
   fmt.Println("Hello, World!")
}

1 命名

Go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个简单的命名规则：

名字必须以一个字母或下划线开头，后面可以跟任意数量的字母、数字或下划线(区分大小写)。25个关键字不能用于自定义名字。

• 名字在函数内部定义，就只在函数内部有效。
• 在函数外部定义，在当前包的所有文件中都可以访问。
• 名字是大写字母开头的,可以被外部的包访问。

Go语言程序员推荐使用驼峰式命名

2 声明

声明语句定义了程序的各种实体对象以及部分或全部的属性。

Go语言主要有四种类型的声明语句：

• var: 变量
• const: 常量
• type: 类型
• func: 函数

3 变量

3.1 一般声明

一般语法：

var 变量名 类型 = 表达式

可以省略“类型”或“= 表达式”

例子：

var myName string
var myWife = "斋藤飞鸟"

或者声明一组变量，如：

var a, b, c int 		// int, int, int
var myWife, age, really = "飞鸟", 21, true // string, int, bool 

3.2 简短变量声明

用于声明和初始化局部变量。例如：

i, j := 0, 1

交换值

i, j = j, i // 交换 i 和 j 的值

3.3 指针

一个变量对应一个保存了变量对应类型值的内存空间。
每一个变量必然有对应的内存地址。
一个指针的值是另一个变量的地址。
一个指针对应变量在内存中的存储位置。
例如：
“var x int”声明语句声明一个x变量
&x表达式产生一个指向该整数变量的指针，指针对应的数据类型是*int
“p = &x”,p指针保存了x变量的内存地址,*p表达式对应p指针指向的变量的值。
例子

x := 1
p := &x         // p, of type *int, points to x
fmt.Println(*p) // "1"
*p = 2          // equivalent to x = 2
fmt.Println(x)  // "2"

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

var x, y int
fmt.Println(&x == &x, &x == &y, &x == nil) // "true false false"

函数返回变量地址：

var p = f()

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

func incr(p *int) int {
    *p++ // 非常重要：只是增加p指向的变量的值，并不改变p指针！！！
    return *p
}

v := 1
incr(&v)              // side effect: v is now 2
fmt.Println(incr(&v)) // "3" (and v is 3)

3.4 new函数

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

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

new函数使用通常相对比较少

3.5 变量的声明周期

变量的生命周期指的是在程序运行期间变量有效存在的时间间隔。

包一级声明的变量，命周期和整个程序的运行周期是一致的。

局部变量的声明周期则是动态的：每次从创建一个新变量的声明语句开始，直到该变量不再被引用为止，然后变量的存储空间可能被回收。函数的参数变量和返回值变量都是局部变量。它们在函数每次被调用的时候创建。

4 赋值

使用赋值语句可以更新一个变量的值

x = 1                       // 命名变量的赋值
*p = true                   // 通过指针间接赋值
person.name = "bob"         // 结构体字段赋值
count[x] = count[x] * scale // 数组、slice或map的元素赋值

数值变量也可以支持++递增和--递减语句（译注：自增和自减是语句，而不是表达式，因此x = i++之类的表达式是错误的）

v := 1
v++    // 等价方式 v = v + 1；v 变成 2
v--    // 等价方式 v = v - 1；v 变成 1

4.1 元祖赋值

元组赋值允许同时更新多个变量的值。

x, y = y, x
a[i], a[j] = a[j], a[i]
i, j, k = 2, 3, 5

5 类型

一个类型声明语句创建了一个新的类型名称，和现有类型具有相同的底层结构。

新命名的类型提供了一个方法，用来分隔不同概念的类型，这样即使它们底层类型相同也是不兼容的。

type 类型名字 底层类型

类型声明语句一般出现在包一级，因此如果新创建的类型名字的首字符大写，则在外部包也可以使用。