内容详细
1 包的使用
// 之前都是放在一个go文件，python 中有模块和包，想把一类的代码放到一起，一起就是放到一个包中
// 包的创建和管理有两种
-go path模式
-go mod 出现之前，所有的代码都要放在go path的src路径下
-go env可以看到go path，/Users/liuqingzheng/go 有三个文件夹
-src：存放代码，项目，第三方包，自己写的包都要放在这
-bin：编译后的文件放在这，下载的第三方可执行文件放在这，已经被加入环境变量了
-pkg：编译过程中产生的中间文件存放路径
-如果项目不放在go path路径下，项目执行不了，导入包也导入不成功
-已经被弃用了，默认使用go mod
-go path，go root
-go mod模式(99.999)
-1.11后官方出现，1.13后作为标准了，的一种包管理方式
-用了它：项目可以放在任意路径下，都可以运行，包一般放在项目中，可以下载并使用第三方包
-不同的项目：第三方包单独用自己的，不会出现混乱
-go mod init // 初始化---》执行它以后，项目根路径会有go.mod文件
-使用goland直接创建，就有了
-go mod tidy // 清理优化第三方包，把go mod中的不使用的包删除，使用的下载下来
-下了一个别人写的项目，安装包-->pip install -r reqirement.txt
-go mod tidy
// 包分为自定义的包和第三方包
// 自定义的包
-在项目路径下新建一个文件夹即可
-在文件夹中新建go文件，每一个go文件的第一句，都是声明包
-默认生成的包名就是文件夹的名字---》可以改，但是不建议改
-在当前文件夹下的所有go文件，都必须属于同一个包
-所有go文件的包名都必须一致，如果不一致就报错
-在文件夹下如果再建文件夹，表示又新建了个包，跟外层的包，没有必然联系
// 包的使用
-在包中定义变量，定义函数，给其他包用
-大写字母开头，表示导出字段---》只有大写字母开头的变量或函数才能被其他包使用
-如果小写字母开头，表示只给包内部使用 (面向对象中隐藏数据或方法)
-只要是同一个包下，所有的变量函数... 都是共享的，相当于在同一个go文件中
// 具体使用
-导入包：import "go_day03_demo/utils/package1"
-根据包名使用 ：package1.Test()
// python中
-创建一个文件夹，文件夹下有init，在文件夹下创建任意多个py文件
-如果在不通py文件中使用其他py文件的变量，函数，也需要导入
-init中可以注册一些给其他包使用的变量，类，函数
-python推荐：把给其他包使用的变量，放在init中注册，以后只需要导入包名这一层，就可以使用在init中注册的变量。。。
-python比较灵活，把所有权限都放给了程序员，你如果想用包内部的变量。。，直接from import导入即可
// go 中
-go包中大写字母开头的，就相当于在 python的init中注册了
-小写字母开头的，不允许使用
// go中包管理的其他
-导入多个包，可以使用
import (
"fmt"
"go_day03_demo/utils"
)
-在任意包中，都可以写多个函数 init ，没有参数，没有返回值，只要包一导入，就会执行它,执行顺序是从上往下执行
-类比：python的 __init__.py ,只要一导入，就会执行
-有什么用？这个初始化的一些操作放在里面
-只导入包，不使用
-因为导入包会执行init，就只想让包内容初始化，但是不用包中的变量。。
-_ "go_day03_demo/utils"
-导入包，给包重命名
pk1 "go_day03_demo/package1"
2 if-else语句
// 逻辑判断---》条件成立执行if的代码，不成立执行else
// 语法1
if 条件 {
}else{
}
// 语法2
if 条件 {
}else if 条件{
}else if 条件{
}else{
}
// 语法3 ---》用的比较多
if 变量初始化;条件 {
}else{
}
package main
// if -else 的使用
func main() {
// 1 基本使用
//var num=11
//// 对2取余，如果余数等于0，说明能整除
//if num%2==0 {
// fmt.Println("能整除")
//}else {
// fmt.Println("不能整除")
//}
// 2 if --else if --else
//var score = 90
//if score > 90 {
// fmt.Println("优秀")
//} else if score > 80 && score <= 90 {
// fmt.Println("良好")
//} else {
// fmt.Println("很一般")
//}
// 3 判断时，初始化
//if b:=add(6,99);b>100{
// fmt.Println("b 大于100")
//}
// 4 if 后的 条件 和 { 必须在一行
// 整除情况下所有编程语言每行结尾都要加 ; ,不需要是因为读到 \n 自动给加的，所有有的语言可以不用加
//if b:=add(6,99);b>100{
// fmt.Println("b 大于100")
//}
}
func add(a,b int)int {
return a+b
}
3 循环
// 在go中，只有for循环，没有其他循环关键字，没有while循环，也没有 do while
// 通过for循环是可以实现 类似于while的功能
// 语法
for 变量初始化;条件;自增{
循环体的内容
}
// 重点记住
-for关键字后三段，都可以省略不写
// break ,continue 一毛一样，没有任何区别
package main
import "fmt"
//for 循环
func main() {
//1 基本使用 打印0---9 ,变量定义需要用简略声明方式
//for i := 0; i < 10; i++ {
// fmt.Println(i)
//}
//2 省略第一部分，跟第一种的区别在于 i 的作用域范围不一样，这个i在for外包还有效
//i:=0
//var i =0
//var i int = 0
//for ; i < 10; i++ { // 第一个分号必须写
// fmt.Println(i)
//}
// 3 省略第三部分
//for i := 0; i < 10; { // 分号必须写
// fmt.Println(i)
// i++
//}
// 4 省略第一部分和第三部分---》这就是while循环
//i := 0
////for ;i < 10; { // 分号可以不写
//for i < 10 { // 分号可以不写
// fmt.Println(i)
// i++
//}
// 仔细观察，变成了 for 条件{}---》它就是while循环
// 5 三部分全省略--->死循环，等同于 for true {}
//for ; ;{
//for true {
//for {
// fmt.Println("lqz is nb")
//}
// 6 上面学的for循环，都是基于索引的循环
// python中没有基于索引的循环，python中都是基于迭代的循环，py中的for 都要写可迭代对象，py中把好的东西做成了可迭代
// go 语言中，有基于索引的和基于迭代的
// js中，早期版本只有基于索引的，没有基于迭代的；后期有基于索引和基于迭代的
// java 中，1.8之前没有基于迭代的循环，只有基于索引的，1.8以后都有了
var a [3]int=[3]int{4,5,6}
//for i:=0;i<len(a);i++{ // 基于索引
// fmt.Println(a[i])
//}
for _,v:=range a{ //range 在go中是关键字
//fmt.Println("顺序是：",i)
fmt.Println("值是：",v)
}
}
4 switch语句
// switch 是为了优雅的替换掉if-else
// python中没有switch关键字，js，java，go都有，用的不算多
// 语法
switch 变量 {
case 条件:
执行1
case 条件2:
执行2
case 条件3:
执行3
}
package main
import "fmt"
// switch
func main() {
// 1 基本使用
//var a =5
//switch a {
//case 3:
// fmt.Println("a是3")
//case 5:
// fmt.Println("a是5")
//case 10:
// fmt.Println("a是10")
//}
// 2 default的使用
//var a =2
//switch a {
//case 3:
// fmt.Println("a是3")
//case 5:
// fmt.Println("a是5")
//case 10:
// fmt.Println("a是10")
//default:
// fmt.Println("不知道你是几")
//}
// 3 多表达式判断
//var a =9
//switch a {
//case 1,2,3:
// fmt.Println("a是3")
//case 4,5,6,7,8,9:
// fmt.Println("a是5")
//case 10,11,12,15:
// fmt.Println("a是10")
//default:
// fmt.Println("不知道你是几")
//}
// 4 无表达式
//var a = 4
//switch {
//case a == 2 || a == 3: // 条件
// fmt.Println("2，3")
//case a == 4: // 条件
// fmt.Println("4")
//default:
// fmt.Println("不知道")
//}
// 5 Fallthrough的使用
var a = 4
switch a {
case 2, 3:
fmt.Println("2，3")
fallthrough
case 4, 5:
fmt.Println("4,5")
fallthrough // 位置必须是case内部，五条件执行下一个
case 6, 7:
fmt.Println("6,7")
//fallthrough // 位置必须是case内部，五条件执行下一个
default:
fmt.Println("不知道")
}
}
5 数组
// 集合类的数据类型，可以放多个元素的数据类型
// python 常用的数据类型
// 数组是同一类型元素的集合，数组中必须放同一类型元素---》要放字符串都是字符串，要放int，都是int，写个int64
// 数组是连续存储的内存空间---->一旦申请，大小固定，不能再改变
// python中列表————》底层如何存的？-->底层就是数组--》追加值--》自动扩容(重新申请大的空间把原来的赋值过，python已经做好了，只需要用即可)
// 数组使用
数组的声明
数组是值类型
数组的长度
使用 range 迭代数组
多维数组
package main
import (
"fmt"
)
// 数组的使用
func main() {
//1 数组的声明--->定义和使用
// 定义了一个长度为3的int类型数组，里面只能放int，长度只有3
// 1.1 定义没有初始化
//var a [3]int // 没有初始化，默认值是 0 0 0
// 1.2 定义并初始化
//var a [3]int=[3]int{4,7} // 少于长度可以，多于不行
//var a =[3]int{4,7} // 少于长度可以，多于不行
//a :=[3]int{4,7} // 少于长度可以，多于不行
//fmt.Println(a) //[0 0 0]
// 1.3 定义并初始化其中有一个 ,第99位置设置成99，其它都是默认
// 98:99 98是位置，99是值
//var a [100]int=[100]int{98:99,66:77}
//fmt.Println(a)
// 1.4 定义并赋初值的另一种方式
//var a =[...]int{3,5,7,9} // 意思并不是数组可变长，意思是使用后面的值来确定数组的长度
//var a =[...]int{99:888} // 意思并不是数组可变长，意思是使用后面的值来确定数组的长度
//fmt.Println(a)
// 1.5 数组取值赋值 中括号 数字取值
//var a =[...]int{3,5,7,9}
//fmt.Println(a[0])
////fmt.Println(a[4]) // 直接越界 ，数组长度只有4
//a[1]=999
//fmt.Println(a)
// 2 数组的大小是类型的一部分
//var a =[4]int{3,5,7,9}
//var a =[5]int{3,5,7,9}
//var b =[5]int{3,5,7,9}
//if a==b{
//}
//3 数组是值类型 --->在函数中当参数传递
// 不会影响原来的---》go语言中函数的参数传递，都是copy传递
//var b =[5]int{3,5,7,9}
//test(b) // 把b复制一份传过去，传到函数内部，新的b，在函数中改了新的b不会影响原来的
//// 通过指针，可以操作
//fmt.Println(b)
//4 数组的长度 内置函数 len
//var b =[5]int{3,5,7,9}
//fmt.Println(len(b))
//5 使用 range 迭代数组
//var b =[5]int{3,5,7,9}
// 方式一：基于索引的
//for i:=0;i<len(b);i++{
// fmt.Println(b[i])
//}
// 方式二：基于迭代的
//for i,v:=range b{
// fmt.Println("顺序是：",i)
// fmt.Println("值是：",v)
//}
//6 多维数组---》最多写两层即可，别写多了
//var a [3][2]int
//fmt.Println(a) //[[0 0][0 0][0 0]]
//var a [3][2]int=[3][2]int{{1,2},{4,},{6,7}}
//fmt.Println(a)
// 取值赋值
//a[0][1]=999
//fmt.Println(a)
// 循环二维数组 --》两层循环
var a [3][2]int=[3][2]int{{1,2},{4,},{6,7}}
for _,v:=range a {
for _, v1 := range v {
fmt.Println(v1)
}
}
}
func test(b [5]int) {
b[0]=999 // 改了，会不会影响原来？
fmt.Println("函数内部",b)
}
7 补充
// 1 go 强类型，不同类型不允许直接运算
var a int =10 // 8 个字节
var b int32 =10 // 4 个字节
fmt.Println(a+b) // 类型不一样
