Golang l&agrave; một ng&ocirc;n ngữ lập tr&igrave;nh m&atilde; nguồn mở bao gồm nhiều t&iacute;nh năng như thư viện chuẩn, quản l&yacute; g&oacute;i, nhập kiểu tĩnh, hỗ trợ kiểm thử v&agrave; nền tảng độc lập . Golang l&agrave; một trong những ng&ocirc;n ngữ kh&aacute; được ưa chuộng gần đ&acirc;y v&agrave; c&oacute; nhu cầu sử dụng cao trong lập tr&igrave;nh. Kh&oacute;a học n&agrave;y TEK4.VN sẽ cung cấp c&aacute;c kh&aacute;i niệm cơ bản v&agrave; n&acirc;ng cao về Golang, v&iacute; dụ xử l&yacute; ngoại lệ, mạng v&agrave; tạo mẫu. Trong kh&oacute;a học n&agrave;y, bạn cũng sẽ học c&aacute;c kh&aacute;i niệm cốt l&otilde;i về t&iacute;nh đồng thời. Bạn cũng sẽ được cung cấp c&aacute;c c&acirc;u hỏi v&agrave; b&agrave;i tập gi&uacute;p luyện tập kỹ năng tư duy phản biện v&agrave; giải quyết vấn đề sử dụng Golang. Sau khi ho&agrave;n th&agrave;nh kh&oacute;a học, bạn c&oacute; thể sử dụng Golang để viết c&aacute;c ứng dụng hiệu quả v&agrave; thực tế sử dụng t&iacute;nh đồng thời.
<h3 style="text-align: justify;">Mục ti&ecirc;u</h3>
<ul style="text-align: justify;">
<li style="font-weight: 400;" aria-level="1">Học c&aacute;c kh&aacute;i niệm cơ bản của Golang</li>
<li style="font-weight: 400;" aria-level="1">Học về t&iacute;nh đồng thời v&agrave; c&aacute;c khối kiến thức x&acirc;y dựng li&ecirc;n quan đến t&iacute;nh đồng thời</li>
<li style="font-weight: 400;" aria-level="1">Học c&aacute;ch x&acirc;y dựng một ứng dụng web ho&agrave;n chỉnh bằng Golang</li>
</ul>

Golang từ cơ bản đến nâng cao

