r.ParseForm field order

So I would like to preserve the order of the post fields.
But now using the http ParseForm function it will put the fields into a map which will have a different order each time.

The original query : a=1&b=2&c=3 can become b=2&c=3&a=1 or any random order.

Since I hash the query and compare it with the hash of the user his query the hash on my side changes all the time since the order of the fields are random.

Code:

func parsePostQuery(r *http.Request, hashQuery string) bool {
    urlquery := url.Values{}

    r.ParseForm()
    
    for k, p := range r.Form {
        urlquery.Set(k, p[0])
    }

    //some psuedo code
    if hashQuery == hash(urlquery.Encode()){
        return true
    }
    
    return false
}

How can I parse the fields that are submitted by the user and keep the field order of the user?

Sidenote: I do not know the field names in advance.

In the same area as other answers, you will need the clients to calculate their hash by alphabetizing all parameters before hashing. The code you've supplied should work fine; values.Encode() will sort the values by key on it's own:

> Encode encodes the values into “URL encoded” form ("bar=baz&foo=quux") sorted by key.

There's no way to preserve the ordering of the client; in fact, what you receive may not even be how it was ordered on the client end. However unlikely, there's no guarantee that intermediate processes won't change things.

tl;dr: You can't implicitly. The underlying data structure is a map, for which the order is not guaranteed. You need to take additional steps.

However Go maps in action shows an easy way to access the map in a sorted way. You create a slice of the keys, sort that slice and access the map value by iterating over the keys in the sorted slice.

For your example, it would look something like this

package main

import (
	"crypto/md5"
	"fmt"
	"io"
	"sort"
)

func main() {
	// Which is the same structure as url.Values()
	var m map[string][]string = make(map[string][]string)
	m["c"] = []string{"19.95"}
	m["b"] = []string{"foo", "bar", "baz"}
	m["a"] = []string{"1"}

	// Note that playground is deterministic, so the order should be preserved there
	// However, you can not rely on that in the real world
	fmt.Println("Unsorted")
	for k, v := range m {
		fmt.Println("Key:", k, "Value:", v)
	}

	var keys []string
	for k := range m {
		keys = append(keys, k)
	}
	sort.Strings(keys)

	hash := md5.New()
	fmt.Println("\nSorted")
	for _, k := range keys {

		fmt.Println("Key:", k, "Value:", m[k])

		// Add Key/Value pair to hash
		fmt.Printf("\tAdding KEY '%s' to hash\n", k)
		io.WriteString(hash, k)
		for _, v := range m[k] {
			fmt.Printf("\tAdding VALUE '%s' to hash\n", v)
			io.WriteString(hash, v)
		}
	}
	fmt.Printf("\nHash: %x", hash.Sum(nil))
}

<kbd>Run above code on Playground</kbd>

You can read the request body and check for the form parameters. They will appear in the same order as in the request(hope your client application is also aware of this order preserving)

You can create a reader for reading the request body. A sample code looks like

body, err := ioutil.ReadAll(r.Body)
if err != nil {
	fmt.Println("Reading Error ")
	return 
}
fmt.Println("Req Body  :  ", string(body))

Note : Be aware of the content type