Go 基本数据类型相互转换

Go 基本数据类型讲解

一、基本数据类型默认值：

数据类型	默认值
整型	0
浮点型	0
字符串	“”
布尔型	false

在 go中，数据类型都有一个默认值，也叫零值。

举个栗子：

package main
import (
	"fmt"
)

func main(){
	 var a int // 0
	 var b float64 // 0.00000
	 var c bool // false
	 var d string // ""
	 fmt.Printf("a=%d, b=%f, c=%v, d=%v", a, b, c, d)
}
// 输出结果：a=0, b=0.000000, c=false, d=

二、基本数据类型的相互转换：

1.基本介绍：

go 在不同类型的变量之间赋值时，需要显式转换。简单理解，就是 go 的数据类型不能自动转换。

2.基本语法：

表达式T(v) 将值 v 转换为类型 T；

• T：就是数据类型，比如 int32、int64、float32等；
• v：就是需要转换的变量；

举个栗子：

package main
import (
	"fmt"
)

// go 中基本数据类型的转换
func main(){
	var i = 100
	var n1 int32 = int32(i)
	var n2 int64 = int64(i)
	var n3 float32 = float32(i)
	fmt.Printf("i=%v n1=%v n2=%v n3=%v\n", i, n1, n2, n3)
	fmt.Printf("i=%T, n1=%T n2=%T n3=%T", i, n1, n2, n3)
}

// 输出结果：
i=100 n1=100 n2=100 n3=100
i=int, n1=int32 n2=int64 n3=float32

3.细节说明：

1. go 数据类型的转换，是从 表示范围小 —> 表示范围大，也可以 表示范围大 —> 表示范围小；

2. 被转换的是变量存储的数据(值)，变量本身的数据类型并没有变化；

   package main
   import (
   	"fmt"
   )
   
   // go 中基本数据类型的转换
   func main(){
   	var i = 100
   	var n1 int32 = int32(i)
   	fmt.Printf("i=%T, n1=%T", i, n1)
   }
   
   // 输出结果：i=int, n1=int32
   

   将 i 值转换成 int32 交给 变量 n1，但是 i 的数据类型还是 int；

3. 转换中，将 int64 转换成 int8 【-128 ~ 127】，编译时不会报错，只是转换的结果按溢出处理；

   package main
   import (
   	"fmt"
   )
   
   // go 中基本数据类型的转换
   func main(){
   	var i int64 =  999999
   	var n1 int8 = int8(i)
   	fmt.Printf("i=%v, n1=%v", i, n1)
   }
   
   // 输出结果：
   i=999999, n1=63
   

4.练习题：

1. 数据类型转换：

   package main
   import (
   	"fmt"
   )
   
   func main(){
   	var n1 int32 = 12
   	var n2 int64  // n2 默认值为 0 
   	var n3 int8   // n3 默认值为 0
   
   	// n2 = n1 + 20  // n1是int32 + 20 也是 int32  但是 n2 是int64, 所以报错
   	// n3 = n1 + 20  // n1是int32 + 20 也是 int32  但是 n3 是 int8, 所以报错
   
   	// 正确写法如下
   	n2 = int64(n1) + 20
   	n3 = int8(n1) + 20
   	fmt.Printf("n1=%v n2=%v", n2, n3)
   }
   
   // 输出结果：n1=32 n2=32
   

2. 编译时的问题：

   package main
   import (
   	"fmt"
   )
   
   func main(){
   	var n1 int32 = 12
   	var n2 int8
   	var n3 int8
   	n2 = int8(n1) + 127  // 【编译时通过】，但是结果会溢出， 
   	n3 = int8(n1) + 128  // 【编译不会通过】  n3 的数据类型为int8，int8的范围 -128~127 直接报错
   	fmt.Printf("n2=%v n3=%v", n2, n3)
   }
   

   在程序运行时，数值超出类型的范围，直接报错；

3. 技巧：导入的包，不想用，也不想报错。在包前面 加 _，表示忽略

   package main
   import (
   	_"fmt"
   )
   
   func main(){
   }
   

三、基本数据类型与string相互转换：

在实际开发中，经常将基本数据类型转换成string，或者将 string 转换成基本数据类型。

1.基本数据类型转换 string 类型：

方式一：fmt.Sprintf("%参数", 表达式)

• Sprintf 根据 format 参数生成格式化的字符串并返回该字符串。
• 参数 和 表达式的数据类型相匹配；
• fmt.Sprintf() 会返回转换后的字符串；

举个栗子：

package main
import (
	"fmt"
)

