写在前面

今天来聊一聊golang中程序结构相关的话题，具体包括条件语句、循环、函数和指针等内容。

条件语句

if语句

给定一个自然数v，如果它在0-100之间则返回v，若大于100则返回100，小于0则返回0，使用Go语言实现的代码如下：

package main

import "fmt"

func ifTest(v int) int{

if v >100 { //if的条件里面不需要括号

return 100

}else if v <0 {

return 0

}else {

return v

}

}

func main() {

var a int = ifTest(5)

fmt.Println(a)

}

//运行结果：

5

注意到没有if的条件里面不需要括号，创建的文件中不能包含下划线。func ifTest(v int) int中参数v的前面不需要添加var关键词，后面的int则是该函数的返回结果。

现在来使用Go语言来读取某个文件的信息，如test.txt中的内容，相应的代码如下：

package main

import (

"fmt"

"io/ioutil"

)

func readFieTest(){

const filename = "test.txt"

contents, errorinfo :=ioutil.ReadFile(filename)

//var contents ,errorinfo = ioutil.ReadFile(filename)

if errorinfo != nil {

fmt.Println(errorinfo)

}else{

fmt.Printf("%s\n",contents)

}

}

func main() {

readFieTest()

}

读取文件需要采用ioutil包中的ReadFile函数，查看源码可知该函数一次可以返回两个值：

func ReadFile(filename string) ([]byte, error) {

......

}

if errorinfo != nil中的nil就是无的意思，此处就是产生了错误，可以参考这篇文章了解更多关于nil的信息：理解Go语言的nil 。其实上面那种方式不是很简介，可以使用类似于Java中的三元表达式：

package main

import (

"fmt"

"io/ioutil"

)

func readFieTest(){

const filename = "test.txt"

if contents, errorinfo := ioutil.ReadFile(filename) ;errorinfo != nil {

//先运行前半句后进行判断

fmt.Println(errorinfo)

}else {

fmt.Printf("%s",contents)

}

}

func main() {

readFieTest()

}

发现没有if的条件里可以进行赋值，且if条件里赋值的变量作用域就是这个if语句。接下来聊一聊switch，很多语言中都有switch。

switch语句

switch后面是可以接表达式的（也可以不接），使用Go实现计算某两个整数的加减乘除的功能，相应的代码如下：

package main

import "fmt"

func eval(a, b int,operation string) int {

var result int

switch operation {

case "+":

result = a +b

case "-":

result = a-b

case "*":

result = a*b

case "/":

result = a/b

default:

panic("不支持的运算方式"+operation) //这个panic就是报错，让程序停下来

}

return result

}

func main() {

test:= eval(3,4,"*")

fmt.Println(test)

}

//运行结果：

12

细心的你发现什么奇特之处么？对，里面没有break，因为Go语言中的switch会自动break，除非使用了fallthrough。而在C、C++或者是Java中你要么在后面添加break要么添加continue。

再来举一个例子，用于判断学生成绩情况：当分数小于60，则显示不及格；60-69为及格；70-79为中等；80-89为良好；90-100为优秀。使用Go语言实现的代码如下：

package main

import "fmt"

func scoreTest(score int)string {

var result string = ""

switch {

case score <0 ||score >100 :

panic(fmt.Sprintf("无效的分数:%d",score)) //如果这个条件成立，则程序不再往下执行

case score <60:

result = "不及格"

case score<70:

result = "及格"

case score <80:

result = "中等"

case score <90:

result = "良好"

case score <=100:

result = "优秀"

}

return result

}

func main() {

fmt.Println(

scoreTest(59),

scoreTest(62),

scoreTest(77),

scoreTest(84),

scoreTest(99),

//scoreTest(-99),

)

}

//运行结果：

不及格 及格 中等 良好 优秀

如果程序满足panic的要求，则程序会停止运行。switch后面可以没有表达式

循环语句

for语句

使用Go语言实现求解0-指定数字内的数字之和，如100以内整数的和，相应的代码如下：

package main

import "fmt"

func sumTest(a int) int {

sum := 0

for i :=0;i<=a;i++ {

sum+=i

}

return sum

}

