golang基本数据类型

数据类型介绍

Go语言中的数据类型分为:基本数据类型和复合数据类型

• 基本数据类型:整型、浮点型、布尔型、字符串

• 复合数据类型:数组、切片、结构体、函数、map、通道(channel)、接口等

基本数据类型：

整型

整型分为两个大类:

• 有符号整型按长度分为:int8、int16、int32、int64
• 对应的无符号整型:uint8、uint16、uint32、uint64
• 

特殊整型:

// 定义int类型
var num int = 10

var number int  // 默认值为0

// 转换为 int32
var b  = int32(num)

浮点型

Go语音支持两种浮点型,数据格式遵循IEEE 754标准

• float32:最大的范围约为-3.4e38~3.4e38,可以使用math.MaxFloat32定义

• float64:最大的范围约为-1.8e308~1.8e308，可以使用math.MaxFloat64定义

• import (
  	"fmt"
  	"math"
  )
  
  func main() {
  
  	fmt.Println(-math.MaxFloat32)
  	fmt.Println(math.MaxFloat32)
  	fmt.Println(-math.MaxFloat64)
  	fmt.Println(math.MaxFloat64)
  
  }
  
  

定义浮点型

func main() {

	var a float32 = 3.12 // 占用4个字节
	var b float64 = 5.12 // 占用8个字节
  var c float // 默认值为0

	fmt.Println(a)
	fmt.Println(b)
}

格式化输出

func main() {
	var a float32 = 3.123123623
	fmt.Printf("%f", a)   // 默认保留6位小数且四舍五入，3.123124
	fmt.Printf("%.2f", a) // 默认保留2位小数且四舍五入 3.12
  


	var fn float32 = 3.14e2  // 用科学技术法表示浮点型
	fmt.Printf("%f", fn) // 314.000000




}

默认浮点类型

