Understanding http server implementation

[thorn lichen]

How is this more efficient

type PlayerServer struct {
    store PlayerStore
    http.Handler
}

func NewPlayerServer(store PlayerStore) *PlayerServer {
    p := new(PlayerServer)

    p.store = store

    router := http.NewServeMux()
    router.Handle("/league", http.HandlerFunc(p.leagueHandler))
    router.Handle("/players/", http.HandlerFunc(p.playersHandler))

    p.Handler = router

    return p
}```
than:
```go
//server.go
func (p *PlayerServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {

    router := http.NewServeMux()
    router.Handle("/league", http.HandlerFunc(p.leagueHandler))
    router.Handle("/players/", http.HandlerFunc(p.playersHandler))

    router.ServeHTTP(w, r)
}

[ancient marsh]

This is more efficient because you don't have to reallocate a whole bunch of objects inside the muxer on every request

instead this is cached

Using a switch (and or ifs and HasPrefix) would be the most efficient solution here

[thorn lichen]

so i understand correctly, then a instance of the routing function that is running in the background, and catches all requests which are called on specified paths?

[tardy tree]

I can't imagine the performance is meaningfully different

[ancient marsh]

there is nothing running the background.

type ServeMux struct {
    mu    sync.RWMutex
    m     map[string]muxEntry
    es    []muxEntry // slice of entries sorted from longest to shortest.
    hosts bool       // whether any patterns contain hostnames
}

Recreating it will reallocate of the map and the slice on every request

[ancient marsh]

this is more garbage, it's not insignificant

Also IMO, the first solution is more readable,
it uses less memory and is faster, why would you not use it ?

[tardy tree]

yes, those are good reasons

but performance doesn't really make a difference here. it's a bonus

[ancient marsh]

it's probably like ~1µs per request (GC accounted)