速战速决 go - go 基础: 基本数据类型,数字类型,字符串类型,字符串和数字类型的转换,字符串的格式化,枚举类型,类型别名,自定义类型

速战速决 go https://github.com/webabcd/GoSample

作者 webabcd

示例如下:

basic/datatype.go

// go 基础 - 基本数据类型(数字类型,字符串类型,字符串和数字类型的转换,字符串的格式化,枚举类型,类型别名,自定义类型)

package basic

import (
        "fmt"
        "math"
        "reflect"
        "strconv"
        "strings"
)

func DataTypeSample() {
        dataType_sample1()
        dataType_sample2()
        dataType_sample3()
        dataType_sample4()
        dataType_sample5()
        dataType_sample6()
}

// 数字类型
func dataType_sample1() {
        // int、int8、int16、int32、int64, uint、uint8、uint16、uint32、uint64(其中的 int 和 uint 是占 32 位还是占 64 位,要看 cpu 是 32 位的还是 64 位的)
        // float32、float64
        // bool(false, true)

        // 格式化打印
        fmt.Printf("%.2f\n", math.Pi) // 3.14

        // 整型('\x..' 以十六进制的方式定义整型)
        var a, b uint8 = 97, '\x61'
        // byte 类型(表示一个字节)其实就是 uint8 类型
        var c, d byte = 97, '\x61'
        // %d 整型,%x 十六进制, %c 字符
        fmt.Printf("%d, %d, %x, %x, %c, %c, %d, %d, %x, %x, %c, %c\n", a, b, a, b, a, b, c, d, c, d, c, d) // 97, 97, 61, 61, a, a, 97, 97, 61, 61, a, a

        var e int32 = '\u738b'
        // rune 类型(表示一个 unicode 编码)其实就是 int32 类型
        var f rune = '\u738b'
        // %d 整型,%x 十六进制, %c 字符
        fmt.Printf("%d, %x, %c,%d, %x, %c\n", e, e, e, f, f, f) // 29579, 738b, 王, 29579, 738b, 王

        // 通过 complex() 定义数学中的复数(由实数部分和虚数部分组成)
        i := complex(3.14, 0)   // 实数部分 3.14,虚数部分 0
        j := complex(3.14, 1.2) // 实数部分 3.14,虚数部分 1.2
        k := i + j              // 实数部分和实数部分相加减,虚数部分和虚数部分相加减
        fmt.Println(i, j, k)    // (3.14+0i) (3.14+1.2i) (6.28+1.2i)
        // real() - 取复数的实数部分
        // imag() - 取复数的虚数部分
        fmt.Println(real(k), imag(k)) // 6.28 1.2

        var l int               // 默认值是 0
        var m float32           // 默认值是 0
        var n bool              // 默认值是 false
        var o string            // 默认值是空字符串
        fmt.Println(l, m, n, o) // 0 0 false
}

// 字符串类型
func dataType_sample2() {
        var a = "webabcd"
        // 定义一个字符,实际上就是一个整型
        var b = 'a'
        // 通过 + 做字符串的拼接
        var c = a + "_wanglei"
        // %d 整型,%x 十六进制, %c 字符, %s 字符串
        // 字符串中的字符可以通过 [] 获取
        fmt.Printf("%s, %c, %c, %c, %d, %x, %s\n", a, a[0], a[len(a)-1], b, b, b, c) // webabcd, w, d, a, 97, 61, webabcd_wanglei

        // 通过 `` 定义的字符串会保留换行,且转义符无效
        var d = `abc
  ijk
    xyz
\r\n`
        fmt.Println(d)

        // 判断字符串是否相同(0 代表相同)
        fmt.Println(strings.Compare("abc", "abc")) // 0
        // 判断字符串是否相同(忽略大小写)
        fmt.Println(strings.EqualFold("ABC", "abc")) // true
}

