blocks|key|2471476|text|通常，编码/解码JSON指的是将字符数据实际读/写成字符串或二进制形式的过程。编组/解组是指将JSON类型从Go数据类型和原语映射到the数据类型和原语的过程。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2471477|例如，实际编码可以包括序列化unicode字符之类的内容。我认为它们有时可以在文档中互换使用，因为它们通常出现在同一步骤中。例如，Marshal函数将确定要编组到哪种JSON类型，然后将以字符串形式进行编码(如果是文本数据，则可能包括其他细节，如特殊字符)。|2471478|您可以参考go+json包文档，了解有关marshaling/unmarshaling步骤如何工作的更多详细信息。|2471479|entityMap|0|LINK|mutability|MUTABLE|url|https://golang.org/pkg/encoding/json/#Marshal|1|https://golang.org/pkg/encoding/json/#Unmarshal^0|8|4|1B|4|1I|2|0|0|K|A|0|V|C|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|11|8|@]|D|@$9|12|A|13|1|14]|$9|15|A|16|1|17]]|E|$]]|$1|J|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]|R|$5|M|N|O|E|$P|S]]]]

Generally, encoding/decoding <code>JSON</code> refers to the process of actually reading/writing the character data to a string or binary form. Marshaling/Unmarshaling refers to the process of mapping <code>JSON</code> types from and to <code>Go</code> data types and primitives.

Actual encoding can include things like serializing unicode characters for example. I think they may be used somewhat interchangeably in documentation sometimes because they generally occur in the same step. The Marshal function for example, will determine which JSON type to marshal something to, and then it will be encoded in string form (which may include other details such as special characters if its textual data).

You can consult the go json package docs for more details on how the <a href="https://golang.org/pkg/encoding/json/#Marshal" rel="noreferrer">marshaling</a>/<a href="https://golang.org/pkg/encoding/json/#Unmarshal" rel="noreferrer">unmarshaling</a> steps work.

blocks|key|2471514|text|func+Encode是编码器上的一个方法，它将JSON编码的Go类型写入输出流(func+NewEncoder接受一个io.Writer并返回一个*编码器)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2471515|Go类型进入黑盒，并以JSON格式写出到流中。|2471516|Marshal是一个返回Go类型的JSON编码的函数。|2471517|在这里，您的Go类型以JSON格式输入黑框并从框中出来。|2471518|它有很好的文档记录：golang.org/pkg/encoding/json/|offset|length|2471519|entityMap|0|LINK|mutability|MUTABLE|url|https://golang.org/pkg/encoding/json/^0|0|0|0|0|A|T|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@$J|Y|K|Z|1|10]]|A|$]]|$1|L|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]]]

func Encode is a method on an Encoder, which writes JSON encoded Go types to an output stream (func NewEncoder takes an io.Writer and returns a *Encoder).

Your Go types enter the black box and are written out to the stream in JSON formatting.

Marshal is a function that returns JSON encoding of Go types.

Here your Go types enter the black box and come out of the box in JSON formatting.

It's well documented at: 
<a href="https://golang.org/pkg/encoding/json/" rel="nofollow">golang.org/pkg/encoding/json/</a>

blocks|key|1855843|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1855844|Marshal+=>+String|unordered-list-item|1855845|Encode+=>+Stream|1855846|1855847|Marshal和Unmarshal将字符串转换为JSON，反之亦然。编码和解码将流转换为JSON，反之亦然。|1855848|下面的代码显示了编组和解组的工作原理|1855849|type+Person+struct+{
First+string
Last+string
}
func+main()+{
++++/*+This+will+marshal+the+JSON+into+[]bytes+*/

++++p1+:=+Person{"alice",+"bob"}
++++bs,+_+:=+json.Marshal(p1)
++++fmt.Println(string(bs))

++++/*+This+will+unmarshal+the+JSON+from+[]bytes+*/

++++var+p2+Person
++++bs+=+[]byte(`{"First":"alice","Last":"bob"}`)
++++json.Unmarshal(bs,+&p2)
++++fmt.Println(p2)

}|code-block|syntax|javascript|1855850|编码器和解码器向流的切片写入结构，或者从流的切片读取数据并将其转换为结构。在内部，它还实现了marshal方法。唯一的区别是，如果您想使用编组来处理字符串或字节，并且如果您想要将任何数据读或写到某个编写器接口，则使用encodes和decode。|1855851|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|T|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|U|7|@]|8|@]|9|$]]|$1|D|3|E|4|C|6|V|7|@]|8|@]|9|$]]|$1|F|3|-4|4|5|6|W|7|@]|8|@]|9|$]]|$1|G|3|H|4|5|6|X|7|@]|8|@]|9|$]]|$1|I|3|J|4|5|6|Y|7|@]|8|@]|9|$]]|$1|K|3|L|4|M|6|Z|7|@]|8|@]|9|$N|O]]|$1|P|3|Q|4|5|6|10|7|@]|8|@]|9|$]]|$1|R|3|-4|4|5|6|11|7|@]|8|@]|9|$]]]|S|$]]

