GO语言学习(三) 流程控制+数组，切片，map

最新推荐文章于 2024-11-04 13:07:19 发布

一啊鸭0402

最新推荐文章于 2024-11-04 13:07:19 发布

阅读量49

点赞数

分类专栏： Go语言学习文章标签：学习

本文链接：https://blog.csdn.net/qq_56540305/article/details/133956980

版权

Go语言学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

if语句

if 布尔表达式{

//一些执行内容

}

注意：

1、布尔表达式没有括号

2、左括号与if、else在同一行

3、大括号必须存在，即使只有一行语句

4、不能使用0或者非0表示真假

5、初始变量可以声明在布尔表达式里面，注意作用域

package main

import (
	"fmt"
)

func main() {
	//if表达式
	a:=1
	b:=2
	if a>b {
		fmt.Printf("%v\n", a)
	}else{
		fmt.Printf("%v\n", b)
	} 
	//flag是关键字，最好不要使用
	flag1:=true
	if flag1{
		fmt.Printf("%v\n", flag1)
	}
	//初始变量可以声明在布尔表达式里面，注意作用域
	if age:=20;age>18{
		fmt.Println("成年")
	}
	//不能使用0或者非0表示真假
}

if else if语句

package main

import (
	"fmt"
)

func f1(){
	score:=90
	if score>=60 &&score <=70{
		fmt.Println("C")
	}else if score>70 &&score<=90{
		fmt.Println("B")
	}else{
		fmt.Println("A")
	}
}

func main() {
	//if else表达式
	var c string
	fmt.Println("请输入一个字符")
	fmt.Scan(&c)
	if c=="S"{
		fmt.Println("请输入第二个字符")
		fmt.Scan(&c)
		if c=="a"{
			fmt.Println("Saturday")
		}else if c=="u"{
			fmt.Println("Sunday")
		}else{
			fmt.Println("输入错误")
	}
	}else if c=="F"{
		fmt.Println("Friday")
	}else if c=="M"{
		fmt.Println("Monday")
	}else if c=="T"{
		fmt.Println("请输入第二个字符")
		fmt.Scan(&c)
		if c=="u"{
			fmt.Println("Tuseday")
		}else if c=="h"{
			fmt.Println("Thursday")
		}else{
			fmt.Println("输入错误")
		}
	}
}

fmt.Scan(&a) 可以输入字符，有需要用户输入的需要在终端使用 go run运行

Switch语句

注意加上fallthrough之后就可以执行后面的case(无论是否符合条件都会执行下一个case，但是仅仅对下面这个case有作用)

package main

import (
	"fmt"
)
func f1(){
	//运行结果是A，不是A、B；虽然没有break，但是满足第一个条件之后，后面就不再执行了
	grade:='A'
	switch grade {
	case 'A':
		fmt.Println("优秀")
		grade = 'B'
	case 'B':
		fmt.Println("良好")
	case 'C':
		fmt.Println("一般")
	default:
		fmt.Println("其他")
	}
}
func f4(){
	//运行结果A、B；，加上fallthro之后就可以执行后面满足条件的了
	grade:='A'
	switch grade {
	case 'A':
		fmt.Println("优秀")
		grade = 'B'
		fallthrough
	case 'B':
		fmt.Println("良好")
		grade = 'C'
	case 'C':
		fmt.Println("一般")
	default:
		fmt.Println("其他")
	}
}
func f2(){
	//case中可以有多个值，匹配其中之一就可以
	day:=3
	switch day{
	case 1,2,3,4:
		fmt.Println("工作日")
	case 5,6,7:
		fmt.Println("休息")
	}
}
func f3(){
	//case中可以是条件表达式
	score:=90
	switch{
	case score>=90:
		fmt.Println("优秀")
	default:
		fmt.Println("一般")
	}
}

func main() {
	//switch语句  没有break
	f1()
	f4()
	f2()
	f3()

	
}

for循环

Golang中只有for循环

package main

import (
	"fmt"
)

