Xenolies Blog
Xenolies Blog

Golang语言基础

Xenolies Xenolies 收录于 笔记
   约 3337 字  预计阅读 16 分钟 

其他相关笔记: [[派蒙bot开发环境配置]] [[Golang常用标准库]]

什么是Go语言

Go 语言被设计成一门应用于搭载 Web 服务器，存储集群或类似用途的巨型中央服务器的系统编程语言。

环境安装

可以参考这个教程 ：Go 语言环境安装 菜鸟教程 (runoob.com)

Go语言的基础构成

  • 包声明
  • 引入包
  • 函数
  • 变量
  • 语句 & 表达式
  • 注释
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package main //包声明  
  
import "fmt" //引入包  
  
func main() { //main函数  
   // 可执行程序必须包含的函数  
   //单行注释  
   /*多行注释*/  
   var A int = 10               //声明变量  
   fmt.Println(A)               //Go中声明变量必须使用  
   fmt.Println("Hello, World!") //语句  
}

Hello,World!

使用Go语言输出 Hello,World!

1
2
3
4
5
6
7
8
9

package main  //包声明  main ,任何可执行的Go程序必须的包  
  
import "fmt"  //引入fmt包  
  
func main() {  //main函数 ,每个可执行程序必须包含  
   //单行注释  
   /*多行注释*/  
   /* 这是我的第一个简单的程序 */   fmt.Println("Hello, World!")  //语句  
}

Go语言基础语法

Go 标记

Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。

比如 fmt.Println("Hello, World!") ,fmt , println ,"Hello,World!" 和 括号以及点都是Go标记。

行分隔符

在Go程序中，一行代表一行语句的结束，每个语句不需要像C，JAVA一样加分号 ; 结尾。

1
2

fmt.Println("Hello, World!")
fmt.Print("Hello,Go!")

1
2
3
4
5
6
7
8

package main  

import "fmt"

func main() { 
	fmt.Println("Hello, World!") 
	fmt.Print("Hello,Go!")
}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/Go1.png

变量的声明

Go语言中声明变量必须使用 var 关键字，而且声明的变量必须使用。

有两种方式来声明变量，

1.指定类型变量的声明

格式 ： var 变量名 变量类型

此方式声明是有默认值的

2,根据值自判断的变量声明

格式 ： var 变量名 = 值

此方法声明，必须赋值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

package main

import "fmt"

func main() {

	var A string = "123"  //指定类型的变量
	var B string=  "987"  //指定类型为字符串的名为 B的变量
	var C = 100  //自判断变量的声明
	var D = true

	fmt.Println(A)  //输出
	fmt.Println(B)
	fmt.Println(C)
	fmt.Println(D)
}

输出结果 ：

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/vAR.png

包的引入

Go语言引入包需要使用 import 关键字，引用格式为 import " 包名 " ,调用格式为 包名.方法名() 或 包名.变量名 .引入的包和变量一样，一经引用，必须使用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

package main  //包声明  main ,任何Go程序必须的包

import "fmt"  //引入fmt包
import "math"  //引入math包

func main() {  //main函数 ,每个可执行程序必须包含

fmt.Print(math.Pi)  //调用math包的变量Pi

}

注意： 一个可执行程序有且仅有一个 main 包。

在Go语言中也可以使用 fmt.Sprint 来格式化字符串

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package main

import "fmt"

func main() {

var A string = "123"
var B string=  "987"
// fmt.Sprint格式化字符串，并赋值给新字符串
var C string   =  fmt.Sprint(A,B) 
fmt.Print(C)
}

输出结果为 ：

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/Sprint.png

注释

注释不会被编译，每一个包应该有相关注释。

单行注释是最常见的注释形式， // 开头是单行注释。多行注释也叫块注释，以 /* 开头，并以 */ 结尾。

1
2
3

//单行注释
/*多行
注释*/

标识符

标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A~Z和a~z)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。

