Golang 基礎數據類型（一）

基礎數據類型

在Go語言中，數據類型用於聲明函數與變量、常量數據的類型，聲明何種數據類型主要是爲了提升內存的利用率，由於不一樣的數據類型在內存所須要的空間大小是不同的。

Golang內置基礎數據類型以下表所示：

數據類型名稱	類型和描述
boolean	布爾型，值能夠是常量true或false
int&uint	帶符號和無符號兩種整型。int8,int16,int32(rune),int64和uint8(byte),uint16,uint32,uint64。uintptr類型在指針小節中單獨介紹。
float32&float64	Golang沒有float這種類型，只有float32和float64兩種類型
complex64&complex128	複數類型，complex64包含float32實部和虛部，complex128包含float64實部和虛部
string	字符串類型，默認使用UTF-8編碼，且字符串的值是固定的，不可變化
派生類型	切片類型(slice)、字典(map)、通道類型(channel)、指針類型(pointer)、數組類型(array)、結構化類型(struct)、函數類型(function)、接口類型(interface)、錯誤類型(error)

整型

Golang一共有9種不一樣大小的整型，無符號和帶符號分別各佔四種，還有一種uintptr類型，多用於底層編程。

Golang除了支持常規整型運算（四則運算），還支持比較運算。

var x int16
var y int32

func main() {
    x, y := 2, 4
    if x == y {
        fmt.Println("x等於y（錯誤）") //編譯不經過，由於不一樣類型不能相互比較
    }

    if x == 2 || y == 2 {
        fmt.Println("x等於y（正確）") //可用字面量比較
    }
}

位運算

（施工中）

浮點型

在Go語言中沒有float這種類型，只有float32和float64兩種類型，float32精確到小數點後七位，float64精確到小數點後十五位。因爲精度不一樣的緣由，在使用"=="和"!="來比較浮點數時須要特別注意，事先測試運算能夠避免很多的問題。

因爲標準庫math包中全部關於數學運算的函數都要求接收float64這個類型，因此在平常編寫Go語言程序時，儘可能使用float64類型。

複數類型

Go語言的複數類型有兩個：complex64和complex128，分別由兩個float32和float64實部和虛部組成。

func main() {

    var v1 complex64 //由兩個float32構成的複數類型
    v1 = 1.2 + 11i

    v2 := 1.2 + 11i //隱式聲明，默認是complex128類型，分爲float64
    v3 := complex(1.2, 11)

    //h := v1 + v2 //float64與float32類型不匹配，所以不能編譯經過
    v := v2 + v3 //v3數值等於v2
    fmt.Println(v1, v2, v3, v)

    vr := real(v) //獲取實部的值
    vt := imag(v) //獲取虛部的值
    fmt.Println(vr, vt)
}

cmath包中包含了一些關於操做複數的方法，除非是對內存有嚴格限制的程序，不然建議使用 complex128 做爲聲明類型，減小後續類型轉換的操做。

字符串

Go語言默認支持UTF-8編碼，一個字符串是一個不可改變的UTF-8字符序列，一個ASCII碼佔用1字節，其餘字符根據須要佔用2~4字節。這樣的設計帶來的好處有兩個：一個是能夠減小內存空間的使用，節約硬盤空間，第二個是統一編碼格式有助於減小編碼和解碼的工做，提升編譯效率。

Go語言字符串類型支持如下兩種形式的字面值

• 解釋字符串

該類字符串使用一對雙引號""括起來，在這當中相關的轉義字符將被替換，不支持換行，會解析轉義字符。

• 非解釋字符串

