https://github.com/wneessen/niljson
🌀 A simple Go package for (un-)marshalling null-able JSON types
https://github.com/wneessen/niljson
go golang hacktoberfest json null-safety unmarshalling
Last synced: 10 months ago
JSON representation
🌀 A simple Go package for (un-)marshalling null-able JSON types
- Host: GitHub
- URL: https://github.com/wneessen/niljson
- Owner: wneessen
- License: mit
- Created: 2024-09-01T13:53:52.000Z (almost 2 years ago)
- Default Branch: main
- Last Pushed: 2024-12-18T08:23:42.000Z (over 1 year ago)
- Last Synced: 2024-12-18T09:29:22.057Z (over 1 year ago)
- Topics: go, golang, hacktoberfest, json, null-safety, unmarshalling
- Language: Go
- Homepage:
- Size: 199 KB
- Stars: 14
- Watchers: 1
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Funding: .github/FUNDING.yml
- License: LICENSE
- Security: SECURITY.md
Awesome Lists containing this project
README
# niljson - A simple Go package for (un-)marshalling null-able JSON types
[](https://pkg.go.dev/github.com/wneessen/niljson)
[](https://codecov.io/gh/wneessen/niljson)
[](https://goreportcard.com/report/github.com/wneessen/niljson)
[](https://api.reuse.software/info/github.com/wneessen/niljson)
niljson provides a simple and efficient way to handle nullable JSON fields during the (un-)marshalling process.
In JSON, it's common to encounter fields that can be `null`, but handling these fields in Go can be cumbersome,
especially when dealing with primitive types like `int`, `float64`, and `bool`. These types can all be either `0`
(as a value) or `null`. In Go you can always work with pointers, but these can lead to unhandled nil
pointer dereferences.
**niljson** addresses this challenge by offering a set of types that can seamlessly handle `null` values during
unmarshalling, allowing your Go applications to work with JSON data more naturally and with fewer boilerplate
checks for `nil` values.
### Key Features
- **Nullable Types**: Provides a range of nullable types (`NilString`, `NilInt`, `NilFloat`, `NilBool`, etc.) that
are easy to use and integrate into your existing Go structs.
- **JSON Unmarshalling Support**: Automatically handles the (un-)marshalling of JSON fields, converting `null` JSON
values to Go's `nil` or zero values, depending on the context.
- **Minimalistic and Lightweight**: Designed to be lightweight and unobtrusive, so it won't bloat your application
or introduce unnecessary dependencies (only relies on the Go standard library)
### Example Usage
```go
package main
import (
"encoding/json"
"fmt"
"os"
"github.com/wneessen/niljson"
)
type JSONType struct {
Bool niljson.NilBoolean `json:"bool"`
Float32 niljson.NilFloat32 `json:"float32,omitempty"`
Float64 niljson.NilFloat64 `json:"float64"`
Int niljson.NilInt `json:"int"`
Int64 niljson.NilInt64 `json:"int64"`
NullString niljson.NilString `json:"nil"`
String niljson.NilString `json:"string"`
}
func main() {
data := []byte(`{
"bytes": "Ynl0ZXM=",
"bool": true,
"float32": null,
"float64":0,
"int": 123,
"int64": 12345678901234,
"nilvalue": null,
"string":"test"
}`)
var example JSONType
var output string
if err := json.Unmarshal(data, &example); err != nil {
fmt.Println("failed to unmarshal JSON:", err)
os.Exit(1)
}
if example.Bool.NotNil() {
output += fmt.Sprintf("Bool is: %t, ", example.Bool.Value())
}
if example.Float32.IsNil() {
output += "Float 32 is nil, "
}
if example.Float64.NotNil() {
output += fmt.Sprintf("Float 64 is: %f, ", example.Float64.Value())
}
if example.String.NotNil() {
output += fmt.Sprintf("String is: %s", example.String.Value())
}
fmt.Println(output)
data, err := json.Marshal(&example)
if err != nil {
fmt.Printf("failed to marshal JSON: %s", err)
os.Exit(1)
}
fmt.Println(data)
}
```