2-2. 数据类型

1 数据类型

Go 语言按类别有以下几种数据类型：

• 字符串格式化

  

  • %v是万能的

  • %T查看数据类型,类似reflect.typeOf()

  • 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

    普通占位符 占位符 说明 举例 输出 %v 相应值的默认格式。 Printf("%v", people) {zhangsan}， %+v 打印结构体时，会添加字段名 Printf("%+v", people) {Name:zhangsan} %#v 相应值的Go语法表示 Printf("#v", people) main.Human{Name:"zhangsan"} %T 相应值的类型的Go语法表示 Printf("%T", people) main.Human %% 字面上的百分号，并非值的占位符 Printf("%%") % 布尔占位符 占位符 说明 举例 输出 %t true 或 false。 Printf("%t", true) true 整数占位符 占位符 说明 举例 输出 %b 二进制表示 Printf("%b", 5) 101 %c 相应Unicode码点所表示的字符 Printf("%c", 0x4E2D) 中 %d 十进制表示 Printf("%d", 0x12) 18 %o 八进制表示 Printf("%d", 10) 12 %q 单引号围绕的字符字面值，由Go语法安全地转义 Printf("%q", 0x4E2D) '中' %x 十六进制表示，字母形式为小写 a-f Printf("%x", 13) d %X 十六进制表示，字母形式为大写 A-F Printf("%x", 13) D %U Unicode格式：U+1234，等同于 "U+%04X" Printf("%U", 0x4E2D) U+4E2D 浮点数和复数的组成部分（实部和虚部） 占位符 说明 举例 输出 %b 无小数部分的，指数为二的幂的科学计数法， 与 strconv.FormatFloat 的 'b' 转换格式一致。例如 -123456p-78 %e 科学计数法，例如 -1234.456e+78 Printf("%e", 10.2) 1.020000e+01 %E 科学计数法，例如 -1234.456E+78 Printf("%e", 10.2) 1.020000E+01 %f 有小数点而无指数，例如 123.456 Printf("%f", 10.2) 10.200000 %g 根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出 Printf("%g", 10.20) 10.2 %G 根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出 Printf("%G", 10.20+2i) (10.2+2i) 字符串与字节切片 占位符 说明 举例 输出 %s 输出字符串表示（string类型或[]byte) Printf("%s", []byte("Go语言")) Go语言 %q 双引号围绕的字符串，由Go语法安全地转义 Printf("%q", "Go语言") "Go语言" %x 十六进制，小写字母，每字节两个字符 Printf("%x", "golang") 676f6c616e67 %X 十六进制，大写字母，每字节两个字符 Printf("%X", "golang") 676F6C616E67 指针 占位符 说明 举例 输出 %p 十六进制表示，前缀 0x Printf("%p", &people) 0x4f57f0 %4s 表示输出当前字符串宽度: ("|%4s|,|%6s|", "aa", "dd") ==> | aa|,| dd|

  • 示例

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120

    // Go 在传统的`printf` 中对字符串格式化提供了优异的支持。 // 这里是一些基本的字符串格式化的人物的例子。 package main import "fmt" import "os" type point struct { x, y int } func main() { // Go 为常规 Go 值的格式化设计提供了多种打印方式。例 // 如，这里打印了 `point` 结构体的一个实例。 p := point{1, 2} fmt.Printf("%v\n", p) // 输出：{1 2} // 如果值是一个结构体，`%+v` 的格式化输出内容将包括 // 结构体的字段名。 fmt.Printf("%+v\n", p) // 输出：{x:1 y:2} // `%#v` 形式则输出这个值的 Go 语法表示。例如，值的 // 运行源代码片段。 fmt.Printf("%#v\n", p) // 输出：main.point{x:1, y:2} // 需要打印值的类型，使用 `%T`。 fmt.Printf("%T\n", p) // 输出：main.point // 格式化布尔值是简单的。 fmt.Printf("%t\n", true) // 输出：true // 格式化整形数有多种方式，使用 `%d`进行标准的十进 // 制格式化。 fmt.Printf("%d\n", 123) // 输出：123 // 这个输出二进制表示形式。 fmt.Printf("%b\n", 14) // 输出：1110 // 这个输出给定整数的对应字符。 fmt.Printf("%c\n", 33) // 输出：! // `%x` 提供十六进制编码。 fmt.Printf("%x\n", 456) // 输出：1c8 // 对于浮点型同样有很多的格式化选项。使用 `%f` 进 // 行最基本的十进制格式化。 fmt.Printf("%f\n", 78.9) // 输出：78.900000 // `%e` 和 `%E` 将浮点型格式化为（稍微有一点不 // 同的）科学技科学记数法表示形式。 fmt.Printf("%e\n", 123400000.0) // 输出：1.234000e+08 fmt.Printf("%E\n", 123400000.0) // 输出：1.234000E+08 // 使用 `%s` 进行基本的字符串输出。 fmt.Printf("%s\n", "\"string\"") // 输出："string" // 像 Go 源代码中那样带有双引号的输出，使用 `%q`。 fmt.Printf("%q\n", "\"string\"") // 输出："\"string\"" // 和上面的整形数一样，`%x` 输出使用 base-16 编码的字 // 符串，每个字节使用 2 个字符表示。 fmt.Printf("%x\n", "hex this") // 输出：6865782074686973 // 要输出一个指针的值，使用 `%p`。 fmt.Printf("%p\n", &p) // 输出：0x42135100 // 当输出数字的时候，你将经常想要控制输出结果的宽度和 // 精度，可以使用在 `%` 后面使用数字来控制输出宽度。 // 默认结果使用右对齐并且通过空格来填充空白部分。 fmt.Printf("|%6d|%6d|\n", 12, 345) // 输出：| 12| 345| // 你也可以指定浮点型的输出宽度，同时也可以通过 宽度. // 精度 的语法来指定输出的精度。 fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45) // 输出：| 1.20| 3.45| // 要左对齐，使用 `-` 标志。 fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45) // 输出：|1.20 |3.45 | // 你也许也想控制字符串输出时的宽度，特别是要确保他们在 // 类表格输出时的对齐。这是基本的右对齐宽度表示。 fmt.Printf("|%6s|%6s|\n", "foo", "b") // 输出：| foo| b| // 要左对齐，和数字一样，使用 `-` 标志。 fmt.Printf("|%-6s|%-6s|\n", "foo", "b") // 输出：|foo |b | // 到目前为止，我们已经看过 `Printf`了，它通过 `os.Stdout` // 输出格式化的字符串。`Sprintf` 则格式化并返回一个字 // 符串而不带任何输出。 s := fmt.Sprintf("a %s", "string") fmt.Println(s) // 输出：a string // 你可以使用 `Fprintf` 来格式化并输出到 `io.Writers` // 而不是 `os.Stdout`。 fmt.Fprintf(os.Stderr, "an %s\n", "error") // 输出：an error }

