Golang基础赋能（二）

### go语⾔循环语句
在go语⾔中不⽀持while语句，它只有for循环，表达式如下
```go
1.for init; condition; post {
	}
ex:
for i := 0; i <= 10; i++ {
sum += i
}
2.for condition {
}
ex:
for ; sum <= 10; {
sum += sum
}
ps：表达式中的init和post都是可以省略的，；也可以省略

如何表达⽆限循环
for true {
sum += sum
}
```

### 循环控制语句
如何在循环体内控制整个循环，在go中提供了3个控制语句
```go
1.break语句 -- ⽤于中断当前for循环或跳出switch语句
ex：
for i := 0; i < 5; i++ {
	if i == 3 {
		break // 当 i 等于 3 时跳出循环
	}
	fmt.Println(i)
}

2.continue语句 -- ⽤于跳过当前循环，进⼊到下⼀次循环中
ex：
for a < 5 {
	if a == 3 {
	/* 跳过此次循环 */
		a = a + 1;
		continue;
	}
	fmt.Printf("a 的值为 : %d\n", a);
	a++;
}

3.goto语句 -- 跳到指定⾏
ex：
var a int = 1
/* 循环 */
for a < 5 {
	if a == 3 {
		/* 跳过迭代 */
		a = a + 1
		goto Test
	}
	fmt.Printf("a的值为 : %d\n", a)
	a++
}

Test:
	fmt.Println(a)
```

### 函数
如同其他的语⾔有函数⼀样， go⾃然也拥有函数的概念，接下来我们看⼀下在golang中式如何定义函数的
```go
1.函数定义
表达式如下：
func function_name(参数1,参数2 类型) [返回类型] {
	函数内容
}

ex：
func max(num1, num2 int) int {
	/* 声明局部变量 */
	var result int
	if (num1 > num2) {
		result = num1
	} else {
		result = num2
	}
	return result
}

与python这些动态语⾔不同， go是静态语⾔，因此需要在传参数的时候标记参数的类型，并且如果该函数中有返回
值，同时还需要表示出返回值的类型

2.函数调⽤
func main() {
	/* 定义局部变量 */
	var a int = 100
	var b int = 200
	
	/* 调⽤函数并返回最⼤值 */
	ret := max(a, b)
	
	fmt.Printf( "最⼤值是 : %d\n", ret )
}

/* 函数返回两个数的最⼤值 */
func max(num1, num2 int) int {
	/* 定义局部变量 */
	var result int
	
	if (num1 > num2) {
		result = num1
	} else {
		result = num2
	}
	return result
}
```

### 变量作⽤域
```go
在go中分为局部变量以及全局变量两种:
- 局部变量：在函数体内声明的变量，只在函数体内⽣效
- 全局变量：在函数体外声明的变量，可以在整个包甚⾄外部包中⽣效

ex：
package main

import "fmt"

/* 声明全局变量 */
var g int
func main() {

/* 声明局部变量 */
	var a, b int

/* 初始化参数 */
	a = 10
	b = 20
	g = a + b
	
	fmt.Printf("结果： a = %d, b = %d and g = %d\n", a, b, g)
}

值得注意的是，在go中如果想要能够在外部包中使⽤定义的变量、函数，需要进⾏⾸字⺟的⼤写

ex：
var A int /*可以在外部包中被引⽤*/
var b int /*不可以在外部包中被引⽤*/
```

### 错误处理
go语⾔与中其他语⾔⼀样，提供了内置的错误异常机制，并针对错误异常机制，提供了处理错误的⽅式
```go
go语⾔中的异常可以划分到类型中，他和int、 string等类型是⼀个级别的，所以我们可以经常看到在golang的那些
程序中，会返回⼀个error类型的返回值，这就是go语⾔中的异常

1.如何创建⼀个异常
//go语⾔作为⼀个流⾏语⾔，⾃然具有让⽤户⾃定义异常的⽅式，具体⽅式如下所示
errors.New("test")

2.异常处理
ex：
（1）写⼀个函数，并返回⼀个异常
func Sqrt(f float64) (float64, error) {
	if f < 0 {
	//返回⼀个异常
	return 0, errors.New("test")
	}
}
（2）接受异常，并进⾏处理
result, err:= Sqrt(-1)

//判断异常是否为空，如果异常为空，返回的值⼀般是nil
if err != nil {
	fmt.Println(err)
}

如上所示，其实在golang中的异常处理⾮常简单，因为它可以简单理解成⼀个对象，因此如何处理完全是在⽤户⾃⼰
的⼿中，你调⽤⼀个函数，该函数返回异常之后，⽤户可以选择在这个异常之后进⾏各种处理
```