Go語言使用Json的方法實現(xiàn)
在Go語言中，處理JSON數(shù)據(jù)通常涉及編碼（將Go結(jié)構(gòu)體轉(zhuǎn)換為JSON字符串）和解碼（將JSON字符串轉(zhuǎn)換為Go結(jié)構(gòu)體）。Go標準庫中的encoding/json包提供了這些功能。第三方插件可以使用"github.com/goccy/go-json"也有同樣的功能
Marshal函數(shù)將會遞歸遍歷整個對象，依次按成員類型對這個對象進行編碼，類型轉(zhuǎn)換規(guī)則如下：
bool類型 轉(zhuǎn)換為JSON的Boolean整數(shù)，浮點數(shù)等數(shù)值類型 轉(zhuǎn)換為
JSON的Numberstring轉(zhuǎn)換為JSON的字符串(帶""引號)struct轉(zhuǎn)換為JSON的Object，再根據(jù)各個成員的類型遞歸打包數(shù)組或切片 轉(zhuǎn)換為
JSON的Array[]byte會先進行base64編碼然后轉(zhuǎn)換為JSON字符串map轉(zhuǎn)換為JSON的Object，key必須是stringinterface{}按照內(nèi)部的實際類型進行轉(zhuǎn)換nil轉(zhuǎn)為JSON的nullchannel,func等類型 會返回UnsupportedTypeError
1、使用標準庫中的encoding/json包
字符串輸出&格式化輸出&解碼
package main
import (
"encoding/json"
"fmt"
)
type ColorGroup struct {
ID int
Name string
Colors []string
}
// 創(chuàng)建一個ColorGroup類型的變量來保存解碼后的數(shù)據(jù)
var decodedGroup ColorGroup
func main() {
group := ColorGroup{
ID: 1,
Name: "Reds",
Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
}
// 將結(jié)構(gòu)體編碼為JSON字符串
jsonData1, err := json.Marshal(group)
jsonData2, err := json.MarshalIndent(group, "", " ")
if err != nil {
fmt.Println("error:", err)
return
}
// 打印JSON字符串
fmt.Println(string(jsonData1))
fmt.Println(string(jsonData2))
// Output:
//{"ID":1,"Name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}
// {
// "ID": 1,
// "Name": "Reds",
// "Colors": [
// "Crimson",
// "Red",
// "Ruby",
// "Maroon"
// ]
// }
// 將JSON字符串解碼到ColorGroup結(jié)構(gòu)體中
err = json.Unmarshal([]byte(jsonData1), &decodedGroup)
if err != nil {
fmt.Println("error:", err)
return
}
// 打印解碼后的數(shù)據(jù)
fmt.Printf("ID: %d, Name: %s, Colors: %v\n", decodedGroup.ID, decodedGroup.Name, decodedGroup.Colors)
// Output: ID: 1, Name: Reds, Colors: [Crimson Red Ruby Maroon]
fmt.Println(decodedGroup.Colors[0])
fmt.Println(decodedGroup.Colors[1])
}
2、使用第三方包
標準輸出&格式化輸出&解碼
package main
import (
"fmt"
"github.com/goccy/go-json"
"os"
)
type ColorGroup struct {
ID int
Name string
Colors []string
}
func main() {
group := ColorGroup{
ID: 1,
Name: "Reds",
Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
}
b1, err := json.Marshal(group)
if err != nil {
fmt.Println("error:", err)
}
println(os.Stdout.Write(b1)) //os.Stdout.Write(b1)將字節(jié)切片b（即JSON字符串的字節(jié)表示）寫入到標準輸出
fmt.Println("---------------格式化輸出----------------")
// 使用 MarshalIndent 來格式化輸出
b2, err := json.MarshalIndent(group, "", " ") // 第二個參數(shù)是空字符串，表示不添加前綴；第三個參數(shù)是縮進字符串
if err != nil {
fmt.Println("error:", err)
return
}
// 使用 fmt.Println 來打印字符串
// MarshalIndent返回的是字節(jié)切片，我們需要使用string(b2)來將其轉(zhuǎn)換為字符串
fmt.Println(string(b2)) // 將字節(jié)切片轉(zhuǎn)換為字符串并打印
// 輸出將會是格式化后的 JSON 字符串
// 創(chuàng)建一個ColorGroup類型的變量來保存解碼后的數(shù)據(jù)
var decodedGroup ColorGroup
// 將JSON字符串解碼到ColorGroup結(jié)構(gòu)體中
err = json.Unmarshal([]byte(b1), &decodedGroup)
if err != nil {
fmt.Println("error:", err)
return
}
// 打印解碼后的數(shù)據(jù)
fmt.Printf("ID: %d, Name: %s, Colors: %v\n", decodedGroup.ID, decodedGroup.Name, decodedGroup.Colors)
// Output: ID: 1, Name: Reds, Colors: [Crimson Red Ruby Maroon]
fmt.Println(decodedGroup.Colors[0])
fmt.Println(decodedGroup.Colors[1])
}
請注意，在解碼時，你需要將JSON字符串轉(zhuǎn)換為[]byte，并且傳入結(jié)構(gòu)體的指針（使用&）。這樣，解碼后的數(shù)據(jù)才會被寫入到結(jié)構(gòu)體中
3、decode
package main
import (
"fmt"
"github.com/goccy/go-json"
)
// Animal 定義結(jié)構(gòu)體來表示單個JSON對象
type Animal struct {
Name string
Order string
}
func main() {
//創(chuàng)建一個JSON字節(jié)切片
var jsonBlob = []byte(`[
{"Name": "Platypus", "Order": "Monotremata"},
{"Name": "Quoll", "Order": "Dasyuromorphia"}
]`)
var animals []Animal
err := json.Unmarshal(jsonBlob, &animals)
if err != nil {
fmt.Println("error:", err)
}
fmt.Printf("%+v", animals)
fmt.Println()
// 打印解碼后的數(shù)據(jù)
for _, animal := range animals {
fmt.Printf("Name: %s, Order: %s\n", animal.Name, animal.Order)
}
}
4、注意
結(jié)構(gòu)體
結(jié)構(gòu)體必須是大寫字母開頭的成員才會被JSON處理到，小寫字母開頭的成員不會有影響。
Mashal時，結(jié)構(gòu)體的成員變量名將會直接作為JSON Object的key打包成JSON；Unmashal時，會自動匹配對應的變量名進行賦值，大小寫不敏感。
Unmarshal時，如果JSON中有多余的字段，會被直接拋棄掉；如果JSON缺少某個字段，則直接忽略不對結(jié)構(gòu)體中變量賦值，不會報錯。
package main
import (
"encoding/json"
"fmt"
)
type Message struct {
Name string
Body string
Time int64
inner string
}
func main() {
var m = Message{
Name: "Alice",
Body: "Hello",
Time: 1294706395881547000,
inner: "ok",
}
b := []byte(`{"nAmE":"Bob","Food":"Pickle", "inner":"changed"}`)
err := json.Unmarshal(b, &m)
if err != nil {
fmt.Printf(err.Error())
return
}
fmt.Printf("%v", m)
//Output: {Bob Hello 1294706395881547000 ok}
}
StructTag/結(jié)構(gòu)體標簽
如果希望手動配置結(jié)構(gòu)體的成員和JSON字段的對應關系，可以在定義結(jié)構(gòu)體的時候給成員打標簽：
使用omitempty熟悉，如果該字段為nil或0值（數(shù)字0,字符串"",空數(shù)組[]等），則打包的JSON結(jié)果不會有這個字段。
案例一
package main
import (
"encoding/json"
"fmt"
)
type Message struct {
Name string `json:"msg_name"` // 對應JSON的msg_name
Body string `json:"body,omitempty"` // 如果為空置則忽略字段
Time int64 `json:"-"` // 直接忽略字段
}
func main() {
var m = Message{
Name: "Alice",
Body: "",
Time: 1294706395881547000,
}
data, err := json.Marshal(m)
if err != nil {
fmt.Printf(err.Error())
return
}
fmt.Println(string(data))
//Output:{"msg_name":"Alice"}
}
案例二
package main
import (
"encoding/json"
"fmt"
"log"
"time"
)
// 定義一個用于JSON映射的結(jié)構(gòu)體
type User struct {
Name string `json:"username"` // 自定義字段名稱映射
Email string `json:"email"`
LastSeen CustomTime `json:"last_seen"` // 嵌套對象
Active bool `json:"-"` // 忽略此字段，即使JSON中存在也不解碼
}
// CustomTime 是一個用于表示時間的結(jié)構(gòu)體
type CustomTime struct {
time.Time
}
// 實現(xiàn) json.Unmarshaler 接口的 UnmarshalJSON 方法
func (ct *CustomTime) UnmarshalJSON(data []byte) error {
var s string
if err := json.Unmarshal(data, &s); err != nil {
return err
}
// 解析自定義時間格式
parsedTime, err := time.Parse(time.RFC3339, s)
if err != nil {
return err
}
ct.Time = parsedTime
return nil
}
func main() {
// 模擬從HTTP請求中獲取的JSON數(shù)據(jù)
jsonData := []byte(`{
"username": "johndoe",
"email": "john.doe@example.com",
"last_seen": "2023-04-01T12:34:56Z",
"active": true
}`)
// 創(chuàng)建一個 User 實例
var user User
// 使用 json.Unmarshal 解碼 JSON 數(shù)據(jù)
if err := json.Unmarshal(jsonData, &user); err != nil {
log.Fatal("Error unmarshaling JSON:", err)
}
// 打印解碼后的信息
fmt.Printf("Name: %s\n", user.Name)
fmt.Printf("Email: %s\n", user.Email)
fmt.Printf("Last Seen: %v\n", user.LastSeen)
// Active 字段將不會被解碼，即使JSON中存在
fmt.Printf("Active: %v\n", user.Active)
//輸出：
//Name: johndoe
//Email: john.doe@example.com
// Last Seen: 2023-04-01 12:34:56 +0000 UTC
//Active: false
}5、更靈活地使用JSON
使用json.RawMessage
json.RawMessage其實就是[]byte類型的重定義?？梢赃M行強制類型轉(zhuǎn)換。
現(xiàn)在有這么一種場景，結(jié)構(gòu)體中的其中一個字段的格式是未知的：
type Command struct {
ID int
Cmd string
Args *json.RawMessage
}使用json.RawMessage的話，Args字段在Unmarshal時不會被解析，直接將字節(jié)數(shù)據(jù)賦值給Args。我們可以能先解包第一層的JSON數(shù)據(jù)，然后根據(jù)Cmd的值，再確定Args的具體類型進行第二次Unmarshal。
這里要注意的是，一定要使用指針類型*json.RawMessage，否則在Args會被認為是[]byte類型，在打包時會被打包成base64編碼的字符串。
案例一
package main
import (
"encoding/json"
"fmt"
"log"
)
type Command struct {
ID int
Cmd string
Args *json.RawMessage // 未解析的JSON片段
}
func main() {
//json字節(jié)切片
jsonData := []byte(`{
"ID": 1,
"Cmd": "example",
"Args": ["arg1", "arg2"]
}`)
var cmd Command
//解碼/反序列化
if err := json.Unmarshal(jsonData, &cmd); err != nil {
log.Fatalf("Error unmarshaling JSON: %v", err)
}
fmt.Printf("Command: %+v\n", cmd)
// 如果需要，可以進一步處理cmd.Args字段
// 例如，將其解析為特定的Go類型
var args []string
if err := json.Unmarshal(*cmd.Args, &args); err != nil {
log.Printf("解析錯誤: %v", err)
} else {
fmt.Printf("Args: %v\n", args)
}
//輸出
//Command: {ID:1 Cmd:example Args:0xc0000080f0}
//Args: [arg1 arg2]
}案例二
package main
import (
"encoding/json"
"fmt"
"log"
)
type Command struct {
ID int
Cmd string
Args *json.RawMessage // 未解析的JSON片段
}
// UnmarshalJSON 自定義JSON解碼方法，Command實現(xiàn)了Unmarshaler接口
func (c *Command) UnmarshalJSON(data []byte) error {
fmt.Println("--------------使用自定義解碼--------------")
// 定義一個輔助結(jié)構(gòu)體，用于解碼除Args外的其他字段
type alias Command
var aux struct {
alias // 嵌入別名類型以獲取其他字段
}
// 先解碼除Args外的所有字段
if err := json.Unmarshal(data, &aux); err != nil {
return err
}
fmt.Printf("Command ID: %+v, Cmd: %+v\n", aux.alias.ID, aux.alias.Cmd)
// 將別名結(jié)構(gòu)體中的字段復制到c中
*c = Command(aux.alias)
// 檢查JSON中是否有Args字段，并處理它
var m map[string]json.RawMessage
if err := json.Unmarshal(data, &m); err != nil {
// 如果這里出錯，可能是因為JSON格式不正確，但我們可能仍然想要保留已經(jīng)解析的字段
// 因此，我們可以只記錄一個錯誤，但不返回它
log.Printf("Error parsing Args field: %v", err)
} else {
// 如果Args字段存在，將其賦值給c.Args
if rawArgs, ok := m["Args"]; ok {
c.Args = &rawArgs // 注意這里我們?nèi)×藃awArgs的地址
var args []string
if err := json.Unmarshal(*c.Args, &args); err != nil {
log.Printf("Error parsing Args contents: %v", err)
} else {
fmt.Printf("Args: %v\n", args)
}
}
}
// 如果沒有錯誤，返回nil
return nil
}
func main() {
//json字節(jié)切片
jsonData := []byte(`{
"ID": 1,
"Cmd": "example",
"Args": ["arg1", "arg2"]
}`)
var cmd Command
//解碼/反序列化
if err := json.Unmarshal(jsonData, &cmd); err != nil {
log.Fatalf("Error unmarshaling JSON: %v", err)
}
}
案例三
package main
import (
"encoding/json"
"fmt"
"log"
)
type Command struct {
ID int
Cmd string
Args *json.RawMessage // 未解析的JSON片段
}
// UnmarshalJSON 自定義JSON解碼方法，Command實現(xiàn)了Unmarshaler接口
func (c *Command) UnmarshalJSON(data []byte) error {
fmt.Println("--------------使用自定義解碼--------------")
// 檢查JSON中是否有Args字段，并處理它
var m map[string]json.RawMessage
if err := json.Unmarshal(data, &m); err != nil {
// 如果這里出錯，可能是因為JSON格式不正確，但我們可能仍然想要保留已經(jīng)解析的字段
// 因此，我們可以只記錄一個錯誤，但不返回它
log.Printf("Error parsing Args field: %v", err)
} else {
// 如果Args字段存在，將其賦值給c.Args
if rawArgs, ok := m["Args"]; ok {
c.Args = &rawArgs // 注意這里我們?nèi)×藃awArgs的地址
var args []string
if err := json.Unmarshal(*c.Args, &args); err != nil {
log.Printf("Error parsing Args contents: %v", err)
} else {
fmt.Printf("Args: %v\n", args)
}
}
}
// 如果沒有錯誤，返回nil
return nil
}
func main() {
//json字節(jié)切片
jsonData := []byte(`{
"ID": 1,
"Cmd": "example",
"Args": ["arg1", "arg2"]
}`)
var cmd Command
//解碼/反序列化
if err := json.Unmarshal(jsonData, &cmd); err != nil {
log.Fatalf("Error unmarshaling JSON: %v", err)
}
}
調(diào)用的json.Unmarshal，并不是調(diào)用json.Unmarshaler，為什么會調(diào)用UnmarshalJSON
調(diào)用 json.Unmarshal 函數(shù)時，您并沒有直接調(diào)用 json.Unmarshaler 接口的方法。但是，json.Unmarshal 函數(shù)在內(nèi)部會檢查目標類型是否實現(xiàn)了 json.Unmarshaler 接口。如果實現(xiàn)了該接口，json.Unmarshal 就會使用您為該類型定義的 UnmarshalJSON 方法來解碼 JSON 數(shù)據(jù)。
這是 json.Unmarshal 函數(shù)內(nèi)部邏輯的一部分，用于確定如何解碼 JSON 數(shù)據(jù)。具體步驟如下：
json.Unmarshal接收一個字節(jié)切片（包含 JSON 數(shù)據(jù)）和一個目標值的指針。- 它首先會檢查目標值的類型是否實現(xiàn)了
json.Unmarshaler接口。 - 如果實現(xiàn)了
json.Unmarshaler接口，json.Unmarshal就會調(diào)用該類型的UnmarshalJSON方法，并將 JSON 數(shù)據(jù)的字節(jié)切片作為參數(shù)傳遞給它。 - 如果目標值沒有實現(xiàn)
json.Unmarshaler接口，json.Unmarshal就會使用默認的解碼邏輯來填充目標值的字段。
這種機制使得開發(fā)者能夠靈活地控制 JSON 數(shù)據(jù)到 Go 結(jié)構(gòu)體之間的轉(zhuǎn)換過程。通過實現(xiàn) json.Unmarshaler 接口，您可以：
- 處理 JSON 數(shù)據(jù)中不存在的字段。
- 自定義字段名稱的映射規(guī)則。
- 處理 JSON 數(shù)據(jù)中的嵌套對象或數(shù)組。
- 執(zhí)行額外的驗證或數(shù)據(jù)處理邏輯。
以下是簡單的示例，展示了如何為一個類型實現(xiàn) json.Unmarshaler 接口
處理 JSON 數(shù)據(jù)中不存在的字段
假設我們有一個結(jié)構(gòu)體，它能夠處理JSON中可能缺失的字段，并且為這些字段提供默認值。
在這個例子中，Age 字段在JSON中不存在，因此它將被賦予其類型的零值（對于int類型是0）。
package main
import (
"encoding/json"
"fmt"
"log"
)
type User struct {
Name string `json:"name"`
Age int `json:"age"`
Email string `json:"email,omitempty"`
}
func main() {
var user User
// JSON 中沒有 "age" 字段，將使用 Age 的零值 0
jsonData := []byte(`{"name": "John", "email": "john@example.com"}`)
if err := json.Unmarshal(jsonData, &user); err != nil {
log.Fatal(err)
}
fmt.Printf("Name: %s, Age: %d, Email: %s\n", user.Name, user.Age, user.Email)
//Name: John, Age: 0, Email: john@example.com
}自定義字段名稱的映射規(guī)則
使用結(jié)構(gòu)體標簽中的json鍵來指定JSON字段名。
在這個例子中，結(jié)構(gòu)體的字段名和JSON字段名不匹配，我們通過在結(jié)構(gòu)體標簽中指定json來實現(xiàn)映射。
package main
import (
"encoding/json"
"fmt"
"log"
)
type User struct {
Username string `json:"user_name"`
Password string `json:"pass"`
}
func main() {
var user User
jsonData := []byte(`{"user_name": "johndoe", "pass": "secret"}`)
if err := json.Unmarshal(jsonData, &user); err != nil {
log.Fatal(err)
}
fmt.Printf("Username: %s, Password: %s\n", user.Username, user.Password)
//Username: johndoe, Password: secret
}處理 JSON 數(shù)據(jù)中的嵌套對象或數(shù)組
解碼一個包含嵌套結(jié)構(gòu)體的JSON數(shù)據(jù)。
在這個例子中，Address 是一個嵌套在 User 結(jié)構(gòu)體中的對象。
package main
import (
"encoding/json"
"fmt"
"log"
)
type Address struct {
City string `json:"city"`
Country string `json:"country"`
}
type User struct {
Name string `json:"name"`
Address Address `json:"address"` // 嵌套對象
}
func main() {
var user User
jsonData := []byte(`{"name": "Jane", "address": {"city": "New York", "country": "USA"}}`)
if err := json.Unmarshal(jsonData, &user); err != nil {
log.Fatal(err)
}
fmt.Printf("Name: %s, Lives in %s, %s\n", user.Name, user.Address.City, user.Address.Country)
//Name: Jane, Lives in New York, USA
}執(zhí)行額外的驗證或數(shù)據(jù)處理邏輯
在UnmarshalJSON方法中添加額外的驗證邏輯。
在這個例子中，我們?yōu)?code>User類型實現(xiàn)了自定義的UnmarshalJSON方法。在解碼過程中，如果Age字段的值是負數(shù)，將返回一個錯誤，這是一個額外的驗證邏輯。
package main
import (
"encoding/json"
"fmt"
"log"
)
type User struct {
Name string `json:"name"`
Age int `json:"age"`
}
func (u *User) UnmarshalJSON(data []byte) error {
type Alias User // 影子類型，避免遞歸調(diào)用 UnmarshalJSON
aux := &Alias{Name: u.Name, Age: u.Age} // 使用輔助結(jié)構(gòu)體來解耦
if err := json.Unmarshal(data, aux); err != nil {
return err
}
*u = User(*aux) // 將解耦的結(jié)構(gòu)體賦值給當前結(jié)構(gòu)體
if u.Age < 0 { //年齡不能為負數(shù)
return fmt.Errorf("age cannot be negative")
}
return nil
}
func main() {
var user User
jsonData := []byte(`{"name": "Alice", "age": -5}`)
if err := json.Unmarshal(jsonData, &user); err != nil {
log.Fatal(err)
}
fmt.Printf("Name: %s, Age: %d\n", user.Name, user.Age)
} 在上面的示例中，User類型實現(xiàn)了 json.Unmarshaler 接口的 UnmarshalJSON 方法，使得 json.Unmarshal 函數(shù)在解碼 JSON 數(shù)據(jù)時會調(diào)用這個方法，而不是使用默認的解碼邏輯。這允許我們自定義解碼邏輯，例如只接受特定格式的 JSON 數(shù)據(jù)。
使用interface{}
interface{}類型在Unmarshal時，會自動將JSON轉(zhuǎn)換為對應的數(shù)據(jù)類型：
JSON的boolean 轉(zhuǎn)換為bool
JSON的數(shù)值 轉(zhuǎn)換為float64
JSON的字符串 轉(zhuǎn)換為string
JSON的Array 轉(zhuǎn)換為[]interface{}
JSON的Object 轉(zhuǎn)換為map[string]interface{}
JSON的null 轉(zhuǎn)換為nil
需要注意的有兩個。一個是所有的JSON數(shù)值自動轉(zhuǎn)換為float64類型，使用時需要再手動轉(zhuǎn)換為需要的int，int64等類型。第二個是JSON的object自動轉(zhuǎn)換為map[string]interface{}類型，訪問時直接用JSON ``Object的字段名作為key進行訪問。再不知道JSON數(shù)據(jù)的格式時，可以使用interface{}。
到此這篇關于Go語言使用Json的方法實現(xiàn)的文章就介紹到這了,更多相關Go 使用Json內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
Go并發(fā)讀寫文件、分片寫、分片下載文件的實現(xiàn)示例
讀寫文件在很多項目中都可以用到,本文主要介紹了Go并發(fā)讀寫文件、分片寫、分片下載文件的實現(xiàn)示例,具有一定的參考價值,感興趣的可以了解一下2024-01-01
本文介紹了Go語言原子操作的使用方法,原子操作是一種無鎖的技術(shù),可通過CPU指令實現(xiàn),文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧2024-10-10
Go語言實現(xiàn)控制臺輸入&生成隨機數(shù)詳解
這篇文章主要介紹了Go語言如何實現(xiàn)控制臺輸入&生成隨機數(shù)，文中通過示例代碼介紹的非常詳細，對大家的學習有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2022-05-05
本文主要帶大家學習了Golang里面的四大類型的變量，十分的詳細，有需要的小伙伴可以參考下2018-10-10
關于golang監(jiān)聽rabbitmq消息隊列任務斷線自動重連接的問題
這篇文章主要介紹了golang監(jiān)聽rabbitmq消息隊列任務斷線自動重連接,本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2022-03-03
事務是數(shù)據(jù)庫操作中的一個邏輯單元,由一系列的數(shù)據(jù)庫操作組成,這一系列操作要么全部執(zhí)行并且提交,要么全部回滾,確保數(shù)據(jù)的一致性和完整性,這篇文章主要介紹了golang的database.sql包和事務處理操作步驟,需要的朋友可以參考下2025-04-04
這篇文章主要介紹了go語言版的ip2long函數(shù),實例分析了Go語言實現(xiàn)的ip2long函數(shù)技巧,具有一定參考借鑒價值,需要的朋友可以參考下2015-02-02
在Mac中搭建go語言開發(fā)環(huán)境的操作步驟
go語言在開發(fā)效率和運行效率中的優(yōu)勢讓很多人青睞，所以有傾向打算轉(zhuǎn)向go語言的開發(fā)。下面介紹在Mac中g(shù)olang的開發(fā)環(huán)境配置。有需要的可以參考借鑒。2016-08-08
如何在 ubuntu linux 上配置 go 語言的 qt 開發(fā)環(huán)境
這篇文章主要介紹了如何在 ubuntu linux 上配置 go 語言的 qt 開發(fā)環(huán)境,本文分步驟通過實例代碼相結(jié)合給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2020-04-04
在 Go 語言中,處理瞬態(tài)錯誤是常見的挑戰(zhàn),這些錯誤可能會在一段時間后自動恢復,因此,重試機制在這些情況下非常重要,所以本文就來和大家聊聊Golang中強大的重試機制吧2025-01-01