code review 2985042: http: Add EncodeQuery, a handy helper function for cons...

src/pkg/http/url.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Parse URLs (actually URIs, but that seems overly pedantic).
 // RFC 3986
 
 package http
 
 import (
-        "fmt"
         "os"
         "strconv"
         "strings"
 )
 
 // URLError reports an error and the operation and URL that caused it.
 type URLError struct {
         Op    string
         URL   string
         Error os.Error
@@ skipping 489 matching lines @@
         if url.RawQuery != "" {
                 result += "?" + url.RawQuery
         }
         if url.Fragment != "" {
                 result += "#" + urlEscape(url.Fragment, encodeFragment)
         }
         return result
 }
 
 // EncodeQuery encodes the query represented as a multimap.
-// Each key's value is encoded as a string using fmt.Sprint, then URL-encoded.
-func EncodeQuery(m map[string][]interface{}) string {

[rsc, 2010/11/24 01:22:38]

I'm not okay with this.  Why interface{}?  What values are okay?  Etc.

I think this should be map[string]string to match PostForm.
I know that's not the right long term type, but when we switch
PostForm we can switch this one to (to map[string][]string).

[dsymonds, 2010/11/24 01:54:03]

It's interface{} in the same way that fmt.Print, etc. take interface{}. Any
value that fmt can render should be usable here, though it will usually be
primitive types.

I'm trying to make it easier to build URLs, and plenty of URLs have query
parameter values that are semantically strings, ints, etc. I could change the
interface{} to string, but that just shifts the fmt.Sprint burden back to all
the callers, which seems silly given that this is mean to be a convenience
function.

+func EncodeQuery(m map[string][]string) string {
         parts := make([]string, 0, len(m)) // will be large enough for most uses
         for k, vs := range m {
                 prefix := URLEscape(k) + "="
                 for _, v := range vs {
-                        parts = append(parts, prefix+URLEscape(fmt.Sprint(v)))
+                        parts = append(parts, prefix+URLEscape(v))
                 }
         }
         return strings.Join(parts, "&")
 }