概述

Go 语言中数据类型分为:基本数据类型和复合数据类型

Go的数据类型 - 图1

一、基本数据类型

1.1 整型

整型的类型有很多中,包括 int8,int16,int32,int64。我们可以根据具体的情况来进行定义
其中,rune类型实际上是一个int32 , uint8就是我们熟知的byte型,
int16对应C语言中的short型,int64对应C语言中的long型。

rune int32
uint8 byte
int16 short
int64 long

如果我们直接写 int也是可以的,它在不同的操作系统中,int的大小是不一样的

  • 32位操作系统:int -> int32
  • 64位操作系统:int -> int64

Go的数据类型 - 图2

可以通过unsafe.Sizeof 查看不同长度的整型,在内存里面的存储空间

  1. var num2 = 12
  2. fmt.Println(unsafe.Sizeof(num2))

1.2 数字字面量语法

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

  1. // 十进制
  2. var a int = 10
  3. fmt.Printf("%d \n", a) // 10
  4. fmt.Printf("%b \n", a) // 1010 占位符%b表示二进制
  5. // 八进制 以0开头
  6. var b int = 077
  7. fmt.Printf("%o \n", b) // 77
  8. // 十六进制 以0x开头
  9. var c int = 0xff
  10. fmt.Printf("%x \n", c) // ff
  11. fmt.Printf("%X \n", c) // FF

1.3 进制转换

整型转换符

%b 二进制表示
%c 相应Unicode码点所表示的字符
%d 十进制表示
%o 八进制表示
%q 单引号围绕的字符字面值,由Go语法安全地转义
%x 十六进制表示,字母形式为小写 a-f
%X 十六进制表示,字母形式为大写 A-F
%U Unicode格式:123,等同于 “U+007B”
  1. var number = 17
  2. // 原样输出
  3. fmt.Printf("%v\n", number)
  4. // 十进制输出
  5. fmt.Printf("%d\n", number)
  6. // 以八进制输出
  7. fmt.Printf("%o\n", number)
  8. // 以二进制输出
  9. fmt.Printf("%b\n", number)
  10. // 以十六进制输出
  11. fmt.Printf("%x\n", number)

结果:

  1. 17
  2. 17
  3. 21
  4. 10001
  5. 11

1.2 浮点型

Go语言支持两种浮点型数:float32和float64。这两种浮点型数据格式遵循IEEE754标准:
float32的浮点数的最大范围约为3.4e38,可以使用常量定义:math.MaxFloat32。float64的浮点数的最大范围约为1.8e308,可以使用一个常量定义:math.MaxFloat64
打印浮点数时,可以使用fmt包配合动词%f,代码如下:

  1. var pi = math.Pi
  2. // 打印浮点类型,默认小数点6位
  3. fmt.Printf("%f\n", pi)
  4. // 打印浮点类型,打印小数点后2位
  5. fmt.Printf("%.2f\n", pi)

| %b | 无小数部分、二进制指数的科学计数法,如-123456p-78; | | —- | —- | | %e | 科学计数法,例如 -1234.456e+78 | | %E | 科学计数法,例如 -1234.456E+78 | | %f | 有小数点而无指数,例如 123.456 | | %g | 根据情况选择 %e 或 %f 以产生更紧凑的(无末尾的0)输出 | | %G | 根据情况选择 %E 或 %f 以产生更紧凑的(无末尾的0)输出 |

1.2.1 Golang中精度丢失的问题

几乎所有的编程语言都有精度丢失的问题,这是典型的二进制浮点数精度损失问题,在定长条件下,二进制小数和十进制小数互转可能有精度丢失

  1. d := 1129.6
  2. fmt.Println(d*100) //输出112959.99999999

解决方法,使用第三方包来解决精度损失的问题
http://github.com/shopspring/decimal(这个不会)

1.3 布尔类型

Go语言中以bool类型进行声明布尔型数据,布尔型数据只有true(真)和false(假)两个值。
注意:

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

定义

  1. var fl = false
  2. if f1 {
  3. fmt.Println("true")
  4. } else {
  5. fmt.Println("false")
  6. }
%t true 或 false

1.4 字符串类型

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

  1. s1 := "hello"
  2. s1 := "你好"

1.4.1 常见转义符

Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等,如下表所示。

\r 一个回车,从顶头开始输,覆盖掉前面的
\n 换行符(直接跳到下一行的同列位置)
\t 一个制表符,中间有空格
\‘ 单引号
\“ 双引号
\\ 反斜杠
\ 在输出路径的时候用

如果想要定义多行字符串,可以使用反引号

  1. var str = `第一行
  2. 第二行`
  3. fmt.Println(str)

1.4.2 strings字符串常见操作

GO语言中文网—strings字符串操作(这个很多,直接去原文看吧)

