GO基础小结

go语言基础小结

（李文州老师的课）

1.流程控制

1.If

if 条件1{
	分支1
}else if 条件2{
	分支2
}else 条件3{
	分支3
}			

2.for循环

1.标准写法

for i:=0;i<=10;1++{
	fmt.println(i)
}	

2.省略初始语句

i:=0
for ;i<=10;i++{
	fmt.println(i)
}	

3.初始与结束语句都省略

i:=0
for  ;i<=10{
	fmt.println(i)
	i++	
}

4.无限循环

break、goto、panic、return强制退出循环

for {
	循环体
}	

3.for range 遍历

遍历对象：数组、切片、map、channel、字符串

4.switch case（对大量的值进行条件判断）

一个switch只能有一个default

1.

finger:=3
switch finger{
	case1:
		fmt.println("大拇指")
	case2:
		fmt.println("食指")
	case3:
		fmt.println("中指")
	case4:
		fmt.println("无名指")
	case5:
		fmt.println("小拇指")
	default:
		fmt.println("输入无效")

2.

switch n:=1;n{
case 1,3,5,7,9:
	fmt.println("奇数")
case 2,4 6,8 :
	fmt.println("偶数")
default :
	fmt.println("输入无效")
}

3.当分支后有表达式时，分支后不用跟变量

age:=30
switch {
	case age<18:
		fmt.println("五年高考，三年模拟")
	case age>18:
		fmt.println("人生开始了")
	default:
		fmt.println("活着真好")
}

5.goto（跳转到指定标签）

6.break

7.continue（跳过本次循环，进行下一次循环）

continue后的所有语句都不执行，直接进行下一次循环

8.练习：九九乘法口诀表

package main

import "fmt"

func main() {
	for i:=1;i<=9;i++{
		for j:=1;j<=i;j++{
			fmt.Printf("%vx%v=%v\t",i,j,i*j)
			}
		fmt.Println("")//重中之重！！！！！！
	}
}
1x1=1	
2x1=2	2x2=4	
3x1=3	3x2=6	3x3=9	
4x1=4	4x2=8	4x3=12	4x4=16	
5x1=5	5x2=10	5x3=15	5x4=20	5x5=25	
6x1=6	6x2=12	6x3=18	6x4=24	6x5=30	6x6=36	
7x1=7	7x2=14	7x3=21	7x4=28	7x5=35	7x6=42	7x7=49	
8x1=8	8x2=16	8x3=24	8x4=32	8x5=40	8x6=48	8x7=56	8x8=64	
9x1=9	9x2=18	9x3=27	9x4=36	9x5=45	9x6=54	9x7=63	9x8=72	9x9=81	

2.数组

1.定义

统一数据类型元素的集合

声明数组

var a [长度]int

2.初始化

1.声明时直接初始化

var a [3]int{0,1,2}
var b [2]string{"北京","上海"}

2.不声明长度，自动填入

var a [...]int{1,2,3,4}
var b  [...] string{"北京","上海","深圳"}

3.索引式初始化

var a [3]int{0:1,1:2}

3.数组遍历

1.for循环遍历

var a =[...]int{0,1,2}
for i:=0; i<len(a); i++{
	fmt.println(a[i])
}

2.for range 遍历

1.索引式遍历

var b= [...]string{"北京","上海","深圳"}
for index ,value:=range b{
	fmt.println(index,value)
}

2.无索引遍历

var b =[...]string {"北京","上海","深圳"}
	for_,v:=range b{
	fmt.println(v)

4.多维数组（以二维数组为例）

1.二维数组的定义

func main(){
	var a:=[3][2]string{
	{"我","是"},
	{"雄","安"},
	{"新","区"},
}
//访问“雄”
fmt.println(b[1][0])//层层访问

2.二维数组的遍历

func main(){
	var a:=[3][2]string{
	{"我","是"},
	{"雄","安"},
	{"新","区"},
}
//我自己摸索的：
for _,value:=range a{
		for _,value1:=range value{
			fmt.Println(value1)
		}
	}
//李文州老师的：
for _, v1 := range a {
		for _, v2 := range v1 {
			fmt.Printf("%s\t", v2)
		}
		fmt.Println()
	}
}

5.数组是值类型

赋值、传参会复制整个数组，改变副本不影响本身，传参或赋值之后，改变母本，也不影响副本。
赋值，传参之后，互不相干

b1:=[3]int {1,2,3}//b1[1,2,3]
		b2:=b1//b2:[1,2,3]
		b1[0]=5//b1[5,2,3]
		b2[0]=100//b2:[100,2,3]
		fmt.Println(b1,b2)
		//b1[5,2,3]
		//b2[100,2,3]

6.练习：作业

1.求数组[1, 3, 5, 7, 8]所有元素的和

func main() {
	b:=0
	a:=[...]int{1,3,5,7,8}
	for _,v:=range a{
		b=b+v
	}
	fmt.Println(b)
}
//24

2.找出数组中和为指定值的两个元素的下标，比如从数组[1, 3, 5, 7, 8]中找出和为8的两个元素的下标分别为(0,3)和(1,2)。

func main() {
var a =[...]int{1,3,5,7,8}
for i1,v1:=range a{
	for i2,v2:=range a{
		if v1+v2==8{
			fmt.Printf("(%v,%v\t)",i1,i2)
		}
	}
}
}//上述代码会出现重复，不大好!!!

结果是：
(0,3 )(1,2 )(2,1 )(3,0 )
更好的代码段

func main() {
var a =[...]int{1,3,5,7,8}
for i1,v1:=range a{
	for i2,v2:=range a{
		if v1+v2==8{
			fmt.Printf("(%v,%v\t)",i1,i2)
		}
	}
}
}

结果是：
(0,3 )(1,2 )

3.切片

切片&数组

数组的长度固定，不可自动扩容，使用起来有较大局限性
切片是拥有相同类型元素的可变长度的序列，是基于数组的封装，
切片的底层是数组

1.切片定义

1.定义切片

var a []string
var b [] int
var c [] bool

2.切片初始化

var a =[] string {"小","王","子"}
var b =[] int{1,2,3}
var c =[] bool{true,false}

3.切片有自己的长度和容量，并且会自动扩容。

4.切片==nil是没有底层数组

var a []int//a==nil(a没有底层数组，打印结果：[])
var b =[]int{}//b!=nil(b有底层数组，底层数组为空,打印结果：[])
//初始化了就不==nil

2.构造切片

1.由数组得到切片

切片依仗底层数组存活

1. 切片指向底层数组
2. 切片的容量是底层数组的容量
3. 改变底层数组，则改变全部切片

//声明一个数组：
	a1:=[...]int{1,2,3,4,5,6,3,7,0,8}
//切割数组：得到s3：[1,2,3,4](包左不包右)
	s3:=a1[0:4]
	fmt.Println(s3)
	s4:=a1[2:6]//s4:[3,4,5,6,3]
	fmt.Println(s4)
	s5:=a1[:4]//s5:[1,2,3,4]
	s6:=a1[2:]//s6:[3,4,5,6,3,7,0,8]
	s7:=a1[:]//s7:[1,2,3,4,5,6,3,7,0,8]
	fmt.Println(s5,s6,s7)
	fmt.Printf("len(s5):%d cap(s5):%d\n",len(s5),cap(s5) )
	//切片的容量是底层数组的容量！！！！！
	//len(s5):4 ,cap(s5):10
	fmt.Printf("len(s6):%d cap(s6):%d\n",len(s6),cap(s6) )
	//len(s6):8, cap(s6):8
	//切片是指向了一个底层数组。
	//切片额度长度是他元素的个数
	//切片的容量是：底层数组从第一个元素到最后一个元素。
	//切片支持扩容
	//切片再切片，切片是一个引用类型，他们都指向底层的数组，
	s8:=s6[3:]//s8:[6,3,7,0,8]
	fmt.Printf("len(s8):%d cap(s8):%d\n",len(s8),cap(s8)  )
	//len(s8):5,cap(s5):5
	fmt.Println(a1,s6,s8)
	//改变底层数组
	a1[6]=13000//a1:[1,2,3,4,5,13000,3,7,0,8]
	//一改则全改
	fmt.Println(s6)//s6:[3 4 5 6 13000 7 0 8]
	fmt.Println(s8)//s8:[6 13000 7 0 8]

2.make函数构造切片

定义方法：
make （[]类型 大小 容量）

//make ([]T,size,cap)
	s1:= make ([]int ,5,10)
	fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d\n",s1,len(s1) ,cap(s1) )
//s1=[0,0,0,0,0],len(s1):5,cap(s5):10
	//如果定义的时候没有定义容量，则容量=长度
	s2:= make ([]int ,0,10)
	fmt.Printf("s2=%v len(s2)=%d cap(s2)=%d\n",s2,len(s2) ,cap(s2))
	//如果标注长度为零，则数组为空
//s2=[],len(s2):0,cap(s2):10
	//切片的本质：就是一个框，框住了一块连续的内存。属于应用类型，真正的数据都是保存在底层数组中。
	//切片的长度是里面东西的个数。
	//切片之间不可以直接比较，
	//一个nil值的切片的长度和容量都是0；
	//但我们不可以说一个长度和容量都是0的切片一定是nil。详见c与a
	var a[]int//切片为空，没有初始化，无底层数组
	fmt.Printf("len(a)=%d cap(a)=%d\n",len(a) ,cap(a))//a=nil
	b:=[]int {}//切片不为空，有自己的底层数组，底层数组为空
	fmt.Printf(" len(b)=%d cap(b)=%d\n",len(b) ,cap(b))//b!=nil
	c:=make ([]int, 0)//一个长度和容量都为0的切片不一定为空
	fmt.Printf("len(c)=%d cap(c)=%d\n",len(c),cap(c))//c!=nil
//如果要判断一个切片是否为空，要用len(s)==0判断，而不能用s==nil来判断
	fmt.Println(a==nil)//true
	fmt.Println(b==nil)//false
	fmt.Println(c==nil)//false

3.append方法添加元素

func main(){
	var s []int
	s = append(s, 1)        // [1]
	s = append(s, 2, 3, 4)  // [1 2 3 4]
	s2 := []int{5, 6, 7}  
	s = append(s, s2...)    // [1 2 3 4 5 6 7]
}

4.从切片中删除元素

Go语言中没有相应删除元素的语言
利用append方法删除元素
记得加上…

func main() {
	// 从切片中删除元素
	a := []int{30, 31, 32, 33, 34, 35, 36, 37}
	// 要删除索引为2的元素
	a = append(a[:2], a[3:]...)
	fmt.Println(a) //[30 31 33 34 35 36 37]
}

3.切片的赋值拷贝与复制

1.赋值拷贝一变都变

赋值拷贝之后共用同一底层数组一变都变
切片是引用类型，s1与s2指向同一块内存地址，修改其中一个另一个也会改变。

func main() {
	s1 := make([]int, 3，3) //[0 0 0]
	s2 := s1             //将s1直接赋值给s2，s1和s2共用一个底层数组
	s2[0] = 100
	fmt.Println(s1) //[100 0 0]
	fmt.Println(s2) //[100 0 0]
}

2.copy()函数复制个变个的

不牵扯底层数组

func main() {
	// copy()复制切片
	a := []int{1, 2, 3, 4, 5}//构造底层数组
	c := make([]int, 5, 5)//使用make()函数构造切片
	copy(c, a)     //使用copy()函数将切片a中的元素复制到切片c
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(c) //[1 2 3 4 5]
	c[0] = 1000
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(c) //[1000 2 3 4 5]
}

3.append改变底层数组

a:=[...]int{1,2,3,4,5,6,7,8,9}
	b:=a[:]
	b=append(a[0:1],a[2:]...)
	fmt.Println(a,b)//append会改变底层数组
//a:[1,3,4,5,6,7,8,9,9]
//b:[1,3,4,5,6,7,8,9]

4.切片的遍历

1.for循环遍历

a:=make ([]int,3,3)
	 a=append(a,1,2,3)
	 for i:=0;i<len(a);i++{
	 	fmt.Println(a[i])
	 } 
//遍历结果：
0
0
0
1
2
3

2.for range 遍历

a:=make ([]int,3,3)
	 a=append(a,1,2,3)
	 for i,v:=range a{
	 	fmt.Println(i,v)
	 }
//遍历结果：
0 0
1 0
2 0
3 1
4 2
5 3

课后作业

1.写出下列代码的结果

func main() {
	var a = make([]int, 5, 10)
	for i := 0; i < 10; i++ {
		a = append(a,i)
	}
	fmt.Println(a)
}//000000123456789

2…请使用内置的sort包对数组var a = […]int{3, 7, 8, 9, 1}进行排序（附加题，自行查资料解答）。

将接口的时候再说