<h2 style="text-align: justify;">Giải m&atilde; dữ liệu động</h2>
G&oacute;i <code>json</code> sử dụng c&aacute;c gi&aacute; trị <code>map[string]interface{}</code> v&agrave; <code>[]interface{}</code> để lưu trữ đối tượng v&agrave; mảng JSON động; n&oacute; c&oacute; thể dễ d&agrave;ng giải m&atilde; bất kỳ đối tượng JSON hợp lệ n&agrave;o th&agrave;nh một gi&aacute; trị <code>interface{}</code> đơn giản.
Cho dữ liệu JSON được lưu trữ trong biến <code>b</code>:
<pre class="language-go" data-content="b%20%3A%3D%20%5B%5Dbyte(%7B%22Name%22%3A%20%22Wednesday%22%2C%20%22Age%22%3A%206%2C%20%22Parents%22%3A%20%5B%22Gomez%22%2C%20%22Morticia%22%5D%7D)" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>b := []byte({"Name": "Wednesday", "Age": 6, "Parents": ["Gomez", "Morticia"]})</code></pre>
Mặc d&ugrave; kh&ocirc;ng biết cấu tr&uacute;c của dữ liệu n&agrave;y, ch&uacute;ng ta vẫn c&oacute; thể giải m&atilde; n&oacute; th&agrave;nh một gi&aacute; trị <code>interface{}</code> bằng Unmarshal:
<pre class="language-go" data-content="var%20f%20interface%7B%7D%0Aerr%20%3A%3D%20json.Unmarshal(b%2C%20%26f)" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>var f interface{}
err := json.Unmarshal(b, &amp;f)</code></pre>
Tại thời điểm n&agrave;y, gi&aacute; trị trong <code>f</code> sẽ l&agrave; một map với c&aacute;c kh&oacute;a l&agrave; chuỗi v&agrave; c&aacute;c gi&aacute; trị được lưu trữ dưới dạng gi&aacute; trị <code>interface{}</code> rỗng:
<pre class="language-go" data-content="map%5Bstring%5Dinterface%7B%7D%7B%0A%C2%A0%C2%A0%22Name%22%3A%20%22Wednesday%22%2C%0A%C2%A0%C2%A0%22Age%22%3A%206%2C%0A%C2%A0%C2%A0%22Parents%22%3A%20%5B%5Dinterface%7B%7D%7B%0A%C2%A0%C2%A0%C2%A0%C2%A0%22Gomez%22%2C%0A%C2%A0%C2%A0%C2%A0%C2%A0%22Morticia%22%2C%0A%C2%A0%C2%A0%7D%2C%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>map[string]interface{}{
 "Name": "Wednesday",
 "Age": 6,
 "Parents": []interface{}{
 "Gomez",
 "Morticia",
 },
}</code></pre>
Để truy cập v&agrave;o dữ liệu n&agrave;y, ch&uacute;ng ta c&oacute; thể sử dụng chỉ định kiểu để truy cập v&agrave;o <code>map[string]interface{}</code> cơ bản của <code>f</code>:
<pre class="language-go" data-content="m%20%3A%3D%20f.(map%5Bstring%5Dinterface%7B%7D)" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>m := f.(map[string]interface{})</code></pre>
Sau đ&oacute; ch&uacute;ng ta c&oacute; thể lặp qua map n&agrave;y bằng c&acirc;u lệnh <code>range</code> v&agrave; sử dụng <code>type switch</code> để truy cập v&agrave;o c&aacute;c gi&aacute; trị của map dưới dạng c&aacute;c kiểu cụ thể:
<pre class="language-go" data-content="for%20k%2C%20v%20%3A%3D%20range%20m%20%7B%0A%C2%A0%C2%A0switch%20vv%20%3A%3D%20v.(type)%20%7B%0A%C2%A0%C2%A0case%20string%3A%0A%C2%A0%C2%A0%C2%A0%C2%A0fmt.Println(k%2C%20%22is%20string%22%2C%20vv)%0A%C2%A0%C2%A0case%20int%3A%0A%C2%A0%C2%A0%C2%A0%C2%A0fmt.Println(k%2C%20%22is%20int%22%2C%20vv)%0A%C2%A0%C2%A0case%20%5B%5Dinterface%7B%7D%3A%0A%C2%A0%C2%A0%C2%A0%C2%A0fmt.Println(k%2C%20%22is%20an%20array%3A%22)%0A%C2%A0%C2%A0%C2%A0%C2%A0for%20i%2C%20u%20%3A%3D%20range%20vv%20%7B%0A%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0fmt.Println(i%2C%20u)%0A%C2%A0%C2%A0%C2%A0%C2%A0%7D%0A%C2%A0%C2%A0default%3A%0A%C2%A0%C2%A0%C2%A0%C2%A0fmt.Println(k%2C%20%22is%20of%20a%20type%20I%20don't%20know%20how%20to%20handle%22)%0A%C2%A0%C2%A0%7D%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>for k, v := range m {
 switch vv := v.(type) {
 case string:
 fmt.Println(k, "is string", vv)
 case int:
 fmt.Println(k, "is int", vv)
 case []interface{}:
 fmt.Println(k, "is an array:")
 for i, u := range vv {
 fmt.Println(i, u)
 }
 default:
 fmt.Println(k, "is of a type I don't know how to handle")
 }
}</code></pre>
Bằng c&aacute;ch n&agrave;y, bạn c&oacute; thể l&agrave;m việc với dữ liệu JSON kh&ocirc;ng x&aacute;c định trong khi vẫn đảm bảo t&iacute;nh an to&agrave;n kiểu.
<h2 style="text-align: justify;">Giải m&atilde; dữ liệu v&agrave;o struct</h2>
Nếu ch&uacute;ng ta biết trước &yacute; nghĩa của dữ liệu json, ch&uacute;ng ta c&oacute; thể định nghĩa một struct th&iacute;ch hợp v&agrave; giải m&atilde; dữ liệu v&agrave;o đ&oacute;. Với v&iacute; dụ trước, ch&uacute;ng ta sẽ định nghĩa:
<pre class="language-go" data-content="type%20FamilyMember%20struct%20%7B%0AName%20string%0AAge%20int%0AParents%20%5B%5Dstring%0A%7D" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>type FamilyMember struct {
Name string
Age int
Parents []string
}</code></pre>
v&agrave; sau đ&oacute; thực hiện giải m&atilde; với:
<pre class="language-go" data-content="var%20m%20FamilyMember%0Aerr%20%3A%3D%20json.Unmarshal(b%2C%20%26m)" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>var m FamilyMember
err := json.Unmarshal(b, &amp;m)</code></pre>
Code n&agrave;y ph&acirc;n bổ một slice mới trong chương tr&igrave;nh. Đ&acirc;y thường l&agrave; c&aacute;ch unmarshal hoạt động với c&aacute;c kiểu tham chiếu được hỗ trợ (con trỏ, slice v&agrave; map).
Dưới đ&acirc;y l&agrave; một v&iacute; dụ minh họa:
C&acirc;y JSON 
<div class="code-editor__wrapped code-editor__edit__wrapped" data-id="aacc8819-ea33-42f3-891a-96260389fe55">
<table class="code-editor__table" data-id="7e021858-4677-41f7-bdf4-3ff60405f297">
<tbody>
<tr class="code-editor__edit__row__first">
<td colspan="2">RUN_CODE (*** ph&acirc;n biệt ***)</td>
</tr>
<tr>
<td>GoLang</td>
<td>
<pre class="language-go" data-content="package" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>package main
import (
 "fmt"
 "encoding/json"
)

