学go第三天

发表于 | 分类于 | | 本文总阅读量 次
字数统计: 2.9k | 阅读时长 ≈ 13

流程控制

if语句

if后条件判断语句没有()
if后面条件成立则执行{}里程序，不成立则跳过

if

运行实例

1
2
3
4
5
6
7
8
package main
import "fmt"
func main(){
	var a int =3
	if a==3 {	//条件判断语句没有()
		fmt.Println(a)
	}
}

运行结果:
3

if…else…

if后条件不成立则执行else{}里语句
运行实例

1
2
3
4
5
6
7
8
9
10
package main
import "fmt"
func main(){
	var a int =3
	if a>3 {	//条件判断语句没有()
		fmt.Println(a)
	}else {
		fmt.Println("a不大于3")
	}
}

运行结果:
a不大于3

if…else if…else…

第一个if不成立则判断第二个，直到所有if不成立执行else{}里程序，如果有一个if条件成立，则执行其{}内语句并跳出判断
运行实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main
import "fmt"
func main(){
	var a int =3
	if a == 1 {
		fmt.Println("a==1")
	}else if a == 2 {
		fmt.Println("a==2")
	}else if a == 3 {
		fmt.Println("a==3")
	}else{
		fmt.Println("a>=3")
	}
}

运行结果:
a==3

switch语句

switch后写的是变量本身，不是判断条件,变量与case等式都不成立则执行default，go语言保留了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()  {
	num:=3
	switch num {	//switch后写的是变量本身，不是判断条件
	case 1:
		fmt.Println("按下的是",num,"楼")
//		break//go语言保留了break关键字,默认不写，默认包含
	case 2:
		fmt.Println("按下的是",num,"楼")
	case 3:
		fmt.Println("按下的是",num,"楼")
	case 4:
		fmt.Println("按下的是",num,"楼")
	default:
		fmt.Println("按下的是",num,"楼")
	}
}

运行结果:
按下的是 3 楼

fallthrough关键字

fallthrough表示不跳出switch循环,后面条件无条件执行
运行实例:

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"
func main()  {
	num:=3
	switch num {	//switch后写的是变量本身，不是判断条件
	case 1:
		fmt.Println("按下的是",num,"楼")
		fallthrough
	case 2:
		fmt.Println("按下的是",num,"楼")
		fallthrough
	case 3:
		fmt.Println("按下的是",num,"楼")
		fallthrough
	case 4:
		fmt.Println("按下的是",num,"楼")
		fallthrough
	default:
		fmt.Println("按下的是",num,"楼")
	}
}

运行结果:

1
2
3
按下的是 3 楼
按下的是 3 楼
按下的是 3 楼

switch语句其他用法

switch语句支持一个初始化语句,初始化语句和变量本身以分号分割
运行实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main
import "fmt"
func main()  {
	//switch语句支持一个初始化语句,初始化语句和变量本身以分号分割
	switch 	num := 3;num {	//switch后写的是变量本身，不是判断条件
	case 1:
		fmt.Println("按下的是",num,"楼")
	case 2:
		fmt.Println("按下的是",num,"楼")
	case 3:
		fmt.Println("按下的是",num,"楼")
	case 4:
		fmt.Println("按下的是",num,"楼")
	default:
		fmt.Println("按下的是",num,"楼")
	}
}

运行结果:
按下的是 3 楼
switch后可以没有变量,case后面可以加判断语句
运行实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main
import "fmt"
func main()  {
	s :=88
	switch  {	//可以没有条件
	case s > 90:
		fmt.Println("优秀")
	case s > 80:
		fmt.Println("良好")
	case s > 70:
		fmt.Println("一般")
	case s > 60:
		fmt.Println("较差")
	default:
		fmt.Println("差")
	}
}

运行结果:
良好
switch语句case后可以加多个常量
运行实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main
import "fmt"
func main()  {
	switch 	num := 3;num {	//switch后写的是变量本身，不是判断条件
	case 1:
		fmt.Println("按下的是",num,"楼")
	case 2:
		fmt.Println("按下的是",num,"楼")
	case 3,4,5:		//num=3|num=4|num=5时执行
		fmt.Println("按下的是",num,"楼")
	default:
		fmt.Println("按下的是",num,"楼")
	}
}

运行结果:
按下的是 3 楼

for循环语句

  • 语法
    for 初始化条件;判断条件;条件变化{}

判断条件是否为真，如果为真执行循环体，如果为假跳出循环,如果不写判断条件则陷入死循环

1
2
3
4
5
6
7
8
9
10
package main
import "fmt"
func main()  {
	sum:=0
	//判断条件是否为真,如果为真执行循环体,如果为假跳出循环
	for i := 0; i <= 100; i++ {
		sum=sum+i
	}
	fmt.Println(sum)
}

range迭代器

迭代打印每个元素,默认返回两个值:一个元素位置，一个元素本身

