（七）golang-變量之基本數據類型（看這篇就夠了）

1.整數類型

類型	有無符號	佔用存儲空間	表示範圍	備註
int8	有	1字節	-2**7~2**7-1
int16	有	2字節	-2**15~2**15-1
int32	有	4字節	-2**31~2**31-1
int64	有	8,字節	-2**63~2**63-1
uint8	無	1字節	0~2**8-1
uint16	無	2字節	0~2**16-1
uint32	無	4字節	0~2**32-1
uint64	無	8字節	0~2**64-1
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	等價int32，表示 一個unicode碼
byte	無	與uint8同樣	0~2**8-1	當要存儲字符時 使用byte

整型的使用細節：

（1）golang整數類型分爲：有符號和無符號，int和uint的大小和系統有關；

（2）golang整型默認申明爲Int；

（3）如何在程序查看某個變量的數據類型？

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var num int64 = 10
    fmt.Printf("num的數據類型是 %T，佔的字節數是 %d", num, unsafe.Sizeof(num))
}

（4）golang使用整數類型時，聽從保小不保大原則，即在保證程序正常運行的狀況下，儘可能使用佔用空間小的數據類型；

（5）bit：計算機中最小的存儲單位，byte：計算機中基本的存儲單元；

2.浮點類型

類型	佔用存儲空間	表示範圍
單精度float32	4字節	-3.403E38~3.403E38
雙精度float64	8字節	-1.798E308~1.798E308

說明：

（1）浮點數在機器中存在的形式：浮點數=符號位+指數位+尾數位（浮點數都是有符號的）11110000111.111111111111111111000

（2）尾數部分可能丟失，形成精度損失；

（3）浮點型的存儲分爲三個部分：符號位+指數位+尾數位；

浮點型的使用細節：

（1）golang浮點類型有固定的範圍和字段長度，不受操做系統的影響；

（2）默認爲float64類別；

（3）浮點型經常使用兩種形式表示：

　　1）十進制：5.十二、.512

　　2）科學記數法形式：5.1234E二、5.1234E-2

（4）一般使用float64，它精度更高；

3.字符類型

字符串是一串固定長度的字符鏈接起來的字符序列。golang沒有專門的存儲字符類型，若是要存儲單個字符，用byte來保存。go的字符串是由單個字節鏈接起來的，它與傳統的字符串是由字符組成的不一樣。

package main

import (
    "fmt"
)

func main() {
    var c1 byte = 'a'
    fmt.Println(c1)
}

當咱們直接輸出字符c1,，獲得的是它的ascII值：97。要用格式化輸出：fmt.Printf("%c",c1)。而當咱們要存儲中文時，此時不可以用byte類型了，即ASCII值大於255時，會顯示溢出，咱們要用int來存儲：

（補：格式化輸出表明含義 %d：輸出整型；%f：輸出浮點型；%c：輸出字符型；%v：輸出原變量值；%T：輸出變量的數據類型；%t：輸出布爾值：%q：輸出帶雙引號的字符串）

package main

import (
    "fmt"
)

func main() {
    var c1 byte = 'a'
    var c2 int = '被'
    fmt.Println(c1)
    fmt.Printf("c1的值是：%c \n", c1)
    fmt.Printf("c2的值是：%c，它的ASCii值是：%d", c2, c2)
}

 

 字符類型使用細節：（不再用擔心編碼的問題了，全部的編碼都是utf-8）
（1）字符常量使用單引號括起來的單個字符；

（2）go中容許使用轉義字符'\'來將其後的字符轉變爲特殊字符型常量，例如 var c int = '\n'；

（3）字符使用utf-8編碼；

（4）go中，字符的本質是一個整數，直接輸出時，會輸出它對應的UTF-8編碼的值；

（5）能夠直接給變量賦予某個數字，而後格式化輸出%c，會輸出該數字對應的unicode字符；

（6）字符類型是能夠進行運算的，至關於一個整數，由於它都對應unicode碼；

4.布爾類型

只容許取兩個值：true、false；佔用1個字節；主要用在邏輯運算；

5.字符串類型

