GO类型转换 string与int互相转换的方式

---

小记

在go语言学习中，除去最基础的学习，还会有很多细微的知识点，在用到的时候时常会忘记，所以我预想将遇见的被忽略的知识点都记录下来，希望对学习有所帮助。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、string类型与int类型的常用转换

1.string转成int：

//string转成int：
int, err := strconv.Atoi(string)

//string转成int64：
int64, err := strconv.ParseInt(string, 10, 64)

2.int转成string：

//int转成string：
string := strconv.Itoa(int)

//int64转成string：
string := strconv.FormatInt(int64,10)

二、go语言中的类型转换

1.什么是类型转换(Type Conversion)？

通常认知是将一个类型的数据转变为了另一个类型的数据。但实际上类型转换并不是把一个变量的类型发生改变，变量的类型一旦声明就不会发生改变。

简单来讲：

类型转换指的是将一个变量中的值拿出来赋值给另外一个类型的变量的过程。

2.类型转换的来历

在不同编程语言中，对于类型转换都有不一样的定义。但都分为显式转换和隐式转换两种，而显式转换又被称为强制转换。也就是在数据类型相兼容，且目标类型小于原类型时。编译器不会自动帮我们做转换，这就需要我们使用强制转换来强制让编译器转换。

详细来历：

类型转换是类型双关的一种形式，在计算机科学和计算机软件编程中使用的一种技术，在这种技术中，一个特定实体的数据类型被转换成另一种数据类型。
　　类型双关的概念是围绕着一种程序设计语言的特定类型系统而产生的，这样就可以达到某些在程序设计语言中很难实现的效果编程语言形式定义的限制。
　　类型转换是类型双关的最常见形式，在几乎所有编程语言中都是可能的，尽管有些语言提供了额外的类型双关方法，如联合或重新解释。一些编程风格指南建议不要使用类型双关操作，尽管类型转换是经常使用的。掌握计算机类型转换的人有时也被称为类型转换或强制转换，这取决于所使用的编程语言。
　　每种编程语言都有关于如何成功使用类型转换的规则。一般来说，转换可以在基本类型或对象上进行。有几种基本数据类型或数据类型类。在数学运算中使用的一种常见数据类型是整数或普通数字，根据宽度中的位数，整数的范围可以达到数千或数百万。例如，32位整数范围从0到4294967295，或-2147483648到2147483648。另一种类型是浮点数，基本上是任何带小数点的数字。单个字符，例如字母表中的字母或标点符号，也可以用作数据类型。字符串数据类型是没有中断的任何数字和/或字母的组或序列；字符串长度是任意的，但其大小或限制通常是在编程语言中定义的。　
　　最古老的数据类型是Boolean，它只是true或false其他类型的类包括代数、函数、机器数据和对象。例如，在面向对象语言中，对象的祖先可以使用父对象的类型，以便它们之间的交互更加顺畅。类型转换的细节在考虑到特定编程语言的规则之前是不会发挥作用的。一些语言规则进一步规定了类型转换是隐式的还是隐式的显式。隐式类型转换通常称为强制转换，通常发生在程序从源代码编译为可执行程序时。例如，如果在表达式中使用多个数据类型，然后执行比较，则可能会发生这种情况。
　　类型转换被认为是隐含的，编译器自动处理；显式类型转换是在程序代码中定义的。C编程语言将两者区别开来，将显式类型转换称为强制转换，显式的类型转换是一个转换。一个普通类型转换的简单例子是在计算机程序中对数字进行数学运算。接收十进制数（浮点数据类型）作为输入的计算机程序可能需要将数字转换为整数数据类型来执行数学运算，反之亦然此转换允许操作继续

3.go语言中的类型转换

go语言对于类型的控制十分严格，不存在隐式类型转换，因此所有的类型都应该通过显示的转换来完成。go语言的类型转换语法格式为：

var a T = (T)(b) //valueOfTypeB = typeB(valueOfTypeA)

类型 B 的值 = （类型 B）(类型 A 的值)
使用括号将类型和要转换的变量或表达式的值括起来，是类型转换的标准格式
实例：

func main()  {
     
	a := 5.2
	b := int(a)
	B := (int32)(b)
	fmt.Printf("%T\n",a)
	fmt.Println(b)
	fmt.Printf("%T\n",b)
	fmt.Println(B)
	fmt.Printf("%T\n",B)
}

输出结果为：

float64
5
int
5
int32

从上方结果我们可以看出：

1. go语言类型转换与其他语言一样当从一个取值范围较大的类型转换到取值范围较小的类型时（将 int32 转换为 int16 或将 float32 转换为 int），会发生精度丢失（截断）的情况。
2. 强制类型转换时类型时可以省略括号的。

Q：那为什么要加上括号呢？
A：因为某些类型可能引起误会，应该用括号括起来转换
例如：

	num1 := new(int32)
	fmt.Printf("%T---%v\n",num1,num1)
	num2 := *int32(num1)//-->*(int32(num1))-->int32(num1)
	fmt.Printf("%T---%v\n",num2,num2)
	num3 := (*int32)(num1)
	fmt.Printf("%T---%v\n",num3,num3)

在编译时，第三行会报错，原因就是*int32(num1)相当于*(int32(num1))，一个指针不能直接转换成一个int32类型，所以该表达式直接编译错误。将该表达式改为 (*int32)(num1)就可以正常输出了。

在go语言中类型转换是用来在不同但相互兼容的类型之间的相互转换的方式，转换的两个数据需要有相同的底层类型。所以，当类型不兼容的时候，就无法强制转换了，这也是文章开头分享string与int类型转换方式的原因。

