go语言基本数据类型

Go 是一种强类型语言。 这意味着你声明的每个变量都绑定到特定的数据类型，并且只接受与此类型匹配的值。

Go 有四类数据类型：

• 基本类型：数字、字符串和布尔值
• 聚合类型：数组和结构
• 引用类型：指针、切片、映射、函数和通道
• 接口类型：接口

在此模块中，我们仅介绍基本类型。 如果你不知道其他类型是什么，请不要担心。 我们将在后续模块中进行介绍。

首先，我们一起浏览数值的数据类型。

一般来说，定义整数类型的关键字是 int。 但 Go 还提供了 int8、int16、int32 和 int64 类型，其大小分别为 8、16、32 或 64 位的整数。 使用 32 位操作系统时，如果只是使用 int，则大小通常为 32 位。 在 64 位系统上，int 大小通常为 64 位。 但是，此行为可能因计算机而不同。 可以使用 uint。 但是，只有在出于某种原因需要将值表示为无符号数字的情况下，才使用此类型。 此外，Go 还提供 uint8、uint16、uint32 和 uint64 类型。

大多数情况下，你将使用 int，但需要了解其他整数类型，因为在 Go 中，int 与 int32 不同，即使整数的自然大小为 32 位也是如此。 换句话说，需要强制转换时，你需要进行显式转换。 如果尝试在不同类型之间执行数学运算，将会出现错误。 例如，假定你具有下面的代码：

var integer16 int16 = 127
var integer32 int32 = 32767
fmt.println(integer16 + integer32)

运行该程序时，你会收到以下错误：

输出

invalid operation: integer16 + integer32 (mismatched types int16 and int32)

package main

import "fmt"

func main() {
    // 无符号整形，默认值都是0
    var u8 uint8
    var u16 uint16
    var u32 uint32
    var u64 uint64
    fmt.Printf("u8: %d, u16: %d, u32: %d, u64: %dn", u8, u16, u32, u64) // 默认值都为0
    u8 = 255
    u16 = 65535
    u32 = 4294967295
    u64 = 18446744073709551615
    fmt.Printf("u8: %d, u16: %d, u32: %d, u64: %dn", u8, u16, u32, u64)

    // 整型
    var i8 int8
    var i16 int16
    var i32 int32
    var i64 int64
    fmt.Printf("i8: %d, i16: %d, i32: %d, i64: %dn", i8, i16, i32, i64) // 默认值都为0
    i8 = 127
    i16 = 32767
    i32 = 2147483647
    i64 = 9223372036854775807
    fmt.Printf("i8: %d, i16: %d, i32: %d, i64: %dn", i8, i16, i32, i64)

    // int 型，取值范围32位系统为 int32，64位系统为 int64，取值相同但为不同类型
    var i int
    //i = i32 // 报错，编译不通过，类型不同
    //i = i64 // 报错，编译不通过，类型不同
    i = -9223372036854775808
    fmt.Println("i: ", i)

    // 浮点型，f32精度6位小数，f64位精度15位小数
    var f32 float32
    var f64 float64
    fmt.Printf("f32: %f, f64: %fn", f32, f64) // 默认值都为 0.000000
    f32 = 1.12345678
    f64 = 1.12345678901234567
    fmt.Printf("f32: %v, f64: %vn", f32, f64) // 末位四舍五入，输出：f32: 1.1234568, f64: 1.1234567890123457

    // 复数型
    var c64 complex64
    var c128 complex128
    fmt.Printf("c64: %v, c128: %vn", c64, c128) // 实数、虚数的默认值都为0
    c64 = 1.12345678 + 1.12345678i
    c128 = 2.1234567890123456 + 2.1234567890123456i
    fmt.Printf("c64: %v, c128: %vn", c64, c128) // 输出：c64: (1.1234568+1.1234568i), c128: (2.1234567890123457+2.1234567890123457i)

    // 字符型
    var b byte                                       // uint8 别名
    var r1, r2 rune                                  // uint16 别名
    fmt.Printf("b: %v, r1: %v, r2: %vn", b, r1, r2) // 默认值为0
    b = 'a'
    r1 = 'b'
    r2 = '字'
    fmt.Printf("b: %v, r1: %v, r2: %vn", b, r1, r2) // 输出：b: 97(ASCII表示的数), r1: 98(utf-8表示的数), r2: 23383 (utf-8表示的数)

    b = u8
    r1 = i32
    fmt.Printf("b: %v, r1: %vn", b, r1) // 输出：b: 255, r1: 2147483647

    // 指针地址
    var p uintptr
    fmt.Printf("p: %vn", p) // 默认值为0
    p = 18446744073709551615 // 64位系统最大值
    //p = 18446744073709551616 // 报错：超出最大值
    fmt.Printf("p: %vn", p)

}

Go语言提供了两种精度的浮点数 float32 和 float64。
这些浮点数类型的取值范围可以从很微小到很巨大。浮点数取值范围的极限值可以在 math 包中找到：
常量 math.MaxFloat32 表示 float32 能取到的最大数值，大约是 3.4e38；
常量 math.MaxFloat64 表示 float64 能取到的最大数值，大约是 1.8e308；
float32 和 float64 能表示的最小值分别为 1.4e-45 和 4.9e-324。
一个 float32 类型的浮点数可以提供大约 6 个十进制数的精度，而 float64 则可以提供约 15 个十进制数的精度，
通常应该优先使用 float64 类型，因为 float32 类型的累计计算误差很容易扩散，并且 float32 能精确表示的正整数并不是很大。

用 Printf 函数打印浮点数时可以使用“%f”来控制保留几位小数

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

布尔类型仅可能有两个值：true 和 false。 你可以使用关键字 bool 声明布尔类型。

在 Go 中，关键字 string 用于表示字符串数据类型。 若要初始化字符串变量，你需要在双引号（"）中定义值。 单引号（'）用于单个字符。 Go 语言默认编码都是 UTF-8。

package main

import "fmt"

func main() {
    var str1 string // 默认值为空字符串 ""
    str1 = `hello world`
    str2 := "你好世界"

    str := str1 + " " + str2 // 字符串连接
    fmt.Println(str1)
    fmt.Println(str2)
    fmt.Println(str) // 输出：hello world 你好世界

    // 遍历字符串
    l := len(str)
    for i := 0; i < l; i++ {
        chr := str[i]
        fmt.Println(i, chr) // 输出字符对应的编码数字
    }
}

有时，你需要对字符进行转义。 为此，在 Go 中，请在字符之前使用反斜杠 ()。 例如，下面是使用转义字符的最常见示例：

• n：新行
• r：回车符
• t：一个制表位
• '：单引号
• "：双引号
• \：反斜杠

到目前为止，几乎每次声明变量时，都使用值对其进行了初始化。 但与在其他编程语言中不同的是，在 Go 中，如果你不对变量初始化，所有数据类型都有默认值。 此功能非常方便，因为在使用之前，你无需检查变量是否已初始化。

下面列出了我们目前浏览过类型的几个默认值：

• int 类型的 0（及其所有子类型，如 int64）
• float32 和 float64 类型的 +0.000000e+000
• bool 类型的 false
• string 类型的空值