func f1(){
	//和cpp中用法一样
	for i:=1;i<=10;i++{
		fmt.Printf("i:%v\n",i)
	}
}
func f2(){
	//和cpp中while用法一样。初始条件放到外面，改变条件放在循环体中
	i:=1
	for i<=10{
		fmt.Printf("i:%v\n", i)
		i++
	}
	//while(i<=10){
	//	i++
	//}
}
func f3(){
	//永真循环
	for{
		fmt.Println("run....")
	}
}

func main() {
	//for循环
	f1()
	f2()
	f3()
	
}

for range循环

GO语言中可以使用for range遍历数组、切片、字符串、map及通道(channel)。通过 for range遍历的返回值有如下规律

1、数组、切片、字符串返回索引和值

2、map返回键和值

3、通道(channel)只返回通道内的值

package main

import (
	"fmt"
)
func f1(){
	//遍历数组
	var a = [5]int{1,2,3,4,5}
	for i,v:=range a{
		fmt.Printf("i:%v ", i)
		fmt.Printf("v:%v\n", v)
	}
	/*  i是索引，v是值
	i:0 v:1
	i:1 v:2
	i:2 v:3
	i:3 v:4
	i:4 v:5
	*/
	for _,v:=range a{
		// fmt.Printf("i:%v ", i)
		fmt.Printf("v:%v\n", v)
	}
	/*
	v:1
	v:2
	v:3
	v:4
	v:5
	*/
}
func f2(){ 
	//遍历切片 切片是动态的数组 []里面什么都没有就是切片
	var s = []int{1,2,3}
	for _,v:=range s{
		fmt.Printf("v:%v\n", v)
	}
}
/*
v:1
v:2
v:3
*/
func f3(){
	//遍历map，map对应着key:value map[string]string  第一个string是key的类型，第二个string是value的类型
	var m=make(map[string] string,0)
	m["name"] = "tom"
	m["age"]="20"
	for key,value:=range m{
		fmt.Printf("key:%v ", key)
		fmt.Printf("value:%v\n", value)
	}
	/*
	key:name value:tom
	key:age value:20
	*/
}
func f4(){
	//遍历字符串
	var b="hello world"
	for i,v:=range b{
		fmt.Printf("i:%v ", i)
		fmt.Printf("v:%c\n", v)
	}
}

func main() {
	f1()
	f2()
	f3()
	f4()
	
}

break关键字

break用在for循环中时，可以跳出循环

package main

import (
	"fmt"
)

func f1(){
	// for中brak的使用
	for i := 0; i < 10; i++ {
		fmt.Println(i)
		if i>=5 {
			break;
		}
	}
}
/*
0
1
2
3
4
5  到5的时候循环退出了，所以break可以跳出循环
*/

func f2(){
	//switch中break的使用
	i:=2
	switch i {
	case 1:
		fmt.Println("1")
		break
	case 2:
		fmt.Println("2")
		// break  
		//加了break之后就没法穿透3了
		// fallthrough
	case 3:
		fmt.Println("3")
	}
}
/*
有break输出是2
没有break输出是 2 3
没有break和fallthrough输出是 2
*/

func f3(){
	//break可以跳转到某一个标签
MYLABEL:  //这是一个标签的定义
	for i := 0; i < 10; i++ {
		if i>=5{
			break MYLABEL //i>=5后跳转到MYLABEL处
		}
	}
	fmt.Println("end...")
}
func main() {
	f1()
	f2()
	f3()
	
}

continue关键字

只能用在for循环中，可以中止本次循环，进行下一次循环。

在continue语句后面添加标签时，表示开始标签对应的循环

package main

import (
	"fmt"
)
func f1(){
	//用在for循环中
	for i := 0; i < 10; i++ {
		if i%2==0{
			fmt.Printf("i:%v\n", i)
		}else{
			continue
		}
	}
/*
i:0
i:2
i:4
i:6
i:8
*/
}
func f2(){
//跳到某个标签里
	for i := 0; i < 10; i++ {
	MYLABEL:
		for j := 0; j < 10; j++ {
			if i==2&&j==2{
				break MYLABEL
			}
			fmt.Printf("%v,%v\n", i,j)
		}
	}
/*
不会打印出2，2
因为到2，2时，跳到了标签label处，没有继续执行 
如果是break，后面的2，3 2，4.。。。都不会输出了，直接从3，0开始
*/
}

