之前我學過C、Java、Python語言時總結的經驗：

1. 先建立整體框架，然后再去摳細節(jié)。
2. 先Know how，然后know why。
3. 先做出來，然后再去一點點研究，才會事半功倍。
4. 適當?shù)泥駠魍虠?。因為死摳某個知識點很浪費時間的。
5. 對于GO語言，切記遵守語法格式規(guī)則。（例如python語言、例如SpringBoot框架等）
   解釋：某些知識點，就是很難了解，那么先做出來，然后繼續(xù)向前學習，可能在某個時間點我們就會恍然大悟。

一、變量

1.1 變量的定義：

• 任何高級程序語言寫程序，變量都是程序的基本組成單位。
• 變量相當于內存中一個數(shù)據(jù)存儲空間的表示，你可以把變量看做是一個房間的門牌號，通過門牌號我們可以找到房間，同樣的道理，通過變量名可以訪問到變量()

1.2 變量的聲明、初始化、賦值

1. 聲明變量（定義變量）

基本語法： var 變量名 數(shù)據(jù)類型
var a int

2. 變量賦值

在聲明變量的時候，就給值
var a int = 1
var b = 300

3. 使用變量

var a int
a = 100

例如下面的a/b/c都是變量

package mainimport "fmt"func main() {var a int  //聲明變量a = 10     //變量賦值b := 20    //變量賦值c := a + b //使用變量fmt.Println(a) // 10fmt.Println(b) // 20fmt.Println(c) // 30
}

1.3 變量使用的注意事項

1. 變量表示內存中的一個存儲區(qū)域
2. 該區(qū)域有自己的名稱(變量名)和類型(數(shù)據(jù)類型)

所有代碼會用磁盤中讀取到內存中，進行運行。
那么變量，例如a = 10 。那么就會存儲到內存中。

3. Golang變量使用的三種方式

   1. 第一種:指定變量類型，聲明后若不賦值，使用默認值。

   int類型默認為0
   String類型默認為空

   2. 第二種:根據(jù)值自行判定變量類型(類型推導)

   如果不指定類型，那么就會go語言類型推導。
   var a = “abc” 在打印的時候就會輸出string類型

   3. 第三種省略var,注意:=左側的變量不應該是已經聲明過的，否則會導致編譯錯誤

   兩種方式：（方式一的兩句話，等價于方式二）
   ＞ var name1 string
   name1 = “zhangsan1”　//方式一
   name2 := “zhangsan2” //方式二

4. 多變量聲明
   在編程中，有時我們需要一次性聲明多個變量，Golang也提供這樣的語法

形式一：
var a, a1, a2, a3 int
a = 10
a1 = 20
a2 = 30
a3 = 40形式二：
var a1, a2, a3, name = 1, 2, 3, "zhangsan"fmt.Println(a1,a12,a23,a4)形式三：
a, b, c, d, name := 1, 2, 3, 4, "zhangsan"
fmt.Println(a,b,c,d,name)

關于全局變量：

var (a    = 1b    = 2c    = 3d    = 4name = "zhangsan"
)
func main() {fmt.Println(a, b, c, d, name)
}

5. 該區(qū)域的數(shù)據(jù)值可以在同一類型范圍內不斷變化
6. 變量在同一個作用域內不能重名
7. 變量=變量名+值+數(shù)據(jù)類型，這一點請大家注意。
8. Golang的變量如果沒有賦初值，編譯器會使用默認值,比如int默認值0 string默認值為空用

插播-關于fmt.Printf格式打印%的作用

參考的官網地址是：https://studygolang.com/pkgdoc

通用：
%v	值的默認格式表示
%+v	類似%v，但輸出結構體時會添加字段名
%#v	值的Go語法表示
%T	值的類型的Go語法表示
%%	百分號布爾值：
%t	單詞true或false整數(shù)：%b	表示為二進制
%c	該值對應的unicode碼值
%d	表示為十進制
%o	表示為八進制
%q	該值對應的單引號括起來的go語法字符字面值，必要時會采用安全的轉義表示
%x	表示為十六進制，使用a-f
%X	表示為十六進制，使用A-F
%U	表示為Unicode格式：U+1234，等價于"U+%04X"浮點數(shù)與復數(shù)的兩個組分：%b	無小數(shù)部分、二進制指數(shù)的科學計數(shù)法，如-123456p-78；參見strconv.FormatFloat
%e	科學計數(shù)法，如-1234.456e+78
%E	科學計數(shù)法，如-1234.456E+78
%f	有小數(shù)部分但無指數(shù)部分，如123.456
%F	等價于%f
%g	根據(jù)實際情況采用%e或%f格式（以獲得更簡潔、準確的輸出）
%G	根據(jù)實際情況采用%E或%F格式（以獲得更簡潔、準確的輸出）字符串和[]byte：%s	直接輸出字符串或者[]byte
%q	該值對應的雙引號括起來的go語法字符串字面值，必要時會采用安全的轉義表示
%x	每個字節(jié)用兩字符十六進制數(shù)表示（使用a-f）
%X	每個字節(jié)用兩字符十六進制數(shù)表示（使用A-F）    指針：%p	表示為十六進制，并加上前導的0x    