1.1 字符串类型

1
2
3
4
5
6

a := "hello"
unsafe.Sizeof(a)
/*
输出结果为：16
字符串类型在 go 里是个结构, 包含指向底层数组的指针和长度,这两部分每部分都是 8 个字节，所以字符串类型大小为 16 个字节。
*/

• 关键字string,用"“或者``反引号表示(’““支持控制符号,反引号所有的都会原样输出)
• 占位符 ‘%s
• 万能占位符’%v’

1.1.1 字符串常用操作

• 长度 **len(str) ** ,返回一个int, 返回的是字节的长度, 中文的字节长3

• 拼接: 使用**+或者fmt.Sprintf()**

• 分割: strings.Split(str,‘分割标识’), 返回一个切片

• 是否存在:

1. 字符串转数字

• strconv.Atoi：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var str = "111"
    i, _ := strconv.Atoi(str)
    fmt.Printf("%d\n", i) // 输出：111
}

2. 大小写规则转换 strings.ToUpperSpecial：将字符串s中的所有字符修改为其大写格式，优先使用c中的规则进行转换 strings.ToLowerSpecial：将字符串s中的所有字符修改为其小写格式，优先使用c中的规则进行转换 strings.ToTitleSpecial：将字符串s中的所有字符修改为其Title格式，优先使用c中的规则进行转换 c规则说明，以下列语句为例： unicode.CaseRange{‘A’, ‘Z’, [unicode.MaxCase]rune{3, -3, 0}}