go的字符串是由字節鏈接而成；

package main

import (
    "fmt"
)

func main() {
    var address string = "北京長城"
    fmt.Println(address)
}

字符串的使用細節：
（1）go語言的字符串的字節使用utf-8編碼；

（2）與python同樣，一旦字符串賦值了，就不能被更改；

（3）兩種表示形式

　　1）雙引號，會識別轉義字符；

　　2）反引號，以字符串的原生形式輸出，包括換行和特殊字符，能夠實現防止攻擊，輸出源代碼等

package main

import (
    "fmt"
)

func main() {
    var c = "abc\nabc"
    var d = `abc\nabc`
    fmt.Println(c)
    fmt.Println(d)
}

 

 　　3）字符串的拼接，當咱們要拼接多行字符串時，要將加號留在每行末尾：（注意單個字符進行拼接是指對unicode值進行相加）

package main

import (
    "fmt"
)

func main() {
    var str = "hello " + "world " +
        "!"
    fmt.Println(str)
}

 

 6.基本數據類型的默認值

整型：0

浮點型：0

字符串：""

布爾類型：false

7.基本數據類型之間的轉換

golang和java、c不一樣，Go在不一樣類型變量之間賦值須要顯示轉換，也就是golang中數據類型不能自動轉換；

基本語法：T(v)，即將變量v轉換成T數據類型

整數型之間的轉換：例如var i int8 = 10; var n1 int64 = int64(i)

（1）數據類型轉換能夠從範圍小-->範圍大，範圍大-->範圍小；

（2）被轉換的是變量存儲的數據（即值），變量自己的數據類型並無變化；

（3）在轉換中，好比將int64轉成int8，編譯時不會報錯，只是轉換的結果是按溢出處理，和咱們但願的結果不同；

基本數據類型和string之間的轉換

（1）fmt.Sprintf("%參數"，表達式)：參數和表達式的類型要匹配；結果返回轉換後的字符串；

package main

import (

    "fmt"

)

func main() {

    var num1 int = 99

    var num2 float64 = 23.456

    var b bool = false

    var c byte = 'g'

    var str1 = fmt.Sprintf("%d", num1)

    var str2 = fmt.Sprintf("%f", num2)

    var str3 = fmt.Sprintf("%t", b)

    var str4 = fmt.Sprintf("%c", c)

    fmt.Printf("%T--%q\n", str1, str1)

    fmt.Printf("%T--%q\n", str2, str2)

    fmt.Printf("%T--%q\n", str3, str3)

    fmt.Printf("%T--%q", str4, str4)

}

 

 （2）使用strconv函數package main

import (
    "fmt"
    "strconv"
)

func main() {
    var num1 int = 99
    var num2 float64 = 23.456
    var b bool = false
    //FormatInt()第一個參數必須轉成int64,第二個是十進制表示
    var str1 = strconv.FormatInt(int64(num1), 10)
    //FormatFloat，'f'表示格式，10表示保留小數，64表示float64
    var str2 = strconv.FormatFloat(num2, 'f', 10, 64)
    var str3 = strconv.FormatBool(b)

      //將int轉換成string

      var str4 = strconv.Itoa(num1)

 fmt.Printf("%T--%q\n", str1, str1) fmt.Printf("%T--%q\n", str2, str2) fmt.Printf("%T--%q\n", str3, str3)

 fmt.Printf("%T--%q\n", str4, str4)

}

 string和基本數據類型轉換：

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var s1 string = "true"
    var s2 string = "888"
    var s3 string = "23.45"
    var num1 int64
    var num2 float64
    var b bool
    b, _ = strconv.ParseBool(s1)
    num1, _ = strconv.ParseInt(s2, 10, 64)
    num2, _ = strconv.ParseFloat(s3, 64)
    fmt.Printf("%T--%t\n", b, b)
    fmt.Printf("%T--%d\n", num1, num1)
    fmt.Printf("%T--%f\n", num2, num2)
}

 

 注意：要確保string類型要可以轉換成有效的數據，即"hello"不能轉換成布爾值、整型、浮點型