// 字符串和数字类型的转换,字符串的格式化
func dataType_sample3() {
        // int32 类型转换为 float32 类型
        var a int32 = 10
        var b = float32(a)
        fmt.Println(reflect.TypeOf(a), reflect.TypeOf(b)) // int32 float32

        // int 和 string 相互转换
        var c int64 = 97
        var d = strconv.FormatInt(c, 10)       // int64 按十进制转为字符串
        var e = strconv.FormatInt(c, 16)       // int64 按十六进制转换为字符串
        var f, _ = strconv.ParseInt(d, 10, 32) // 字符串按十进转换为 int32(最后一个参数表示转换后的 int 的位数)
        var g, _ = strconv.ParseInt(e, 16, 64) // 字符串按十六进制转换为 int64(最后一个参数表示转换后的 int 的位数)
        fmt.Println(c, d, e, f, g)             // 97 97 61 97 97

        // int 和 float 相互转换
        var h = math.Pi
        var i = strconv.FormatFloat(h, 'f', 4, 64) // float64 转换为字符串,保留 4 位小数(四舍五入)
        j, _ := strconv.ParseFloat(i, 32)          // 字符串转换为 float32(最后一个参数表示转换后的 float 的位数)
        fmt.Println(h, i, j)                       // 3.141592653589793 3.1416 3.1415998935699463

        // 通过 fmt.Sprintf 返回格式化后的字符串(注:fmt.Sprintf() 是不会打印的,只是返回格式化后的字符串)
        var k = fmt.Sprintf("%.2f", math.Pi)
        fmt.Println(k) // 3.14

        // %% - 输出 %
        // %d - 十进制
        // %b - 二进制
        // %o - 八进制
        // %x - 十六进制(小写)
        // %X - 十六进制(大写)
        // %c - 字符
        // %s - 字符串
        // %f - 浮点型
        // %v - 按值的方式输出(另外还有 %+v 和 %#v 请参见:oop/struct1.go)
        // %T - 数据类型
        // %p - 地址
        var l = fmt.Sprintf("%%, %d, %b, %o, %x, %X, %c, %s, %.2f, %v, %T, %p", 'z', 'z', 'z', 'z', 'z', 'z', "z", 3.14159, [3]int{1, 2, 3}, [3]int{1, 2, 3}, &a)
        fmt.Println(l) // %, 122, 1111010, 172, 7a, 7A, z, z, 3.14, [1 2 3], [3]int, 0xc000014118
}

// 枚举类型
func dataType_sample4() {
        // go 没有枚举类型,但是可以通过 const 模拟一个枚举
        const (
                a1 = 10
                a2 = "hello"
        )

        // iota 只能在 const 中使用,下面的枚举会从 0 开始(如果想从 1 开始,那就 iota + 1)
        const (
                b1 = iota // 0
                b2        // 1
                b3        // 2
        )

        // iota 也能用来实现 flag 类型的枚举
        const (
                c1 = 1 << iota // 1 左移 0 位,即 1
                c2             // 1 左移 1 位,即 2
                c3             // 1 左移 2 位,即 4
                c4             // 1 左移 3 位,即 8
        )

        fmt.Println(a1, a2, b1, b2, b3, c1, c2, c3, c4) // 10 hello 0 1 2 1 2 4 8
}

// 类型别名
func dataType_sample5() {
        // 定义类型别名(MyType 和 int32 是同一类型)
        type MyType = int32
        // 使用类型别名
        var x MyType = 100
        fmt.Println(x, reflect.TypeOf(x)) // 100 int32
}

// 自定义类型
func dataType_sample6() {
        // 定义自定义类型(MyType 和 int32 不是同一类型)
        type MyType int32
        var x MyType = 100
        // 因为自定义类型与原类型不是同一个类型,所以下面这句是会报错的
        // var y int = x
        // 自定义类型与原类型之间可以像下面这样做转换
        var y int = int(x)
        fmt.Printf("%v, %v, %T, %T", x, y, x, y) // 100, 100, basic.MyType, int
}

速战速决 go https://github.com/webabcd/GoSample

作者 webabcd