Go语言面向对象和结构体_2021_11_08

最新推荐文章于 2022-01-12 10:07:49 发布
最新推荐文章于 2022-01-12 10:07:49 发布
阅读量175 收藏
点赞数
分类专栏： Go 文章标签： golang 开发语言 后端
自己的博客
本文链接：https://blog.csdn.net/quyixiao/article/details/121206683
版权
结构体

结构体是由一些列属性组成的复合数据类型，下面是一个简单的列子

package main

import "fmt"

type Counter int

type User map[string]string

func main() {

	var counter Counter = 20
	counter += 10
	fmt.Println(counter) //30

	me := make(User)
	me["username"] = "zhangsan"
	me["age"] = "30"
	fmt.Println(me) //map[age:30 username:zhangsan]

	fmt.Printf("%T ,%T \n", counter, me)

	var callback = func(args ...string) {
		for i, v := range args {
			fmt.Println(i, ":", v)
		}
	}

	callback("a", "a", "c")

	var counter2 int = 10
	fmt.Println(int(counter2) > counter2)

}
结构体的定义
package main

import "fmt"

type User struct {
	ID       int
	userName string
	age      int
	Addr     string
	remark   string
	tel      string
}

func main() {
	var user User
	fmt.Printf("%T \n", user) // main.User
	fmt.Printf("%#v\n", user) //main.User{ID:0, userName:"", age:0, Addr:"", remark:"", tel:""}

	var me2 = User{1, "张三", 10, "有道", "kwkw ", "182123455"}
	fmt.Printf("%#v\n", me2) //main.User{ID:1, userName:"张三", age:10, Addr:"有道", remark:"kwkw ", tel:"182123455"}

	var me3 = User{}
	fmt.Printf("%#v\n", me3)

	//指定属性名
	var me4 User = User{ID: 1, userName: "zhangsan", age: 10, Addr: "海南省", remark: "张", tel: "1845"}
	fmt.Printf("%#v\n", me4) //main.User{ID:1, userName:"zhangsan", age:10, Addr:"海南省", remark:"张", tel:"1845"}


	fmt.Printf("%T \n",&me3)	//*main.User 是一个指针类型


	var pointer *User
	fmt.Printf("%T \n",pointer)
	fmt.Printf("%#v \n",pointer)

	var point2 *User = &me2
	fmt.Printf("%#v \n",point2)
	var point3 *User = &User {}
	fmt.Printf("%#v \n",point3)

	//创建结构条的指针的时候，用new
	var pointer4 *User = new (User)
	fmt.Printf("%#v\n",pointer4)



}
结构体的使用
package main

import "fmt"

type MyUser struct {
	ID       int
	userName string
	age      int
	Addr     string
	remark   string
	tel      string
}

func main() {

	me := MyUser{
		userName: "kk",
		ID:       1,
		Addr:     "西安",
	}
	fmt.Println(me)

	me.tel = "182898329839"
	fmt.Printf("%#v\n", me)
	me2 := &MyUser{
		ID:       2,
		userName: "wuha",
	}

	fmt.Printf("%T \n", me2)
	(*me2).tel = "18389389238"

	fmt.Printf("%#v\n", me2)

	me2.Addr = "北京 "
	fmt.Printf("%#v\n", me2)
}
匿名结构体
package main

import "fmt"

func main() {
	var me struct {
		id   int
		name string
	}

	fmt.Printf("%#v\n", me) // struct { id int; name string }{id:0, name:""}

	me2 := struct {
		Id   int
		name string
	}{1, "2"}

	fmt.Printf("%#v \n", me2)						// struct { Id int; name string }{Id:1, name:"2"}

	
}
结构体中有另外的结构体
package main

import "fmt"

type Address struct {
	Region  string
	Streect string
	No      string
}

type User struct {
	Id   int
	Name string
	Addr Address
}

func main() {

	var me01 User
	fmt.Printf("%#v \n", me01) //main.User{Id:0, Name:"", Addr:main.Address{Region:"", Streect:"", No:""}}

	user := User{
		Id:   1,
		Name: "zhangsan",
		Addr: Address{
			Region:  "北京",
			Streect: "天水街道",
			No:      "002",
		},
	}
	fmt.Printf("%#v \n", user) //main.User{Id:1, Name:"zhangsan", Addr:main.Address{Region:"北京", Streect:"和", No:"002"}}
	fmt.Println(user.Addr.Streect) //天水街道	
}
匿名嵌入
package main

