Шпаргалка по работе с JSON в Golang
Парсинг JSON — одна из наиболее частых задач: в JSON приходят данные в REST API, конфигурационные файлы часто оформляются в виде JSON и пр.
Go предоставляют довольно удобные механизмы для этих целей расположенные в пакете «encoding/json» включающий в себя необходимые методы.
Преобразование в JSON
Преобразование простых типов ( bool , string , int )
boolVar, _ := json.Marshal(true) fmt.Println(string(boolVar)) // true intVar, _ := json.Marshal(1) fmt.Println(string(intVar)) // 1 fltVar, _ := json.Marshal(2.34) fmt.Println(string(fltVar)) // 2.34 strVar, _ := json.Marshal("something") fmt.Println(string(strVar)) // "something"
Преобразование массивов, слайсов и словарей
sliceVar1 := []string«John», «Andrew», «Robert»> sliceVar2, _ := json.Marshal(sliceVar) fmt.Println(string(sliceVar2)) // [«John», «Andrew», «Robert»] mapVar1 := map[string]string mapVar2, _ := json.Marshal(mapVar1) fmt.Println(string(mapVar2)) //
Преобразование пользовательских типов данных
type User struct < FirstName string LastName string Books: []string >userVar1 := &User< FirstName: "John", LastName: "Smith", Books: []string< "The Art of Programming", "Golang for Dummies" >> userVar2, _ := json.Marshal(userVar1) fmt.Println(string(userVar2)) //
По-умолчанию ключи в JSON будут соответствовать именам свойств структуры ( FirstName , LastName , Books ), если требуется изменить это поведение, то необходимо добавить теги:
type User2 struct < FirstName string `json:"name"` // свойство FirstName будет преобразовано в ключ "name" LastName string `json:"lastname"` // свойство LastName будет преобразовано в ключ "lastname" Books []string `json:"ordered_books"` // свойство Books будет преобразовано в ключ "ordered_books" >userVar3 := &User2< FirstName: "John", LastName: "Smith", Books: []string< "The Art of Programming", "Golang for Dummies" >> userVar4, _ := json.Marshal(userVar3) fmt.Println(string(userVar4)) //
Преобразование из JSON
Стандартные типы
byt := []byte(``) var dat map[string]interface<> if err := json.Unmarshal(byt, &dat); err != nil < panic(err) >fmt.Println(dat)
В dat получим объект типа map[string]interface<> . Для того, чтобы работать с «внутренностями» этого объекта придётся немного поcastовать:
num := dat["num"].(float64) // для того, чтобы получить из свойства num число fmt.Println(num) strs := dat["strs"].([]interface<>) // для того, чтобы получить массив интерфейсов. str1 := strs[0].(string) // . и потом получить из него строку fmt.Println(str1)
Пользовательские типы
Пользовательские типы так же просто можно получить из JSON:
user := User1<> userJson := "<\"FirstName\":\"John\",\"LastName\":\"Smith\",\"Books\":[\"The Art of Programming\",\"Golang for Dummies\"]>" bytes := []byte(userJson) json.Unmarshal(bytes, &user) fmt.Println(user.FirstName, user.LastName, user.Books) // John Smith [The Art of Programming Golang for Dummies]
Но что же делать, если ключи в JSON отличаются от свойств в структуре или необходимо получать не все данные из JSON? Для этого необходимо воспользоваться знакомыми по предыдущим примерам тегами json :
user2 := User2<> userJson2 := "<\"name\":\"John\",\"lastname\":\"Smith\",\"ordered_books\":[\"The Art of Programming\",\"Golang for Dummies\"]>" bytes2 := []byte(userJson2) json.Unmarshal(bytes2, &user2) fmt.Println(user2.FirstName, user2.LastName, user2.Books) // John Smith [The Art of Programming Golang for Dummies]
Получили результат аналогичный предыдущему.
На этом основы работы с JSON можно и завершить. Поиграться с преобразование можно в Go Playground. Примеры из статьи можно найти там же.
Список полезных ссылок:
- Go by Example: JSON
- Go Docs. Package json
- Unmarshaling nested JSON objects in Golang
- The Go Blog: JSON and Go
Как описать нестандартную структуру для JSON
Описать структуру для хранения информации
1. Описать структуру для хранения следующей информации: — название продукции — стоимость за.
Описать структуру для хранения следующей информации
Нужно срочно написать, а не выходит(((( Описать структуру для хранения следующей информации (при.
Описать структуру для обработки информации о студентах
Информация включает в себя: ФИО студента. Группа. Пол. Экзаменационные оценки по высшей.
Для представления данных в памяти описать структуру
Для представления данных в памяти описать структуру. 1)Языки программирования. Название, год.
4467 / 2701 / 484
Регистрация: 28.04.2012
Сообщений: 8,558
Сообщение от Gamerman 
структура наперед не известна
Как сформировать указаный JSON? Как описать поле client?
map[string]interface<>
Регистрация: 11.01.2021
Сообщений: 9
Так и начал делать, но как потом подвязать к структуре? Или тогда делать без структуры?
Грубо говоря, как описать в структуре «client»?
Добавлено через 2 минуты
Если делать
1 2 3 4 5 6
type Response_getform struct Ok bool `json:"ok"` Datetimedone string `json:"datetimedone"` Phone string `json:"phone"` Client map[string]interface<> `json:"client"` >
, то получается вложение клиент в клиент
4467 / 2701 / 484
Регистрация: 28.04.2012
Сообщений: 8,558
Сообщение от Gamerman
то получается вложение клиент в клиент
Что? Какое ещё вложение?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
package main import ( "encoding/json" "fmt" "log" ) const payload = ` "ok": true, "datetimedone": "2020-04-03 16:44:15", "client": "FirstName": "Mirko", "lastname" : "Gamerman" > >` type Response struct Ok bool `json:"ok"` Datetimedone string `json:"datetimedone"` Phone string `json:"phone"` Client map[string]interface<> `json:"client"` > func main() var r Response if err := json.Unmarshal([]byte(payload), &r); err != nil log.Fatal(err) > fmt.Printf("%+v\n", r) >
Регистрация: 09.10.2010
Сообщений: 145
как — то так
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
package main import ( "encoding/json" "fmt" "log" ) const payload = ` "ok": true, "datetimedone": "2020-04-03 16:44:15", "client": "FirstName": "Mirko", "lastname" : "Gamerman" > >` type Response struct Ok bool `json:"ok"` Datetimedone string `json:"datetimedone"` Phone string `json:"phone"` Client struct FirstName string `json:"FirstName"` Lastname string `json:"lastname"` > `json:"client"` > func main() var r Response if err := json.Unmarshal([]byte(payload), &r); err != nil log.Fatal(err) > fmt.Printf("%+v\n", r) fmt.Println(r.Client.FirstName, r.Client.Lastname) >
> Mirko Gamerman
Регистрация: 08.12.2015
Сообщений: 7
Как то делал helper для того чтобы парсить динамически json
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
package main import ( "fmt" "github.com/akula410/helper" ) func main() var json = []byte(` "datetimedone":"2020-04-03 16:44:15", "client": >`) var data = helper.Transform.ToMap(helper.Transform.JsonToInterface(json), make(map[string]interface<>, 0)) for key, value := range data switch v := value.(type) case nil:fmt.Println(key, value) case bool:fmt.Println(key, helper.Transform.ToBool(value, false)) case string:fmt.Println(key, helper.Transform.ToString(value, "")) default: fmt.Println(key, helper.Transform.ToMap(v, make(map[string]interface<>))) > > >
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
Помогаю со студенческими работами здесь
Как получить нужную мне структуру HTML из JSON
Нужен совет что поменять в json структуре или в коде , чтоб получить такую разметку: <div.
Как правильно сформировать json структуру по следующему формату
Что-то не получается сформировать структуру json. Параметры и значения вымышленные, нужно точно по.
Для хранения данных о ноутбуках описать структуру NOTEBOOK
Для хранения данных о ноутбуках описать структуру вида (при необходимости дополнив ее): .
Для хранения данных о планшетных сканерах описать структуру
Для хранения данных о планшетных сканерах описать структуру вида: struct scan_info< char.
Для хранения данных о ноутбуках описать структуру вида
Для хранения данных о ноутбуках описать структуру вида: struct NOTEBOOK < char m odel; // н.
Описать структуру с именем Marsh (для работы с маршрутами)
Описать структуру с именем MARSH, содержащую следующие поля: ■ название начального пункта.
(Решено) как распарсить входные данные в Golang, когда они входят от пользователя, json в Golang …
Внимание! Ответы искусственного интеллекта могут быть неточными. Не полагайтесь на них в медицине, юриспруденции, финансах и вопросах безопасности. При принятии важных решений всегда консультируйтесь с профильными специалистами.
Администрация сайта не несет ответственности за любой автоматически созданный контент. Если вы обнаружили ошибки, пожалуйста, сообщите об этом через кнопку «репорт» внизу ответа и мы примем соответствующие меры. Спасибо за вашу помощь в улучшении качества нашего сервиса.
Ответ нейросети:
Для распарсинга входных данных в формате JSON в Golang можно воспользоваться стандартной библиотекой encoding/json. Эта библиотека предоставляет удобные инструменты для сериализации и десериализации JSON-объектов в структуры данных Golang.
Процесс распарсинга JSON в Golang можно разделить на две основные части: декодирование JSON-строки в байтовый массив и разбор байтового массива в структуру данных.
Для начала необходимо прочитать входные данные от пользователя, например, из stdin или HTTP-запроса, и сохранить их в строковую переменную. В случае HTTP-запроса часто используются библиотеки типа net/http, где получение тела запроса можно выполнить с помощью функции ReadAll. Пример получения входных данных из HTTP-запроса:
«`
func handler(w http.ResponseWriter, r *http.Request) body, err := ioutil.ReadAll(r.Body)
if err != nil // Обработка ошибки чтения тела запроса
return
>
// Распарсинг JSON
var data MyDataStruct
err = json.Unmarshal(body, &data)
if err != nil // Обработка ошибки распарсинга JSON
return
>
// Доступ к данным
fmt.Println(data.Field1)
fmt.Println(data.Field2)
// .
>
«`
После получения входных данных необходимо распарсить JSON-строку в структуру данных Golang. Для этого используется функция json.Unmarshal, которой передается ссылка на переменную, в которую будет записан результат декодирования. Результат проверяется на ошибки, и в случае их наличия обрабатывается соответствующим образом.
Структура данных, в которую происходит распарсинг данных, должна соответствовать структуре JSON-объекта. Имена полей структуры данных должны совпадать с именами полей в JSON-объекте, иначе необходимо использовать аннотации для связывания полей структуры и полей JSON-объекта.
Пример структуры данных для распарсинга JSON:
«`
type MyDataStruct struct Field1 string `json:»field1″`
Field2 int `json:»field2″`
// .
>
«`
После успешного распарсинга JSON в структуру данных можно получить доступ к полям и работать с ними как с обычными переменными Golang.
Важно помнить, что при распарсинге JSON с помощью encoding/json в Golang необходимо учитывать привязку типов данных и проверять ошибки.
Также может потребоваться проверка наличия необходимых полей, а также обработка дополнительных случаев, таких как массивы или вложенные структуры данных.
Данный код примера является упрощенным и может потребовать доработки в зависимости от конкретной задачи и структуры входных данных. Однако, основной принцип работы с JSON-данными в Golang остается неизменным.
Чтобы оставить комментарий, необходимо авторизоваться.
Задай любой вопрос нейросети!
она справится с любой поставленной задачей быстрее чем поиск в Яндекс.
Для того, чтобы задать вопрос нейросети, необходимо войти на сайт.
Последние вопросы
Последние вопросы:
(c) ChatGPT по русски 2023. Все права защищены. При обнаружении неправомерного контента пишите на [email protected]
Хотите задать любой вопрос нейросети?
Нажимая «Регистрация» или «Войти через Google», вы соглашаетесь с Публичной офертой, даете Согласие на обработку персональных данных, а также подтверждаете что вам есть 18 лет»
Форма репорта неправомерного контента.
Обратная связь с администрацией проекта
Уведомление об использовании cookie файлов
Наш сайт, как и большинство других, использует файлы cookie и другие похожие технологии (пиксельные тэги и т. п.), чтобы предоставлять услуги, наиболее отвечающие Вашим интересам и потребностям, а также собирать статистическую и маркетинговую информацию для анализа и совершенствования наших услуг и сайтов.
При использовании данного сайта, вы подтверждаете свое согласие на использование файлов cookie и других похожих технологий в соответствии с настоящим Уведомлением.
Если Вы не согласны, чтобы мы использовали данный тип файлов, Вы должны соответствующим образом установить настройки Вашего браузера или не использовать наш сайт.
Обращаем Ваше внимание на то, что при блокировании или удалении cookie файлов, мы не можем гарантировать корректную работу нашего сайта в Вашем браузере.
Cookie файлы, которые сохраняются через веб-сайт, не содержат сведений, на основании которых можно Вас идентифицировать.
Что такое файл cookie и другие похожие технологии
Файл cookie представляет собой небольшой текстовый файл, сохраняемый на вашем компьютере, смартфоне или другом устройстве, которое Вы используете для посещения интернет-сайтов.
Некоторые посещаемые Вами страницы могут также собирать информацию, используя пиксельные тэги и веб-маяки, представляющие собой электронные изображения, называемые одно-пиксельными (1×1) или пустыми GIF-изображениями.
Файлы cookie могут размещаться на вашем устройстве нами («собственные» файлы cookie) или другими операторами (файлы cookie «третьих лиц»).
Мы используем два вида файлов cookie на сайте: «cookie сессии» и «постоянные cookie». Cookie сессии — это временные файлы, которые остаются на устройстве пока вы не покинете сайт. Постоянные cookie остаются на устройстве в течение длительного времени или пока вы вручную не удалите их (как долго cookie останется на вашем устройстве будет зависеть от продолжительности или «времени жизни» конкретного файла и настройки вашего браузера).
Cookie файлы бывают различных типов:
Необходимые. Эти файлы нужны для обеспечения правильной работы сайта, использования его функций. Отключение использования таких файлов приведет к падению производительности сайта, невозможности использовать его компоненты и сервисы.
Файлы cookie, относящиеся к производительности, эффективности и аналитике. Данные файлы позволяют анализировать взаимодействие посетителей с сайтом, оптимизировать содержание сайта, измерять эффективность рекламных кампаний, предоставляя информацию о количестве посетителей сайта, времени его использования, возникающих ошибках.
Функциональные файлы cookie запоминают пользователей, которые уже заходили на наш сайт, их индивидуальные параметры (такие как язык и регион, например) и предпочтения, и помогают индивидуализировать содержание сайта.
Рекламные файлы cookie определяют, какие сайты Вы посещали и как часто, какие ссылки Вы выбирали, что позволяет показывать Вам рекламные объявления, которые заинтересуют именно Вас.
Электронная почта. Мы также можем использовать технологии, позволяющие отслеживать, открывали ли вы, прочитали или переадресовывали определенные сообщения, отправленные нами на вашу электронную почту. Это необходимо, чтобы сделать наши средства коммуникации более полезными для пользователя. Если вы не желаете, чтобы мы получали сведения об этом, вам нужно аннулировать подписку посредством ссылки «Отписаться» («Unsubscribe»), находящейся внизу соответствующей электронной рассылки.
Кнопки доступа к социальным сетям. Они используются для того, чтобы пользователи могли поделиться ссылкой на страницу в социальных сетях или сделать электронную закладку. Данные кнопки являются ссылками на веб-сайты социальных сетей, принадлежащих третьим лицам, которые, в свою, очередь могут фиксировать информацию о вашей активности в интернете, в том числе на нашем сайте. Пожалуйста, ознакомьтесь с соответствующими условиями использования и политикой конфиденциальности таких сайтов для понимания того, как они используют ваши данные, и того, как можно отказаться от использования ими ваших данных или удалить их.
Сторонние веб-сервисы. Иногда на данном сайте мы используем сторонние веб-сервисы. Например, для отображения тех или иных элементов (изображения, видео, презентации и т. п.), организации опросов и т. п. Как и в случае с кнопками доступа к социальным сетям, мы не можем препятствовать сбору этими сайтами или внешними доменами информации о том, как вы используете содержание сайта.
Как управлять файлами cookie?
Большинство интернет-браузеров изначально настроены на автоматический прием файлов cookie.
В любое время Вы можете изменить настройки вашего браузера таким образом, чтобы блокировать файлы cookie или предупреждать вас о том, когда они будут отправляться к вам на устройство (обратитесь к руководству использования конкретного браузера). Отключение файлов cookie может повлиять на Вашу работу в интернете.
Если вы используете несколько устройств и (или) браузеров для доступа в интернет, соответствующие настройки должны быть изменены в каждом из них.
Заключительные положения
По собственному усмотрению мы можем периодически изменять настоящее Уведомление.
По возникающим вопросам с нами можно связаться, используя контакты, размещенные на нашем сайте.
Golang
JSON (JavaScript Object Notation) — это простой формат обмена данными. Синтаксически это напоминает объекты и списки JavaScript. Он чаще всего используется для связи между веб-интерфейсами и программами JavaScript, работающими в браузере, но также используется и во многих других местах. Его домашняя страница, json.org, предоставляет четкое и краткое определение стандарта.
С пакетом json легко и быстро читать и записывать данные JSON из ваших программ Go.
Кодирование
Для кодирования данных в JSON используется функция Marshal.
func Marshal(v interface<>) ([]byte, error)
Задав структуру данных Go, Message,
type Message struct
и экземпляр сообщения
m := Message
мы можем получить JSON-кодированную версию m, используя json.Marshal:
b, err := json.Marshal(m)
Если все хорошо, err будет nil, а b будет []byte, содержащим JSON данные:
b == []byte(``)
Будут закодированы только структуры данных, которые могут быть представлены валидным JSON:
- Объекты JSON поддерживают только строки в качестве ключей; чтобы кодировать Go тип map он должен иметь вид map[string]T (где T — любой тип Go, поддерживаемый пакетом json).
- Channel, complex и func типы не могут быть закодированы.
- Циклические структуры данных не поддерживаются; они приведут к попаданию Marshal в бесконечный цикл.
- Указатели будут закодированы как значения, на которые они указывают (или ‘null’, если указатель равен nil).
Пакет json обращается только к экспортированным полям struct типов (те, которые начинаются с заглавной буквы). Поэтому в выводе JSON будут присутствовать только экспортированные поля структуры.
Декодирование
Для декодирования JSON данных используем функцию Unmarshal.
func Unmarshal(data []byte, v interface<>) error
Сначала нужно создать место, где будут храниться декодированные данные
var m Message
и вызвать json.Unmarshal, передав ему []byte JSON данных и указатель на m
err := json.Unmarshal(b, &m)
Если b содержит допустимый JSON, который соответствует m, после вызова err будет nil и данные из b будут сохранены в структуре m, как если бы это было сделано с помощью присваивания, подобного следующему:
m = Message
Как Unmarshal идентифицирует поля для хранения декодированных данных? Для заданного ключа JSON «Foo» Unmarshal просматривает поля структуры назначения, чтобы найти (в порядке предпочтения):
- Экспортированное поле с тегом «Foo»
- Экспортированное поле с именем «Foo»
- Экспортированное поле с именем «FOO» или «FoO» или другое нечувствительное к регистру совпадение «Foo»
Что происходит, когда структура данных JSON не совсем соответствует типу Go?
b := []byte(``) var m Message err := json.Unmarshal(b, &m)
Unmarshal будет декодировать только те поля, которые он может найти в типе назначения. В этом случае будет заполнено только поле Name в m, а поле Food будет игнорироваться. Это поведение особенно полезно, когда вы хотите выбрать только несколько определенных полей из большого JSON-объекта. Это также означает, что Unmarshal не затронет любые неэкспортированные поля в структуре назначения.
Но что, если вы заранее не знаете структуру данных JSON?
Универсальный JSON с interface<>
Тип interface<> (пустой интерфейс) описывает интерфейс с нулевыми методами. Каждый тип Go реализует как минимум ноль методов и поэтому удовлетворяет пустому интерфейсу.
Пустой интерфейс служит общим типом контейнера:
var i interface<> i = "a string" i = 2011 i = 2.777
Утверждение типа обращается к подлежащему конкретному типу:
r := i.(float64) fmt.Println("the circle's area", math.Pi*r*r)
Или, если базовый тип неизвестен, переключатель типа определяет тип:
switch v := i.(type) < case int: fmt.Println("twice i is", v*2) case float64: fmt.Println("the reciprocal of i is", 1/v) case string: h := len(v) / 2 fmt.Println("i swapped by halves is", v[h:]+v[:h]) default: // i ни один из типов выше >
Пакет json использует значения map[string]interface<> и []interface<> для хранения произвольных объектов и массивов JSON; он с радостью разархивирует любой допустимый большой бинарный объект JSON (blob) в простое значение interface<>. Конкретные типы Go по умолчанию:
- bool для логических выражений JSON
- float64 для JSON чисел
- string для JSON строк
- nil для JSON null
Декодирование произвольных данных
Рассмотрим JSON данные, хранящиеся в переменной b:
b := []byte(``)
Не зная структуры этих данных, мы можем декодировать их в значение interface<> с помощью Unmarshal:
var f interface<> err := json.Unmarshal(b, &f)
В этот момент значением Go в f будет карта, ключи которой являются строками, а сами значения хранятся как пустые значения интерфейса:
f = map[string]interface<>< "Name": "Wednesday", "Age": 6, "Parents": []interface<>< "Gomez", "Morticia", >, >
Чтобы получить доступ к этим данным, мы можем использовать утверждение типа для доступа к подлежащему map[string]interface<>:
m := f.(map[string]interface<>)
Затем мы можем перебрать карту с помощью оператора range и использовать переключатель типа для доступа к ее значениям в качестве их конкретных типов:
for k, v := range m < switch vv := v.(type) < case string: fmt.Println(k, "is string", vv) case float64: fmt.Println(k, "is float64", 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") > >
Таким образом, вы можете работать с неизвестными JSON данными, сохраняя при этом преимущества безопасности типов.
Ссылочные типы
Определим тип Go, который будет содержать данные из предыдущего примера:
type FamilyMember struct < Name string Age int Parents []string >var m FamilyMember err := json.Unmarshal(b, &m)
Демонстрация этих данных в значение FamilyMember работает, как и ожидалось, но если мы посмотрим внимательнее, то увидим, что произошла замечательная вещь. С помощью оператора var мы выделили структуру FamilyMember, а затем предоставили указатель на это значение для Unmarshal, но в то время поле Parents было нулевым значением среза. Чтобы заполнить поле Parents, Unmarshal выделил новый срез за кулисами. Это типично для того, как Unmarshal работает с поддерживаемыми ссылочными типами (указатели, срезы и карты).
Рассмотрим конвертирование в эту структуру данных:
type Foo struct
Если бы в объекте JSON было поле Bar, Unmarshal выделил бы новый Bar и заполнил его. Если нет, Bar будет оставлен как нулевой указатель.
Из этого вытекает полезный шаблон: если у вас есть приложение, которое получает несколько различных типов сообщений, вы можете определить структуру «получателя», например:
type IncomingMessage struct
и отправляющая сторона может заполнить поле Cmd и/или поле Msg объекта JSON верхнего уровня, в зависимости от типа сообщения, которое они хотят передать. Unmarshal при декодировании JSON в структуру IncomingMessage будет выделять только структуры данных, присутствующие в JSON данных. Чтобы узнать, какие сообщения обрабатывать, программисту просто нужно проверить, что Cmd или Msg не ноль.
Потоковые кодировщики и декодеры
Пакет json предоставляет типы Decoder и Encoder для поддержки обычной операции чтения и записи потоков данных JSON. Функции NewDecoder и NewEncoder оборачивают типы интерфейсов io.Reader и io.Writer.
func NewDecoder(r io.Reader) *Decoder func NewEncoder(w io.Writer) *Encoder
Вот пример программы, которая читает серию объектов JSON из стандартного ввода, удаляет все, кроме поля Name, из каждого объекта, а затем записывает объекты в стандартный вывод:
package main import ( "encoding/json" "log" "os" ) func main() < dec := json.NewDecoder(os.Stdin) enc := json.NewEncoder(os.Stdout) for < var v map[string]interface<>if err := dec.Decode(&v); err != nil < log.Println(err) return >for k := range v < if k != "Name" < delete(v, k) >> if err := enc.Encode(&v); err != nil < log.Println(err) >> >
Из-за повсеместного распространения программ чтения и записи эти типы кодировщиков и декодеров могут использоваться в широком диапазоне сценариев, таких как чтение и запись в соединения HTTP, веб-сокеты или файлы.
Пример использования тегов в структуре
Использование тегов в структуре кодируемой в JSON позволяет получить названия полей в результирующем JSON, отличающиеся от названия полей в структуре. В следующем примере в результирующем JSON поле BrandID будет выглядеть как brand_id:
package main import ( "encoding/json" "fmt" ) type Item struct < ID uint `json:"id"` Title string `json:"title"` BrandID uint `json:"brand_id"` >func main() < item := Itemjitem, err := json.Marshal(item) if err != nil < fmt.Println(err.Error()) return >fmt.Println(string(jitem)) >
- Основы Go: структуры (struct)
- Основы Go: карты (словари)
- Основы Go: switch с типами