数据类型

布尔类型

值只有 ture 和 false ，声明方式 var B bool ，默认值为 false

和 JAVA 不同的是，JAVA使用 Boolean 关键字来表示布尔值 ，Go 语言用 bool 来表示，注意区分

数字类型

整数类型

  • 整数

int 类型，有正负之分。

1
2
3
4

int8   //有符号 8 位整型,取值 -128 到 127
int16 //有符号 16 位整型,取值 -32768 到 32767
int32 //有符号 32 位整型,取值 -2147483648 到 2147483647
int64 //有符号 64 位整型,取值 -9223372036854775808 到 9223372036854775807
  • 无符号整数

int 前面加个u (unsigned) ,变成无符号整数 uint (unsigned integer),无符号整数一定是正整数。

和有符号整数一样，也是有各种位数的

1
2
3
4

uint8   //无符号 8 位整型,取值 0 到 255
uint16 //无符号 16 位整型,取值 0 到 65535
uint32 //无符号 32 位整型,取值 0 到 4294967295
uint64 //无符号 64 位整型,取值 0 到 18446744073709551615

浮点型

float32 和 float64 IEEE754标准

Go语言的浮点型没有float ,有 float32 和 float64 ，无 double 类型

1
2

float32  //32位浮点型数
float64 //64位浮点型数

字符串类型

string ,一串固定长度的字符连接起来的字符序列。

使用双引号 " "，或者反引号` `来创建。

在JAVA中 ，字符串类型是 String 第一个字母是大写，Go语言中，第一个字母小写

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package main

import "fmt"

func main() {

var A string = "A" //定义字符串
var B string = `B`

fmt.Println("var A = " , A )  //输出
fmt.Println(`var B = ` , B )
}

输出结果 ：

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/gostring1-1.png

合并字符串

使用加号来合并字符串

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import "fmt"

func main() {

var A string = "A"
var B string = `B`
var str string = A + B

fmt.Println("var A = " , A )
fmt.Println(`var B = ` , B )
fmt.Println("var str1 = " , str )
}

输出结果:

gostring2-1.png

fmt包中的 Sprintf来合并字符串

格式 : fmt.Sprintf(格式化样式, 参数列表)

  • **格式化样式：**字符串形式，格式化符号以 % 开头， %s 字符串格式，%d 十进制的整数格式。
  • **参数列表：**多个参数以逗号分隔，个数必须与格式化样式中的个数一一对应，否则运行时会报错。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package main

import "fmt"

func main() {

var A = "123"
var B = "123"

        //fmt包中的Sprint方法格式化输出
var str = fmt.Sprintf("A = %s , B = %s",A , B)  

fmt.Println( "var str :" ,str )

}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/gostring3.png

派生类型

  • 指针类型（Pointer）
  • 数组类型 (Arrayllist)
  • 结构化类型(struct)
  • 通道类型 (Channel)
  • 函数类型(Fanc)
  • 切片类型
  • 接口类型（interface）
  • Map 类型 相关笔记: [[Golang派生类型]]

注意

Go语言中在不同数据类型之间赋值时需要显式的转换，不像其他如php,java可自动转换。

比如下面这个例子:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/GoType.png

会出现类型不匹配的报错。

需要强制转换一下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import "fmt"

func main() {

var A int8 = 10

var B float32 = 0.5

var C = float32(A) + B  //将 int强制转换为 float32

fmt.Println(C)
}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/Gotype1.png

而在JAVA中不会出现这个问题。

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/JavaType.png

变量

声明变量

在Go语言中,使用var关键字声明变量，且变量一旦声明，必须使用。

这里和JAVA中不同，需要注意。

声明格式

1

var Name Type //声明变量的格式

var ： 变量声明关键字

Name : 变量名字

Type : 变量类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

//声明变量
package main

import "fmt"

func main() {

var A string = "Hello,Go" //声明名为 A 的整数变量

fmt.Println(A)  //输出
}

