GoLang之方法调用系列二

已于 2022-05-10 09:16:33 修改
阅读量604 收藏 1
点赞数
分类专栏： GoLang底层 文章标签： golang 学习 开发语言
于 2022-03-07 18:03:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52690231/article/details/123335762
版权

文章目录

GoLang之方法调用系列二

1.方法定义

func (recevier type) methodName(参数列表)(返回值列表){}

1.一个包含了接受者的函数，接受者可以是命名类型、结构体类型、指针;

2.只能为当前包内命名类型定义方法；

3.不支持方法重载，receiver 只是参数签名的组成部分；

4.Golang 方法总是绑定对象实例，并隐式将实例作为第一实参 (receiver)；

5.参数 receiver 可任意命名，如方法中未曾使用 ，可省略参数名；

6.参数 receiver 类型可以是 T 或 *T ;

7.参数和返回值可以省略 ；

8.可用实例 value 或 pointer 调用全部方法，编译器自动转换

package main
type Test struct{}
// 无参数、无返回值
func (t Test) method0() {}
// 单参数、无返回值
func (t Test) method1(i int) {
}
// 多参数、无返回值
func (t Test) method2(x, y int) {
}
// 无参数、单返回值
func (t Test) method3() (i int) {
    return
}
// 多参数、多返回值
func (t Test) method4(x, y int) (z int, err error) {
    return
}
func main() {}  

package main
// 无参数、无返回值
func (t *Test) method5() {
}
// 单参数、无返回值
func (t *Test) method6(i int) {
}
// 多参数、无返回值
func (t *Test) method7(x, y int) {
}
// 无参数、单返回值
func (t *Test) method8() (i int) {
    return
}
// 多参数、多返回值
func (t *Test) method9(x, y int) (z int, err error) {
    return
}
func main() {}

2.值类型调用方法(值接收者)

a := A{name: “eggo”}
a.Name()//等效于A.Name(a)

type A struct {
	name string
}

func (a A) Name() string {
	a.name = "Hi!"
	return a.name
}

func main() {
	a := A{name: "eggo"}
     //可用实例 value调用方法，编译器自动转换
    a.Name()//等效于A.Name(a)
	fmt.Println(a.name)//输出：aggo
}
//注意，当接受者不是一个指针时，该方法操作对应接受者的值的副本(意思就是即使你使用了指针调用函数，但是函数的接受者是值类型，所以函数内部操作还是对副本的操作，而不是指针操作

a.Name()等效于A.Name(a)

type A struct {
	name string
}

func (a A) Name() string {
	a.name = "Hi!" + a.name
	return a.name
}

func main() {
	a := A{name: "eggo"}
	//不能写成fmt.Println(a.name(a))
	//以下中a.Name()与A.Nmae(a)两种方式是一样的
	fmt.Println(a.Name())  //输出：Hi!eggo
	fmt.Println(A.Name(a)) //输出；Hi!eggo
}


type A struct {
	name string
}

func (a A) Name() string {
	a.name = "Hi!"
	return a.name
}

func main() {
	fmt.Println(A.Name(A{name: "eggo"})) //输出：Hi!
}

不对结构体初始化也照常可以调用方法

type Animal struct {
    Age int
}

func (animal Animal) getName() string {
    return "animal"  //返回一个字符串
}

func main() {
    var animal Animal
    fmt.Println(animal.getName())
    fmt.Println(person.getName())
}

3.指针类型调用方法(值接收者)

type A struct {
	name string
}

func (a A) Name() string {
	a.name = "Hi!"
	return a.name
}
func main() {
	a := A{name: "eggo"}
	b := &a
    //可用实例 pointer 调用全部方法，编译器自动转换
    b.Name()//等效于:(*b).Name()   ,A.Name(*b)
	fmt.Println(a.name) //输出：eggo
}
//注意，当接受者不是一个指针时，该方法操作对应接受者的值的副本(意思就是即使你使用了指针调用函数，但是函数的接受者是值类型，所以函数内部操作还是对副本的操作，而不是指针操作。

b.Name()等效于(*b).Name()

type A struct {
	name string
}

func (a A) Name() string {
	a.name = "Hi!"
	return a.name
}
func main() {
	fmt.Println((A{name: "eggo"}).Name())//Hi!
}

b.Name()等效于A.Name(*b)


type A struct {
	name string
}

