golang学习笔记01——基本数据类型

基本类型

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

整型

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

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

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

• int

- 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
1
2
3
4

• uint

- uint8 取值范围：0 ~ 255
- uint16 取值范围：0 ~ 65,535
- uint32 取值范围：0 ~ 4,294,967,295
- uint64 取值范围：0 ~ 18,446,744,073,709,551,615
1
2
3
4

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

package main
import "fmt"
func main() {
        var Decimal int = 12	// 十进制
        var Binary int = 0b1100	// 二进制
        var Octal int = 0o14	// 八进制
        var Hexadecimal int = 0x0c	// 十六进制

        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
}
1
2
3
4
5
6
7
8
9
10
11
12
13

补充整型的输出格式化：

fmt.Printf() 函数据的格式化功能：
- %b 表示为二进制
- %c 该值对应的unicode码值
- %d 表示为十进制
- %o 表示为八进制
- %q 该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
- %x 表示为十六进制，使用a-f
- %X 表示为十六进制，使用A-F
- %U 表示为Unicode格式：U+1234，等价于"U+%04X"
- %E 用科学计数法表示
- %f 用浮点数表示
1
2
3
4
5
6
7
8
9
10
11

浮点型

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

- float32：最大值约 3.4e38，常量定义：math.MaxFloat32
- float64：最大值约 1.8e308，常量定义：math.MaxFloat64
1
2

• 浮点型的零值为 0.0 ，在进行除法运算的时候，浮点型的零值可以为分母并且不会报错，而整形的就会报错。
• float32 精确到小数点后 7 位，float64 精确到小数点后 15 位。由于精确度的缘故，你在使用 == 或者 != 来比较浮点数时应当非常小心。最好在正式使用前测试对于精确度要求较高的运算。也可以使用 第三方包 来完成这个操作
• 浮点数的保留位：

package main
import "fmt"
func main() {
    var f float64 = 3.1415926
    fmt.Printf("保留两位小数：%.2f",f)    //3.14
    fmt.Printf("保留两位小数：%.3f",f)    //3.142
}
1
2
3
4
5
6
7

• 在日常使用中，我们经常通常都使用 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))
}
1
2
3
4
5
6
7
8
9
10

byte 和 rune 类型

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

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

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

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

字符串

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

    var str string = "hello，世界！"
1

• 字符串其实多个是 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)
    }
1
2
3
4
5
6
7
8

输出的结果为

    mystr01: hello
    mystr02: hello
1
2

• 上面这个例子就说明了 string 类型的底层就是由一组 byte 类型的数组组成的。
• 在Go 语言中，字符串之间可以直接通过 + 连接起来，例如：

    import "fmt"
    func main() {        
        s := "hel" + "lo," 
        s += "world!" 
        fmt.Println(s) 
        //输出 “hello, world!”
    }
1
2
3
4
5
6
7

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

- \n：换行符
- \r：回车符
- \t：tab 键
- \u 或
- \U：Unicode 字符
- \：反斜杠自身
1
2
3
4
5
6