02go基本数据类型
go数据类型介绍
参考: http://docscn.studygolang.com/pkg/fmt/
go语言数据类型:
-
基本数据类型
- 整型
- 浮点型
- 布尔型
- 字符串
-
复合数据类型
- 数组
- 切片
- 结构体
- 函数
- map
- 通道(channel)
- 接口
- 等等
1、整型
分类:
- 有符号整型:int8、int16、int32、int64
- 无符号整型:uint8、uint16、uint32、uint64
特殊整型
int和uint:根据底层平台,表示32或64位整数。除非需要使用特定大小的整数,否则通常应该使用int来表示整数。
类型 | 说明 |
---|---|
int | 32 位操作系统上就是 int32,64 位操作系统上就是 int64 |
uint | 32 位操作系统上就是 uint32,64 位操作系统上就是 uint64 |
uintptr | 无符号整型,用于存放一个指针 |
注意事项 :实际项目中整数类型、切片、 map 的元素数量等都可以用 int 来表示。 在涉及
到二进制传输、为了保持文件的结构不会受到不同编译目标平台字节长度的影响 , 不要使
用 用 int 和 和 uint 。
package main
import (
"fmt"
)
func main() {
var num int64
num = 123
//%v => 值 %T => 变量的类型
fmt.Printf("值:%v 类型%T", num, num) //值:123 类型int64
}
unsafe.Sizeof
unsafe.Sizeof(n1) 是 unsafe 包的一个函数,可以返回 n1 变量占用的字节数。
package main
import (
"fmt"
"unsafe"
)
func main() {
var a int8 = 120
fmt.Printf("%T\n", a)
fmt.Println(unsafe.Sizeof(a))
}
int 不同长度直接的转换
package main
import (
"fmt"
)
func main() {
var num1 int8
num1 = 127
num2 := int32(num1)
fmt.Printf("值:%v 类型%T", num2, num2) //值:127 类型 int32
}
数字字面量语法(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
a = 10
fmt.Printf("%d \n", a) // 10
fmt.Printf("%b \n", a) // 1010 占位符%b 表示二进制
// 八进制 以 0 开头
var b int
b = 077
fmt.Printf("%o \n", b) // 77
// 十六进制 以 0x 开头
var c int
c = 0xff
fmt.Printf("%x \n", c) // ff
fmt.Printf("%X \n", c) // FF
fmt.Printf("%d \n", c) // 255
}
2、浮点型
Go 语言支持两种浮点型数:float32
和 float64
。
这两种浮点型数据格式遵循 IEEE 754 标准:
float32
的浮点数的最大范围约为 3.4e38
,可以使用常量定义:math.MaxFloat32
。float64
的
浮点数的最大范围约为 1.8e308
,可以使用一个常量定义:math.MaxFloat64
。
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%f\n", math.Pi) //默认保留 6 位小数
fmt.Printf("%.2f\n", math.Pi) //保留 2 位小数
}
Go 语言中浮点数默认是 float64
3、复数
complex64和complex128
var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)
复数有实部和虚部,complex64的实部和虚部为32位,complex128的实部和虚部为64位。
Golang 中 中 float 精度丢失问题
几乎所有的编程语言都有精度丢失这个问题,这是典型的二进制浮点数精度损失问题,在定
长条件下,二进制小数和十进制小数互转可能有精度丢失。
d := 1129.6
fmt.Println((d * 100)) //输出:112959.99999999999
var d float64 = 1129.6
fmt.Println((d * 100)) //输出:112959.99999999999
m1 := 8.2
m2 := 3.8
fmt.Println(m1 - m2) // 期望是 4.4,结果打印出了 4.399999999999999
使用第三方包来解决精度损失问题:
https://github.com/shopspring/decimal
Golang 科学计数法
num8 := 5.1234e2 // ? 5.1234 * 10 的 2 次方
num9 := 5.1234E2 // ? 5.1234 * 10 的 2 次方 shift+alt+向下的箭头
num10 := 5.1234E-2 // ? 5.1234 / 10 的 2 次方 0.051234
fmt.Println("num8=", num8, "num9=", num9, "num10=", num10)
4、布尔值
Go语言中以bool
类型进行声明布尔型数据,布尔型数据只有true(真)
和false(假)
两个值。
注意:
- 布尔类型变量的默认值为
false
。 - Go 语言中不允许将整型强制转换为布尔型.
- 布尔型无法参与数值运算,也无法与其他类型进行转换。
package main
import (
"fmt"
"unsafe"
)
func main() {
var b = true
fmt.Println(b, "占用字节:", unsafe.Sizeof(b))
}
5、字符串
Go语言中的字符串以原生数据类型出现,使用字符串就像使用其他原生数据类型(int、bool、float32、float64 等)一样。 Go 语言里的字符串的内部实现使用UTF-8
编码。 字符串的值为双引号(")
中的内容,可以在Go语言的源码中直接添加非ASCII码字符,例如:
s1 := "hello"
s2 := "你好"
字符串转义符
Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等,如下表所示。
转义符 | 含义 |
---|---|
\r |
回车符(返回行首) |
\n |
换行符(直接跳到下一行的同列位置) |
\t |
制表符 |
\' |
单引号 |
\" |
双引号 |
\\ |
反斜杠 |
多行字符串
Go语言中要定义一个多行字符串时,就必须使用反引号
字符:和js ES6 用法一样
s1 := `第一行
第二行
第三行
`
fmt.Println(s1)
反引号间换行将被作为字符串中的换行,但是所有的转义字符均无效,文本将会原样输出。
字符串的常用操作
方法 | 介绍 |
---|---|
len(str) | 求长度 |
+或fmt.Sprintf | 拼接字符串 |
strings.Split | 分割 |
strings.contains | 判断是否包含 |
strings.HasPrefix,strings.HasSuffix | 前缀/后缀判断 |
strings.Index(),strings.LastIndex() | 子串出现的位置 |
strings.Join(a[]string, sep string) | join操作 |
例子:
package main
import (
"fmt"
"strings"
)
func main() {
//len() str 长度
var str = "hello kaka"
fmt.Println(len(str)) //10
// 拼接字符串
var str1 = "您好"
var str2 = "go"
fmt.Println(str1 + str2) //您好go
var str3 = fmt.Sprintf("%v %v",str1, str2) //您好 go
fmt.Println(str3)
//.Split 分割字符串
var str4 = "123-456-789"
var arr = strings.Split(str4, "-")
fmt.Println(arr) //[123 456 789]
//判断是否包含字符串
var str5 = "this is golang"
var flag = strings.Contains(str5, "golang")
fmt.Println(flag) //true
//判断首字符尾字母是否包含指定字符
var str6 = "this is golang"
var flag2 = strings.HasPrefix(str6, "this")
fmt.Println(flag2) //true
var str7 = "this is golang"
var flag3 = strings.HasSuffix(str7, "go")
fmt.Println(flag3) //false
//判断字符串出现的位置
var str8 = "this is golang"
var index1 = strings.Index(str8, "is") //第一个is的index
fmt.Println(index1) //2
var str9 = "this is golang"
var index2 = strings.LastIndex(str9, "is") //最后一个is的index
fmt.Println(index2) //5
//jion 拼接字符串
var str10 = "123-456-789"
var arr2 = strings.Split(str10, "-")
var str12 = strings.Join(arr2, "*")
fmt.Println(str12) //123*456*789
}
6、byte 和 和 rune 类型
组成每个字符串的元素叫做“字符”,属于int类型,可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号(’)包裹起来,如:
var a := '中'
var b := 'x'
Go 语言的字符有以下两种:
uint8
类型,或者叫 byte 型,代表了ASCII码
的一个字符。rune
类型,代表一个UTF-8字符
。
1、byte 等同于Uint8,常用来处理ascii字符
2、rune 等同于int32,常用来处理unicode或utf-8字符
当需要处理中文、日文或者其他复合字符时,则需要用到rune
类型。rune
类型实际是一个int32
。
// rune is an alias for int32 and is equivalent to int32 in all ways. It is
// used, by convention, to distinguish character values from integer values.
//int32的别名,几乎在所有方面等同于int32
//它用来区分字符值和整数值
type rune = int32
GO默认是utf-8
6.1、go查看数据类型
package main
import (
"fmt"
"reflect"
)
func main() {
v1 := 'a'
v2 := '中'
v3 := "中国"
//第一种方法
fmt.Printf("v1 type:%T\n", v1) //v1 type: int32 (字符的码值是整数型)
fmt.Printf("v2 type:%T\n", v2) //v2 type: int32
fmt.Printf("v3 type:%T\n", v3) //v3 type: string
//第二种方法,结果一样
fmt.Println("v1 type:", reflect.TypeOf(v1))
fmt.Println("v2 type:", reflect.TypeOf(v2))
fmt.Println("v3 type:", reflect.TypeOf(v3))
}
6.2、查看字符的码值
package main
import (
"fmt"
// "reflect"
)
func main() {
v1 := 'a'
v2 := '中'
v3 := "中国"
v4 := "abc"
//当我们直接输出 byte(字符)的时候输出的是这个字符对应的码值
fmt.Println(v1) //97 这里是ascii的值
fmt.Println(v2) // 20013 这里是utf-8对应的值
fmt.Println(v3) // 中国
fmt.Println(v4) //abc
//如果我们要输出这个字符,需要格式化输出,%c 相应 Unicode 码点所表示的字符
fmt.Printf("%c\n", v1) //a
fmt.Printf("%c\n", v2) //中
fmt.Printf("%c\n", 100) //100
}
6.3 查看字符的长度
// 中文3个字节,英文1个字节
a := "m"
fmt.Println(len(a)) //1
b := "张"
fmt.Println(len(b)) //3
得到str的字符串长度
package main
import (
"fmt"
"unicode/utf8"
)
func main() {
var str = "hello 你好"
//golang中string底层是通过byte数组实现的,座椅直接求len 实际是在按字节长度计算 所以一个汉字占3个字节算了3个长度
fmt.Println("len(str):", len(str))
//以下两种都可以得到str的字符串长度
//golang中的unicode/utf8包提供了用utf-8获取长度的方法
fmt.Println("RuneCountInString:", utf8.RuneCountInString(str)) //RuneCountInString:8
//通过rune类型处理unicode字符
fmt.Println("rune:", len([]rune(str))) // rune:8
}
Go 使用了特殊的 rune 类型来处理 Unicode,让基于 Unicode 的文本处理更为方便,也可以使用 byte 型进行默认字符串处理,性能和扩展性都有照顾。
package main
import "fmt"
func main() {
s := "hello 张三"
for i := 0; i < len(s); i++ { //byte len(s) == 12
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) 32( ) 229(å) 188(¼) 160( ) 228(ä) 184(¸) 137()
104(h) 101(e) 108(l) 108(l) 111(o) 32( ) 24352(张) 19977(三)
因为 UTF8 编码下一个中文汉字由 3 个字节组成,所以我们不能简单的按照字节去遍历一个
包含中文的字符串,否则就会出现上面输出中第一行的结果。
字符串底层是一个 byte 数组,所以可以和[]byte 类型相互转换。字符串是不能修改的 字符
串是由 byte 字节组成,所以字符串的长度是 byte 字节的长度。 rune 类型用来表示 utf8 字
符,一个 rune 字符由一个或多个 byte 组成。
7 、 修改字符串
要修改字符串,需要先将其转换成[]rune 或[]byte,完成后再转换为 string。无论哪种转换,
都会重新分配内存,并复制字节数组。
字符串不能通过index的方式直接修改。
//感觉很麻烦,改来改去的,不如python方便
func changeString() {
s1 := "big"
// 强制类型转换
byteS1 := []byte(s1)
byteS1[0] = 'p'
fmt.Println(string(byteS1))
s2 := "白萝卜"
runeS2 := []rune(s2)
runeS2[0] = '红'
fmt.Println(string(runeS2))
}