有興趣的小伙伴可以+vx一起學(xué)習(xí)：lmomo7205

Go 學(xué)習(xí)筆記

Go語言變量和常量

1. 標(biāo)識符

在變成語言中標(biāo)識符就是程序員定義的具有特殊意義的詞姆怪，比如變量名叛赚、常量名、函數(shù)名等等稽揭。Go語言中標(biāo)識符由字母數(shù)字和_下劃線組成俺附，并且只能以字母和_開頭，比如abc溪掀、_事镣、_123、a123

2. 關(guān)鍵字

關(guān)鍵字是指變成語言中預(yù)先定義好的具有特殊含義的標(biāo)識符揪胃。關(guān)鍵字和保留字都不建議用做變量名璃哟。

1. Go語言中有25個關(guān)鍵字

       break        default      func         interface    select
       case         defer        go           map          struct
       chan         else         goto         package      switch
       const        fallthrough  if           range        type
       continue     for          import       return       var
   

2. 37個保留字段

      Constants:    true  false  iota  nil
   
           Types:    int  int8  int16  int32  int64  
                     uint  uint8  uint16  uint32  uint64  uintptr
                     float32  float64  complex128  complex64
                     bool  byte  rune  string  error
   
       Functions:   make  len  cap  new  append  copy  close  delete
                    complex  real  imag
                    panic  recover
   

3.變量

程序運(yùn)行過程中的數(shù)據(jù)都是保存在內(nèi)存中氛琢，我們想要在代碼中操作某個數(shù)據(jù)時就需要去內(nèi)存上找到這個變量，但是如果我們直接在代碼中通過內(nèi)存地址去操作變量的話随闪，代碼的可讀性會非常差而且還容易出錯阳似，所以我們就利用變量將這個數(shù)據(jù)的內(nèi)存地址保存起來，以后直接通過這個變量就能找到內(nèi)存上對應(yīng)的數(shù)據(jù)了铐伴。
***
Go語言中變量必須聲明后才能使用撮奏，同意作用域內(nèi)不支持重復(fù)聲明，并且變量聲明后必須使用当宴，不然會報錯

1. 變量標(biāo)準(zhǔn)聲明

   每聲明一個變量就要使用一個var

   var 變量名 變量類型 = var name string
   

2. 批量聲明

   批量聲明可以使用一個var

   var (
   name string
   age int
   money float32
   )
   

3. 變量的初始化

   Go語言在聲明變量的時候畜吊，會自動對變量對應(yīng)的內(nèi)存區(qū)域進(jìn)行初始化操作，每個變量會被初始化成其類型的默認(rèn)值即供，例如：int和float類型的變量初始值為0定拟，string的初始值為 空字符串，布爾類型默認(rèn)值為 false逗嫡，切片青自、函數(shù)、指針變量的默認(rèn)值為nil

   // 在聲明變量的時候可以指定初始值如下
   var 變量名 類型 = 表達(dá)式 = var name string = "Lmomo"
   // 一次是初始化多個變量驱证，有兩種方式
   1. var name,age ="Lmomo",20 //此種聲明會進(jìn)行推導(dǎo)類型
   2. var (
    name string = "lmomo"
       age int = 20
   )
   

4. 類型推導(dǎo)

   聲明變量的時候可以省略類型延窜，此時Go語言會根據(jù)=號右邊的值進(jìn)行推導(dǎo)類型

   var name ="Lmomo" // name類型為string
   

5. 短變量聲明

   短變量聲明只能在局部變量中使用，可以使用:=方式聲明并初始化變量

   var m = 100 //全局變量
   func main(){
    n:=10
    m:=200 //此處為局部變量
   }
   

6. 匿名變量

   使用多重賦值時抹锄，如果需要忽略某一個值逆瑞，可以使用匿名變量（anonymous variable）。匿名變量用一個下劃線_表示伙单，匿名變量不占用命名空間获高，不會分配內(nèi)存，所以匿名變量之間不存在重復(fù)聲明吻育。（在Lua等變成語言中念秧，匿名比那里也被稱作啞元變量）

   package main
   func foo()(int,string){ //無入?yún)ⅲ祷豬nt和string類型的兩個參數(shù)
    return 10,"Lmomo"
   }
   func main(){
    x,_:=foo() //值為10和空
    _,x:=foo() //值為空和Lmomo
   }
   

7. 注意事項

   1. 函數(shù)外的每個語句都必須以關(guān)鍵字開始（var布疼、const瞭空、func等）
   2. :=不能在函數(shù)外使用撑刺，只做局部變量
   3. _多用于占位，表示忽略值

4.常量

對比變量聲明方式基本一致只是var換成了const，并且聲明必須賦值鞭缭，而且在程序運(yùn)行過沖中不能修改

// 幾種定義常量的方式
const name string ="Lmomo"
const name ="Lmomo"
const (
    name string = "Lmomo"
)
const(
    name ="Lmomo"
)
const(
    name ="Lmomo"
    name1 
    name2
    name3
    // name-name3值均為Lmomo
)