输出结果：

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/var1.png

批量声明变量

在Go中，可以使用 var + ()来实现批量声明变量的操作。

声明格式：

1
2
3
4
5
6

//批量声明变量
var (
Name string 
Sex string 
Age int 
)

类型推断

在Go中有一种很方便的声明变量或者常量的方式，就是类型推断

声明格式：

1

var Name = value

var : 变量声明关键字

Name : 变量名

value : 初始化值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

//类型推断
package main

import "fmt"

func main() {
var Name = "たかみ ちか"  

fmt.Println(Name)  //输出

 }

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/var2-2.png

变量的初始化

Go语言中声明变量，会自动进行初始化操作，并且赋默认值。

int类型默认值为0,string类型默认值为""，bool类型默认值为false

1
2
3
4
5
6

//变量初始化
var (
Name string  = "Takami Chika"
Sex string = "female"
Age int = 16
)

批量初始化

一次性可以初始化多个变量，中间用逗号隔开变量和值

1
2

//批量初始化
var A ,B , C = 1, 2, 3

短变量声明

在函数内部，可以使用短变量来更为快速地声明变量。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

//短变量声明
package main

import "fmt"

func main() {

Name := "短变量"  //短变量声明

fmt.Println(Name)  //输出

 }

短变量只能在函数内部声明，无法在函数外部声明

匿名变量

如果接收到多个变量，而有一些变量暂时使用不到，可以使用下划线 _ 来声明匿名变量来代替变量名称。

匿名变量声明后，传入的任何值将会被抛弃，且不能在后续的代码中使用。

1
2

var _ = "" 
var Name,_ = "KSM" , 123

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/var3.png

常量

在编译时就确定的值，运行后无法改变。

声明常量

在Go语言中，使用 const 关键字来定义常量

1

const Name Type = value

const : 常量定义关键字

Name : 常量名

Type : 常量数据类型 , 因为有 类型推断，也可以不用写数据类型

value ：常量值

Go中的常量，在定义时就必须要赋初值，且后续无法修改。（比JAVA方便了不少）

JAVA 中的常量 : private static final int A = 100;
Go 中的常量 : const A = 100

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

//常量
package main

import "fmt"

func main() {

const Name string = "CYaRon!"
fmt.Println(Name)

}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/const1.png

当然，常量也是可以批量定义和初始化的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

package main

import "fmt"

func main() {

const Name string = "CYaRon!"
fmt.Println(Name)

const (
A = "A"
B = 10
)

const C, D, E = 1,2,3
}

IOTA

关键字iota

iota可以理解为一个可以被编译器修改的变量，初始值为0，调用一次增加1，遇到下一个const关键字重置为0。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package main

import "fmt"

func main() {

const (
A = iota  //0
B = iota  //类似 JAVA 中的 i++
C = iota
D = iota
E = iota  //4
)
fmt.Println("const A = " ,A)
fmt.Println("const E =",E)
const (  //iota被重置
F = iota  //0
G= iota  //1
)
fmt.Println("const F = ",F)
fmt.Println("const G = ",G)
}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/iota1.png

使用 _ (下划线)来跳过某些值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

package main

import "fmt"

func main() {

const (
A = iota  //0
B = iota //1
_        //2
D = iota //3
E = iota //4
)
fmt.Println("const A = " ,A)
fmt.Println("const E =",E)
}

运行结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/iota2.png

iota中间插队

在iota中间，如果被别的常量打断，iota 会被覆盖掉，不再继续自增。但是用另一个 iota 接一下，又会继续自增。

  • 被打断有iota接
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package main

import "fmt"

func main() {

const (
A = iota  //0
B = iota //1
C = 100
D = iota //3
E = 100
F = iota  //5
G         //6
)
fmt.Println("const A = " , A )
fmt.Println("const D = " , D )

fmt.Println("const G = " , G )
}

