Go语言|基本数据类型

基本类型

虽然从底层而言，所有的数据都是由比特组成，但计算机一般操作的是固定大小的数，如整数、浮点数、比特数组、内存地址等。进一步将这些数组织在一起，就可表达更多的对象，例如数据包、像素点、诗歌，甚至其他任何对象。Go语言提供了丰富的数据组织形式，这依赖于Go语言内置的数据类型。这些内置的数据类型，兼顾了硬件的特性和表达复杂数据结构的便捷性。

基本类型汇总

基本数据类型	长度(字节)	默认值	说明
bool	1	false
byte	1	0	uint8
rune	4	0	Unicode Code Point, int32
int, uint	4或8	0	32 或 64 位
int8, uint8	1	0	-128 ~ 127, 0 ~ 255，byte是uint8 的别名
int16, uint16	2	0	-32768 ~ 32767, 0 ~ 65535
int32, uint32	4	0	-21亿~ 21亿, 0 ~ 42亿，rune是int32 的别名
int64, uint64	8	0
float32	4	0.0
float64	8	0.0
complex64	8
complex128	16
uintptr	4或8		以存储指针的 uint32 或 uint64 整数

复杂数据类型	长度(字节)	默认值	说明
array			值类型
struct			值类型
string		""	UTF-8 字符串
slice		nil	引用类型
map		nil	引用类型
channel		nil	引用类型
interface		nil	接口
function		nil	函数

布尔类型

布尔型的值只可以是常量 true 或者 false
简单定义：

    var b bool = true

两个相同类型的值可以通过 == 或者 != 等比较运算符号来获得一个布尔类型的值。

布尔值并不会隐式转换为数字值0或1，反之亦然。必须使用一个显式的if语句辅助转换：

// 布尔类型转换为0或者1
func btoi(b bool) int{
    if b {
        return 1
    }
    return 0
}

// 数字转换为布尔类型
func itob(i int) bool { return i != 0 }

整形

Go语言中整形被分为三大类：int 、uint、uintptr
这三种类型的长度是跟据程序所在的操作系统来决定长度的：

• int 和 uint 在32位操作系统上，它们使用32位，4个字节，在64拉操作系统上，它们使用64位，8个字节。
• uintptr 的长度被设定为存储指针的 uint32 或 uint64 整数

int 和uint又被称为有符号整形和无符号整形
有符号整形：

• int8（-128 -> 127）
• int16（-32768 -> 32767）
• int32（-2,147,483,648 -> 2,147,483,647）
• int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）

无符号整形：

• uint8（0 -> 255）
• uint16（0 -> 65,535）
• uint32（0 -> 4,294,967,295）
• uint64（0 -> 18,446,744,073,709,551,615）

用不同的进制来表示整数：
十进制：

    var Decimal int = 12

二进制：

    var Binary int = 0b1100

八进制：

    var Octal int = 0o14

十六进制：

    var Hexadecimal int = 0xc

用fmt.printf()函数进行输出：

    func main() {
        var Decimal int = 12
        var Binary int = 0b1100
        var Octal int = 0o14
        var Hexadecimal int = 0xCvar

        fmt.Printf("10进制数 %d 表示的是: %d \n", Decimal, Decimal)     //12
        fmt.Printf("2进制数 %b 表示的是: %d \n", Binary, Binary)           //12
        fmt.Printf("8进制数 %o 表示的是: %d \n", Octal, Octal)             //12
        fmt.Printf("16进制数 %X 表示的是: %d \n", Hexadecimal, Hexadecimal)    //12
    }

跟据上面的输出可以发现，在Go语言中使用二进制、八进制、十六进制 非常的方便，只需要在数字前面加上：0b、0o、0x 就可以使用。

---

补充：

fmt.Printf() 函数据的格式化功能：

%b 表示为二进制
%c 该值对应的unicode码值
%d 表示为十进制
%o 表示为八进制
%q 该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
%x 表示为十六进制，使用a-f
%X 表示为十六进制，使用A-F
%U 表示为Unicode格式：U+1234，等价于"U+%04X"
%E 用科学计数法表示
%f 用浮点数表示

浮点型

Go语言支持两种浮点型数：float32 和 float64。这两种浮点型数据格式遵循 IEEE 754标准 ：

• float32（+- 1e-45 -> +- 3.4 * 1e38），可以使用常量定义：math.MaxFloat32。
• float64（+- 5 1e-324 -> 107 1e308），可以使用一个常量定义：math.MaxFloat64。