<ul>
<li>Marshal => String</li>
<li>Encode => Stream</li>
</ul>

Marshal and Unmarshal convert a string into JSON and vice versa.
Encoding and decoding convert a stream into JSON and vice versa.

The below code show working of marshal and unmarshal

<pre><code>type Person struct {
First string
Last string
}
func main() {
 /* This will marshal the JSON into []bytes */

 p1 := Person{"alice", "bob"}
 bs, _ := json.Marshal(p1)
 fmt.Println(string(bs))

 /* This will unmarshal the JSON from []bytes */

 var p2 Person
 bs = []byte(`{"First":"alice","Last":"bob"}`)
 json.Unmarshal(bs, &amp;p2)
 fmt.Println(p2)

}
</code></pre>

Encoder and decoder write struct to slice of a stream or read data from a slice of a stream and convert it into a struct. Internally, it also implements the marshal method. The only difference is if you want to play with string or bytes use marshal, and if any data you want to read or write to some writer interface, use encodes and decode.

blocks|key|5999386|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5999387|+JSON‘编码/解码’和JSON‘编组/解组’有什么区别？|blockquote|5999388|5999389|5999390|5999391|当然，Marshaling和Encoding是不同的概念，在维基百科(或其他地方)上更好地解决了这一问题。但简而言之，对象被编组为JSON编码的字符串。|offset|length|5999392|另外，不要让Golang的json.NewEncoder+/+(json.Encoder).Encode和json.Marshal方法让您感到困惑。它们都将对象编组为JSON编码的字符串。不同之处在于编码器，首先将对象编组为JSON编码字符串，然后将数据写入缓冲流(或维基百科上的Data+Buffer+)。因此，编码器比更简单的json.Marshal使用更多的代码和内存开销。|style|CODE|5999393|您也可以在Golang源代码中看到这一点：|5999394|https://golang.org/src/encoding/json/encode.go?s=6458:6501#L148|5999395|Encode：https://golang.org/src/encoding/json/stream.go?s=5070:5117#L191|unordered-list-item|5999396|
：|5999397|Marshal|5999398|5999399|通常，如果需要将JSON编码的字符串发送到文件系统或作为HTTP响应，则可能需要使用缓冲流。但是，您也可以使用pipe在没有缓冲流的情况下发送这个JSON编码字符串。|5999400|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Marshalling_(computer_science)|1|https://en.wikipedia.org/wiki/Character_encoding|2|https://en.wikipedia.org/wiki/Data_buffer|3|4|https://golang.org/src/encoding/json/stream.go?s=5070:5117#L191|5|https://golang.org/pkg/io/#Pipe^0|0|0|0|0|0|3|A|0|E|8|1|0|D|F|V|L|1H|C|4L|C|3W|B|2|0|0|0|1R|3|0|7|1R|4|0|0|0|0|1J|4|5|0^^$0|@$1|2|3|-4|4|5|6|1J|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1K|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|1L|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|1M|7|@]|8|@]|9|$]]|$1|F|3|-4|4|5|6|1N|7|@]|8|@]|9|$]]|$1|G|3|H|4|5|6|1O|7|@]|8|@$I|1P|J|1Q|1|1R]|$I|1S|J|1T|1|1U]]|9|$]]|$1|K|3|L|4|5|6|1V|7|@$I|1W|J|1X|M|N]|$I|1Y|J|1Z|M|N]|$I|20|J|21|M|N]|$I|22|J|23|M|N]]|8|@$I|24|J|25|1|26]]|9|$]]|$1|O|3|P|4|5|6|27|7|@]|8|@]|9|$]]|$1|Q|3|R|4|5|6|28|7|@]|8|@$I|29|J|2A|1|2B]]|9|$]]|$1|S|3|T|4|U|6|2C|7|@]|8|@$I|2D|J|2E|1|2F]]|9|$]]|$1|V|3|W|4|5|6|2G|7|@]|8|@]|9|$]]|$1|X|3|Y|4|U|6|2H|7|@]|8|@]|9|$]]|$1|Z|3|-4|4|5|6|2I|7|@]|8|@]|9|$]]|$1|10|3|11|4|5|6|2J|7|@]|8|@$I|2K|J|2L|1|2M]]|9|$]]|$1|12|3|-4|4|5|6|2N|7|@]|8|@]|9|$]]]|13|$14|$4|15|16|17|9|$18|19]]|1A|$4|15|16|17|9|$18|1B]]|1C|$4|15|16|17|9|$18|1D]]|1E|$4|15|16|17|9|$18|R]]|1F|$4|15|16|17|9|$18|1G]]|1H|$4|15|16|17|9|$18|1I]]]]

