net/url.Parse în Go

import "net/url"

func Parse(rawURL string) (*URL, error)

type URL struct {
    Scheme, Host, Path, RawQuery, Fragment string
    User *Userinfo
    ...
}
func (u *URL) String() string

Ce face net/url.Parse

url.Parse("https://dexblog.ro:443/invata/go/?pagina=2#exemple") returnează un *url.URL cu câmpurile Scheme (https), Host (dexblog.ro:443), Path (/invata/go/, decodat), RawQuery (pagina=2) și Fragment (exemple). Metodele Hostname() și Port() separă numele de port, iar Query() desface parametrii.

Poți modifica câmpurile și apoi obține adresa completă cu u.String(), care codează corect caracterele speciale. Este modul sigur de a construi adrese, în locul lipirii de texte.

Parse este îngăduitor: acceptă și adrese relative (/cale?x=1) sau text fără schemă, pe care îl pune în Path. Returnează eroare doar pentru adrese cu adevărat invalide (de exemplu un % urmat de caractere care nu sunt hexazecimale). Pentru adrese primite de la utilizatori, verifică și Scheme și Host.

Parametri

Parametru	Descriere
rawURL	Adresa ca text.

Ce returnează

Un *url.URL și o eroare. String() returnează adresa ca text.

Exemple

Exemplul 1: Părțile unei adrese

package main

import (
	"fmt"
	"net/url"
)

func main() {
	u, err := url.Parse("https://ana:parola@dexblog.ro:8443/invata/go/time%20format/?pagina=2&limba=ro#exemple")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("Scheme:  ", u.Scheme)
	fmt.Println("User:    ", u.User.Username())
	fmt.Println("Host:    ", u.Host)
	fmt.Println("Hostname:", u.Hostname(), "Port:", u.Port())
	fmt.Println("Path:    ", u.Path)
	fmt.Println("RawQuery:", u.RawQuery)
	fmt.Println("Fragment:", u.Fragment)
	fmt.Println("pagina = ", u.Query().Get("pagina"))
}

Rezultat

Scheme:   https
User:     ana
Host:     dexblog.ro:8443
Hostname: dexblog.ro Port: 8443
Path:     /invata/go/time format/
RawQuery: pagina=2&limba=ro
Fragment: exemple
pagina =  2

Exemplul 2: Modificare și String()

Construim o adresă din părți; String() codează spațiile și diacriticele din cale.

package main

import (
	"fmt"
	"net/url"
)

func main() {
	u := &url.URL{
		Scheme: "https",
		Host:   "magazin.ro",
		Path:   "/categorii/cărți noi",
	}
	q := url.Values{}
	q.Set("sortare", "preț")
	q.Set("pagina", "1")
	u.RawQuery = q.Encode()
	fmt.Println(u.String())

	u.Scheme = "http"
	u.Host = "localhost:8080"
	fmt.Println(u)
}

Rezultat

https://magazin.ro/categorii/c%C4%83r%C8%9Bi%20noi?pagina=1&sortare=pre%C8%9B
http://localhost:8080/categorii/c%C4%83r%C8%9Bi%20noi?pagina=1&sortare=pre%C8%9B

Exemplul 3: Adrese valide și invalide

package main

import (
	"fmt"
	"net/url"
)

func main() {
	for _, text := range []string{"https://go.dev/doc/", "/produse?id=7", "dexblog.ro", "https://exemplu.ro/%zz"} {
		u, err := url.Parse(text)
		if err != nil {
			fmt.Printf("%-24s eroare: %v\n", text, err)
			continue
		}
		fmt.Printf("%-24s scheme=%q host=%q path=%q\n", text, u.Scheme, u.Host, u.Path)
	}
}

Rezultat

https://go.dev/doc/      scheme="https" host="go.dev" path="/doc/"
/produse?id=7            scheme="" host="" path="/produse"
dexblog.ro               scheme="" host="" path="dexblog.ro"
https://exemplu.ro/%zz   eroare: parse "https://exemplu.ro/%zz": invalid URL escape "%zz"

Greșeli frecvente

• Crezi că url.Parse("dexblog.ro") dă un host. Fără https://, textul este o cale relativă și Host este gol.
• Construiești adrese prin lipire: "https://site.ro/cauta?q=" + text. Dacă text conține &, spații sau diacritice, adresa se strică; folosește url.Values și String().
• Validezi o adresă doar prin err == nil. Aproape orice text trece; verifică u.Scheme și u.Host.

Comenzi înrudite

• net/url.URL.Query: Desface partea de după „?” a unei adrese într-un url.Values (map de la nume la valori).
• net/url.Values: Parametrii unui query string sau ai unui formular: Get, Set, Add, Del, Has și Encode (codare sortată după cheie).
• net/url.JoinPath: Adaugă segmente la calea unei adrese, cu exact o bară între ele și fără ./ sau ../; varianta metodă lucrează pe *URL.
• net/url.QueryEscape: QueryEscape codează un text pentru query string (spațiu → +), PathEscape pentru o bucată de cale (spațiu → %20); QueryUnescape decodează.