一、Go数据类型

基础数据类型

类型	长度(字节)	默认值	说明
bool	1	false
byte	1	0	uint8，取值范围[0,255]
rune	4	0	Unicode Code Point, int32
int, uint	4或8	0	32 或 64 位，取决于操作系统
int8, uint8	1	0	-128 ~ 127, 0 ~ 255
int16, uint16	2	0	-32768 ~ 32767, 0 ~ 65535
int32, uint32	4	0	-21亿~ 21亿, 0 ~ 42亿，rune是int32 的别名
int64, uint64	8	0
float32	4	0.0
float64	8	0.0
complex64	8
complex128	16
uintptr	4或8		以存储指针的 uint32 或 uint64 整数

func main() {
	var m complex64
	m = complex(2, 6)
	fmt.Printf("%T %T\n", real(m), imag(m))           // float32 float32 实部32，虚部32，加起来就是64
	fmt.Printf("real=%f  img=%f\n", real(m), imag(m)) //real=2.000000  img=6.000000

	var n complex128
	n = complex(2, 6)
	fmt.Printf("%T %T\n", real(n), imag(n))           //float64 float64 实部64，虚部64，加起来就是128
	fmt.Printf("real=%f  img=%f\n", real(n), imag(n)) //real=2.000000  img=6.000000

}

三种指针类型都是同一个地址

func main() {
	var a int
	// unsafe.Pointer 是特别定义的一种指针类型，它可以包含任意类型变量的地址（类似 C 语言中的 void 类型指针）
	var pointer unsafe.Pointer = unsafe.Pointer(&a)
	var p uintptr = uintptr(pointer)
	var ptr *int = &a
	fmt.Printf("pointer=%p  ,  p=%d  %x,  ptr=%p\n", pointer, p, p, ptr)
	//pointer=0xc0000a6058  ,  p=824634400856  c0000a6058,  ptr=0xc0000a6058

}

复合数据类型：
- 数值型变量的默认值是0，字符串的默认值是空字符串，布尔型变量的默认值是false
- 引用类型、函数、指针、接口的默认值是nil
- 数组的默认值取每个元素对应类型的默认值
- 结构体的默认值取每个成员变量对应类型的默认值

类型	默认值	说明
array	取每个元素对应类型的默认值	值类型
struct	取每个成员变量对应类型的默认值	值类型
string	“”	UTF-8 字符串
slice	nil	引用类型
map	nil	引用类型
channel	nil	引用类型
interface	nil	接口
function	nil	函数

func defaultValue() {
	var a int
	var b byte
	var f float32
	var t bool
	var s string
	var r rune
	var arr [3]int
	var slc []int

	fmt.Printf("default value of int %d\n", a)           //default value of int 0
	fmt.Printf("default value of byte %d\n", b)          //default value of byte 0
	fmt.Printf("default value of float32 %.2f\n", f)     //default value of float32 0.00
	fmt.Printf("default value of bool %t\n", t)          //default value of bool false
	fmt.Printf("default value of string [%s]\n", s)      //default value of string []
	fmt.Printf("default value of rune %d, [%c]\n", r, r) //default value of rune 0, []
	fmt.Printf("default int array is %v\n", arr)         //取每个元素对应类型的默认值 default int array is [0 0 0]
	fmt.Printf("default slice is nil %t\n", slc == nil)  //default slice is nil true
}

自定义类型
- 类型别名
  - type byte = uint8
  - type rune = int32
- 自定义类型
  - type user struct {name string;age int}
  - type signal uint8
  - type ms map[string]string
  - type add func(a, b int) int

type ms map[string]int

func (s ms) Say() {
	fmt.Printf("%d\n", s["hello"])
}

二、字符串

字符串定义

package main

import "fmt"

func main() {
	s1 := " My name is 张朝阳☻"                       //字符串里可以包含任意Unicode字符
	s2 := "He say:\"I'm fine.\" \n\\Thank\tyou.\\" //字符串里可以包含任意Unicode字符

	//字符串也可以用反引号来定义，反引号里的转义字符无效。反引号里的内容原封不动地输出，包括空白符和换行符

	s3 := `here is first line. 

  there is third line.
`

	fmt.Printf("%s\n", s1)
	fmt.Printf("%s\n", s2)
	fmt.Printf("%s\n", s3)
}

在这里插入图片描述

字符串常用操作

方法	介绍
len(str)	求长度
strings.Split	分割
strings.Contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.Index(),strings.LastIndex()	子串出现的位置

