golang 结构体总结

最新推荐文章于 2024-04-25 20:12:07 发布
最新推荐文章于 2024-04-25 20:12:07 发布
阅读量743 收藏
点赞数
文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/geek99_guo/article/details/121752993
版权

golang 结构体

关注公众号 免费领取golang视频教程

file

go语言没有面向对象的概念了，但是可以使用结构体来实现，面向对象编程的一些特性，例如：继承、组合等特性。

go语言结构体的定义

上一节我们介绍了类型定义，结构体的定义和类型定义类似，只不过多了一个struct关键字，语法结构如下：

type struct_variable_type struct {
   member definition;
   member definition;
   ...
   member definition;
}

type：结构体定义关键字

struct_variable_type：结构体类型名称

struct：结构体定义关键字

member definition;：成员定义

实例

下面我们定义一个人的结构体Person

type Person struct {
    id    int
    name  string
    age   int
    email string
}

以上我们定义一个Person结构体，有四个成员，来描述一个Person的信息。

形同类型的可以合并到一行，例如：

type Person struct {
    id, age     int
    name, email string
}

声明一个结构体变量

声明一个结构体变量和声明一个普通变量相同，例如：

var tom Person
fmt.Printf("tom: %v\n", tom)
kite := Person{}
fmt.Printf("kite: %v\n", kite)

也行结果

tom: {0 0  }
kite: {0 0  }

结构体成员，在没有赋值之前都是零值。

访问结构体成员

可以使用点运算符(.)，来访问结构体成员，例如：

package main

import "fmt"

func main() {
    type Person struct {
        id, age     int
        name, email string
    }

    var tom Person
    tom.id = 1
    tom.name = "tom"
    tom.age = 20
    tom.email = "tom@gmail.com"
    fmt.Printf("tom: %v\n", tom)
}

运行结果如下

tom: {1 20 tom tom@gmail.com}

匿名结构体

如果结构体是临时使用，可以不用起名字，直接使用，例如：

package main

import "fmt"

func main() {
    var dog struct {
        id   int
        name string
    }
    dog.id = 1
    dog.name = "花花"
    fmt.Printf("dog: %v\n", dog)
}

golang结构体的初始化

未初始化的结构体，成员都是零值 int 0 float 0.0 bool false string nil nil

实例

package main

import "fmt"

func main() {
    type Person struct {
        id, age     int
        name, email string
    }

    var tom Person
    fmt.Printf("tom: %v\n", tom)
}

运行结果

tom: {0 0 "" ""}

使用键值对对结构体进行初始化

实例

package main

import "fmt"

func main() {
    type Person struct {
        id, age     int
        name, email string
    }

    kite := Person{
        id:    1,
        name:  "kite",
        age:   20,
        email: "kite@gmail.com",
    }
    fmt.Printf("kite: %v\n", kite)
}

运行结果

kite: {1 20 kite kite@gmail.com}

使用值的列表初始化

实例

package main

import "fmt"

func main() {
    type Person struct {
        id, age     int
        name, email string
    }

    kite := Person{
        1,
        20,
        "kite",
        "kite@gmail.com",
    }
    fmt.Printf("kite: %v\n", kite)
}

运行结果

kite: {1 20 kite kite@gmail.com}

注意：

  1. 必须初始化结构体的所有字段。
  2. 初始值的填充顺序必须与字段在结构体中的声明顺序一致。
  3. 该方式不能和键值初始化方式混用。

部分成员初始化

用不到的成员，可以不进行初始化

package main

import "fmt"

func main() {
    type Person struct {
        id, age     int
        name, email string
    }

    kite := Person{
        id:   1,
        name: "kite",
    }
    fmt.Printf("kite: %v\n", kite)
}

运行结果

kite: {1 0 kite "" }

golang结构体指针

结构体指针和普通的变量指针相同，我先来回顾一下普通变量的指针，例如：

package main

import "fmt"

func main() {
    var name string
    name = "tom"
    // p_name 指针类型
    var p_name *string
    // &name 取name地址
    p_name = &name
    fmt.Printf("name: %v\n", name)
    // 输出指针地址
    fmt.Printf("p_name: %v\n", p_name)
    // 输出指针指向的内容值
    fmt.Printf("*p_name: %v\n", *p_name)
}

运行结果

name: tom
p_name: 0xc00010e120
*p_name: tom

go结构体指针

实例

package main

import "fmt"