import "fmt"

type Address struct {
	Region  string
	Streect string
	No      string
}

type User struct {
	Id   int
	Name string
	Addr Address
}

type Employee struct {
	User
	Salary float64
}

func main() {

	var me Employee
	fmt.Printf("%T,%#v", me, me)//main.Employee,main.Employee{User:main.User{Id:0, Name:"", Addr:main.Address{Region:"", Streect:"", No:""}}, Salary:0}



}
指针结构体
package main

import "fmt"

type Address struct {
	Region  string
	Streect string
	No      string
}

type User struct {
	Id   int
	Name string
	Addr *Address
}

type Employee1 struct {
	*User
	Salary float64
	Name   string
}

func main() {
	var me01 User
	fmt.Printf("%#v \n", me01)

	me02 := User{
		Id:   1,
		Name: "kk",
		Addr: &Address{
			"西安市",
			"大山",
			"大模大样",
		},
	}
	fmt.Printf("%#v\n", me02)      //main.User{Id:1, Name:"kk", Addr:(*main.Address)(0xc00006e180)}
	fmt.Println(me02.Addr.Streect) //大山
	me02.Addr.Region = "北京市"
	fmt.Printf("%#v\n", me02.Addr) //&main.Address{Region:"北京市", Streect:"大山", No:"大模大样"}

	me03 := Employee1{
		User: &User{
			Id:   1,
			Name: "kk",
			Addr: &Address{
				"西安",
				"业路",
				"iodis",
			},
		},
	}
	fmt.Println(me03.Addr.Streect) //业路

	user1 := User{}
	user2 := user1
	user2.Name = "张三"
	fmt.Printf("%#v\n", user1) //main.User{Id:0, Name:"", Addr:(*main.Address)(nil)}
	fmt.Printf("%#v\n", user2) //main.User{Id:0, Name:"张三", Addr:(*main.Address)(nil)} 按值类型传递
	change(user1)
	fmt.Printf("%#v\n", user1)		//main.User{Id:0, Name:"", Addr:(*main.Address)(nil)} 按值类型传递
	changePoint(&user1)
	fmt.Printf("%#v\n", user1)		//main.User{Id:0, Name:"yyyyyyy", Addr:(*main.Address)(nil)} 按地址传递

	mex := User{
		Id: 1 ,
		Name: "kk ",
		Addr: &Address{"西安","锦业","001"},
	}
	mex2 := mex
	fmt.Println(mex2.Name)		//
	// fmt.Println(mex2.Addr.Streect ) //如果没有初始化 的话 panic: runtime error: invalid memory address or nil pointer dereference



}

func change(u User) {
	u.Name = "xxxxxx"
}

func changePoint(u * User ){
	u.Name = "yyyyyyy"
}
创建新用户
package main
import (
	"fmt"
)
type Address struct {
	Region  string
	Streect string
	No      string
}

type User struct {
	Id   int
	Name string
	Addr Address
}

func NewUser(id int, name string, region string) User {
	return User{
		Id:   id,
		Name: name,
		Addr: Address{
			Region: region,
		},
	}
}

func main() {
	me := User{}
	me2 := me
	me2.Name = "kk"
	fmt.Printf("%#v\n", me) //值类型
	fmt.Printf("%#v\n", me2)
	user := NewUser(1,"iodsoi","83ew98")
	fmt.Printf("%#v\n",user)		//main.User{Id:1, Name:"iodsoi", Addr:main.Address{Region:"83ew98", Streect:"", No:""}}

}


package main
import "fmt"
type Dog struct {
	Name string
}

func (dog Dog) Call(){
	fmt.Printf("%s :汪汪",dog.Name)
}

func main() {
	dog := Dog{"豆豆"}
	dog.Call()				//豆豆 :汪汪
}

package main

import "fmt"

type Address struct {
	Region string
	Street string
	No     string
}

func (addr Address) Addr() string {
	return fmt.Sprintf("%s-%s-%s ", addr.Region, addr.Street, addr.No)
}

type User struct {
	ID   int
	Name string
	Addr Address
}

func (user User) User() string {
	return fmt.Sprintf("[%d]%s:%s", user.ID, user.Name, user.Addr)
}

func (user User) String() string {
	return fmt.Sprintf("[%d]%s:%s", user.ID, user.Name, user.Addr)
}

