Apakah perbezaan antara kaedah dan fungsi dalam bahasa go

Perbezaan: 1. Fungsi ialah sekeping kod dengan fungsi bebas, yang boleh dipanggil berulang kali berkali-kali, dengan itu merealisasikan penggunaan semula kod manakala kaedah ialah fungsi tingkah laku kelas, dan hanya objek kelas ini boleh dipanggil. 2. Kaedah mempunyai penerima, tetapi fungsi tidak mempunyai penerima. 3. Fungsi tidak boleh mempunyai nama yang sama, tetapi kaedah boleh mempunyai nama yang sama. 4. Kaedah panggilan adalah berbeza. 5. Kaedah perlu menentukan jenisnya, yang boleh menjadi struktur atau jenis tersuai, manakala fungsi adalah universal. 6. Bentuk dan jenis parameter fungsi mestilah konsisten, dan kaedah boleh diubah.

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Dalam bahasa Go, fungsi dan kaedah adalah berbeza dan mempunyai perbezaan konsep yang jelas. Dalam bahasa lain, seperti Java, secara amnya, fungsi ialah kaedah, dan kaedah ialah fungsi Walau bagaimanapun, dalam bahasa Go, fungsi merujuk kepada kaedah yang tidak tergolong dalam mana-mana struktur atau jenis , fungsi tidak mempunyai penerima; Kaedah mempunyai penerima Kaedah yang kita bicarakan sama ada tergolong dalam struktur atau tergolong dalam jenis yang baru ditakrifkan.

Fungsi

Fungsi dan kaedah, walaupun konsepnya berbeza, definisinya sangat serupa. Pernyataan definisi fungsi tidak mempunyai penerima, jadi kami boleh mentakrifkan pernyataan secara langsung dalam fail go dan di bawah pakej go.

func main() {
    sum := add(1, 2)
    fmt.Println(sum)
}

func add(a, b int) int {
    return a + b
}

Dalam contoh, kami mentakrifkan add sebagai fungsi tandatangannya ialah func add(a, b int) int Ia tidak mempunyai penerima dan ditakrifkan secara langsung di bawah pakej go , seperti fungsi main dalam contoh memanggil fungsi add.

Nama fungsi dalam contoh bermula dengan huruf kecil add, jadi skopnya hanya milik pakej yang diisytiharkan dan tidak boleh digunakan oleh pakej lain Jika kita meletakkan nama fungsi bermula dengan huruf besar, Skop fungsi ini lebih besar dan boleh dipanggil oleh pakej lain. Ini juga merupakan penggunaan huruf besar dan kecil dalam bahasa Go Sebagai contoh, dalam Java, terdapat kata kunci khas untuk mengisytiharkan skop private, protect, public, dsb.

/*
 提供的常用库，有一些常用的方法，方便使用
*/
package lib

// 一个加法实现
// 返回a+b的值
func Add(a, b int) int {
    return a + b
}

Kaedah Add yang ditakrifkan dalam contoh di atas boleh dipanggil oleh pakej lain.

Kaedah

Pengisytiharan kaedah adalah serupa dengan fungsi yang berbeza ialah apabila kaedah ditakrifkan, parameter akan ditambah antara func dan nama kaedah , parameter ini ialah penerima, jadi kaedah yang kita takrifkan terikat kepada penerima, dan dipanggil kaedah penerima.

type person struct {
    name string
}

func (p person) String() string{
    return "the person name is "+p.name
}

Perhatikan parameter func yang ditambahkan antara (p person) dan nama kaedah dalam contoh Ini ialah penerima. Sekarang kita katakan jenis person mempunyai kaedah String, sekarang mari lihat cara menggunakannya. Kaedah yang dipanggil oleh

func main() {
    p:=person{name:"张三"}
    fmt.Println(p.String())
}

adalah sangat mudah. ​​Hanya gunakan pembolehubah jenis untuk memanggil Pembolehubah jenis dan kaedah didahului oleh operator ., yang bermaksud kaedah tertentu pembolehubah jenis ini. untuk dipanggil.

Terdapat dua jenis penerima dalam bahasa Go: penerima nilai dan penerima penunjuk. Dalam contoh di atas, kami menggunakan penerima jenis nilai.

Gunakan kaedah yang ditakrifkan oleh penerima jenis nilai Apabila dipanggil, salinan penerima nilai sebenarnya digunakan, jadi sebarang operasi pada nilai tidak akan menjejaskan pembolehubah jenis asal.

func main() {
    p:=person{name:"张三"}
    p.modify() //值接收者，修改无效
    fmt.Println(p.String())
}

type person struct {
    name string
}

func (p person) String() string{
    return "the person name is "+p.name
}

func (p person) modify(){
    p.name = "李四"
}

Dalam contoh di atas, nilai yang dicetak masih 张三 dan pengubahsuaian padanya adalah tidak sah. Jika kita menggunakan penunjuk sebagai penerima, ia akan berfungsi, kerana penerima penunjuk menghantar salinan penuding kepada nilai asal Salinan penunjuk masih menunjuk kepada nilai jenis asal, jadi apabila ia diubah suai, ia juga akan Mempengaruhi nilai pembolehubah jenis asal.