浮点型的零值为 0.0 ，在进行除法运算的时候，浮点型的零值可以为分母并且不会报错，而整形的就会报错。

float32 精确到小数点后 7 位，float64 精确到小数点后 15 位。由于精确度的缘故，你在使用 == 或者 != 来比较浮点数时应当非常小心。你最好在正式使用前测试对于精确度要求较高的运算。也可以使用第三方包来完成这个操作。`go get github.com/shopspring/decimal

package main

func main() {
    var f float64 = 3.1415926
    fmt.Printf("保留两个位小数：%.2f",f)    //3.14
    fmt.Printf("保留两个位小数：%.3f",f)    //3.142
}

---

在日常使用中，我们经常通常都使用 float64 来来定义浮点类型，因为 math 包里面，几乎所有的方法，都支持 float64。
把float64 转换为 int 类型：

func IntFromFloat64(x float64) int {
    if math.MinInt32 <= x && x <= math.MaxInt32 { 
        whole, fraction := math.Modf(x)
        if fraction >= 0.5 {
            whole++
        }
        return int(whole)
    }
    panic(fmt.Sprintf("%g is out of the int32 range", x))
}

复数

复数分为：

    complex64 的实部和虚部为32位，
    complex128 的实部和虚部为64位。

复数的简单使用：

    var c1 complex64 = 5 + 10i
    fmt.Printf("The complex64 is: %v", c1)
    // 输出： 5 + 10i

---

函数 real(c) 和 imag(c) 可以分别获得相应的实数和虚数部分。

byte 和 rune 类型

组成每个字符串的元素叫做字符，通过遍厉字符串或者定义单个字符可以获取，定义字符时用 ' 包裹起来。

    var testRune := '国'
    var testByte := 'a'
    fmt.Printf("字符的类型为：%T",testRune)    //rune
    fmt.Printf("字符的类型为：%T",testRune)    //byte

使用中文或者一些特殊字符和Unicode编码的时候，一般都推荐定义为 rune 类型。

rune 类型为 int32 的别名
byte 类型为 uint8 的别名范围为 (0~255)

字符串

Go语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型（int、bool、float32、float64 等）一样。 Go 语言里的字符串的内部实现使用UTF-8编码。 字符串的值为双引号(")中的内容，可以在Go语言的源码中直接添加非ASCII码字符，例如：

    var str string = "hello，世界！”

字符串其实多个是byte 类型和 rune 类型放在一起的类型，也就是 string 类型。

---

比如上面输出的字符串hello ，在 ascii 编码表中，每个字母对应的编号是：104,101,108,108,111。
如果这样的话，我们就可以输出一组 []byte 数组，来看一下 string 的底层是什么结构。

    import (
        "fmt")

    func main() {
        var mystr01 string = "hello"
        var mystr02 [5]byte = [5]byte{104, 101, 108, 108, 111}
        fmt.Printf("mystr01: %s\n", mystr01)
        fmt.Printf("mystr02: %s", mystr02)
    }

输出的结果为：

    mystr01: hello
    mystr02: hello

上面这个例子就说明了 string 类型的底层就是由一组 byte 类型的数组组成的。
那么就可以通过数组的自带函数来获取字符串的长度：

    import (
        "fmt")

    func main() {
        var mystr string = "hello"
        fmt.Printf("mystr: %d\n", len(mystr))
        // 结果为：mystr: 5
    }

---

在Go 语言中，字符串之间可以直接通过 + 连接起来，例如：

    import (
        "fmt"
    )
    func main() {        
        s := "hel" + "lo," 
        s += "world!" 
        fmt.Println(s) 
        //输出 “hello, world!”
    }

在遇到字符串数组时，也可以使用 Go 语言封装好的方法 strings.Join() 或者使用字符缓冲 bytes.Buffer() 拼接都可以，并且效率也更高。

转义字符

转义字符 就是一类特殊字符，它们表示特殊的函意，可以用作辅助作用：

• \n：换行符
• \r：回车符
• \t：tab 键
• \u 或
• \U：Unicode 字符
• \：反斜杠自身

例如：

    import "fmt"

    func main() {
        str := "hello \n world"
        fmt.Println(str)
        // 输出：
        //hello
        // world
    }

多行字符

在定义字符串的时候，可以使用 反引号 进行包括，这样就可以进行多行字符串的编译了，例如：

    import "fmt"

    func main() {
        str := `hello world 
    你好，世界`
        fmt.Println(str)
    }
    // 输出：
    //hello world 
    //你好，世界

---

细节决定成败!
个人愚见，如有不对，恳请扶正!