---
title: "URLs in Go kodieren"
date: 2020-03-04
draft: false
tags: ["programmieren","golang","go","urlencode","net/url"]
---
Das Paket net/url ist ein nützliches Paket um in Go mit URLs, Pfaden und Parametern umzugehen. Man kann Parameter in ein URL kodieren lassen oder Sonderzeichen automatisch umwandeln.
```go
package main

import (
	"fmt"
	"log"
	"net/url"
)

func main() {
	//set the URL
	baseUrl, err := url.Parse("https://www.google.com/search")
	if err != nil {
		log.Fatalln(err)
	}
	fmt.Printf("URL: %s\n", baseUrl)
	fmt.Println(baseUrl.Host)
	fmt.Println(baseUrl.Path)
}
```
[Code ausprobieren](https://play.golang.org/p/_W7yv9HWHBD)

Wie man wird die URL mit url.Parse in Ihre Bestandteile zerlegt und in einer Struktur gespeichert.
Neben den oben stehenden Feldern gibt es auch noch weitere (Auszug aus der Dokumentation):
```go
type URL struct {
    Scheme     string
    Opaque     string    // encoded opaque data
    User       Userinfo // username and password information
    Host       string    // host or host:port
    Path       string    // path (relative paths may omit leading slash)
    RawPath    string    // encoded path hint (see EscapedPath method); added in Go 1.5
    ForceQuery bool      // append a query ('?') even if RawQuery is empty; added in Go 1.7
    RawQuery   string    // encoded query values, without '?'
    Fragment   string    // fragment for references, without '#'
}
```

## Mit URL Parametern arbeiten

Net/url definiert einen Typ Values als Schlüssel-Wertepaar und bietet einige Methoden an um Damit zu arbeiten. 
```go
package main

import (
	"fmt"
	"log"
	"net/url"
)

func main() {
	//parameters
	p := url.Values{}
	p.Add("q", "cat")
	p.Add("s", "something else")

	fmt.Println(p)
	fmt.Println(p.Encode())

	//this also works backwards
	q, err := url.ParseQuery("q=cat&s=something+else")

	if err != nil {
		log.Fatalln(err)
	}

	fmt.Println(q)

	//delete a key
	p.Del("q")
	fmt.Println(p)

}
```
[Code ausprobieren](https://play.golang.org/p/BzuUpv3bIaO)

## URL Pfade mit Sonderzeichen kodieren

Beim Erstellen der URL mit der parse Methode wird praktischweise auch ein eine kodierte Fassung des URL Pfades angelegt, so dass Sonderzeichen kein Problem sind:

```go
package main

import (
	"fmt"
	"log"
	"net/url"
)

func main() {
	//set the URL
	baseUrl, err := url.Parse("https://www.google.com/search")
	if err != nil {
		log.Fatalln(err)
	}

	//path encoding
	baseUrl.Path += "/a path with spaces and special chars!ü@"
	fmt.Printf("URL: %s\n", baseUrl)

	fmt.Println(baseUrl.Host)
	fmt.Println(baseUrl.Path)
	fmt.Println(baseUrl.EscapedPath())

	//lets try this backwards
	newUrl, err := url.ParseRequestURI("https://www.google.com/search/a%20path%20with%20spaces%20and%20special%20chars%21%C3%BC@")
	if err != nil {
		log.Fatalln(err)
	}
	fmt.Println(newUrl.Host)
	fmt.Println(newUrl.Path)
	fmt.Println(baseUrl.EscapedPath())
}

```
Das Paket hat noch mehr praktische Funktion. Die Doku findet Ihr unter: https://golang.org/pkg/net/