输出结果：

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/iota3.png

  • 被打断没有iota来接
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package main

import "fmt"

func main() {

const (
A = iota  //0
B = iota //1
C = 100
D = iota //3
E = 100
F         //100
G         //100
)
fmt.Println("const A = " , A )
fmt.Println("const D = " , D )
fmt.Println("const E = " , E )
fmt.Println("const G = " , G )
}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/iota4.png

运算符

算数运算符

符号 描述
+ 相加
- 相减
* 相乘
/ 相处
% 取余

在Go语言中， 自增 ( ++ ) 和 自减 ( -- ) 算单独的语句，不属于运算符。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

package main

import "fmt"

func main() {

var A = 100
var B = 10

fmt.Println("A+B : " ,A + B)
fmt.Println("A-B : " ,A - B)
fmt.Println("A*B : " ,A * B)
fmt.Println("A/B : " ,A / B)
fmt.Println("A%B : " ,A % B)

}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/Go1-1.png

关系运算符

运算符 描述
== 检查两个值是否相等，如果相等返回 True, 否则返回 False。
!= 检查两个值是否不相等，如果不相等返回 True, 否则返回 False。
> 检查左边值是否大于右边值，如果是返回 True, 否则返回 False。
>= 检查左边值是否大于等于右边值，如果是返回 True ,否则返回 False。
< 检查左边值是否小于右边值，如果是返回 True ,否则返回 False。
<= 检查左边值是否小于等于右边值，如果是返回 True, 否则返回 False。 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

package main

import "fmt"

func main() {
var Bool bool  //定义布尔值 Bool
var A = 10
var B = 100
var C = 10

Bool = A==B
fmt.Println("A == B: " , Bool)  // false
Bool = A!=B
fmt.Println("A != B: " , Bool)  //true

Bool = A > C
fmt.Println("A > C: " , Bool)  //false
Bool = A < B
fmt.Println("A < B: " , Bool) //true

Bool = A <= B
fmt.Println("A <= B: " , Bool) //true
Bool = A >= C
fmt.Println("A >= C: " , Bool) //true
}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/Go2.png

逻辑运算符

运算符 描述
&& 逻辑 AND 运算符。 如果两边的操作数都是 True，则为 True，否则为 False。
|| 逻辑 OR 运算符。 如果两边的操作数有一个 True，则为 True，否则为 Fal
! 逻辑 NOT 运算符。 如果条件为 True，则为 False，否则为 True 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main

import "fmt"

func main() {
var S bool

var A = true
var B = false

S = A && B
fmt.Println("A && B: " , S)
S = A  B
fmt.Println("A  B: " , S)
S = !A
fmt.Println("!A: " , S)

}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/Go3.png

位运算符

运算符 描述
& 参与运算的两数各对应的二进位相与。（两位均为1才为1）
| 参与运算的两数各对应的二进位相或。（两位有一个为1就为1）
^ 参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。（两位不一样则为1）
« 左移n位就是乘以2的n次方。“a«b”是把a的各二进位全部左移b位，高位丢弃，低位补0。
» 右移n位就是除以2的n次方。“a»b”是把a的各二进位全部右移b位。

位运算符的概念可以参考这篇教程来更好的理解： C 运算符

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package main

import "fmt"

func main() {

var A  = 15 //1111
var B = 10 // 1010
var C uint = 1 //1

Y := A & B
fmt.Println("A & B: " , Y)  //1010 = 10
Y = A  B
fmt.Println("A  B: " , Y) //1111 = 5
Y = A ^ B
fmt.Println("A ^ B: " , Y) //0101 = 5
Y = A << C
fmt.Println("A << C: " , Y)//11110 = 30
Y = A >> C
fmt.Println("A >> C: " , Y)//0111 = 7

}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/Go4.png

赋值运算符