func main() {
	var u User = User{
		ID:   1,
		Name: "kk",
		Addr: Address{
			Region: "89328",
			Street: "iuiods",
			No:     "iods",
		},
	}
	
	fmt.Printf("%#v\n", u)
	fmt.Println(u.User())      //[1]kk:{89328 iuiods iods}
	fmt.Println(u.Addr.Region) //89328
	fmt.Println(u)             //[1]kk:{89328 iuiods iods}

}

java中的this, 但是在go中一定需要写一个对象

package main

import (
	"fmt"
)

type User struct {
	id   int
	name string
}

func (user User) GetId() int {
	return user.id
}

func (user *User) SetId(id int) {
	user.id = id
}

func (user *User) GetName() string {
	return user.name
}

func (user *User) SetName(name string) {
	user.name = name
}

type Employee struct {
	User
	Salary float64
	name   string
}

func (employee Employee) GetName() string {
	return employee.name
}


func (employee * Employee) SetName(name string) {
	employee.name = name
}

func main() {
	u := User{
		id:   1,
		name: "张三",
	}
	u.SetId(10)
	fmt.Println(u.id)
	u.SetName("哈哈")
	fmt.Println(u.GetName()) //哈哈
	e := Employee{
		User:   User{1, "kk"},
		Salary: 1000,
		name:   "xiaoke",
	}
	fmt.Println(e.GetName())      		//xiaoke
	fmt.Println(e.User.GetName()) 		//kk
	e.SetName(" set userName ") 	//设置的是user的Name
	fmt.Println(e.GetName())      		// 获取到Employee的Name
	fmt.Println(e.User.GetName()) 		// 获取用户名
	e.SetName("哈哈")
	fmt.Println("----------",e.GetName())			// 哈哈
}

方法：
指针接收者
该使用的值接收者还是指针接收者，取决于是否现需要修改原始结构体，若不需要修改则使用值，若需要修改则使用指针，若存在指针接收者，则所有方法的使用指针接收者。
对于 接收者为指针类型的方法 ，需要注意在运行时若接收者为nil用会发生错误 。

若结构体中匿名嵌入带有方法的结构体时，则在外部结构体可以嵌入结构体的方法，并且 在调用时只有嵌入字段会传递给嵌入结构体方法的接收者。
当被嵌入结构体与嵌入结构体具有相同的名称时，则使用对象，方法名调用被嵌入结构体方法，若想要调用嵌入结构体方法，则使用对象嵌入结构体名，方法 。

方法值/方法表达式
方法可以赋值给变量，存储在数组，切片，映射中，可以作为参数传递给函数返回值进行返回 。
方法有两种，一种时使用对象/对象指针调用的方法值，另外一种有类型，类型调用的（方法表达式）
方法值 。
在方法表达式赋值时若方法接收者为值类型，则在赋值时会将值类型拷贝（或调用为指针类型则自动解引用拷贝）

package main

import "fmt"

type Dog struct {
	name string
}


func (dog Dog) Call() {
	fmt.Printf("%s: 汪汪:", dog.name)
}

func (dog *Dog) SetName(name string) {
	dog.name = name
}

func main() {
	dog := Dog{"豆豆"}
	m1 := dog.Call
	fmt.Printf("%T \n", m1)
	m1()
}

package main

import "fmt"

type Dog struct {
	name string
}

func (dog Dog) Call() {
	fmt.Printf("%s %#v  : 汪汪\n", dog.name,&dog)

}

func (dog * Dog) CallPoint() {
	fmt.Printf("%s %#v  : 汪汪\n", dog.name,&dog)

}


func (dog *Dog) SetName(name string) {
	dog.name = name
	fmt.Printf("%#v \n",&dog)
}

func main() {
	dog := Dog{"豆豆"}
	m1 := dog.Call
	fmt.Printf("%T \n", m1)	//func()
	m1()							// 豆豆 : 汪汪

	dog.SetName("小黑")	//
	m1()						//豆豆 : 汪汪

	fmt.Println("============================")

	// 对于值接收者方法 者会拷备一份
	pdog := &Dog{"豆豆"}
	m2 := pdog.Call

	fmt.Printf("%T \n",m2)		//func()
	m2()						//豆豆 : 汪汪

	pdog.SetName("小黑")
	m2()					//豆豆 : 汪汪


	fmt.Println("============================")

	// 对于值接收者方法 者会拷备一份
	pdog1 := &Dog{"豆豆"}
	m3 := pdog1.CallPoint

	fmt.Printf("%T \n",m3)		//func()
	m3()						//豆豆 (**main.Dog)(0xc00000e040)  : 汪汪

	pdog1.SetName("小黑")
	m3()					//小黑 (**main.Dog)(0xc00000e050)  : 汪汪

}
结构体排序
package main

