Rumah > Artikel > pembangunan bahagian belakang > Memperkenalkan beberapa kaedah penulisan lanjutan di Golang
Memperkenalkan beberapa kaedah penulisan lanjutan di Golang
- PHPzasal
- 2023-04-27 09:11:28897semak imbas
Golang ialah bahasa pengaturcaraan moden yang cekap dengan tahap konkurensi yang tinggi, sintaks ringkas dan perpustakaan standard yang berkuasa. Disebabkan kecekapan dan kebolehpercayaannya, semakin ramai pembangun memilih untuk menggunakan Golang untuk membina aplikasi berprestasi tinggi. Walau bagaimanapun, bagi pembangun yang ingin memanfaatkan sepenuhnya keupayaan Golang, mereka perlu menguasai beberapa kemahiran pengaturcaraan lanjutan yang boleh menjadikan kod Golang anda lebih ringkas, cekap dan boleh diselenggara. Seterusnya, kami akan memperkenalkan beberapa kaedah penulisan lanjutan di Golang untuk membantu anda memahami Golang dengan mendalam dan memberikan permainan sepenuhnya kepada kelebihannya.
1 Gunakan struktur terbenam bahasa Go untuk mencapai penggunaan semula kod
Struktur terbenam dalam Golang ialah teknologi penggunaan semula kod yang sangat berkuasa Ini kerana struktur boleh Membenamkan berbilang struktur, dan setiap satu struktur boleh menggunakan sifat dan kaedah struktur dalamannya. Ini secara berkesan boleh mengurangkan lebihan kod dan meningkatkan kebolehselenggaraan kod. Berikut ialah kod contoh mudah:
utama pakej
import (
"fmt"
)
taip Num struct {
A int B int
}
taip struct Kira {
Num
}
func (c *Calculate) Add() int {
return c.A + c.B
}
func main () {
num := Num{1, 2}
calc := Calculate{num}
fmt.Println(calc.Add()) //输出：3
}
Dalam kod contoh di atas, kami mentakrifkan struktur Num, yang mengandungi dua pembolehubah integer A dan B. Kami juga mentakrifkan struktur Kira dan membenamkannya ke dalam struktur Kira melalui medan "Num". Oleh kerana struktur Kira mengandungi struktur Num, kita boleh terus menggunakan sifat dan kaedah struktur Num dalam struktur Kira tanpa mentakrifkannya semula. Dengan cara ini, kita boleh melaksanakan kaedah Tambah dengan cepat dan mengira jumlah dua integer A dan B dalam struktur Num.
2. Gunakan antara muka untuk meningkatkan kebolehskalaan kod
Antara muka di Golang ialah teknologi pengembangan kod yang sangat berkuasa, yang boleh meningkatkan fleksibiliti dan kebolehskalaan kod. Dengan menggunakan antara muka, kita boleh mentakrifkan satu set kaedah, dan kemudian berbilang objek berbeza boleh melaksanakan antara muka dan menggunakan set kaedah ini. Berikut ialah kod sampel:
utama pakej
import (
"fmt"
)
taip antara muka Bentuk {
Area() float64
}
taip struct Rect {
Width float64 Height float64
}
func (r Rect) Area() float64 {
return r.Width * r.Height
}
type Circle struct {
Radius float64
}
func (c Bulatan) Kawasan() float64 {
return 3.14 * c.Radius * c.Radius
}
func CalculateArea(s Shape) float64 {
rreee}
func main() {
return s.Area()
}
Dalam contoh di atas, kami mentakrifkan antara muka Bentuk, yang mengandungi kaedah Kawasan. Kemudian kami menentukan dua lagi struktur: Rect dan Circle, yang masing-masing melaksanakan kaedah Area dalam antara muka Shape. Akhir sekali, kami mentakrifkan fungsi CalculateArea yang boleh mengira luas mana-mana objek yang melaksanakan antara muka Shape. Dengan menggunakan antara muka Shape, kita boleh mengira dengan mudah kawasan bentuk yang berbeza tanpa mengambil berat tentang butiran pelaksanaan tertentu.
3. Gunakan goroutine dalam perpustakaan standard untuk meningkatkan keselarasan program
Golang’s goroutine ialah teknologi serentak yang sangat berkuasa, yang boleh membantu kami menggunakan berbilang teras komputer anda dengan lebih cekap kuasa pemprosesan. Dengan menggunakan coroutine, kami boleh melaksanakan pelbagai tugas secara selari, dengan itu mengurangkan masa tindak balas program. Berikut ialah contoh kod:
pakej utama
import (
rect := Rect{10, 20}
circle := Circle{5}
fmt.Println(CalculateArea(rect)) //输出：200
fmt.Println(CalculateArea(circle)) //输出：78.5
)
func worker(id int, c chan int) {
"fmt" "time"
}
func main() {
fmt.Printf("Worker %d started.\n", id)
for {
num := <-c
fmt.Printf("Worker %d received %d.\n", id, num)
time.Sleep(time.Millisecond * 500)
fmt.Printf("Worker %d finished %d.\n", id, num)
}
}
Dalam kod contoh di atas, kami telah mentakrifkan fungsi pekerja yang menerima jenis chan int Channel c sebagai parameter dan gelung di dalamnya menunggu mesej dalam saluran. Di samping itu, kami memulakan 4 coroutine dalam fungsi utama untuk melaksanakan pekerja secara selari. Akhir sekali, kami menghantar 20 integer ke saluran mengikut urutan dan menunggu selesainya tugasan coroutine sepanjang masa. Fungsi tidur. Dengan menggunakan coroutine, kami boleh memproses sejumlah besar tugas secara selari dengan pantas, dengan itu meningkatkan responsif dan prestasi program.
4 Gunakan tangguh dan pulihkan untuk membina mekanisme pengendalian ralat yang boleh dipercayai
Pernyataan tangguh dan pulih dalam Golang adalah mekanisme pengendalian ralat yang sangat mudah apabila ralat kod berlaku. Kembali kepada normal, dengan itu memastikan kebolehpercayaan keseluruhan program. Pernyataan penangguhan akan dilaksanakan sebelum fungsi keluar, dan pernyataan pulih digunakan untuk memulihkan daripada ralat panik semasa program berjalan. Berikut ialah kod contoh mudah:
utama pakej
import (
var c = make(chan int)
for i := 0; i < 4; i++ {
go worker(i, c)
}
for i := 0; i < 20; i++ {
c <- i
}
time.Sleep(time.Second)
fmt.Println("Main finished.")
)
func errorHandler() {
"fmt"
}
func doPanic() {
if p := recover(); p != nil {
fmt.Printf("Recover from panic: %v\n", p)
}
}
func main() {
defer errorHandler()
panic("A panic error occurs.")
}
Dalam kod contoh di atas , kami mentakrifkan fungsi doPanic, yang mencetuskan ralat panik apabila dilaksanakan. Untuk mengendalikan ralat panik, kami mentakrifkan fungsi errorHandler dan menggunakan pernyataan tangguh untuk melaksanakannya sebelum fungsi doPanic. Jika ralat panik berlaku dalam fungsi doPanic, ia akan keluar serta-merta dan memanggil fungsi errorHandler untuk menyambung semula pelaksanaan program yang normal. Dengan menggunakan penyata tangguh dan pulih, kami boleh mewujudkan mekanisme pengendalian ralat yang boleh dipercayai untuk memastikan kebolehpercayaan dan kestabilan keseluruhan program.
Ringkasan:
Di atas adalah beberapa kaedah penulisan Golang lanjutan yang diperkenalkan dalam artikel ini. Ia boleh membantu anda memahami dengan lebih baik ciri-ciri Golang dan memberikan permainan sepenuhnya kepada kelebihannya. Dalam pembangunan sebenar, anda boleh menggunakan teknik ini secara fleksibel untuk meningkatkan prestasi, kebolehselenggaraan dan kebolehpercayaan program mengikut keperluan dan senario anda sendiri.
Atas ialah kandungan terperinci Memperkenalkan beberapa kaedah penulisan lanjutan di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!