func main() {
    type Person struct {
        id   int
        name string
    }

    var tom = Person{1, "tom"}

    var p_person *Person
    p_person = &tom
    fmt.Printf("tom: %v\n", tom)
    fmt.Printf("p_person: %p\n", p_person)
    fmt.Printf("*p_person: %v\n", *p_person)
}

运行结果

tom: {1 tom}
p_person: 0xc000004078
*p_person: {1 tom}

使用new关键字创建结构体指针

我们还可以通过使用new关键字对结构体进行实例化，得到的是结构体的地址，例如：

package main

import "fmt"

func main() {
    type Person struct {
        id   int
        name string
    }

    var p_person = new(Person)
    fmt.Printf("p_person: %T\n", p_person)
}

运行结果

p_person: *main.Person

从运行结果，我们发现p_person为指针类型

访问结构体指针成员

访问结构体指针成员，也使用点运算符(.)，例如：

package main

import "fmt"

func main() {
    type Person struct {
        id   int
        name string
    }

    var p_person = new(Person)
    fmt.Printf("p_person: %T\n", p_person)

    p_person.id = 1
    p_person.name = "tom"
    fmt.Printf("*p_person: %v\n", *p_person)
}

运行结果

p_person: *main.Person
*p_person: {1 tom}

golang结构体作为函数参数

go结构体可以像普通变量一样，作为函数的参数，传递给函数，这里分为两种情况：

  1. 直接传递结构体，这是是一个副本（拷贝），在函数内部不会改变外面结构体内容。
  2. 传递结构体指针，这时在函数内部，能够改变外部结构体内容。

直接传递结构体

实例

package main

import "fmt"

type Person struct {
    id   int
    name string
}

func showPerson(person Person) {
    person.id = 1
    person.name = "kite"
    fmt.Printf("person: %v\n", person)
}

func main() {
    person := Person{1, "tom"}
    fmt.Printf("person: %v\n", person)
    fmt.Println("----------------")
    showPerson(person)
    fmt.Println("----------------")
    fmt.Printf("person: %v\n", person)
}

运行结果

person: {1 tom}
----------------
person: {1 kite}
----------------
person: {1 tom}

从运行结果可以看出，函数内部改变了结构体内容，函数外面并没有被改变。

传递结构体指针

实例

package main

import "fmt"

type Person struct {
    id   int
    name string
}

func showPerson(person *Person) {
    person.id = 1
    person.name = "kite"
    fmt.Printf("person: %v\n", person)
}

func main() {
    person := Person{1, "tom"}
    fmt.Printf("person: %v\n", person)
    fmt.Println("----------------")
    showPerson(&person)
    fmt.Println("----------------")
    fmt.Printf("person: %v\n", person)
}

运行结果

person: {1 tom}
----------------
person: &{1 kite}
----------------
person: {1 kite}

从运行结果，我们可以看到，调用函数后，参数被改变了。

golang嵌套结构体

go语言没有面向对象编程思想，也没有继承关系，但是可以通过结构体嵌套来实现这种效果。

下面通过实例演示如何实现结构体嵌套，加入有一个人Person结构体，这个人还养了一个宠物Dog结构体。

下面我们来看一下：

Dog结构体

type Dog struct {
    name  string
    color string
    age   int
}

Person结构体

type person struct {
    dog  Dog
    name string
    age  int
}

访问它们

package main

import "fmt"

type Dog struct {
    name  string
    color string
    age   int
}

type person struct {
    dog  Dog
    name string
    age  int
}

func main() {
    var tom person
    tom.dog.name = "花花"
    tom.dog.color = "黑白花"
    tom.dog.age = 2

    tom.name = "tom"
    tom.age = 20

    fmt.Printf("tom: %v\n", tom)
}

运行结果

tom: {{花花 黑白花 2} tom 20}

golang继承

golang本质上没有oop的概念，也没有继承的概念，但是可以通过结构体嵌套实现这个特性。

例如

package main

import "fmt"

type Animal struct {
    name string
    age  int
}

func (a Animal) eat() {
    fmt.Println("eat...")
}

func (a Animal) sleep() {
    fmt.Println("sleep")
}

type Dog struct {
    Animal
}

type Cat struct {
    Animal
}

func main() {
    dog := Dog{
        Animal{
            name: "dog",
            age:  2,
        },
    }

    cat := Cat{
        Animal{name: "cat",
            age: 3},
    }

    dog.eat()
    dog.sleep()

    cat.eat()
    cat.sleep()

}

golang模拟OOP的属性和方法

golang没有面向对象的概念，也没有封装的概念，但是可以通过结构体struct和函数绑定来实现OOP的属性和方法等特性。接收者 receiver 方法。

