學習路線

2023-Go全鏈路工程師課綱 https://www.processon.com/view/link/63594cd97d9c0854f9ac855e

一、搭建環境

https://studygolang.com/dl

msi需要自己安裝

安裝目錄最好沒有中文

1. 簡單dos命令

進入磁碟 D:, C:
檢視目錄結構 dir
進入目錄 cd
目錄層級 .代表當前目錄，..代表上一層目錄
補全 tab
建立 md
刪除資料夾 rm
刪除檔案 del

2. 環境變數設定

如果我想要在任意的路徑下執行某個命令，需要將這個命令所在的目錄設定到環境變數path中去
將命令「註冊」到當前的計算機中：
解決如下錯誤：

在命令列中執行go build命令進行編譯，在執行.exe執行檔案，可獲得結果
或者是go run直接獲取執行結果

如果先編譯生成了可執行女件，那麼我們可以將該可執行檔案拷貝到沒有go開發環境的機器上，仍然可以執行
如果直接go run go原始碼，那麼如果要在另外一個機器上這麼執行，需要go開發環境，否則無法執行。

2.語法注意事項

（1）原始檔以"go"為擴充套件名。

（2）程式的執行入口是main()函數。

（3）嚴格區分大小寫。

（4）方法由一條條語句構成，每個語句後不需要分號(Go語言會在每行後自動加分號)，這也體現出Golang的簡潔性。

（5）Go編譯器是一行行進行編譯的，因此我們一行就寫一條語句，不能把多條語句寫在同一個，否則報錯

（6）定義的變數或者import的包如果沒有使用到，程式碼不能編譯通過。

（7）大括號都是成對出現的，缺一不可

3.程式碼風格

【1】注意縮排
向後縮排：tab
向前取消縮排：shift+tab
通過命令完成格式化操作：

【2】成對程式設計 {} （）「」 ‘’

【3】運運算元兩邊加空白

【4】註釋：官方推薦行註釋//

【5】以下程式碼是錯誤的：

原因：go的設計者想要開發者有統一的程式碼風格，一個問題儘量只有一個解決方案是最好的

【6】行長約定：

一行最長不超過80個字元，超過的請使用換行展示，儘量保持格式優雅

三、變數

1.宣告與使用

變數相當於記憶體中一個資料儲存空間的表示

package main
import "fmt"
func main ()  {
	var age int = 20
	fmt.Println("age = ", age)
}

2.多種使用方式

//第一種：變數的使用方式：指定變數的型別，並且賦值，
        var num int = 18
        fmt.Println(num)
//第二種：指定變數的型別，但是不賦值，使用預設值 
        var num2 int
        fmt.Println(num2)
//第三種：如果沒有寫變數的型別，那麼根據=後面的值進行判定變數的型別 （自動型別推斷）
        var num3 = "tom"
        fmt.Println(num3)
//第四種：省略var，注意 := 不能寫為 =   
        sex := "男"
        fmt.Println(sex)

3.支援多變數宣告

 var n1,n2,n3 int
        fmt.Println(n1)
        fmt.Println(n2)
        fmt.Println(n3)
        
var n4,name,n5 = 10,"jack",7.8
        fmt.Println(n4)
        fmt.Println(name)
        fmt.Println(n5)
        
n6,height := 6.9,100.6
        fmt.Println(n6)
        fmt.Println(height)

4.全域性變數（兩種）

