Go语言开发（二）、Go语言基础
一、Go语言程序结构
Go语言程序基本结构如下：
A、包声明
B、引入包
C、函数
D、变量
E、语句 & 表达式
F、注释
package main //包声明
import "fmt" //引入包
func main(){ //main函数
//打印Hello World
fmt.Print("Hello World!")
}二、Go语言基础语法
1、Go语言标记
Go语言程序由多个标记组成，可以是关键字、标识符、常量、字符串、符号。
fmt.Println("Hello, World!")语句由6个标记组成：
fmt
.
Println
(
"Hello, World!"
)2、行分隔符
在Go语言程序中，一行代表一个语句结束。每个语句不需要像C家族中的其它语言一样以分号;结尾。
如果打算将多个语句写在同一行，则必须使用;人为区分，但在实际开发中不推荐。
fmt.Println("Hello, World!")
fmt.Println("Hello, Go!")3、注释
注释不会被编译，每一个包应该有相关注释。
单行注释是最常见的注释形式，可以在任何地方使用以 // 开头的单行注释。 多行注释也叫块注释，均已以 / 开头，并以 / 结尾。
//打印hello world
/*
It print to console a string
*/4、标识符
标识符用来命名变量、类型等程序实体。标识符是由一个或是多个字母(A~Z和a~z)数字(0~9)、下划线_组成的序列，但第一个字符必须是字母或下划线而不能是数字。无效的标识符如下：
1ab（以数字开头）
case（Go语言的关键字）
a+b（运算符是不允许的）
5、关键字
Go语言有25个关键字或保留字：break,case,chan,const,continue,default,defer,else,fallthrough,for,func,go,goto,if,import,interface,map,package,range,return,select,struct,switch,type,var
Go语言有36个预定义标识符：append,bool,byte,cap,close,complex,complex64,complex128,copy,false,float32,float64,imag,int,int8,int16,int32,int64,iota,len,make,new,nil,panic,uint,uint8,uint16,uint32,uint64,uintptr,print,println,real,recover,string,true
程序一般由关键字、常量、变量、运算符、类型和函数组成。
程序中可能会使用到分隔符：括号 ()，中括号 [] 和大括号 {}。
程序中可能会使用到标点符号：.、,、;、: 和 …。
6、空格
Go语言中变量的声明必须使用空格隔开，如：var age int;
语句中适当使用空格能让程序看易阅读。
无空格：fruit=apples+oranges;
在变量与运算符间加入空格，程序看起来更加美观，如：fruit = apples + oranges;
7、可见性规则
Go语言中，使用大小写来决定常量、变量、类型、接口、结构或函数是否可以被外部包所调用。
函数名首字母小写即为private : func getId() {}
函数名首字母大写即为public : func Printf() {}
8、Package
Go语言程序通过package来组织，只有package名称为main的包可以包含main函数。
一个可执行程序有且仅有一个main包。
通过import关键字来导入其他非main包。
可以通过import关键字单个导入:
import "fmt"
import "io"也可以同时导入多个:
import {
"fmt",
"io"}或是：
import (
"fmt"
)使用<PackageName>.<FunctionName>调用:
package别名：import fmt2 "fmt"
为fmt起别名为fmt2
省略调用:调用的时候只需要Println()，而不需要fmt.Println()import . "fmt"
前面加个点表示省略调用，那么调用该模块里面的函数，可以不用写模块名称:
import . "fmt"
func main (){
Println("hello,world")}三、Go语言数据类型
在Go编程语言中，数据类型用于声明函数和变量。
数据类型是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。
1、bool
布尔型的值只可以是常量true或者false。var b bool = true
2、数字类型
整型int和浮点型float32float64，Go语言支持整型和浮点型数字，并且原生支持复数，其中位的运算采用补码。
uint8：无符号8位整型(0到255)
uint16：无符号16位整型(0到65535)
uint32：无符号32位整型(0到4294967295)
uint64：无符号64位整型(0到18446744073709551615)
int8：有符号8位整型(-128到127)
int16：有符号16位整型(-32768到32767)
int32：有符号32位整型(-2147483648到2147483647)
int64：有符号64位整型(-9223372036854775808到 9223372036854775807)
float32：IEEE-754 32位浮点型数
float64：IEEE-754 64位浮点型数
complex64：32位实数和虚数
complex128：64位实数和虚数
byte：类似uint8
rune:类似int32
uint:32或64位
int:与uint一样大小
uintptr:无符号整型，用于存放一个指针
3、字符串类型
字符串就是一串固定长度的字符连接起来的字符序列。Go语言的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本。
4、派生类型
派生类型包括：
A、指针类型（Pointer）
B、数组类型
C、结构化类型(struct)
D、Channel 类型
E、函数类型
F、切片类型
G、接口类型（interface）
H、Map 类型
四、Go语言变量
1、Go语言变量简介
变量是计算机语言中能储存计算结果或能表示值的抽象概念。变量可以通过变量名访问。
Go 语言变量名由字母、数字、下划线组成，其中首个字母不能为数字。
2、Go语言变量声明
声明变量的一般形式使用var关键字：var identifier type
第一种，指定变量类型，声明后若不赋值，使用默认值。
var v_name v_type
v_name = value第二种，根据值自行判定变量类型。var v_name = value
第三种，省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误。
v_name := value
// 例如
var a int = 10
var b = 10
c := 103、Go语言多变量声明
//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3
//不需要显示声明类型，自动推断
var vname1, vname2, vname3 = v1, v2, v3
//出现在:=左侧的变量不应该是已经被声明过的，否则会导致编译错误
vname1, vname2, vname3 := v1, v2, v3
//分解关键字的写法一般用于声明全局变量
var (
vname1 v_type1
vname2 v_type2
)实例：
var x, y int
var (
a int
b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"
//不带声明格式的只能在函数体中出现
//g, h := 123, "hello"4、值类型和引用类型
int、float、bool、string等基本类型都属于值类型，值类型的变量直接指向存在内存中的值。
当使用等号=将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将i的值进行拷贝。
可以通过&i来获取变量i的内存地址，例如0xf840000040（地址随机）。值类型的变量的值存储在栈中。
内存地址会根据机器的不同而有所不同，相同的程序在不同的机器上执行后也会有不同的内存地址。因为每台机器可能有不同的存储器布局，并且位置分配也可能不同。
更复杂的数据通常会需要使用多个字，一般使用引用类型保存。
一个引用类型的变量r1存储的是r1的值所在的内存地址（数字），或内存地址中第一个字所在的位置。
同一个引用类型的指针指向的多个字可以是在连续的内存地址中（内存布局是连续的），也可以将这些字分散存放在内存中，每个字都指示了下一个字所在的内存地址。
当使用赋值语句r2 = r1时，只有引用（地址）被复制。
如果r1的值被改变，r1的所有引用都会指向被修改后的内容。
五、Go语言变量作用域
1、Go语言变量作用域简介
作用域为已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。
Go语言中变量可以在三个地方声明：
A、函数内定义的变量称为局部变量
B、函数外定义的变量称为全局变量
C、函数定义中的变量称为形式参数
2、局部变量
在函数体内声明的变量为局部变量，其作用域只在函数体内，参数和返回值变量也是局部变量。
package main
import "fmt"
func main() {
/* 声明局部变量 */
var a, b, c int
/* 初始化参数 */
a = 10
b = 20
c = a + b
fmt.Printf ("结果： a = %d, b = %d and c = %d\n", a, b, c)
}3、全局变量
在函数体外声明的变量为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。
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语言程序中全局变量与局部变量名称可以相同，但是函数内的局部变量会被优先考虑。
package main
import "fmt"
/* 声明全局变量 */
var g int = 20
func main() {
/* 声明局部变量 */
var g int = 10
fmt.Printf ("结果： g = %d\n", g)
}4、形式参数
形式参数会作为函数的局部变量来使用。
package main
import "fmt"
/* 声明全局变量 */
var a int = 20;
func main() {
/* main 函数中声明局部变量 */
var a int = 10
var b int = 20
var c int = 0
fmt.Printf("main()函数中 a = %d\n", a);
c = sum( a, b);
fmt.Printf("main()函数中 c = %d\n", c);
}
/* 函数定义-两数相加 */
func sum(a, b int) int {
fmt.Printf("sum() 函数中 a = %d\n", a);
fmt.Printf("sum() 函数中 b = %d\n", b);
return a + b;
}5、局部和全局变量的初始化
不同类型的局部和全局变量默认值为：
int 0
float32 0
pointer nil
六、Go语言常量
1、Go语言常量
常量是一个简单值的标识符，在程序运行时，不会被修改的量。
常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
2、Go语言常量声明
常量的定义格式：const identifier [type] = value
可以省略类型说明符[type]，因为编译器可以根据变量的值来推断其类型。
显式类型定义： const b string = "abc"
隐式类型定义： const b = "abc"
多个相同类型的声明可以简写为：const c_name1, c_name2 = value1, value2
常量使用实例：
package main
import "fmt"
func main() {
const LENGTH int = 10
const WIDTH int = 5
var area int
const a, b, c = 1, false, "str" //多重赋值
area = LENGTH * WIDTH
fmt.Printf("面积为 : %d", area)
println()
println(a, b, c)
}3、Go语言枚举
常量可以用作枚举：
const (
Unknown = 0
Female = 1
Male = 2)数字 0、1和2分别代表未知性别、女性和男性。
常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数。
package main
import "unsafe"
const (
a = "abc"
b = len(a)
c = unsafe.Sizeof(a)
)
func main(){
println(a, b, c)
}4、iota
Iota是一个特殊常量，是一个可以被编译器修改的常量。
在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1。
iota可以被用作枚举值：
const (
a = iota
b = iota
c = iota
)第一个iota等于0，每当iota在新的一行被使用时，值都会自动加1，所以a=0, b=1, c=2可以简写为如下形式：
const (
a = iota
b
c
)使用实例：
package main
import "fmt"
func main() {
const (
a = iota //0
b //1
c //2
d = "ha" //独立值，iota += 1
e //"ha" iota += 1
f = 100 //iota +=1
g //100 iota +=1
h = iota //7,恢复计数
i //8
)
fmt.Println(a,b,c,d,e,f,g,h,i)
}存储数据的Byte、KB、MB、GB、TB、PB的计算：
const(
b=1<<(10*iota)
kb
mb
gb
tb
pb
)
func dataByte() {
fmt.Println("b=",b)
fmt.Println("kb=",kb)
fmt.Println("mb=",mb)
fmt.Println("gb=",gb)
fmt.Println("tb=",tb)
fmt.Println("pb=",pb)
}七、Go语言运算符
1、Go语言运算符简介
运算符用于在程序运行时执行数学或逻辑运算。Go语言内置的运算符有：
A、算术运算符
B、关系运算符
C、逻辑运算符
D、位运算符
E、赋值运算符
F、其它运算符
2、算术运算符
+ 相加 A+B
- 相减 A-B
* 相乘 A*B
/ 相除 A/B
% 求余 A%B
++ 自增 A++
-- 自减 A--算术运算实例：
package main
import "fmt"
func main() {
var a int = 21
var b int = 10
var c int
c = a + b
fmt.Printf("相加 - c 的值为 %d\n", c)
c = a - b
fmt.Printf("相减 - c 的值为 %d\n", c)
c = a * b
fmt.Printf("相乘 - c 的值为 %d\n", c)
c = a / b
fmt.Printf("相除 - c 的值为 %d\n", c)
c = a % b
fmt.Printf("求余 - c 的值为 %d\n", c)
a++
fmt.Printf("自增 - a 的值为 %d\n", a)
a--
fmt.Printf("自减 - a 的值为 %d\n", a)
}3、关系运算符
==:检查两个值是否相等，如果相等返回 True 否则返回 False。
!=:检查两个值是否不相等，如果不相等返回 True 否则返回 False。
>:检查左边值是否大于右边值，如果是返回 True 否则返回 False。
<:检查左边值是否小于右边值，如果是返回 True 否则返回 False。
>=:检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
<=:检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。4、逻辑运算符
&&：逻辑AND运算符。 如果两边的操作数都是True，则条件True，否则为False。
||：逻辑OR运算符。 如果两边的操作数有一个True，则条件True，否则为False。
!：逻辑NOT运算符。 如果条件为True，则逻辑NOT条件False，否则为True。5、位运算符
&：按位与运算符"&"是双目运算符，功能是参与运算的两数各对应的二进位进行相与。
|：按位或运算符"|"是双目运算符，功能是参与运算的两数各对应的二进位进行相或。
^：按位异或运算符"^"是双目运算符，功能是参与运算的两数各对应的二进位进行相异或，当两对应的二进位相异时，结果为1。
<<：左移运算符"<<"是双目运算符，左移n位就是乘以2的n次方，功能把"<<"左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。
>>：右移运算符">>"是双目运算符，右移n位就是除以2的n次方，功能是把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。位运算实例：
package main
import "fmt"
func main() {
var a uint = 60 /* 60 = 0011 1100 */
var b uint = 13 /* 13 = 0000 1101 */
var c uint = 0
c = a & b /* 12 = 0000 1100 */
fmt.Printf("& - c 的值为 %d\n", c )
c = a | b /* 61 = 0011 1101 */
fmt.Printf("| - c 的值为 %d\n", c )
c = a ^ b /* 49 = 0011 0001 */
fmt.Printf("^ - c 的值为 %d\n", c )
c = a << 2 /* 240 = 1111 0000 */
fmt.Printf("<< - c 的值为 %d\n", c )
c = a >> 2 /* 15 = 0000 1111 */
fmt.Printf(">> - c 的值为 %d\n", c )
}6、赋值运算符
=：简单的赋值运算符，将一个表达式的值赋给一个左值
+=：相加后再赋值
-=：相减后再赋值
*=：相乘后再赋值
/=：相除后再赋值
%=：求余后再赋值
<<=：左移后赋值
>>=：右移后赋值
&=：右移后赋值
^=：按位异或后赋值
|=：按位或后赋值赋值运算符实例：
package main
import "fmt"
func main() {
var a int = 21
var c int
c = a
fmt.Printf("= 运算符实例，c 值为 = %d\n", c )
c += a
fmt.Printf("+= 运算符实例，c 值为 = %d\n", c )
c -= a
fmt.Printf("-= 运算符实例，c 值为 = %d\n", c )
c *= a
fmt.Printf("*= 运算符实例，c 值为 = %d\n", c )
c /= a
fmt.Printf("/= 运算符实例，c 值为 = %d\n", c )
c = 200;
c <<= 2
fmt.Printf("<<= 运算符实例，c 值为 = %d\n", c )
c >>= 2
fmt.Printf(">>= 运算符实例，c 值为 = %d\n", c )
c &= 2
fmt.Printf("&= 运算符实例，c 值为 = %d\n", c )
c ^= 2
fmt.Printf("^= 运算符实例，c 值为 = %d\n", c )
c |= 2
fmt.Printf("|= 运算符实例，c 值为 = %d\n", c )
}7、其它运算符
&：返回变量存储地址
*：指针变量实例：
package main
import "fmt"
func main() {
var a int = 4
var b int32
var c float32
var ptr *int
/* 运算符实例 */
fmt.Printf("a 变量类型为 = %T\n", a )
fmt.Printf("b 变量类型为 = %T\n", b )
fmt.Printf("c 变量类型为 = %T\n", c )
fmt.Printf("ptr变量类型为 = %T\n", ptr)
/* & 和 * 运算符实例 */
ptr = &a /* 'ptr' 包含了 'a' 变量的地址 */
fmt.Printf("a 的值为 %d\n", a);
fmt.Printf("*ptr 为 %d\n", *ptr);
}8、运算符优先级
有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。
优先级 运算符
7 ^、!
6 * 、/、%、 <<、>>、&、^
5 +、-、|、^
4 ==、!=、<、<=、>=、>
3 <、-
2 &&
1 ||运算符优先级实例：
package main
import "fmt"
func main() {
var a int = 20
var b int = 10
var c int = 15
var d int = 5
var e int
e = (a + b) * c / d // ( 30 * 15 ) / 5
fmt.Printf("(a + b) * c / d 的值为 : %d\n", e)
e = ((a + b) * c) / d // (30 * 15 ) / 5
fmt.Printf("((a + b) * c) / d 的值为 : %d\n", e)
e = (a + b) * (c / d) // (30) * (15/5)
fmt.Printf("(a + b) * (c / d) 的值为 : %d\n", e)
e = a + (b*c)/d // 20 + (150/5)
fmt.Printf("a + (b * c) / d 的值为 : %d\n", e)
}八、Go语言条件语句
1、条件语句简介
条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true来决定是否执行指定语句，并在条件为false的情况在执行另外的语句。
条件语句的结构如下：
2、if语句
if语句由一个布尔表达式后紧跟一个或多个语句组成。
Go编程语言中if语句的语法如下：
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */}If在布尔表达式为true时，其后紧跟的语句块执行，如果为false则不执行。
3、if...else语句
if语句后可以使用可选的else语句, else语句中的表达式在布尔表达式为 false时执行。
Go编程语言中 if...else 语句的语法如下：
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */} else {
/* 在布尔表达式为 false 时执行 */}If在布尔表达式为true时，其后紧跟的语句块执行，如果为false则执行 else语句块。
package main
import "fmt"
func main() {
var a int = 100
var b int = 0
if a > b {
println("a > b")
} else {
fmt.Println("a < b")
}
}4、if嵌套语句
if或else if语句中嵌入一个或多个if或else if语句。
5、switch语句
switch语句用于基于不同条件执行不同动作，每一个case分支都是唯一的，从上直下逐一测试，直到匹配为止。
switch语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break。
Go编程语言中switch语句的语法如下：
switch var1 {
case val1:
...
case val2:
...
default:
...}变量var1可以是任何类型，而val1和val2则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。
switch流程结构如下：
Switch实例如下：
package main
import "fmt"
func grade(score int)string{
var grade string;
switch{
case score<0 && score > 100:
fmt.Printf("score is error")
grade = "Error"
case score < 60:
fmt.Printf("F")
grade = "F"
case score<80:
fmt.Printf("C")
grade = "C"
case score<90:
fmt.Printf("B")
grade = "B"
case score<=100:
fmt.Printf("A")
grade = "A"
}
return grade
}
func operator(a,b int, op string)int{
var result int
switch op {
case "+":
result = a + b
case "-":
result = a -b
case "*":
result = a * b
case "/":
result = a / b
default:
panic("unsupported operator:" + op)
}
return result
}
func main() {
grade(100)
fmt.Println(operator(3,6,"+"))
}switch语句会自动break，不用每个case分支都break，如果要取消break，可以使用fallthrough。Switch后可以不带表达式。
switch语句还可以被用于type-switch来判断某个interface变量中实际存储的变量类型。
Type Switch语法格式如下：
switch x.(type){
case type:
statement(s);
case type:
statement(s);
/* 可以定义任意个数的case */
default: /* 可选 */
statement(s);
}实例：
var x interface{}
switch i := x.(type) {
case nil:
fmt.Printf(" x 的类型 :%T",i)
case int:
fmt.Printf("x 是 int 型")
case float64:
fmt.Printf("x 是 float64 型")
case func(int) float64:
fmt.Printf("x 是 func(int) 型")
case bool, string:
fmt.Printf("x 是 bool 或 string 型" )
default:
fmt.Printf("未知型")
}6、select语句
select是Go中的一个控制结构，类似于用于通信的switch语句。每个case必须是一个通信操作，要么是发送要么是接收。
select随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。一个默认的子句应该总是可运行的。
Go编程语言中select语句的语法如下：
select {
case communication clause:
statement(s);
case communication clause:
statement(s);
/* 可以定义任意数量的 case */
default: /* 可选 */
statement(s);
}select语句中：
A、每个case都必须是一个通信
B、所有channel表达式都会被求值，
C、所有被发送的表达式都会被求值，如果任意某个通信可以进行，它就执行；其他被忽略。
D、如果有多个case都可以运行，Select会随机公平地选出一个执行。其他不会执行。
否则：
如果有default子句，则执行该语句。
如果没有default字句，select将阻塞，直到某个通信可以运行；Go不会重新对channel或值进行求值。
func main() {
var c1, c2, c3 chan int
var i1, i2 int
select {
case i1 = <-c1:
fmt.Printf("received ", i1, " from c1\n")
case c2 <- i2:
fmt.Printf("sent ", i2, " to c2\n")
case i3, ok := (<-c3): // same as: i3, ok := <-c3
if ok {
fmt.Printf("received ", i3, " from c3\n")
} else {
fmt.Printf("c3 is closed\n")
}
default:
fmt.Printf("no communication\n")
}
}九、Go语言循环语句
1、循环语句简介
实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。
循环语句的结构如下：
2、for循环
for循环是一个循环控制结构，可以执行指定次数的循环。
G语言的for循环有3种形式，只有其中的一种使用分号。
for init; condition; post { }
for condition { }
for { }init：一般为赋值表达式，给控制变量赋初值；
condition：关系表达式或逻辑表达式，循环控制条件；
post：一般为赋值表达式，给控制变量增量或减量。
for语句执行过程如下：
A、先对表达式init赋初值；
B、判别赋值表达式init是否满足给定条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行post，进入第二次循环，再判别condition；否则判断condition的值为假，不满足条件，就终止for循环，执行循环体外语句。
for循环的range格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：
for key, value := range oldMap {
newMap[key] = value}for语句的流程结构如下：
实例如下：
package main
import "fmt"
func main() {
var b int = 15
var a int
numbers := [6]int{1, 2, 3, 5}
/* for 循环 */
for a := 0; a < 10; a++ {
fmt.Printf("a 的值为: %d\n", a)
}
for a < b {
a++
fmt.Printf("a 的值为: %d\n", a)
}
for i,x:= range numbers {
fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
}
}3、循环嵌套
Go语言允许用户在循环内使用循环。Go语言嵌套循环的格式：
for [condition | ( init; condition; increment ) | Range]{
for [condition | ( init; condition; increment ) | Range]
{
statement(s);
}
statement(s);}循环嵌套实例：
package main
import "fmt"
func main() {
/* 定义局部变量 */
var i, j int
for i=2; i < 100; i++ {
for j=2; j <= (i/j); j++ {
if(i%j==0) {
break; // 如果发现因子，则不是素数
}
}
if(j > (i/j)) {
fmt.Printf("%d 是素数\n", i);
}
}
}4、循环控制语句
循环控制语句可以控制循环体内语句的执行过程。GO语言支持以下三种循环控制语句：
A、break语句
经常用于中断当前for循环或跳出switch语句。
用于循环语句中跳出循环，并开始执行循环后的语句。
break在switch（开关语句）中在执行一条case后跳出语句的作用。
break 语法格式如下：break;
break语句流程结果如下：
/* 定义局部变量 */
var a int = 10
/* for 循环 */
for a < 20 {
fmt.Printf("a 的值为 : %d\n", a);
a++;
if a > 15 {
/* 使用 break 语句跳出循环 */
break;
}
}B、continue语句
Go语言的continue语句用于跳过当前循环执行下一次循环语句。
for循环中，执行continue语句会触发for增量语句的执行。
continue语法格式如下：continue;
Continue语句流程结构如下：
/* 定义局部变量 */
var a int = 10
/* for 循环 */
for a < 20 {
if a == 15 {
/* 跳过此次循环 */
a = a + 1;
continue;
}
fmt.Printf("a 的值为 : %d\n", a);
a++;
}C、goto语句
Go语言的goto语句可以无条件地转移到过程中指定的行。
goto语句通常与条件语句配合使用。可用来实现条件转移，构成循环，跳出循环体等功能。
在结构化程序设计中一般不主张使用goto语句，以免造成程序流程的混乱，使理解和调试程序都产生困难。
goto语法格式如下：
goto label;
...
label: statement;goto语句流程结构如下：
/* 定义局部变量 */
var a int = 10
/* 循环 */
LOOP: for a < 20 {
if a == 15 {
/* 跳过迭代 */
a = a + 1
goto LOOP
}
fmt.Printf("a的值为 : %d\n", a)
a++
}5、无限循环
如果循环中条件语句永远不为false，则会进行无限循环。可以通过for循环语句中只设置一个条件表达式来实现无限循环。
for true{
fmt.Printf("这是无限循环。\n");
}十、Go语言函数
1、Go语言函数简介
函数是基本的代码块，用于执行一个任务。
Go语言最少有个main()函数。
可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。
函数声明告诉编译器函数的名称、返回类型和参数。
Go语言标准库提供了多种可用的内置的函数。例如，len()函数可以接受不同类型参数并返回该类型的长度。如果传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数。
2、函数定义
Go 语言函数定义格式如下：
func function_name( [parameter list] ) [return_types] {
函数体}函数定义解析：
func：函数由func开始声明
function_name：函数名称，函数名和参数列表一起构成了函数签名。
parameter list：参数列表，参数就像一个占位符，当函数被调用时，可以将值传递给参数，传递的值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，函数可以不包含参数。
return_types：返回类型，函数返回一列值。return_types是返回值的数据类型。有些功能不需要返回值，return_types不是必须的。
函数体：函数定义的代码集合。
函数实例如下：
/* 函数返回两个数的最大值 */
func max(num1, num2 int) int {
/* 声明局部变量 */
var result int
if (num1 > num2) {
result = num1
} else {
result = num2
}
return result
}3、函数调用
当创建函数时，定义函数需要做什么，通过调用该函数来执行指定任务。
调用函数，向函数传递参数，并返回值，例如：
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 100
var b int = 200
var ret int
/* 调用函数并返回最大值 */
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
}4、函数返回值
Go语言函数可以返回多个值。
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("Mahesh", "Kumar")
fmt.Println(a, b)
}5、函数参数
函数如果使用参数，参数变量称为函数的形参。
调用函数，可以通过两种方式来传递参数：
A、值传递
值传递是指在调用函数时将实际参数复制一份传递到函数中，在函数中如果对参数进行修改，将不会影响到实际参数。
B、引用传递
引用传递是指在调用函数时将实际参数的地址传递到函数中，在函数中对参数所进行的修改，将影响到实际参数。
默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。
6、函数用法
A、函数作为值
Go语言可以很灵活的创建函数，并作为值使用。
package main
import (
"fmt"
"math"
)
func main(){
/* 声明函数变量 */
getSquareRoot := func(x float64) float64 {
return math.Sqrt(x)
}
/* 使用函数 */
fmt.Println(getSquareRoot(9))
}B、闭包
Go语言支持匿名函数，可作为闭包。匿名函数是一个"内联"语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必申明。
创建函数getSequence()，函数体内返回另外一个函数。
func getSequence() func() int {
i:=0
return func() int {
i+=1
return i
}
}C、方法
Go语言中同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。语法格式如下：
func (variable_name variable_data_type) function_name() [return_type]{
/* 函数体*/
}方法实例如下：
/* 定义结构体 */
type Circle struct {
radius float64
}
//method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
//c.radius 即为 Circle 类型对象中的属性
return 3.14 * c.radius * c.radius
}杨辉三角的实现如下：
//行数
const LINES int = 10
// 杨辉三角
func PascalTriangle() {
nums := []int{}
for i := 0; i < LINES; i++ {
//补空白
for j := 0; j < (LINES - i); j++ {
fmt.Print(" ")
}
for j := 0; j < (i + 1); j++ {
var length = len(nums)
var value int
if j == 0 || j == i {
value = 1
} else {
value = nums[length-i] + nums[length-i-1]
}
nums = append(nums, value)
fmt.Print(value, " ")
}
fmt.Println("")
}
}十一、Go语言指针
1、Go语言指针的定义
变量是一种使用方便的占位符，用于引用计算机内存地址。
Go语言的取地址符是&，放到一个变量前使用就会返回相应变量的内存地址。
指针变量指向了一个值的内存地址。
指针声明格式如下：var var_name *var-type
var-type为指针类型，var_name为指针变量名，* 号用于指定变量是作为一个指针。
var ip *int /* 指向整型*/
var fp *float32 /* 指向浮点型 */2、Go语言指针的使用
指针使用流程：
A、定义指针变量。
B、为指针变量赋值。
C、访问指针变量中指向地址的值。
在指针类型前面加上*号（前缀）来获取指针所指向的内容。
package main
import "fmt"
func main() {
var a int= 20 /* 声明实际变量 */
var ip *int /* 声明指针变量 */
ip = &a /* 指针变量的存储地址 */
fmt.Printf("a 变量的地址是: %x\n", &a )
/* 指针变量的存储地址 */
fmt.Printf("ip 变量储存的指针地址: %x\n", ip )
/* 使用指针访问值 */
fmt.Printf("*ip 变量的值: %d\n", *ip )
}3、Go语言空指针
当一个指针被定义后没有分配到任何变量时，值为nil。
nil指针也称空指针。
nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。
一个指针变量通常缩写为ptr。
package main
import "fmt"
func main() {
var ptr *int
fmt.Printf("ptr 的值为 : %x\n", ptr )
}4、Go语言指针数组
整型指针数组声明如下：var ptr [MAX]*int;
ptr 为整型指针数组。
package main
import "fmt"
const MAX int = 3
func main() {
a := []int{10,100,200}
var i int
var ptr [MAX]*int;
for i = 0; i < MAX; i++ {
ptr[i] = &a[i] /* 整数地址赋值给指针数组 */
}
for i = 0; i < MAX; i++ {
fmt.Printf("a[%d] = %d\n", i,*ptr[i] )
}
}5、Go语言二级指针
如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。
当定义一个指向指针的指针变量时，第一个指针存放第二个指针的地址，第二个指针存放变量的地址：
指向指针的指针变量声明格式如下：var ptr **int;
访问指向指针的指针变量值需要使用两个*号，如下所示：
package main
import "fmt"
func main() {
var a int
var ptr *int
var pptr **int
a = 3000
/* 指针 ptr 地址 */
ptr = &a
/* 指向指针 ptr 地址 */
pptr = &ptr
/* 获取 pptr 的值 */
fmt.Printf("变量 a = %d\n", a )
fmt.Printf("指针变量 *ptr = %d\n", *ptr )
fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
}6、Go语言指针参数
Go语言允许向函数传递指针，只需要在函数定义的参数上设置为指针类型即可。
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 100
var b int= 200
fmt.Printf("交换前 a 的值 : %d\n", a )
fmt.Printf("交换前 b 的值 : %d\n", b )
/* 调用函数用于交换值
* &a 指向 a 变量的地址
* &b 指向 b 变量的地址
*/
swap(&a, &b);
fmt.Printf("交换后 a 的值 : %d\n", a )
fmt.Printf("交换后 b 的值 : %d\n", b )
}
func swap(x *int, y *int) {
var temp int
temp = *x /* 保存 x 地址的值 */
*x = *y /* 将 y 赋值给 x */
*y = temp /* 将 temp 赋值给 y */
}