mx52jing

Appearance

Return to top
On this page

url包

net/url包在Go语言中用于解析和构建URL

url.Parse

url.Parse方法用于解析一个URL字符串并返回一个*url.URL对象。url.URL对象如下：

Go
// URL's String method uses the EscapedPath method to obtain the path.
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)
	OmitHost    bool      // do not emit empty host (authority)
	ForceQuery  bool      // append a query ('?') even if RawQuery is empty
	RawQuery    string    // encoded query values, without '?'
	Fragment    string    // fragment for references, without '#'
	RawFragment string    // encoded fragment hint (see EscapedFragment method)
}

示例代码如下：

Go
package main

import (
	"fmt"
	"net/url"
)

func parseFn() {
	rawURL := "https://example.com/path?name=张三#section"
	//rawURL := "https://example.com:8080/#/before/error?name=%E5%BC%A0%E4%B8%89"
	parsedURL, _ := url.Parse(rawURL)
    fmt.Println("parsedURL:", parsedURL)
	fmt.Println("Scheme:", parsedURL.Scheme)
	fmt.Println("Host:", parsedURL.Host)
	fmt.Println("Path:", parsedURL.Path)
	fmt.Println("RawQuery:", parsedURL.RawQuery)
	fmt.Println("Fragment:", parsedURL.Fragment)
	/**
	rawURL := "https://example.com/path?name=张三#section" 打印如下
    parsedURL: https://example.com/path?name=张三#section
	Scheme: https
	Host: example.com
	Path: /path
	RawQuery: name=张三
	Fragment: section
	*/

	/**
	rawURL := "https://example.com:8080/#/before/error?name=%E5%BC%A0%E4%B8%89" 打印如下
    parsedURL: https://example.com:8080/#/before/error?name=%E5%BC%A0%E4%B8%89
	Scheme: https
	Host: example.com:8080
	Path: /
	RawQuery:
	Fragment: /before/error?name=张三
	*/
}

func main() {
	parseFn()
}

url.ParseRequestURI

url.ParseRequestURI类似于url.Parse，但它更严格地遵循RFC 3986规范，用于解析HTTP请求URI

Go
package main

import (
	"fmt"
	"net/url"
)

func parseRequestFn() {
	//rawURL := "https://example.com/path?name=张三#section"
	rawURL := "https://example.com:8080/#/before/error?name=%E5%BC%A0%E4%B8%89"
	parsedURL, _ := url.ParseRequestURI(rawURL)
	fmt.Println("parsedURL:", parsedURL)
	fmt.Println("Scheme:", parsedURL.Scheme)
	fmt.Println("Host:", parsedURL.Host)
	fmt.Println("Path:", parsedURL.Path)
	fmt.Println("RawQuery:", parsedURL.RawQuery)
	fmt.Println("Fragment:", parsedURL.Fragment)
	/**
	rawURL := "https://example.com/path?name=张三#section" 打印如下
	parsedURL: https://example.com/path?name=张三#section
	Scheme: https
	Host: example.com
	Path: /path
	RawQuery: name=张三#section
	*/

	/**
	rawURL := "https://example.com:8080/#/before/error?name=%E5%BC%A0%E4%B8%89" 打印如下
	parsedURL: https://example.com:8080/%23/before/error?name=%E5%BC%A0%E4%B8%89
	Scheme: https
	Host: example.com:8080
	Path: /#/before/error
	RawQuery: name=%E5%BC%A0%E4%B8%89
	Fragment:
	*/
}

func main() {
	parseRequestFn()
}

url.PathEscape和url.PathUnescape

url.PathEscape将字符串转义，以便可以安全地放置在URL路径段中，类似于js中的encodeURIComponent

url.PathUnescape方法用于对URL路径中的编码字符进行解码，类似于js中的decodeURIComponent

示例代码：

Go
package main

import (
	"fmt"
	"net/url"
)

func pathEscapeAndUnPathEscape() {
	rawUrl := "https://example.com/path?name=张三&age=22"
	escapedUrl := url.PathEscape(rawUrl)
	// Escaped Url: https:%2F%2Fexample.com%2Fpath%3Fname=%E5%BC%A0%E4%B8%89&age=22
	fmt.Println("Escaped Url:", escapedUrl)
	unescapedUrl, _ := url.PathUnescape(escapedUrl)
	// UnEscaped Url: https://example.com/path?name=张三&age=22
	fmt.Println("UnEscaped Url:", unescapedUrl)
}

func main() {
	pathEscapeAndUnPathEscape()
}

url.QueryEscape和url.QueryUnescape

url.QueryEscape方法用于对字符串进行URL编码

url.QueryUnescape方法用于对字符串进行URL解码

示例

Go
package main

import (
	"fmt"
	"net/url"
)

func queryEscapeAndUnEscape() {
	rawQuery := "?name=张三&age=18"
	escapedQuery := url.QueryEscape(rawQuery)
	fmt.Println("Escaped Query:", escapedQuery)
	unescapedQuery, _ := url.QueryUnescape(escapedQuery)
	fmt.Println("Unescaped Query:", unescapedQuery)
    /**
	Escaped Query: %3Fname%3D%E5%BC%A0%E4%B8%89%26age%3D18
	Unescaped Query: ?name=张三&age=18
	*/
}

