Golang 学习笔记:程序结构

Go语言的程序元素

Go语言包含了五种程序符号,分别是标识符(identifier)、关键字(keyword)、运算符(operator)、分隔符(delimiter)与字面量(literal)。这五种程序元素组合成各种表达式和语句。

  • 标识符

    标识符是用于标识变量、函数或任何用户自定义项目的名称(程序实体)

标识符可分为两类,一类是用户定义的标识符,作为程序实体存在;另一类是预定义标识符,它们在Go语言中的源代码被声明(如数据类型)。
还有一个特殊的标识符,叫空标识符,记作 "_",一般用在变量声明与包的导入中。例如,在Go语言程序中,若存在一个没有使用的变量a,那么编译时就会报错,因为Go语言要求存在的程序实体必须被使用,这时就可以使用这样一句 _=a 的代码,编译器就会认为已经使用了变量a(实际上并没有使用),也就不会报错。
在大型的Go语言开发项目中,空标识符的运用很普遍,提高了代码的灵活性和可读性。

  • 关键字

    Go语言作为一门静态强类型的编译语言,它的关键字一共只有25个(均为小写)分别是:

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

    字面量是表示值的一种标记法(其实我觉得这个概念生涩难懂)举个例子很容易就理解是什么了。

var str string = "dog" //str为变量,dog为字面量
const b := 10 //b为变量,10为字面量
  • 分隔符

//fmt.Println("b")使用括号和标点符分隔而成,包含了6个标记
fmt
.
Println
(
"b"
)

程序代码都是通过语句来实现结构化的,但**Go语言的语句结束不需要开发者手动写上分号,编译器会在每一行语句的末尾加上分号,这一过程是自动完成的**。
- 运算符

运算符是用于执行运算或逻辑操作的符号,**Go语言不支持运算符重载**。
在Go语言中,一元运算符的优先级高于二元运算符;如果一个表达式中出现相同优先级的运算符,就根据**从左到右的顺序依次操作**。
需要特别注意的是,在Go语言中,**++和- -是语句,不是表达式,没有运算符优先级一说**。

- 注释
Go语言的注释风格和C语言一样,分为单行注释和多行注释

/*

  • 测试:使用http包实现服务
  • 启动:bee run
  • 访问: curl "http://127.0.0.1:8888/v1/demo"

*/
func main() {

// 初始化一个http.Server
server := &http.Server{}
// 初始化handler并赋值给server.Handler
server.Handler = DemoHandle{}
// 绑定地址
server.Addr = ":8888"
// 启动一个http服务
server.ListenAndServe()

}


## 常量
在Go语言中,常量是编译期间已知,且在执行过程中不会改变的固定值;在Go语言程序中,常量使用 const 关键字定义

//指定常量
const H = 1.287456875623903
//指定常量的类型,float64类型默认保留小数点后15位
const H float64 = 1.28745687562390300000
//bool值
const Return := true
//甚至可以使用中文
const 完满主任 = 100

- 数字表示

Go语言的常量可以是十进制、八进制或十六进制常数
1. 前缀0x或0X的是十六进制
2. 前缀0的是八进制
3. 十进制没有前缀
4. 整数可以有一个后缀,是字母U和L的组合,分别用于表示unsigned和long;后缀字母大小写和顺序都是任意的,但不能重复。

0123 //八进制,合法
0x3a //十六进制,合法
0xFeeL //合法
30l //long,合法
40u //无符号整型,合法
078 //后缀8不是八进制的数,非法
032UU //后缀不能重复,非法

## 转义字符
与其他程序语言一样,Go语言使用反斜杠 " \"表示转义符号,例如换行符 " \n"或制表符 " \t"

func main() {

fmt.Println("Hello\nGo") //换行
fmt.Println("Hello\tGo") //水平

}

以上程序实体的输出结果为:

$ Hello
$ Go
$ Hello Go

## 赋值