运算符 描述
= 简单的赋值运算符，将一个表达式的值赋给一个左值
+= 相加后再赋值
-= 相减后再赋值
*= 相乘后再赋值
/= 相除后再赋值
%= 求余后再赋值
«= 左移后赋值
»= 右移后赋值
&= 按位与后赋值
l= 按位或后赋值
^= 按位异或后赋值 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

package main

import "fmt"

func main() {

var R = 20
fmt.Println("var R = 20")
R += 1
fmt.Println("R += 1: ",R)  // R = R + 1
R -= 1
fmt.Println("R -= 1: ",R)  // R = R - 1
fmt.Println("++++++++++++++++")

var A = 10
fmt.Println("var A = 10")
A *= 2
fmt.Println("A *= 2: ",A) // A = A * 2
A /= 4  //a = 20/4
fmt.Println("A /= 4: ",A)  // A = A / 4
A %= 10  //5%10
fmt.Println("A %= 10: ",A)// A = A % 10
fmt.Println("++++++++++++++++")

var G = 15  //1111
fmt.Println("var G = 15")
G <<= 1
fmt.Println("G <<= 1: ",G)  // 1111 ---> 11110 , 11110 = 30
G >>= 1
fmt.Println("G >>= 1: ",G) // 1111  ---> 01111 , 01111 = 15
fmt.Println("++++++++++++++++")

var E = 10  // 1010
E &= 10
fmt.Println("E &= 10: ",E)  //1010 & 1010 ---> 1010 , 1010 = 10
E = 15
fmt.Println("E = 10: ",E)  //1010 % 1111 ---> 1111 , 1111 = 15
E ^= 10
fmt.Println("E ^= 10: ",E)  //1010 ^ 1010 ---> 0101 , 0101 = 5

}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/Go5.png

条件判断语句

if - else 语句

语法格式:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