func main() {
	f1()
	f2()
	
}

关键字goto

package main

import (
	"fmt"
)

func f1(){
	a:=0
	if a>=2{
		fmt.Println("yes")
	}else{
		goto END
	}

END:
	fmt.Println("END...")
/*
goto到了END
*/
}
func f2(){
	//跳出双层循环
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if i>=2 && j>=2{
				goto END
			}
			fmt.Printf("%v,%v\n", i,j)
		}
	}
END:
fmt.Println("END...")
/*
输出到2，1之后就输出END...了
*/
}


func main() {
	f1()
	f2()
}

golang数组

定义

package main

import (
	"fmt"
)

func f1(){
	//数组定义
	var a1 [2]int
	var a2 [3]string
	fmt.Printf("a1:%T\n", a1) //a1:[2]int
	fmt.Printf("a2:%T\n", a2) //a2:[3]string
	//没有赋初值是什么样的？
	fmt.Printf("a1:%v\n", a1) //a1:[0 0]
	fmt.Printf("a2:%v\n", a2) //a2:[  ]
}

func main() {
	f1()
	// f2()
}

初始化

package main

import (
	"fmt"
)


func f2(){
	//初始化
	//方式一：使用初始化列表初始化
	var a1 = [2]int{1,2}
	fmt.Printf("a1:%v\n", a1) //a1:[1 2]
	var b1 = [3]int{1,2}
	fmt.Printf("b1:%v\n", b1) //b1:[1 2 0]
	var a2 = [2]string{"hello","world"} 
	fmt.Printf("a2:%v\n", a2) //a2:[hello world]
	var a3 = [2]bool{true,false}
	fmt.Printf("a3:%v\n", a3) //a3:[true false]
	//方式二：省略长度，默认初始化列表的长度为数组的长度
	var a4 = [...]int{1,2,3,4}
	fmt.Printf("a4:%v\n", a4) //a4:[1 2 3 4]
	fmt.Printf("a4:%T\n", a4) //a4:[4]int
	//方式三：指定索引值的方式来初始化
	var a5 = [3]string{0:"hello",2:"here"}
	fmt.Printf("a5:%v\n", a5) //a5:[hello  here]
	var a6 = [...]string{0:"hello",3:"here"}
	fmt.Printf("a6:%v\n", a6) //a6:[hello   here]
	var a7 = [...]int{0:1,4:3}
	fmt.Printf("a7:%v\n", a7) //a7:[1 0 0 0 3]
	fmt.Printf("a7:%T\n", a7) //a7:[5]int
}

func main() {
	// f1()
	f2()
	// f3()
}

改变元素

package main

import (
	"fmt"
)


func f3(){
	//修改
	var a1=[...]int{1,2,3}
	fmt.Printf("a1:%v\n", a1) //a1:[1 2 3]
	a1[0]=100
	fmt.Printf("a1:%v\n", a1) // a1:[100 2 3]
}

func main() {
	// f1()
	// f2()
	f3()
}

访问数组元素

通过下标访问

package main

import (
	"fmt"
)
func f1(){
	var a1=[...]int{1,2,3,4,5,6}
	for i:=0;i<len(a1);i++{
		fmt.Printf("%v ", a1[i])
	}
	for i,v:=range a1{
		fmt.Printf("%v %v\n",i,v)
	}
}

func main() {
	f1()
}

golang切片（slice）

切片是可变长度的数组

声明

声明一个切片和一个数组类似，只要不添加长度就可以了

var identifier []type

切片是引用类型，可以使用make函数来创建切片

var slice1 []type = make([]type,len)
也可以简写为
slice1 := make([]type,len)

也可以指定容量，其中capacity是可选参数

make([]T,length,capacity)

示例（注意一下两种声明方式的区别）

package main