func main() {

a := 20
c := 200
c = a
//以下c的值依次被使用
fmt.Println("赋值操作,把a的值赋给c,c的值为:", c) //20
c += a
fmt.Println("相加和赋值运算符,c的值为:", c) //40
c -= a
fmt.Println("相减和赋值运算符,c的值为:", c) //20
c /= a
fmt.Println("相除和赋值运算符,c的值为:", c) //1
c *= a
fmt.Println("相乘和赋值运算符,c的值为:", c) //20
c <<= 2
fmt.Println("左移和赋值运算符,c的值为:", c) //80,正数左移1位相当于乘2 (左边的二进制丢弃,右边补0)
c >>= 2
fmt.Println("右移和赋值运算符,c的值为", c) //40,正数右移1位相当于除2  (正数左补0,负数左补1)
c &= 2
fmt.Println("按位与赋值运算符,c的值为:", c) //0
c ^= 2
fmt.Println("按位异或运算符,c的值为:", c) //2
c |= 2
fmt.Println("按位或和赋值运算符,c的值为:", c) //2

}

Go语言也支持并行赋值的写法:

func main() {
//使用并行赋值的方法

const (
    a, b, c int = 1, 2, 3
    d, e, f int = 4, 5, 6
)

//打印常量a,b,c,d,e,f的值

fmt.Println("分别是:", a, b, c, d, e, f)

}

## 枚举

在C/C++,Java等高级语言中,常常会用到枚举类型表示状态;在Go语言中却没有枚举类型,iota是Go语言的常量计数器,只能在常量的表达式中使用,因此可以借助iota实现枚举。

const (

a       = iota             //使用iota关键字实现枚举,每次const出现时,都会让iota的值初始化为0
b                          //b = 1
c                          //c = 2
d, e, f = iota, iota, iota //d, e, f = 3, 3, 3
g       = iota             // g = 4
h       = "h"              // h = "h"
i                          // i = 6
j       = iota             // j = 7

)
const z = iota // iota初始化为0,因此 z = 0

func main() {

//分别打印:0 1 2 3 3 3 4 h h 7 0
fmt.Println(a, b, c, d, e, f, g, h, i, j, z)

}

## 变量
- 声明变量的标准形式

//定义一个变量a为int型
var a int
//定义一个变量b为bool型
var b bool
//并行定义类型
var (

a, b int
c    bool
str string

)

- 局部变量声明

声明变量有两种写法,一种是像上面使用 = ,另一种是使用赋值运算符号 := 代替。

a := 1 //等价于 a = 1,此处可以省略声明类型,因为编译器会自动推导

Go语言官方推荐使用这种方式声明变量,但有一点必须要注意,**这种声明方式只能被用于函数体内,不可以用于全局变量的声明与赋值。**
- 匿名变量
全局变量自然是全局可用,局部变量只能在相应代码块内使用,除此之外,局部变量还有一个特点就是,定义了后必须要使用(全局变量允许声明但可以不使用)否则编译器会报错。

 但在使用强类型编程语言时,经常会在调用函数时,返回多个值,有时候我们只需要其中的一个值,不需要其他的值,就可以使用匿名变量来解决这个问题。匿名变量可以通过使用空标识符 "_" 来实现。

func GetClass() (ageNum int, stuTeacher string, isGirl bool) { //获取班级信息

return 78, "完满主任", false //多个返回值

}

func main() {

_, stuTeacher, _ := GetClass() //选取完满主任的名字,其他信息使用匿名变量屏蔽

fmt.Println(stuTeacher) //打印

}

- init函数初始化
在Go语言中,除了可以在全局声明中初始化实体,还可以借助init函数初始化,这个函数比较特殊,**它会在包完成初始化后自动执行,执行优先级比main函数更高,并且不能手动调用init函数。**每一个源代码文件有且只有一个init函数,初始化过程会根据包的依赖关系按**顺序单线程执行**。



发表评论

电子邮件地址不会被公开。 必填项已用*标注