if (布尔表达式){   //布尔值为true执行花括号内语句

语句1

}
else {  //布尔值为false执行else内语句

语句2

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main

import "fmt"

func main() {

var A = 2

if (A == 10){  //2 != 10结果为false,执行else内的语句

fmt.Println("A = 10")

}else {
fmt.Println("A = ",A)
}


}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/GoBool.png

if嵌套语句

在 if 内添加if语句，实现嵌套效果.

语法格式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

if (布尔表达式){

语句1

if(B  == 4) {

语句1.1
}

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main

import "fmt"

func main() {

var B = 4

if (B > 2){  // 4 > 2 执行语句1

fmt.Println("B > 2")  //语句1

if(B  == 4) {  //B = 4 ,执行语句1.1

fmt.Println("B = 4" )  //语句1.1
		}
	}
}

运行结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/GoBool2.png

if-else if-if 语句

单纯是if else是不够用的，所以Go语言还有else if语句。可以搭配if ，else使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func main() {


var A = 10

if (A == 5){
fmt.Println("A = 5")
}else if (A == 10) {
fmt.Println("A = 10")
}else{
fmt.Println("A != 5 && A != 10")
}
}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/Goelseif.png

switch语句

switch用来执行不同条件的不同动作，switch包含case的分支，swicth会从上到下一次判断各个case分支。case都是唯一的，而且自带一个break效果，一旦执行一个case就不会执行后面的case，如果需要执行后面的case,需要加 fallthrough .

fallthrough 要放在要第一个执行的case内

default代表如果没有可执行的 case ，则会执行 default下的语句。

case中值的数据类型必须和switch中的数据类型相同, 多个值也可以写在一个case中, 但要用逗号隔开

格式 :

1
2
3
4
5
6
7
8

switch Var {
    case var1:
        //语句1
    case var2:
        //语句2
    default:
        //语句3
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package main

import "fmt"

func main() {

var A = 4

var B = 2

var C = A

var D = 4

switch C {  //判断

case A:
fmt.Println("A = " , A)
fallthrough   // D 和 A都为4，如果不加fallthrough只能执行A 的case

case B:
fmt.Println("B = " , B)


case D:
fmt.Println("D = " , D)

default:
fmt.Println("C = " , C)

}


}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/GoBool3.png

条件循环语句

for关键字

在Go语言中去除了while ,do - while 循环,变得更加简洁了。

格式:

1
2
3

for 控制变量(赋值表达式); 循环条件(逻辑表达式\关系表达式);控制变量控制(自增\自减){
        //语句
}

其中 控制变量控制 是可以选择性添加的，不添加就实现了while循环

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package main

import "fmt"

func main() {

var A = 0
for i := 0; i < 10; i++{
A = A + i
}
fmt.Println( "A = ",A)

}

运行结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/GoFor1.png

for range 语句

for range语句有着类似迭代器操作(遍历数组，字符串等)，返回 (索引, 值) 或 (键, 值)

特点:

  • 数组，切片返回格式为[索引,值]
  • map返回 键和值
  • 通道(channel)只返回通道（channel）内的值

格式:

1
2
3

for (索引名\键名),(值) := range (range的对象) {
      //语句
}

字符串会转为ASCII码输出，如果需要显示字符 则需要 string()转为字符串类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

package main

import "fmt"

func main() {

var String = "ABCDEFG"

for index,value := range String{

        //index:索引 , value:for range出来的值
fmt.Println("index:",index,",Value:",string(value),"ASCII:",value)

	}
}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/GoForRange.png

流程控制语句

Continue

跳过当前循环，进入下一循环

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main

import "fmt"

func main() {

for i := 0;i < 3;i++{
fmt.Println("i =  = = ",i)
for n := 0;n < 5;n++{
if (n < 2){
continue
}
fmt.Println("n =",n)
}

}

}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/GoContinue.png

Break

终止当前循环,或者跳出switch语句

在多重循环中，可以用标号 label 标出想 break 的循环。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main

import "fmt"

func main() {

for i := 0;i < 3;i++{
fmt.Println("i =  = = ",i)
for n := 0;n < 5;n++{
if (n < 2){
break
}
fmt.Println("n =",n)
}

}

}

输出结果：

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/GoBreak.png

break + label 跳出指定循环

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

package main

import "fmt"

func main() {
label1:
for i := 0; i < 3; i++ {
for n := 0; n < 3; n++ {
break label1  //跳出最外层循环（label1）
fmt.Println("循环2")
}
fmt.Println("循环1")
fmt.Println("---------------")
}

}

输出结果:

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/GoBreak1.png

Goto

无条件地转移到过程中指定的行。

格式 :

1
2
3
4

goto label;
..
.
label: statement;

使用Goto语句来跳出双层循环.

未使用Goto：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main

import "fmt"

func main() {

for i := 0; i < 3; i++ {
for n := 0; n < 3; n++ {
fmt.Println("循环2")
//goto label
}
fmt.Println("循环1")
fmt.Println("---------------")
}

//label:
//fmt.Println("label")
}

输出结果,可见break只能跳出所在的循环，无法跳出双层循环。

1
2
3
4
5
6
7
8
9

循环 2
循环1
---------------
循环 2
循环1
---------------
循环2
循环1
---------------

使用Goto语句:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main

import "fmt"

func main() {

for i := 0; i < 3; i++ {
for n := 0; n < 3; n++ {
fmt.Println("循环2")
goto label  //跳到名为label的代码处
}
fmt.Println("循环1")
fmt.Println("---------------")
}

label:
fmt.Println("label")
}

输出结果：

1
2

循环2
label

函数

何为函数

函数是基本的代码块，用于执行一个任务。

Go 语言最少有个 main() 函数。

你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。

函数声明告诉了编译器函数的名称，返回类型，和参数。

函数的定义和调用

函数定义

Go语言定义函数的语法：

1
2
3
4
5

func function_name( [parameter list] ) [return_types] {
   函数体

   [return return_Numbers]
}

func ：定义函数的关键字

function_name : 函数名

parameter list : 参数列表，需要传入的参数和参数类型，根据需要选择可以不设置。

return_types ： 返回值类型，返回一系列的值，根据需要选择可以不设置。

函数体：函数定义的代码集合。

1
2
3
4
5
6

func PrintHello() { //打印Hello的函数

var String = "Hello"
fmt.Println(String)

}

函数调用

当创建函数时，你定义了函数需要做什么，通过调用该函数来执行指定任务。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package main

import "fmt"

func main() {
PrintHello()  //调用PrintHello函数

fmt.Println(PrintHelloWorld()) //调用PrintHelloWorld函数


        fmt.Println(Add(10, 10))  //调用求和函数
}

func PrintHello() { //PrinrHello函数，无参，无返回值

var String = "Hello"
fmt.Println(String)


}

func PrintHelloWorld() string { //PrintHelloWorld函数，无参，有返回值

var String = "Hello,World!"
return String

}

func Add(X int, Y int) int {  //求和函数，有参，有返回值
Res := X + Y
return Res
}

运行结果：

1
2
3

HeTTo
Hetto ,WorTd!
20

函数类型

使用Type关键字可以定义函数类型。

在Go语言中,type可以定义任何自定义的类型。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package main

import "fmt"

func main() {
type T1 func(int, int) int  //使用type关键字，定义T1类型
var F T1 = Add  //声明T1类型的变量F ，将Add函数赋给F
f1 := F(1, 4)
fmt.Println(f1)

var F2 T1 = subtract
f2 := F2(10, 40)
fmt.Println(f2)

fmt.Println(f1 + f2)

}

func Add(X int, Y int) int {  //Add函数
Res := X + Y
return Res
}

func subtract(X int, Y int) int {  //subtract函数
Res := X - Y
return Res
}

输出结果：

1
2
3

5
-30
-25

高阶函数

函数作为参数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main

import "fmt"

func main() {
PrintHello("Sam", SayHello)

}

func SayHello(name string) string {
var Hello string = name + " Hello"
fmt.Println("func SayHello: ", Hello)
return Hello
}

func PrintHello(name string, f func(string2 string) string) {
fmt.Println("func PrintHello: ", name, f(name))
}

输出结果：

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/Gofunction3.png

函数作为返回值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package main

import (
"fmt"
"strconv"
)

func main() {
fmt.Println(Add(10, 20))

}

func Add(x int, y int) string {
var Res = x + y
return ToString(Res)
}

func ToString(z int) string {
var Res = strconv.Itoa(z)  //使用 strconv.Itoa()将整型数字转为字符串数字
return Res
}

其他

strconv.Itoa() 和 string()的区别

string()是直接整数类型的数字转为ASCII码值等于该整形数字的字符。

而strconv.Itoa() 是转换成对应的字符串类型的数字。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package main

import (
"fmt"
"strconv"
)

func main() {

var Number = 40

fmt.Println(Number)
fmt.Printf("%T\n", Number)
fmt.Println("------------------")

fmt.Println(string(Number))
fmt.Printf("%T\n", string(Number))

fmt.Println("------------------")

fmt.Println(strconv.Itoa(Number))
fmt.Printf("%T\n", strconv.Itoa(Number))

}

输出结果：

https://xenolies-blog-images.oss-cn-hangzhou.aliyuncs.com/Pics/Gofunction4.png

匿名函数

Go语言中的函数无法实现函数的嵌套，但是可以通过匿名函数来实现相似的效果。

匿名函数效果类似Python中的lamda

格式:

1
2
3

func(参数列表) 返回值 { 
    函数体
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package main

import "fmt"

func main() {
Add := func(X int, Y int) int { //匿名函数
return X + Y
}

A := Add(1, 2) //调用匿名函数
fmt.Println("var A =", A) //输出
}

输出结果：

var A = 3

更新于 2022-05-28 
CC BY-NC 4.0
 Golang
返回 | 主页
0%