• 其中 ‘A’, ‘Z’ 表示此规则只影响 ‘A’ 到 ‘Z’ 之间的字符。
• 其中[unicode.MaxCase]rune数组表示：
• 当使用 ToUpperSpecial 转换时，将字符的 Unicode 编码与第一个元素值（3）相加
• 当使用 ToLowerSpecial 转换时，将字符的 Unicode 编码与第二个元素值（-3）相加
• 当使用 ToTitleSpecial 转换时，将字符的 Unicode 编码与第三个元素值（0）相加

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package main

import (
    "fmt"
    "strings"
    "unicode"
)

func main() {
    // 定义转换规则
    var _MyCase = unicode.SpecialCase{
        // 将半角逗号替换为全角逗号，ToTitle 不处理
        unicode.CaseRange{',', ',',
            [unicode.MaxCase]rune{'，' - ',', '，' - ',', 0}},
        // 将半角句号替换为全角句号，ToTitle 不处理
        unicode.CaseRange{'.', '.',
            [unicode.MaxCase]rune{'。' - '.', '。' - '.', 0}},
        // 将 ABC 分别替换为全角的 ＡＢＣ、ａｂｃ，ToTitle 不处理
        unicode.CaseRange{'A', 'C',
            [unicode.MaxCase]rune{'Ａ' - 'A', 'ａ' - 'A', 0}},
    }

    s := "ABCDEF,abcdef."
    us := strings.ToUpperSpecial(_MyCase, s)
    fmt.Printf("%q\n", us) // 输出："ＡＢＣDEF，ABCDEF。"
    ls := strings.ToLowerSpecial(_MyCase, s)
    fmt.Printf("%q\n", ls) // 输出："ａｂｃdef，abcdef。"
    ts := strings.ToTitleSpecial(_MyCase, s)
    fmt.Printf("%q\n", ts) // 输出："ABCDEF,ABCDEF."
}

1.2 字符串原理

• 单引号是字符,双引号是字符串

• 字符串的底层就是一个byte数组,所以可以和 []byte 类型互相转换

• 字符串是由byte字节组成的,所以字符串的长度是byte字节的长度

• rune类型用来表示utf8字符,一个rune字符由1个或多个byte组成

  • 对包含中文的字符串排序

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

    package main import ( "fmt" ) func main() { str := "ABCDEFGH你好" strRune := []rune(str) for i:=0 ; i<len(strRune)/2;i++{ item := strRune[i] strRune[i] = strRune[len(strRune)-1-i] strRune[len(strRune)-1-i] = item } fmt.Println(len(str)) // 14 fmt.Println(strRune) // [22909 20320 72 71 70 69 68 67 66 65] fmt.Println(string(strRune)) //好你HGFEDCBA }

• 扩展

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

  //1、位： 数据存储的最小单位。每个二进制数字0或者1就是1个位； //2、字节： 8个位构成一个字节；即：1 byte (字节)= 8 bit(位)；      1 KB = 1024 B(字节)；      1 MB = 1024 KB;   (2^10 B)      1 GB = 1024 MB;  (2^20 B)      1 TB = 1024 GB;   (2^30 B) //3、字符：      a、A、中、+、*、の......均表示一个字符； unicode,万国码,32位既4个字节表示一个字符;      一般 utf-8 编码下，一个汉字 字符 占用 3 个 字节；      一般 gbk 编码下，一个汉字  字符  占用 2 个 字节； //4、字节和字符： 字节是计算机传输数据的格式，供计算识别的。 字符是供人类观看的内容 //5、编码： 编码（encoding）:把…译成密码。==》二进制 解码（decoding）：破译(尤指密码) ==》破解密码成可以看的懂的 //6.编码格式： 字节和字符之间转换，参照的规则就是编码格式。 Unicode 编码共有三种具体实现，分别为utf-8,utf-16,utf-32，其中utf-8占用一到四个字节，utf-16占用二或四个字节，utf-32占用四个字节。 Unicode码的前128个字符就是ASCII码，之后是ASCII码的扩展码。

1.3 数字类型

• Go 也有基于架构的类型，例如：int、uint 和 uintptr。

• 所有整数初始化为0,所有浮点数初始化为0.0,布尔类型初始化为 false

1.3.1 浮点型

1.3.2 其他数字类型

以下列出了其他更多的数字类型：