Calculator Backend-API In Go

Back again with another mini-project, this time with a calculator backend API tool written in Go!

I recently wrapped up a project to build an HTTP JSON API for a stateless calculator, and let me tell you—it was a lot more fun (and a little more challenging) than I expected. On the surface, it might sound simple: “Hey, it’s just a calculator, right?” But once you dive in, you start uncovering all the nitty-gritty details that make an API truly production-ready.

So, let me share the process, the lessons learned, and what I’d tweak if I had to do it again.

~ Souce code: Found here

A Stateless Calculator API

The mission was straightforward: build an API for a calculator that doesn’t store any data—no databases, no in-memory caching. Every calculation happens in isolation. Stateless. Clean. Simple. The API follows an OpenAPI specification, which lays out all the endpoints and expected behaviors.

What's next?

Input Validation

One of the first lessons I learned was the importance of input validation. You can’t trust users, even with something as basic as math. For example:

What happens if someone sends in a non-number? Boom.
How about division by zero? Double boom.

To handle this, I made sure every input was sanitized and validated before the API even thought about processing it. If something was off, the user got a helpful, friendly error message like:

{
  "error": "Division by zero is not allowed. Please provide a valid denominator."
}

Nobody likes cryptic “500 Server Error” messages.

Logging for Debugging

You know that saying, “Logs are your best friend”? It’s true. I implemented structured logging using a Go golang.org/x/exp/slog package, and it saved me so much time. Every request was logged with details like:

• The request path
• The user’s IP address
• The status code
• Any errors that popped up

Here’s a snippet of how I set it up for text logs:

logger := slog.New(slog.NewTextHandler(os.Stdout, nil))

Or for JSON logs (which are great for integrating with monitoring tools):

logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))

Having those logs handy made debugging a breeze when something didn’t work as expected.

CORS: An Unexpected Hero

I hadn’t initially planned for this API to be used in a browser-based app, but as the project evolved, it became clear that CORS (Cross-Origin Resource Sharing) was necessary.

Using the github.com/rs/cors package, I quickly added the required headers to allow browser-based clients to interact with the API.

{
  "error": "Division by zero is not allowed. Please provide a valid denominator."
}

---

My main packages

1) net/http: Go’s standard library for setting up the HTTP server and routing requests.
2) encoding/json: To handle JSON encoding/decoding for requests and responses.
3) golang.org/x/exp/slog: For logging every request in either text or JSON format.
4) github.com/rs/cors: To handle cross-origin requests for web integrations.

What about the calculation logic?

Well I made some handlers for these calculations, they are pretty basic in nature and primarily focus on the core functionality of calculations (Addition, Subtraction, Division & Multiplication).

logger := slog.New(slog.NewTextHandler(os.Stdout, nil))

Aside from this, handling my HTTP requests with the famous net/http package was straightforward and there are many examples out there of doing this in different ways. My case was very simple and I just needed to serve up some HTTP, handling the response writer and the request.

logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))

Here are some use-case examples:

c := cors.New(cors.Options{
        AllowedOrigins:   []string{"*"},
        AllowedMethods:   []string{"GET", "POST", "OPTIONS"},
        AllowedHeaders:   []string{"Content-Type"},
        AllowCredentials: true,
    })

Requests:

//handlers.go

func AddHandler(logger *slog.Logger) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        handleOperation(logger, w, r, func(a, b float64) float64 { return a + b })
    }
}

func SubtractHandler(logger *slog.Logger) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        handleOperation(logger, w, r, func(a, b float64) float64 { return a - b })
    }
}

func MultiplyHandler(logger *slog.Logger) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        handleOperation(logger, w, r, func(a, b float64) float64 { return a * b })
    }
}

func DivideHandler(logger *slog.Logger) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        handleOperation(logger, w, r, func(a, b float64) float64 {
            if b == 0 {
                panic("division by zero")
            }
            return a / b
        })
    }
}

Conclusion

Yep! That's pretty much it! It was a quick and fun mini-project that I enjoyed! Feel free to give it a try and improve & enhance whichever way you'd like to.

Until next time, cheers! ? ?

The above is the detailed content of Calculator Backend-API In Go. For more information, please follow other related articles on the PHP Chinese website!