1
2
3
4
5
6
7
8
9
10
11
12
package main
import "fmt"
func main()  {
	str :="abc"
	for i := 0; i < len(str); i++ {
		fmt.Printf("%d,%c\n",i,str[i])
	}
	//迭代打印每个元素,默认返回两个值:一个元素位置，一个元素本身
	for i,data:=range str{
		fmt.Println(i,data)
	}
}

运行结果:

1
2
3
4
5
6
0,a
1,b
2,c
0 97
1 98
2 99

其他用法

1
2
3
4
5
6
for i :=range str {
	fmt.Printf("%d,%c",i,str[i])
}
for i,_ :=range str {
	fmt.Printf("%d,%c",i,str[i])
}

跳转语句

break和continue

break可用于for、switch、select，而continue只能用于for循环
braek运行实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main
import "fmt"
import "time"
func main()  {
	i:=0
	for{
		i++
		time.Sleep(time.Second)//休眠一秒
		if i==5 {
			break 	//跳出循环，如果嵌套多个循环，跳出最近的那个循环
		}
		fmt.Println(i)
	}
}

运行结果

1
2
3
4
1
2
3
4

continue运行实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main
import "fmt"
import "time"
func main()  {
	i:=0
	for{
		i++
		time.Sleep(time.Second)//休眠一秒
		if i==5 {
			//break 	//跳出循环，如果嵌套多个循环，跳出最近的那个循环
			continue	//跳过本次循环,下一次继续
		}
		fmt.Println(i)
	}
}

运行结果

1
2
3
4
5
6
7
1
2
3
4
6
7
……

goto跳转

goto可以用在任何地方，但不能夸函数使用，用goto跳转前必须在当前函数内定义标签
运行实例

1
2
3
4
5
6
7
8
9
10
package main
import "fmt"
func main()  {
	//goto可以用在任何地方，但不能夸函数使用
	fmt.Println("111111111111111111111111111111")
	goto end	//goto是关键字，end是用户定义标签的名字
	fmt.Println("22222222222222222222222222")
	end:	//定义标签
		fmt.Println("33333333333333333333333")
}

运行结果:

1
2
111111111111111111111111111111
33333333333333333333333

函数

在golang中，函数基本组成为:关键字func、函数名、参数列表、返回值、函数体和返回语句

1
2
3
4
func/*关键字*/ name/*函数名*/(/*参数列表*/)(a string,b int/*返回类型*/){
    /*函数体*/
    return v1,v2//返回语句
}

自定义函数

自定义函数不调用不会执行

无参无返回值函数

1
2
3
4
5
6
7
8
package main
import "fmt"
func Myfunc()  {//自定义函数
	fmt.Println("我是Myfunc函数")
}
func main()  {
	Myfunc()//无参无返回值函数的调用
}

运行结果:

1
我是Myfunc函数

有参无返回值函数

普通参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main
import "fmt"
func main()  {
    //调用函数传递的参数叫实参
	youcan(10,10)//调用函数
    youcan2(10,"abc")
}
//定义函数时，在（）内定义的参数是形参
//参数传递只能由实参传给形参
func youcan(a,b int){//定义有参无返回值函数
	fmt.Println(a,b)
}
func youcan2(a int,b string){
	fmt.Println(a,b)
}

运行结果

1
2
10 10
10 abc

不定参数

不定参数是指函数传入的参数个数为不定数量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main
import "fmt"
func main()  {
	Myfunc(100,200)
	Bdfunc(1,2,3,4,5)
   	Bdfunc(1,2,3)
    Bdfunc()//不定参数也可以不传参数
}
func Myfunc(a int, b int)  {
	fmt.Println(a,b)
}
//...type不定参数类型
func Bdfunc(a...int){	//不定参数函数
	for i := 0; i< len(a);i++{
		fmt.Print(a[i])//传多少参数打印多少个
	}
}

运行结果

1
2
3
100 200
12345
123

不定参数，只能放在形参中的最后一个参数

不定参数的传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main
import "fmt"
func main()  {
	test(1,2,3,4,5)
}
func test(args ...int)  {
	test01(args...)//全部元素传递给test01()函数
	test01(args[:2]...)//从args[0]开始，到args[2]结束(不包括args[2])把中间所有元素传递过去
    test01(args[2:]...)//从args[2]开始(包括args[2])，把后面所有元素传递过去
}
func test01(args ...int){
	for _,data:=range args{
		fmt.Printf("%d",data)
	}
	fmt.Println()
}

运行结果

1
2
3
12345
12
345

无参有返回值

有返回值的参数，必须有明确的终止语句(return语句)，否则会引发编译错误，

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()  {
	var a int = func1()
	fmt.Println(a)
	var b int
	var c string
	b,c=func2()
	fmt.Println(b,c)
}
//常用推荐写法
func func1()(a int)  {	
    a = 1		
    return a	
}
//也可写为,不推荐
//func func1() int{
//	return 1
//}
func func2()(a int,b string)  {
	a=1
	b="abc"
	return a,b
}
//func func2()(int,string)  {
//	return 1,"abc"
//}

运行结果

1
2
1
1 abc

有参有返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main
import "fmt"
func main()  {
	max:=maxfunc(5,10)
	fmt.Println(max)
}
//求两数最大值
func maxfunc(a ,b int)(c int){
	if a>b {
		c=a
	}else {
		c=b
	}
    return c
}