len(str) 求长度
+或fmt.Sprintf 拼接字符串
strings.Split 分割
strings.Contains 判断是否包含
strings.HasPrefix,
strings.HasSuffix
前缀/后缀判断
strings.Index(),
strings.LastIndex()
子串出现的位置
strings.Join(a[]string, sep string) join操作

1. 比较(strings.Compare)

不推荐使用这个函数,直接使用 == != > < >= <= 等一系列运算符更加直观。

  1. // Compare 函数,用于比较两个字符串的大小,如果两个字符串相等,返回为 0。如果 a 小于 b ,返回 -1 ,反之返回 1 。
  2. func Compare(a, b string) int
  3. // EqualFold 函数,计算 s 与 t 忽略字母大小写后是否相等。
  4. func EqualFold(s, t string) bool
  5. a := "gopher"
  6. b := "hello world"
  7. fmt.Println(strings.Compare(a, b)) //-1
  8. fmt.Println(strings.Compare(a, a)) //0
  9. fmt.Println(strings.Compare(b, a)) //1
  10. fmt.Println(strings.EqualFold("GO", "go")) //true
  11. fmt.Println(strings.EqualFold("壹", "一")) //false

2 . 是否包含

有三个函数做这件事:

  1. // 子串 substr 在 s 中,返回 true
  2. func Contains(s, substr string) bool
  3. // chars 中任何一个 Unicode 代码点在 s 中,返回 true
  4. func ContainsAny(s, chars string) bool
  5. // Unicode 代码点 r 在 s 中,返回 true
  6. func ContainsRune(s string, r rune) bool

这里对 ContainsAny 函数进行一下说明,看如下例子:

  1. fmt.Println(strings.ContainsAny("team", "i")) //false
  2. fmt.Println(strings.ContainsAny("failure", "u & i")) //true
  3. fmt.Println(strings.ContainsAny("in failure", "s g")) //true
  4. fmt.Println(strings.ContainsAny("foo", "")) //false
  5. fmt.Println(strings.ContainsAny("", "")) //false

3. 待续。。。

1.5 byte 和 rune类型

组成每个字符串的元素叫做 “字符”,可以通过遍历字符串元素获得字符。字符用单引号 ‘’ 包裹起来
Go语言中的字符有以下两种类型

  • uint8类型:或者叫byte型,代表了ACII码的一个字符
  • rune类型:代表一个UTF-8字符

当需要处理中文,日文或者其他复合字符时,则需要用到rune类型,rune类型实际上是一个int32
Go使用了特殊的rune类型来处理Unicode,让基于Unicode的文本处理更为方便,也可以使用byte型进行默认字符串处理,性能和扩展性都有照顾。
需要注意的是,在go语言中,一个汉字占用3个字节(utf-8),一个字母占用1个字节

  1. package main
  2. import "fmt"
  3. func main() {
  4. var a byte = 'a'
  5. // 输出的是ASCII码值,也就是说当我们直接输出byte(字符)的时候,输出的是这个字符对应的码值
  6. fmt.Println(a)
  7. // 输出的是字符
  8. fmt.Printf("%c", a)
  9. // for循环打印字符串里面的字符
  10. // 通过len来循环的,相当于打印的是ASCII码
  11. s := "你好 golang"
  12. for i := 0; i < len(s); i++ {
  13. fmt.Printf("%v(%c)\t", s[i], s[i])
  14. }
  15. // 通过rune打印的是 utf-8字符
  16. for index, v := range s {
  17. fmt.Println(index, v)
  18. }
  19. }

1.5.1 修改字符串

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

  1. // 字符串转换
  2. s1 := "big"
  3. byteS1 := []byte(s1)
  4. byteS1[0] = 'p'
  5. fmt.Println(string(byteS1))

转换为rune类型

  1. // rune类型
  2. s2 := "你好golang"
  3. byteS2 := []rune(s2)
  4. byteS2[0] = '我'
  5. fmt.Println(string(byteS2))

1.6 基本数据类型转换

1.6.1 类型转换

通过在变量前面添加指定类型,就可以进行强制类型转换

  1. var a1 int16 = 10
  2. var a2 int32 = 12
  3. var a3 = int32(a1) + a2
  4. fmt.Println(a3)

注意,高位转低位的时候,需要注意,会存在精度丢失,比如上述16转8位的时候,就丢失了

  1. var n1 int16 = 130
  2. fmt.Println(int8(n1)) // 变成 -126

1.6.2 数值类型转换

  1. // 整型和浮点型之间转换
  2. var aa int8 = 20
  3. var bb int16 = 40
  4. fmt.Println(int16(aa) + bb)
  5. // 建议整型转换成浮点型
  6. var cc int8 = 20
  7. var dd float32 = 40
  8. fmt.Println(float32(cc) + dd)

建议从低位转换成高位,这样可以避免精度丢失!