import (
	"fmt"
)
func f1(){
	//切片声明
	//方式一：类似于声明变量
	var s1 []int 
	var s2 []string
	fmt.Printf("s1:%v\n", s1) //s1:[] 使用这种方式没有分配内存还，所以是空
	fmt.Printf("s2:%v\n", s2) //s2:[]
	//方式二：通过make函数来声明 前面是类型，后面是size，通过make声明需要指定长度，但是长度可变
	var s3 =make([]int,2)
	fmt.Printf("s3:%v\n", s3)  //s3:[0 0] 说明make方式已经分配了内存了，所以有默认值
}
func f2(){
	//切片的长度和容量的定义
	var s1 = []int{1,2,3}
	fmt.Printf("len:%v\n", len(s1)) //len:3
	fmt.Printf("cap:%v\n", cap(s1)) //cap:3
	
}
func main() {
	// f1()
	f2()
}

golang切片初始化

package main

import (
	"fmt"
)

func f1(){
	//方式一：直接初始化
	var s1 = []int{1,2,3}
	fmt.Printf("%v", s1)
	//方式二：使用数组初始化 取全部元素
	arr:=[...]int{1,2,3,4}
	s2:=arr[:]
	fmt.Printf("%v", s2) //[1 2 3 4]
	//取部分元素
	s3:=arr[2:4]
	fmt.Printf("%v", s3) //[3 4]
	fmt.Printf("%T", s3) //[]int 切片
	fmt.Printf("%T", arr) //[4]int 数组

}
func main() {
	f1()
	// f2()
}

切片的遍历

package main

import (
	"fmt"
)

func f1(){
	s1:=[]int{1,2,3,4,5,6}
	for i := 0; i < len(s1); i++ {
		fmt.Printf("%v\n", s1[i])
	}
	for i,v:=range s1{
		fmt.Printf("%v %v\n", i,v)
	}

}
func main() {
	f1()
	// f2()
}

切片的增删改查和copy

增加

//添加
func f1(){
	s1 := []int{}
	//添加
	s1 = append(s1,100) 
	s1 = append(s1,200)
	s1 = append(s1,300)
	fmt.Printf("%v\n", s1) //[100 200 300]
}

删除

删除是通过append来实现的

func f2(){
	var s1=[]int{1,2,3,4,5}
	//如果要删除3 ，索引是2
	s1 = append(s1[:2],s1[3:]...) //添加从开头到(2-1)1的索引元素
	//公式 a=append(s1[:index],s1[index+1]...)
	fmt.Printf("%v\n", s1) //[1 2 4 5]
}

更改

func f3(){
	var s1=[]int{1,2,3,4,5}
	s1[1]=100
	fmt.Printf("%v\n", s1) //[1 100 3 4 5]
}

查找

func f4(){
	var s1=[]int{1,2,3,4,5}
	var key=2;
	for i,v :=range s1{
		if v==key{
			fmt.Println(i) //1
		}
	}
}

copy

注意：对于一般的复制情况，例如 var s2=s1，实际上是把s1的地址赋值给了s2，所以改变s1或者s2时，另一个都会跟着改变。为了解决这种情况，使用copy函数，copy(目标、源)。这样就是只复制了值，修改一个时，另一个不会跟着改变

func f5(){
	var s1=[]int{1,2,3,4,5}
	var s2 = s1
	s2[0]=100
	fmt.Printf("%v\n", s1) //[100 2 3 4 5]
	fmt.Printf("%v\n", s2) //[100 2 3 4 5]
	/*
	发现：把s2复制给s1之后，如果s2改变，则s1也会改变
	原因：var s2=s1这种赋值方式是直接把s1的地址赋值给了s2，
	    所以修改一个，另一个也会改变
	*/
	//解决办法：copy
	s3 := make([]int,4)
	copy(s3,s1) //copy(目标，源)
	s3[2]=100
	fmt.Printf("%v\n", s1) //[100 2 3 4 5]
	fmt.Printf("%v\n", s3) //[100 2 100 4]
}

golang Map

map是一种key:value键值对的数据结构容器。map内部实现是哈希表。

map最重要的一点是通过key来快速检索数据。key类似于索引，指向数据的值

