GO-基本数据类型及基本操作

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

---

目录

一、整形

二、浮点型

2.1 float类型

2.2 科学计数表示

3 布尔类型

4 字符串

4.1 索引的概念

4.2 字符串的基本操作

4.3 转义符

4.4 多行字符串的表示

5 类型转换

5.1 基本转换

5.2 Parse系列函数

---

一、整形

基本整形的默认值为0

• 整形类型：

## 整数类型

具体类型 | 取值范围                                                     
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`  


## 流量的单位换算：数据类那个的大小，就是占用内存空间的大小

1GB = 1024MB
1MB = 1024KB
1KB = 1024B  //字节
1B  = 8bit   //比特位
1bit 可以存两个二进制数 0或1
int8 就是8bit = 1B 
一字节的长度为 0到255

 

• 使用实例

var x int   // 有默认值，为0
x = 9223372036854775809
fmt.Print(x) // overflows int，超出int类型范围

fmt.Print(reflect.TypeOf(x)) // 可查看变量的数据类型

二、浮点型

2.1 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

2.2 科学计数表示

• 还可以用科学计数法表示。指数部分由 E 或 e 以及一个带正负号的十进制数组成。例如 6.2E-2 表示浮点数 0.062 ， 6.2E+1 表示浮点数 62

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

var f2 = 6.2e+1
fmt.Println(f2, reflect.TypeOf(f2))

// 有时候，浮点数类型值的表示也可以被简化。 66.0可以简化为66，0.066可以简化为.066
var num1 float64 = 66
var num2 float64 = .066
fmt.Println(num1)
fmt.Println(num2)

3 布尔类型

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

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var b bool // 声明b是一个布尔类型, 有默认值为false
	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 = "li"
	var b2 = name == "rain"
	fmt.Println(b2)

}

4 字符串

• go中""双引号代表的是字符串，''单引号代表的是单个字符

var s string // 有默认值，为""空
s = "hello world"
fmt.Println(s, reflect.TypeOf(s))

4.1 索引的概念

• 字符串在内存中是一段连续的存储空间，可以利用索引将字符串中的某个字符或字符范围取出
• 索引从0开始计数，go语言不支持负索引

4.2 字符串的基本操作

package main

import (
	"fmt"
	"reflect"
	"strings"
)

func main() {
	name := "liduole"
	name2 := []string{"li", "duo", "le"}
	var s = "hello world"
	
	// （1）字符串的基本操作
	// 字符串的所有字符大写并将内容返回
	fmt.Println(strings.ToUpper(name))
	// 字符串的所有字符小写并将内容返回
	fmt.Println(strings.ToLower(name))
	// 判断字符串是否以指定的字符或字符串开头并返回布尔结果
	fmt.Println(strings.HasPrefix(name, "duo"))
	// 判断字符串是否以指定的字符或字符串结尾并返回布尔结果
	fmt.Println(strings.HasSuffix(name, "e"))
	// 判断字符串中是否包含字符或字符串，并返回布尔结果
	fmt.Println(strings.Contains(name, "ol"))
	// 将字符串的两边去除指定的字符或字符串，并将结果返回
	fmt.Println(strings.Trim(name, "e"))
	// 将字符串的两边取出空格，并将结果返回
	fmt.Println(strings.TrimSpace(name))
	// 将字符串的左边去除指定的字符或字符串，并将结果返回
	fmt.Println(strings.TrimLeft(name, "l"))
	// 将字符串的右边去除指定的字符或字符串，并将结果返回
	fmt.Println(strings.TrimRight(name, "e"))
	// 将字符串以指定的字符、符号或字符串进行分隔
	fmt.Println(strings.Split(name, "l"))
	// 通过索引取出字符串中的某个字符或某段字符串，返回的结果为字符的ascll码，所以通过string函数进行字符转换
	fmt.Println(string(name[3]), reflect.TypeOf(string(name[3])))
	// 将切片的元素通过指定的拼接符，拼接成字符串
	fmt.Println(strings.Join(name2, ","))

	// （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 = "world"
	var s3 = s1 + s2 // 生成一个新的字符串
	fmt.Println(s3)
}

4.3 转义符

• Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等

转义符 |                             含义                             
 `\r`  |                      回车符（返回行首）                      
 `\n`  |              换行符（直接跳到下一行的同列位置）              
 `\t`  |                            制表符                            
 `\'`  |                            单引号                            
 `\"`  |                            双引号                            
 `\\`  | Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等反斜杠 

4.4 多行字符串的表示

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

s1 := `第一行
第二行
第三行
`
fmt.Println(s1)

5 类型转换

5.1 基本转换

// （1）整型之间的转换
var a int8
a = 99

a1 := int64(a)
a2 := float64(a)
fmt.Println(a1, reflect.TypeOf(a1))
fmt.Println(a2, reflect.TypeOf(a2))

// （2）string与int类型的转换
x := strconv.Itoa(98)
fmt.Println(x, reflect.TypeOf(x))
y, _ := strconv.Atoi("97")
fmt.Println(y, reflect.TypeOf(y))

5.2 Parse系列函数

//  （1）ParseInt
//  输入：1.数字的字符串形式 2.base,数字字符串的进制，比如：2进制、10进制。
//       3.bitSize的含义是⼤⼩限制，如果字符串转化的整形数据类型超过bitSize的最大值，那么输出的int64为bitSize的最大值，err就会显⽰数据超出范围。
// // Atoi is equivalent to ParseInt(s, 10, 0), converted to type int.

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

//  (2) ParseFloat
// ParseFloat 将字符串 s 转换为具有 bitSize 指定精度的浮点数：对于 float32 为 32，对于 float64 为 64。
// 当 bitSize=32 时，结果仍然是 float64 类型，但它可以转换为 float32 而不会改变它的值。
f2, _ := strconv.ParseFloat("3.1415926", 64)
fmt.Println(f2, reflect.TypeOf(f2))
f1, _ := strconv.ParseFloat("3.1415926", 32)
fmt.Println(f1, reflect.TypeOf(f1))