type Node struct {
 Left *Node
 Value interface{}
 Right *Node
}
func main() {
 b := []byte(`{"Value": "Father", "Left": {"Value": "Left child"}, "Right": {"Value": "Right child"}}`)
 var f Node
 json.Unmarshal(b, &amp;f)
 fmt.Println(f, f.Left, f.Right)
}</code></pre>
</td>
</tr>
</tbody>
</table>
</div>
Trong code tr&ecirc;n, ch&uacute;ng ta định nghĩa một struct t&ecirc;n l&agrave; <code>Node</code> ở d&ograve;ng 7, đại điện cho c&acirc;y nhị ph&acirc;n. N&oacute; bao gồm ba trường. Trường <code>Left</code> v&agrave; <code>Right</code> l&agrave; c&aacute;c con trỏ đến c&aacute;c <code>Node</code> kh&aacute;c, trong khi trường <code>Value</code> chứa dữ liệu. <code>Value</code> c&oacute; thể l&agrave; bất kỳ kiểu dữ liệu n&agrave;o, do đ&oacute; kiểu dữ liệu của n&oacute; l&agrave; <code>interface{}</code>.
Ở d&ograve;ng 13, ch&uacute;ng ta định nghĩa một mảng byte <code>b</code> chứa dữ liệu gốc của map với c&aacute;c kh&oacute;a l&agrave; <code>Value</code>, <code>Left</code> v&agrave; <code>Right</code>.
Ch&uacute;ng ta khai b&aacute;o biến <code>f</code> c&oacute; kiểu <code>Node</code> ở d&ograve;ng 15 v&agrave; ở d&ograve;ng 16, ch&uacute;ng ta giải m&atilde; <code>b</code> v&agrave;o struct <code>f</code>. Ch&uacute;ng ta thấy c&aacute;c con trỏ đều l&agrave; địa chỉ bộ nhớ: địa chỉ thực sự trong c&aacute;c node tr&ecirc;n c&ugrave;ng v&agrave; <code>nil</code> cho c&aacute;c node tr&aacute;i v&agrave; phải.
<h2 style="text-align: justify;">L&agrave;m việc với JSON v&agrave; struct</h2>
G&oacute;i <code>json</code> cũng cho ph&eacute;p m&atilde; h&oacute;a v&agrave; giải m&atilde; <code>json</code> với c&aacute;c t&ecirc;n trường kh&aacute;c với t&ecirc;n trường trong struct, v&iacute; dụ: 
<div class="code-editor__wrapped code-editor__edit__wrapped" data-id="671a6387-3792-46df-bba6-6f81509b874c">
<table class="code-editor__table" data-id="0c62e49b-6f88-43e9-8cef-4665792890d6">
<tbody>
<tr class="code-editor__edit__row__first">
<td colspan="2">RUN_CODE (*** ph&acirc;n biệt ***)</td>
</tr>
<tr>
<td>GoLang</td>
<td>
<pre class="language-go" data-content="package" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>package main
import (
 "fmt"
 "encoding/json"
)

type Person struct {
 Name string `json:"personName"`
 Age int `json:"personAge"`
}

