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 整数

复合数据类型

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

自定义类型

类型别名

• type byte= uint8
• type rune= int32

自定义类型

• type signal uint8
• type ms map[string]string
• type add func(a,b int) int
• type user struct {name string ; age int}

type User struct {
   Name string
   Age  int
}

func (self User) Hello() {
   fmt.Printf("my name is %s \n", self.Name)
}

type ms map[string]string

func (self ms) Hello() {
   fmt.Printf("%d \n", self["Hello"])
}

字符串

字符串的拼接

• 加号连接
• func fmt.Spintf(format string , a...interface{})
• func strings.Join(elems []string, sep string)
• 当有大量的string需要拼接时，用strings.Builder效率最高

byte和rune

• string 中每个元素叫“字符”，字符有两种： byte: 1个字节，代表ASCII码的一个字符 rune: 4个自己呃，代表一个UTF-8字符，一个汉字可用一个rune表示
• string底层时byte数组，string的长度就是该byte数组的长度，UTF-8编码下一个汉字下3个byte，即一个汉字占3个长度
• string可以转换为[]byte或[]rune类型
• string是常量，不能修改其中的字符

func main() {
   s := "sdajsd 是谁"
   arr := []byte(s) //一个汉字三个自己呃
   for _, ele := range arr {
      fmt.Printf("%d ", ele)
   }
   fmt.Printf("\narr len %d , s len %d ", len(arr), len(s))
   arrrune := []rune(s) //一个字符一个rune
   for _, ele := range arrrune {
      fmt.Printf("%d ", ele)
   }
   fmt.Printf("\narr len %d , s len %d ", len(arrrune), len(s))
   fmt.Println()
   s1 := "777sss"
   s2 := `sss
d
ddd
` //文本格式化用``引住
   fmt.Println(s1)
   fmt.Println(s2)

}

字符串的常用方法

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

func str_func() {
   s := "hello, how are you "
   arr := strings.Split(s, ",")
   for _, ele := range arr {
      fmt.Println(ele)
   }
   //查看字符串的前缀
   fmt.Printf("%t\n", strings.HasPrefix(s, "hello"))
   //查看ss字符串在s中第一次出现的位置
   ss := "e"
   fmt.Printf("%d\n", strings.Index(s, ss))
   //查看sss字符串中任意一个字符在ss中第一次 出现的位置
   sss := "oe"
   fmt.Printf("%d\n", strings.Index(s, sss))
}

func string_jion() {
   s1 := "aaa"
   s2 := "bbb"
   s3 := "ccc"
   S1 := s1 + s2 + s3
   fmt.Println(S1)
   S2 := fmt.Sprintf("%s %s %s", s1, s2, s3)
   fmt.Println(S2)
   S3 := strings.Join([]string{s1, s2, s3}, " ")
   fmt.Println(S3)
   builder := strings.Builder{}
   builder.WriteString(s1)
   builder.WriteString(s2)
   builder.WriteString(s3)
   fmt.Println(builder.String())

}

强制类型

• byte和int可用相互转换
• float和int可用相互转换，小数位会丢失
• bool和int不能相互转换
• 不同长度的int和float之间可以相互转换
• string可以转换为[]byte或者rune类型,byte或rune可以转为string
• 低精度向高精度转换没问题，高精度向低精度换会丢失位数
• 无符号向有符号转换，最高位是符号位

var ua uint64 = 1
i8 := int(ua)
fmt.Println(i8)

var ua1 uint64 = math.MaxUint64
i81 := int8(ua1)
fmt.Println(ua1)
fmt.Println(i81)

var f float32 = 3.14
i := int(f)
fmt.Println(i)