运行结果

1
10

递归函数

递归函数可以直接或间接调用自身
递归函数通常有相同的结构:一个跳出条件和一个递归体。所谓跳出条件是根据传入的参数判断是否需要停止递归，而递归体则是函数自身所做的一些处理

普通函数的调用流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main
import "fmt"
func main()  {
    a :=funca()	//调用funca()
	fmt.Println(a)	//4最后执行
}
func funca()(a int)  {
	a=1
    b:=funcb()	//调用funcb()
	fmt.Println("funca b=",b)	//2
	fmt.Println("funca a=",a)	//3
	return a
}
func funcb()(a int)  {
	a=1
	fmt.Println("funcb a=",a)	//1
	return a
}

运行结果

1
2
3
4
funcb a= 1
funca b= 1
funca a= 1
1

递归函数调用流程

1
2
3
4
5
6
7
8
9
10
11
12
13
package main
import "fmt"
func main()  {
	funcjian(10)
}
func funcjian(a int)  {
	if a == 1 {	//此条件不成立下面调用函数一直执行，此语句成立时结束调用开始打印
		fmt.Println(a)
		return
	}
	funcjian(a-1)
	fmt.Print("a=",a)
}
1
2
1
a=2a=3a=4a=5a=6a=7a=8a=9a=10

数字的累加

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
package main
import "fmt"
func main()  {
	var aum int = sum()
	fmt.Println(aum)
	sum1 :=sum01(100)
	fmt.Println(sum1)
	sum2 :=sum02(1)
	fmt.Println(sum2)
}
//普通方法
func sum()(sum int)  {
	for i:=0;i <=100 ;i++  {
		sum +=i
	}
	return
}
//递归方法
func sum01(a int)(sum int)  {
	if a==1 {
		return a
	}
	return a+sum01(a-1)
}
func sum02(a int)(sum int)  {
	if a==100 {
		return a
	}
	return a+sum02(a+1)
}

运行结果:

1
2
3
5050
5050
5050

函数类型

可以通过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
package main
import "fmt"
func main()  {
	var result int
	result=addd(10,10)
	fmt.Println(result)
	//声明一个函数类型的变量，变量名叫s
	var sss Functype
	sss=addd//是变量就可以赋值
	result=sss(10,20)//等价于addd（10,20）
	fmt.Println(result)
	sss=jian
	result=sss(20,10)//等价于jian(20,10)
	fmt.Println(result)
}
//函数也是一种数据类型，通过type给一个函数类型起名，名字为Functype
type Functype func(int,int) int

func addd(a,b int)int  {
	return a+b
}
func jian(a,b int)int  {
	return a-b
}

运行结果

1
2
3
20
30
10

回调函数

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()  {
	var result int
	result = funccc(20,10,jia)
	fmt.Println(result)
	result = funccc(20,10,jians)
	fmt.Println(result)
	result = funccc(20,10,cheng)
	fmt.Println(result)
	result = funccc(20,10,chu)
	fmt.Println(result)
}
type funcType func(int,int)int
func funccc(a,b int,fun funcType) (c int) {
	fmt.Print("funccc:")
	c=fun(a,b)
	return
}
func jia(a int,b int)int{
	return a+b
}
func jians(a int,b int)int  {
	return a-b
}
func cheng(a int,b int)int  {
	return a*b
}
func chu(a int,b int)int  {
	return a/b
}

运行结果

1
2
3
4
funccc:30
funccc:10
funccc:200
funccc:2

匿名函数与闭包

详解（<https://blog.csdn.net/lengyuezuixue/article/details/78527667）（https://www.cnblogs.com/williamjie/p/9875362.html）

匿名函数基本使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main
import "fmt"
func main()  {
	a:=10
	str:="abc"
	//匿名函数，没有函数名字
	f1 := func() {
		fmt.Println(a)
		fmt.Println(str)
	}
	f1()
    //给一个函数类型起别名
	type funcType func()
	var f2 funcType
	f2=f1
	f2()
}

运行结果

1
2
3
4
10
abc
10
abc

定义匿名函数同时调用

1
2
3
4
5
6
7
8
9
package main
import "fmt"
func main()  {
	a:=10
	str:="abc"
func(){
		fmt.Println(a,str)
	}()//()代表调用此匿名函数
}

运行结果

1
10 abc

带参数的匿名函数

1
2
3
4
5
6
7
package main
import "fmt"
func main()  {	
	func(i,j int){
		fmt.Println(i,j)
	}(1,2)
}

运行结果

1
1 2

匿名函数有参有返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main
import "fmt"
func main()  {	
	x,y:=func(i,j int)(max,min int){
		if i>j {
			max=i
			min=j
		}else {
			max=j
			min=i
		}
		return
	}(10,20)
	fmt.Println(x,y)
}

运行结果

1
20 10
-------------本文结束❤️感谢您的阅读-------------
ボ wechat
扫描二维码，可获得菜鸡一枚
打赏测试
0%