func main() {
	s := "张"
	arr := []byte(s)
	for _, ele := range arr { //一个汉字占用3个byte表示
		fmt.Printf("%d ", ele) // 229 188 160
	}
	fmt.Println()
	fmt.Printf("%d %d\n", len(s), len(arr)) //3 3

	brr := []rune(s)
	for _, ele := range brr { //一个rune就可以表示一个汉字
		fmt.Printf("%d ", ele) // 24352
	}
	fmt.Println()
	fmt.Printf("%d %d", len(s), len(brr)) //3 1
}

//
func main() {
	s := "张2"
	arr := []byte(s)
	brr := []rune(s)
	fmt.Printf("%d %c\n", s[1], s[1])     //188 ¼
	fmt.Printf("%d %c\n", arr[1], arr[1]) //188 ¼
	fmt.Printf("%d %c\n", brr[1], brr[1]) //50 2（字符2，在Unicode编码中为50）

}
//
func main() {
	s := "hello, how are u"
	arr := strings.Split(s, ",")
	for _, ele := range arr {
		fmt.Println(ele)
		//hello
		// how are u
	}

	fmt.Printf("%t\n", strings.Contains(s, "how")) //true
	fmt.Printf("%t\n", strings.HasPrefix(s, "he")) //true
	fmt.Printf("%t\n", strings.HasPrefix(s, "hE")) //false
	fmt.Printf("%t\n", strings.HasSuffix(s, " u")) //true
	fmt.Printf("%t\n", strings.HasSuffix(s, "a"))  //false

	pos := strings.Index(s, "lo")
	fmt.Printf("%d\n", pos)                       //3
	fmt.Printf("%d\n", strings.Index(s, "e"))     //1（首次出现e的位置）
	fmt.Printf("%d\n", strings.LastIndex(s, "e")) //13（最后出现e的位置）

	fmt.Printf("%d\n", strings.IndexAny(s, "oe")) //1（查找任意一个字符的位置）
}

字符串拼接
- 加号连接
- func fmt.Sprintf(format string, a …interface{}) string
- func strings.Join(elems []string, sep string) string
- 当有大量的string需要拼接时，用strings.Builder效率最高
byte和rune
- string中每个元素叫“字符”，字符有两种
  - byte：1个字节，代表ASCII码的一个字符
  - rune：4个字节，代表一个UTF-8字符，一个汉字可用一个rune表示
- string是常量，不能修改其中的字符
- string可以转换为[]byte或[]rune类型
- string的底层是byte数组，string的长度就是该byte数组的长度，UTF-8编码下一个汉字占3个byte，即一个汉字占3个长度

func main() {
	s1 := "aaa"
	s2 := "bbb"
	s3 := "ccc"

	S1 := s1 + " " + s2 + " " + s3
	S2 := fmt.Sprintf("%s %s %s", s1, s2, s3)
	S3 := strings.Join([]string{s1, s2, s3}, " ") //性能较高

	sb := strings.Builder{} //性能最高
	sb.WriteString(s1)
	sb.WriteString(" ")
	sb.WriteString(s2)
	sb.WriteString(" ")
	sb.WriteString(s3)
	S4 := sb.String()

	fmt.Println(S1) //aaa bbb ccc
	fmt.Println(S2) //aaa bbb ccc
	fmt.Println(S3) //aaa bbb ccc
	fmt.Println(S4) //aaa bbb ccc

}

三、强制类型转换

强制类型转换：基本方法就是把目标类型放在变量前面，把变量括起来
- 低精度向高精度转换没问题，高精度向低精度转换会丢失位数
- 无符号向有符号转换，最高位是符号位
- 不同长度的int或float之间可以相互转换
- byte和int可以互相转换；float和int可以互相转换，小数位会丢失；bool和int不能相互转换

func main() {
	var i int = 9
	var by byte = byte(i) //int转为byte
	i = int(by)           //byte转为int
	
	//高精度向低精度转换，数字很小时这种转换没问题
	var ua uint64 = 1
	i8 := int8(ua)
	fmt.Printf("i8=%d\n", i8) //i8=1

	//最高位的1变成了符号位
	ua = uint64(math.MaxUint64)
	i64 := int64(ua)
	fmt.Printf("i64=%d\n", i64) //i64=-1

	//位数丢失
	ui32 := uint32(ua)
	fmt.Printf("ui32=%d\n", ui32) //ui32=4294967295

	//单个字符可以转为int
	var i int = int('a')
	fmt.Printf("i=%d\n", i) //97

	//bool和int不能相互转换

	//byte和int可以互相转换
	var by byte = byte(i)
	i = int(by)
	fmt.Printf("i=%d\n", i) //97

	//float和int可以互相转换，小数位会丢失
	var ft float32 = float32(i)
	i = int(ft)
	fmt.Printf("i=%d\n", i) //97
}