func (a A) Name() string {
	a.name = "Hi!"
	return a.name
}
func main() {
	a := A{name: "eggo"}
	b := &a
	A.Name(*b)
	fmt.Println(a.name) //输出：eggo
}

以下的方式也算指针类型调用方法(值接收者)

type A struct {
	name string
}

func (a A) Name() string {
	a.name = "Hi!"
	return a.name
}
func main() {
	a := &A{name: "eggo"}
	a.Name()
	fmt.Println(a.name) //输出：eggo
}

4.值类型调用方法(指针接受者)

type A struct {
	name string
}

func (a *A) Name() string {
	a.name = "Hi!"
	return a.name
}

func main() {
	a := A{name: "eggo"}
    a.Name()//等效于: (&a).Name()   ,   (*A).Name(&a)
	fmt.Println(a.name) //输出：Hi
}

//注意：当接受者是指针时，即使用值类型调用那么函数内部也是对指针的操作。

a.Name()等效于 (&a).Name()

type A struct {
	name string
}

func (a *A) Name() string {
	a.name = "Hi!"
	return a.name
}

func main() {
	fmt.Println((&A{name: "eggo"}).Name())//hi
}

a.Name()等效于: (*A).SetName(&a)

type A struct {
	name string
}

func (a *A) Name() string {
	a.name = "Hi!"
	return a.name
}

func main() {
	a := A{name: "eggo"}
	(*A).Name(&a)
	fmt.Println(a.name) //输出：Hi
}

5.指针类型调用方法(指针接收者)

type A struct {
	name string
}

func (a *A) Name() string {
	a.name = "Hi!"
	return a.name
}

func main() {
	a := A{name: "eggo"}
	b := &a
    b.Name()//等效于:(*A).Name(b)
	fmt.Println(a.name) //输出：Hi
}

b.Name()//等效于(*A).Name(b)

type A struct {
	name string
}

func (a *A) Name() string {
	a.name = "Hi!"
	return a.name
}

func main() {
	a := A{name: "eggo"}
	b := &a
	(*A).Name(b)
	fmt.Println(a.name) //输出：Hi
}


type A struct {
	name string
}

func (a *A) Name() string {
	a.name = "Hi!"
	return a.name
}

func main() {
	fmt.Println((*A).Name(&A{name: "eggo"}))//Hi!
}

以下的方式也算指针类型调用方法(指针接收者)

type A struct {
	name string
}

func (a *A) Name() string {
	a.name = "Hi!"
	return a.name
}

func main() {
	a := &A{name: "eggo"}
	a.Name()
	fmt.Println(a.name) //输出：Hi
}

6.四大方法接收者地址

type Data struct {
	x int
}

func (self Data) ValueTest() { // func ValueTest(self Data);
	fmt.Printf("Value: %p\n", &self)
}
func (self *Data) PointerTest() { // func PointerTest(self *Data);
	fmt.Printf("Pointer: %p\n", self)
}
func main() {
	d := Data{}
	p := &d
	fmt.Printf("Data: %p\n", p)  //d的地址,Data: 0xc000016098
	fmt.Printf("Data: %p\n", &p) //p的地址
	//d的地址
	d.ValueTest() // 副本的地址,   Value: 0xc0000160b8

	p.ValueTest() // 副本的地址,   Value: 0xc0000160d0

	d.PointerTest() // d的地址,  Pointer: 0xc000016098

	p.PointerTest() // d的地址, Pointer: 0xc000016098

}

6.调用函数(值接收者)

//接收值类型参数的函数
func valueIntTest(a int) int {
	return a + 10
}
func main() {
	a := 2
	fmt.Println("valueIntTest:", valueIntTest(a))
	//函数的参数为值类型，则不能直接将指针作为参数传递
	//fmt.Println("valueIntTest:", valueIntTest(&a))
	//compile error: cannot use &a (type *int) as type int in function argument
}

7.调用函数(指针接收者)

//接收指针类型参数的函数
func pointerIntTest(a *int) int {
    return *a + 10
}
func main() {
	 b := 5
    fmt.Println("pointerIntTest:", pointerIntTest(&b))
    //同样，当函数的参数为指针类型时，也不能直接将值类型作为参数传递
    //fmt.Println("pointerIntTest:", pointerIntTest(b))
    //compile error:cannot use b (type int) as type *int in function argument
}

8.不同结构体可以定义相同方法

type Human struct {
	name string
}
type Student struct {
	speciality string
}