//全域性變數：定義在函數外的變數
var n7 = 100
var n8 = 9.7
//設計者認為上面的全域性變數的寫法太麻煩了，可以一次性宣告：
var (
        n9 = 500
        n10 = "netty"
)
func main(){

四、進位制轉換

1.進位制的介紹：

十進位制整數，如：99, -500, 0

八進位制整數，要求以 0 開頭，如：015

十六進位制數，要求 0x 或 0X 開頭，如：0x15

二進位制：要求0b或者0B開頭，如：0b11

幾進位制：就是逢幾進1的問題：

平時實際生活中用的最多的是：十進位制
計算機用二進位制最多

4.八進位制轉換十進位制：

八進位制： 16

18^1 + 68^0
= 8 + 6
=14

5.十進位制轉換為八進位制：

十進位制14：

6.八進位制轉換為十六進位制：

把十進位制當做一箇中轉站：

八進位制---》十進位制---》十六進位制

實際上根本不用自己轉換這麼麻煩：我們可以直接用系統中提供給我們的計算器：

五、資料型別

如何選擇

Golang程式中整型變數在使用時,遵守保小不保大的原則

即:在保證程式正確執行下,儘量使用佔用空間小的資料型別

1.基本資料型別

1.整數型別

1.1有符號整數型別

一位元組佔8位元

1.2無符號整數型別：

3.字元型別

【1】Golang中沒有專門的字元型別，如果要儲存單個字元(字母)，一般使用byte來儲存。

【2】Golang中字元使用UTF-8編碼

【3】ASCII碼錶：

左面是不可見字元右面是可見字元

跳脫字元

4.布林型別

【1】布林型別也叫bool型別，bool型別資料只允許取值true和false

【2】布林型別佔1個位元組。

【3】布林型別適於邏輯運算，一般用於程式流程控制

【4】程式碼：

package main
import "fmt"
func main(){
        //測試布林型別的數值：
        var flag01 bool = true
        fmt.Println(flag01)
        var flag02 bool = false
        fmt.Println(flag02)
        var flag03 bool = 5 < 9
        fmt.Println(flag03)
}

5.字串型別（java中不屬於基本資料型別）

字串就是一串固定長度的字元連線起來的字元序列。

字串的使用：

如果字串中有特殊字元，字串的表示形式用反引號 ``

package main
import "fmt"
func main(){
        //1.定義一個字串：
        var s1 string = "你好全面擁抱Golang"
        fmt.Println(s1)
        //2.字串是不可變的：指的是字串一旦定義好，其中的字元的值不能改變
        var s2 string = "abc"
        //s2 = "def"
        //s2[0] = 't'
        fmt.Println(s2)
        //3.字串的表示形式：
        //（1）如果字串中沒有特殊字元，字串的表示形式用雙引號
        //var s3 string = "asdfasdfasdf"
        //（2）如果字串中有特殊字元，字串的表示形式用反引號 ``
        var s4 string = `
        package main
        import "fmt"
        
        func main(){
                //測試布林型別的數值：
                var flag01 bool = true
                fmt.Println(flag01)
        
                var flag02 bool = false
                fmt.Println(flag02)
        
                var flag03 bool = 5 < 9
                fmt.Println(flag03)
        }
        `
        fmt.Println(s4)
        //4.字串的拼接效果：
        var s5 string = "abc" + "def"
        s5 += "hijk"
        fmt.Println(s5)
        //當一個字串過長的時候：注意：+保留在上一行的最後
        var s6 string = "abc" + "def" + "abc" + "def" + "abc" + "def" + "abc" +
         "def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+
          "abc" + "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" +
           "def" + "abc" + "def"+ "abc" + "def" + "abc" + "def"+ "abc" + "def" + 
           "abc" + "def"+ "abc" + "def"
        fmt.Println(s6)
}

預設值

2.基本資料型別轉換

Go在不同型別的變數之間賦值時需要顯式轉換，並且只有顯式轉換(強制轉換)。

package main
import "fmt"
func main(){
        //進行型別轉換：
        var n1 int = 100
        //var n2 float32 = n1  在這裡自動轉換不好使，比如顯式轉換
        fmt.Println(n1)
        //fmt.Println(n2)
        var n2 float32 = float32(n1)
        fmt.Println(n2)
        //注意：n1的型別其實還是int型別，只是將n1的值100轉為了float32而已，n1還是int的型別
        fmt.Printf("%T",n1)  //int
        fmt.Println()
        //將int64轉為int8的時候，編譯不會出錯的，但是會資料的溢位
        var n3 int64 = 888888
        var n4 int8 = int8(n3)
        fmt.Println(n4)//56
        var n5 int32 = 12
        var n6 int64 = int64(n5) + 30  //一定要匹配=左右的資料型別
        fmt.Println(n5)
        fmt.Println(n6)
        var n7 int64 = 12
        var n8 int8 = int8(n7) + 127  //編譯通過，但是結果可能會溢位
        //var n9 int8 = int8(n7) + 128 //編譯不會通過
        fmt.Println(n8)
        //fmt.Println(n9)
}

3.基礎資料型別轉String型別

3.1 方法一

package main
import "fmt"
func main(){
        var n1 int = 19
        var n2 float32 = 4.78
        var n3 bool = false
        var n4 byte = 'a'
        var s1 string = fmt.Sprintf("%d",n1)
        fmt.Printf("s1對應的型別是：%T ，s1 = %q \n",s1, s1)
        var s2 string = fmt.Sprintf("%f",n2)
        fmt.Printf("s2對應的型別是：%T ，s2 = %q \n",s2, s2)
        var s3 string = fmt.Sprintf("%t",n3)
        fmt.Printf("s3對應的型別是：%T ，s3 = %q \n",s3, s3)
        var s4 string = fmt.Sprintf("%c",n4)
        fmt.Printf("s4對應的型別是：%T ，s4 = %q \n",s4, s4)
}

3.2 方法二

package main
import(
        "fmt"
        "strconv"
)
func main(){
        var n1 int = 18
        var s1 string = strconv.FormatInt(int64(n1),10)  //引數：第一個引數必須轉為int64型別 ，第二個引數指定字面值的進位制形式為十進位制
        fmt.Printf("s1對應的型別是：%T ，s1 = %q \n",s1, s1)
        var n2 float64 = 4.29
        var s2 string = strconv.FormatFloat(n2,'f',9,64)
        //第二個引數：'f'（-ddd.dddd）  第三個引數：9 保留小數點後面9位  第四個引數：表示這個小數是float64型別
        fmt.Printf("s2對應的型別是：%T ，s2 = %q \n",s2, s2)
        var n3 bool = true
        var s3 string = strconv.FormatBool(n3)
        fmt.Printf("s3對應的型別是：%T ，s3 = %q \n",s3, s3)
}

4.String型別轉為基礎資料型別

func main(){
        //string-->bool
        var s1 string = "true"
        var b bool
        //ParseBool這個函數的返回值有兩個：(value bool, err error)
        //value就是我們得到的布林型別的資料，err出現的錯誤
        //我們只關注得到的布林型別的資料，err可以用_直接忽略
        b , _ = strconv.ParseBool(s1)
        fmt.Printf("b的型別是：%T,b=%v \n",b,b)
        //string---》int64
        var s2 string = "19"
        var num1 int64
        num1,_ = strconv.ParseInt(s2,10,64)
        fmt.Printf("num1的型別是：%T,num1=%v \n",num1,num1)
        //string-->float32/float64
        var s3 string = "3.14"
        var f1 float64
        f1,_ = strconv.ParseFloat(s3,64)
        fmt.Printf("f1的型別是：%T,f1=%v \n",f1,f1)
        //注意：string向基本資料型別轉換的時候，一定要確保string型別能夠轉成有效的資料型別，否則最後得到的結果就是按照對應型別的預設值輸出
        var s4 string = "golang"
        var b1 bool
        b1 , _ = strconv.ParseBool(s4)
        fmt.Printf("b1的型別是：%T,b1=%v \n",b1,b1)
        var s5 string = "golang"
        var num2 int64
        num2,_ = strconv.ParseInt(s5,10,64)
        fmt.Printf("num2的型別是：%T,num2=%v \n",num2,num2)
}

Go學習筆記1