Register multiple routes using range for loop slices/map

by

So the problem was that you actually used this code:

for _, path := range paths {
    http.HandleFunc(path, func(w http.ResponseWriter, req *http.Request) {
        fmt.Fprintf(w, path)
    })
}

You used a function literal, a closure as the handler function to register. Closures capture the context they refer to, in your case the path loop variable.

But there is only a single path loop variable, its value is overwritten in each iterations of the loop, and its final value will be the last path. Relevant section from the spec: For statements with range clause:

The iteration variables may be declared by the “range” clause using a form of short variable declaration (:=). In this case their types are set to the types of the respective iteration values and their scope is the block of the “for” statement; they are re-used in each iteration. If the iteration variables are declared outside the “for” statement, after execution their values will be those of the last iteration.

Once the for loop is finished, and you start making requests, each registered handler function will send back the value of this single path variable. That’s why you see the last path returned for all requested paths.

Solution is easy: create a new variable in each iteration, and use that in the handler function:

for _, path := range paths {
    path2 := path
    http.HandleFunc(path2, func(w http.ResponseWriter, req *http.Request) {
        fmt.Fprintf(w, path2)
    })
}

What happens here is that we use a short variable declaration in each iteration to create a new variable, initialized with the value of the path loop variable. And the handler function we register will refer to this new variable, unique only to one registered path.

Another, equally good solution is to use an anonymous function with a parameter to pass the path string. Might be harder to understand though:

for _, path := range paths {
    func(p string) {
        http.HandleFunc(p, func(w http.ResponseWriter, req *http.Request) {
            fmt.Fprintf(w, p)
        })
    }(path)
}

What happens here is that we call an anonymous function, passing the current path value to it, and it registers the handler function, using only the parameter of this anonymous function (and there’s a new, distinct local variable allocated for each call).

More Related Contents:

  1. Captured Closure (for Loop Variable) in Go
  2. Using Pointers in a for loop
  3. How many times does a (for) loop iterate? [closed]
  4. Nested loops array in Go not behaving like other languages' array
  5. Difference between pre-increment and post-increment in a loop?
  6. Is it a bad practice to use break in a for loop? [closed]
  7. Change values while iterating
  8. Concatenate two slices in Go
  9. What does it mean to pass in a vector into a `for` loop versus a reference to a vector?
  10. How to get memory size of variable in Go?
  11. Can I concurrently write different slice elements
  12. My object is not updated even if I use the pointer to a type to update it
  13. Why does Go handle closures differently in goroutines?
  14. How to use setInterval function within for loop
  15. What is a concise way to create a 2D slice in Go?
  16. Does go garbage collect parts of slices?
  17. Closures behaving differently in for and foreach loops
  18. range over interface{} which stores a slice
  19. Can I construct a slice of a generic type with different type parameters?
  20. why slice values can sometimes go stale but never map values?
  21. How do I reverse a slice in go?
  22. Batch script for loop won’t set variable
  23. Getting a slice of keys from a map
  24. Print a triangular pattern of asterisks
  25. Google Apps Script – Label Email Based On Email Body [Optimize Code]
  26. How to delete an element from a Slice in Golang
  27. Convert slice of string to slice of pointer to string
  28. How can I do a mutable borrow in a for loop?
  29. Big O of append in Golang
  30. Slice chunking in Go

Leave a Comment