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]