import (
	"fmt"
	"sort"
)

type User struct {
	ID   int
	Name string
}

func main() {

	list := [][2]int{{1, 3}, {5, 9}, {4, 3}, {6, 2}}

	//使用数组中第二个元素比较大小,元素比较大小进行排序
	sort.Slice(list, func(i, j int) bool {
		return list[i][1] < list[j][1]
	})
	fmt.Println(list) //从小到大开始排序
	users := []User{
		{ID: 1, Name: "zhangsan"},
		{ID: 2, Name: "lisi"},
		{ID: 4, Name: "wangwu"},
		{ID: 3, Name: "zhaoliu"},
	}
	sort.Slice(users, func(i, j int) bool {
		return users[i].ID < users[j].ID //从小到大开始排序
	})
	fmt.Println(users) //[{1 zhangsan} {2 lisi} {3 zhaoliu} {4 wangwu}]

}

作业 将用户管理系统改成结构体

package manager

import (
	"fmt"
	"sort"
	"strings"
)

type User struct {
	ID       int
	RealName string
}

//添加用户
func AddUser(users *[]User) {
start:
	var (
		id   int
		name string
	)
	fmt.Println("请输入姓名或退出(q/Q)：")
	fmt.Scan(&name)

	if name == "q" || name == "Q" {
		return
	}
	if exits(users, name) {
		fmt.Println(name, " 名字已经存在")
		goto start
	}
	id = GetmaxId(users)
	user := User{ID: id, RealName: name}
	*users = append(*users, user)
	for _, v := range *users {
		fmt.Printf("%#v \t ", v)
	}
	fmt.Println()
	goto start
}

func exits(users *[]User, name string) bool {
	for _, v := range *users {
		if strings.Contains(v.RealName, name) {
			return true
		}
	}
	return false
}

func GetmaxId(users *[]User) int {
	maxId := 1
	for _, v := range *users {
		if maxId < v.ID {
			maxId = v.ID
		}
	}
	maxId = maxId + 1
	return maxId
}

//更新用户
func UpdateUser(users *[]User) {
	fmt.Println("请输入要修改用户姓名:")
	var inputId string
	fmt.Scan(&inputId)
	xx := strings.Split(inputId, "_")
	fmt.Println(xx)
	for _, v := range *users {
		if strings.Contains(v.RealName, xx[0]) {
			v.RealName = xx[1]
			break
		}
	}
}

//删除用户
func DeleteUser(users *[]User) {

start:
	fmt.Println("请删除用户姓名:")
	var inputId string
	fmt.Scan(&inputId)
	if inputId == "q" || inputId == "Q" {
		return
	}
	if inputId == "all" {
		*users = []User{}
	} else {
		for k, v := range *users {
			if strings.Contains(v.RealName, inputId) {
				*users = append((*users)[:k], (*users)[k+1:]...)
				break
			}
		}
	}
	goto start
}

//
func QueryUser(users *[]User) {
start:
	fmt.Println("请输入要查询的用户姓名或退出(q/Q):")
	var inputId string
	fmt.Scan(&inputId)
	if inputId == "q" || inputId == "Q" {
		return
	}
	if inputId == "all" {
		sort.Slice(*users, func(i, j int) bool {
			return (*users)[i].RealName > (*users)[j].RealName
		})
		for _, v := range *users {
			fmt.Printf("%5d | %20s\n", v.ID, v.RealName)
		}
	} else {
		for _, v := range *users {
			if strings.Contains(v.RealName, inputId) {
				fmt.Printf("%5d | %20s \n", v.ID, v.RealName)
				break
			}
		}
	}
	goto start
}



package main

import (
	"fmt"
	"go_learn/20211111/codes/manager"
	"os"
)

