Go基础02

1 包管理

#1  包：模块的意思
#2 自定义包
	-go语言的代码必须放在gopath的src路径下
    -包导入是从gopath的src路径下开始检索（开始找）
    -除了main包以外，建议包名就叫文件夹名，一个文件夹下的包名必须一致
    -同一个包下，变量，函数只能定义一次
    -同一个包下的变量和函数可以直接使用
    -包内的函数或变量，想让外部包使用，必须首字母大写
    -以后下的第三方包都是放在gopath的src路径下
# 3 init函数（特殊函数）
	-不需要调用就会执行
    -可以定义多个
# 4 包导入的几种方式
	-import "day02/mypackage"
    -给包重命名
    	-import 名字 "day02/mypackage"
       
    -包只导入，不使用
    import _ "day02/mypackage"   //使用它的init方法
 
# 5 go语言没有一个统一包管理的地址，大家都放到github上

# 6 采用go mode模式
	-两种创建方式之一
    	-命令行下输入：go mod init 项目名   在当前路径下创建出go.mod(该项目依赖go的版本，第三方包版本)
        -项目路径的cmd窗口，go get 第三方包，就会在go.mod中加入依赖
        -以后把项目copy给别人，go install
        -自己写的包，就放在自己项目路径下
        -加代理的方式：手动写，goland中配置
   	-在goland中创建项目时，直接指定modules，可以配置环境变量（加代理）

2 if-else语句

if 表达式 {
    ...
} else if 表达式2 {
    ...
}else {
	...
}

3 循环

  没有while循环，没有do while循环，只有一个for循环
1.全表达式
for i:=0;i<10;i++{
    fmt.Println(i)
}
 fmt.Println(i)  //报错 ，没有定义i
2 省略第一部分
i:=0   //作用域范围大，不止在for内部，外部也可以用
for ;i<10;i++{
    fmt.Println(i)
}
注意:
	循环会改变i的值,循环结束，此时i的值为9
3 省略第三部分
	i:=0   //作用域范围大，不止在for内部，外部也可以用
	for ;i<10;{
	fmt.Println(i)
		i++
	}
3.2 省略一和三部分的简略写法（这就是while循环）  for 条件{ 循环体内容}
	i:=0
	for i<10{
		fmt.Println(i)
		i++
	}
4 死循环
	for {
		fmt.Println("ssssss")
	}
5	break :结束本次for循环，
	continue: 结束本次循环，继续下一次循环

4 .switch语句

// switch 是一个条件语句，用于将表达式的值与可能匹配的选项列表进行比较，并根据匹配情况执行相应的代码块。它可以被认为是替代多个 if else 子句的常用方式
1 默认情况
num:=40
switch num {
    case 1:
    fmt.Println("1")
    case 2:
    fmt.Println("2")
    case 3:
    fmt.Println("3")
    case 4:
    fmt.Println("4")
    default:
    fmt.Println("我没有匹配")
}

2 多表达式判断
num:=40
switch num {
    case 1,2,3,4,5,6,7,8:
    fmt.Println("1")
    case 10,11,16:
    fmt.Println("2")
    case 30:
    fmt.Println("3")
    case 40,44,45:
    fmt.Println("4")
    default:
    fmt.Println("我没有匹配")
}
4 无表达式的 switch
num:=80
switch  {
    case num==12,num==13:
    fmt.Println("12,13")
    case num==40,num==41:
    fmt.Println("40,41")
    default:
    fmt.Println("我没有匹配")
}
注意:
	fallthrough  //穿透，只要看到fallthrough，无条件执行下一个case或者default
goto:饱受诟病  java 保留字，没有实际作用

5.数组

数组：数组是同一类型元素的集合。可以放多个值，但是类型一致，内存中连续存储
// Go 语言中不允许混合不同类型的元素
1 数组的定义,数组的大小，在定义阶段就确定了，而且不能改
	var names [3]string
	var ages [3]int8
2 数组赋值
	var ages [3]int8
	ages[0]=99
	ages[2]=88
3 定义并初始化,
	var ages [3]int=[3]int{1,2,3}
	ages:=[3]int{1,3,4,7}  //不允许多放
4 数组定义并初始化的其他（了解）数组只要定义，长度就固定了，。。。,后面放几个值，数组大小是多少
	var ages [9]int=[...]int{1,2,3,4,5,6,7,8}   //不支持这个
	var ages =[...]int{1,2,3,4,5,6,7,8}
