0
0

【Golang】Go语言中type关键字到底是什么？

在这里插入图片描述

✨✨ 欢迎大家来到景天科技苑✨✨

🎈🎈 养成好习惯，先赞后看哦~🎈🎈

🏆 作者简介：景天科技苑
🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。
🏆《博客》：Python全栈，Golang开发，PyQt5和Tkinter桌面开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi，flask等框架，云原生K8S，linux，shell脚本等实操经验，网站搭建，数据库等分享。

所属的专栏：Go语言开发零基础到高阶实战
景天的主页：景天科技苑

在这里插入图片描述

文章目录

Go语言中Type的详细用法教程

在Go语言中，

  1. type

关键字是构建自定义数据类型和声明新类型的基础。通过

  1. type

，我们可以定义类型别名、结构体、接口、函数类型等多种数据类型，这些自定义类型极大地增强了Go语言的灵活性和表达能力。本文将结合实际案例，详细探讨

  1. type

在Go语言中的多种用法。

1. type使用语法

1、定义新类型

type NewTypeName OldTypeName
其中，NewTypeName是新创建的类型别名，OldTypeName是已存在的类型。

2、给存在的类型起别名

type xxx = 类型 ，将某个类型赋值给 xxx，相当于这个类型的别名。程序原酸的时候还是按原类型来处理

type关键字的理解：
1、type 定义一个类型

  • type User struct 定义结构体类型
  • type User interface 定义接口类型
  • type Diy (int、string、…) 自定义类型，全新的类型

2、type 起别名

  • type xxx = 类型 ，将某个类型赋值给 xxx，相当于这个类型的别名
  • 别名只能在写代码的时候使用，增加代码的可阅读性。
  • 真实在项目的编译过程中，它还是原来的类型。

总结：

  • type xxx TTT 自定义类型
  • type xxx = TTT 起别名

代码示例：

  1. package main
  3. import"fmt"// var 变量   type 类型（结构体、接口、别名...）// type的别名用法,全局变量中// 这是定义了一个新类型 MyInt，是int转换过来的，和int一样，但是不能通int发生操作，类型不同// 这里他俩MyInt int 是两个类型// 创建了一种新类型！type MyInt intfuncmain(){var a MyInt =20// MyIntvar b int=10// int//自定义的类型和原类型也不能做运算// invalid operation: a + b (mismatched types MyInt and int)//fmt.Println(a + b)//可以进行强制类型转换// 类型转换： T(v)
  4.     fmt.Println(int(a)+ b)// 30//查看他俩数据类型
  5.     fmt.Printf("%T\n", a)// main.MyInt
  6.     fmt.Printf("%T\n", b)// int// 给int起一个小名，但是它还得是int   type  anytype diyint =int//用等号赋值，这里diyint和int是一样的var c diyint =30//查看数据类型，可以看到还是原来的数据类型
  7.     fmt.Printf("%T\n", c)// int//此时的c和基本int类型的数据可以直接进行运算
  8.     fmt.Println(c + b)//40}/*
  9. type关键字的理解：
  10. 1、type 定义一个类型
  11.  - type User struct 定义结构体类型
  12.  - type User interface 定义接口类型
  13.  - type Diy (int、string、....) 自定义类型，全新的类型
  15. 2、type 起别名
  16.  - type xxx = 类型 ，将某个类型赋值给 xxx，相当于这个类型的别名
  17.  - 别名只能在写代码的时候使用，增加代码的可阅读性。
  18.  - 真实在项目的编译过程中，它还是原来的类型。
  19. */

在这里插入图片描述

进阶用法

类型别名不仅限于基础类型，也可以用于复合类型，如结构体、切片、映射等。然而，重要的是要理解，类型别名和原始类型在类型系统中是被视为等价的。