func main() {
	callbacks := map[string]func(users *[]manager.User){
		"1": manager.AddUser,
		"2": manager.UpdateUser,
		"3": manager.DeleteUser,
		"4": manager.QueryUser,
	}
	fmt.Println(callbacks)
	//存储用户信息
	users := []manager.User{}
	fmt.Println("欢迎使用用户管理系统：")
	//id := 0
	for {
		var op string
		fmt.Println(`请输入指令：
1.新建用户 2.修改用户 3.删除用户 4.查询用户 q.退出`)
		fmt.Scan(&op)
		if "q" == op {
			os.Exit(500) //直接退出
		}
		callbacks[op](&users)
	}

}

github地址
https://github.com/quyixiao/go_learn.git

柳擎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go基础之面向对象（结构体与方法篇）
coding
08-29 1469
go语言的面向对象相对简单，只支持封装，不支持继承和多态，go中用面向接口来做继承和多态的任务 go中没有class ,只有struct struct的创建 type treeNode struct {     value int     left, right *treeNode } struct的声明和初始化 //声明一个结构体类型     var root treeNode   ...
Golang结构体与面向对象
Erick Lv的笔记
11-28 425
结构体和内嵌类型 结构体是Golang中面向对象的核心，Golang允许内嵌类型，内嵌可以理解为使用组合来实现继承，给出代码示例： package main import "fmt" type SmallFoo struct { name string money float64 } func (smallFoo *SmallFoo) Talk() { fmt.Print...
go-结构体与面向对象 3
weixin_44102152的博客
05-14 239
一、go结构体 结构体的定义 指针与结构体 初始化结构体 类型别名和自定义类型 二、go面向对象-结构体与接口 构造函数 方法 方法与指针 嵌套结构体下《继承》 方法规则 接口
【Go】 结构体形式的面向对象
风景旧曾谙
06-12 180
对象，是一个永恒的话题 —— 开发实习生 面向对象 Go 里面的面向对象，没有继承，没有多态这些花里胡哨的东西，它就一个封装。 结构体 func main() { var root TreeNode root = TreeNode{value: 0} root.left = &TreeNode{} root.right = &TreeNode{nil , nil , 1} root.right.left = new(TreeNode) fmt.Println(root) }
17《Go语言入门》面向对象和结构体
干志雄的博客
02-25 275
这是我纯手写的《Go语言入门》，手把手教你入门Go。源码+文章，看了你就会????，此处应有掌声????????????！ 文章中所有的代码我都放到了github.com/GanZhiXiong/go_learning这个仓库中。在看文章的时候，对照仓库中代码学习效果更佳！ 目录Go是不是面向对象编程语言？Go的类（class）结构体定义实例化结构体初始化结构体使用“键值对”初始化结构体使用多个值的列表初始化结构体结构体成员只能包含结构体的指针类型使用结构体的指针作为函数参数支持???? Go是不是面向对
Go.rar_Go_ Go_ Go!_golang
最新发布
09-22
Go语言，又称Golang，是由Google开发的一种静态类型的、编译型的、并发型的、垃圾回收的编程语言。它的设计目标是提高编程效率、系统性能以及代码的可读性。Go语言以其简洁的语法、高效的并发模型以及强大的标准库在...
Go语言基础之面向对象编程
01-07
Go语言并没有沿袭传统面向对象编程中的诸多概念 封装：通过方法实现 继承：通过匿名字段实现 多态：通过接口实现 一、匿名组合 1. 匿名字段 匿名字段（嵌入字段）： go支持只提供类型，而不写字段名的方式 匿名字段...
韩顺平_Go语言核心编程完整版笔记.zip
08-22
2. **函数与方法**：讲解Go语言的函数定义、参数传递和返回值，以及面向对象编程中的方法和接口。 3. **包与导入**：阐述Go语言的模块化设计，包括包的组织、导入选项以及如何使用标准库和其他外部包。 4. **并发...
Go语言中面向对象
01-20
面向对象： Go语言中没有明确的OOP（Object Oriented Programming）概念。 Go语言只提供了两个关键类型：struct，interface。 1、struct与C++语言中的普通struct相似，在Go语言中是借助着struct结构体才实现的 2、...
Go语言教程之结构体
01-20
结构体在Go语言中的地位与面向对象语言中的类类似，但Go并不支持传统的面向对象特性如继承和多态。 对象是面向对象编程的核心概念。在编程中，对象是对现实世界中实体的一种抽象，它包含了属性（数据成员）和方法...
golang该如何循环 多层结构体
01-20
一：首先贴代码（你们大概看看就行，在看看后面的数据 你们就能理解 结构体嵌套的案例） 如果是PHP就方便很多，直接数组嵌套数组就行，也就是二维数组。 package model import ( fmt time ) type Find struct { Article []Article SelectArticle []SelectArticle RecoArticle []SelectArticle SelectLabel []SelectLabel IndexAbout SiteInfo IndexContact SiteInfo }
Go---面向对象（结构体）
weixin_47328424的博客
01-12 282
Golang语言面向对象编程说明 1) Golang也支持面向对象编程(OOP),但是和传统的面向对象编程有区别，并不是纯粹的面向对象语言。所以说Golang支持面向对象编程特性是比较准确的。 2) Golang没有类(lass)， Go语言的结构体(struct)和其它编程语言的类(class)有同等的地位，你可以理解Golang是基于struct来实现OOP特性的。 3) Golang面向对象编程非常简洁，去掉了传统OOP语言的继承、方法重载、构造函数和析构函数、隐藏的this指针等等 4) Gola
GO语言使用之面向对象编程(2)——结构体
Science Explorer
08-13 253
一、什么是结构体？有什么作用？ 1、 结构体是自定义的数据类型，代表一类事物. 2、结构体变量(实例)是具体的，实际的，代表一个具体变量 其实go中的结构体作用有点像Java中的类。 type cat struct{ Name string age int Price float64 } 3、内存分析图： 二、声明结构体 1、 基本语法 type 结...
Go语言学习(十二)面向对象编程-结构体
mChenys的博客
05-09 1850
1.结构体的初始化方式例如自定义一个结构体package mainimport( "fmt" ) type Rect struct{ //type和struct为关键字 x,y float64 //结构体成员 widh,height float64 }func (r *Rect) Area() float64{ return r.width * r.height
Go语言面向对象之结构体和方法
Radioman-lhq的博客
02-11 240
一、面向对象 1.go语言仅支持封装，不支持继承和多态 2.go语言中没有class，只有struct 二、结构的定义 type TreeNode struct { Left, Right *TreeNode Value int } 三、结构的创建 1.不论地址还是结构本身，一律使用.来访问成员 2.使用自定义工厂函数 3.注意返回了局部变量的地址 示例1： type treeNode str...
GO 面向对象之结构体和方法
风中的劲草
07-02 965
文章目录 一、结构体 1.1 如何定义结构体 1.2 如何创建结构体 1.3 递归结构体 1.4 结构体转换 1.5 访问结构体中的成员 1.6 结构体作为参数 1.7 带标签的结构体 1.8 匿名字段 1.9 内嵌结构体 1.10 命名冲突 1.11 值语义 和 引用语义 1.12 二叉树 二、方法 2.1 方法声明 2.2 方法和函数的区别 2.3 如何扩展任意类型的方法 2.4 工厂模式 2.5 方法
Golang教程：（二十六）go面向对象编程--结构体代替类
zhangbohh8662的博客
02-14 6319
原文地址：https://golangbot.com/structs-instead-of-classes/欢迎来到第二十六讲。GO是面向对象的吗？go并不是一个纯面向对象编程语言。下面是从Go的FAQs上面摘录的一些关于go是不是面向对象语言的答复。Yes and no. Although Go has types and methods and allows an object-oriente...
go 结构体和类 函数和方法 接口
云飞的博客
09-09 3285
go中没有类的概念，只有结构体。 定义结构体使用type struct 关键字 type typeName struct { var1 Type var2 Type ... varn Type } 其它面向对象的语言中类包含属性和方法，go中定义类的方法和定义函数很像 定义函数： func funcName (param Type ...) returnT...
三层嵌套对象数组怎么解构_嵌套解构
Web 开发&软件开发
08-07 2835
嵌套解构 使用JavaScript进行结构分解最初可能会感到困惑，但事实是，结构分解可以使您的代码更具逻辑性和直截了当。 当您要寻找一个具有多个对象深层的属性时，解构的过程看起来会更加复杂，因此让我们来看看如何做到这一点！ 简单的解构如下所示： const { target } = event; 在这里，我们使用{}和=来命名与属性名称相同的变量（ 在解构时也可以使用别名！ ）。 但...
Go语言面向对象编程实践：抽象与封装示例
本资源主要探讨了Go语言中的面向对象编程思想，特别是抽象和封装。 在Go语言中，我们通过定义结构体来实现抽象，将一组相关属性（字段）和行为（方法）组合在一起，形成一个对象的模型。例如，`Account` 结构体就...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值