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,varGo语言有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：类似uint8rune:类似int32uint: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_typev_name = value

第二种，根据值自行判定变量类型。

var v_name = value第三种，省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误。

v_name := value// 例如var a int = 10var b = 10c := 10

3、Go语言多变量声明

//类型相同多个变量, 非全局变量var vname1, vname2, vname3 typevname1, 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 intvar (   a int   b bool)var c, d int = 1, 2var 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 mainimport "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 mainimport "fmt"/* 声明全局变量 */var g intfunc 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 mainimport "fmt"/* 声明全局变量 */var g int = 20func main() {   /* 声明局部变量 */   var g int = 10   fmt.Printf ("结果： g = %d\n",  g)}

4、形式参数

形式参数会作为函数的局部变量来使用。

package mainimport "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 0float32 0pointer 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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport ("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-typevar-type为指针类型，var_name为指针变量名，* 号用于指定变量是作为一个指针。

var ip *int        /* 指向整型*/var fp *float32    /* 指向浮点型 */

2、Go语言指针的使用

指针使用流程：

A、定义指针变量。B、为指针变量赋值。C、访问指针变量中指向地址的值。在指针类型前面加上*号（前缀）来获取指针所指向的内容。

package mainimport "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 mainimport "fmt"func main() {   var  ptr *int   fmt.Printf("ptr 的值为 : %x\n", ptr  )}

4、Go语言指针数组

整型指针数组声明如下：

var ptr [MAX]*int;ptr 为整型指针数组。

package mainimport "fmt"const MAX int = 3func 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 mainimport "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 mainimport "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 */}