包管理

#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)
}