go語言有哪些資料型別

int8、int16、int32、int64

uint8、uint16、uint32、uint64

uint8 對應 byte 型
int16 對應 C 語言中的 short 型
int64 對應 C 語言中的 long 型

1.在使用 int 和 uint 型別時，不能假定它是 32 位或 64 位的整型，而是考慮 int 和 uint 可能在不同平臺上的差異
2.獲取物件的長度的內建 len() 函數返回的長度可以根據不同平臺的位元組長度進行變化
3.實際使用中，切片或 map 的元素數量等都可以用 int 來表示
4.在涉及到二進位制傳輸，讀寫檔案的結構描述時，為了保持檔案的結構不會受到不同編譯目標平臺位元組長度的影響，不要使用 int 和 uint

v := 0b00101101， 代表二進位制的 101101，相當於十進位制的 45
v := 0o377，代表八進位制的 377，相當於十進位制的 255
v := 0x1p-2，代表十六進位制的 1 除以 2²，也就是 0.25

v := 123_456 表示 v 的值等於 123456。

package main

import "fmt"

func main() {
    // 定義十進位制數
    var a int = 10
    fmt.Printf("%d \n", a) // 預留位置 %d 表示使用十進位制顯示為 10
    fmt.Printf("%b \n", a) // 預留位置 %b 表示使用二進位制顯示為 1010

    // 定義八進位制數，需要以 0 開頭
    var b int = 077
    fmt.Printf("%o \n", b) // 預留位置 %o 表示使用八進位制顯示為 77

    // 定義十六進位制數，需要以 0x 開頭
    var c int = 0xff
    fmt.Printf("%x \n", c) // 預留位置 %x 表示使用十六進位制顯示為 ff，小寫字母顯示
    fmt.Printf("%X \n", c) // 預留位置 %X 表示使用十六進位制顯示為 FF，大寫字母顯示
}

float32 的浮點數的最大範圍約為 3.4e38，可以使用常數定義：math.MaxFloat32
float64 的浮點數的最大範圍約為 1.8e308，可以使用一個常數定義：math.MaxFloat64
列印浮點數時，可以使用 fmt 包配合 %f

package main
import (
    "fmt"
    "math"
)
func main() {
    fmt.Printf("%f\n", math.Pi)
    fmt.Printf("%.2f\n", math.Pi)
}

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

1.布林型資料只有 true 和 false 兩個值,布林型別變數的預設值為 false。
2.Go 語言中不允許將整型強制轉換為布林型.
3.布林型無法參與數值運算，也無法與其他型別進行轉換

package main

import "fmt"

func main() {
    // 使用 雙引號 定義 單行字串 變數
    s1 := "hello" //定義英文字串
    s2 := "你好"    // 可以識別非 ASCII 碼，預設支援 utf-8 編碼

    // 使用 反引號 定義 多行字串 變數
    s3 := `
11111
22222   // 多行字串裡的雙斜槓也表示註釋
33333
`

    // 使用 單引號 定義 單個字元 變數
    s4 := 'h'

    fmt.Println("\n單行字串01", s1)
    fmt.Println("\n單行字串02", s2)
    fmt.Println("\n多行字串", s3)
    fmt.Println("\n字元定義", s4)
}

package main

import (
    "fmt"
)

func main() {
    // 跳脫符的使用
    fmt.Println("\n# 跳脫符的使用 str := \"c:\\go\"")
}

package main

import (
    "fmt"
    "strings"
)

// 字串操作
func main() {
    // 字串求長度
    s3 := "zhongguojueqi"
    fmt.Println("\n字串-求長度: ", len(s3))
    
    // 字串拼接
    s4 := "nihaoshijie"
    fmt.Println("\n字串-拼接01: ", s3+s4)
    
    s5 := fmt.Sprintf("%s---%s", s3, s4)
    fmt.Println("\n字串-拼接02: ", s5)
    
    // 字串分割
    s6 := strings.Split(s3, "o")
    fmt.Println("\n字串-分割: ", s6)
    
    // 字串包含判斷
    s7 := strings.Contains(s3, "o")
    fmt.Println("\n字串-包含判斷01: ", s7)
    fmt.Println("\n字串-包含判斷02: ", strings.Contains(s3, "o"))
    
    // 字串字首， 字尾判斷
    fmt.Println("\n字串-字首判斷: ", strings.HasPrefix(s3, "zhong"))
    fmt.Println("\n字串-字尾判斷: ", strings.HasSuffix(s3, "qi"))
    
    // 字串索引查詢
    fmt.Println("\n字串-索引查詢-第一個字元 o 的索引: ", strings.Index(s3, "o"))
    fmt.Println("\n字串-索引查詢-最後一個字元 o 的索引: ", strings.LastIndex(s3, "o"))
    
    // 字串-join操作
    s8 := []string{"aaa", "bbb", "ccc", "ddd"}
    fmt.Println("\n字串-join 操作: ", strings.Join(s8, " + "))
}

func runeDemo01() { // 字元定義
    a := '中'         // 預設識別為 rune 型別的字元變數
    b := "中"         // 定義一個字串
    var c byte = 'a' // 定義一個byte型別字元
    var d rune = 'a' // 定義一個rune型別字元
    fmt.Println(a, b)
    fmt.Printf("%v,%T\n", c, c)
    fmt.Printf("%v,%T\n", d, d)
}

// 字串遍歷-traversalString
package main

import (
    "fmt"
)

func traversalString01() {
    s := "hello世界"
    for i := 0; i < len(s); i++ { // 中英文使用 for迴圈加 len() 方法遍歷迴圈，但遇到中文會有亂碼
      fmt.Printf("%v(%c) ", s[i], s[i])
    }
    fmt.Println()
    fmt.Println([]byte(s))
}
-----------------------
104(h) 101(e) 108(l) 108(l) 111(o) 228(ä) 184(¸) 150() 231(ç) 149() 140()
-----------------------

package main

import (
    "fmt"
)

// 遍歷字串 traversalString
func traversalString02() {
    s := "hello世界"
    fmt.Println()
    for _, r := range s { // 按照 rune 型別遍歷
        fmt.Printf("%v(%c) ", r, r)
    }
    fmt.Println()
    fmt.Println([]rune(s))

}
-----------------------
104(h) 101(e) 108(l) 108(l) 111(o) 19990(世) 30028(界)
-----------------------

1.因為 UTF8 編碼下一個中文漢字由 3~4 個位元組組成，所以我們不能簡單的按照位元組去遍歷一個包含中文的字串，否則就會出現上面輸出中第一行的結果
2.字串底層是一個 byte 陣列，所以可以和 []byte 型別相互轉換
3.字串是不能修改的 字串是由 byte 位元組組成，所以字串的長度是 byte 位元組的長度
4.rune 型別用來表示 utf8 字元，一個 rune 字元由一個或多個 byte 組成。

func changeString() {
    s1 := "big"
    // 強制型別轉換
    byteS1 := []byte(s1)
    byteS1[0] = 'p'
    fmt.Println(string(byteS1))

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

T(表示式)

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