Hey there! Let's tackle how to ensure your JSON fields aren't empty when converting to a struct, using your Range struct as an example. I'll focus on Go first (since it’s super common for this kind of work) and also cover general patterns you can apply to other languages.

Go’s standard encoding/json package doesn’t natively enforce required fields, so we’ll combine unmarshaling with validation. Let’s start with a basic Range struct:

type Range struct {
    Start int `json:"start"`
    End   int `json:"end"`
}

Option 1: Manual Validation (Simple & No Dependencies) #

After unmarshaling your JSON into the struct, add a custom validation method to check for empty or invalid values:

import "errors"

func (r *Range) Validate() error {
    // Adjust this logic based on what "empty" means for your use case
    if r.Start == 0 && r.End == 0 {
        return errors.New("both `start` and `end` fields are required and cannot be empty")
    }
    if r.Start >= r.End {
        return errors.New("`start` must be less than `end`")
    }
    return nil
}

Use it like this after unmarshaling:

var r Range
err := json.Unmarshal(jsonData, &r)
if err != nil {
    // Handle JSON parsing errors
}
if err := r.Validate(); err != nil {
    // Handle empty/invalid field errors
}

Option 2: Use a Validation Library (Cleaner for Complex Cases) #

Libraries like go-playground/validator let you enforce rules directly via struct tags. First, add validation tags to your struct:

import "github.com/go-playground/validator/v10"

type Range struct {
    Start int `json:"start" validate:"required,ltfield=End"`
    End   int `json:"end" validate:"required"`
}

Then set up the validator and run checks after unmarshaling:

validate := validator.New()
var r Range
err := json.Unmarshal(jsonData, &r)
if err != nil {
    // Handle parsing errors
}
if err := validate.Struct(r); err != nil {
    // Handle validation failures (e.g., missing fields, invalid range)
}

Option 3: Use Pointer Fields to Detect Missing Values #

If zero values (like 0 for int) are valid but you need to distinguish between "not provided" and "set to zero", use pointers:

type Range struct {
    Start *int `json:"start"`
    End   *int `json:"end"`
}

Then validate that the pointers aren’t nil:

func (r *Range) Validate() error {
    if r.Start == nil || r.End == nil {
        return errors.New("`start` and `end` fields must be provided")
    }
    if *r.Start >= *r.End {
        return errors.New("`start` must be less than `end`")
    }
    return nil
}

The core idea is the same across languages: combine deserialization with explicit validation:

• Java: Use Jackson’s @JsonProperty(required = true) and Hibernate Validator’s @NotNull annotations to mark fields as required.
• Python: Use Pydantic models with Field(..., required=True) to enforce non-empty fields at runtime.
• TypeScript: Define interfaces with required fields, then use a schema validator like Zod to validate incoming JSON.

Pro Tip: Always clarify what "non-empty" means for each field. For numeric types, does 0 count as empty? For strings, is an empty string invalid? Adjust your validation logic to match your business rules.

内容的提问来源于stack exchange，提问作者iFreezy