go语言学习-数据类型

go语言学习-数据类型

基础类型

• 布尔类型:bool。 //false
• 整型:int8、byte、int16、int、uint、uintptr等。 //0
• 浮点类型:float32、float64。 //0
• 复数类型:complex64、complex128。 //(0+0i)
• 字符串:string。//""
• 字符类型:byte,rune。 //0
• 错误类型:error。 //nil

##复合类型(初始值 nil)

• 指针(pointer，uintptr)：保存指针的32位或64位整数。
• 数组(array)
• 切片(slice)
• 字典(map)
• 通道(chan)
• 结构体(struct)
• 接口(interface)
• 方法(function)

int

go语言有13种整形，其中有2种只是名字不同，实质是一样的，所以，实质上go语言有11种整形。如下：

1. int ：依赖不同平台下的实现，可以是int32或int64
2. int8 : (-128->127)
3. int16: (-32768->32767)
4. int32: (-2 147 483 648->2 147 483 647)
5. int64 :(-9 223 372 036 854 775 808->9 223 372 036 854 775 807)
6. unit : 依赖不同平台下的实现，可以是int32或int64
7. unit8 (又名byte): (0->255)
8. unit16 : (0->65535)
9. unit32 (又名rune):　 (0->4 294 967 295)
10. unit64 : (0->18 446 744 073 709 551 615)
11. unitptr : 恰好容纳指针值的类型，对32位平台是unit32，对64位平台是unit64

string rune byte 的关系

字符串是用一对双引号("")或反引号(` `)括起来定义

在Go当中 string底层是用byte数组存的，并且是不可以改变的。

中文字符是用3个字节存的,在计算index的可以会不一样

例如:

s:="Go编程" 

fmt.Println(len(s)) //结果是8,中文字符是用3个字节存的。

fmt.Println(len(string(rune('编')))) //结果是3

如果想要获中文长度也为1，需要先转换为rune切片再使用内置的len()函数

fmt.Println(len([]rune(s))) //结果是4。

所以用string存储unicode的话，如果有中文，按下标是访问不到的，因为你只能得到一个[]byte。 要想访问中文的话，还是要用rune切片，这样就能按下标访问。

rune 能操作 任何字符, byte 不支持中文的操作

string 大量拼接

在循环中使用加号 + 拼接字符串并不是最高效的做法，更好的办法是使用函数 strings.Join()，有没有更好地办法了？有！使用字节缓冲（bytes.Buffer）拼接更加给力

字符串遍历

1.字节数组(byte),中文在utf-8中占3字节

str := "Hello,世界"
n := len(str)
for i := 0; i < n; i++ {
    ch := str[i] // 依据下标取字符串中的字符,类型为byte
    fmt.Println(i, ch)
}

2.以Unicode字符遍历

str = "Hello,世界"
for i, ch := range str {
    fmt.Println(i, ch)//ch的类型为rune }


}

字符类型

Go语言中支持两个字符类型,一个是byte(实际上是uint8的别名),代表UTF-8字符串的单个字节的值;另一个是rune,代表单个Unicode字符。

rune相关的操作,可查阅Go标准库的unicode包。另外unicode/utf8包也提供了UTF8和Unicode之间的转换

float比较

因为浮点数不是一种精确的表达方式,所以像整型那样直接用==来判断两个浮点数是否相等是不可行的,这可能会导致不稳定的结果。

下面是一种推荐的替代方 :

使用中f1 > f2，math.Dim返回的是x-y与0中大的那个值

import "math"

// p为用户自定义的比较精度0.00001
func IsEqual(f1, f2, p float64) bool {
	return math.Dim(f1, f2) < p
}

//true 比较位数和精度相同
var a float64 = 0.0000123
var b float64 = 0.000012234
var p float64 = 0.0000001

//false p精度比比较位数更精确
var a float64 = 0.0000123
var b float64 = 0.000012234
var p float64 = 0.00000001

//false  精度0.0000002 大于比较精度
var a float64 = 0.0000124
var b float64 = 0.000012234
var p float64 = 0.0000001

总结： flaot 因为底层存放的问题，并不是一个准确的值，所以在比较的时候不能直接进行相等比较，而在使用精度比较的时候，设置精度和比较位数一样，如果使用第二种比比较为更精确一位则两个数就不相等了。

其他补充

string类型不能修改，需要转为[]byte,修改后再转为string. 字符串虽不能更改,但可进行切片操作

s := "hello"
c := []byte(s) // 将字符串 s 转换为 []byte 类型 c[0] = 'c'
s2 := string(c) // 再转换回 string 类型
fmt.Printf("%s\n", s2)


s := "hello"
s = "c" + s[1:] // 字符串虽不能更改,但可进行切片操作
fmt.Printf("%s\n", s)