Gibt es ein Paket für Marschall in die und aus der x-www-form-urlencoding in golang

Ich gerade gefunden https://github.com/ajg/form das ist genau das, was ich suchte. Es ist auch https://github.com/gorilla/schema ausschließlich für die Decodierung und https://github.com/google/go-querystring ausschließlich für die Codierung.

Die "github.com/pasztorpisti/qs" - Paket können auch Marschall/unmarshal Strukturen zu/von query-strings und POST-ed-Formen.

Beispiel:

package main

import "fmt"
import "github.com/pasztorpisti/qs"

type Query struct {
    Search     string
    Page       int
    PageSize   int
    Categories []string `qs:"category"`
}

func main() {
    queryStr, err := qs.Marshal(&Query{
        Search:     "my search",
        Page:       2,
        PageSize:   50,
        Categories: []string{"c1", "c2"},
    })
    fmt.Println("Marshal-Result:", queryStr, err)

    var q Query
    err = qs.Unmarshal(&q, queryStr)
    fmt.Println("Unmarshal-Result:", q, err)

    //Output:
    //Marshal-Result: category=c1&category=c2&page=2&page_size=50&search=my+search <nil>
    //Unmarshal-Result: {my search 2 50 [c1 c2]} <nil>
}

Möglich Verkaufsargumente von diesem Paket:

• Struct Feldnamen erscheinen automatisch als snake_case im query-string. Sie müssen nicht fügen Sie qs:"field_name" auf die struct-Feld-tag für diese. Dieses Verhalten kann geändert werden.
• Modulare Architektur, die es einem ermöglicht, Sie zu ersetzen marshalers und unmarshalers auch für den builtin-Typen (wie bool, []byte) und hinzufügen von Unterstützung für neue Arten verändern, ohne die Art selbst (z.B.: hinzufügen von Rangier-und/oder unmarshaling für time.Time). Hier ist ein Beispiel.
• Können Sie die req option, um die struct-Feld-tag, um zu machen dem Feld, während unmarshaling. Beachten Sie, dass dies eher Validierung als unmarshaling und golang-Bibliotheken gehen in der Regel für die Trennung zwischen den beiden, aber ich fand diese option sehr nützlich, weil es erforderlich ist, oft ist es einfach und liest sich gut. Für diejenigen, die vermeiden wollen, dass req und tun diese überprüfung, getrennt nach unmarshaling: es ist ein nil - tag", dass ist so ziemlich das gleiche wie die Standard - opt (das steht für "optional"), außer, dass es nicht initialisieren null-Zeiger, wenn die vorgegebenen Felder nicht in deren Marshalling rückgängig gemacht wurde query-string. Auf diese Weise validator-code erkennen kann, die fehlenden Felder von der Suche nach der null-Zeiger nach unmarshaling.

• Den qs Paket kann sagen, ob ein komplexer Typ (z.B.: Ihre Struktur), ist marshalable, bevor Sie tatsächlich Marshalling eine Instanz dieses Typs. Die meisten Marshaller-Pakete können nicht dies tun, auch nach Marshalling eine Instanz des angegebenen Typs! Die meisten marshalers untersuchen, komplexe Typen zu Fuß das Objekt gemarshallt und die überprüfung der Arten nur für die besuchten sub-Objekte. Dies bedeutet, wenn das komplexe Objekt enthält einen container (Zeiger, anzeigen oder Scheibe), die leer ist, dann wird der Elementtyp des Containers gar nicht untersucht. Im Vertrag qs geht die Struktur des Komplexes Objekt (anstelle des Objekts selbst) während der Erstellung der Marshaller für den Typ, so es scheitert, wo es zu scheitern. Betrachten Sie den folgenden code in die standard - "encoding/json" Paket erfolgreich Streckenposten ein Objekt, dessen Typ enthält eine nicht-marshalable Typ:

  package main
  
  import (
      "encoding/json"
      "fmt"
      "reflect"
  
      "github.com/pasztorpisti/qs"
  )
  
  type NonMarshalable func()
  
  func jsonEmptyMap() {
      //Since the container is empty "encoding/json" doesn't examine the type
      //of its items. This results in an unexpected success.
      var m = map[string]NonMarshalable{}
      j, err := json.Marshal(m)
      fmt.Println(string(j), err)
      //Output:
      //{} <nil>
  }
  
  func jsonNonEmptyMap() {
      var m = map[string]NonMarshalable{
          "f": func() {},
      }
      j, err := json.Marshal(m)
      fmt.Println(string(j), err)
      //Output:
      // json: unsupported type: main.NonMarshalable
  }
  
  func qsEmptyMap() {
      //qs.Marshal fails even if the container is empty because the first step
      //of qs.Marshal fails: It can't create the marshaler object for this type.
      var m = map[string]NonMarshalable{}
      s, err := qs.Marshal(m)
      fmt.Println(s, err)
      //Output:
      // error getting marshaler for map value type main.NonMarshalable :: unhandled type: main.NonMarshalable
  }
  
  func qsTypeCheck() {
      //You don't even have to try to marshal an object to find out whether its
      //type is marshal-friendly. You can check the type directly. By doing this
      //at startup (e.g.: from init functions) you can avoid delaying runtime
      //errors.
      t := reflect.TypeOf((map[string]NonMarshalable)(nil))
      err := qs.CheckMarshalType(t)
      fmt.Println(err)
      //Output:
      //error getting marshaler for map value type main.NonMarshalable :: unhandled type: main.NonMarshalable
  }
  
  func main() {
      jsonEmptyMap()
      jsonNonEmptyMap()
      qsEmptyMap()
      qsTypeCheck()
  }