[[417414]]

 本文是一篇學習筆記，記錄了作者學習 go 語言標準庫 net/url 庫的過程。

參考：https://studygolang.com/pkgdoc

導入方式： 

import "net/url" 

url 包解析 URL 并實現了查詢的逸碼，參見 RFC 3986。

func PathEscape

func PathEscape(s string) string 

PathEscape 會將字符串轉義出來，以便將其安全地放置在 URL 路徑段中。

func PathUnescape 

func PathUnescape(s string) (string, error 

PathUnescape 執行 PathEscape 的逆轉換，將 ％AB 轉換為字節 0xAB 。如果任何 ％ 之后沒有兩個十六進制數字，它將返回一個錯誤。

PathUnescape 與 QueryUnescape 相同，只是它不會將'+'改為''（空格）。

func QueryEscape 

func QueryEscape(s string) string 

QueryEscape 函數對 s 進行轉碼使之可以安全的用在 URL 查詢里。

func QueryUnescape 

func QueryUnescape(s string) (string, error) 

QueryUnescape 函數用于將 QueryEscape 轉碼的字符串還原。它會把%AB 改為字節 0xAB，將'+'改為' '。如果有某個%后面未跟兩個十六進制數字，本函數會返回錯誤。

舉例： 

package main   
import(  
    "fmt"  
    "encoding/base64"  
    "net/url"  
    "crypto/rand"  
    "io"  
    "log"  
)  
//sessionId 函數用來生成一個 session ID，即 session 的唯一標識符  
func sessionId() string {  
    b := make([]byte, 32)  
    //ReadFull 從 rand.Reader 精確地讀取 len(b) 字節數據填充進 b  
    //rand.Reader 是一個全局、共享的密碼用強隨機數生成器  
    if _, err := io.ReadFull(rand.Reader, b); err != nil {   
        return ""  
    }  
    fmt.Println(b) //[238 246 235 166 48 196 157 143 123 140 241 200 213 113 247 168 219 132 208 163 223 24 72 162 114 30 175 205 176 117 139 118] 
     return base64.URLEncoding.EncodeToString(b)//將生成的隨機數 b 編碼后返回字符串，該值則作為 session ID 
 }  
func main() {   
    sessionId := sessionId()   
    fmt.Println(sessionId) //7vbrpjDEnY97jPHI1XH3qNuE0KPfGEiich6vzbB1i3Y=  
    encodedSessionId := url.QueryEscape(sessionId) //對 sessionId 進行轉碼使之可以安全的用在 URL 查詢里  
    fmt.Println(encodedSessionId) //7vbrpjDEnY97jPHI1XH3qNuE0KPfGEiich6vzbB1i3Y%3D  
    decodedSessionId, err := url.QueryUnescape(encodedSessionId) //將 QueryEscape 轉碼的字符串還原  
    if err != nil {  
        log.Fatal(err)  
    }  
    fmt.Println(decodedSessionId) //7vbrpjDEnY97jPHI1XH3qNuE0KPfGEiich6vzbB1i3Y=  
} 

type URL 

type URL struct {  
    Scheme   string    //具體指訪問服務器上的資源使用的哪種協議  
    Opaque   string    // 編碼后的不透明數據  
    User     *Userinfo // 用戶名和密碼信息，有些協議需要傳入明文用戶名和密碼來獲取資源，比如 FTP  
    Host     string    // host 或 host:port，服務器地址，可以是 IP 地址，也可以是域名信息  
    Path     string  //路徑，使用"/"分隔  
    RawQuery string // 編碼后的查詢字符串，沒有'?'  
    Fragment string // 引用的片段（文檔位置），沒有'#'  
} 

URL 類型代表一個解析后的 URL（或者說，一個 URL 參照）。URL 基本格式如下： 

scheme://[userinfo@]host/path[?query][#fragment] 

scheme 后不是冒號加雙斜線的 URL 被解釋為如下格式： 

scheme:opaque[?query][#fragment] 

注意路徑字段是以解碼后的格式保存的，如/%47%6f%2f 會變成/Go/。這導致我們無法確定 Path 字段中的斜線是來自原始 URL 還是解碼前的%2f。除非一個客戶端必須使用其他程序/函數來解析原始 URL 或者重構原始 URL，這個區別并不重要。此時，HTTP 服務端可以查詢 req.RequestURI，而 HTTP 客戶端可以使用 URL{Host: "example.com", Opaque: "//example.com/Go%2f"}代替{Host: "example.com", Path: "/Go/"}。

func Parse 

func Parse(rawurl string) (url *URL, err error) 

Parse 函數解析 rawurl 為一個 URL 結構體，rawurl 可以是絕對地址，也可以是相對地址。

func ParseRequestURI 

func ParseRequestURI(rawurl string) (url *URL, err error) 

ParseRequestURI 函數解析 rawurl 為一個 URL 結構體，本函數會假設 rawurl 是在一個 HTTP 請求里，因此會假設該參數是一個絕對 URL 或者絕對路徑，并會假設該 URL 沒有#fragment 后綴。（網頁瀏覽器會在去掉該后綴后才將網址發送到網頁服務器）

func (*URL) IsAbs

func (u *URL) IsAbs() bool 

函數在 URL 是絕對 URL 時才返回真。

舉例： 

package main   
import(  
    "fmt"  
    "net/url"  
)  
func main() {   
    u := url.URL{Host: "example.com", Path: "foo"}  
    fmt.Println(u.IsAbs()) //false  
    u.Scheme = "http"  
    fmt.Println(u.IsAbs()) //true  
} 

func (*URL) Query 

func (u *URL) Query() Values 

Query 方法解析 RawQuery 字段并返回其表示的 Values 類型鍵值對。

舉例： 

package main   
import(  
    "fmt"  
    "net/url"  
)  
func main() {   
    u := &url.URL{  
        Scheme:   "https",  
        User:     url.UserPassword("me", "pass"),  
        Host:     "example.com",  
        Path:     "foo/bar",  
        RawQuery: "x=1&y=2",  
        Fragment: "anchor",  
    }  
    fmt.Println(u.Query()) //map[x:[1] y:[2]]  
} 

func (*URL) RequestURI 

func (u *URL) RequestURI() string 

RequestURI 方法返回編碼好的 path?query 或 opaque?query 字符串，用在 HTTP 請求里。 

package main   
import(  
    "fmt"  
    "net/url"  
    "log"  
)  
func main() {   
    u, err := url.Parse("https://example.org/path?foo=bar")  
    if err != nil {  
        log.Fatal(err)  
    }  
    fmt.Println(u.RequestURI()) ///path?foo=bar  
} 

func (*URL) String 

func (u *URL) String() string 

String 將 URL 重構為一個合法 URL 字符串。

字符串將 URL 重組為一個有效的 URL 字符串。結果的一般形式是以下之一： 

scheme:opaque?query#fragment  
scheme://userinfo@host/path?query#fragment 

如果 u.Opaque 不為空，則 String 使用第一種形式；否則它使用第二種形式。要獲取路徑，String 使用 u.EscapedPath() 。

在第二種形式中，適用下列規則： 

- if u.Scheme is empty, scheme: is omitted.  
- if u.User is nil, userinfo@ is omitted.  
- if u.Host is empty, host/ is omitted.  
- if u.Scheme and u.Host are empty and u.User is nil,  
   the entire scheme://userinfo@host/ is omitted.  
- if u.Host is non-empty and u.Path begins with a /,  
   the form host/path does not add its own /.  
- if u.RawQuery is empty, ?query is omitted.  
- if u.Fragment is empty, #fragment is omitted. 

舉例： 

package main   
import(  
    "fmt"  
    "net/url"  
)  
func main() {   
    u := &url.URL{  
        Scheme:   "https",  
        User:     url.UserPassword("me", "pass"),  
        Host:     "example.com",  
        Path:     "foo/bar",  
        RawQuery: "x=1&y=2",  
        Fragment: "anchor",  
    }  
    //這是第一種形式  
    fmt.Println(u.String()) //https://me:pass@example.com/foo/bar?x=1&y=2#anchor  
    u.Opaque = "opaque"  
    //這是第二種形式  
    fmt.Println(u.String()) //https:opaque?x=1&y=2#anchor  
} 

func (*URL) EscapedPath 

func (u *URL) EscapedPath() string 

EscapedPath 返回 u.Path 的轉義形式。一般來說，任何路徑都有多種可能的轉義形式。EscapedPath 在 u.Path 有效轉義時返回 u.RawPath 。否則，EscapedPath 將忽略 u.RawPath 并自行計算轉義表單。String 和 RequestURI 方法使用 EscapedPath 來構造它們的結果。通常，代碼應該調用 EscapedPath ，而不是直接讀取 u.RawPath 。

舉例： 

package main   
import(  
    "fmt"  
    "net/url"  
    "log"  
)  
func main() {   
    u, err := url.Parse("http://example.com/path with spaces")  
    if err != nil {  
        log.Fatal(err)  
    }  
    fmt.Println(u.EscapedPath()) ///path%20with%20spaces  
} 

func (*URL) Hostname 

func (u *URL) Hostname() string 

主機名返回 u.Host ，沒有任何端口號。

如果主機是具有端口號的 IPv6 文本，則主機名將返回不帶方括號的 IPv6 文字。IPv6 文字可能包含區域標識符。

舉例： 

package main   
import(  
    "fmt"  
    "net/url"  
    "log"  
)  
func main() {   
    u, err := url.Parse("https://example.org:8000/path")//IPV4  
    if err != nil {  
        log.Fatal(err)  
    }  
    fmt.Println(u.Hostname()) //example.org  
    u, err = url.Parse("https://[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:17000") //IPV6  
    if err != nil {  
        log.Fatal(err)  
    }  
    fmt.Println(u.Hostname())//2001:0db8:85a3:0000:0000:8a2e:0370:7334  
} 

func (*URL) Port 

func (u *URL) Port() string 

Port 返回 u.Host 的端口部分，不帶前導冒號。如果 u.Host 不包含端口，則 Port 返回空字符串。

func (*URL) Parse 

func (u *URL) Parse(ref string) (*URL, error) 

Parse 方法以 u 為上下文來解析一個 URL，ref 可以是絕對或相對 URL。

本方法解析失敗會返回 nil, err；否則返回結果和 ResolveReference 一致。

舉例： 

package main   
import(  
    "fmt"  
    "net/url"  
    "log"  
)  
func main() {   
    base, err := url.Parse("http://example.com/directory/")  
    if err != nil {  
        log.Fatal(err)  
    }  
    fmt.Println(base)  
    result, err := base.Parse("./search?q=dotnet")  
    if err != nil {  
        log.Fatal(err) 
    }  
    fmt.Println(result)  
} 

返回： 

bogon:~ user$ go run testGo.go   
http://example.com/directory/  
http://example.com/directory/search?q=dotnet 

func (*URL) ResolveReference 

func (u *URL) ResolveReference(ref *URL) *URL  

本方法根據一個絕對 URI 將一個 URI 補全為一個絕對 URI，參見 RFC 3986 節 5.2。參數 ref 可以是絕對 URI 或者相對 URI。ResolveReference 總是返回一個新的 URL 實例，即使該實例和 u 或者 ref 完全一樣。如果 ref 是絕對 URI，本方法會忽略參照 URI 并返回 ref 的一個拷貝。

舉例：

當 ref 是相對路徑，則其將會相對于 u 來得到其的絕對路徑： 

package main   
import(  
    "fmt"  
    "net/url"  
    "log"  
)  
func main() {   
  //該相對路徑的意思是  
    u, err := url.Parse("../../..//search?q=dotnet")//相對路徑的不同會影響返回的結果  
    if err != nil {  
        log.Fatal(err) 
     }  
    fmt.Println(u) 
     base, err := url.Parse("http://example.com/directory/")  
    if err != nil {  
        log.Fatal(err)  
    }  
    fmt.Println(base)  
    fmt.Println(base.ResolveReference(u))  
} 

返回： 

bogon:~ user$ go run testGo.go   
../../..//search?q=dotnet  
http://example.com/directory/  
http://example.com/search?q=dotnet 

如果相對路徑為。./..//search?q=dotnet，返回結果是相同的，即 http://example.com/search?q=dotnet

但是如果相對路徑為。.//search?q=dotnet，將返回 http://example.com//search?q=dotnet，這并不是我們想要的結果。如果想要相對于 directory 目錄，則相對路徑寫成。/search?q=dotnet

func (u *URL) MarshalBinary() (text []byte, err error) 

func (u *URL) MarshalBinary() (text []byte, err error) 

舉例： 

package main   
import(  
    "fmt"  
    "net/url"  
    "log"  
    "reflect"  
)  
func main() {   
    u, _ := url.Parse("https://example.org")  
    b, err := u.MarshalBinary() //將其轉成二進制  
    if err != nil {  
        log.Fatal(err)  
    }  
    fmt.Println(reflect.TypeOf(b)) //[]uint8  
    fmt.Println(b) //[104 116 116 112 115 58 47 47 101 120 97 109 112 108 101 46 111 114 103]  
    fmt.Printf("%s\n", b) //https://example.org  
} 

func (*URL) UnmarshalBinary 

func (u *URL) UnmarshalBinary(text []byte) error 

舉例： 

package main   
import(  
    "fmt"  
    "net/url"  
    "log"  
    "reflect"  
)  
func main() {   
    u := &url.URL{}  
    //將其從二進制轉成 url.URL 類型  
    err := u.UnmarshalBinary([]byte("https://example.org:8000/foo"))  
    if err != nil {  
        log.Fatal(err)  
    }  
    fmt.Println(reflect.TypeOf(u)) //*url.URL  
    fmt.Println(u) //https://example.org:8000/foo  
    fmt.Println(u.Hostname()) //example.org  
    fmt.Println(u.Port()) //8000 
} 

type Userinfo 

type Userinfo struct {  
    // 內含隱藏或非導出字段  
} 

Userinfo 類型是一個 URL 的用戶名和密碼細節的一個不可修改的封裝。一個真實存在的 Userinfo 值必須保證有用戶名（但根據 RFC 2396 可以是空字符串）以及一個可選的密碼。

func User

func User(username string) *Userinfo 

User 函數返回一個用戶名設置為 username 的不設置密碼的* Userinfo。

func UserPassword 

func UserPassword(username, password string) *Userinfo 

UserPassword 函數返回一個用戶名設置為 username、密碼設置為 password 的* Userinfo。

這個函數應該只用于老式的站點，因為風險很大，不建議使用，參見 RFC 2396。

func (*Userinfo) Username 

func (u *Userinfo) Username() string  

Username 方法返回用戶名。

func (*Userinfo) Password 

func (u *Userinfo) Password() (string, bool) 

如果設置了密碼返回密碼和真，否則會返回假。

func (*Userinfo) String 

func (u *Userinfo) String() string 

String 方法返回編碼后的用戶信息，格式為"username[:password]"。

舉例： 

package main   
import(  
    "fmt"  
    "net/url"  
    "log"  
)  
func main() {   
    u := &url.URL{  
        Scheme:   "https",  
        User:     url.UserPassword("me", "pass"),  
        Host:     "example.com",  
        Path:     "foo/bar",  
        RawQuery: "x=1&y=2",  
        Fragment: "anchor",  
    }  
    fmt.Println(u.User.Username()) //me  
    password, b := u.User.Password()  
    if b == false{  
        log.Fatal("can not get password")  
    }  
    fmt.Println(password) //pass  
    fmt.Println(u.User.String()) //me:pass  
} 

type Values 

type Values map[string][]string 

Values 將建映射到值的列表。它一般用于查詢的參數和表單的屬性。不同于 http.Header 這個字典類型，Values 的鍵是大小寫敏感的。

func ParseQuery 

func ParseQuery(query string) (m Values, err error) 

ParseQuery 函數解析一個 URL 編碼的查詢字符串，并返回可以表示該查詢的 Values 類型的字典。本函數總是返回一個包含了所有合法查詢參數的非 nil 字典，err 用來描述解碼時遇到的（如果有）第一個錯誤。

舉例： 

package main   
import(  
    "fmt"  
    "net/url"  
    "log"  
)  
func main() {   
    v, err := url.ParseQuery("friend=Jess&friend=Sarah&fruit=apple&name=Ava")  
    if err != nil {  
        log.Fatal(err)  
    }  
    fmt.Println(v) //map[friend:[Jess Sarah] fruit:[apple] name:[Ava]]  
} 

func (Values) Get 

func (v Values) Get(key string) string 

Get 會獲取 key 對應的值集的第一個值。如果沒有對應 key 的值集會返回空字符串。獲取值集請直接用 map。

func (Values) Set 

func (v Values) Set(key, value string) 

Set 方法將 key 對應的值集設為只有 value，它會替換掉已有的值集。

func (Values) Add 

func (v Values) Add(key, value string) 

Add 將 value 添加到 key 關聯的值集里原有的值的后面。

func (Values) Del 

func (v Values) Del(key string) 

Del 刪除 key 關聯的值集。

func (Values) Encode 

func (v Values) Encode() string 

Encode 方法將 v 編碼為 url 編碼格式 ("bar=baz&foo=quux")，編碼時會以鍵進行排序。

舉例： 

package main   
import(  
    "fmt"  
    "net/url"  
) 
func main() {   
    v := url.Values{}  
    v.Set("name", "Ava")  
    v.Add("friend", "Jess")  
    v.Add("friend", "Sarah")  
    v.Add("fruit", "apple")  
    fmt.Println(v.Get("name"))  
    fmt.Println(v.Get("friend"))  
    fmt.Println(v["friend"])  
    fmt.Println(v.Encode())  
    v.Del("name")  
    fmt.Println(v.Encode())  
} 

返回： 

bogon:~ user$ go run testGo.go   
Ava  
Jess  
[Jess Sarah]  
friend=Jess&friend=Sarah&fruit=apple&name=Ava  
friend=Jess&friend=Sarah&fruit=apple