示例：类型别名与结构体
  1. type Point struct{
  2.     X, Y int}type Coord Point
  4. funcmain(){var p Point = Point{1,2}var c Coord = Coord{3,4}// Point 和 Coord 是等价的var q Point = c // 正确，因为 Point 和 Coord 是等价的
  5.     fmt.Println(q)// 输出: {3 4}}

尽管

  1. Point

和

  1. Coord

在代码中是两个不同的类型名称，但在Go的类型系统中，它们被视为等价。因此，

  1. Point

类型的变量可以赋值为

  1. Coord

类型的值，反之亦然。

2. 结构体类型（Struct Types）

定义与基本用法

结构体是Go语言中的一种复合数据类型，用于将多个不同类型的变量组合成一个单一的类型。结构体类型允许我们创建具有多个属性的自定义类型。

语法
  1. type StructName struct{
  2.     Field1 FieldType1
  3.     Field2 FieldType2
  4.     // ...}
示例
  1. package main
  3. import"fmt"type Person struct{
  4.     Name string
  5.     Age  int}funcmain(){
  6.     p := Person{Name:"Alice", Age:30}
  7.     fmt.Println(p)// 输出: {Alice 30}}

在上述代码中，我们定义了一个

  1. Person

结构体，它有两个字段：

  1. Name

和

  1. Age

。然后，我们创建了一个

  1. Person

类型的变量

  1. p

，并初始化了它的字段。

结构体字段的访问与修改

结构体字段可以通过点操作符

  1. .

来访问和修改。

  1. p.Name ="Bob"
  2. fmt.Println(p.Name)// 输出: Bob

结构体标签（Struct Tags）

结构体字段还可以包含标签（也称为元数据），这些标签用于为字段提供额外的信息，常用于JSON序列化/反序列化等场景。

  1. type Person struct{
  2.     Name string`json:"name"`
  3.     Age  int`json:"age"`}

匿名结构体与内嵌结构体

Go还允许定义匿名结构体和将结构体作为另一个结构体的字段（内嵌结构体）。

匿名结构体
  1. var person =struct{
  2.     Name string
  3.     Age  int}{"Alice",30}
  4. fmt.Println(person)// 输出: {Alice 30}
内嵌结构体
  1. type Address struct{
  2.     City, State string}type Person struct{
  3.     Name string
  4.     Age  int
  5.     Address
  6. }funcmain(){
  7.     p := Person{
  8.         Name:"Alice",
  9.         Age:30,
  10.         Address: Address{
  11.             City:"New York",
  12.             State:"NY",},}
  13.     fmt.Println(p)// 输出: {Alice 30 {New York NY}}
  14.     fmt.Println(p.City)// 输出: New York}

在上述代码中，

  1. Address

结构体被内嵌到

  1. Person

结构体中。这允许我们直接通过

  1. Person

类型的实例访问

  1. Address

结构体的字段。

3. 接口类型（Interface Types）

定义与基本用法

接口是一种抽象类型，它定义了一组方法，但不实现它们。接口由一组方法签名组成，这些方法的具体实现由其他类型（如结构体）提供。

语法
  1. type InterfaceName interface{Method1(param1 ParamType1) ReturnType1
  2.     Method2(param1 ParamType2, param2 ParamType2) ReturnType2
  3.     // ...}
示例
  1. package main
  3. import"fmt"type Shape interface{Area()float64}type Circle struct{
  4.     Radius float64}func(c Circle)Area()float64{return math.Pi * c.Radius * c.Radius
  5. }funcmain(){var s Shape = Circle{Radius:5}
  6.     fmt.Println(s.Area())// 输出: 78.53981633974483}

在上述代码中，我们定义了一个

  1. Shape

接口和一个

  1. Circle

结构体。

  1. Circle

结构体实现了

  1. Shape

接口中的

  1. Area

方法。然后，我们将

  1. Circle

的实例赋值给

  1. Shape

接口类型的变量

  1. s

，并调用了

  1. Area

方法。

接口与多态

接口是实现多态性的关键。通过接口，我们可以编写不依赖于具体实现的代码，从而使代码更加灵活和可重用。

示例：使用接口实现多态
  1. package main
  3. import"fmt"type Shape interface{Area()float64}type Circle struct{
  4.     Radius float64}func(c Circle)Area()float64{return math.Pi * c.Radius * c.Radius
  5. }type Rectangle struct{
  6.     Width, Height float64}func(r Rectangle)Area()float64{return r.Width * r.Height
  7. }funcprintArea(s Shape){
  8.     fmt.Println(s.Area())}funcmain(){
  9.     circle := Circle{Radius:5}
  10.     rectangle := Rectangle{Width:4, Height:6}printArea(circle)// 输出: 78.53981633974483printArea(rectangle)// 输出: 24}

在上述代码中，我们定义了一个

  1. printArea

函数，它接受一个

  1. Shape

接口类型的参数。这意味着它可以接受任何实现了

  1. Shape

接口的类型的实例作为参数。这样，我们就实现了多态性。

4. 函数类型（Function Types）

定义与基本用法

在Go中，我们还可以定义函数类型，即函数的签名。函数类型允许我们将函数作为参数传递给其他函数，或者将函数作为返回值。

语法
  1. type FunctionName func(param1 ParamType1, param2 ParamType2) ReturnType
示例
  1. package main
  3. import"fmt"type AddFunc func(a, b int)intfuncadd(a, b int)int{return a + b
  4. }funcapply(f AddFunc, x, y int)int{returnf(x, y)}funcmain(){
  5.     result :=apply(add,5,3)
  6.     fmt.Println(result)// 输出: 8}

在上述代码中，我们定义了一个

  1. AddFunc

函数类型，它接受两个

  1. int

类型的参数并返回一个

  1. int

类型的结果。然后，我们定义了一个

  1. add

函数，它符合

  1. AddFunc

的签名。最后，我们定义了一个

  1. apply

函数，它接受一个

  1. AddFunc

类型的参数和两个

  1. int

类型的参数，并返回调用该函数的结果。

在Go语言中，

  1. type

关键字不仅用于定义基础的数据类型别名、结构体、接口和函数类型，还有一些高级用法和特性。接下来，我们将继续探讨 

  1. type

在Go语言中的其他用法。

5. 指针类型（Pointer Types）

虽然指针类型本身不是通过 

  1. type

关键字直接定义的（因为所有类型都可以有指针），但理解指针类型对于深入掌握Go语言至关重要。在Go中，指针类型允许我们直接访问变量的内存地址，并通过指针来修改变量的值。

示例
  1. package main
  3. import"fmt"funcmain(){
  4.     x :=10
  5.     p :=&x  // p 是一个指向 x 的指针
  6.     fmt.Println(*p)// 输出: 10*p =20// 通过指针修改 x 的值
  7.     fmt.Println(x)// 输出: 20}

在上面的代码中，

  1. &x

获取了变量 

  1. x

的内存地址，并将其赋值给指针变量 

  1. p

。

  1. *p

是对指针 

  1. p

进行解引用，即获取指针所指向的值。

6. 类型断言（Type Assertions）

类型断言提供了一种访问接口值底层具体值的方式。类型断言主要用于将接口类型的变量转换为具体的类型。

语法
  1. value, ok := x.(T)

如果 

  1. x

不是 

  1. T

类型，则 

  1. ok

会是 

  1. false

，且 

  1. value

会是 

  1. T

类型的零值。如果 

  1. x

是 

  1. T

类型，则 

  1. ok

会是 

  1. true

，且 

  1. value

会是 

  1. x

的值。

示例
  1. package main
  3. import"fmt"funcmain(){var i interface{}="hello"
  5.     s, ok := i.(string)if ok {
  6.         fmt.Println(s)// 输出: hello}else{
  7.         fmt.Println("类型断言失败")}// 尝试将i断言为int类型，会失败
  8.     n, ok := i.(int)if!ok {
  9.         fmt.Println("类型断言失败")}}

7. 类型选择（Type Switches）

类型选择是 

  1. switch

语句的一个变种，用于在多个类型之间进行选择。它通常与接口一起使用，以检查接口值持有的具体类型。

语法
  1. switch v := x.(type){case T1:// 处理 T1 类型的 vcase T2:// 处理 T2 类型的 v// ...default:// 处理所有其他类型}
示例
  1. package main
  3. import"fmt"funcdo(i interface{}){switch v := i.(type){caseint:
  4.         fmt.Printf("整型: %v\n", v)casestring:
  5.         fmt.Printf("字符串型: %q\n", v)default:
  6.         fmt.Printf("未知类型\n")}}funcmain(){do(21)do("hello")do(true)}

8. 自定义类型的方法

在Go中，你可以为任何自定义类型（结构体、类型别名等）定义方法。方法是附加到类型上的函数，其第一个参数是接收者（receiver），接收者指定了方法所属的类型。

示例
  1. package main
  3. import"fmt"type MyInt int// 为 MyInt 类型定义方法func(m MyInt)SayHello(){
  4.     fmt.Println("Hello from MyInt:", m)}funcmain(){var x MyInt =10
  5.     x.SayHello()// 输出: Hello from MyInt: 10}

9. 类型系统的高级特性

Go的类型系统还包含一些高级特性，如空接口（

  1. interface{}

）、隐式接口、类型嵌入（在结构体中使用）和接口的组合等。这些特性为Go提供了强大的灵活性和表达力。

空接口

空接口 

  1. interface{}

没有定义任何方法，因此任何类型都实现了空接口。空接口通常用于需要存储任意类型值的场景，如标准库中的 

  1. fmt.Println

函数和 

  1. json.Marshal

函数。

隐式接口

Go的接口是隐式的，意味着我们不需要显式声明一个类型实现了某个接口。只要类型实现了接口中定义的所有方法，那么它就自动实现了该接口。

类型的零值

Go中的每个类型都有一个零值。对于数值类型，零值是0；对于布尔类型，零值是

  1. false

；对于字符串，零值是空字符串

  1. ""

；对于指针、切片、映射、通道（channel）、函数和接口，零值是

  1. nil

。了解类型的零值对于编写健壮的Go代码至关重要。

10. 总结

Go语言中的 

  1. type

关键字是构建自定义数据类型和声明新类型的基础。通过类型别名、结构体、接口、函数类型等，Go提供了丰富的类型系统，使得我们可以编写出既灵活又强大的代码。掌握 

  1. type

的用法，是深入理解Go语言的关键。

标签： golang 开发语言 后端
本文转载自: https://blog.csdn.net/littlefun591/article/details/142549243
版权归原作者 景天科技苑 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【Golang】Go语言中type关键字到底是什么？”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？