func main() {
 // 在32位系统中，没有显示声明，则默认是float32，在64位系统中，就是float64
	a := 3.1233123
	fmt.Printf("%T", a)

浮点型精度丢失问题

可以使用第三方包来解决精度损失问题->：
https://github.com/shopspring/decimal

布尔型

• 布尔类型变量的默认值为false

• Go语言中不允许将整型强制转换为布尔型

• 布尔型无法参与数值运算,也无法与其他类型进行转换

var flag bool = true
var status bool // 默认值为false

字符串

声明字符串类型:

func main() {
	var work string // 默认值为空
	var name string = "木子"  // 显示的声明字符串类型
	var car = "梅赛德斯奔驰AMG GLE 53 Couple" // 根据表达式推导变量的类型
	city := "Beijing" // 根据表达式推导变量的类型
	fmt.Println(work)
	fmt.Println(name)
	fmt.Println(car)
	fmt.Println(city)

}

字符串转义符

通常使用/来进行字符串的特殊符号转义

func main() {
	// \n 表示换行
	str1 := "this \nis str"
	// C:\Go\bin 输出反斜杠
	str2 := "C:\\Go\\bin"

	// C:Go"bin 输出“
	str3 := "C:Go\"bin"

	fmt.Println(str1)
	fmt.Println(str2)
	fmt.Println(str3)

}

输出多行字符串

使用双引号
""
只能输出一行字符串，不能输出多行，如果要输出多行，使用反引号

``

func main() {
	str1 := `
   第一行内容 
   第二行内容
`
	fmt.Println(str1)
}

字符串的常用方法

import (
	"fmt"
	"strings"
)

func main() {
	var str1 = "this is str"
	// 输出字符串的长度
	fmt.Println(len(str1))
	// 拼接字符串 使用 + 号
	str2 := "你好"
	fmt.Println(str2 + str1)

	// 拼接字符串 使用fmt.Sprintf，fmt.Sprintf的作用是格式化字符串赋值给新串
	str3 := fmt.Sprintf("%v %v", str2, str1)
	fmt.Println(str3)

	// strings.Split,分割字符串，需要引入strings包,Split方法第一个参数是要分割的字符串，第二个参数是以什么进行分割
	var str4 = "123-456-789"
	arr := strings.Split(str4, "-")
	fmt.Println(arr) // [123 456 789] 切片数组

	// strings.Join(),把一个切片连接成一个字符串 第一个参数是要连接的数组，第二个参数是以什么连接
	str5 := strings.Join(arr, "*")
	fmt.Println(str5) // 123*456*789

	// strings.Contains()，判断一个字符串是否包含另一个字符串,包含返回true,否则false
	str6 := "this is str"
	str7 := "this"
	flag := strings.Contains(str6, str7)
	fmt.Println(flag) // true

	// 	strings.HasPrefix() / 	strings.HasSuffix() 字符串前缀、后缀判断
	str8 := "this is str"
	str9 := "this"
	// 判断 str8的前缀是不是str9，是则是true，否则false
	first := strings.HasPrefix(str8, str9)
	fmt.Println(first)
	// 判断str8的后缀是不是str，是则是true，否则false
	last := strings.HasSuffix(str8, "str")
	fmt.Println(last)

	//	strings.Index() / 	strings.LastIndex() 子串出现的位置
	// 子串在str8中出现的位置,从前往后查找 查找不到返回-1
	indexNum := strings.Index(str8, "is")
	fmt.Println(indexNum) // 2
	// 子串在str8中出现的位置,从后往前查找 查找不到返回-1
	lastNum := strings.LastIndex(str8, "s")
	fmt.Println(lastNum) // 8

}

byte和rune类型

组成每个字符串的元素叫做字符，可以通过遍历字符串元素获得字符，字符用单引号``包裹起来

Go语言的字符有两种：

• uint8类型，就是byte型，代表了ascii码的一个字符

• rune类型，代表一个utf-8字符

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

• 字符串中的单个字符，一个汉字占用3个字节(utf-8),一个字母占用一个字节,使用len方法的长度根据类型获取

• Go 使用了 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理

func main() {
	// golang中定义字符,字符属于int类型，对应ascii码数值
	a := 'a'
	b := '0'
	// 当我们直接输出字符的时候，输出的是这个字符对应的ascii码的数值
	fmt.Println(a) // 97
	fmt.Println(b) // 48

	// 原样输出字符 使用%c格式化输出 , 相应 Unicode 码点所表示的字符
	fmt.Printf("%c", a) // a

}

修改字符串

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

func main() {
	s1 := "big"
	// 1.将字符串s1 转换为byte类型
	byteStr := []byte(s1)

	// 2.将byte类型的第一个字符修改为p
	byteStr[0] = 'p'
	// 3. 将修改后的byte转回string类型
	fmt.Println(string(byteStr)) // pig

	// 如果字符串中有中文，转换为则需要为rune类型
	s2 := "你好golang"
	// 1. 将s2转为rune类型
	runeStr2 := []rune(s2)
	// 2. 将转换后的第一个字符修改
	runeStr2[0] = '李'
	// 3. 将修改后的字符转回string类型
	fmt.Println(string(runeStr2))

}

数值类型之间的转换

import (
	"fmt"
	"strconv"
)

func main() {

	/*

		数值类型的转换 int、float建议从低位转换成高位，如果是高位转换低位可能会溢出
		不同的数据类型不可以进行比较、运算，会报类型错误

	*/

	// int类型转换
	var int1 int8 = 10
	var int2 int16 = 20
	fmt.Println(int16(int1) + int2)

	// 整型和浮点型转换
	var float1 float32 = 20.312
	fmt.Println(float32(int2) + float1)

	/* 字符串转换方式一：通过Sprintf将其他类型转换为string */

	var t bool = true
	var b byte = '7'
	// int类型转换string
	str1 := fmt.Sprintf("%d", int1)
	fmt.Println(str1)
	// float类型转换string
	str2 := fmt.Sprintf("%f", float1)
	fmt.Println(str2)
	// bool转换为string
	str3 := fmt.Sprintf("%t", t)
	fmt.Println(str3)
	// 字符转换为string
	str4 := fmt.Sprintf("%c", b)
	fmt.Println(str4)

	/* 字符串转换方式二: 使用strconv，需要import strconv包*/
	var i1 int = 20
	// 数字转换字符串
	s1 := strconv.FormatInt(int64(i1), 10) // 第一个参数是int64的数值,第二个参数是int类型的进制
	fmt.Println(s1)

	// 浮点转字符串
	var f1 float32 = 20.23
	s2 := strconv.FormatFloat(float64(f1), 'f', 2, 64) // Param:要转换的值、格式化类型、保留的位数、64位or32位
	fmt.Println(s2)

	// bool转换字符串
	s3 := strconv.FormatBool(t)
	fmt.Println(s3)

	// 字符转换字符串
	s4 := strconv.FormatUint(uint64(b), 10) // Param:unit64的数值、输出的进制
	fmt.Println(s4)

	/* string类型转换为数值型*/

	var string1 string = "10"
	// string 转换为int 返回值有两个，结果和错误
	num1, _ := strconv.ParseInt(string1, 10, 64) // Param:字符串、进制、位数
	fmt.Println(num1)

	// string转换为float
	var string2 string = "3.14"
	float2, _ := strconv.ParseFloat(string2, 64) // Param:字符串、位数
	fmt.Println(float2)

}