无法强制转换，我们还需要实现整形与字符串转换，就需要用到fmt包中的strconv库了。将整形转换为字符串，需要使用strconv.Itoa()。
该方法的源码是：

// Itoa is shorthand for FormatInt(i, 10).
func Itoa(i int) string {
     
    return FormatInt(int64(i), 10)
}

可以看出是FormatInt方法的简单实现，下面我列举了几个常用的转换

//字符串转整形
i, _ := strconv.Atoi("100")
fmt.Println(i)

//整形转字符串
str1 := strconv.Itoa(num1)
fmt.Println(str1)

//int64位整形转字符串
var i int64
i = 0x100
fmt.Println(strconv.FormatInt(i, 10))
//FormatInt第二个参数表示进制，10表示十进制

//字符串转int64
num2_int, _ := strconv.ParseInt(str2, 10, 64)
fmt.Println(num2_int)
//ParseInt第三个参数表示bitSize

//字节转32位整形
b := []byte{
     0x00, 0x00, 0x03, 0xe8}
bytesBuffer := bytes.NewBuffer(b)
 
var x int32
binary.Read(bytesBuffer, binary.BigEndian, &x)
fmt.Println(x)
//其中binary.BigEndian表示字节序，相应的还有little endian。通俗的说法叫大端、小端。

//32位整形转字节
var x int32
x = 106
bytesBuffer := bytes.NewBuffer([]byte{
     })
binary.Write(bytesBuffer, binary.BigEndian, x)
fmt.Println(bytesBuffer.Bytes())

//字节转字符串
fmt.Println(string([]byte{
     97, 98, 99, 100}))
//字符串转字节
fmt.Println([]byte("abcd"))

另外：Go语言没有语言机制支持指针和interger之间的直接转换，可以使用标准库中的unsafe

---

4.断言

1.什么是断言？

什么是断言呢？它是用来干什么的呢？
顾名思义，断言就是果断的去猜测一个未知的事物，就好比我断言正在看本文的你是个糙汉子一样。我们知道在 go 语言中，空接口可以存储任意类型的值，那我们如何获取其存储的具体数据呢？没错，断言！我们可以通过断言来判断你的空接口中接到的是个什么类型的数据。

2.断言的语法：

<目标类型的值>，<布尔参数> := <表达式>.( 目标类型 ) // 安全类型断言
<目标类型的值> := <表达式>.( 目标类型 )　　//非安全类型断言

表达式一般指的是类型为 interface{} 的变量，后面跟的目标类型是我们断言的它的类型。该语法返回两个参数，第一个参数是 x 转化为 T 类型后的变量，第二个值是一个布尔值，若为true 则表示断言成功，false 则表示断言失败。
其实这玩意说白了就是去猜，猜对了就拿去操作，猜错了返回个“你丫猜错了”。

3.断言的本质与使用：

类型断言的本质，跟类型转换类似，都是类型之间进行转换，不同之处在于，类型断言实在接口之间进行，相当于Java中，对于一个对象，把一种接口的引用转换成另一种。下面咱们就来简单的“猜一猜”

func main(){
     
	var A interface{
     }
	A = "昰阳"
	v,ok := A.(string)
	if ok {
     
		fmt.Println("恭喜你，猜对了呢",v)
	}else {
     
		fmt.Println("你可真是个大聪明")
	}
}
//结果：恭喜你，猜对了呢 昰阳

上面这个是安全的断言，下面咱们看一个错误典范：

	var B interface{
     } = "昰阳"
	C := B.(int)
	fmt.Printf("%T->%d\n", C, C)
	//运行结果：panic: interface conversion: interface {} is string, not int

var i interface{} = “昰阳” 某种程度上相当于java中的，Object i = “昰阳”;

断言的机制其实就是对空接口接收到的数据进行一次类型转换，就像上方代码一样，将接收的“昰阳”转换成int类型，如果系统内部检测到这种不匹配，就会调用内置的panic()函数，抛出一个异常。如果将“昰阳”改为111，那么在转换的时候检测匹配成功，就可以证明你“猜对了”。

我们可以选择不对异常进行处理，但不能不接收它，下方用一个匿名变量接收异常后就不会触发panic。但此时的C就将接不到赋值，它的值就成了你断言类型的空值

	var B interface{
     } = "昰阳"
	C,_ := B.(int)
	fmt.Printf("%T->%d\n", C, C)
	//运行结果：int->0

所以在使用断言的时候通常为了提高程序的健壮性，我们会对第二个布尔参数做检查判断，如若判断失败，则做相应的处理。

5.指针

既然都讲这么多了，不放在提一点，go语言中的指针。go 保留了 C语言 的指针概念，但 go 的指针操作并不复杂，通过符号 & 、* 就能轻松的实现指针与其所对应值的切换。依靠这两个操作符我们就可以轻松实现类型转换。
& 符 可以轻松的将某类型 T 转化为 T 的指针类型（T）
* 符 可轻松实现解指针，将某一类型的指针转化为该指针指向的值的类型。

type Person struct {
     
	Name string
	Age  uint8
}
func main() {
     
	p := Person{
     
		Name: "昰阳",
		Age: 19,
	}
	per := &p
	fmt.Printf("The type of per is : %T\n", per)//The type of per is : *main.Person
	fmt.Printf("After operation , type is : %T", *per)//After operation , type is : main.Person
}

以上，如有错误请大佬们不吝赐教。