有興趣的小伙伴可以+vx一起學習：lmomo7205

Go 學習筆記

Go語言變量和常量

1. 標識符

在變成語言中標識符就是程序員定義的具有特殊意義的詞，比如變量名、常量名、函數(shù)名等等。Go語言中標識符由字母數(shù)字和_下劃線組成，并且只能以字母和_開頭，比如abc、_、_123、a123

2. 關鍵字

關鍵字是指變成語言中預先定義好的具有特殊含義的標識符。關鍵字和保留字都不建議用做變量名。

1. Go語言中有25個關鍵字

       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.變量

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

1. 變量標準聲明

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

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

2. 批量聲明

   批量聲明可以使用一個var

   var (
   name string
   age int
   money float32
   )
   

3. 變量的初始化

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

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

4. 類型推導

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

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

5. 短變量聲明

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

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

6. 匿名變量

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

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

7. 注意事項

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

4.常量

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

// 幾種定義常量的方式
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語言的常量計算器，只能在常量的表達式中使用。

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

   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 對應的無符號整型：uint8、uint16、uint32、uint64

其中，uint8就是我們熟知的byte型，int16對應C語言中的short型，int64對應C語言中的long型。

特殊整數(shù)型

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

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

浮點型

Go語言支持兩種浮點型數(shù)：float32和float64。這兩種浮點型數(shù)據(jù)格式遵循IEEE 754標準： float32 的浮點數(shù)的最大范圍約為 3.4e38，可以使用常量定義：math.MaxFloat32。 float64 的浮點數(shù)的最大范圍約為 1.8e308，可以使用一個常量定義：math.MaxFloat64。

復數(shù)

complex64和complex128

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

復數(shù)有實部和虛部，complex64的實部和虛部為32位，complex128的實部和虛部為64位。

布爾值

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

注意：

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

字符串

Go語言中的字符串以原生數(shù)據(jù)類型出現(xiàn)，使用字符串就像使用其他原生數(shù)據(jù)類型（int、bool、float32、float64 等）一樣。 Go 語言里的字符串的內(nèi)部實現(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字符。

當需要處理中文、日文或者其他復合字符時，則需要用到rune類型。rune類型實際是一個int32。

Go 使用了特殊的 rune 類型來處理 Unicode，讓基于 Unicode 的文本處理更為方便，也可以使用 byte 型進行默認字符串處理，性能和擴展性都有照顧。

// 遍歷字符串
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)存，并復制字節(jié)數(shù)組。

func changeString() {
    s1 := "big"
    // 強制類型轉(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語言中只有強制類型轉(zhuǎn)換，沒有隱式類型轉(zhuǎn)換。該語法只能在兩個類型之間支持相互轉(zhuǎn)換的時候使用。

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

T(表達式)

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

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

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

Go語言基礎之運算符

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

運算符

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

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

1.算數(shù)運算符

注意： ++（自增）和--（自減）在Go語言中是單獨的語句，并不是運算符。

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.關系運算符

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.邏輯運算符

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.位運算符

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

5.賦值運算符

字面意思理解