func main() {
 b := []byte(`{"personName": "Obama", "personAge": 57}`)
 var p Person
 // Unmarshalling
 json.Unmarshal(b, &amp;p)
 fmt.Println(p)
 // Marshalling
 js, _ := json.Marshal(p)
 fmt.Printf("%s\n", js)
}</code></pre>
</td>
</tr>
</tbody>
</table>
</div>
Ở đ&acirc;y, ch&uacute;ng ta định nghĩa struct <code>Person</code> ở d&ograve;ng 7, trong khi định nghĩa c&aacute;c t&ecirc;n json thay thế dưới dạng chuỗi th&ocirc; được đặt trong dấu trọng &acirc;m, v&iacute; dụ: <code>Name string json:"personName"</code> c&oacute; nghĩa l&agrave; trường <code>Name</code> c&oacute; t&ecirc;n <code>personName</code> trong JSON.
Ở d&ograve;ng 13, ch&uacute;ng ta tạo dữ liệu JSON trong biến <code>b</code> v&agrave; ở d&ograve;ng 14, ch&uacute;ng ta tạo thực thể <code>p</code> của struct <code>Person</code>. Sau đ&oacute;, ch&uacute;ng ta giải m&atilde; <code>b</code> v&agrave;o <code>p</code> ở d&ograve;ng 16 với <code>Unmarshal(b, &amp;p)</code> v&agrave; in ra struct.
Ở d&ograve;ng 19, ch&uacute;ng ta sử dụng <code>Marshal</code> để tạo chuỗi JSON <code>js</code> từ struct <code>p</code> v&agrave; in ra, hiển thị c&aacute;c t&ecirc;n trường JSON được sử dụng:
<h2 style="text-align: justify;">Bộ m&atilde; h&oacute;a v&agrave; giải m&atilde; luồng dữ liệu</h2>
G&oacute;i <code>json</code> cung cấp c&aacute;c kiểu <code>Decoder</code> v&agrave; <code>Encoder</code> cho c&aacute;c thao t&aacute;c phổ biến với đọc v&agrave; ghi dữ liệu JSON theo luồng. C&aacute;c h&agrave;m<code> NewDecoder</code> v&agrave; <code>NewEncoder</code> bao gồm c&aacute;c kiểu interface <code>io.Reader</code> v&agrave; <code>io.Writer</code>.
<pre class="language-go" data-content="func%20NewDecoder(r%20io.Reader)%20*Decoder%0Afunc%20NewEncoder(w%20io.Writer)%20*Encoder." data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>func NewDecoder(r io.Reader) *Decoder
func NewEncoder(w io.Writer) *Encoder.</code></pre>
Để ghi dữ liệu json trực tiếp v&agrave;o file, bạn c&oacute; thể sử dụng <code>json.NewEncoder</code> tr&ecirc;n file (hoặc bất kỳ kiểu n&agrave;o kh&aacute;c triển khai interface <code>io.Writer</code>) v&agrave; gọi h&agrave;m <code>Encode()</code> tr&ecirc;n dữ liệu của chương tr&igrave;nh. Qu&aacute; tr&igrave;nh ngược lại được thực hiện bằng c&aacute;ch sử dụng <code>json.Decoder</code> v&agrave; h&agrave;m <code>Decode()</code>:
<pre class="language-go" data-content="func%20NewDecoder(r%20io.Reader)%20*Decoder%0Afunc%20(dec%20*Decoder)%20Decode(v%20interface%7B%7D)%20error" data-language="go" data-ace-language="golang" data-name-language="GoLang" data-main-file="main.go"><code>func NewDecoder(r io.Reader) *Decoder
func (dec *Decoder) Decode(v interface{}) error</code></pre>
Để &yacute; việc sử dụng interface đ&atilde; tổng qu&aacute;t h&oacute;a triển khai. C&aacute;c cấu tr&uacute;c dữ liệu c&oacute; thể l&agrave; bất cứ thứ g&igrave; v&igrave; ch&uacute;ng chỉ cần triển khai <code>interface{}</code>. C&aacute;c đối tượng hoặc nguồn để m&atilde; h&oacute;a/giải m&atilde; dữ liệu phải triển khai interface <code>io.Writer</code> hoặc <code>io.Reader</code>. Do mức độ phổ biến của c&aacute;c đối tượng đọc v&agrave; ghi, c&aacute;c kiểu <code>Encoder</code> v&agrave; <code>Decoder</code> c&oacute; thể được sử dụng trong nhiều t&igrave;nh huống kh&aacute;c nhau, chẳng hạn đọc v&agrave; ghi dữ liệu từ kết nối HTTP, web-socket hoặc file.

Giải mã JSON