func main() {
	queryEscapeAndUnEscape()
}

url.ParseQuery

url.ParseQuery方法用于解析URL查询字符串并将其转换为一个url.Values类型的map

代码示例：

Go
func parseQuery() {
	rawQuery := "name=张三&age=22"
	queryParams, _ := url.ParseQuery(rawQuery)
	queryParams.Set("like", "ping_pang")
	fmt.Println("Query Params:", queryParams)
	fmt.Println("name:", queryParams.Get("name"))
	fmt.Println("age:", queryParams.Get("age"))
	fmt.Println("like:", queryParams.Get("like"))
	/**
	打印如下:
	Query Params: map[age:[22] like:[ping_pang] name:[张三]]
	name: 张三
	age: 22
	like: ping_pang
	*/
}

func main() {
	parseQuery()
}

url.Values

url.Values是一个map类型，用于构建和解析URL查询参数

示例：

Go
func urlValues() {
	params := url.Values{}
	params.Add("name", "张三")
	params.Add("age", "22")
	query := params.Encode()
	// query: age=22&name=%E5%BC%A0%E4%B8%89
	fmt.Println("query:", query)
}

func buildURL() {
	parsedUrl, _ := url.Parse("https://example.com/path")
	// 添加search params
	params := url.Values{}
	params.Add("name", "张三")
	params.Add("age", "22")
	parsedUrl.RawQuery = params.Encode()
	finalURL := parsedUrl.String()
	// finalURL: https://example.com/path?age=22&name=%E5%BC%A0%E4%B8%89
	fmt.Println("finalURL:", finalURL)
}

func main() {
	urlValues()
    buildURL()
}

url.JoinPath

url.JoinPath方法用于拼接URL路径

代码示例：

Go
func pathJoin() {
	baseURL := "https://example.com"
	path1 := "path1"
	path2 := "path2"
	joinedURL, _ := url.JoinPath(baseURL, path1, path2)
    // Joined URL: https://example.com/path1/path2
	fmt.Println("Joined URL:", joinedURL)
}

func main() {
	pathJoin()
}

url.UserInfo

url.Userinfo类型和相关方法用于处理URL中的用户信息部分（即用户名和密码）

代码示例：

Go
func urlUserInfo() {
	rawURL := "https://user:root@example.com/path"
	parsedURL, _ := url.Parse(rawURL)
	if parsedURL.User != nil {
		fmt.Println("Username:", parsedURL.User.Username())
		password, hasPassword := parsedURL.User.Password()
		if hasPassword {
			fmt.Println("Password:", password)
		} else {
			fmt.Println("No password provided")
		}
		return
	}
	fmt.Println("No user info provided")
	/**
	Username: user
	Password: root
	*/
}

func main() {
	urlUserInfo()
}

url.URL.String

url.URL.String方法将*url.URL对象转换回字符串

代码示例：

Go
func urlString() {
	parsedURL := &url.URL{
		Scheme:   "https",
		Host:     "example.com",
		Path:     "/path",
		RawQuery: "name=张三",
		Fragment: "section",
	}
	// URL String: https://example.com/path?name=张三#section
	fmt.Println("URL String:", parsedURL.String())
}

func main() {
	urlString()
}

url.URL.Query

url.URL.Query方法解析URL查询参数并返回一个url.Values类型的map

代码示例：

Go
func urlQuery() {
	rawURL := "https://example.com/path?name=张三&age=22"
	parsedURL, _ := url.Parse(rawURL)
	queryParams := parsedURL.Query()
	/**
	Query Params: map[age:[22] name:[张三]]
	name: 张三
	age: 22
	like: ping_pang
	*/
	fmt.Println("Query Params:", queryParams)
	fmt.Println("name:", queryParams.Get("name"))
	queryParams.Set("like", "ping_pang")
	fmt.Println("age:", queryParams.Get("age"))
	fmt.Println("like:", queryParams.Get("like"))
}

func main() {
	urlQuery()
}

url.URL.Hostname和url.URL.Port

url.URL.Hostname方法返回URL的主机名部分

url.URL.Port方法返回URL的端口部分

代码示例：

Go
func pathNameHost() {
	rawURL := "https://example.com:8080/path?foo=bar#section"
	parsedURL, _ := url.Parse(rawURL)
	/**
	Hostname: example.com
	Port: 8080
	*/
	fmt.Println("Hostname:", parsedURL.Hostname())
	fmt.Println("Port:", parsedURL.Port())
}

func main() {
	pathNameHost()
}

url.URL.IsAbs

url.URL.IsAbs方法用于检查URL是否为绝对URL

Absolute意味着它具有非空的Schema

代码示例：

Go
func urlIsAbs() {
	rawURL1 := "https://example.com/path"
	parsedURL1, _ := url.Parse(rawURL1)

	rawURL2 := "example.com/path"
	parsedURL2, _ := url.Parse(rawURL2)
	/**
	RawURL1 Is absolute URL? true
	RawURL2 Is absolute URL? false
	*/
	fmt.Println("RawURL1 Is absolute URL?", parsedURL1.IsAbs())
	fmt.Println("RawURL2 Is absolute URL?", parsedURL2.IsAbs())
}

func main() {
	urlIsAbs()
}