func main() {

fmt.Println(sumTest(100))

}

上面使用了for循环，可以发现这个for循环的格式除了条件中不包含括号以外，其实和Java，JavaScript的代码完全一致。且大家要学会在函数中尽量使用:=的方式替代var来声明变量。

for的条件中不包含括号，且条件中可省略初始条件，结束条件以及递增表达式

再来看一个例子，将整数转换成二进制的表达式，相应的代码如下：

package main

import (

"fmt"

"strconv"

)

func intToBinary(n int)string {

result := ""

for ;n>0;n/=2{ //省略初始条件，相当于while

lsb := n%2

result = strconv.Itoa(lsb) +result

}

return result

}

func main() {

fmt.Println(

intToBinary(5), // 101

intToBinary(13), //1101

intToBinary(121242),

)

}

再来换一种方式读取之前那个test.txt文件中的内容，现在是一行行的进行读取：

//一行行读取

func printFileTest(filename string){

file, err :=os.Open(filename)

if err != nil{

panic(err) //程序停下来去报错

}else{

scanner := bufio.NewScanner(file)

for scanner.Scan(){

// 这里既没有开始条件，也没有递增条件，只有结束条件，此时分号都可以不写，Go语言中没有while

fmt.Println(scanner.Text()) //输出

}

}

}

func main() {

printFileTest("test.txt")

}

在这段代码里面for中既没有开始条件，也没有递增条件，只有结束条件，那么此时的分号都可以不写，记住Go语言中没有while。因为while的功能和for相似，所以Go语言中就没有必要存在while这个关键词了。

当for中什么也不加，则变成了一个死循环，就相当于其他语言中的while true。Go语言中的死循环实现起来非常简单，那是因为后面会经常使用到死循环。

简单总结一下循环语句的特点：1、for和if条件后面没有括号；2、if条件里面也可以定义变量；3、Go语言中没有while；4、switch中不需要定义break，也可以直接switch多个语句。

函数

其实在前面我们就使用了func这个关键词用于定义函数，函数定义的格式为：

func 函数名称(参数名称，参数类型)返回值类型{

......

}

需要说明的是，Go语言的函数可以有多个返回值的，且类型可以不相同：

package main

import "fmt"

//求解两个数的和

func sumTest(a,b int)int{

return a+b

}

//求两个数相除的商及余数

func divTest(a ,b int) (int,int, string) {

return a/b, a%b, "你好"

}

func main() {

fmt.Println(sumTest(3,6))

fmt.Println(divTest(13, 4))

}

//运行结果：

9

3 1 你好

在上面的代码中不知道返回的到底是什么，只知道都是int类型，其实可以像声明变量的方式那样给返回值设置名称：

//求两个数相除的商及余数

func divTest(a ,b int) (q, r int, s string) {

return a/b, a%b, "你好"

}

由于Go语言非常严格，定义的变量一定要使用，如果函数有多个返回值，我们只想取某个值时，那么其余的变量可以使用匿名变量_来接收。尽管Go语言支持返回多个类型值，但是不要乱用，一般返回两个，前者是数据，后者是错误nil，如下图所示。将前面实现两个数的四则运算的相关代码进行改写：

package main

import "fmt"

func calcTest(a, b int,operation string ) (int, error) {

switch operation {

case "+":

return a+b, nil

case "-":

return a-b,nil

case "*":

return a*b,nil

case "/":

return a/b,nil

default:

return 0,fmt.Errorf("不支持的运算操作:%s",operation)

}

}

func main() {

fmt.Println(calcTest(3,5,"+"))

}

//运行结果：

8

上述代码其实还不够完善，在main方法中对正常与否需要进行判断：

func main() {

if result ,err:= calcTest(3,5,"+");err != nil{

//程序运行存在错误

fmt.Println("程序运行存在错误",err)

}else{

fmt.Println(result)

}

}

在Go语言中函数可以返回多个值，且可以给多个值声明名称，但是返回多个值的情况仅仅适用于非常简单的函数，不过取不取名字和调用者无关。