func main(){
	// go 中 基本数据类型 转成 string使用
	var n1 int = 99
	var n2 float64 = 123.456
	var b bool = true
	var char byte = 'a'
	var str string // 空的str

	// 使用 fmt.Sprintf() 方法进行转换

	// int 数据类型转换成 string
	str = fmt.Sprintf("%d", n1)    // 将 n1 99 的这个值, 转换成 string 类型, 进行返回
	fmt.Printf("str type=%T str=%q\n" , str, str)

	// float 数据类型 转换成 String
	str = fmt.Sprintf("%f", n2)
	fmt.Printf("str type=%T  str=%q\n", str, str)

	// bool 数据类型 转换成 string
	str = fmt.Sprintf("%t", b)
	fmt.Printf("str type=%T str=%q\n", str, str)

	// byte 数据类型 转换成 string
	str = fmt.Sprintf("%c", char)
	fmt.Printf("str type=%T  str=%q", str, str)
}

// 输出结果
str type=string str="99"
str type=string  str="123.456000"
str type=string str="true"
str type=string  str="a"

方式二：strconv包的函数

package main
import (
	"fmt"
	"strconv"  // 使用strconv 包 进行转换字符串类型
)

func main(){
	// go 中 基本数据类型 转成 string使用
	var n1 int = 99
	var n2 float64 = 123.456
	var b bool = true
	var str string
	// 第二种方式, 使用strconv 包函数进行转换 

	// int 转换成 string
	str = strconv.FormatInt(int64(n1), 10)  // 10 表示 十进制
	fmt.Printf("str type=%T str=%q\n", str, str)

	// float 转换成 string
	// 'f'：格式  10：小数点保留位10位  64：float64 数据类型
	str = strconv.FormatFloat(n2, 'f', 10, 64)
	fmt.Printf("str type=%T str=%q\n", str, str)

	// bool 转换成 string
	str = strconv.FormatBool(b)
	fmt.Printf("str type=%T str=%q", str, str)
}

// 输出结果：
str type=string str="99"
str type=string str="123.4560000000"
str type=string str="true"

方式三：strconv 包中有一个函数 Itoa

将整数转换成 string类型；

package main
import (
	"fmt"
	"strconv"
)

func main(){
	// go 中 基本数据类型 转成 string使用
	var n1 int = 99
	var n2 int64 = 100
	var str string // 空的str
	str = strconv.Itoa(n1)
	fmt.Printf("str type=%T str=%q\n", str, str)
	
	// n2 是int64 转换中会报错, 先转换成 int 在进行转换string
	str = strconv.Itoa(int(n2))
	fmt.Printf("str type=%T str=%q", str, str)

}

// 输出结果：
str type=string str="99"
str type=string str="100"

2. string 类型转换 基本数据类型：

使用strconv包的函数

package main
import (
	"fmt"
	"strconv"
)

// 将 string 转换成 基本类型
func main(){
	
	var str string = "true"
	var b bool
	
	// b, _ = strconv.ParseBool(str)
	// 说明
	// 1.strconv.ParseBool(str) 函数会返回 两个值 (value bool, err error)
	// 2.仅想获得 value bool, 不想获取 err error 使用 _ 呼噜
	b, _ = strconv.ParseBool(str)
	fmt.Printf(" b type=%T  b=%v\n", b, b)

	var str1  string = "1234567"
	var n1 int64
	// 10 表示 十进制 64 表示基本数据类型 int64
	n1, _ = strconv.ParseInt(str1, 10, 64)
	fmt.Printf("n1 type=%T n1=%v\n", n1, n1)

	var str2 = "123.4567"
	var n2 float64
	// 64 表示 float64
	n2, _ = strconv.ParseFloat(str2, 64)
	fmt.Printf("n2 type=%T n2=%v\n", n2, n2)
}

// 输出结果
 b type=bool  b=true
n1 type=int64 n1=1234567
n2 type=float64 n2=123.4567

3.注意事项：

在 string 类型转成 基本数据类型时，保证string类型能够转成有效的数据。

比如： “123” ，转成一个整型，但是 不能把 “hello” 转成一个整型。若这样做，直接其转换成0(默认值)。

package main
import (
	"fmt"
	"strconv"
)

// 将 string 转换成 基本类型
func main(){
	
	var str string = "hello"
	var str1 string = "true"
	var n1 int64
	var b bool
	n1, _ = strconv.ParseInt(str, 10, 64)
	fmt.Printf("n1 type=%T n1=%v\n", n1, n1)

	b, _ = strconv.ParseBool(str)
	fmt.Printf("b type=%T b=%v\n", b, b)

	b, _ = strconv.ParseBool(str1)
	fmt.Printf("b type=%T b=%v", b, b)
}	

// 输出结果
n1 type=int64 n1=0
b type=bool b=false
b type=bool b=true