内容详细
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) // 类型不一样