Reka bentuk kaedah umum golang

Memandangkan semakin ramai pembangun berminat dengan bahasa Go, semakin ramai orang menggunakan bahasa pengaturcaraan yang cekap dan mudah ini. Beberapa pustaka dan rangka kerja bahasa Go yang biasa digunakan juga telah mendapat lebih banyak perhatian, seperti Gin, Echo, gRPC, dsb.

Walau bagaimanapun, bagi pembangun yang ingin menulis kaedah biasa dalam Go, rangka kerja dan perpustakaan ini tidak selalunya terpakai semasa menulis API biasa. Walau bagaimanapun, ini tidak bermakna anda tidak boleh menulis kaedah generik anda sendiri untuk meningkatkan kebolehgunaan semula kod dan meningkatkan kecekapan pembangunan.

Dalam artikel ini, kami akan memperkenalkan beberapa kaedah asas untuk mereka bentuk fungsi dan kaedah biasa. Kami akan membincangkan topik berikut:

1. Cara menentukan fungsi dan kaedah biasa
2. Cara menggunakan antara muka dalam bahasa Go
3. Kod sampel

Cara mentakrifkan fungsi dan kaedah universal

Mentakrifkan fungsi dan kaedah universal hendaklah berdasarkan dua prinsip: ketekalan input dan output.

Ketekalan input bermakna jenis dan nombor parameter input perlu mempunyai gelagat yang sama dalam senario yang berbeza, manakala ketekalan output bermakna keputusan output harus sama. Kedua-dua perkara ini sangat penting kerana kedua-duanya meningkatkan kebolehgunaan semula kod anda dan kebolehramalan kod anda.

Berikut ialah beberapa cara untuk meningkatkan kebolehgunaan semula dan kebolehramalan kod anda:

1. Hadkan parameter fungsi dan kembalikan jenis kepada jenis data asas dan jenis pratakrif. Ini mengelakkan keutamaan dan susunan operasi yang tidak dijangka serta menjadikan fungsi lebih mudah difahami dan digunakan.
2. Jadikan parameter fungsi dan jenis pulangan akaun untuk nilai nol. Jika parameter fungsi boleh menjadi nol, anda perlu mempertimbangkan kemungkinan nilai nol. Jika nilai pulangan fungsi mungkin batal, ini perlu ditunjukkan dalam tandatangan fungsi.
3. Pertimbangkan gelagat fungsi dan pengendalian ralat. Mengendalikan ralat dan pengecualian dengan baik dalam kod anda, serta mentakrifkan gelagat fungsi anda, boleh menjadikan gelagat fungsi anda lebih boleh diramal.

Cara menggunakan antara muka bahasa Go

Antara muka ialah jenis yang digunakan untuk menerangkan objek dan kaedah komunikasi antara objek. Dalam Go, antara muka ialah satu set tandatangan fungsi yang mentakrifkan gelagat sesuatu objek. Dengan mentakrifkan antara muka, kita boleh mentakrifkan fungsi dan kaedah biasa antara objek yang berbeza, dan fungsi dan kaedah ini boleh digunakan dalam objek yang berbeza dengan mengikuti konvensyen antara muka ini.

Menggunakan antara muka dalam bahasa Go mempunyai faedah berikut:

1. Menyokong pelaksanaan yang berbeza. Dengan mentakrifkan antara muka awam, kami boleh menyokong pelaksanaan yang berbeza. Ini menjadikan komponen lebih mudah untuk digunakan semula dan lebih fleksibel.
2. memberikan kekangan yang jelas. Antara muka membolehkan kami menyatakan secara eksplisit tingkah laku dan kekangan sesuatu objek, yang meningkatkan kebolehgunaan semula kod dan mengurangkan risiko ralat kod.
3. Kebolehujian kod dipertingkat. Dengan antara muka, kami boleh menentukan mengejek antara muka yang dijangkakan, yang membolehkan kami menguji ketepatan kod kami dan bukannya pelaksanaan sebenar.

Berikut ialah contoh praktikal yang menunjukkan cara menggunakan antara muka untuk menentukan kaedah biasa:

type User interface {
  GetName() string
  GetAge() int
}

func printUser(u User) {
  fmt.Printf("Name: %s, Age: %d", u.GetName(), u.GetAge())
}

Dalam kod ini, kami mentakrifkan antara muka bernama Pengguna, yang Terdapat dua kaedah: GetName dan GetAge.

Kemudian kami menulis fungsi yang dipanggil printUser, yang menerima parameter jenis antara muka Pengguna. Fungsi ini akan memanggil kaedah antara muka secara seragam, kerana antara muka ini dinyatakan oleh semua objek Pengguna yang melaksanakan tingkah laku yang sama.

Contoh ini menggambarkan cara mentakrifkan kaedah biasa dengan menggunakan antara muka bahasa Go.

Kod Contoh

Berikut ialah kod sampel yang menggunakan antara muka bahasa Go untuk mentakrifkan API Pengelogan umum:

type Logger interface {
  Log(message string)
}

func LogMessage(logger Logger, message string) {
  logger.Log(message)
}

Dalam contoh ini, kami mentakrifkan antara muka yang dinamakan Logger mempunyai kaedah Log, yang digunakan untuk log mesej. Kami juga mentakrifkan fungsi LogMessage yang lain, yang menerima logger parameter jenis Logger, dan mesej parameter jenis rentetan. Ia mentakrifkan API Pengelogan biasa antara objek yang berbeza dan boleh dipanggil dengan mengikuti antara muka Logger.

Seterusnya kita boleh menentukan pelaksanaan log khusus untuk melaksanakan kaedah Log. Kod sampel adalah seperti berikut:

type ConsoleLogger struct{}

func (r ConsoleLogger) Log(message string) {
  fmt.Println(message)
}

type FileLogger struct {
  file *os.File
}

func (r FileLogger) Log(message string) {
  r.file.WriteString(message)
}

Kami melihat bahawa ConsoleLogger dan FileLogger yang sepadan melaksanakan kaedah Log, yang memenuhi konvensyen antara muka API Pengelogan, dengan itu membolehkan pembangunan fungsi umum.

Kesimpulan

Go ialah bahasa yang sangat sesuai untuk menulis kod yang cekap dan boleh digunakan semula. Dalam artikel ini, kami membincangkan cara untuk mentakrifkan fungsi dan kaedah biasa, serta memperkenalkan cara menggunakan antara muka bahasa Go untuk melaksanakan penulisan API biasa. Kami juga menyediakan kod sampel untuk membantu memahami proses tersebut. Untuk meningkatkan kebolehgunaan semula kod dan meningkatkan kecekapan pembangunan, anda boleh menggunakan kaedah yang diperkenalkan ini untuk menulis API biasa anda sendiri.

Atas ialah kandungan terperinci Reka bentuk kaedah umum golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!