十分鐘搞懂20個Golang優(yōu)秀實踐
只需要花上10分鐘閱讀本文，就可以幫助你更高效編寫Go代碼。
20: 使用適當縮進
良好的縮進使代碼更具可讀性，始終使用制表符或空格(最好是制表符)，并遵循Go標準的縮進約定。
package main
import "fmt"
func main() {
for i := 0; i < 5; i++ {
fmt.Println("Hello, World!")
}
}運行g(shù)ofmt根據(jù)Go標準自動格式化(縮進)代碼。
$ gofmt -w your_file.go19: 正確導(dǎo)入軟件包
只導(dǎo)入需要的包，并格式化導(dǎo)入部分，將標準庫包、第三方包和自己的包分組。
package main
import (
"fmt"
"math/rand"
"time"
)18: 使用描述性變量名和函數(shù)名
- 有意義的名稱: 使用能夠傳達變量用途的名稱。
- 駝峰表示法(CamelCase): 以小寫字母開頭，后面每個單詞的首字母大寫。
- *簡短的名稱: 簡短、簡潔的名稱對于作用域小、壽命短的變量是可以接受的。
- 不使用縮寫: 避免使用隱晦的縮寫和首字母縮略詞，盡量使用描述性名稱。
- 一致性: 在整個代碼庫中保持命名一致性。
package main
import "fmt"
func main() {
//使用有意義的名稱聲明變量
userName := "John Doe" // CamelCase:以小寫字母開頭，后面的單詞大寫。
itemCount := 10 // 簡短的名稱:對于小作用域變量來說，短而簡潔。
isReady := true // 不使用縮寫:避免使用隱晦的縮寫或首字母縮寫。
// 顯示變量值
fmt.Println("User Name:", userName)
fmt.Println("Item Count:", itemCount)
fmt.Println("Is Ready:", isReady)
}
// 對包級變量使用mixedCase
var exportedVariable int = 42
// 函數(shù)名應(yīng)該是描述性的
func calculateSumOfNumbers(a, b int) int {
return a + b
}
// 一致性:在整個代碼庫中保持命名的一致性。17: 限制每行長度
盡可能將每行代碼字符數(shù)控制在80個以下，以提高可讀性。
package main
import (
"fmt"
"math"
)
func main() {
result := calculateHypotenuse(3, 4)
fmt.Println("Hypotenuse:", result)
}
func calculateHypotenuse(a, b float64) float64 {
return math.Sqrt(a*a + b*b)
}16: 將魔法值定義為常量
避免在代碼中使用魔法值。魔法值是硬編碼的數(shù)字或字符串，分散在代碼中，缺乏上下文，很難理解其目的。將魔法值定義為常量，可以使代碼更易于維護。
package main
import "fmt"
const (
// 為重試的最大次數(shù)定義常量
MaxRetries = 3
// 為默認超時(以秒為單位)定義常量
DefaultTimeout = 30
)
func main() {
retries := 0
timeout := DefaultTimeout
for retries < MaxRetries {
fmt.Printf("Attempting operation (Retry %d) with timeout: %d seconds\n", retries+1, timeout)
// ... 代碼邏輯 ...
retries++
}
}15. 錯誤處理
Go鼓勵開發(fā)者顯式處理錯誤，原因如下:
- 安全性: 錯誤處理確保意外問題不會導(dǎo)致程序panic或突然崩潰。
- 清晰性: 顯式錯誤處理使代碼更具可讀性，并有助于識別可能發(fā)生錯誤的地方。
- 可調(diào)試性: 處理錯誤為調(diào)試和故障排除提供了有價值的信息。
我們創(chuàng)建一個簡單程序來讀取文件并正確處理錯誤:
package main
import (
"fmt"
"os"
)
func main() {
// Open a file
file, err := os.Open("example.txt")
if err != nil {
// 處理錯誤
fmt.Println("Error opening the file:", err)
return
}
defer file.Close() // 結(jié)束時關(guān)閉文件
// 讀取文件內(nèi)容
buffer := make([]byte, 1024)
_, err = file.Read(buffer)
if err != nil {
// 處理錯誤
fmt.Println("Error reading the file:", err)
return
}
// 打印文件內(nèi)容
fmt.Println("File content:", string(buffer))
}14. 避免使用全局變量
盡量減少使用全局變量，全局變量可能導(dǎo)致不可預(yù)測的行為，使調(diào)試變得困難，并阻礙代碼重用，還會在程序的不同部分之間引入不必要的依賴關(guān)系。相反，通過函數(shù)參數(shù)傳遞數(shù)據(jù)并返回值。
我們編寫一個簡單的Go程序來說明避免全局變量的概念:
package main
import (
"fmt"
)
func main() {
// 在main函數(shù)中聲明并初始化變量
message := "Hello, Go!"
// 調(diào)用使用局部變量的函數(shù)
printMessage(message)
}
// printMessage是帶參數(shù)的函數(shù)
func printMessage(msg string) {
fmt.Println(msg)
}13: 使用結(jié)構(gòu)體處理復(fù)雜數(shù)據(jù)
通過結(jié)構(gòu)體將相關(guān)的數(shù)據(jù)字段和方法組合在一起，使代碼更有組織性和可讀性。
下面是一個完整示例程序，演示了結(jié)構(gòu)體在Go中的應(yīng)用:
package main
import (
"fmt"
)
// 定義名為Person的結(jié)構(gòu)體來表示人的信息。
type Person struct {
FirstName string // 名字
LastName string // 姓氏
Age int // 年齡
}
func main() {
// 創(chuàng)建Person結(jié)構(gòu)的實例并初始化字段。
person := Person{
FirstName: "John",
LastName: "Doe",
Age: 30,
}
// 訪問并打印結(jié)構(gòu)體字段的值。
fmt.Println("First Name:", person.FirstName) // 打印名字
fmt.Println("Last Name:", person.LastName) // 打印姓氏
fmt.Println("Age:", person.Age) // 打印年齡
}12. 對代碼進行注釋
添加注釋來解釋代碼的功能，特別是對于復(fù)雜或不明顯的部分。
(1) 單行注釋
單行注釋以//開頭，用來解釋特定的代碼行。
package main
import "fmt"
func main() {
// 單行注釋
fmt.Println("Hello, World!") // 打印問候語
}(2) 多行注釋
多行注釋包含在/* */中，用于較長的解釋或跨越多行的注釋。
package main
import "fmt"
func main() {
/*
多行注釋。
可以跨越多行。
*/
fmt.Println("Hello, World!") // 打印問候語
}(3) 函數(shù)注釋
在函數(shù)中添加注釋，解釋函數(shù)的用途、參數(shù)和返回值。函數(shù)注釋使用'godoc'樣式。
package main
import "fmt"
// greetUser通過名稱向用戶表示歡迎。
// Parameters:
// name (string): 歡迎的用戶名
// Returns:
// string: 問候語
func greetUser(name string) string {
return "Hello, " + name + "!"
}
func main() {
userName := "Alice"
greeting := greetUser(userName)
fmt.Println(greeting)
}(4) 包注釋
在Go文件頂部添加注釋來描述包的用途，使用相同的'godoc'樣式。
package main
import "fmt"
// 這是Go程序的主包。
// 包含入口(main)函數(shù)。
func main() {
fmt.Println("Hello, World!")
}11: 使用goroutine處理并發(fā)
利用goroutine來高效執(zhí)行并發(fā)操作。在Go語言中，gooutine是輕量級的并發(fā)執(zhí)行線程，能夠并發(fā)的運行函數(shù)，而沒有傳統(tǒng)線程的開銷。從而幫助我們編寫高度并發(fā)和高效的程序。
我們用一個簡單的例子來說明:
package main
import (
"fmt"
"time"
)
// 并發(fā)運行的函數(shù)
func printNumbers() {
for i := 1; i <= 5; i++ {
fmt.Printf("%d ", i)
time.Sleep(100 * time.Millisecond)
}
}
// 在主goroutine中運行的函數(shù)
func main() {
// 開始goroutine
go printNumbers()
// 繼續(xù)執(zhí)行main
for i := 0; i < 2; i++ {
fmt.Println("Hello")
time.Sleep(200 * time.Millisecond)
}
// 確保在goroutine在退出前完成
time.Sleep(1 * time.Second)
}10: 用Recover處理panic
使用recover來優(yōu)雅處理panic和防止程序崩潰。在Go中，panic是可能導(dǎo)致程序崩潰的意外運行時錯誤。然而，Go提供了一種名為recover的機制來優(yōu)雅的處理panic。
我們用一個簡單的例子來說明:
package main
import "fmt"
// 可能會panic的函數(shù)
func riskyOperation() {
defer func() {
if r := recover(); r != nil {
// 從panic中Recover，并優(yōu)雅處理
fmt.Println("Recovered from panic:", r)
}
}()
// 模擬panic條件
panic("Oops! Something went wrong.")
}
func main() {
fmt.Println("Start of the program.")
// 在從panic中恢復(fù)的函數(shù)中調(diào)用有風險的操作
riskyOperation()
fmt.Println("End of the program.")
}9. 避免使用'init'函數(shù)
除非必要，否則避免使用init函數(shù)，因為這會使代碼更難理解和維護。
更好的方法是將初始化邏輯移到顯式調(diào)用的常規(guī)函數(shù)中，通常從main中調(diào)用，從而提供了更好的控制，增強了代碼可讀性，并簡化了測試。
下面是一個簡單的Go程序，演示了如何避免使用init函數(shù):
package main
import (
"fmt"
)
// InitializeConfig初始化配置
func InitializeConfig() {
// 初始化配置參數(shù)
fmt.Println("Initializing configuration...")
}
// InitializeDatabase初始化數(shù)據(jù)庫連接
func InitializeDatabase() {
// 初始化數(shù)據(jù)庫連接
fmt.Println("Initializing database...")
}
func main() {
// 顯示調(diào)用初始化函數(shù)
InitializeConfig()
InitializeDatabase()
// 主代碼邏輯
fmt.Println("Main program logic...")
}8: 使用Defer進行資源清理
defer可以將函數(shù)的執(zhí)行延遲到函數(shù)返回的時候，通常用于關(guān)閉文件、解鎖互斥鎖或釋放其他資源等任務(wù)。
這確保了即使在存在錯誤的情況下也能執(zhí)行清理操作。
我們創(chuàng)建一個簡單的程序，從文件中讀取數(shù)據(jù)，使用defer確保文件被正確關(guān)閉，不用管可能發(fā)生的任何錯誤:
package main
import (
"fmt"
"os"
)
func main() {
// 打開文件(用實際文件名替換"example.txt")
file, err := os.Open("example.txt")
if err != nil {
fmt.Println("Error opening the file:", err)
return // Exit the program on error
}
defer file.Close() // 確保函數(shù)退出時關(guān)閉文件
// 讀取并打印文件內(nèi)容
data := make([]byte, 100)
n, err := file.Read(data)
if err != nil {
fmt.Println("Error reading the file:", err)
return // 出錯退出程序
}
fmt.Printf("Read %d bytes: %s\n", n, data[:n])
}7: 選擇復(fù)合字面值而不是構(gòu)造函數(shù)
使用復(fù)合字面值來創(chuàng)建struct實例，而不是構(gòu)造函數(shù)。
為什么要使用復(fù)合文字?
復(fù)合字面值提供了幾個優(yōu)點:
- 簡潔
- 易讀
- 靈活
我們用一個簡單例子來說明:
package main
import (
"fmt"
)
// 定義一個表示人的結(jié)構(gòu)類型
type Person struct {
FirstName string // 名字
LastName string // 姓氏
Age int // 年齡
}
func main() {
// 使用復(fù)合字面量創(chuàng)建Person實例
person := Person{
FirstName: "John", // 初始化FirstName字段
LastName: "Doe", // 初始化LastName字段
Age: 30, // 初始化Age字段
}
// Printing the person's information
fmt.Println("Person Details:")
fmt.Println("First Name:", person.FirstName) // 訪問并打印FirstName字段
fmt.Println("Last Name:", person.LastName) // 訪問并打印LastName字段
fmt.Println("Age:", person.Age) // 訪問并打印Age字段
}6. 最小化功能參數(shù)
在Go中，編寫干凈高效的代碼至關(guān)重要。實現(xiàn)這一點的一種方法是盡量減少函數(shù)參數(shù)的數(shù)量，從而提高代碼的可維護性和可讀性。
我們用一個簡單例子來說明:
package main
import "fmt"
// Option結(jié)構(gòu)保存配置參數(shù)
type Option struct {
Port int
Timeout int
}
// ServerConfig是接受Option結(jié)構(gòu)作為參數(shù)的函數(shù)
func ServerConfig(opt Option) {
fmt.Printf("Server configuration - Port: %d, Timeout: %d seconds\n", opt.Port, opt.Timeout)
}
func main() {
// 創(chuàng)建Option結(jié)構(gòu)并初始化為默認值
defaultConfig := Option{
Port: 8080,
Timeout: 30,
}
// 用默認值配置服務(wù)
ServerConfig(defaultConfig)
// 創(chuàng)建新的Option結(jié)構(gòu)并修改端口
customConfig := Option{
Port: 9090,
}
// 用自定義端口和默認Timeout配置服務(wù)
ServerConfig(customConfig)
}在這個例子中，我們定義了一個Option結(jié)構(gòu)體來保存服務(wù)器配置參數(shù)。我們沒有向ServerConfig函數(shù)傳遞多個參數(shù)，而是使用Option結(jié)構(gòu)體，這使得代碼更易于維護和擴展。這種方法在具有大量配置參數(shù)的函數(shù)時特別有用。
5: 清晰起見，使用顯式返回值而不是命名返回值
命名返回值在Go中很常用，但有時會使代碼不那么清晰，特別是在較大的代碼庫中。
我們用一個簡單例子來看看它們的區(qū)別。
package main
import "fmt"
// namedReturn演示命名返回值。
func namedReturn(x, y int) (result int) {
result = x + y
return
}
// explicitReturn演示顯式返回值。
func explicitReturn(x, y int) int {
return x + y
}
func main() {
// 命名返回值
sum1 := namedReturn(3, 5)
fmt.Println("Named Return:", sum1)
// 顯示返回值
sum2 := explicitReturn(3, 5)
fmt.Println("Explicit Return:", sum2)
}上面的示例程序中有兩個函數(shù)，namedReturn和explicitReturn，以下是它們的不同之處:
- namedReturn使用命名返回值result。雖然函數(shù)返回的內(nèi)容很清楚，但在更復(fù)雜的函數(shù)中可能不會很明顯。
- explicitReturn直接返回結(jié)果，這樣更簡單、明確。
4: 將函數(shù)復(fù)雜性保持在最低限度
函數(shù)復(fù)雜性是指函數(shù)代碼的復(fù)雜程度、嵌套程度和分支程度。保持較低的函數(shù)復(fù)雜度會使代碼更具可讀性、可維護性，并且不易出錯。
我們用一個簡單的例子來探索這個概念:
package main
import (
"fmt"
)
// CalculateSum返回兩個數(shù)字的和
func CalculateSum(a, b int) int {
return a + b
}
// PrintSum打印兩個數(shù)字的和
func PrintSum() {
x := 5
y := 3
sum := CalculateSum(x, y)
fmt.Printf("Sum of %d and %d is %d\n", x, y, sum)
}
func main() {
// 調(diào)用PrintSum函數(shù)來演示最小函數(shù)復(fù)雜度
PrintSum()
}在上面的示例程序中:
- 我們定義了兩個函數(shù)，CalculateSum和PrintSum，各自具有特定職責。
- CalculateSum是一個簡單函數(shù)，用于計算兩個數(shù)字的和。
- PrintSum調(diào)用CalculateSum計算并打印5和3的和。
- 通過保持函數(shù)簡潔并專注于單個任務(wù)，我們保持了較低的函數(shù)復(fù)雜性，提高了代碼的可讀性和可維護性。
3: 避免隱藏變量
當在較窄的范圍內(nèi)聲明具有相同名稱的新變量時，就會發(fā)生變量隱藏，這可能導(dǎo)致意外行為。這種情況下，具有相同名稱的外部變量會被隱藏，使其在該作用域中不可訪問。盡量避免在嵌套作用域中隱藏變量以防止混淆。
參考如下示例程序:
package main
import "fmt"
func main() {
// 聲明并初始化值為10的外部變量'x'。
x := 10
fmt.Println("Outer x:", x)
// 在內(nèi)部作用域里用新變量'x'覆蓋外部'x'。
if true {
x := 5 // 覆蓋發(fā)生在這里
fmt.Println("Inner x:", x) // 打印內(nèi)部'x', 值為5
}
// 外部'x'保持不變并仍然可以訪問
fmt.Println("Outer x after inner scope:", x) // 打印外部'x', 值為10
}2: 使用接口進行抽象
(1) 抽象
抽象是Go中的基本概念，允許我們定義行為而不指定實現(xiàn)細節(jié)。
(2) 接口
在Go語言中，接口是方法簽名的集合。
實現(xiàn)接口的所有方法的任何類型都隱式的滿足該接口。
因此只要遵循相同的接口，我們就能夠編寫可以處理不同類型的代碼。
下面是一個用Go語言編寫的示例程序，演示了使用接口進行抽象的概念:
package main
import (
"fmt"
"math"
)
// 定義Shape接口
type Shape interface {
Area() float64
}
// Rectangle結(jié)構(gòu)
type Rectangle struct {
Width float64
Height float64
}
// Circle結(jié)構(gòu)
type Circle struct {
Radius float64
}
// 實現(xiàn)Rectangle的Area方法
func (r Rectangle) Area() float64 {
return r.Width * r.Height
}
// 實現(xiàn)Circle的Area方法
func (c Circle) Area() float64 {
return math.Pi * c.Radius * c.Radius
}
// 打印任何形狀面積的函數(shù)
func PrintArea(s Shape) {
fmt.Printf("Area: %.2f\n", s.Area())
}
func main() {
rectangle := Rectangle{Width: 5, Height: 3}
circle := Circle{Radius: 2.5}
// 對矩形和圓形調(diào)用PrintArea，因為都實現(xiàn)了Shape接口
PrintArea(rectangle) // 打印矩形面積
PrintArea(circle) // 打印圓形面積
}在這個程序中，我們定義了Shape接口，創(chuàng)建了兩個結(jié)構(gòu)體Rectangle和Circle，每個結(jié)構(gòu)體都實現(xiàn)了Area()方法，并使用PrintArea函數(shù)打印滿足Shape接口的任何形狀的面積。
這演示了如何在Go中使用接口進行抽象，從而使用公共接口處理不同的類型。
1: 避免混合庫包和可執(zhí)行文件
在Go中，在包和可執(zhí)行文件之間保持清晰的隔離以確保代碼干凈和可維護性至關(guān)重要。
下面是演示庫和可執(zhí)行文件分離的示例項目結(jié)構(gòu):
myproject/
├── main.go
├── myutils/
└── myutils.gomyutils/myutils.go:
// 包聲明——為實用程序函數(shù)創(chuàng)建單獨的包
package myutils
import "fmt"
// 導(dǎo)出打印消息的函數(shù)
func PrintMessage(message string) {
fmt.Println("Message from myutils:", message)
}main.go:
// 主程序
package main
import (
"fmt"
"myproject/myutils" // 導(dǎo)入自定義包
)
func main() {
message := "Hello, Golang!"
// 調(diào)用自定義包里的導(dǎo)出函數(shù)
myutils.PrintMessage(message)
// 演示主程序邏輯
fmt.Println("Message from main:", message)
}在上面的例子中，有兩個獨立的文件: myutils.go和main.go。
- myutils.go定義了一個名為myutils的自定義包，包含輸出函數(shù)PrintMessage，用于打印消息。
- main.go是使用相對路徑(myproject/myutils)導(dǎo)入自定義包myutils的可執(zhí)行文件。
- main.go中的main函數(shù)從myutils包中調(diào)用PrintMessage函數(shù)并打印一條消息。這種關(guān)注點分離保持了代碼的組織性和可維護性。
參考資料：
[1]Golang Best Practices (Top 20): https://medium.com/@golangda/golang-quick-reference-top-20-best-coding-practices-c0cea6a43f20
