Golang 基础教程

Golang 控制语句

Golang 函数 & 方法

Golang 结构体

Golang 切片 & 数组

Golang 字符串(String)

Golang 指针

Golang 接口

Golang 并发

Golang 异常(Error)

Golang 其他杂项

الطريقة المماثلة لـ Go كلمة رئيسية Defer لـ Go

Go 语言方法(Method)

Go语言支持方法。Go方法与Go函数相似，但有一点不同，就是方法中包含一个接收者参数。在接收者参数的帮助下，该方法可以访问接收者的属性。在这里，接收方可以是结构类型或非结构类型。在代码中创建方法时，接收者和接收者类型必须出现在同一个包中。而且不允许创建一个方法，其中的接收者类型已经在另一个包中定义，包括像int、string等内建类型。如果您尝试这样做，那么编译器将抛出错误。

语法：

func(reciver_name　Type)　method_name(parameter_list)(return_type){
　　　　//　Code
}

在此，可以在方法内访问接收器。

结构类型接收器的方法

在Go语言中，允许您定义其接收者为结构类型的方法。可以在方法内部访问此接收器，如以下示例所示：

مثال

package main　
　　
import "fmt"
　　
//Author　结构体
type author struct {　
　　　　name　　　　　　string　
　　　　branch　　　　string　
　　　　particles　int
　　　　salary　　　　int
}　
　　
//接收者的方法　
func　(a　author)　show()　{　
　　
　　　　fmt.Println("Author's　Name:　",　a.name)　
　　　　fmt.Println("Branch　Name:　",　a.branch)　
　　　　fmt.Println("Published　articles:　",　a.particles)　
　　　　fmt.Println("Salary:　",　a.salary)　
}　
　　
func main() {　
　　
　　　　// إعداد القيم
　　　　//Author结构体
　　　　res := author{　
　　　　　　　　name:　　　　　　"Sona",　
　　　　　　　　branch:　　　　"CSE",　
　　　　　　　　particles:　203,　
　　　　　　　　salary:　　　　34000,　
　　　　}　
　　
　　　　//调用方法
　　　　res.show()　
}

الإخراج:

Author's　Name:　　Sona
Branch　Name:　　CSE
Published　articles:　　203
Salary:　　34000

非结构类型接收器的方法

在Go语言中，只要类型和方法定义存在于同一包中，就可以使用非结构类型接收器创建方法。如果它们存在于int，string等不同的包中，则编译器将抛出错误，因为它们是在不同的包中定义的。

مثال

package main　
　　
import "fmt"
　　
//类型定义
type　data　int
//定义一个方法
//非结构类型的接收器　
func　(d1　data)　multiply(d2　data)　data　{　
　　　　return　d1　*　d2　
}　
　　
/*　
//如果您尝试运行此代码，
//然后编译器将抛出错误　
func(d1　int)multiply(d2　int)int{　
return　d1　*　d2　
}　
*/
　　
func main() {　
　　　　value1　:=　data(23)　
　　　　value2　:=　data(20)　
　　　　res　:=　value1.multiply(value2)　
　　　　fmt.Println("最终结果:　",　res)　
}

الإخراج:

最终结果:　　460

带指针接收器的Go方法

在Go语言中，允许您使用指针接收器创建方法。在指针接收器的帮助下，如果方法中所做的更改将反映在调用方中，这对于值接收器是不可能的。

语法：

func　(p　*Type)　method_name(...Type)　Type　{
　　　　//　Code
}

مثال

package main　
　　
import "fmt"
　　
// هيكل مؤلف
type author struct {　
　　　　name　　　　　　string　
　　　　branch　　　　string　
　　　　particles　int
}　
　　
//方法，使用author类型的接收者
func　(a　*author)　show(abranch　string)　{　
　　　　(*a).branch = abranch　
}　
　　
//　Main　function　
func main() {　
　　
　　　　//初始化author结构体
　　　　res := author{　
　　　　　　　　name: "Sona",　
　　　　　　　　branch: "CSE",　
　　　　}　
　　
　　　　fmt.Println("Author's　name:　",　res.name)　
　　　　fmt.Println("اسم الفرع (قبل): ", res.branch)　
　　
　　　　//创建一个指针
　　　　p　:=　&res　
　　
　　　　//调用show方法
　　　　p.show("ECE")　
　　　　fmt.Println("Author's　name:　",　res.name)　
　　　　fmt.Println("اسم الفرع (بعد): ", res.branch)　
}

الإخراج:

اسم المؤلف: Sona
اسم الفرع (قبل): CSE
اسم المؤلف: Sona
اسم الفرع (بعد): ECE

يمكن للطرق قبول الإشارة والقيمة

من المعروف أن في لغة Go، عندما يكون لديك دالة تحتوي على معامل قيمة، فإنها ستقبل فقط قيمة المعامل، وإذا حاولت إرسال إشارة إلى دالة القيمة، فإنها لن تقبل، والعكس صحيح. ولكن يمكن للطرق في Go قبول القيمة والإشارة، بغض النظر عما إذا كانت تستخدم مستقبل إشارة أو قيمة مُحددة.

مثال

package main　
　　
import "fmt"
　　
// هيكل مؤلف
type author struct {　
　　　　name string　
　　　　branch string　
}　
　　
// طريقة تحتوي على إشارة
// مستقبل نوع المؤلف
func (a *author) show_1(abranch string) {　
　　　　(*a).branch = abranch　
}　
　　
// طريقة تحتوي على قيمة
// مستقبل نوع المؤلف　
func (a author) show_2() {　
　　　　a.name = "Gourav"
　　　　fmt.Println("اسم المؤلف (قبل): ", a.name)　
}　
　　
func main() {　
　　
　　　　　// إعداد القيم
　　　　　// هيكل مؤلف
　　　　res := author{　
　　　　　　　　name: "Sona",　
　　　　　　　　branch: "CSE",　
　　　　}　
　　
　　　　fmt.Println("اسم الفرع (قبل): ", res.branch)　
　　
　　　　　// استدعاء الطريقة show_1
　　　　　// طريقة إشارة تحتوي على قيمة
　　　　res.show_1("ECE")　
　　　　fmt.Println("اسم الفرع (بعد): ", res.branch)　
　　
　　　　　// استدعاء الطريقة show_2
　　　　　// طريقة قيمة تحتوي على إشارة
　　　　(&res).show_2()　
　　　　fmt.Println("اسم المؤلف (بعد): ", res.name)　
}

الإخراج:

اسم الفرع (قبل): CSE
اسم الفرع (بعد): ECE
اسم المؤلف (قبل): Gourav
اسم المؤلف (بعد): Sona

الفرق بين الطريقة والدالة

الطريقة	الوظيفة
يحتوي على المُستقبل.	لا يحتوي على المُستقبل.
يمكنه قبول الإشارات والقيم.	لا يمكنه قبول الإشارات والقيم في نفس الوقت.
يمكن تعريف طرق بنفس الاسم ولكن بتصنيفات مختلفة في البرنامج.	لا يُسمح في البرنامج بتسمية الدوال بنفس الاسم ولكن بتصنيفات مختلفة.

الطريقة المماثلة لـ Go كلمة رئيسية Defer لـ Go