第2章 程序结构

Go语言程序元素

标识符 identifier

预定义标识符

bool(true和false)
byte
float32、float64
int、int8、int16、int32、int64
unit、uint8、uint16、uint32、uint64、uintptr
string

append
cap
close
complex
copy
delete
imag
len
make
new
panic
print
println
real
recover

iota
nil
_

自定义标识符

用户自定义的程序实体，同一个代码块中不允许程序实体同名。

使用不同代码包中的实体需要使用包标识符声明，如fmt.Println表示的是使用fmt包中的Println标识符

关键字 keyword

• 包导入声明 import package
• 程序实体声明与定义 var type func``interface map struct chan const
• 流程控制 if else for continue break return go case goto switch select default defer fallthrough range

这些关键字也称保留字，不能用作常量、变量或任何其它标识符名称。除此之外，还有一个比较特殊的类型叫空接口，它的字面量是_

字面量 literal

字面量是表示值的一种标记法，但在Go语言中，字面量含义更广。首先，它用于表示基础数据类型的各种字面量；其次用于表示用户构造的自定义符合数据类型的类型字面量；最后它用于表示复合数据类型的值的复合字面量，简单来说，它会被用来构造类型Struct(结构体)、Array(数组)、Slice(切片)和Map(字典)的值。

const b int = 10    // b为常量，10为字面量
var str string = "hello world"    //    str为变量,hello world为字面量

分隔符 delimiter

括号分隔符：括号、中括号、大括号

标点分隔符：小数点、逗号、分号、冒号、省略号

运算符 operator

Go语言中，一元运算符优先级高于二元运算符，二元运算符优先级如下

注释

// 注释
/* 注释 */
/*
注释
*/

Go语言基本概念

常量

// 常量使用关键字 const 定义，常量定义格式：const identifier[type] = value，如
const Return = true
const hello = "你好,Go语言"
const 人数 = 100
const Pi float32 = 3.1415926536
const Pi = 3.1415926536\
            23846264338327950288\
            4197169399375105820974944\
            5923078164062            
// ↑省略类型说明符[type]，Go语言编译器可智能判断值的类型；

3.14    // 十进制
0213    // 八进制
0x4b    // 十六进制
30u        // 无符号整型,u大小写均可
30l        // long,l大小写均可
078        // 非法
032UU    // 非法

换行符    \n
制表符    \t

a := 20
c = a
c += a
c -= a
c *= a
c /= a
c <<= a
c >>= a
c &= 2
c ^= 2
c |= 2

// 常量实现枚举
const (
    Connected    = 0
    Disconnected = 1
    Unknown      = 2
)
// 使用 iota 关键字实现枚举
const (
    a       = iota             // a==0
    b                          // b==1,隐式使用 iota 关键字,实际等同于 b=iota
    c                          // c==2,实际等同于 c=iota
    d, e, f = iota, iota, iota // d==3,e==3,f==3,同一行值相同,此处不能只写一个iota
    g       = iota             // g==4
    h       = "h"              // h=="h",单独赋值,iota递增为5
    i                          // i=="h",默认使用上边的赋值，iota递增为6
    j       = iota             // j==7
)
const z = iota // 每个单独定义的const常量中,iota都会重置,此时 z==0
func main() {
    fmt.Println(a, b, c, d, e, f, g, h, i, j, z)    // 0 1 2 3 3 3 4 h h 7 0
}

变量

格式 var identifier type

package main
import (
    "fmt"
    "os"
)
func main() {
    fmt.Println(a) // D:\Go
    a := "hello"   // 局部变量定义,写在方法外会报错,一个变量在一个代码块只能被声明一次，但是函数体属于另一个代码块,所以可以重新声明该变量
    fmt.Println(a) // hello
}
var a = os.Getenv("GOPATH") // 全局变量定义,位置不限

func GetClass() (stuNum int, className, headTeacher string) {
    return 49, "一班", "二班"
}
func main() {
    stuNum, _, _ := GetClass() // 只想获取班级人数stuNum,其它不需要
    fmt.Println(stuNum)        // 49
}

int     0
float     0.0
bool    false
string    ""
指针      nil

// Go中，除了可以在全局声明中初始化实体,也可以在 init 函数中初始化。
// init在包完成初始化后自动执行,执行优先级比 main 函数高,且不能手动调用 init 函数
// 每个源文件有且只有一个init函数，初始化过程会根据包的依赖关系按顺序单线程执行
package main
import (
    "fmt"
    "math"
)
var Pi float64
func init() {
    Pi = 4 * math.Atan(1)
}
func main() {
    DPi := Pi * Pi
    fmt.Println(Pi, DPi) // 3.141592653589793 9.869604401089358
}