基本数据类型

基本数据类型包含整型和浮点型，布尔类型以及字符串，这几种数据类型在几乎所有编程语言中都支持。

4.1、整形

字节了解：

提示

字节(Byte)：计算机中数据储存的单位。

提示

位(bit)：也叫作“比特”，计算机中数据储存的最小单位，因为在计算机中是以二进制的形式数据储存，所以每个位以“0”或“1”表示。

提示

位和字节的关系是：8个位组成一个字节。

字节与位的关系：1Byte=8bit。

• 整形类型

| 具体类型 | 取值范围 |

| -------- | ------------------------------------------------------------ |

| int8 | -128到127 |

| uint8 | 0到255 |

| int16 | -32768到32767 |

| uint16 | 0到65535 |

| int32 | -2147483648到2147483647 |

| uint32 | 0到4294967295 |

| int64 | -9223372036854775808到9223372036854775807 |

| uint64 | 0到18446744073709551615 |

| uint | 与平台相关，32位操作系统上就是uint32，64位操作系统上就是uint64 |

| int | 与平台相关，32位操作系统上就是int32，64位操作系统上就是int64 |

var x int

x = 9223372036854775809

fmt.Print(x) // overflows int

• 进制转换

	// 十进制转化

	var a int = 10

	fmt.Printf("%d \n", a)  // 10    占位符%d表示十进制
	fmt.Printf("%b \n", a)  // 1010  占位符%b表示二进制
	fmt.Printf("%o \n", a)  // 12    占位符%o表示八进制
	fmt.Printf("%x \n", a)  // a     占位符%x表示十六进制

	// 八进制转化

	var b int = 020

	fmt.Printf("%o \n", b)  // 20
	fmt.Printf("%d \n", b)  // 16
	fmt.Printf("%x \n", b)  // 10
	fmt.Printf("%b \n", b)  // 10000

	// 十六进制转化

	var c = 0x12

	fmt.Printf("%d \n", c)  // 18
	fmt.Printf("%o \n", c)  // 22
	fmt.Printf("%x \n", c)  // 12
	fmt.Printf("%b \n", c)  // 10010

4.2、浮点型

• float类型

float类型分为float32和float64两种类型，这两种浮点型数据格式遵循 IEEE 754 标准。

单精度浮点数占用4个字节(32位)存储空间来存储一个浮点数。而双精度浮点数使用 8个字节(64位)存储空间来存储一个浮点数。

单精度浮点数最多有7位十进制有效数字，如果某个数的有效数字位数超过7位，当把它定义为单精度变量时，超出的部分会自动四舍五入。双精度浮点数可以表示十进制的15或16位有效数字，超出的部分也会自动四舍五入。

浮点类型默认声明为float64。

     var f1 float32 // float32：  单精度浮点型

	f1 = 3.1234567890123456789
	fmt.Println(f1, reflect.TypeOf(f1))

	var f2 float64 // 双精度浮点型
	f2 = 3.1234567890123456789
	fmt.Println(f2, reflect.TypeOf(f2))

	var f3 = 3.1234567890123456789
	fmt.Println(f3, reflect.TypeOf(f2)) // 默认64

• 科学计数表示

var f1 = 2e10        // 即使是整数用科学技术表示也是浮点型
fmt.Println(f1,reflect.TypeOf(f1))

var f2 = 2e-2
fmt.Println(f2,reflect.TypeOf(f2))

4.3、布尔类型

布尔类型是最基本数据类型之一，只有两个值：true和false，分别代表逻辑判断中的真和假，主要应用在条件判断中。

package main

import (
	"fmt"
	"reflect"
)

func main() {

	var b bool // 声明b是一个布尔类型

	b = true
	b = false // 该类型只有true和false两个值，分别代表真假两种状态

	fmt.Println(b, reflect.TypeOf(b))

	fmt.Println(1 == 1) // 比较运算符的结果是一个布尔值
	// fmt.Println(1 == "1") // 报错，mismatched types不能比较
	fmt.Println(3 > 1)

	var name = "yuan"
	var b2 = name == "rain"
	fmt.Println(b2)

}

4.4、字符串

字符串是最基本也是最常用的数据类型，是通过双引号将多个字符按串联起来的一种数据，用于展示文本。

var s = "hello yuan"  

fmt.Println(s)

提示

单引号只能标识字符

字符串的基本操作

字符串在内存中是一段连续存储空间

提示

注意：

提示

1. 索引从零开始计数

提示

2. go语言不支持负索引

var s = "hello yuan"

fmt.Println(s)

// (1)索引取值 slice[index]  

a:= s[2]

fmt.Println(string(a))

// (2)切片取值slice[start:end], 取出的元素数量为：结束位置 - 开始位置；

b1:=s[2:5]   //

fmt.Println(b1)

b2:=s[0:]    // 当缺省结束位置时，表示从开始位置到整个连续区域末尾；

fmt.Println(b2)

b3:=s[:8]    // 当缺省开始位置时，表示从连续区域开头到结束位置；

fmt.Println(b3)

// (3)字符串拼接

var s1 = "hello"
var s2 = "yuan"
var s3 = s1 + s2 // 生成一个新的字符串

