Go 基本型別

雲崖先生發表於2020-09-29
Go型別

整形

標準整形

　　 標準整形是按長度進行分類的，其中uint8為byte型，int16為C語言中的short型，int64為C語言中的long型別。

型別描述
uint8 無符號 8位整型 (0 到 255)
uint16 無符號 16位整型 (0 到 65535)
uint32 無符號 32位整型 (0 到 4294967295)
uint64 無符號 64位整型 (0 到 18446744073709551615)
int8 有符號 8位整型 (-128 到 127)
int16 有符號 16位整型 (-32768 到 32767)
int32 有符號 32位整型 (-2147483648 到 2147483647)
int64 有符號 64位整型 (-9223372036854775808 到 9223372036854775807)

動態整形

型別描述
uint 32位作業系統上就是uint32，64位作業系統上就是uint64
int 32位作業系統上就是int32，64位作業系統上就是int64
uintptr 無符號整型，用於存放一個指標

　　 動態整形的意思即是再不同的平臺上，有不同的差異。

　　 注意事項：len()函式可以根據不同平臺動態獲取動態整形的長度。但是在涉及到二進位制傳輸、讀寫檔案的結構描述時，不要使用int和uint

進位制寫法

　　 在Go1.13版本後，可以根據字面量來書寫不同的進位制。

　　 你甚至可以使用_來做分割，如v:=123_456表示v的值為123456。

　　 需要注意的一點是，Go語言中目前不支援二進位制的字面量寫法。

　　 藉助fmt函式將一個整數用於不同的進位制顯示。

package main

import "fmt"

func main() {
	// 十進位制定義
	var a int = 10
	fmt.Printf("%d \n", a) // 顯示十進位制
	fmt.Printf("%b \n", a) // 顯示二進位制
	fmt.Printf("%o \n", a) // 顯示八進位制
	fmt.Printf("%0x \n", a) // 顯示十六進位制

	// 八進位制定義
	var b int = 077
	fmt.Printf("%d \n", b) // 顯示十進位制

	// 十六進位制定義
	var c int = 0xff
	fmt.Printf("%d \n", c) // 顯示十進位制

}

浮點型

　　 Go語言中有兩種浮點型，float32與float64。

　　 float32 的浮點數的最大範圍約為 3.4e38，可以使用常量定義：math.MaxFloat32。 float64 的浮點數的最大範圍約為 1.8e308，可以使用一個常量定義：math.MaxFloat64。

　　 在列印浮點數時，使用fmt配合%f。

package main

import "fmt"

func main() {
	// float32
	var a float32 = 9.999
	// float64
	var b float64 = 8.888

	fmt.Println(a)

	fmt.Printf("型別：%T-數值：%f \n", a, a)
	fmt.Printf("型別：%T-數值：%f \n", b, b)

	// 9.999
	// 型別：float32-數值：9.999000
	// 型別：float64-數值：8.888000
}

複數

　　 複數用的比較少。有實部和虛部，complex64的實部和虛部為32位，complex128的實部和虛部為64位。

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

布林型別

　　 Go語言中的bool型別有true和false。

　　 值得一提的是在Go語言中布林值有以下的特性：

　　 1.布林型別的變數預設值都是false

　　 2.Go語言中布林值與整形沒有任何關係

　　 3.布林值無法參與運算，也不能進行轉換

字串

　　 Go語言中的字串是雙引號進行宣告，而多行的原生字串可以使用``來進行宣告。

　　 至於單引號，則用來表示單個字元。

　　 另外，Go語言中的字串都是使用UTF-8編碼格式。

基本定義

　　 以下示例中定義了一個字串。

package main

import "fmt"

func main() {
	var str string = "HELLO,WORLD!"
	fmt.Printf("型別：%T \n值: %v \n", str, str)
	// 型別：string
	// 值: HELLO,WORLD!
}

　　

轉義符

　　 可以使用\反斜槓來進行特殊字元的轉義。

轉義符含義
\r 回車符（返回行首）
\n 換行符（直接跳到下一行的同列位置）
\t 製表符
\\ 單引號
\" 雙引號
\\ 反斜槓

原始字元

　　 使用``來定義多行，並且它還具有原始字串的功能，即特殊字元在原始字串中沒有意義。

package main

import "fmt"

func main() {
	str := `
		望廬山瀑布
			李白
		日照香爐生紫煙，
		遙看瀑布掛前川。
		飛流直下三千尺，
		疑似銀河落九天。
	`
	fmt.Println(str)
}