1. iota

   iota是go語言的常量計算器鼻由，只能在常量的表達(dá)式中使用省骂。

   iota在const關(guān)鍵字中出現(xiàn)的時候?qū)⒈恢刂脼?惊橱，重復(fù)使用后以第一次使用時為準(zhǔn)

   const(
    number = iota //0
    number1 //1
    number2 //2
    number3 //3
   )
   const(
    number = iota //0
    number1 //1
    number2 = iota //2
    number3 //3
   )
   const(
    number = iota //0
    number1 = 100 //100
    number2 = iota //2
    number3 //3
   )
   const(
    number = iota //0
    number1 = 100 //100
    _
    number3 //2
   )
   

Go語言基本數(shù)據(jù)類型

整數(shù)

整型分為以下兩個大類： 按長度分為：int8、int16、int32铸董、int64 對應(yīng)的無符號整型：uint8祟印、uint16、uint32粟害、uint64

其中蕴忆，uint8就是我們熟知的byte型，int16對應(yīng)C語言中的short型悲幅，int64對應(yīng)C語言中的long型套鹅。

特殊整數(shù)型

注意： 在使用int和 uint類型時，不能假定它是32位或64位的整型留荔，而是考慮int和uint可能在不同平臺上的差異吟孙。

注意事項 獲取對象的長度的內(nèi)建len()函數(shù)返回的長度可以根據(jù)不同平臺的字節(jié)長度進(jìn)行變化。實(shí)際使用中聚蝶，切片或 map 的元素數(shù)量等都可以用int來表示杰妓。在涉及到二進(jìn)制傳輸、讀寫文件的結(jié)構(gòu)描述時碘勉，為了保持文件的結(jié)構(gòu)不會受到不同編譯目標(biāo)平臺字節(jié)長度的影響巷挥，不要使用int和 uint。

浮點(diǎn)型

Go語言支持兩種浮點(diǎn)型數(shù)：float32和float64验靡。這兩種浮點(diǎn)型數(shù)據(jù)格式遵循IEEE 754標(biāo)準(zhǔn)： float32 的浮點(diǎn)數(shù)的最大范圍約為 3.4e38倍宾，可以使用常量定義：math.MaxFloat32。 float64 的浮點(diǎn)數(shù)的最大范圍約為 1.8e308胜嗓，可以使用一個常量定義：math.MaxFloat64高职。

復(fù)數(shù)

complex64和complex128

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)

復(fù)數(shù)有實(shí)部和虛部，complex64的實(shí)部和虛部為32位辞州，complex128的實(shí)部和虛部為64位初厚。

布爾值

Go語言中以bool類型進(jìn)行聲明布爾型數(shù)據(jù)，布爾型數(shù)據(jù)只有true（真）和false（假）兩個值孙技。

注意：

1. 布爾類型變量的默認(rèn)值為false。
2. Go 語言中不允許將整型強(qiáng)制轉(zhuǎn)換為布爾型.
3. 布爾型無法參與數(shù)值運(yùn)算排作，也無法與其他類型進(jìn)行轉(zhuǎn)換牵啦。

字符串

