go基本数据类型

[TOC]

数据类型分为 基本数据类型 和 复合数据类型

基本数据类型：
* 整型
* 浮点型
* 布尔型
* 字符串

复合数据类型：
* 数组
* 切片
* 结构体
* 函数
* map
* 通道 channel
* 接口

## 整型

有符号整型	int8	int16	int32	int64
无符号整型	uint8	uint16	uint32	uint64

![](/media/202207/2022-07-29_154900_9535560.07419276438253775.png)

int类型转换
```
var i1 int32 =20
var i2 int64 =30
fmt.Println(int64(i1)+i2)  // int64(i1)  把i1 强制类型转换成int64

```

---

数字字面量语法  %d表示10进制输出 %b表示二进制输出 %o表示八进制输出 %x表示16进制输出

---

unsafe.Sizeof(num) 输出变量在 内存中的占用的字节数 byte

---

## 浮点型
float32		占用4字节
float64		占用8字节

可以使用 %f 格式化输出浮点类型的变量   fmt.Printf("%f",浮点变量名)
%.2f 表示输出数据的时候保留2位小数

## 布尔类型
布尔类型 默认值是false

## 字符串

输出多行字符串   使用反引号
```
s1 := `  	1
 			 2
			3`
```

![](/media/202207/2022-07-29_172458_6759860.8004506704964878.png)

split   join
```
func main() {

var i string = "123-456-789"
	// Split  返回的是一个数组
	s := strings.Split(i, "-")
	fmt.Printf("s: %v\n", s) //s: [123 456 789]

//strings.join(arry,"*") 把一个数组拼接成字符串  join(数组,连接符)
	// 返回一个字符串的值
	s2 := strings.Join(s, "*")
	fmt.Printf("s2: %v\n", s2) //s2: 123*456*789

}
```

contains
```
func main() {

var str1 string = "this is str"
	var str2 string = "is"
	// str1 中是否包含 str2
	b := strings.Contains(str1, str2) // 返回bool值
	fmt.Printf("b: %v\n", b)
}

```

HasSuffix
```
func main() {

var str1 string = "hello.txt"
	var str2 string = ".txt"
	// str1 的后缀是不是txt
	b := strings.HasSuffix(str1, str2) //返回布尔值
	fmt.Printf("b: %v\n", b)           //b: true
}

```
实例
```
const a, b = "david", 20
	var newstring = fmt.Sprintf("%s你好 你的年龄%d", a, b)
	fmt.Println(newstring)
	//david你好 你的年龄20

const url string = "www.baidu.com"
	var newlist = strings.Split(url, ".")
	fmt.Println(newlist)
	//[www baidu com]

var result1 = strings.Contains(url, "..com")
	fmt.Println(result1)
	//Flase

var result2 = strings.HasPrefix(url, "www")
	fmt.Println(result2)
	//true

var result3 = strings.HasSuffix(url, "com")
	fmt.Println(result3)
	//true

var result4 = strings.Join(newlist, "*")
	fmt.Println(result4)
	//www*baidu*com
```

## byte 和  rune 类型
字符用单引号(')包裹起来

```
a := 'a'
b := '0'
//当我们直接输出byte字符 的时候  输出的是这个字符对应的码值
fmt.print(a)
fmt.print(b)

//如果我们要输出这个字符需要使用 printf 格式化输出 
fmt.Printf("%c",a) //%c  输出相应 Unicode码 所表示的字符
```
Go 字符有以下两种：
uint8 类型，或者叫byte类型，代表了 ASCII码的一个字符
rune 类型，代表一个UTF-8字符

当需要处理中文 日文 或者其他符合字符时，则需要用到rune类型。rune类型其实是一个int32。

go使用了特殊的rune 类型来处理unicode，让基于 unicode 的文本处理更为方便，也可以使用 byte型进行默认字符串处理，性能和扩展性都有照顾。

## 修改字符串
要修改字符串，需要先将其转换成[]rune 或者  []byte，完成后再转换为string。无论哪种转换，都会进行重新分配内存，并复制字节数组。

```
func main() {
	var str1 string = "abc"
	//强制类型转换
	b := []byte(str1)
	b[1] = 'd'
	fmt.Println(string(b))
	//如何string 中包含 unicode 字符  ，则转换成rune数组
	var str2 string = "白萝卜"
	r := []rune(str2)
	r[1] = '屁'
	fmt.Println(string(r))

}
```

## 基本数据类型转换
```
func main() {
	var i1 int8 = 20
	var i2 int16 = 40 
	fmt.Print(int16(i1) + i2)  // i1 int8 强制转换为 int16 
	//60
}
```

### 把其他类型转换成 string 类型
springf
```func main() {
	var a int = 12
	var b float64 = 23.21
	var c bool = true
	var d byte = 'l'
	s1 := fmt.Sprintf("%d", a) //整数使用 %d
	s2 := fmt.Sprintf("%f", b) //浮点使用%f
	s3 := fmt.Sprintf("%t", c) //布尔使用%t
	s4 := fmt.Sprintf("%c", d) //byte 使用%c
	fmt.Printf("s1: %v  s1 type : %t \n", s1, s1)
	fmt.Printf("s2: %v  s2 type : %t \n", s2, s2)
	fmt.Printf("s3: %v  s3 type : %t \n", s3, s3)
	fmt.Printf("s4: %v  s4 type : %t \n", s4, s4)
	/**
	s1: 12  s1 type : %!t(string=12)
	s2: 23.210000  s2 type : %!t(string=23.210000)
	s3: true  s3 type : %!t(string=true)
	s4: l  s4 type : %!t(string=l)
	**/
}

```

使用 strconv 包里面的几种转换方法进行转换
```
func main() {
	var a int64 = 12
	var b float64 = 203.23
	var c bool = true
	var d byte = 'l'
	s1 := strconv.FormatInt(a, 10) //strconv.FormatInt(int64的值，数值的进制)
	fmt.Printf("s1: %v s1的数据类型: %T\n", s1, s1)
	s2 := strconv.FormatFloat(b, 'f', 2, 64) //strconv.FormatFloat(float64,格式化类型，保留几位小数，32位 or 64位)
	fmt.Printf("s2: %v s2的数据类型: %T\n", s2, s2)
	s3 := strconv.FormatBool(c)
	fmt.Printf("s3: %v s3的数据类型： %T\n", s3, s3)
	s4 := strconv.FormatUint(uint64(d), 10)
	fmt.Printf("s4: %v\n", s4)
	/*
		s1: 12 s1的数据类型: string
		s2: 203.23 s2的数据类型: string
		s3: true s3的数据类型： string
		s4: 108
	*/
}
```

### 把string类型转换成 其他类型

string类型转换成int类型
parse 解析
strconv.ParseInt
```
func main() {
	var str1 string = "2334433"
	i, _ := strconv.ParseInt(str1, 10, 64) //strconv.ParseInt(字符串,进制，int类型)
	fmt.Printf("i: %v i数据类型 %T \n", i, i)
	//i: 2334433 i数据类型 int64
}
```
strconv.ParseFloat
```
	var str1 string = "2334433.222"
	i, _ := strconv.ParseFloat(str1, 64)
	fmt.Printf("i: %v i数据类型 %T \n", i, i)
```