<blockquote>
What is the difference between JSON 'encoding/decoding' and JSON 'marshalling/unmarshalling'?
</blockquote>
<hr />
<a href="https://en.wikipedia.org/wiki/Marshalling_(computer_science)" rel="nofollow noreferrer">Marshaling</a> and <a href="https://en.wikipedia.org/wiki/Character_encoding" rel="nofollow noreferrer">Encoding</a> are of course different concepts, better addressed on Wikipedia (or elsewhere). But in short, objects are marshaled into JSON encoded strings.
Also don't let the Golang <code>json.NewEncoder</code> / <code>(json.Encoder).Encode</code> and <code>json.Marshal</code> methods confuse you. They both marshal objects into JSON encoded strings. The difference being the Encoder, first marshals the object to a JSON encoded string, then writes that data to a buffer stream (or <a href="https://en.wikipedia.org/wiki/Data_buffer" rel="nofollow noreferrer">Data Buffer</a> on Wikipedia). The Encoder therefore, uses more code and memory overhead than the simpler <code>json.Marshal</code>.
You can also see this in the Golang source code:
<ul>
<li>Marshal: <a href="https://golang.org/src/encoding/json/encode.go?s=6458:6501#L148" rel="nofollow noreferrer">https://golang.org/src/encoding/json/encode.go?s=6458:6501#L148</a></li>
<li>Encode: <a href="https://golang.org/src/encoding/json/stream.go?s=5070:5117#L191" rel="nofollow noreferrer">https://golang.org/src/encoding/json/stream.go?s=5070:5117#L191</a></li>
</ul>
Typically, if you need to send the JSON encoded string to a file system, or as an HTTP response, you may need the use of a buffer stream. However, you can also send this JSON encoded string without a buffer stream using a <a href="https://golang.org/pkg/io/#Pipe" rel="nofollow noreferrer">pipe</a>.

