視瞥澩：b站UP主v若水若水的尚硅谷go視頻
不動筆墨不讀書 ，雖然我有全套視頻和筆記 還是自己動點筆墨
因為在19年下半年大致學過go語言 所以這么計劃：一個星期拿下基礎 一個星期拿下框架 兩個星期拿出專案 一個月搞定go
Go環境安裝
版本選擇
>go version
go version go1.13.5 windows/amd64
SDK：軟體開發工具包，是提供給開發人員使用的，其中包含了對應開發語言的工具包
Go SDK下載地址：https://www.golangtc.com/download
src：go的源代碼
bin: go的指令
Go開發需要配置的環境變數
- GOROOT：指定SDK的安裝 路徑E:\GO
- PATH：添加SDK的/bin目錄 E:\GO\go\bin
- GOPATH：作業目錄，撿來go專案的作業路徑 E:\gostudent
IDE: 選擇goland https://www.cnblogs.com/zisefeizhu/p/11178668.htm
Go官方編程指南
Go 設計思想：一個問題盡量只有一個解決方法
Golang 官方網站 國內要使用特殊手段 https://golang.org
進入后第一個頁面，點擊 tour-> 選擇 簡體中文就可以進入中文版的 Go 編程指南
Golang 官方標準庫 API 檔案，https://golang.org/pkg可以查看 Golang所有包下的函式和使用
api ： application program interface:應用程式編程介面， 就是我們 Go 的各個包的各個函式，
API是Golang提供的基本編程介面
Go語言提供了大量的標準庫，因此Google公司也為這些標準庫提供了相應的API檔案，用于告訴開發者如何使用這些標準庫，以及標準庫包含的方法
Go中文網 在線標準庫檔案：https://studygolang.com/pkgdoc
Go的包和源檔案和函式的關系簡圖
識別符號的命名規范
Go對各種變數、方法、函式等命名時使用的字符序列稱為識別符號
凡是自己可以起名字的地方都叫識別符號
由26個英文字母大小寫，0-9，_組成
數字不可以開頭，var num int // √ var 3num int//×
Go中嚴格區分大小寫
var num int
var Num int
說明：在Go中，num和Num是兩個不同的變數
識別符號不能包含空格
下劃線”_”本身在Go中是一個特殊的識別符號，稱為空識別符號，可以代表任何其它的識別符號，但是它對應的值會被忽略(比如：忽略某個回傳值)，所以僅能被作為占位符使用，不能作為識別符號使用
不能以系統保留關鍵字作為識別符號(一共有25個)，比如break，if 等等...
包名：保持package的名字和目錄保持一致，盡量采取有意義的包名，簡短，有意義，不要和標準庫沖突
變數名、函式名、常量名：采用駝峰法
如果變數名、函式名、常量名首字母大寫，則可以被其他的包訪問：如果首字母小寫，則只能在本包中使用(注：可以簡單的理解成，首字母大寫是公開的，首字母小寫是私有的)，在Go語言中沒有public，private等關鍵字，
| 對 | 錯 |
|---|---|
| hello hello12 h_4 _ab int【建議不要使用】 float32【建議不要使用】 Abc | 1hello h-b ‘x h’ _ |
系統保留關鍵字
在Go中，為了簡化代碼編譯程序中對代碼的決議，其定義的保留關鍵字只有25個
系統的預定義識別符號
除了保留關鍵字外，Go還提供了36個預定義的識別符號，其包括基本資料型別和系統內嵌函式
Go語言快速開發入門
hello.go
//開發一個hello.go程式，可以輸出 "hello， 紫色飛豬"
package main
import (
"fmt"
_"log"
)
func main() {
fmt.Println("hello, zisefeizhu")
}
1) go檔案的后綴是.go
2) package main
表示該hello.go檔案所在的包是main，再go中，每個檔案都必須歸屬于一個包
3) import "fmt"
表示：引入一個包，包名fmt,引入該包后，就可以使用fmt包的函式，比如：fmt.Println
fmt包中提供格式化、輸出、輸入的函式
4）_"log"
go語言定義的變數或者import的包如果沒有使用到，就用_注釋掉，
4） func main() { //func是關鍵字，表示一個函式
//main是函式名，是一個主函式，程式的入口
fmt.Println("hello,zisefeizhu") //表示呼叫fmt包的函式 Println輸出“hello, zisefeizhu”
}
5） go語言嚴格區分大小寫，
6） go編譯器是按行進行編譯的，一行寫一條陳述句，每條陳述句不需要分號(go討語言會在每行后自動加分號)，不能把多行陳述句寫在同一行
7） go語言大括號成對出現，
Go執行流程分析 go run / go build
E:\gostudent>dir //專案目錄
E:\gostudent 的目錄
2020/04/01 15:16 <DIR> .
2020/04/01 15:16 <DIR> ..
2020/04/01 15:33 <DIR> .idea
2020/04/01 15:33 <DIR> 2020-04-01 //今日目錄
E:\gostudent>cd 2020-04-01
E:\gostudent\2020-04-01>dir
E:\gostudent\2020-04-01 的目錄
2020/04/01 15:33 <DIR> .
2020/04/01 15:33 <DIR> ..
2020/04/01 15:33 151 hello.go //hello.go檔案
E:\gostudent\2020-04-01>go run hello.go
hello, zisefeizhu //編譯運行一步完成
E:\gostudent\2020-04-01>dir
E:\gostudent\2020-04-01 的目錄
2020/04/01 15:33 <DIR> .
2020/04/01 15:33 <DIR> ..
2020/04/01 15:33 151 hello.go
1 個檔案 151 位元組
2 個目錄 121,884,221,440 可用位元組
//沒有生成二進制檔案
E:\gostudent\2020-04-01>go build hello.go
E:\gostudent\2020-04-01>dir
驅動器 E 中的卷是 娛樂
卷的序列號是 78AB-12F2
E:\gostudent\2020-04-01 的目錄
2020/04/01 15:49 <DIR> .
2020/04/01 15:49 <DIR> ..
2020/04/01 15:49 2,106,368 hello.exe //二進制檔案
2020/04/01 15:33 151 hello.go
E:\gostudent\2020-04-01>hello.exe //直接執行
hello, zisefeizhu
1）如果先編譯生成了可執行檔案，那么可以將該可執行檔案拷貝到沒有go開發環境的機器上，仍然可以運行
2）如果是直接go run 源代碼，那么如果要在另外一個機器上這么運行，也需要go開發環境，否則無法執行
3）在編譯時，編譯器會將程式運行依賴的庫檔案包含在可執行檔案中，所以，可執行檔案變大了很多
go build 可以指定生成的可執行檔案名
E:\gostudent\2020-04-01>go build -o zisefeizhu.exe hello.go
E:\gostudent\2020-04-01>dir
2020/04/01 15:55 <DIR> .
2020/04/01 15:55 <DIR> ..
2020/04/01 15:49 2,106,368 hello.exe
2020/04/01 15:33 151 hello.go
2020/04/01 15:55 2,106,368 zisefeizhu.exe
3 個檔案 4,212,887 位元組
2 個目錄 121,880,002,560 可用位元組
E:\gostudent\2020-04-01>zisefeizhu.exe
hello, zisefeizhu
windows 二進制檔案必須是.exe linux 沒有后綴之分
轉義字符
//轉義字符
package main
import "fmt"
func main() {
fmt.Println("hello\tzisefeizhu\nage\t21\ndir\tE:\\gostudent\\2020-04-01\nhellozisefeizhuhellozisefeizhu\rzisefeizhu\ni live you\"jing xiang\"")go
}
輸出：
hello zisefeizhu
age 21
dir E:\gostudent\2020-04-01
zisefeizhu
i live you"jing xiang"
1)\t : 表示一個制表符，通常使用它可以排版
2)\n : 換行符
3)\\ : 一個\
4)\" : 一個 "
5)\r : 一個回車 不是換行 是整行替換了
在現實中，我們認為回車和換行是一碼事，但是在計算機的世界里面其實我們之前的判斷是有誤的，回車是意味著當前行的回傳到行首，而換行是結束本行到下一行，
注釋
//注釋
package main
import "fmt"
func main() {
//單行注釋
/*
多行注釋
多行注釋
*/
fmt.Println("注釋")
}
1) 對于行注釋和塊注釋，被注釋的文字，不會被Go編譯器執行
2) 塊注釋里面不能有塊注釋，也就是說塊注釋不能有嵌套
3) 推薦使用單行注釋
代碼風格
package main
import "fmt"
func main() {
fmt.Println("gofmt格式化")
var num int = 2 + 4 * 5
fmt.Println("hellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisef" +
"eizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhu" +
"hellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozi" +
"sefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhuhellozisefeizhu\nnum = ",num)
}
1) 使用一次tab操作，實作縮進，默認整體向右邊移動，使用shift+tab整體向左移
2) 使用gofmt來進行格式化
3) 運算子兩邊習慣性各加一個空格
4） 大括號必須和函式名同行
5) 一行最長不超過80個字符，超過的請使用換行展示，盡量保持格式優雅
Dos常用指令
dos的基本操作原理
案例：
切換到E盤，新建一個目錄zisefeizhu，切換到該目錄，新建 a b c 三個目錄，切換到a 目錄， 新建檔案news.txt，復制檔案到b目錄下，移動到c目錄下,最后都洗掉
e:\gostudent\2020-04-01>cd e:\ //切換到e盤
e:\>md zisefeihu //新建目錄zisefeizhu
e:\>cd zisefeihu //切換到該目錄
e:\zisefeihu>md a b c //新建目錄 a b c
e:\zisefeihu>dir //查看目錄下的內容
2020/04/01 16:55 <DIR> a
2020/04/01 16:55 <DIR> b
2020/04/01 16:55 <DIR> c
e:\zisefeihu>cd a //切換到a 目錄 相對目錄
e:\zisefeihu\a>echo . > news.txt //創建一個空檔案
e:\zisefeihu\a>copy news.txt e:\zisefeihu\b //復制到b目錄 絕對路徑
已復制 1 個檔案，
e:\zisefeihu\a>move news.txt e:\zisefeihu\c //移動到c盤
移動了 1 個檔案，
e:\zisefeihu\a>dir
e:\zisefeihu\a>cd ..
e:\zisefeihu>cd ..
e:\>rd /q/s zisefeihu //洗掉zisefeizhu目錄及子目錄和檔案 不帶詢問
e:\>dir
e:\>cls //清屏 cang lao shi :蒼老師 首字母
Go變數
一個程式就是一個世界，變數是程式的基本組成單位，
變數相當于記憶體中一個資料存盤空間的表示，可以把變數看作是一個房間的門牌號，通過門牌號可以找到房間，同樣的道理，通過變數名可以訪問到變數(值)
變數的使用步驟
import "fmt"
func main() {
var i int //宣告變數(定義變數)
i = 10 //非變數賦值
fmt.Println("i = ", i) //使用變數
}
//i = 10
1) 變數表示記憶體中的一個存盤區域
這里可以把記憶體比喻成一個大廈每個房間都是存盤區域
2）該區域有自己的名稱(變數名)和型別(資料型別）
房間號 房間存放的內容
變數使用三種方式：
func main() {
var i int //指定變數型別，宣告后如不賦值，使用默認值
var num = 10.11 //根據值自行判定變數型別(型別推導)
name := "zisefeizhu" //(3)省略var,注意:=左側的變數不應該是已經宣告過的，否則會導致編譯錯誤
n1, n2, name2 := 100, 200, "jingxing" //一次性宣告多個變數
}
一次性宣告多個全域變數【在go中函式外部定義變數就是全域變數】
var (
n3 = 300
n4 = 900
name2 = "yike"
)
func main() {
}
變數在同一個作用域(在一個函式或者在代碼塊)內不能重名
變數 = 變數名 + 資料型別 + 值 【變數的三要素】
Go的變數如果沒有賦初值，編譯器會使用默認值，比如int 默認值0 string默認值是空串，小數默認值為0
變數的宣告、初始化和賦值
宣告變數
基本語法：var 變數名 資料型別
var a int 這就是宣告了一個變數，變數名是a
var num1 float32 這也是宣告了一個變數，表示一個單精度型別的小數，變數名是num1
初始化變數
在宣告變數的時候，就給值
var a int = 45 這就是初始化變數a
使用細節：如果宣告時就直接賦值，可省略資料型別
var b = 400
變數賦值
var num int //默認0
num = 780 這就是給變數賦值
程式中 + 號的使用
- 當左右兩邊都是資料型時，則做加法運算
2) 當左右兩邊都是字串，則做字串拼接
資料型別的基本介紹
在 Go 編程語言中，資料型別用于宣告函式和變數，資料型別的出現是為了把資料分成所需記憶體大小不同的資料，編程的時候需要用大資料的時候才需要申請大記憶體，就可以充分利用記憶體，編譯器在進行編譯的時候，就要知道每個值的型別，這樣編譯器就知道要為這個值分配多少記憶體，并且知道這段分配的記憶體表示什么，
基本資料型別、陣列和結構體都是值型別
整數型別
int的有符號型別
| 型別 | 有無符號【正負】 | 占用存盤空間 | 表數范圍 | 備注 |
|---|---|---|---|---|
| int8 | 有 | 1位元組 | -128 ~ 127 | -128 到 127 |
| int16 | 有 | 2位元組 | -2^15 ~ 2^15 - 1 | -32768 到 32767 |
| int32 | 有 | 4位元組 | -2^31 ~ 2^31 -1 | -2147483648 到2147483647 |
| int64 | 有 | 8位元組 | -2^63 ~ 2^63 -1 | -9223372036854775808 到 9223372036854775807 |
int的無符號型別
| 型別 | 有無符號 | 占用存盤空間 | 表數范圍 | 備注 |
|---|---|---|---|---|
| uint8 | 無 | 1位元組 | 0 ~ 255 | 0 到 255 |
| uint16 | 無 | 2位元組 | 0 ~ 2^16 - 1 | 0 到 65535 |
| uint32 | 無 | 4位元組 | 0 ~ 2^32 - 1 | 0 到 4294967295 |
| uint64 | 無 | 8位元組 | 0 ~ 2^64 4- 1 | 0 到 18446744073709551615 |
有無符號型別的區別
? 首位為符號位
int的其它型別
| 型別 | 有無符號 | 占用存盤空間 | 表數范圍 | 備注 |
|---|---|---|---|---|
| int | 有 | 32位系統4個位元組/64位系統8個位元組 | -2^31 ~ 2^31 - 1/-2^63 ~ 2^63 - 1 | |
| uint | 無 | 32位系統4個位元組/64位系統8個位元組 | 0 ~ 2^32 - 1/0 ~ 2^64 - 1 | |
| rune | 有 | 與int32一樣 | -2^31 ~ 2^31 - 1 | Unicode碼 |
| uintptr | 無符號整形，用于存放一個指標，是一種無符號的整數型別，沒有指定具體的bit大小但是足以容納指標，uintptr型別只有在底層編程是才需要，特別是Go語言和C語言函式庫或作業系統介面相互動的地方， | |||
| byte | 無 | 與uint8等價 | 0 ~ 255 | 一般用來存盤單個字符 |
整型的使用細節
package main
import (
"fmt"
"unsafe"
)
func main() {
var n1 = 65535 //Golang的整型默認宣告為int型
fmt.Printf("n1的型別是%T n1 占用的位元組數是%d ", n1, unsafe.Sizeof(n1)) //在程式查看某個變數的位元組大小和資料型別
}
//n1的型別是int n1 占用的位元組數是8
Go程式中整型變數在使用時，遵守保小不保大的原則，即：在保證程式正確運行下，盡量使用占用空間小的資料型別
bit：計算機中的最小存盤單位，byte：計算機中基本存盤單位，1byte = 8bit
有符號型別可以存盤任何整數，無符號型別只能存盤自然數
定義一個int8型別的整數(var num int8 = 0),如果一直自加1，這個變數的值會是(0...127 -128 -127... 0 ...127)回圈往復下去，而不會超過型別最大值的范圍
浮點數/小數型別
小數型別就是用于存放小數的，比如 6.6 0.23 -1.91
小數型別分類
| 型別 | 占用存盤空間 | 表數范圍 |
|---|---|---|
| 單精度float32 | 4位元組 | -3.403E38 ~ 3.403E38 |
| 雙精度float64 | 8位元組 | -1.798E308 ~ 1.798E308 |
| complex64 | 32位實數和虛數 | |
| complex128 | 64位實數和虛數 |
func main() {
var n1 = 21.23 //默認宣告為float64 推薦使用float64
var (
n2 float32 = -123.0000901 //float64的精度比float32高
n3 float64 = -123.0000901
)
fmt.Printf("n1的型別%T n1 占用的位元組數是%d\n", n1, unsafe.Sizeof(n1))
fmt.Println("n2 = ",n2, "n3 = ",n3)
}
//n1的型別float64 n1 占用的位元組數是8
//n2 = -123.00009 n3 = -123.0000901
尾數部分可能丟失，造成精度損失
浮點型別有固定的范圍和欄位長度，不受os影響
浮點數 = 符號位+指數位+尾數位
浮點數都是有符號的
浮點型常量有兩種表示形式
十進制數形式：如:5.12 .512（必須有小數點）
科學計數法形式：如：5.1234e2 = 5.1234^10的2次方 5.12E-2 = 5.12/10的2次方
字符型別
Golang中沒有專門的字符型別，如果要存盤單個字符(字母)，一般使用byte來保存，
字串就是一串固定長度的字符連接起來的字符序列，Go的字串是由單個位元組連接起來的，也就是說對于傳統的字串是由字符組成的，而Go的字串不同，它是由位元組組成的，
func main() {
var (
c1 byte = 'a' //字符常量用單引號括起來
c2 byte = '0' //字符o byte等價uint8
//c3 byte = '北' //.\變數.go:12:13: constant 21271 overflows byte
//c3 int = "北" //.\變數.go:13:12: cannot use "北" (type string) as type int in assignment
c3 int = '北'
c4 int = 22269
n1 = 10 + c1 //字符型別是可以進行運算的
)
fmt.Printf("c2 的型別是%T c2占用的位元組數%d c2對應的字符%c\n ", c2, unsafe.Sizeof(c2), c2)
fmt.Println("c1 = ", c1) //直接輸出byte值，就是輸出對應字符的碼值， 字符的本質是一個整數，直接輸出時，是該字符對應的UTF-8編碼的碼值
fmt.Printf("c3 = %c c3對應碼值=%d\n", c3, c3 ) //格式化輸出對應的字符
fmt.Printf("c4 = %c\n", c4)
fmt.Println("n1 = ", n1)
}
//c2 的型別是uint8 c2占用的位元組數1 c2對應的字符0
// c1 = 97
//c3 = 北 c3對應碼值=21271
//c4 = 國
//n1 = 107
Go語言的字符使用UTF-8編碼，如果想查詢字符對應的utf8碼值：http://www.mytju.com/classcode/tools/encode_utf8.asp
英文字符 - 1個位元組 漢字 - 3個位元組
字符型存盤到計算機中，需要將字符對應的碼值(整數)找出來
存盤：字符 -->對應碼值 -->二進制 -->存盤
讀取：二進制 -->碼值 -->字符 -->讀取
字符和碼值的對應關系是通過字符編碼表決定的(是規定好的)
Go語言的編碼都統一成了utf-8，非常的方便，很統一，再也沒有編碼亂碼的困擾了
布爾型別
布爾型別也叫bool型別，bool型別資料只允許取值true和false
bool型別占1個位元組
bool型別適于邏輯運算，一般用于程式流程控制
if條件控制陳述句
for回圈控制陳述句
func main() {
var b = false
fmt.Printf("b = %v, b的占用空間=%d", b, unsafe.Sizeof(b))
}
//b = false, b的占用空間=1
string型別
字串就是一串固定長度的字符連接起來的字符序列，Go的字串是由單個位元組連接起來的，Go語言的字串的位元組使用UTF-8編碼標識Unicode文本
func main() {
var (
addrress string = "北京 110 world!"
str = "hello" // // 字串一旦賦值了，字串就不能修改了：在Go中字串是不可變的
)
str2 := `str[0] = 'a'` //反引號，會識別轉義字符，以字串的原生形式輸出，包括換行和特殊字符，可以實作防止攻擊，輸出源代碼等效果
fmt.Println("str2 = ", str2, "\n","address = ", addrress)
}
//str2 = str[0] = 'a'
// address = 北京 110 world!
基本資料型別的默認值
在go中，資料型別都有一個默認值，當程式員沒有賦值時，就會保留默認值，在Go中，默認值又叫o值
| 資料型別 | 默認值 |
|---|---|
| 整型 | 0 |
| 浮點型 | 0 |
| 字串 | “” |
| 布爾型別 | false |
基本資料型別的相互轉換
Go在不同型別的變數之間賦值時需要顯式轉換，也就是說Go中資料型別不能自動轉換
func main() {
var (
i int32 = 1000 //被轉換的是變數存盤的資料(即值)，變數本身的資料型別并沒有變化
n1 float32 = float32(i)
n2 int8 = int8(i) //將int32轉成int8【-128 - 127】,編譯時不會報錯，只是轉換的結果是按溢位處理，和我們希望的結果不一樣，因此在轉換時，需要考慮范圍
n3 int64 = int64(i)
)
n4 = i + n2 //型別不同，不能相加
fmt.Printf("i = %v, n1 = %v, n2 = %v, n3 = %v", i, n1, n2, n3)
}
//i = 1000, n1 = 1000, n2 = -24, n3 = 1000
運算式T(v)將值v轉換為型別T
T：就是資料型別，比如int32, int64, float32 等等
v：就是需要轉換的變數
Go中，資料型別的轉換可以是從：表示范圍小 --> 表示范圍大，也可以：范圍大 --> 范圍小 存在溢位現象
基本資料型別和string的轉換
在程式開發中，經常將基本資料型別轉成string，或者將string轉成基本資料型別
基本型別轉string型別
func main() {
var (
num1 int = 99
num2 float32 = 23.456
b bool = true
myChar byte = 'h'
str string //空的str
)
//使用第一種方式來轉換fmt.Sprintf方法 fmt.Sprintf("%引數",運算式)
//引數需要和運算式的資料型別相匹配
//fmt.Sprintf() 會回傳轉換后的字串
str = fmt.Sprintf("%d",num1) //%d 表示為十進制
fmt.Printf("str type %T str = %q\n",str,str) //%T 值的型別的Go語法表示
// %q 該值對應的雙引號括起來的go語法字串字面值，必要時會采用安全的轉義表示
str = fmt.Sprintf("%f",num2) //%f 有小數部分但無指數部分，如123.456
fmt.Printf("str type %T str = %q\n",str,str)
str = fmt.Sprintf("%t",b)
fmt.Printf("str type %T str = %q\n",str,str)
str = fmt.Sprintf("%c",myChar) //%c 該值對應的unicode碼值
fmt.Printf("str type %T str = %q\n",str,str)
}
//str type string str = "99"
//str type string str = "23.455999"
//str type string str = "true"
//str type string str = "h"
這也是我喜歡用的一種 簡單好使
func main() {
//第二種方式strconv函式
var (
num3 int = 99
num4 float64 = 23.456
b2 bool = true
str string
)
str = strconv.FormatInt(int64(num3),10) //這里的10是進制
fmt.Printf("str type %T str = %q\n",str,str)
//strconv.FormatFloat(num4,'f',10,64)
//說明：'f'格式 10：表示小數位保留10位，64：表示這個小數是float64
str = strconv.FormatFloat(num4,'f',10,64)
fmt.Printf("str type %T str = %q\n",str,str)
str = strconv.FormatBool(b2)
fmt.Printf("str type %T str = %q\n",str,str)
//strconv包中有一個函式Itoa
var num5 int64 = 4567
str = strconv.Itoa(int(num5)) //strconv.Itoa是strconv.FormatInt的簡寫
fmt.Printf("str type %T str = %q\n",str,str)
}
//str type string str = "99"
//str type string str = "23.4560000000"
//str type string str = "true"
//str type string str = "4567"
函式將浮點數表示為字串并回傳，
bitSize表示f的來源型別（32：float32、64：float64），會據此進行舍入，
fmt表示格式：'f'（-ddd.dddd）、'b'（-ddddp±ddd，指數為二進制）、'e'（-d.dddde±dd，十進制指數）、'E'（-d.ddddE±dd，十進制指數）、'g'（指數很大時用'e'格式，否則'f'格式）、'G'（指數很大時用'E'格式，否則'f'格式），
prec控制精度（排除指數部分）：對'f'、'e'、'E'，它表示小數點后的數字個數；對'g'、'G'，它控制總的數字個數，如果prec 為-1，則代表使用最少數量的、但又必需的數字來表示f，
string型別轉基本資料型別
func main() {
var (
str string = "true"
b bool
str2 string = "1234590"
n1 int64
n2 int
str3 string = "123.456"
f1 float64
str4 string = "hello"
n int64 = 11
)
//b,_ = strconv.ParseBool(str)
//說明
//1. strconv.ParseBool(str)函式會回傳兩個值(value bool,err error)
//2. 因為只想獲取到value bool，不想獲取err所以使用_忽略
b,_ = strconv.ParseBool(str)
fmt.Printf("b type %T b = %v \n",b,b)
n1,_ = strconv.ParseInt(str2,10,64)
n2 = int(n1)
fmt.Printf("n1 type %T n1 = %v\n",n1,n1)
n3 := int32(n1)
fmt.Printf("n3 type %T n3 = %v\n", n3,n3) //再將64位轉32位
fmt.Printf("n2 type %T n2 = %v\n",n2,n2)
f1,_ = strconv.ParseFloat(str3,64)
fmt.Printf("f1 type %T f1 = %v\n",f1,f1)
n, _ = strconv.ParseInt(str4, 10, 64)
//在將String型別轉成基本資料型別時，要確保String型別能夠轉成有效的資料，比如我們可以把’123’轉成一個整數，
//但是不能把“hello”轉成一個整數，如果這樣做，Go直接將其轉成0，其它型別也是一樣的道理，
// float --> 0 bool --> false
fmt.Printf("n type %T n == %v\n", n,n)
}
//b type bool b = true
//n1 type int64 n1 = 1234590
//n2 type int n2 = 1234590
//f1 type float64 f1 = 123.456
//n type int64 n == 0
值型別和參考型別
值型別：基本資料型別int系列、float系列、bool、string、陣列和結構體struct
參考型別：指標、slice切片、map、管道chan、interface等都是參考型別
值型別和參考型別的使用特點
值型別：變數直接存盤值，記憶體通常在堆疊中分配
參考型別：變數存盤的是一個地址，這個地址對應的空間才真正存盤資料(值)，記憶體通常在堆上分配，當沒有任何變數參考這個地址時，該地址對應的資料空間就成為一個垃圾，由GC來回收
記憶體的堆疊區和堆區示意圖
指標
基本資料型別，變數存的就是值，也叫值型別
獲取變數的地址，用&，比如：var num int，獲取num的地址：&num
分析一下基本資料型別在記憶體的布局
func main() {
//基本資料型別，變數存的就是值，也叫值型別
var i int = 10
fmt.Println("i 的地址 = ", &i) //獲取變數的地址，用&，比如：var num int，獲取num的地址：&num
var ptr *int = &i //指標型別，指標變數存的是一個地址，這個地址指向的空間存的才是值
//1. ptr 是一個指標變數
//2. ptr 的型別 *int
//3. ptr 本身的值&i
*ptr = 101
fmt.Printf("ptr = %v\n", ptr)
fmt.Printf("ptr的地址 = %v\n", &ptr)
fmt.Printf("ptr 指定的值 = %v\n", *ptr) //獲取指標型別所指向的值，使用：*,比如：var ptr *int，使用*ptr獲取ptr指向的值
fmt.Printf("i 的值 =%v", i) //將i的地址賦給指標ptr，并通過ptr去修改i的值
}
//i 的地址 = 0xc00000a0b8
//ptr = 0xc00000a0b8
//ptr的地址 = 0xc000006030
//ptr 指定的值 = 101
//i 的值 =101
值型別，都有對應的指標型別，形式為 *資料型別，比如int的對應的指標就是 *int，float32對應的指標型別就是*float32，依次類推
值型別包括：基本資料型別int系列、float系列、bool、string、陣列和結構體struct
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/30734.html
標籤：Go
上一篇：淺嘗Go語言GC