Go語言中的字符串以原生數(shù)據(jù)類型出現(xiàn)，使用字符串就像使用其他原生數(shù)據(jù)類型（int妄痪、bool哈雏、float32、float64 等）一樣。 Go 語言里的字符串的內(nèi)部實(shí)現(xiàn)使用UTF-8編碼裳瘪。 字符串的值為雙引號(")中的內(nèi)容土浸，可以在Go語言的源碼中直接添加非ASCII碼字符，例如：

字符轉(zhuǎn)義符

Go 語言的字符串常見轉(zhuǎn)義符包含回車彭羹、換行黄伊、單雙引號、制表符等派殷，如下表所示还最。

多行字符串

Go語言中要定義一個多行字符串時，就必須使用反引號字符：

s1 := `第一行
第二行
第三行
`
fmt.Println(s1)

反引號間換行將被作為字符串中的換行毡惜，但是所有的轉(zhuǎn)義字符均無效拓轻，文本將會原樣輸出。

字符串的常用操作

byte和rune類型

組成每個字符串的元素叫做“字符”经伙，可以通過遍歷或者單個獲取字符串元素獲得字符扶叉。 字符用單引號（’）包裹起來，如：

var a := '中'
var b := 'x'

Go 語言的字符有以下兩種：

1. uint8類型帕膜，或者叫 byte 型枣氧，代表了ASCII碼的一個字符。
2. rune類型泳叠，代表一個 UTF-8字符作瞄。

當(dāng)需要處理中文、日文或者其他復(fù)合字符時危纫，則需要用到rune類型宗挥。rune類型實(shí)際是一個int32。

Go 使用了特殊的 rune 類型來處理 Unicode种蝶，讓基于 Unicode 的文本處理更為方便契耿，也可以使用 byte 型進(jìn)行默認(rèn)字符串處理，性能和擴(kuò)展性都有照顧螃征。

// 遍歷字符串
func traversalString() {
    s := "hello沙河"
    for i := 0; i < len(s); i++ { //byte
        fmt.Printf("%v(%c) ", s[i], s[i])
    }
    fmt.Println()
    for _, r := range s { //rune
        fmt.Printf("%v(%c) ", r, r)
    }
    fmt.Println()
}

輸出：

104(h) 101(e) 108(l) 108(l) 111(o) 230(?) 178(2) 153() 230(?) 178(2) 179(3) 
104(h) 101(e) 108(l) 108(l) 111(o) 27801(沙) 27827(河) 

因為UTF8編碼下一個中文漢字由3~4個字節(jié)組成搪桂，所以我們不能簡單的按照字節(jié)去遍歷一個包含中文的字符串，否則就會出現(xiàn)上面輸出中第一行的結(jié)果盯滚。

字符串底層是一個byte數(shù)組踢械，所以可以和[]byte類型相互轉(zhuǎn)換。字符串是不能修改的 字符串是由byte字節(jié)組成魄藕，所以字符串的長度是byte字節(jié)的長度内列。 rune類型用來表示utf8字符，一個rune字符由一個或多個byte組成背率。

修改字符串

要修改字符串话瞧，需要先將其轉(zhuǎn)換成[]rune或[]byte嫩与，完成后再轉(zhuǎn)換為string。無論哪種轉(zhuǎn)換交排，都會重新分配內(nèi)存划滋，并復(fù)制字節(jié)數(shù)組。

func changeString() {
    s1 := "big"
    // 強(qiáng)制類型轉(zhuǎn)換
    byteS1 := []byte(s1)
    byteS1[0] = 'p'
    fmt.Println(string(byteS1))

    s2 := "白蘿卜"
    runeS2 := []rune(s2)
    runeS2[0] = '紅'
    fmt.Println(string(runeS2))
}

類型轉(zhuǎn)換

Go語言中只有強(qiáng)制類型轉(zhuǎn)換埃篓，沒有隱式類型轉(zhuǎn)換处坪。該語法只能在兩個類型之間支持相互轉(zhuǎn)換的時候使用。

強(qiáng)制類型轉(zhuǎn)換的基本語法如下：

T(表達(dá)式)

其中都许，T表示要轉(zhuǎn)換的類型稻薇。表達(dá)式包括變量、復(fù)雜算子和函數(shù)返回值等.

比如計算直角三角形的斜邊長時使用math包的Sqrt()函數(shù)胶征，該函數(shù)接收的是float64類型的參數(shù)塞椎，而變量a和b都是int類型的，這個時候就需要將a和b強(qiáng)制類型轉(zhuǎn)換為float64類型睛低。

func sqrtDemo() {
    var a, b = 3, 4
    var c int
    // math.Sqrt()接收的參數(shù)是float64類型案狠，需要強(qiáng)制轉(zhuǎn)換
    c = int(math.Sqrt(float64(a*a + b*b)))
    fmt.Println(c)
}

Go語言基礎(chǔ)之運(yùn)算符

運(yùn)算符用于程序執(zhí)行時的數(shù)學(xué)或邏輯運(yùn)算

運(yùn)算符

Go語言內(nèi)置的運(yùn)算符有：

1.算數(shù)運(yùn)算符
2.關(guān)系運(yùn)算符
3.邏輯運(yùn)算符
4.位運(yùn)算符
5.賦值運(yùn)算符

1.算數(shù)運(yùn)算符

注意： ++（自增）和--（自減）在Go語言中是單獨(dú)的語句，并不是運(yùn)算符钱雷。

package main
import "fmt"
func main(){
    a:=10
    b:=20
    fmt.Println(a+b) //30
    fmt.Println(a-b) //-10
    fmt.Println(a*b) //200
    fmt.Println(a/b) //0
    fmt.Println(a%b) //10
    a--
    fmt.Println(9)
    a++
    fmt.Println(11)
}

2.關(guān)系運(yùn)算符

package main
import "fmt"
func main(){
    fmt.Println(10 > 2) // true
    fmt.Println(10 < 2) // false
    fmt.Println(10 != 2) // true
    fmt.Println(4 <= 5) //true
    fmt.Println(1 == 1) //true
    fmt.Println(1 != 2) //true
    fmt.Println(2 >= 2) //true
}

3.邏輯運(yùn)算符

package main
import "fmt"
func main(){
    fmt.Println(10>5 && 5<7) // true
    fmt.Println(10>5 || 5>7) //true ,滿足其中一個即為true
    fmt.Println(!(10>5)) //false
}

4.位運(yùn)算符

位運(yùn)算符對整數(shù)在內(nèi)存中的二進(jìn)制進(jìn)行操作

5.賦值運(yùn)算符

字面意思理解