GO进阶之类型篇

数据类型是语言的基础,对于强类型的语言来说,正确使用类型也是一个基本功,不可轻视。

一、Go 的类型有哪些?

Go语言内置以下这些基础类型:

  • 布尔类型: bool。
  • 整型: int8、 byte、 int16、 int、 uint、 uintptr等。
  • 浮点类型: float32 、 float64。
  • 复数类型: complex64、 complex128。
  • 字符串: string。
  • 字符类型: rune。
  • 错误类型: error。

同时, Go语言也支持以下这些复合类型:

  • 指针( pointer)
  • 数组( array)
  • 切片( slice)
  • 字典( map)
  • 通道( chan)
  • 结构体( struct)
  • 接口( interface)

二、怎么判断一个变量的类型(断言)?

很多语言都有自己判断变量类型的方式,大多数高级语言都是提供了对应的函数,例如 PHP 的 gettype() ,js 的 typeof, 或者java包装类型变量的 getClass().getTypeName(),然而,在 go 语言中,使用的是类型断言的方式。

语法形式是x.(T)。其中的x代表要被判断类型的值。这个值当下的类型必须是接口类型的。

我们举个例子:

package main

import "fmt"

func main() {
	name := "mclink"
	//s, ok := block.(string)  这个会报错,必须是接口类型才能使用断言
	s1, ok1 := interface{}(name).(struct{})
	s2, ok2 := interface{}(name).(string)
	//s3 := interface{}(name).(int) 类型判断不对,会有panic
	fmt.Println(s1, s2, ok1, ok2) // {} mclink false true
}

首先类型断言的 x 必须是一个接口类型,所以我们需要对非接口类型的变量进行强制类型转换,类型转换的语法就是 type(xxx), 对应这里的 interface{}(), 空接口类型可以容纳世间万物。转换成接口类型,我们再按照 x.(T) 的语法对其进行套入。其中,会有两个返回值。我们可以选择性的选择接收一个或者两个返回值,其中两个返回的结果在不同场景下均不同,有这样的规律:
我们分别把两个返回值标记为 r1, r2

  • 当类型断言正确时,r1 为断言的原值,r2 为布尔值 true
  • 当类型断言不正确时,r1 为断言类型(T)的零值,r2 为 false
  • 当不接收 r2 时,类型断言不正确会有 panic 抛出

三、怎么转换类型?

go 语言是强类型语言,虽然有自动类型推断的功能,但是并不像PHP这种弱类型一样可以无视变量类型随便玩,请记住它是强类型语言。因此,在一些情况下,我们需要进行类型的转换,一般的转换方式是 T(x), 其中 x 可以是一个变量,也可以是一个代表值的字面量(比如1.23和struct{}{})

并且go 只支持强制类型转换,不支持隐式类型转换,例如

package main

import "fmt"

func main() {  
    var a int64 = 3
    var b int32
    //b = a //这样会报错
    b = int32(a) // 这样可以
    fmt.Printf("b 为 : %d", b)
}

如果从源类型到目标类型的转换是不合法的,那么就会引发一个编译错误,IDE 会自动识别这种错误,因此我们在此不关心这种问题,需要我们关心的是,语言层次允许的不规范转换问题。

  • 对于整数类型值、整数常量之间的类型转换
    不同整数类型能存储的数值范围是不同的,当从大范围整数转为小整数范围会有一些神奇的现象发生,例如
var srcNum int16 = -255
dstNum := int8(srcNum)

首先我们分析一下, 两者的存储范围分别是:
int8: -128 ~ 127
int16: -32768 ~ 32767

-255 一看就知道放不进 int8中,那 go 会怎么做呢?

要明白这个东西,首先你要知道,整数在 Go 语言以及计算机中都是以补码的形式存储的。这主要是为了简化计算机对整数的运算过程。正数的补码是它本身,负数的补码其实就是符号位不变,原码各位求反再加 1。

然后 -255 的原码是 1000000011111111, 补码为11111111 00000001(首先是算出反码为 11111111 00000000,然后加1得到 11111111 00000001),当 -255 要强制性存在不够存的 int8 里时,go 语言会把前面的八个多余的二进制数直接截掉,那么就剩下了 00000001 ,因为它的符号位(最高位)是0,说明是个正数,由于正数的补码是自己,所以算出它的原码也是自己,即 十进制的 1。

所以,当整数值的类型的有效范围由宽变窄时,只需在补码形式下截掉一定数量的高位二进制数即可。同理,当把一个浮点数类型的值转换为整数类型值时,前者的小数部分会被全部截掉。

四、别名类型和潜在类型

举个例子

type MyString = string // 1

type MyString2 string // 2

上面两个长得很像,却有着完全不同的含义。第一条声明语句表示 MyString 是 string 的别名类型,顾名思义,别名类型和源类型实际上是完全相同的,唯一的不同只有名称,就像你的名字和绰号,朋友叫的实际都是你。
在 go 语言中,内建的基本类型中就存在两个别名类型, 例如 byte 是 unit8 的别名类型, rune 是 int32 的别名类型。

而第二条声明语句却完全不同,它表示对原有类型的类型在定义,在 go 语言中 ,MyString2 和 string 属于不同的类型。对于这里的类型在定义来说, string 类型可以说是 MyString2 的潜在类型。潜在类型的意识就是说某个类型在本质上是哪个类型。潜在类型相同的不同类型的值之间可以进行类型转换。
在这里插入图片描述

例如这样:

package main

import "fmt"
type MyString string

func main() {
	var test MyString = "test"
	fmt.Println(string(test)) // 这样是允许的
}

但对于集合类的类型[]MyString2与[]string来说这样做却是不合法的,因为[]MyString2与[]string的潜在类型不同,分别是[]MyString2和[]string。另外,即使两个不同类型的潜在类型相同,它们的值之间也不能进行判等或比较,它们的变量之间也不能赋值。
例如:

package main

import "fmt"
type MyString string

func main() {
	var testArr []MyString= make([]MyString,3)
	//fmt.Println([]string(testArr)) // 这个会报错
}

对于上面的强制类型转换,IDE会报这样的错误:
Cannot convert expression of type ‘[]MyString’ to type ‘[]string’

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 终极编程指南 设计师:CSDN官方博客 返回首页