該類字符串使用一對反引號 ` 括起來，支持換行，引號內全部的內容（包括轉義字符）所有輸出。

func main() {
  /*打印輸出
  * 我家住在隔壁的\n  
  *    釣魚城大學
  * 我家住在隔壁的
  * 釣魚城大學
  */
    str1 := `我家住在隔壁的\n  
    釣魚城大學`
    str2 := "我家住在隔壁的\n釣魚城大學"
    fmt.Println(str1) //徹底輸出反單引號括號內的內容而且能夠跨行，不解析轉義字符
    fmt.Println(str2) //雙引號內的不能換行，而且會解析轉義字符

}

• 操做字符串

雖然字符串是不能改動的，但能夠經過索引逐個讀取它的值。

func main() {
    s := "abcd你" //一個漢字佔3字節，一共7字節長度
    for i := 0; i < len(s); i++ {
        fmt.Println(s[i])
    }
    /*
        *c := s[len(s)] // 訪問超出字符串索引範圍的字節會輸出panic異常，編譯不報錯，執行會報錯
        fmt.Println(len(s), c)
    */
    fmt.Println(s[0:4]) //打印從第0字節到第4字節的字符串，abcd
    fmt.Println(s[:])   //打印所有字節的字符串，abcd你
    fmt.Println(s[2:])  //打印從第2字節以後的字符串，cd你
    fmt.Println(s[:3])  //打印從第0字節到第3字節（不包括最後字節的字符串），abc
    fmt.Println(s[1:2]) //打印從第1字節到第2字節的字符串（不包括最後字節的字符串），b
}

因爲像漢字這種非ASCII字符的UTF-8編碼由多個字節構成，一個漢字佔3字節長度；因此，第i個字節並不必定是字符串的第i個字符。例如，打印從第0字節到第6字節的字符串長度，因爲漢字 "你"佔3個字節長度，選取索引值爲6的字符串返回的是一個 "�"，並不是完整的漢字字符串。

$ fmt.Println(s[0:6])
$ abcd�

• 鏈接字符串

除了截取字符串，還可使用+符號鏈接字符串。

func main() {
    s := "abcd你" //一個漢字佔3字節，一共7字節長度
    for i := 0; i < len(s); i++ {
        fmt.Println(s[i])
    }
    /*
    *c := s[len(s)] // 訪問超出字符串索引範圍的字節會拋出panic異常
    *fmt.Println(len(s), c)
    */
    fmt.Println(s[0:4]) //打印從第0字節到第4字節的字符串，abcd
    fmt.Println(s[:])   //打印所有字節的字符串，abcd你
    fmt.Println(s[2:])  //打印從第2字節以後的字符串，cd你
    fmt.Println(s[:3])  //打印從第0字節到第3字節，abc
    fmt.Println(s[1:2]) //打印從第1字節到第2字節的字符串，b

    fmt.Println(s[0:4] + "好") //鏈接字符串
    str := "你我皆完滿，" +
        "生在人世間。"
    fmt.Println(str)
}

由代碼塊能夠看出，使用 + 鏈接字符串的時候，是能夠跨行操做的；因爲編譯器會自動在行尾補全分號，+ 號必需要放在第一行。

除此之外，還能夠經過使用 "==" 和 "<" 等比較運算符的方法逐字節的編碼進行比較。

func main() {
    s := "你"
    t := "好"
    if s < t { //使用比較運算符計算字節長度
        fmt.Print(s[0], t[0])
        fmt.Println(s[1], t[1])
        fmt.Println(s[2], t[2])
    }
    a := "a"
    b := "b"
    if a < b {
        fmt.Println(a[0], "小於", b[0])
    }
}

• 字符串遍歷

(施工中)

• 字符串修改

在Go語言中，字符串的內容不能修改，也就不能用 s[i] 這種方式修改字符串的UTF-8編碼，若是確實要修改，那麼能夠將字符串的內容複製到另外一個可寫的變量中，而後再進行修改。通常使用 []bute 或 []rune 進行修改。

若是要對字符串中的字節進行修改，就轉換成 []byte 格式；若是要對字符串中的字符進行修改，就轉換成 []rune 格式。在轉換的過程當中會自動複製數據。

//使用[]byte修改字符串s的字節
func main() {
    s := "Hello 世界"
    b := []byte(s)        
    b[5] = ','            //修改第5字節的值
    fmt.Printf("%s\n", s) //打印修改前字符串
    fmt.Printf("%s\n", b) //打印修改後的字符串
}

//使用[]rune修改字符串s中的字符
func main() {
    s := "Hello 世界！"
    r := []rune(s)
    r[6] = '中' //修改字符串中的字符
    r[7] = '國'
    fmt.Println(s)         //打印修改前字符串的字符
    fmt.Println(string(r)) //打印修改後字符串的字符
}

Go語言中的字符串是根據長度限定的，而非特殊字符0。string類型的0值是長度爲0的字符串，即空字符串""。

• 想要獲取字符串所佔字節長度的方法，通常是能夠經過比較運算符（==, !=, <, <=, >=, >）在內存中按字節比較來實現字符串的對比，再使用 len() 函數獲取字符串所佔的字節長度。
• 字符串的內容能夠經過使用標準索引法來獲取。須要注意的是，標準索引法只適用於純ASCII碼的字符串有效。
• 注意，獲取字符串中某個字節的地址是非法的！例如：&str[i]。

布爾型

布爾類型沒法被其餘類型複製，也不支持類型轉換。Go語言中只有 true 和 false兩個值。它的聲明形式以下：

v := bool //聲明布爾類型
x := (1 == 2) //編譯器自動推導類型

當運算符兩邊的值徹底相同時（值相同，數據類型相同）時就會返回true，不然返回false。若是值的類型是接口，它們必須實現了相同類型的接口才能比較。若是類型不一樣，則必須使用類型轉換以後才能比較。

布爾類型運算

二元運算符：和&&、或||、相等==、不等!=
一元運算符：非!

• 非運算符：!

使用T表明符合true的語句，使用F表明附和false的語句
非運算符用於取得與布爾值相反的結果

!T -> false
!F -> true

• 和運算符：&&

和運算符用於當兩邊的值都爲true時，結果纔是true

T && T -> true
T && F -> false
F && T -> false
F && F -> false

• 或運算符：||

或運算符用於當兩邊值都爲false時，結果纔是false

T || T -> true
T || F -> true
F || T -> true
F || F -> false

在Go語言中，&&和||是具備快捷性質的運算符，當左邊表達式的值確立時（&&左邊爲false，||左邊爲true），運算符右邊的表達式就不會被執行。利用這個性質，咱們應該將計算過程較爲複雜的表達式放在運算符的右邊，減小沒必要要的計算。

在格式化輸出時，可使用%t來表示要輸出的值爲布爾型。