go语言基础学习（一）基础数据结构

---

数字类型

• int类型:其中有int8 int16 int32 int64, 还有无符号的uint8 uint16 uint32 uint64
• float类型:有float64, float32
• rune类型:int32类型的别名
• byte类型: uint8类型的别名

func main() {
	fmt.Printf("int8类型的范围为 %d 到 %d\n", math.MinInt8, math.MaxInt8) // -128 到 127
	fmt.Printf("uint8类型的范围为 %d 到 %d\n", 0, math.MaxUint8) // 0 到 255
	fmt.Printf("int16类型的范围为 %d 到 %d\n", math.MinInt16, math.MaxInt16) // -32768 到 32767
	fmt.Printf("uint16类型的范围为 %d 到 %d\n", 0, math.MaxUint16) // 0 到 65535
	fmt.Printf("int32类型的范围为 %d 到 %d\n", math.MinInt32, math.MaxInt32) // -2147483648 到 2147483647
	fmt.Printf("uint32类型的范围为 %d 到 %d\n", 0, math.MaxUint32) // 0  到 4294967295
	fmt.Printf("int64类型的范围为 %d 到 %d\n", math.MinInt64, math.MaxInt64) // -9223372036854775808 到 9223372036854775807
	// fmt.Printf("uint64类型的范围为 %d 到 %v\n", 0, math.MaxUint64)
	// 这里直接打印会编译不过，显示constant 18446744073709551616 overflows int,
	// 大概原因是这里默认用的是int类型，也就是int64类型去创建的内存空间，但是uint64的最大值超过int64的最大值
	// 所以需要显式的定义一个 uint64类型的变量去接收这个数
	var ui64 uint64 = math.MaxUint64
	fmt.Printf("uint64类型的范围为 %d 到 %v\n", 0, ui64) // 0 到 18446744073709551615

	// int/uint类型，根据操作系统的位数有关，如果32位操作系统，则是int32/uint32,
	// 如果是64为操作系统，则是int64/uint64
	var di int = 32
	fmt.Printf("dv的字节数为 %d \n", unsafe.Sizeof(di)) // dv的字节数为8
	// 虽然这里默认是采用int32/64，但是类型不一样，一个是int, 一个是int32/64
	fmt.Printf("dv的类型为 %T \n", di) // dv的类型为 int

	// 浮点型
	fmt.Printf("float32类型的范围为 %e 到 %e\n", math.SmallestNonzeroFloat32, math.MaxFloat32)
	fmt.Printf("float64类型的范围为 %e 到 %e\n", math.SmallestNonzeroFloat64, math.MaxFloat64)

	// 默认值是float64
	df := 3.2
	fmt.Printf("df的字节数为 %d \n", unsafe.Sizeof(df)) // df的字节数为8
	fmt.Printf("df的类型为 %T \n", df)                 // df的类型为 float64

	// byte类型
	var bf byte
	// bf = 256 这里编译不过，说明bf的类型就是uint8
	bf = 255
	fmt.Printf("bf的字节数为 %d\n", unsafe.Sizeof(bf)) // bf的类型为 uint8
	fmt.Printf("bf的类型为 %T\n", bf)                 //bf的类型为 uint8

	// rune类型, 存储字符的类型，因为go支持utf-8编码，所以字符最多可以有三个字节,所有用int32存储
	var rf rune
	// rf = 1 << 33 这里编译不过， rune的类型是int32
	rf = 255
	fmt.Printf("rf的字节数为 %d\n", unsafe.Sizeof(rf)) //rf的字节数为 4
	fmt.Printf("rf的类型为 %T\n", rf)                 //rf的类型为 int32

}

布尔类型

布尔类型比较简单，就两个值true 和 false

需要注意的是，布尔类型的值不能和任何其他类型进行强制转换

复数类型

用的不多，就不详细说了,就两种类型complex64和complex128

字符串类型

• 字符串底层是byte类型的数组，也就是uint8类型的数组
• 字符串用双引号括起来，单引号括起来的是字符。
• 中文字符占3个字节，在查找索引的等涉及数组下标的操作时候，要注意。转换成rune列表进行操作。

func main() {
	s1 := "必须用双引号括起来"

	//strings包有很多对于字符串的函数
	fmt.Printf("s1 是否以 必 开头: %t\n", strings.HasPrefix(s1, "必"))   // true
	fmt.Printf("s1 是否以 符 结尾: %t\n", strings.HasSuffix(s1, "符"))   // false
	fmt.Printf("s1 是否包含 单引号 : %t\n", strings.Contains(s1, "单引号")) // false

	// index， 返回出现的索引值
	fmt.Printf("s1第一次出现 双的索引值, %d\n", strings.Index(s1, "双"))     // 9?
	fmt.Printf("s1第一次出现 双的索引值, %d\n", strings.IndexRune(s1, '双')) // 9?
	// 这里出现结果为9，是因为一个中文字符三个字节，而strings本质是byte类型的数组
	// 目前看到的一种可以兼容中文和英文的一种方式，就是转换成rune列表在进行操作

	// 定义了一个匿名函数
	find_string_index := func(rlist []rune, find_str rune) (index int) {
		index = -1
		for i, v := range rlist {
			if find_str == v {
				index = i
				break
			}
		}
		return index
	}

	rlist := []rune(s1)
	fmt.Printf("s1第一次出现 双的索引值, %d\n", find_string_index(rlist, '双')) // 3

	s2 := "hello,单引号括起来的是字符"
	r2list := []rune(s2)
	fmt.Printf("s2第一次出现 单的索引值, %d\n", find_string_index(r2list, '单')) // 6
	// replace替换字符串
	s3 := "my name is 闪电球，my age is 18"
	s3_1 := strings.Replace(s3, "is", "was", 1)  //替换一次
	s3_2 := strings.Replace(s3, "is", "was", -1) //替换全部

	fmt.Printf("只替换一个 %s\n", s3_1)
	fmt.Printf("替换了所有 %s\n", s3_2)

	// 修剪
	s4 := "    前面后面都有空白!   "
	fmt.Printf("去掉两边的空格 %s\n", strings.TrimSpace(s4))
	fmt.Printf("去掉两边的空格以及感叹号 %s\n", strings.Trim(s4, " !"))

	// 拆分和合并
	s5 := "看看中文能不能拆分andEnginlist"
	ret := strings.Split(s5, "")
	fmt.Printf("拆分后的类型为 %T\n", ret) // []string
	fmt.Printf("拆分后的值为: %v\n", ret)

	s6_strings := []string{"这", "是", "字符串", "列表"}
	s6 := strings.Join(s6_strings, "")
	fmt.Printf("连接后的值为 %v", s6)
}

---

总结

以上就是今天要讲的内容，本文仅仅简单介绍了go的基本数据结构。