刘沙河
bigox
2021-03-30
目录

数据类型

# 数据类型

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

序号 类型和描述
1 布尔型布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
2 数字类型整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
3 **字符串类型:**字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
4 派生类型: 指针类型（Pointer） /数组类型 /结构化类型(struct) / Channel 类型 / 函数类型 /切片类型 /接口类型（interface） /Map 类型

  • 字符串格式化

    img

    • %v是万能的

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

    • 普通占位符
占位符 说明 举例 输出
%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
      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

# 字符串类型

a := "hello"
unsafe.Sizeof(a)
/*
输出结果为：16
字符串类型在 go 里是个结构, 包含指向底层数组的指针和长度,这两部分每部分都是 8 个字节，所以字符串类型大小为 16 个字节。
*/
1
2
3
4
5
6
  • 关键字string,用""或者``反引号表示('""支持控制符号,反引号所有的都会原样输出)
  • 占位符 '%s
  • 万能占位符'%v'

# 字符串常用操作

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

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

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

  • 是否存在:

函数|返回值 作用
strconv 包：
Atoi(s string) (int, error) 字符串转整型
strings 包：
Count(s, substr string) int 计算子串substr在字符串s中出现的次数
Compare(a, b string) int 比较字符串大小
Contains(s, substr string) bool 判断字符串s中是否包含子串substr
ContainsAny(s, chars string) bool 判断字符串s中是否包含chars中的某个Unicode字符
ContainsRune(s string, r rune) bool 判断字符串s中是否包含rune型值为r的字符
Index(s, substr string) int 查找子串substr在字符串s中第一次出现的位置，如果找不到则返回 -1，如果substr为空，则返回 0
LastIndex(s, substr string) int 查找子串substr在字符串s中最后出现的位置
IndexRune(s string, r rune) int 查找rune型值为r的字符在字符串s中出现的起始位置
IndexAny(s, chars string) int 查找字符串chars中字符，在字符串s中出现的起始位置
LastIndexAny(s, chars string) int 查找字符串s中出现chars中字符的最后位置
LastIndexByte(s string, c byte) int 查找byte型字符c在字符串s中的位置
SplitN(s, sep string, n int) []string 以字符串sep为分隔符，将字符串s切分成n个子串，结果中不包含sep本身。如果sep为空则将s切分为 Unicode 字符列表，如果s中没有sep子串则整个s作为切片 []string 中的第一个元素返回。参数n表示最多切出几个子串，s超出切分大小时，超出部分不再切分。n超出切分子串个数时，返回实际切分子串数。如果n为 0，则返回 nil；如果n小于 0，则不限制切分个数，全部切分
SplitAfterN(s, sep string, n int) []string 以字符串sep为分隔符，将字符串s切分成n个子串，结果中包含sep本身。如果sep为空则将s切分为 Unicode 字符列表，如果s中没有sep子串则整个s作为切片 []string 中的第一个元素返回。参数n表示最多切出几个子串，s超出切分大小时，超出部分不再切分。n超出切分子串个数时，返回实际切分子串数。如果n为 0，则返回 nil；如果n小于 0，则不限制切分个数，全部切分
Split(s, sep string) []string 以字符串sep为分隔符，将s切分成多个子串，结果中不包含sep本身。如果sep为空，则将s切分成 Unicode 字符列表，如果s中没有sep子串，则将整个s作为 []string 的第一个元素返回
SplitAfter(s, sep string) []string 以字符串sep为分隔符，将s切分成多个子串，结果中包含sep本身。如果sep为空则将s切分为 Unicode 字符列表，如果s中没有sep子串则整个s作为切片 []string 中的第一个元素返回。
Fields(s string) []string 以连续的空白字符为分隔符，将s切分成多个子串，结果中不包含空白字符本身。空白字符有：\t, \n, \v, \f, \r, '', U+0085 (NEL), U+00A0 (NBSP) 。如果s中只包含空白字符，则返回一个空切片
FieldsFunc(s string, f func(rune) bool) []string 以一个或多个满足函数f(rune)的字符为分隔符，将s切分成多个子串，结果中不包含分隔符本身。如果s中没有满足f(rune)的字符，则返回一个空切片
Join(a []string, sep string) string 以sep为拼接符，拼接切片a中的字符串
HasPrefix(s, prefix string) bool 判断字符串s是否以prefix字符串开头，是返回 true，否则返回 false
HasSuffix(s, suffix string) bool 判断字符串s是否以suffix字符串结尾，是返回 true，否则返回 false
Map(f func(rune) rune, s string) string 将字符串s中满足函数f(rune)的字符替换为f(rune)的返回值。如果f(rune)返回负数，则相应的字符将被删除
Repeat(s string, count int) string 返回字符串s重复count次数后的结果
ToUpper(s string) string 将字符串s中的小写字符转为大写
ToLower(s string) string 将字符串s中的大写字符转为小写
ToTitle(s string) string 将字符串s中的首个单词转为Title形式，大部分字符的Title格式就是Upper格式
ToUpperSpecial(c unicode.SpecialCase, s string) string 将字符串s中的所有字符修改为其大写格式，优先使用c中的规则进行转换
ToLowerSpecial(c unicode.SpecialCase, s string) string 将字符串s中的所有字符修改为其小写格式，优先使用c中的规则进行转换
ToTitleSpecial(c unicode.SpecialCase, s string) string 将字符串s中的所有字符修改为其Title格式，优先使用c中的规则进行转换
Title(s string) string 将字符串s中的所有单词的首字母修改为其Title格式（BUG: Title 规则不能正确处理 Unicode 标点符号）
TrimLeftFunc(s string, f func(rune) bool) string 删除字符串s左边连续满足f(rune)的字符
TrimRightFunc(s string, f func(rune) bool) string 删除字符串s右边连续满足f(rune)的字符
TrimFunc(s string, f func(rune) bool) string 删除字符串s左右两边连续满足f(rune)的字符
IndexFunc(s string, f func(rune) bool) int 查找字符串s中第一个满足f(rune)的字符的字节位置，没有返回 -1
LastIndexFunc(s string, f func(rune) bool) int 查找字符串s中最后一个满足f(rune)的字符的字节位置，没有返回 -1
Trim(s string, cutset string) string 删除字符串s左右两边连续包含cutset的字符
TrimLeft(s string, cutset string) string 删除字符串s左边连续包含cutset的字符
TrimRight(s string, cutset string) string 删除字符串s右边连续包含cutset的字符
TrimSpace(s string) string 删除字符串s左右两边连续的空白字符
TrimPrefix(s, prefix string) string 删除字符串s 头部的prefix字符串
TrimSuffix(s, suffix string) string 删除字符串s 尾部的suffix字符串
Replace(s, old, new string, n int) string 替换字符串s中的old为new，如果old为空则在s中的每个字符间插入new包括首尾，n为替换次数， -1 时替换所有
EqualFold(s, t string) bool 忽略大小写比较字符串s和t，相同返回 true，反之返回 false

1. 字符串转数字

  • strconv.Atoi：
package main

import (
    "fmt"
    "strconv"
)

func main() {
    var str = "111"
    i, _ := strconv.Atoi(str)
    fmt.Printf("%d\n", i) // 输出：111
}
1
2
3
4
5
6
7
8
9
10
11
12

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）相加
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
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

# 字符串原理

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

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

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

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

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

      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

  • 扩展

    //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
    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

# 数字类型

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

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

序号 类型和描述
1 uint8无符号 8 位整型 (0 到 255)
2 uint16无符号 16 位整型 (0 到 65535)
3 uint32无符号 32 位整型 (0 到 4294967295)
4 uint64无符号 64 位整型 (0 到 18446744073709551615)
5 int8有符号 8 位整型 (-128 到 127)
6 int16有符号 16 位整型 (-32768 到 32767)
7 int32有符号 32 位整型 (-2147483648 到 2147483647)
8 int64有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

# 浮点型

序号 类型和描述
1 float32IEEE-754 32位浮点型数
2 float64IEEE-754 64位浮点型数
3 complex6432 位实数和虚数
4 complex12864 位实数和虚数

# 其他数字类型

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

序号 类型和描述
1 byte类似 uint8
2 rune类似 int32
3 uint32 或 64 位
4 int与 uint 一样大小
5 uintptr无符号整型，用于存放一个指针
#Go#
上次更新: 2023/04/16, 18:35:33
变量
运算符

← 运算符→

最近更新
01
go与http代理
05-24
02
自制申威架构k8s-reloader
12-06
03
Docker Buildx 教程
12-01
更多文章>
Theme by Vdoing | Copyright © 2020-2024 小刘扎扎 | MIT License