常用方法

　　 以下是一些字串的常用方法。注意，需要匯入strings包。

方法描述
len() 求長度，byte長度
+ 字串拼接
fmt.Sprint() 字串拼接
strings.Contains() 判斷是否包含子串
strings.HasPrefix() 是否是以特定字首開始
strings.HasSuffx() 是否是以特定字尾結束
strings.Index() 子串出現位置，從左至右檢索
strings.LastIndex() 子串出現位置，從右至左檢索
strings.Split() 字串按照指定字元分割，返回陣列
strings.Join(str,sep string) 陣列拼接成字串 
package main

import (
	"fmt"
	"strings"
)

func main() {
	str := "this is string"
	fmt.Println(len(str)) // 14
	fmt.Println(str + "拼接後的內容")            // 返回新字串 this is string拼接後的內容
	fmt.Println(fmt.Sprint(str, "拼接後的內容")) // 返回新字串 this is string拼接後的內容
	fmt.Println(strings.Contains(str, "this")) // true
	fmt.Println(strings.HasPrefix(str, "this")) // true
	fmt.Println(strings.HasSuffix(str, "string")) // true
	fmt.Println(strings.Index(str,"is")) // 2
	fmt.Println(strings.LastIndex(str,"str")) // 8
	newStr := strings.Split(str,` `) 
	fmt.Println(newStr) // [this is string]
	fmt.Println(strings.Join(newStr,` `)) // this is string
}

byte

　　 當單個字元為英文時，是一個byte型別。一個byte標識八位二進位制數。

　　 值得注意的是，byte等同於uint8

package main

import (
	"fmt"
)

func main() {
	str := "this is string"
	fmt.Printf("型別:%T \n值:%v ", str[0], str[0])
	// 型別:uint8 
	// 值:116 
}

rune

　　 當單個字元為中文，或者其他文字如韓文時，該字元為rune型別。

　　 rune等同於uint32。

　　 如下示例，如果按照普通的len()進行遍歷，則會遍歷出byte型別，而一箇中文字元通常是3個byte，所以需要用rune來進行顯示。否則就會出現第一次遍歷出的結果。

package main

import (
	"fmt"
)

func main() {
	str := "這是字串"
	for i := 0; i < len(str); i++ { //byte
		fmt.Printf("%v(%c) ", str[i], str[i])
	}

	for _, r := range str { // rune
		fmt.Printf("%v(%c)", r, r)
	}
	// 232(è) 191(¿) 153() 230(æ) 152() 175(¯) 229(å) 173(­) 151() 231(ç) 172(¬) 166(¦) 228(ä) 184(¸) 178(²)
	// 36825(這)26159(是)23383(字)31526(符)20018(串)
	
	fmt.Print(len(str))
	// 15 按照byte進行遍歷
}

字元轉換

　　 將一個字串修改為byte型別，將一個字串修改為rune型別：

　　 注意：不管是byte還是rune型別，其實都是由陣列構成

package main

import (
	"fmt"
)

func main() {
	strChinese := "這是字串"
	strEngilsh := "this is string"

	byteStr := []byte(strEngilsh)
	runeStr := []rune(strChinese)

	fmt.Println(byteStr) // [116 104 105 115 32 105 115 32 115 116 114 105 110 103]
	fmt.Println(runeStr) // [36825 26159 23383 31526 20018]
}

字元修改

　　 要修改字串，必須要將其轉換為byte型別或rune型別。

　　 並且在修改時用``單引號進行包裹，改完後再將他們轉換為字串。

　　 如下示例：

package main

import (
	"fmt"
)

func main() {
	strChinese := "這是字串"
	runeStr := []rune(strChinese)
	runeStr[0] = '它' // 注意，用單引號進行包裹
	newString := string(runeStr)
	fmt.Println(newString) // 它是字串
}

型別轉換

　　 Go語言中型別轉換用的比較少，它要原本兩個不同型別支援互轉才行，如浮點型轉整型等。

　　 如下示例，將整形轉換為浮點數：

package main

import (
	"fmt"
)

func main() {
	var (
		intNum   int16
		floatNum float64
	)
	intNum = 10
	floatNum = float64(intNum)
	fmt.Printf("型別：%T \n值:%v", floatNum, floatNum)
	// 型別：float64 
	// 值:10
}

相關文章