例如，想要定义一个Person类，有name和age属性，有eat/sleep/work方法。

package main

import "fmt"

type Person struct {
    name string
    age  int
}

func (per Person) eat() {
    fmt.Println("eat...")
}

func (per Person) sleep() {
    fmt.Println("sleep...")
}

func (per Person) work() {
    fmt.Println("work...")
}

func main() {
    per := Person{
        name: "tom",
        age:  20,
    }

    fmt.Printf("per: %v\n", per)

    per.eat()
    per.sleep()
    per.work()
}

golang构造函数

golang没有构造函数的概念，可以使用函数来模拟构造函数的的功能。

例如

package main

import "fmt"

type Person struct {
    name string
    age  int
}

func NewPerson(name string, age int) (*Person, error) {
    if name == "" {
        return nil, fmt.Errorf("name 不能为空")
    }
    if age < 0 {
        return nil, fmt.Errorf("age 不能小于0")
    }
    return &Person{name: name, age: age}, nil
}

func main() {
    person, err := NewPerson("tom", 20)
    if err == nil {
        fmt.Printf("person: %v\n", *person)
    }
}

关注公众号 免费领取golang视频教程

file

多课网_老郭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Golang结构体和map
01-07
Golang 文章目录Golang1 struct2 map3 struct补充 1 struct 在Golang中没有对象,但是有面向对象的思想,有继承,多态,封装的思想。 但是缺少了class,而取而代之的是struct(结构体) 下面的是几种结构体的初始化方法4种...
gova:golang结构体的验证工具
07-04
#gova 它使用结构标记提供验证功能。 ＃＃如何使用？ ...type MyType struct { FirstName string `length:"20" pattern:"[A-Z][a-z]*"` LastName string `length:"20" pattern:"[A-Z][a-z]*"` ...
Golang 结构体
weixin_47243236的博客
12-19 2482
1. 结构体 Golang 也支持面向对象编程（OOP），但其并不是纯粹的面对对象，可以说是 Golang 支持面对对象编程。Golang 中没有类（class）的概念，Golang 中提供了结构体（struct）的概念用于实现 OOP 特性。 Golang 的面对对象编程十分简洁，去除了传统 OOP 的方法重载、构造函数、隐式的 this 指针等。Golang 具有封装、继承、多态的特性，实现方式与其他的 OOP语言不同，比如继承没有 extends 关键字，而是通过匿名类字段实现等。 1.1 定义结构体
数据结构【Golang实现】(五)——栈
脑袋装水的博客
03-15 1146
《Go语言》实现顺序栈以及链式栈。
Golang深入浅出之-Go语言结构体（struct）入门：定义与使用
最新发布
zevjay的博客
04-25 624
Age intAddress Address // 内嵌结构体Zip string上述代码定义了一个名为Person的结构体，包含Name（字符串类型）、Age（整型）两个字段，以及内嵌的Address结构体。结构体的定义简洁明了，字段间以逗号分隔，类型紧跟字段名。常见问题与避免方法问题1：未初始化的结构体字段默认值Go语言结构体的字段如果没有显式初始化，其默认值取决于字段类型。对于数值类型，如intfloat64等，默认为零值；对于字符串类型，默认为空字符串；
Golang基础(结构体、方法)
qq_31387691的博客
10-20 468
一.结构体 结构体解释:将一个或多个变量组合到一起,形成新的类型.这个类型就是结构体 Go语言中的结构体和C++结构体有点类似,而Java或C#中类本质就是结构体 结构体是值类型 结构体定义语法 通过语法可以看出,Go语言发明者明确认为结构体就是一种自定义类型 type 结构体名称 struct{ 名称 类型//成员或属性 } 二. 代码示例 定义结构体 结构体可以定义在函数内部或函数外部(与普通变量一样...
Golang 入门 : 结构体(struct)
weixin_30753873的博客
04-25 833
Go 通过类型别名(alias types)和结构体的形式支持用户自定义类型，或者叫定制类型。试图表示一个现实世界中的实体。 结构体由一系列命名的元素组成，这些元素又被称为字段，每个字段都有一个名称和一个类型。结构体的目的就是把数据聚集在一起，以便能够更加便捷地操作这些数据。结构体的概念在 C 语言里很常见，被称为 struct。Golang 中的结构体也是 struct。Go 语言中没有类的概...
golang中结构体
LeoHan
05-02 1548
golang其实并不是一个完全意义上的面向对象语言，其实现面向对象的多态主要基于接口和结构体实现。 在golang中结构体与c/c++中的结构体类似，用来定义复杂的数据类型，一般结构体定义如下： type StructName struct{ fieldName1 type1 fidldName2 type2 ... } 需要注意的是： 结构体的包名在同一个包内必须唯一，不能重复 结构体的字段必须唯一，不能重复 同类型的结构体字段可以放在一行定义 一般结构体实例化可以通过如下方
golang结构体与json格式串实例代码
01-03
具体代码如下所示： package main import ( encoding/json fmt ) type IT struct { //一定要注意这里的成员变量的名字首字母必须是大写 Company string Subjects []string Isok bool ... s := IT{zyg, []string{...
sql2struct:一个开发者友好的使用sql生成golang结构体的工具
05-29
SQL2Struct是一款对golang开发者友好的chrome插件，根据在mysql中创建数据表的sql语句，自动生成golang中的struct，在golang开发者使用诸如gorm之类的框架时，可以很好的把mysql中的数据表与orm的结构体关联起来。...
Golang结构体
qq_53267860的博客
01-27 284
面向对象编程 结构体 Golang语言面向对象编程说明 Golang也支持面向对象编程(OOP)，但是和传统的面向对象编程有区别，并不是纯粹的面向对象语言。所以我们说Golang支持面向对象编程特性是比较准确的。 Golang没有类(class)，Go语言的结构体(struct)和其它编程语言的类(class)有同等的地位，你可以理解Golang是基于struct来实现OOP特性的。 Golang面向对象编程非常简洁，去掉了传统OOP语言的继承、方法重载、构造函数和析构函数、隐藏的this指针等等 Gol
Kite框架文档.pdf
05-14
字节跳动后台开发框架 kite
golang 类型的初始化和寻址问题
much efforts, much luck
08-05 1351
一、类型初始化 1、基本数据类型 2、函数类型:初始值为nil var test func() //初始值为nil 函数字面量类型的语法表达格式是 func (InputTypeList) OutputTypeList， “有名函数”和“匿名函数(没有函数名类似闭包)”的类型都属于函数字面量类型，有名函数的定义相当于初始化一个函数字面量类型后将其赋值给一个函数名变量，“匿名函数”的定义也是直接初始化一个函数字面量类型，只是没有绑定到一个具体函数名变量上。从 Go 类型系统的角度来看，“有名函数”和“匿
go结构体定义
u011290064的博客
12-29 807
type person struct{ name string age int } 定义结构体 调用结构体 p:= person{ name:"jiangguangxun", age:29, } 作者：蒋光洵
golang结构体
acr7720的博客
10-24 79
声明结构体 定义结构体使用struct关键字。在结构体内部定义它们的成员变量和类型。如果成员变量的类型相同还可以把它们写到同一行。 struct里面可以包含多个字段（属性） struct类型可以定义方法，注意和函数的区分 struct类型是值类型 struct类型可以嵌套 golang中没有class类型，只有struct golang中没有pub...
Golang入门教程（十四）结构体和类详解
Tinywan
03-15 4621
golang中并没有明确的面向对象的说法，实在要扯上的话，可以将struct比作其它语言中的class。 类声明 type Book struct { Title string Author string intro string } 　　这样就声明了一个类，其中没有public、protected、private的的声明。golang用另外一种做法来实...
go语言结构体定义使用
JieLinDee的专栏
05-20 2280
package main import ( "fmt" "sync" ) type Info struct { info map[int]string mu sync.RWMutex } func main() { x := &Info{info: make(map[int]string)} x.Set(1, "golang
Golang教程：（十六）结构体
zhangbohh8662的博客
02-06 9797
欢迎来到Golang系列教程的第十六篇。 什么是结构体 结构体（struct）是用户自定义的类型，它代表若干字段的集合。有些时候将多个数据看做一个整体要比单独使用这些数据更有意义，这种情况下就适合使用结构体。 比如将一个员工的 firstName, lastName 和 age 三个属性打包在一起成为一个 employee 结构就是很有意义的。 结构体的声明 type E
Golang 之 面向对象struct ，定义结构体方法(二)
JaysenLeo
07-22 2354
package main import &amp;quot;fmt&amp;quot; type treeNode struct { value int left, right * treeNode } func (node treeNode) print() { fmt.Println(node.value) } // 说明其传值 func (node treeNode) setNode(val...
golang 结构体初始化
08-26
- *3* [Golang结构体和map](https://download.csdn.net/download/weixin_38731199/14037169)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

多课网_老郭

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值