5 数组的大小是类型的一部分
	var a [2]int=[2]int{1,2}
	var b [2]int=[2]int{1,3}
	b=a   //如果不是同一种类型，不允许相互赋值
6 数组是值类型
	var a [2]int=[2]int{1,2}
	fmt.Println(a)
	test5(a)  //因为数组是值类型，go函数传参，都是copy传递，如果是值类型，函数内改了，不会影响原来的
	fmt.Println(a)
7 数组长度  len()  数组长度在定义阶段已经固定
	var a [2]int=[2]int{1,2}
	fmt.Println(len(a))
8 数组循环
	var a =[...]int{7,4,3,5,6,7}
	fmt.Println(a[99])
	fmt.Println(len(a))
	普通循环
	for i:=0;i<len(a);i++{
		fmt.Println(a[i])
	}
	通过range来循环  (range不是内置函数，是一个关键字，for，if，else),打印出索引
	for i:=range a{
		fmt.Println(i)
	}

	//如果用一个变量来接收，这个值是可迭代的索引
	//如果用两个变量来接收，这两个变量，一个是索引，一个具体的值
	for i,value:=range a{
		fmt.Println(i)
		fmt.Println(value)
	}
	把数组循环打印出来
	for _,value:=range a{
		fmt.Println(value)
	}

	 9 多维数组
	var a [3][3]int  //定义
	a[0][1]=99      //使用
	fmt.Println(a)
	定义并赋初值
	var a [3][3]int=[3][3]int{{1},{1,2,3},{4,4,4}}
	var s =[3][3]string{{"lqz","xxx","yyy"},{},{}}
	fmt.Println(s)
	////循环多维数组
	for _,value:=range s{
		for _,in_value:=range value{
			fmt.Println(in_value)
		}
	}

	10 数组定义并指定位置初始化
	var names [100]int=[100]int{10:99,99:99}
	var names [100]int=[100]int{10,11,2,44,99:99,45:88}
	fmt.Println(names)

6 切片基础(对数组的引用)

//切片:理解下面的话就行: 切片是对底层数组的引用，切片有容量cap()，长度len()，当容量不够时会依赖新数组，与之前的无关,下面的所有都是围绕这句话理解
1 切片定义的第一种方式
定义一个数组
var a =[10]int{9,8,7,6,5,4,3,2,1,0}
基于数组，做一个切片	
s := a[0:2] //前闭后开  此时s [9,8] 长度为 2 ,容量为10,因为指针指向的是原数组的第0个位置开始切的，是基于原来的数组的  如果 s := a[1:3]  此时长度为2 容量为9
2 使用切片
fmt.Println(a[0])
3 修改切片，会影响数组
 s[0] = 999 // a[0] 也是999，因为是对数组的引用
4 修改数组，是否会影响切片？
a[0] = 888   //s[0] 也是 888，因为是对数组的引用
//当多个切片共用相同的底层数组时，每个切片所做的更改将反映在数组中
5 切片追加值
	s = append(s,999) //原来的切片的s是[9,8] 在后面追加一个999,s = [9,7,999]由于切片是对底层数组的引用，原数组的a[2] 也变成999,
6.当容量不够时，添加如何
	var a = [...]int{9,8,7}
	b := a[0:2] // b = [9 8]  len = 2  cap = 3
	a[0] = 999   // 由于切片是对底层数组的引用
	fmt.Println(a)   // a = [999 8 7]
	fmt.Println(b)   // b = [999 8]
	b = append(b, 555)   // 添加一个 b = [999 8 555] len=3 cap= 3 
	fmt.Println(a)    // 由于切片是对底层数组的引用  a = [999 8 555]
	fmt.Println(b)     // b = [999 8 555]
	b[0] = 666          // b = [666 8 555]
	fmt.Println(a)       //a = [666 8 555]
	fmt.Println(b)			// b = [666 8 555]  由于切片是对底层数组的引用
	b = append(b, 999)     //b添加一个999， 由于原来的容量不够了，他要扩容，并且要以来新的数组
	b[0] = 777       // b = [777 8 555 999]
	fmt.Println(a)// 由于刚刚的b扩容了，依赖新的的数组了，和切片b和a没有关系了 a=[666 8 55]
	fmt.Println(b) // b = [777 8 555 999]