二、 變量的數(shù)據(jù)類型

2.1整數(shù)的基本類型

簡單的說，就是用于存放整數(shù)值的，比如 0,-1,2345 等等。

2.1.1 有符號類型 int8/16/32/64

** int8 范圍是：-128 ~ 127**

2.1.2 無符號類型 int8/16/32/64

int 無符號類型：

2.1.3 整型類型 int、uint、rune、byte

2.1.4 整型的使用細節(jié)

1. Golang 各整數(shù)類型分: 有符號和無符號，int uint 的大小和系統(tǒng)有關
2. Golang 的整型默認聲明為 int 型
3. 如何在程序查看某個變量的字節(jié)大小和數(shù)據(jù)類型

import ("fmt"unsafe "unsafe"
)var n1 = 100fmt.Printf("n1 的類型是 %T ", n1) //n1 的類型是 intvar n2 int64 = 1fmt.Printf("n1 的數(shù)據(jù)類型是 %T, n2 占用的字節(jié)數(shù)是%d", n2, unsafe.Sizeof(n2))//   n1 的數(shù)據(jù)類型是 int64, n2 占用的字節(jié)數(shù)是8

4. olang 程序中整型變量在使用時，遵守保小不保大的原則，即:在保證程序正確運行下，盡量使用占用空間小的數(shù)據(jù)類型。[如: 年齡]
5. bit: 計算機中的最小存儲單位。byte:計算機中基本存儲單元。[二進制再詳細說] 1byte = 8 bit

2.2 浮點類型

Golang的浮點類型可以表示一個小數(shù)，比如1.2 / 3333.11 / 3232.324等等

2.2.1 小數(shù)類型分類

1. 關于浮點數(shù)在機器中存放形式的簡單說明.浮點數(shù)=符號位+指數(shù)位+尾數(shù)位說明: 浮點數(shù)都是有符號的.
2. 如果使用float32 可能造成精度損失。

開發(fā)過程中，推薦使用float64。 并且默認也是float64 .
Golang浮點類型有固定的范圍和字段類型，不受具體操作系統(tǒng)的影響。

3. 浮點型的存儲分為三個部分：符號位+指數(shù)位+尾數(shù)位。 在存儲過程中，精度會有丟失

2.3 字符類型

2.3.1 基本介紹

Golang 中沒有專門的字符類型，如果要存儲單個字符(字母)，一般使用 byte 來保存。
字符串就是一串固定長度的字符連接起來的字符序列。Go 的字符串是由單個字節(jié)連接起來的。也就是說對于傳統(tǒng)的字符串是由字符組成的，而 Go 的字符串不同，它是由字節(jié)組成的。

1. 如果我們保存的字符在 ASCII 表的,比如[0-1,a-z,A-Z.]直接可以保存到 byte2)
2. 如果我們保存的字符對應碼值大于 255,這時我們可以考慮使用 int 類型保存3)
3. 如果我們需要安裝字符的方式輸出，這時我們需要格式化輸出，即 fmt.Printfr“%c”,cl)…

var n2 int = '你'fmt.Printf("n2 的數(shù)據(jù)類型是 %T, n2 占用的字節(jié)數(shù)是%d.  \n", n2, unsafe.Sizeof(n2))// n2 的數(shù)據(jù)類型是 int, n2 占用的字節(jié)數(shù)是8. var c3 int = '你'fmt.Printf("c3 = %c \n", c3)	//c3 = 你	fmt.Printf("%c", c3) 			//你

2.3.2 字符使用細節(jié)

1. 字符型 存儲到 計算機中，需要將字符對應的碼值 (整數(shù)) 找出來存儲:字符—>對應碼值---->二進制–>存儲
   讀取:二進制----> 碼值 ----> 字符 -> 讀取