fmt.Println(s3)

转义符

Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等，如下表所示。

| 转义符 | 含义 |

| :----: | :--------------------------------: |

| \r | 回车符(返回行首) |

| \n | 换行符(直接跳到下一行的同列位置) |

| \t | 制表符 |

| \' | 单引号 |

| \" | 双引号 |

| \\ | 反斜杠 |

举个例子，我们要打印一个Windows平台下的一个文件路径：

package main

import "fmt"

func main() {

	var s1 = "hi yuan\nhi,alvin"
	fmt.Println(s1)

	var s2 = "his name is \"rain\""
	fmt.Println(s2)

	var s3 = "D:\\next\\go.exe"
	fmt.Println(s3)

}

多行字符串

Go语言中要定义一个多行字符串时，就必须使用反引号字符：

s1 := `第一行

第二行

第三行

`

fmt.Println(s1)

反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

字符串的常用方法

| 方法 | 介绍 |

| :------------------------------------ | :-------------------------------------------------------- |

| len(str) | 求长度 |

| strings.ToUpper,strings.ToLower | 生成一个新的全部大写的字符串,生成一个新的全部小写的字符串 |

| strings.ReplaceAll | 生成一个新的原字符串被指定替换后的字符串 |

| strings.Contains | 判断是否包含 |

| strings.HasPrefix,strings.HasSuffix | 前缀/后缀判断 |

| strings.Trim、 | 去除字符串两端匹配的内容 |

| strings.Index(),strings.LastIndex() | 子串出现的位置 |

| strings.Split | 分割，将字符串按指定的内容分割成数组 |

| strings.Join(a[]string, sep string) | join操作，将数组按指定的内容拼接成字符串 |

package main

import (

	"fmt"
	"reflect"
	"strings"
)

func main() {

	s := "hello world"

	// fmt.Println(len(s))

	// strings.ToUpper 和 strings.ToLower

	s1 := strings.ToUpper("Yuan")
	s2 := strings.ToLower("Rain")

	fmt.Println(s1, s2)

	// strings.Trim

     user := "  yuan "

	fmt.Println(len(user))
	fmt.Println(strings.TrimLeft(user, " "))
	fmt.Println(strings.TrimSpace(user))
	fmt.Println(strings.Trim(user, " "))

	s := "alvin,yuan,eric"

	// strings.Index，strings.LastIndex

	var index = strings.Index(s, "yuan!")
	fmt.Println(index) // 未找到返回-1

	var index2 = strings.LastIndex(s, "l")
	fmt.Println(index2)

	// strings.HasPrefix,strings.HasSuffix,strings.Contains(实现的依赖的就是strings.Index)

	fmt.Println(strings.HasPrefix(s, "alv"))
	fmt.Println(strings.HasSuffix(s, "eric"))
	fmt.Println(strings.Contains(s, "eric"))

	// strings.Split: 将字符串分割成数组

	var ret2 = strings.Split(s, ",")
	fmt.Println(ret2, reflect.TypeOf(ret2))

	// strings.Join：将数组拼接成字符串

	var ret3 = strings.Join(ret2, "-")
	fmt.Println(ret3, reflect.TypeOf(ret3))

}

练习：

提示

1. 基于字符串操作获取用户名和密码* s := "mysql ... -u root -p 123"

4.5、类型转换

Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

    // (1)整型之间的转换
	var a int8

	a = 99

	fmt.Println(int64(a), reflect.TypeOf(int64(a)))
	fmt.Println(float64(a), reflect.TypeOf(float64(a)))

	// (2)string与int类型的转换
	x := strconv.Itoa(98)
	fmt.Println(x, reflect.TypeOf(x))

	y, _ := strconv.Atoi("97")
	fmt.Println(y, reflect.TypeOf(y))

	// (3) Parse系列函数

	//  ParseInt

	//  输入：1.数字的字符串形式 2.base,数字字符串的进制，比如：2进制、10进制。

	//       3.bitSize的含义是⼤⼩限制，如果字符串转化的整形数据类型超过bitSize的最大值，那么输出的int64为bitSize的最大值，err就会显⽰数据超出范围。

	i1, _ := strconv.ParseInt("1000", 10, 8)
	println(i1)

	i2, _ := strconv.ParseInt("1000", 10, 64)
	println(i2)

	f2, _ := strconv.ParseFloat("3.1415926", 64)
	fmt.Println(f2, reflect.TypeOf(f2))

	f1, _ := strconv.ParseFloat("3.1415926", 32)
	fmt.Println(f1, reflect.TypeOf(f1))

	// 返回字符串表示的bool值。它接受1、0、t、f、T、F、true、false、True、False、TRUE、FALSE；否则返回错误。

	b1, _ := strconv.ParseBool("true")
	fmt.Println(b1, reflect.TypeOf(b1))

	b2, _ := strconv.ParseBool("T")
	fmt.Println(b2, reflect.TypeOf(b2))

	b3, _ := strconv.ParseBool("1")
	fmt.Println(b3, reflect.TypeOf(b3))

	b4, _ := strconv.ParseBool("100")
	fmt.Println(b4, reflect.TypeOf(b4))