func (s Student) demo1() {
	fmt.Println("ssssssssssssss")
}
func (h Human) demo1() {
	fmt.Println("hhhhhhhhhh")
}

func main() {
	a := Human{}
	b := Student{}
	a.demo1()//hhhhhhhhhh
	b.demo1()//sssssssssssssss
}

9.函数与与方法的区别

普通函数与方法的区别：
1.对于普通函数，接收者为值类型时，不能将指针类型的数据直接传递，反之亦然；
2.对于方法（如struct的方法），接收者为值类型时，可以直接用指针类型的变量调用方法，反过来同样也可以

10.reflet.TypeOf验证方法是函数

A.Nme(a)里的a就是所谓的方法接收者，它会作为方法Nme的以一个参数传入，这一点我们可以通过代码验证一下；
Go语言中函数类型只和参数与返回值相关，方法其实就是普通的函数，而接收者就是隐含的第一个参数

type A struct {
	name string
}

func (a A) Name() string {
	a.name = "Hi!" + a.name
	return a.name
}

func Name(a A) string {
	a.name = "Hi!" + a.name
	return a.name
}

func main() {
	t1 := reflect.TypeOf(A.Name)
	t2 := reflect.TypeOf(Name)
	fmt.Println(t1 == t2)//true
}
GoGo在努力
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Golang 上传Office文档并转化为PDF
qq_39052648的博客
06-07 1291
之前介绍了利用libreoffice 将office文件转化pdf并处理中文乱码的问题 不清楚的同学点击这里 使用LibreOffice将word转化为pdf -解决中文乱码 现在结合Golang 实现文件上传和并生成PDF链接地址 upload.html 上传页面 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Upload</ti
Golang动态调用方法
热门推荐
An丶的博客
06-08 2万+
main.go package main import ( "lenu/call" "reflect" ) type FuncMapsType map[string]reflect.Value func main() { _, _ = CallFunc("Hello", "执行Hello方法") _, _ = CallFunc("World", "执行World方法") } func CallFunc(tableName string, args ... interface{}) (r
golang通过反射动态调用方法
weixin_33756418的博客
09-19 270
  func Call(m map[string]interface{}, name string, params ...interface{}) ([]reflect.Value, error) { f := reflect.ValueOf(m[name]) if len(params) != f.Type().NumIn() { return nil, errors.New...
在 Golang 中用名字调用函数
soEase
03-13 740
我是在这里看的，准备晚点再学习一下 https://www.cnblogs.com/lchb/archive/2013/12/28/3495376.html https://bitbucket.org/mikespook/golib/src/27c65cdf8a772c737c9f4d14c0099bb82ee7fa35/funcmap/funcmap.go?at=default&amp;fi...
golang动态调用方法
weixin_30604651的博客
09-16 283
package main import ( "fmt" "reflect" ) type YourT1 struct { } func (y *YourT1) MethodBar() { fmt.Println("MethodBar called") } type YourT2 struct { } func (y *Your...
Golang:Golang方法声明与使用
ZzzWClock的博客
01-09 592
Golang方法声明与使用 一.Golang方法介绍 方法与函数区别 函数可以直接用函数名称直接调用,而方法则需要变量+方法名调用 方法在传递实例的时候最好传递地址,处理速度会比值传递要快 函数在接收一个指针后,需要用到传统(*变量名)拿取指针值,而在方法中底成做了优化,可以直接用变量名拿去值不需要加*号 方法在声明的时候需要绑定一个自定义类型如常用的struct,或者init,string,interface都可以 在实现了String()方法后会改写默认打印结果 二.方法的声明与使用 方法的
golang学习系列——16. 函数(2)
01-07
栈溢出一般可以通过惰性求值的技术来解决：golang 的话可以使用 channel 和 goroutine 来实现惰性求值，举例如下 func generatenums() chan int { nums := make(chan int) num := 0 go func() { for { num++ ...
Golang的Cobalt Strike Shellcode Loader-Golang开发
05-26
Cobalt Strike Shellcode Loader by Golang Doge-Loader Cobalt Strike Shellcode Loader by Golang 本人github的项目可能目前主要分为两大类， :frog: Frog系列为自动化扫描方向， :dog_face: Doge系列为免杀...
Golang游戏服务端
09-26
使用责任链、反射、gin框架等技术实现的restful风格的Golang游戏服务端，里面包含了一系列功能。包括接收客户端的请求，并调用相关的业务代码。业务职责清晰，分层明显，是开发游戏服务端的不二选择。
cmall-go:golang写的电子商城的API接口
03-19
项目依赖本项目采用了一系列golang中比较流行的组件来进行开发杜松子酒戈姆MySQL的Redis Godotenv jwt-go邮件使用的SDK或调用的API阿里云OSS极验支付FM QQ第三方登录目录结构mall-go/├── api├── cache├── ...
详解Golang利用反射reflect动态调用方法
09-19
主要介绍了详解Golang利用反射reflect动态调用方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
golang库的生成和调用
02-23
golang库的生成和调用， 里面提供了静态库（.a）具体的操作步骤和实现方法， 最后提供调用方法。希望能给到帮助， 目前还不能实现生成DLL。期待。。。
用于Go编程语言的无服务器集群计算系统-Golang开发
05-26
Bigslice公开了可组合的API，该API使用户可以通过调用用户代码的一系列数据转换来表达数据处理任务。 Big Bigslice Bigslice是Go的无服务器集群数据处理系统。 Bigslice公开了可组合的API，该API使用户可以通过调用...
Golang 通过方法名调用方法
fengfengdiandia的专栏
09-20 7314
有这样一个结构体 Person，带有4个方法。 现在有个需求，想通过方法的名字调用对应的方法，想到的办法是将名字和对应方法建立 map 关系。 type Person struct { nape string age int } func (p *Person) SetName(nape string) { p.nape = nape } func (p *Person) GetName(...
6.golang之函数调用机制
weixin_43893483的博客
07-28 250
1. 函数的调用机制 （1）通俗易懂的方式理解 （2）函数的调用过程 介绍：为了让大家更好的理解函数调用过程，看两个案例，并画出示意图。 <1> 传入一个数+1 对上图说明： （1）在调用一个函数时，会给该函数分配一个新的空间，编译器会通过自身的处理让这个新的空间和其它的栈的空间分开来。 （2）在每个函数对应的栈中，数据空间是独立的，不会混淆 （3）当一个函数调用完毕（执行完毕后），程序会销毁这个函数对应的栈空间 &...
Golang通过反射动态调用包下面方法、动态调用结构体下方法，类似JS的eval
qq_39272466的博客
07-27 518
【代码】Golang通过反射动态调用包下面方法、动态调用结构体下方法，类似JS的eval。
Golang 新手入门教程（十四）：Go中的方法
麻凡
08-03 255
方法主要源于 OOP 语言，在传统面向对象语言中 (例如 C++), 我们会用一个“类”来封装属于自己的数据和函数，这些类的函数就叫做方法。虽然 Go 不是经典意义上的面向对象语言，但是我们可以在一些接收者（自定义类型，结构体）上定义函数，同理这些接收者的函数在 Go 里面也叫做方法。...
利用golang的反射包，实现根据函数名自动调用函数。
积累
01-13 1万+
package main import "fmt" import "reflect" import "encoding/xml" type st struct{ } func (this *st)Echo(){ fmt.Println("echo()") } func (this *st)Echo2(){ fmt.Println("echo-----------------
go动态调用方法
Tom_ands_Jerry的博客
06-19 2303
package main import ( "fmt" "reflect" ) type X struct{} func (X) Test(x, y int) (int ,error) { return x + y , fmt.Errorf("err: %d", x+y) } func main() { var a X v
golang跨包调用
最新发布
12-03
在Go语言中，如果要跨包调用函数或变量，需要注意以下几点： 1.被调用的函数或变量名首字母必须大写，否则无法被其他包访问。 2.在调用时需要使用被调用函数或变量所在包的包名作为前缀。 下面是一个例子，假设我们有两个包：main和mypackage，其中mypackage中定义了一个函数MyFunction和一个变量MyVariable： ```go //mypackage/mypackage.go package mypackage import "fmt" var MyVariable = 123 func MyFunction() { fmt.Println("This is MyFunction in mypackage.") } ``` 在main包中，我们可以通过以下方式来调用mypackage中的函数和变量： ```go //main.go package main import ( "fmt" "mypackage" ) func main() { fmt.Println("MyVariable in mypackage is:", mypackage.MyVariable) mypackage.MyFunction() } ``` 在上面的例子中，我们通过import语句引入了mypackage包，并使用mypackage.MyVariable和mypackage.MyFunction()来访问其中的变量和函数。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

GoGo在努力

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

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

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

打赏作者

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

抵扣说明：

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

余额充值