1.6.3 转换成字符串类型

第一种方式,就是通过 fmt.Sprintf()来转换

  1. // 字符串类型转换
  2. var i int = 20
  3. var f float64 = 12.456
  4. var t bool = true
  5. var b byte = 'a'
  6. str1 := fmt.Sprintf("%d", i)
  7. fmt.Printf("类型:%v-%T \n", str1, str1)
  8. str2 := fmt.Sprintf("%f", f)
  9. fmt.Printf("类型:%v-%T \n", str2, str2)
  10. str3 := fmt.Sprintf("%t", t)
  11. fmt.Printf("类型:%v-%T \n", str3, str3)
  12. str4 := fmt.Sprintf("%c", b)
  13. fmt.Printf("类型:%v-%T \n", str4, str4)

第二种方法就是通过strconv包里面的集中转换方法进行转换

  1. // int类型转换str类型
  2. var num1 int64 = 20
  3. s1 := strconv.FormatInt(num1, 10)
  4. fmt.Printf("转换:%v - %T", s1, s1)
  5. // float类型转换成string类型
  6. var num2 float64 = 3.1415926
  7. /*
  8. 参数1:要转换的值
  9. 参数2:格式化类型 'f'表示float,'b'表示二进制,‘e’表示 十进制
  10. 参数3:表示保留的小数点,-1表示不对小数点格式化
  11. 参数4:格式化的类型,传入64位 或者 32位
  12. */
  13. s2 := strconv.FormatFloat(num2, 'f', -1, 64)
  14. fmt.Printf("转换:%v-%T", s2, s2)

1.6.4 字符串转换成int 和 float类型

  1. str := "10"
  2. // 第一个参数:需要转换的数,第二个参数:进制, 参数三:32位或64位
  3. num,_ = strconv.ParseInt(str, 10, 64)
  4. // 转换成float类型
  5. str2 := "3.141592654"
  6. num,_ = strconv.ParseFloat(str2, 10)

附录:

整型转换符

%b 二进制表示
%c 相应Unicode码点所表示的字符
%d 十进制表示
%o 八进制表示
%q 单引号围绕的字符字面值,由Go语法安全地转义
%x 十六进制表示,字母形式为小写 a-f
%X 十六进制表示,字母形式为大写 A-F
%U Unicode格式:123,等同于 “U+007B”

浮点型转换符

| %b | 无小数部分、二进制指数的科学计数法,如-123456p-78; | | —- | —- | | %e | 科学计数法,例如 -1234.456e+78 | | %E | 科学计数法,例如 -1234.456E+78 | | %f | 有小数点而无指数,例如 123.456 | | %g | 根据情况选择 %e 或 %f 以产生更紧凑的(无末尾的0)输出 | | %G | 根据情况选择 %E 或 %f 以产生更紧凑的(无末尾的0)输出 |

常见转义字符

\r 一个回车,从顶头开始输,覆盖掉前面的
\n 换行符(直接跳到下一行的同列位置)
\t 一个制表符,中间有空格
\‘ 单引号
\“ 双引号
\\ 反斜杠
\ 在输出路径的时候用

字符串常见操作

len(str) 求长度
+或fmt.Sprintf 拼接字符串
strings.Split 分割
strings.contains 判断是否包含
strings.HasPrefix,
strings.HasSuffix
前缀/后缀判断
strings.Index(),
strings.LastIndex()
子串出现的位置
strings.Join(a[]string, sep string) join操作

fmy.Print

Print 输出到控制台,不接受任何格式化操作
Println 输出到控制台并换行
Printf 只可以打印出格式化的字符串。只可以直接输出字符串类型的变量(不可以输出别的类型)
Sprintf 格式化并返回一个字符串而不带任何输出
Fprintf 来格式化并输出到 io.Writers 而不是 os.Stdout

通用占位符

%v 值的默认格式。
%+v 类似%v,但输出结构体时会添加字段名
%#v 相应值的Go语法表示
%T 相应值的类型的Go语法表示
%% 百分号,字面上的%,非占位符含义

其他

+ 总打印数值的正负号;对于%q(%+q)保证只输出ASCII编码的字符。
- 左对齐
# 备用格式:为八进制添加前导 0(%#o),为十六进制添加前导 0x(%#x)或0X(%#X),为 %p(%#p)去掉前导 0x;对于 %q,若 strconv.CanBackquote 返回 true,就会打印原始(即反引号围绕的)字符串;如果是可打印字符,%U(%#U)会写出该字符的Unicode编码形式(如字符 x 会被打印成 U+0078 ‘x’)。
‘ ‘ (空格)为数值中省略的正负号留出空白(% d);以十六进制(% x, % X)打印字符串或切片时,在字节之间用空格隔开
0 填充前导的0而非空格;对于数字,这会将填充移到正负号之后