2. 字符和碼值的對應關系是通過字符編碼表決定的(是規(guī)定好)
3. Go 語言的編碼都統(tǒng)一成了 utf-8。非常的方便，很統(tǒng)一，再也沒有編碼亂碼的困擾了

2.4 布爾類型

2.4.1 基本概述

1. 布爾類型也叫 bool類型，bool 類型數(shù)據(jù)只允許取值 true 和 false
2. bool類型占1 個字節(jié)。
3. bool 類型適于邏輯運算，一般用于程序流程控制

	seg := truefmt.Printf("%T  \n", seg) //boolfmt.Println("seg=", seg)    //seg= trueif seg {fmt.Println("如果是true， 我就打印")} else {fmt.Println("如果是false， 我就打印")}

2.5 String類型

2.5.1 基本概述

字符串就是一串固定長度的字符連接起來的字符序列。Go 的字符串是由單個字節(jié)連接起來的。Go語言的字符串的字節(jié)使用 UTF-8 編碼標識 Unicode 文本。

var name string = "今年張三，英文ZhangSan，23歲了。"fmt.Println(name)

2.5.2 String使用注意事項和細節(jié)

1. Go語言的字符串的字節(jié)使用UTF-8編碼標識Unicode文本，這樣Golang統(tǒng)一使用Utf-8編碼，中文亂碼就不會出現(xiàn)了。
2. 字符串一旦賦值后，字符串就不能單個字符修改了。在Go中字符串是不可變的。

var str = "hello"
str[0] = 'b'  //這里就會報錯了。字符串單個字符是不可變的。可以直接從新賦值：
str ="word"

3. 字符串的兩種表示方式
1. 雙引號，會識別轉義字符
2. 反引號，以字符串的原生形式輸出，包括換行和特殊字符，可以實現(xiàn)防止攻擊、輸出源代碼等效果。

4. 字符串拼接方式

	str := "hello "name := "zhangsan"strName := str + namefmt.Println(strName)  //hello zhangsan

5. 當一行字符串太長時，需要使用多行字符串，可以用“” + 進行綁定。 重點是：+ 號必須保持在上一行中。

str := "lisi " + "wangwu " + " zhaoliu " + " a" +" b" + "c " +"D"fmt.Println(str)  //lisi wangwu  zhaoliu  a bc D

2.6 基本數(shù)據(jù)類型的默認值

在Go中，數(shù)據(jù)類型都有一個默認值，當沒有賦值時，就會保留默認值，在Go中，默認值又叫“零值”

2.7 基本數(shù)據(jù)類型的相互轉換

Golang和java、C不同，在Go語言中，不同類型的變量之間賦值時需要顯式轉換。 也就是說Golang中數(shù)據(jù)類型不能自動轉換。

基本語法：

• 表達式T(v) 將值 v 轉換為類型T
  • T：就是數(shù)據(jù)類型，比如：int32 , int64 ,float32, float64等
  • V：就是需要轉換的變量

var n1 int = 100
var n2 float64 = float64(n1)
n2 += 0.905
var n3 int = int(n2)
fmt.Printf("n1=%v, n2=%v, n3=%v", n1, n2, n3)
// n1=100, n2=100.905, n3=100

2.8 轉換的細節(jié)（重要）

1. 在Go中，數(shù)據(jù)類型的轉換可以是從 小范圍 轉換到 大范圍。也可以從 大范圍 轉換成 小范圍。
2. 被轉換的是變量存儲的數(shù)據(jù)（既值） ，變量本身的數(shù)據(jù)類型并沒有變化。

例如：
我們將 n1 float =1.23 轉換成 n2 int = 100
那么分別打印 n1 =1.23. 打印n2 =100
var n1 float64 = 1.23
var n2 int = int(n1)
fmt.Printf(“n1=%v, n2=%v”, n1, n2)
// 打印結果：n1=1.23, n2=1

3. 在轉換結果中，比如將Int64轉換成int8 ，編譯時不會報錯 ，只是轉換的結果是按溢出處理，和我們希望的結果不一樣。

var n1 int64 = 999999
var n2 int8 = int8(n1)
fmt.Printf("n1=%v, n2=%v", n1, n2)
//  n1=999999, n2=63

2.9 基本數(shù)據(jù)類型轉String（重要）

在程序開發(fā)中，我們經常需要將基本數(shù)據(jù)類型轉成String類型。
或者String類型轉換成基本數(shù)據(jù)類型。

