Go語(yǔ)言使用Json的方法實(shí)現(xiàn)
在Go語(yǔ)言中，處理JSON數(shù)據(jù)通常涉及編碼（將Go結(jié)構(gòu)體轉(zhuǎn)換為JSON字符串）和解碼（將JSON字符串轉(zhuǎn)換為Go結(jié)構(gòu)體）。Go標(biāo)準(zhǔn)庫(kù)中的encoding/json包提供了這些功能。第三方插件可以使用"github.com/goccy/go-json"也有同樣的功能
Marshal函數(shù)將會(huì)遞歸遍歷整個(gè)對(duì)象，依次按成員類型對(duì)這個(gè)對(duì)象進(jìn)行編碼，類型轉(zhuǎn)換規(guī)則如下：
bool類型 轉(zhuǎn)換為JSON的Boolean整數(shù)，浮點(diǎn)數(shù)等數(shù)值類型 轉(zhuǎn)換為
JSON的Numberstring轉(zhuǎn)換為JSON的字符串(帶""引號(hào))struct轉(zhuǎn)換為JSON的Object，再根據(jù)各個(gè)成員的類型遞歸打包數(shù)組或切片 轉(zhuǎn)換為
JSON的Array[]byte會(huì)先進(jìn)行base64編碼然后轉(zhuǎn)換為JSON字符串map轉(zhuǎn)換為JSON的Object，key必須是stringinterface{}按照內(nèi)部的實(shí)際類型進(jìn)行轉(zhuǎn)換nil轉(zhuǎn)為JSON的nullchannel,func等類型 會(huì)返回UnsupportedTypeError
1、使用標(biāo)準(zhǔn)庫(kù)中的encoding/json包
字符串輸出&格式化輸出&解碼
package main
import (
"encoding/json"
"fmt"
)
type ColorGroup struct {
ID int
Name string
Colors []string
}
// 創(chuàng)建一個(gè)ColorGroup類型的變量來(lái)保存解碼后的數(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、使用第三方包
標(biāo)準(zhǔn)輸出&格式化輸出&解碼
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é)表示）寫(xiě)入到標(biāo)準(zhǔn)輸出
fmt.Println("---------------格式化輸出----------------")
// 使用 MarshalIndent 來(lái)格式化輸出
b2, err := json.MarshalIndent(group, "", " ") // 第二個(gè)參數(shù)是空字符串，表示不添加前綴；第三個(gè)參數(shù)是縮進(jìn)字符串
if err != nil {
fmt.Println("error:", err)
return
}
// 使用 fmt.Println 來(lái)打印字符串
// MarshalIndent返回的是字節(jié)切片，我們需要使用string(b2)來(lái)將其轉(zhuǎn)換為字符串
fmt.Println(string(b2)) // 將字節(jié)切片轉(zhuǎn)換為字符串并打印
// 輸出將會(huì)是格式化后的 JSON 字符串
// 創(chuàng)建一個(gè)ColorGroup類型的變量來(lái)保存解碼后的數(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])
}
請(qǐng)注意，在解碼時(shí)，你需要將JSON字符串轉(zhuǎn)換為[]byte，并且傳入結(jié)構(gòu)體的指針（使用&）。這樣，解碼后的數(shù)據(jù)才會(huì)被寫(xiě)入到結(jié)構(gòu)體中
3、decode
package main
import (
"fmt"
"github.com/goccy/go-json"
)
// Animal 定義結(jié)構(gòu)體來(lái)表示單個(gè)JSON對(duì)象
type Animal struct {
Name string
Order string
}
func main() {
//創(chuàng)建一個(gè)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)體必須是大寫(xiě)字母開(kāi)頭的成員才會(huì)被JSON處理到，小寫(xiě)字母開(kāi)頭的成員不會(huì)有影響。
Mashal時(shí)，結(jié)構(gòu)體的成員變量名將會(huì)直接作為JSON Object的key打包成JSON；Unmashal時(shí)，會(huì)自動(dòng)匹配對(duì)應(yīng)的變量名進(jìn)行賦值，大小寫(xiě)不敏感。
Unmarshal時(shí)，如果JSON中有多余的字段，會(huì)被直接拋棄掉；如果JSON缺少某個(gè)字段，則直接忽略不對(duì)結(jié)構(gòu)體中變量賦值，不會(huì)報(bào)錯(cuò)。
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)體標(biāo)簽
如果希望手動(dòng)配置結(jié)構(gòu)體的成員和JSON字段的對(duì)應(yīng)關(guān)系，可以在定義結(jié)構(gòu)體的時(shí)候給成員打標(biāo)簽：
使用omitempty熟悉，如果該字段為nil或0值（數(shù)字0,字符串"",空數(shù)組[]等），則打包的JSON結(jié)果不會(huì)有這個(gè)字段。
案例一
package main
import (
"encoding/json"
"fmt"
)
type Message struct {
Name string `json:"msg_name"` // 對(duì)應(yīng)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"
)
// 定義一個(gè)用于JSON映射的結(jié)構(gòu)體
type User struct {
Name string `json:"username"` // 自定義字段名稱映射
Email string `json:"email"`
LastSeen CustomTime `json:"last_seen"` // 嵌套對(duì)象
Active bool `json:"-"` // 忽略此字段，即使JSON中存在也不解碼
}
// CustomTime 是一個(gè)用于表示時(shí)間的結(jié)構(gòu)體
type CustomTime struct {
time.Time
}
// 實(shí)現(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
}
// 解析自定義時(shí)間格式
parsedTime, err := time.Parse(time.RFC3339, s)
if err != nil {
return err
}
ct.Time = parsedTime
return nil
}
func main() {
// 模擬從HTTP請(qǐng)求中獲取的JSON數(shù)據(jù)
jsonData := []byte(`{
"username": "johndoe",
"email": "john.doe@example.com",
"last_seen": "2023-04-01T12:34:56Z",
"active": true
}`)
// 創(chuàng)建一個(gè) User 實(shí)例
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 字段將不會(huì)被解碼，即使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其實(shí)就是[]byte類型的重定義。可以進(jìn)行強(qiáng)制類型轉(zhuǎn)換。
現(xiàn)在有這么一種場(chǎng)景，結(jié)構(gòu)體中的其中一個(gè)字段的格式是未知的：
type Command struct {
ID int
Cmd string
Args *json.RawMessage
}使用json.RawMessage的話，Args字段在Unmarshal時(shí)不會(huì)被解析，直接將字節(jié)數(shù)據(jù)賦值給Args。我們可以能先解包第一層的JSON數(shù)據(jù)，然后根據(jù)Cmd的值，再確定Args的具體類型進(jìn)行第二次Unmarshal。
這里要注意的是，一定要使用指針類型*json.RawMessage，否則在Args會(huì)被認(rèn)為是[]byte類型，在打包時(shí)會(huì)被打包成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)
// 如果需要，可以進(jìn)一步處理cmd.Args字段
// 例如，將其解析為特定的Go類型
var args []string
if err := json.Unmarshal(*cmd.Args, &args); err != nil {
log.Printf("解析錯(cuò)誤: %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實(shí)現(xiàn)了Unmarshaler接口
func (c *Command) UnmarshalJSON(data []byte) error {
fmt.Println("--------------使用自定義解碼--------------")
// 定義一個(gè)輔助結(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)體中的字段復(fù)制到c中
*c = Command(aux.alias)
// 檢查JSON中是否有Args字段，并處理它
var m map[string]json.RawMessage
if err := json.Unmarshal(data, &m); err != nil {
// 如果這里出錯(cuò)，可能是因?yàn)镴SON格式不正確，但我們可能仍然想要保留已經(jīng)解析的字段
// 因此，我們可以只記錄一個(gè)錯(cuò)誤，但不返回它
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)
}
}
}
// 如果沒(méi)有錯(cuò)誤，返回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實(shí)現(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 {
// 如果這里出錯(cuò)，可能是因?yàn)镴SON格式不正確，但我們可能仍然想要保留已經(jīng)解析的字段
// 因此，我們可以只記錄一個(gè)錯(cuò)誤，但不返回它
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)
}
}
}
// 如果沒(méi)有錯(cuò)誤，返回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，為什么會(huì)調(diào)用UnmarshalJSON
調(diào)用 json.Unmarshal 函數(shù)時(shí)，您并沒(méi)有直接調(diào)用 json.Unmarshaler 接口的方法。但是，json.Unmarshal 函數(shù)在內(nèi)部會(huì)檢查目標(biāo)類型是否實(shí)現(xiàn)了 json.Unmarshaler 接口。如果實(shí)現(xiàn)了該接口，json.Unmarshal 就會(huì)使用您為該類型定義的 UnmarshalJSON 方法來(lái)解碼 JSON 數(shù)據(jù)。
這是 json.Unmarshal 函數(shù)內(nèi)部邏輯的一部分，用于確定如何解碼 JSON 數(shù)據(jù)。具體步驟如下：
json.Unmarshal接收一個(gè)字節(jié)切片（包含 JSON 數(shù)據(jù)）和一個(gè)目標(biāo)值的指針。- 它首先會(huì)檢查目標(biāo)值的類型是否實(shí)現(xiàn)了
json.Unmarshaler接口。 - 如果實(shí)現(xiàn)了
json.Unmarshaler接口，json.Unmarshal就會(huì)調(diào)用該類型的UnmarshalJSON方法，并將 JSON 數(shù)據(jù)的字節(jié)切片作為參數(shù)傳遞給它。 - 如果目標(biāo)值沒(méi)有實(shí)現(xiàn)
json.Unmarshaler接口，json.Unmarshal就會(huì)使用默認(rèn)的解碼邏輯來(lái)填充目標(biāo)值的字段。
這種機(jī)制使得開(kāi)發(fā)者能夠靈活地控制 JSON 數(shù)據(jù)到 Go 結(jié)構(gòu)體之間的轉(zhuǎn)換過(guò)程。通過(guò)實(shí)現(xiàn) json.Unmarshaler 接口，您可以：
- 處理 JSON 數(shù)據(jù)中不存在的字段。
- 自定義字段名稱的映射規(guī)則。
- 處理 JSON 數(shù)據(jù)中的嵌套對(duì)象或數(shù)組。
- 執(zhí)行額外的驗(yàn)證或數(shù)據(jù)處理邏輯。
以下是簡(jiǎn)單的示例，展示了如何為一個(gè)類型實(shí)現(xiàn) json.Unmarshaler 接口
處理 JSON 數(shù)據(jù)中不存在的字段
假設(shè)我們有一個(gè)結(jié)構(gòu)體，它能夠處理JSON中可能缺失的字段，并且為這些字段提供默認(rèn)值。
在這個(gè)例子中，Age 字段在JSON中不存在，因此它將被賦予其類型的零值（對(duì)于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 中沒(méi)有 "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)體標(biāo)簽中的json鍵來(lái)指定JSON字段名。
在這個(gè)例子中，結(jié)構(gòu)體的字段名和JSON字段名不匹配，我們通過(guò)在結(jié)構(gòu)體標(biāo)簽中指定json來(lái)實(shí)現(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ù)中的嵌套對(duì)象或數(shù)組
解碼一個(gè)包含嵌套結(jié)構(gòu)體的JSON數(shù)據(jù)。
在這個(gè)例子中，Address 是一個(gè)嵌套在 User 結(jié)構(gòu)體中的對(duì)象。
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"` // 嵌套對(duì)象
}
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í)行額外的驗(yàn)證或數(shù)據(jù)處理邏輯
在UnmarshalJSON方法中添加額外的驗(yàn)證邏輯。
在這個(gè)例子中，我們?yōu)?code>User類型實(shí)現(xiàn)了自定義的UnmarshalJSON方法。在解碼過(guò)程中，如果Age字段的值是負(fù)數(shù)，將返回一個(gè)錯(cuò)誤，這是一個(gè)額外的驗(yàn)證邏輯。
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)體來(lái)解耦
if err := json.Unmarshal(data, aux); err != nil {
return err
}
*u = User(*aux) // 將解耦的結(jié)構(gòu)體賦值給當(dāng)前結(jié)構(gòu)體
if u.Age < 0 { //年齡不能為負(fù)數(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類型實(shí)現(xiàn)了 json.Unmarshaler 接口的 UnmarshalJSON 方法，使得 json.Unmarshal 函數(shù)在解碼 JSON 數(shù)據(jù)時(shí)會(huì)調(diào)用這個(gè)方法，而不是使用默認(rèn)的解碼邏輯。這允許我們自定義解碼邏輯，例如只接受特定格式的 JSON 數(shù)據(jù)。
使用interface{}
interface{}類型在Unmarshal時(shí)，會(huì)自動(dòng)將JSON轉(zhuǎn)換為對(duì)應(yīng)的數(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
需要注意的有兩個(gè)。一個(gè)是所有的JSON數(shù)值自動(dòng)轉(zhuǎn)換為float64類型，使用時(shí)需要再手動(dòng)轉(zhuǎn)換為需要的int，int64等類型。第二個(gè)是JSON的object自動(dòng)轉(zhuǎn)換為map[string]interface{}類型，訪問(wèn)時(shí)直接用JSON ``Object的字段名作為key進(jìn)行訪問(wèn)。再不知道JSON數(shù)據(jù)的格式時(shí)，可以使用interface{}。
到此這篇關(guān)于Go語(yǔ)言使用Json的方法實(shí)現(xiàn)的文章就介紹到這了,更多相關(guān)Go 使用Json內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章主要介紹了Go 語(yǔ)言中的空接口的實(shí)現(xiàn)方法，本文給大家介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值,需要的朋友可以參考下2020-06-06
go-micro微服務(wù)domain層開(kāi)發(fā)示例詳解
這篇文章主要為大家介紹了go-micro微服務(wù)domain層開(kāi)發(fā)示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2023-01-01
簡(jiǎn)單聊聊Golang中defer預(yù)計(jì)算參數(shù)
在golang當(dāng)中defer代碼塊會(huì)在函數(shù)調(diào)用鏈表中增加一個(gè)函數(shù)調(diào)用,下面這篇文章主要給大家介紹了關(guān)于Golang中defer預(yù)計(jì)算參數(shù)的相關(guān)資料,文中通過(guò)實(shí)例代碼介紹的非常詳細(xì),需要的朋友可以參考下2022-03-03
Golang使用archive/zip包實(shí)現(xiàn)ZIP壓縮與解壓
Golang?中的?archive/zip?包用于處理?ZIP?格式的壓縮文件，提供了一系列用于創(chuàng)建、讀取和解壓縮?ZIP?格式文件的函數(shù)和類型，使用起來(lái)非常方便,下面就跟隨小編一起了解一下具體使用方法吧2023-08-08
Swagger 是一款強(qiáng)大的 API 文檔生成工具,可以幫助開(kāi)發(fā)者輕松創(chuàng)建、管理和展示 RESTful API 文檔,在本文中,我們將介紹如何在 Golang 項(xiàng)目中使用 Swagger 來(lái)生成 API 文檔,文中有相關(guān)的代碼示例供大家參考,需要的朋友可以參考下2024-07-07
這篇文章主要介紹了Go語(yǔ)言Echo服務(wù)器的方法,實(shí)例分析了Echo服務(wù)器的技巧,具有一定參考借鑒價(jià)值,需要的朋友可以參考下2015-02-02
golang實(shí)現(xiàn)并發(fā)控制的方法和技巧
golang 是一門(mén)支持并發(fā)的編程語(yǔ)言,它提供了 goroutine 和 channel 等強(qiáng)大的特性,讓我們可以輕松地創(chuàng)建和管理多個(gè)執(zhí)行單元,實(shí)現(xiàn)高效的任務(wù)處理,在本文中,我們將介紹一些 golang 的并發(fā)控制的方法和技巧,希望對(duì)你有所幫助2024-03-03
go語(yǔ)言實(shí)現(xiàn)sftp包上傳文件和文件夾到遠(yuǎn)程服務(wù)器操作
這篇文章主要介紹了go語(yǔ)言實(shí)現(xiàn)sftp包上傳文件和文件夾到遠(yuǎn)程服務(wù)器操作，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。一起跟隨小編過(guò)來(lái)看看吧2020-12-12
在?Go?語(yǔ)言中,函數(shù)選項(xiàng)模式（Functional?Options?Pattern）?是一種優(yōu)雅的設(shè)計(jì)模式,用于處理可選配置參數(shù),特別是當(dāng)配置項(xiàng)較多或可能變化時(shí),它避免了冗長(zhǎng)的構(gòu)造函數(shù)參數(shù)列表,提高了代碼的可讀性和可擴(kuò)展性,本文介紹Go函數(shù)選項(xiàng)模式,感興趣的朋友一起看看吧2025-08-08
golang 獲取明天零點(diǎn)的時(shí)間戳示例
今天小編就為大家分享一篇golang 獲取明天零點(diǎn)的時(shí)間戳示例，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。一起跟隨小編過(guò)來(lái)看看吧2018-05-05