func main() {
    p:=person{name:"张三"}
    p.modify() //指针接收者，修改有效
    fmt.Println(p.String())
}

type person struct {
    name string
}

func (p person) String() string{
    return "the person name is "+p.name
}

func (p *person) modify(){
    p.name = "李四"
}

Hanya tukar dan jadi penerima penunjuk, dan pengubahsuaian selesai.

Apabila memanggil kaedah, penerima yang diluluskan pada asasnya adalah salinan, tetapi satu salinan nilai, dan satu lagi salinan penunjuk yang menunjuk kepada nilai. Penunjuk mempunyai ciri menunjuk kepada nilai asal, jadi mengubah suai nilai yang ditunjuk oleh penuding juga mengubah suai nilai asal. Kita hanya boleh memahami bahawa penerima nilai menggunakan salinan nilai untuk memanggil kaedah, manakala penerima penunjuk menggunakan nilai sebenar untuk memanggil kaedah.

Dalam contoh di atas, adakah anda mendapati bahawa apabila kita memanggil kaedah penerima penunjuk, kita juga menggunakan pembolehubah nilai, bukan penunjuk Ia juga mungkin jika kita menggunakan yang berikut .

p:=person{name:"张三"}
(&p).modify() //指针接收者，修改有效

Ini juga boleh. Jika kami tidak memaksa penggunaan penunjuk untuk panggilan, pengkompil Go secara automatik akan membantu kami mendapatkan penunjuk untuk memenuhi keperluan penerima.

Begitu juga, jika ia adalah kaedah penerima nilai, ia juga boleh dipanggil menggunakan penunjuk The Go secara automatik akan membatalkan rujukan untuk memenuhi keperluan penerima, seperti kaedah String() yang ditakrifkan dalam. contohnya, Ia juga boleh dipanggil seperti ini:

p:=person{name:"张三"}
fmt.Println((&p).String())

Ringkasnya, panggilan kaedah boleh menggunakan sama ada nilai atau petunjuk Kami tidak perlu mematuhi kehendak penyusun bahasa The Go bantu kami dengan pelarian automatik , yang sangat memudahkan kami pembangun.

不管是使用值接收者，还是指针接收者，一定要搞清楚类型的本质：对类型进行操作的时候，是要改变当前值，还是要创建一个新值进行返回？这些就可以决定我们是采用值传递，还是指针传递。

Go语言中方法和函数的区别

1、含义不同

函数function是一段具有独立功能的代码，可以被反复多次调用，从而实现代码复用。而方法method是一个类的行为功能，只有该类的对象才能调用。

2、方法有接受者，而函数无接受者

• Go语言的方法method是一种作用于特定类型变量的函数，这种特定类型变量叫做Receiver（接受者、接收者、接收器）；

• 接受者的概念类似于传统面向对象语言中的this或self关键字；

• Go语言的接受者强调了方法具有作用对象，而函数没有作用对象；

• 一个方法就是一个包含了接受者的函数；

• Go语言中， 接受者的类型可以是任何类型，不仅仅是结构体， 也可以是struct类型外的其他任何类型。

3、函数不可以重名，而方法可以重名

只要接受者不同，则方法名可以一样。

4、调用方式不一样

方法是struct对象通过.点号+名称来调用，而函数是直接使用名称来调用。

方法的调用需要指定类型变量调用，函数则不需要

 ```
var p testMethod.Person
p.Name = "tom"
p.Age = 123
p.ShowInfo()

注：方法和函数的访问权限都受大小写影响，小写本包，大写全局

5、方法需要指定所属类型，可以是结构体也可以是自定义type，函数则通用

```
func (person Person) ShowInfo(形参) 返回值{

   person.Name = "123"
   person.Age = 12
   fmt.Printf("name=%v,age=%v",person.Name,person.Age)
}
```
 
person为类型的形参，类型为Person

6、函数的形参与传参类型需要一致，方法可以改变

     ```
func (person *Person) ShowInfo(形参) 返回值{

   person.Name = "123"
   person.Age = 12
   fmt.Printf("name=%v,age=%v",person.Name,person.Age)
}

（1）这里方法的类型形参为指针，调用时可以使用 p.ShowInfo()或者 (&p).ShowInfo(),本质上都是后者，只不过Go的设计者对于方法的调用做了底层优化

func (person Person) ShowInfo(形参) 返回值{

   person.Name = "123"
   person.Age = 12
   fmt.Printf("name=%v,age=%v",person.Name,person.Age)
}

（2）这里方法的形参类型为数值型，默认为值传递，而在调用时可以使用p.ShowInfo()或者 (&p).ShowInfo()，但依旧是值拷贝

func test01(i *int) {


}

（3）对于函数则需保持一致，需要的形参为指针，则传入的形参需为地址值，否则编译无法通过

【相关推荐：Go视频教程、编程教学】

Atas ialah kandungan terperinci Apakah perbezaan antara kaedah dan fungsi dalam bahasa go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!