2.9.1 fmt.Sprintf(“%參數(shù)”, 變量名)

方式一： fmt.Sprintf(“%參數(shù)", 表達式）

1. 參數(shù)需要和表達式的數(shù)據(jù)類型相匹配
2. fmt.Sprintf() 會返回轉換后的字符串

package mainimport "fmt"func main() {var n1 int = 123var n2 float64 = 1.23var n3 byte = 'a'var n4 bool = truevar str string// %T 的意思是：該變量的類型// %q 的意思是：打印變量的類型，并且用雙引號，引起來。str = fmt.Sprintf("%d", n1)fmt.Printf("str的類型是：%T, Str等于%q\n", str, str)str = fmt.Sprintf("%f", n2)fmt.Printf("str的類型是%T,str等于：%q \n", str, str)str = fmt.Sprintf("%c", n3)fmt.Printf("str的類型是:%T,str等于%q \n", str, str)str = fmt.Sprintf("%t", n4)fmt.Printf("str的類型是%T,str等于%q \n", str, str)
}
str的類型是string, Str等于"123"
str的類型是string, str等于："1.230000" 
str的類型是:string str等于"a" 
str的類型是string, str等于"true" 

2.9.2 使用strconv包的函數(shù)

方式二：使用strconv包的函數(shù)
3. func FomatBool(b lool) String
4. func FomatInt(i int64, base int ) String

	var num1 int = 123var num2 float64 = 1.234var num3 bool = truevar str stringfmt.Printf("num1的類型是：%T \n", num1)str = strconv.FormatInt(int64(num1), 10)fmt.Printf("str的類型是：%T,str的值是：%q \n", str, str)//要轉換的變量，//'f'：格式是：ddd.dddd。 一般使用的比較多//精度（小數(shù)點后面幾位），該float的位數(shù)，例如64/32str = strconv.FormatFloat(num2, 'f', 2, 64)fmt.Printf("str的類型是：%T,str的值是%q \n", str, str)str = strconv.FormatBool(num3)fmt.Sprintf("str的類型是:%T,str的值是%q", str, str)num1的類型是：int 
str的類型是：string,str的值是："123" 
str的類型是：string,str的值是"1.23" Itoa 將int類型轉為String類型：
var num1 int = 100var str string = strconv.Itoa(num1)fmt.Printf(str)

關于strconv.FormatFloat的參數(shù)說明：

2.10 String類型轉為基本類型

2.10.1 使用strconv包的函數(shù)

func ParseBool
func ParseBool(str string) (value bool, err error)
返回字符串表示的bool值。它接受1、0、t、f、T、F、true、false、True、False、TRUE、FALSE；否則返回錯誤。

	var str string = "true"var err errorvar b boolb, err = strconv.ParseBool(str)fmt.Printf("b的類型是 %T,b的值是%v,b的錯誤結果是：%v \n", b, b, err)

func ParseInt
func ParseInt(s string, base int, bitSize int) (i int64, err error)
返回字符串表示的整數(shù)值，接受正負號。

base指定進制（2到36），如果base為0，則會從字符串前置判斷，"0x"是16進制，"0"是8進制，否則是10進制；
bitSize指定結果必須能無溢出賦值的整數(shù)類型，0、8、16、32、64 分別代表 int、int8、int16、int32、int64；返回的err是*NumErr類型的，如果語法有誤，err.Error = ErrSyntax；如果結果超出類型范圍err.Error = ErrRange。

	var str string = "123"var i int64// 要轉的字符串，base：轉成10進制，bitSize：轉成64位i, _ = strconv.ParseInt(str, 10, 0)fmt.Printf("i的格式是:%T,  i的值是:%v", i, i)// i的格式是:int64,  i的值是:123

• func ParseFloat
  func ParseFloat(s string, bitSize int) (f float64, err error)

解析一個表示浮點數(shù)的字符串并返回其值。
如果s合乎語法規(guī)則，函數(shù)會返回最為接近s表示值的一個浮點數(shù)（使用IEEE754規(guī)范舍入）。bitSize指定了期望的接收類型，32是float32（返回值可以不改變精確值的賦值給float32），64是float64；返回值err是*NumErr類型的，語法有誤的，err.Error=ErrSyntax；結果超出表示范圍的，返回值f為±Inf，err.Error= ErrRange。

	var str string = "1.2345"var f float64f, _ = strconv.ParseFloat(str, 64)fmt.Printf("f的類型是%T, f的值是:%v", f, f)// f的類型是float64, f的值是:1.2345