(Go) 3. 数据类型

一. 整型

 

注意: 内建len()函数返回的长度是int类型的,但究竟是int32还是int64要看系统的情况

切片或 map 的元素数量等都可以用int来表示。在涉及到二进制传输、读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用int和 uint。

数字字面量语法（Number literals syntax）

Go1.13版本之后引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字，例如：

v := 0b00101101， 代表二进制的 101101，相当于十进制的 45。

v := 0o377，代表八进制的 377，相当于十进制的 255。

v := 0x1p-2，代表十六进制的 1 除以 2²，也就是 0.25。

而且还允许我们用 _ 来分隔数字，比如说：v := 123_456 等于 123456。

我们可以借助fmt函数来将一个整数以不同进制形式展示。

package main

import "fmt"

func main() {
    // 十进制
    var a int = 10
    fmt.Printf("%d \n", a) // 10
    fmt.Printf("%b \n", a) // 以二进制输出 1010
    fmt.Printf("%o \n", a) // 以八进制输出 12
    fmt.Printf("%x \n", a) // 以十六进制输出 a
    fmt.Printf("%T \n", a) // 查看a的类型 int

    // 八进制  以0开头
    var b int = 077
    fmt.Printf("%o \n", b) // 77

    // 十六进制  以0x开头
    var c int = 0xff
    fmt.Printf("%x \n", c) // ff
    fmt.Printf("%X \n", c) // FF

    // 声明int8类型
    var d int8 = 22
    e := int8(33)
    fmt.Printf("%T \n", d) // int8
    fmt.Printf("%T \n", e) // int8
}

 

二. 浮点型

 打印浮点数时，可以使用%.2f来控制小数位数

诸如math.MaxFloat64等是常量

package main
import (
        "fmt"
        "math"
)
func main() {
    f1 := 1.23456  //默认是float64类型
    fmt.Printf("%T\n",f1)  // float64
    f2 := float32(1.2345)  // 强制设置成float32类型
    fmt.Printf("%T\n",f2)  // float32
    fmt.Printf("%f\n", math.Pi)    // 3.141593
    fmt.Printf("%.2f\n", math.Pi)  // 3.14
}

 

三. 布尔类型

布尔型数据只有true（真）和false（假）两个值。

注意：

1. 布尔类型变量的默认值为false。
2. Go 语言中不允许将整型强制转换为布尔型.
3. 布尔型无法参与数值运算，也无法与其他类型进行转换。 

    b1 := true
    var b2 bool // 默认是false
    fmt.Printf("%T\n",b1)  // bool
    fmt.Printf("%T value:%v\n",b2,b2)  // bool value:false

 

四. fmt总结

    var n = 100
    fmt.Printf("%T\n", n)
    fmt.Printf("%v\n", n) // 输出该变量的值
    fmt.Printf("%b\n", n)
    fmt.Printf("%d\n", n)
    fmt.Printf("%o\n", n)
    fmt.Printf("%x\n", n)
　　 fmt.Printf("%c\n",n)  // 转换成字符输出
    var s = "hello"
    fmt.Printf("字符串: %s\n", s)
    fmt.Printf("字符串: %v\n", s)
    fmt.Printf("字符串: %#v\n", s) // 字符串: "hello"  输出值的同时,加上其类型格式
    fmt.Printf("字符串: %#v\n", n) // 字符串: 100

五. 字符串

    var s1 = "你好" // 字符串
    var s2 = '我'  // 字符,输出结果为其在utf-8中的顺序的编号
    var s3 = `    
    你
    是
        猪
    ` // 反引号实现多行输出
    var s4 = `
    d:\n\c\d
    `  // 反引号中,转义符失效

    fmt.Printf("%s,%s,%s,%s\n", s1, s2, s3, s4)

字符串常用操作

    // len()
    s1 := "你好啊"
    fmt.Println(len(s1))                       // 9  len()返回的是字节长度
    fmt.Println(utf8.RuneCountInString("你好啊")) // 3  返回的是字符长度

    // 字符串拼接
    name := "alex"
    age := "55"
    total := name + age
    fmt.Println(total) // alex55
    ss1 := fmt.Sprintf("%s%s", name, age)
    fmt.Println(ss1) // alex55

    // 字符串分割
    ret := strings.Split("g:\\goProjects\\src\\go第5期\\day01", "\\") // 一个\是转义,两个\\代表一个\
    fmt.Println(ret)                                                // [g: goProjects src go第5期 day01]
    fmt.Printf("%T%s\n", ret)                                       //  []string

    // 包含
    fmt.Println(strings.Contains("我和你", "他")) // false
    fmt.Println(strings.Contains("我和你", "我")) // true

    // 前后缀
    fmt.Println(strings.HasPrefix("我和你", "我")) // true
    fmt.Println(strings.HasSuffix("我和你", "你")) // true

    // 索引
    fmt.Println(strings.Index("abcdabcd", "a"))     // 0   第一次出现
    fmt.Println(strings.LastIndex("abcdabcd", "a")) // 4   最后一次出现
    fmt.Println(strings.LastIndex("我和你", "你"))   // 6   最后一次出现,单位:字节

    // join
    fmt.Println(strings.Join(ret, "_")) // g:_goProjects_src_go第5期_day01
    // fmt.Println(strings.Join("[g: goProjects src go第5期 day01]", "_")) // 报错
    // fmt.Println(strings.Join('[g: goProjects src go第5期 day01]', "_")) // 报错

 

 六. 字符类型:  byte和rune类型

Go 语言的字符有以下两种：

• uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。
• rune类型，代表一个 UTF-8字符。

当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。

Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。

// 遍历字符串
func traversalString() {
    s := "hello沙河"
    for i := 0; i < len(s); i++ { //按byte遍历
        fmt.Printf("%v(%c) ", s[i], s[i])
    }
    fmt.Println() 
    for _, r := range s { //按rune遍历
        fmt.Printf("%v(%c) ", r, r)
    }
    fmt.Println()
}

结果

104(h) 101(e) 108(l) 108(l) 111(o) 230(æ) 178(²) 153() 230(æ) 178(²) 179(³) 
104(h) 101(e) 108(l) 108(l) 111(o) 27801(沙) 27827(河) 

 

七. 字符串修改

要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

    // 字符串修改
    s1 := "白萝卜"
    s2 := []rune(s1) // 把s1转换成可编辑的 []rune 类型
    s2[0] = '红'      // 通过索引来替换 []rune 类型数据的字符, 切记是''字符
    s3 := string(s2) // 再把s2转换成string类型
    fmt.Println(s3)
    fmt.Printf("%T %T", s2, s3) // []int32 string 说明[]rune根本上还是int32类型

    // 字符类型补充
    c1 := "红" 
    c2 := '红'
    c3 := "H"
    c4 := 'H'
    c5 := byte('H')  // 强制转换成byte类型,即uint8类型
    fmt.Printf("%T %T %T %T %T", c1, c2, c3, c4,c5) //string int32 string int32 uint8 说明单引号字符都是 []rune 类型的

    // 类型转换
    n := 10
    f := float64(n)
    fmt.Println(f)  // 10
    fmt.Printf("%T",f)  // float64

 

 

 

 

 

 

 

 

 

 

 

 

 

---  君子处其实，不处其华；治其内，不治其外   张居正  ----