Golang通脉之如何使用类型定义

这篇文章主要介绍“Golang通脉之如何使用类型定义”,在日常操作中,相信很多人在Golang通脉之如何使用类型定义问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”Golang通脉之如何使用类型定义”的疑惑有所帮助!接下来,请跟着小编一起来学习吧!

目录
  • 1、自定义类型

  • 2、类型定义

    • 2.1 定义结构体

    • 2.2 定义接口

    • 2.3 定义其他的新类型

    • 2.4 定义函数的类型

  • 3、类型别名

    • 4、类型定义和类型别名的区别

      • 5、非本地类型不能定义方法

        • 6、在结构体成员嵌入时使用别名

          1、自定义类型

          在Go语言中有一些基本的数据类型,如 string 、 整型 、 浮点型 、 布尔 等数据类型, Go语言中可以使用 type 关键字来定义自定义类型。

          type是Go语法里的重要而且常用的关键字,type绝不只是对应于C/C++中的typedef。搞清楚type的使用,就容易理解go语言中的核心概念structinterface、函数等的使用。

          2、类型定义

          2.1 定义结构体

          使用 type 可以定义结构体类型:

          //1、定义结构体
          //结构体定义
          type person struct {
             name string //注意后面不能有逗号
             age  int
          }

          2.2 定义接口

          使用 type 可以定义接口类型:

          type USB interface {
           start()
           end()
          }

          2.3 定义其他的新类型

          使用 type ,还可以定义新类型。

          语法:

          type 类型名 Type

          示例代码:

          type myint int
          type mystr string
          
          func main() {
          
            var i1 myint
            var i2 = 100
            i1 = 100
            fmt.Println(i1)
            //i1 = i2 //cannot use i2 (type int) as type myint in assignment
            fmt.Println(i1,i2)
            
            var name mystr
            name = "王二狗"
            var s1 string
            s1 = "李小花"
            fmt.Println(name)
            fmt.Println(s1)
            name = s1 //cannot use s1 (type string) as type mystr in assignment
          }

          2.4 定义函数的类型

          Go语言支持函数式编程,可以使用高阶编程语法。一个函数可以作为另一个函数的参数,也可以作为另一个函数的返回值,那么在定义这个高阶函数的时候,如果函数的类型比较复杂,可以使用type来定义这个函数的类型:

          func main() {
            res1 := fun1()
            fmt.Println(res1(10,20))
          }
          
          
          type my_fun  func (int,int)(string)
          
          //fun1()函数的返回值是my_func类型
          func fun1 () my_fun{
           fun := func(a,b int) string {
            s := strconv.Itoa(a) + strconv.Itoa(b)
            return s
           }
           return fun
          }

          3、类型别名

          类型别名规定TypeAlias只是Type的别名,本质上TypeAliasType是同一个类型。就像一个孩子小时候有小名、乳名,上学后用学名,英语老师又会给他起英文名,但这些名字都指的是他本人。

          类型别名是 Go 1.9 版本添加的新功能。主要用于代码升级、迁移中类型的兼容性问题。在 C/C++语言中,代码重构升级可以使用宏快速定义新的一段代码。Go 语言中没有选择加入宏,而是将解决重构中最麻烦的类型名变更问题。

          type TypeAlias = Type

          在 Go 1.9 版本之前的内建类型定义的代码是这样写的:

          type byte uint8
          type rune int32

          而在 Go 1.9 版本之后变为:

          type byte = uint8
          type rune = int32

          这个修改就是配合类型别名而进行的修改。

          4、类型定义和类型别名的区别

          类型别名与类型定义表面上看只有一个等号的差异,我们通过下面的这段代码来理解它们之间的区别。

          //类型定义
          type NewInt int
          
          //类型别名
          type MyInt = int
          
          func main() {
           var a NewInt
           var b MyInt
           
           fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
           fmt.Printf("type of b:%T\n", b) //type of b:int
          }

          结果显示a的类型是 main.NewInt ,表示main包下定义的 NewInt 类型。b的类型是 int MyInt 类型只会在代码中存在,编译完成时并不会有 MyInt 类型。

          5、非本地类型不能定义方法

          能够随意地为各种类型起名字,是否意味着可以在自己包里为这些类型任意添加方法?

          // 定义time.Duration的别名为MyDuration
          type MyDuration = time.Duration
          // 为MyDuration添加一个函数
          func (m MyDuration) EasySet(a string) { //cannot define new methods on non-local type time.Duration
          }
          func main() {
          }

          以上代码报错。报错信息:cannot define new methods on non-local type time.Duration

          编译器提示:不能在一个非本地的类型 time.Duration 上定义新方法。非本地方法指的就是使用 time.Duration 的代码所在的包,也就是 main 包。因为 time.Duration 是在 time 包中定义的,在 main 包中使用。time.Duration 包与 main 包不在同一个包中,因此不能为不在一个包中的类型定义方法。

          解决这个问题有下面两种方法:

          • 将类型别名改为类型定义: type MyDuration time.Duration ,也就是将 MyDuration 从别名改为类型。

          • MyDuration 的别名定义放在 time 包中。

          6、在结构体成员嵌入时使用别名

          当类型别名作为结构体嵌入的成员时会发生什么情况?

          type Person struct {
           name string
          }
          
          func (p Person) Show() {
           fmt.Println("Person-->",p.name)
          }
          
          //类型别名
          type People = Person
          
          type Student struct {
           // 嵌入两个结构
           Person
           People
          }
          
          func (p People) Show2(){
           fmt.Println("People------>",p.name)
          }
          
          func main() {
           //
           var s Student
          
           //s.name = "王二狗" //ambiguous selector s.name
           s.People.name = "李小花"
           s.Person.name = "王二狗"
           //s.Show() //ambiguous selector s.Show
           s.Person.Show()
           s.People.Show2()
           fmt.Printf("%T,%T\n",s.Person,s.People) //main.Person,main.Person
          
          }

          在通过s直接访问name的时候,或者s直接调用Show()方法,因为两个类型都有 name字段和Show() 方法,会发生歧义,证明People 的本质确实是Person 类型。

          到此,关于“Golang通脉之如何使用类型定义”的学习就结束了,希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习,快去试试吧!若想继续学习更多相关知识,请继续关注网站,小编会继续努力为大家带来更多实用的文章!