Go语言是函数式编程，函数是一等公民（Python中也是），函数里面的参数，返回值里面都可以包含函数。通过前面求两个数的四则运算这个例子进行改写，实现将函数作为参数：

Go语言没有其他语言中的默认参数、可变参数、函数重载等，只有一个可变参数列表:

//求可变参数列表中参数之和

func dynamicVariable(values ... int)int {

sum :=0

for i:=range values{

sum+=values[i]

}

return sum

}

func main() {

fmt.Println(dynamicVariable(1,2,3,4,5,6))

}

//运行结果：

21

函数小结：1、函数返回值的类型写在最后面；2、函数可以返回多个值；3、函数可作为参数进行使用；4、没有默认参数和可选参数，函数重载等。

指针

大家不要听到指针就害怕，Go语言中的指针和C语言中的指针差别很大（Go语言中的指针不能运算，而C语言中却可以），比C中的指针简单多了。

看到这里就必须谈到一个老生常谈的问题：Go语言中的参数传递是值传递还是引用传递？在C和C++中既可以值传递也可以引用传递。Java和Python绝大部分都是引用传递，除了系统的自建类型以外。那么什么是值传递？什么是引用传递呢？我们通过C++中的一段代码进行了解（C++中使用&表示引用传递）：

void pass_by_value(int a){ //值传递

a++;

}

void pass_by_guide(int& a){ //引用传递

a++;

}

int main(){

int a =3;

pass_by_value(a)

printf("值传递以后的值为：%d\n",a);

pass_by_guide(a)

printf("引用传递以后的值为：%d\n",a);

}

//运行结果：

3 4

pass_by_value是值传递，会将a的值从main函数中拷贝一份到pass_by_value函数中，真正作了一份拷贝，拷贝进去的a加了1，那么main函数中的a并没有发生变化，没有动依旧是3。pass_by_guide是引用传递，它不会拷贝，此时main函数中的a和pass_by_guide中的a其实是引用了同一个变量a，因此在pass_by_guide函数中进行了加1操作，自然main函数中的a也会发生变化，因此就变成了4。值传递就是拷贝，原来值不会发生变化；引用传递不会拷贝，会导致原来的值发生变化。

Go语言只有值传递一种方式。Go语言中的参数需要配合其指针来使用，具体分情况：

上面这种就是值传递，两者没有影响。下面是使用到了指针的情况：

左侧是一个int类型名为a的变量，右侧是一个int类型名为aa的指针，通过指针实现相当于引用传递的效果，把a的地址给了你以后，可以修改a的值。这些都是基本数据类型，再来尝试一个自定义类型：

当把左侧的book对象传给右侧的read函数时，一般这个book对象本身通常包含指向data的一个指针，然后拷贝一份到右侧函数中，右侧的book对象也有一个pdata，但是是指向同一个data，其实就是拷贝了同一份指针。因此在Go语言中，自定义类型的时候需要考虑把它作为一个值还是一个指针来用。这里的book其实就是作为一个值来用。

用一个交换两个对象的值这个例子来加深大家的印象：

//交换两个对象的值

func swap(a,b int) {

a,b = b ,a

}

func main() {

a ,b := 1,2

swap(a,b)

fmt.Println(a, b)

}

//运行结果：

1,2

你会发现这个函数没有用，两个数值并没有发生交换，的确是这样的，那是因为这个需要借助于指针来完成：

//交换两个对象的值

func swap(a,b *int) {

*a,*b = *b ,*a //声明指针需要使用*

}

func main() {

a ,b := 1,2

swap(&a,&b) //传递地址需要使用&

fmt.Println(a, b)

}

//运行结果：

2,1

不过这种看起来挺麻烦的，其实之前的代码不是没有起作用，而是没有将结果进行返回，修改一下代码其实是可以的：

func swapTest(a,b int)(int ,int) {

return b ,a

}

func main() {

a ,b := 1,2

a, b = swapTest(a,b)

fmt.Println(a, b)

}

//运行结果：

2,1

这样就通过接收函数的返回值，进而实现交换两个数值的目的。至此程序结构部分就聊到这里，后续介绍内建容器和面向对象，面向接口等方面的知识。