Dalam Go, kata kunci tangguh ialah alat berkuasa yang membantu mengurus sumber dan memastikan tindakan pembersihan dilakukan apabila fungsi keluar. Fungsi tertunda dilaksanakan apabila fungsi sekeliling kembali, sama ada ia kembali seperti biasa, disebabkan ralat, atau kerana panik. Ini memastikan bahawa kod pembersihan berjalan tanpa mengira cara fungsi keluar, menjadikan pengurusan sumber lebih mudah dan lebih dipercayai.
Dalam Go, berbilang pernyataan penangguhan dalam fungsi dilaksanakan dalam urutan terbalik penampilannya. Ini berguna untuk menguruskan berbilang tugas pembersihan, memastikan tugasan tersebut dilakukan dalam susunan tertentu apabila fungsi itu keluar.
func exampleFunction() {
fmt.Println("Start of function")
defer fmt.Println("First defer: executed last")
defer fmt.Println("Second defer: executed second")
defer fmt.Println("Third defer: executed first")
fmt.Println("End of function")
}
Output:
Start of function End of function Third defer: executed first Second defer: executed second First defer: executed last
Salah satu penggunaan penangguhan yang paling biasa adalah untuk memastikan sumber seperti fail ditutup dengan betul selepas ia tidak diperlukan lagi.
func processFile(fileName string) error {
file, err := os.Open(fileName)
if err != nil {
return err // Return the error if opening the file fails
}
defer file.Close() // Ensure the file is closed when the function exits
// Process the file...
return nil
}
os.File melaksanakan io.ReadCloser, jadi menggunakan tangguh di sini memastikan fail ditutup dengan betul, mengelakkan kebocoran sumber.
Apabila bekerja dengan konkurensi, adalah penting untuk melepaskan kunci untuk mengelakkan kebuntuan. tangguh membantu mengurus mutex dengan berkesan.
var mu sync.Mutex
func criticalSection() {
mu.Lock()
defer mu.Unlock() // Ensure the mutex is unlocked when the function exits
// Critical section...
}
Dengan menangguhkan mu.Unlock(), anda memastikan bahawa mutex sentiasa dikeluarkan, menjadikan kod lebih mudah difahami dan kurang terdedah kepada ralat.
Sambungan pangkalan data harus ditutup apabila ia tidak lagi diperlukan untuk mengosongkan sumber.
func queryDatabase() error {
db, err := sql.Open("driver", "database=example")
if err != nil {
return err
}
defer db.Close() // Ensure the database connection is closed when the function exits
// Query the database...
return nil
}
Apabila menukar direktori kerja, adalah penting untuk memulihkannya kepada keadaan asalnya.
func changeDirectory() error {
oldDir, err := os.Getwd()
if err != nil {
return err
}
err = os.Chdir("/tmp")
if err != nil {
return err
}
defer os.Chdir(oldDir) // Restore the working directory when the function exits
// Work in /tmp...
return nil
}
Menggunakan tangguh memudahkan untuk memulihkan direktori asal secara automatik.
tangguh boleh digunakan untuk pulih daripada panik dan menangani ralat dengan baik.
func safeFunction() {
defer func() {
if r := recover(); r != nil {
log.Println("Recovered from panic:", r)
}
}()
// Code that might panic...
}
Dengan menangguhkan fungsi yang mengendalikan panik, anda boleh memastikan aplikasi anda kekal teguh walaupun menghadapi ralat yang tidak dijangka.
tangguh berguna untuk mengukur masa pelaksanaan atau pengelogan apabila fungsi keluar.
func measureTime() {
start := time.Now()
defer func() {
duration := time.Since(start)
log.Printf("Execution time: %v", duration)
}()
// Code to measure...
}
Pendekatan ini memudahkan kod pemasaan dan memastikan tempoh dilog apabila fungsi selesai.
Operasi I/O yang ditimbal hendaklah dibuang untuk memastikan semua data dihapuskan.
func bufferedWrite() {
buf := bufio.NewWriter(os.Stdout)
defer buf.Flush() // Ensure the buffer is flushed when the function exits
buf.WriteString("Hello, World!")
}
Menggunakan tangguh di sini menjamin bahawa sebarang data penimbal akan dihapuskan sebelum fungsi selesai.
Badan permintaan HTTP melaksanakan io.ReadCloser, jadi adalah penting untuk menutupnya selepas digunakan untuk membebaskan sumber dan mengelakkan kebocoran.
func handleRequest(req *http.Request) error {
// Ensure that the request body is closed when the function exits
defer func() {
if err := req.Body.Close(); err != nil {
log.Println("Error closing request body:", err)
}
}()
body, err := io.ReadAll(req.Body)
if err != nil {
return err
}
// Process the body...
fmt.Println("Request body:", string(body))
return nil
}
Dengan menangguhkan req.Body.Close(), anda memastikan badan ditutup dengan betul, walaupun ralat berlaku semasa membaca atau memprosesnya.
Apabila anda membuka fail atau sumber lain dalam Go, adalah penting untuk memastikan sumber itu ditutup dengan betul apabila ia tidak diperlukan lagi. Walau bagaimanapun, jika anda cuba menutup sumber selepas menyemak ralat tanpa menggunakan penangguhan, anda boleh memperkenalkan risiko ke dalam kod anda.
file, err := os.Open(fileName)
if err != nil {
return err // Handle error
}
// Risk: If something goes wrong before this point, the file might never be closed
// Additional operations here...
file.Close() // Attempt to close the file later
Not using defer to close resources in Go can lead to unintended consequences, such as attempting to close a resource that was never successfully opened, resulting in unexpected behavior or panics. Additionally, if an error occurs before the explicit Close() call, the resource might remain open, causing leaks and exhausting system resources. As the code becomes more complex, ensuring all resources are properly closed becomes increasingly difficult, raising the likelihood of overlooking a close operation.
In Go, it's crucial to place a defer statement after verifying that a resource, like a file, was successfully opened.
Placing defer before the error check can introduce several risks and undesirable behavior.
file, err := os.Open(fileName)
defer file.Close() // Incorrect: This should be deferred after the error check
if err != nil {
return err // Handle error
}
// Additional operations here...
Placing defer file.Close() before checking if os.Open succeeded can cause several issues. If the file wasn't opened and is nil, attempting to close it will lead to a runtime panic since Go executes all deferred functions even when an error occurs. This approach also makes the code misleading, implying that the file was successfully opened when it might not have been, which complicates understanding and maintenance. Furthermore, if a panic does occur, debugging becomes more challenging, especially in complex codebases, as tracing the issue back to the misplaced defer can take additional effort.
The defer keyword in Go simplifies resource management and enhances code clarity by ensuring that cleanup actions are performed automatically when a function exits. By using defer in these common scenarios, you can write more robust, maintainable, and error-free code.
Atas ialah kandungan terperinci Menggunakan penangguhan dalam Go: Amalan Terbaik dan Kes Penggunaan Biasa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
