How to terminate request from a sub function in golang

I want to return and terminate request that comes in checkSomeThing function. But the problem is the process continues and doesn't return response unless reaches the end of the main(). here's my code:

package main

import (
	"fmt"
	"net/http"
)

func main() {
	http.HandleFunc("/", handler)
	// ...

	http.ListenAndServe(":8080", nil)
}

func handler(w http.ResponseWriter, r *http.Request) {
	checkSomeThing(w, r)

	http.Error(w, "Operation completed!", http.StatusOK)
	fmt.Println("End of Handler.")
}

func checkSomeThing(w http.ResponseWriter, r *http.Request) {

	http.Error(w, "Bad Request!", http.StatusBadRequest)
	return
}

After run the program here's the output:

// Output:    
< HTTP/1.1 400 Bad Request
< Content-Type: text/plain; charset=utf-8
< X-Content-Type-Options: nosniff
< Date: Sun, 12 Sep 2021 12:38:49 GMT
< Content-Length: 34
< 
Bad Request!
Operation completed!

Always try to handle errors at the API level - bubbling errors up the call-stack. There are, however, cases where this is not possible - maybe your handler is one of many in a middleware chain of handlers, and you don't want those other layers to complete. So...

If you want to immediately abort a request from your handler, the standard library supports panic & recovery.

From the http.Handler docs:

> If ServeHTTP panics, the server (the caller of ServeHTTP) assumes that
> the effect of the panic was isolated to the active request. It
> recovers the panic, logs a stack trace to the server error log, and
> either closes the network connection or sends an HTTP/2 RST_STREAM,
> depending on the HTTP protocol. To abort a handler so the client sees
> an interrupted response but the server doesn't log an error, panic
> with the value ErrAbortHandler.
>

and http.ErrAbortHandler:

> ... is a sentinel panic value to abort a handler. While
> any panic from ServeHTTP aborts the response to the client, panicking
> with ErrAbortHandler also suppresses logging of a stack trace to the
> server's error log.

so to do this in your handler:

func checkSomeThing(w http.ResponseWriter, r *http.Request) {
	http.Error(w, "Bad Request!", http.StatusBadRequest)
	panic(http.ErrAbortHandler) // terminate request (and any more handlers in the chain)
}

There is a catch...

Writes to client will be buffered - and panicing will likely cause these buffered writes to be lost.

To forcibly flush the buffer:

if f, ok := w.(http.Flusher); ok {
    f.Flush()
}

panic(http.ErrAbortHandler)

or you can add your own panic recovery. Just ensure, in the recovery, to "re-raise" any panics - if they were not cause by you - so they won't be lost:

func handler(w http.ResponseWriter, r *http.Request) {

    defer func() {
	    r := recover()

	    switch r {

	    case nil: // no panic

        // (2) goes here...
	    case http.ErrAbortHandler:
		    log.Println("Recovered in handler")

        // (2) or here...
	    default:
		    panic(r) // re-raise any unexpected panic
	    }
    }()
	checkSomeThing(w, r)  // (1) panic here ...

    // (3) ... and this never runs
}

in the above panic-recovery code, http.ServeHTTP will never know there was a panic - and flush the request buffers naturally.

According to the http.Error documentation
> Error replies to the request with the specified error message and HTTP code.
It does not otherwise end the request; the caller should ensure no further writes are done to w. The error message should be plain text.

So after executing the checkSomeThing function it just writing the error string in responsewriter and continuing processing further operations.

A working version of your code is given below:

package main

import (
	"errors"
	"fmt"
	"net/http"
)

func main() {
	http.HandleFunc("/", handler)
	// ...

	http.ListenAndServe(":8080", nil)
}

func handler(w http.ResponseWriter, r *http.Request){
	err := checkSomeThing(w, r)
	if err != nil {
		return
	}

	http.Error(w, "Operation completed!", http.StatusOK)
	fmt.Println("End of Handler.")
	return
}

func checkSomeThing(w http.ResponseWriter, r *http.Request) error{

	http.Error(w, "Bad Request!", http.StatusBadRequest)
	return errors.New("bad request")
}