map是引用类型的

声明

//声明
func f1(){
	var m1 map[string]string //声明
	m1 = make(map[string]string) //初始化 不初始化的话无法添加元素
	fmt.Printf("%v\n", m1) //map[]
	fmt.Printf("%T\n", m1) //map[string]string
}

赋初值

//赋初值
func f2(){
	//方式一：大括号
	var m1 =map[string]string{"name":"zxx","age":"21"} 
	m1["BF"]="QYC"
	fmt.Printf("%v\n", m1) //map[age:21 name:zxx] map是无序的
	//方式二：make
	m2:=make(map[string]string)
	m2["name"]="tome"
	m2["age"]="11"
	fmt.Printf("%v\n", m2) //map[age:11 name:tome]
}

访问map

//赋初值
func f2(){
	//方式一：大括号
	var m1 =map[string]string{"name":"zxx","age":"21"} 
	m1["BF"]="QYC"
	fmt.Printf("%v\n", m1) //map[age:21 name:zxx] map是无序的
	//方式二：make
	m2:=make(map[string]string)
	m2["name"]="tome"
	m2["age"]="11"
	fmt.Printf("%v\n", m2) //map[age:11 name:tome]
}

判断某个键是否存在

//判断某个键是否存在 value,ok:=s2["name"]
//如果这个键存在，则value给出对应的值，且ok返回为true
//否则，value返回空,ok为false
func f4(){
	var s2 = map[string]string{"name":"zxx","age":"22"}
	value,ok:=s2["name"]
	fmt.Printf("%v %v\n",value,ok ) //zxx true
	value,ok=s2["name1"]
	fmt.Printf("%v %v\n",value,ok ) // false
}

遍历

func f5(){
	var s2 = map[string]string{"name":"zxx","age":"22"}
	for key:=range s2{
		fmt.Printf("%v\n", key) //name age
	}
	for key,value:=range s2{
		fmt.Printf("%v %v\n", key,value) //name zxx name zxx
	}
	for _,value:=range s2{
		fmt.Printf("%v\n",value) //22
	}
}

总代码

package main

import (
	"fmt"
)
/*
map的声明、赋值和遍历
*/

//声明
func f1(){
	var m1 map[string]string //声明
	m1 = make(map[string]string) //初始化 不初始化的话无法添加元素
	fmt.Printf("%v\n", m1) //map[]
	fmt.Printf("%T\n", m1) //map[string]string
}
//赋初值
func f2(){
	//方式一：大括号
	var m1 =map[string]string{"name":"zxx","age":"21"} 
	m1["BF"]="QYC"
	fmt.Printf("%v\n", m1) //map[age:21 name:zxx] map是无序的
	//方式二：make
	m2:=make(map[string]string)
	m2["name"]="tome"
	m2["age"]="11"
	fmt.Printf("%v\n", m2) //map[age:11 name:tome]
}
//访问map
func f3(){
	m1:=make(map[string]string)
	m1["name"]="zxx"
	m1["age"]="22"
	fmt.Printf("%v\n", m1) //map[age:22 name:zxx]
	fmt.Printf("%v\n", m1["age"]) //22
}
//判断某个键是否存在 value,ok:=s2["name"]
//如果这个键存在，则value给出对应的值，且ok返回为true
//否则，value返回空,ok为false
func f4(){
	var s2 = map[string]string{"name":"zxx","age":"22"}
	value,ok:=s2["name"]
	fmt.Printf("%v %v\n",value,ok ) //zxx true
	value,ok=s2["name1"]
	fmt.Printf("%v %v\n",value,ok ) // false
}
//遍历
func f5(){
	var s2 = map[string]string{"name":"zxx","age":"22"}
	for key:=range s2{
		fmt.Printf("%v\n", key) //name age
	}
	for key,value:=range s2{
		fmt.Printf("%v %v\n", key,value) //name zxx name zxx
	}
	for _,value:=range s2{
		fmt.Printf("%v\n",value) //22
	}
}

func main() {
	f1()
	f2()
	f3()
	f4()
	f5()
}