blocks|key|5999472|text|这些方法没有太大的区别，更多的是取决于你的使用，如果你有io.Reader+(例如:当你使用HTTP或文件系统时)，使用NewDecoder会更容易：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5999473|​|5999474|📷|atomic|offset|length|5999475|5999476|它提供io.Reader并返回*Decoder类型，然后将Decode方法链接到它：|5999477|5999478|5999479|5999480|此Decode方法将数据写入v，您将数据作为参数传递给它。|5999481|另一方面，|5999482|Unmarshal方法将帮助您轻松地将字符串化的JSON转换为Go数据类型(主要是结构和映射)|5999483|5999484|5999485|5999486|有关更多详细信息，请阅读文档：|5999487|https://golang.org/pkg/encoding/json/#Unmarshal|5999488|https://golang.org/pkg/encoding/json/#NewDecoder|5999489|https://golang.org/pkg/encoding/json/#Decoder.Decode|5999490|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/a5e26707e36910a966bfcb81a673144c.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/a6410ef04670995db4c92285f9f25ecc.png|2|https://ask.qcloudimg.com/http-save/yehe-900000/a9bd191ce6173a313a510c59b13f3141.png|3|LINK|MUTABLE|url|4|5^0|0|0|0|1|0|0|0|0|0|0|1|1|0|0|0|0|0|0|0|1|2|0|0|0|0|1B|3|0|0|1C|4|0|0|1G|5|0^^$0|@$1|2|3|4|5|6|7|1O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1Q|8|@]|9|@$G|1R|H|1S|1|1T]]|A|$]]|$1|I|3|C|5|6|7|1U|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1V|8|@]|9|@]|A|$]]|$1|L|3|C|5|6|7|1W|8|@]|9|@]|A|$]]|$1|M|3|E|5|F|7|1X|8|@]|9|@$G|1Y|H|1Z|1|20]]|A|$]]|$1|N|3|C|5|6|7|21|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|22|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|23|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|24|8|@]|9|@]|A|$]]|$1|U|3|C|5|6|7|25|8|@]|9|@]|A|$]]|$1|V|3|E|5|F|7|26|8|@]|9|@$G|27|H|28|1|29]]|A|$]]|$1|W|3|C|5|6|7|2A|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|2B|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|2C|8|@]|9|@$G|2D|H|2E|1|2F]]|A|$]]|$1|11|3|12|5|6|7|2G|8|@]|9|@$G|2H|H|2I|1|2J]]|A|$]]|$1|13|3|14|5|6|7|2K|8|@]|9|@$G|2L|H|2M|1|2N]]|A|$]]|$1|15|3|-4|5|6|7|2O|8|@]|9|@]|A|$]]]|16|$17|$5|18|19|1A|A|$1B|1C|1D|-4]]|1E|$5|18|19|1A|A|$1B|1F|1D|-4]]|1G|$5|18|19|1A|A|$1B|1H|1D|-4]]|1I|$5|1J|19|1K|A|$1L|10]]|1M|$5|1J|19|1K|A|$1L|12]]|1N|$5|1J|19|1K|A|$1L|14]]]]

There is not a lot of difference between these methods, it's more depends on your usage,
If you have io.Reader (for example: when you are working with HTTP or file system), it's easier to use NewDecoder:
<a href="https://i.stack.imgur.com/QcOyh.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/QcOyh.png" alt="json.NewDecoder go standard lib" /></a>
It gives io.Reader and returns *Decoder type,
then you chain a Decode method to it:
<a href="https://i.stack.imgur.com/kYFcG.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/kYFcG.png" alt="json.Decode go standard lib" /></a>
And this Decode method will write data to v that you passed to it as a parameter.
<h2>On the other hand</h2>
Unmarshal method will help you easily convert stringified JSON to Go data types (mostly structs and maps)
<a href="https://i.stack.imgur.com/kW8ew.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/kW8ew.png" alt="json.Unmarshal go standard lib" /></a>
for more details, you can read the documentation:
<a href="https://golang.org/pkg/encoding/json/#Unmarshal" rel="nofollow noreferrer">https://golang.org/pkg/encoding/json/#Unmarshal</a>
<a href="https://golang.org/pkg/encoding/json/#NewDecoder" rel="nofollow noreferrer">https://golang.org/pkg/encoding/json/#NewDecoder</a>
<a href="https://golang.org/pkg/encoding/json/#Decoder.Decode" rel="nofollow noreferrer">https://golang.org/pkg/encoding/json/#Decoder.Decode</a>

What is the difference between JSON 'encoding/decoding' and JSON 'marshalling/unmarshalling'?

Trying to learn how to write a RESTFUL api in golang and not sure what the difference between JSON 'encoding' and 'marshalling' is or if they are the same?

in Golang, what is the difference between json encoding and marshalling

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

JSON‘编码/解码’和JSON‘编组/解组’有什么区别？尝试学习如何用golang编写RESTFUL api，但不确定JSON“编码”和“编组”之间的区别是什么，或者它们是否相同？

问在Golang中，json编码和编组有什么不同？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Golang中，json编码和编组有什么不同？EN