Checking for Empty Integer in Golang

Question

I am designing an API where a user sends integer values and some operation is performed depending on the value sent. During the validation check that whether this value exists in the request, I have to equate it to 0 i.e. if intValue == 0.

However, I also have to perform a different operation in case the value is 0. Is there any way I can check that the integer does not exist or is empty without equating to 0?

Note: The requirements are set by the client and I cannot change them.

there's no such thing as an "empty integer". An integer always holds a value, regardless of 0, -1 or any other possible integral values — phuclv, Aug 11 '22 at 06:45
"I am designing an API" Then you have to design it so, that you can distinguish these two cases. What is your actual problem. E.g. checking whether a query parameter `intValue` is sent or not is trivial. — Volker, Aug 11 '22 at 07:24
It's more of coding the API than designing it. The client has set the requirements for the API and I am just coding it. — MRA1412, Aug 11 '22 at 07:28

score 1 · Accepted Answer · answered Aug 11 '22 at 07:37

When decoding JSON data into a struct, you can differentiate optional fields by declaring them as a pointer type.

For example:

type requestFormat struct {
    AlwaysPresent int
    OptionalValue *int
}

Now when the value is decoded, you can check if the value was supplied at all:

var data requestFormat

err := json.NewDecoder(request.Body).Decode(&data)
if err != nil { ... }

if data.OptionalValue == nil {
    // OptionalValue was not defined in the JSON data
} else {
    // OptionalValue was defined, but it still may have been 0
    val := *data.OptionalValue
}

score 0 · Answer 2 · answered Jul 24 '23 at 03:02

If considering compatibility, my suggestion is to use json.Number. This way, both int and string can be passed by the requesting side, and it can also determine whether the requesting side has passed the parameter.

For example:

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

type Param struct {
    Level json.Number `json:"level"`
}

func main() {
    var p Param

    if err := json.Unmarshal([]byte(`{"level": 30}`), &p); err != nil {
        log.Fatalf("Unmarshal err: %v", err)
    }

    if p.Level == "" {
        log.Fatal("level not pass")
    }

    level, err := p.Level.Int64()
    if err != nil {
        log.Fatalf("level is not integer")
    }

    fmt.Printf("level: %d", level)
}

score -2 · Answer 3 · answered Aug 11 '22 at 08:23

in production as @phuclv say

there's no such thing as an "empty integer"

inelegant implementation

check if it is required:

like

@Hymns For Disco use json.NewDecoder or validators

but it is being abandoned: Why required and optional is removed in Protocol Buffers 3

another way:

use map but struct,which can tell if a field exists

follow is a example

package main

import (
    "encoding/json"
    "io/ioutil"
    "net/http"
)

type Test struct {
    Name string
    Age  int
}

func testJson(w http.ResponseWriter, r *http.Request) {
    aMap := make(map[string]interface{})
    data, _ := ioutil.ReadAll(r.Body)
    json.Unmarshal(data, &aMap)
    test := Test{}
    json.Unmarshal(data, &test)
}
func main() {
    http.HandleFunc("/", testJson)    
    http.ListenAndServe(":8080", nil)
}

Checking for Empty Integer in Golang

3 Answers3

inelegant implementation

check if it is required:

another way: