包管理
#1 包：模块的意思
#2 自定义包
-代码必须放在gopath的src路径下
-第三方包都是放在gopath的src路径下
-包导入是从gopath的src路径下开始检索（开始找）
-除了main包以外，建议包名就叫文件夹名，一个文件夹下的包名必须一致
-同一个包下，变量，函数只能定义一次
-同一个包下的变量和函数可以直接使用
-包内的函数或变量，想让外部包使用，必须首字母大写
# 3 init函数（特殊函数）
-不需要调用就会执行
-可以定义多个
# 4 包导入的几种方式
-import "kkk/mypackage"
-给包重命名
-import 名字 "day02/mypackage"
名字.变量/函数
-包只导入，不使用
import _ "kkk/mypackage"
# 5 go语言没有一个统一包管理的地址，大家都放到github上
# 6 采用go mode模式
-两种创建方式之一
-命令行下输入：go mod init 项目名 在当前路径下创建出go.mod(该项目依赖go的版本，第三方包版本)
-项目路径的cmd窗口，go get 第三方包，就会在go.mod中加入依赖
-以后把项目copy给别人，go install
-自己写的包，就放在自己项目路径下
-加代理的方式：手动写，goland中配置
-在goland中创建项目时，直接指定modules，可以配置环境变量（加代理）
if-else语句
package main
import "fmt"
//if-else
func main() {
//1 if else
a := test()
if a>10{
fmt.Println("a大于10")
}else {
fmt.Println("a小于10")
}
//2 if --else if--- else
if a > 10 {
fmt.Println("dayu 10")
} else if a == 10 {
fmt.Println("10101010")
} else {
fmt.Println("xiaoyu 10")
}
//3 条件语句后不能回车换行
if a > 10 {
fmt.Println("dayu 10")
} else if a == 10 {
fmt.Println("10101010")
} else {
fmt.Println("xiaoyu 10")
}
}
func test() int {
return 100
}
循环
1 没有while循环，没有do while循环，只有一个for循环
package main
//for 循环
/* for 后面三部分，都可以省略
for 变量初始化;条件；变量自增/自减 {
循环体内容
}
*/
func main() {
//1 基本使用
for i:=0;i<10;i++{
fmt.Println(i)
}
//2 省略第一部分
i:=0 //作用域范围大，不止在for内部，外部也可以用
for ;i<10;i++{
fmt.Println(i)
}
//2 省略第三部分
i:=0 //作用域范围大，不止在for内部，外部也可以用
for ;i<10;{
fmt.Println(i)
i++
}
//3 省略一和三部分的简略写法（这就是while循环） for 条件{ 循环体内容}
i:=0
for i<10{
fmt.Println(i)
i++
}
//4 死循环
for {
fmt.Println("ssssss")
}
//5 只是演示开多协程
for i:=0;i<4000;i++{
go test2()
}
//6 break :结束本次for循环，continue结束本次循环，继续下一次循环
}
func test2() {
for {
fmt.Println("sssss")
}
}
switch语句
// switch 是一个条件语句，用于将表达式的值与可能匹配的选项列表进行比较，并根据匹配情况执行相应的代码块。它可以被认为是替代多个 if else 子句的常用方式
package main
import "fmt"
func main() {
//1 基本使用
num:=4
switch num {
case 1:
fmt.Println("1")
case 2:
fmt.Println("2")
case 3:
fmt.Println("3")
case 4:
fmt.Println("4")
}
//2 默认情况
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("我没有匹配")
}
//3 多表达式判断
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("我没有匹配")
}
//5 Fallthrough
num:=12
switch {
case num==12,num==13:
fmt.Println("12,13")
fallthrough
case num==40,num==41:
fmt.Println("40,41")
//fallthrough //穿透，只要看到fallthrough，无条件执行下一个case或者default
default:
fmt.Println("我没有匹配")
}
}
goto:饱受诟病 java 保留字，没有实际作用
数组
package main
import (
"fmt"
)
//数组：数组是同一类型元素的集合。可以放多个值，但是类型一致，内存中连续存储
func main() {
//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}
var ages [3]int=[3]int{1,2}
var ages [3]int=[3]int{}
var ages=[3]int{}
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}
ages :=[...]int{1,2,3,4,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}
test5(a) //因为数组是值类型，go函数传参，都是copy传递，如果是值类型，函数内改了，不会影响原来的
//7 数组长度 len() 数组长度在定义阶段已经固定
//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"},{},{}}
//循环多维数组
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}
func test5(a [2]int) {
a[0]=99
}
切片
package main
import "fmt"
//切片：切片是由数组建立的一种方便、灵活且功能强大的包装（Wrapper）。切片本身不拥有任何数据。它们只是对现有数组的引用
func main() {
//1 切片定义的第一种方式
//定义一个数组
var a =[10]int{9,8,7,6,5,4,3,2,1,0}
//基于数组，做一个切片
//[]int 中括号中不带东西，就是切片类型
var b []int
b=a[:]
//2 使用切片
fmt.Println(b[0])
//3 修改切片，会影响数组
b[0]=999
// 5 切片只切数组一部分
var a =[10]int{9,8,7,6,5,4,3,2,1,0}
var b []int=a[3:5]
fmt.Println(b)
//6 当多个切片共用相同的底层数组时，每个切片所做的更改将反映在数组中
var a =[10]int{9,8,7,6,5,4,3,2,1,0}
var b []int=a[3:5]
var c []int=a[4:6]
//7 切片的长度和容量
var a =[10]int{9,8,7,6,5,4,3,2,1,0}
var b []int=a[3:5]
var b []int=a[7:8]
// 切片长度
fmt.Println(len(b))
// 切片容量（最多能存多少值）
fmt.Println(cap(b))
//8 切片追加值
b=append(b,3)
b=append(b,999)
//到了临界点再追加，超过切片容量，会新开辟新的内存地址存，之后修改不会影响原来的数组了
b=append(b,888)
fmt.Println(b)
fmt.Println(a)
}
