web-dev-qa-db-ja.com

URLのエンコード/デコード

GoでURL全体をエンコードおよびデコードする推奨方法は何ですか？私はメソッドを知っていますurl.QueryEscapeおよびurl.QueryUnescape、しかし、彼らは私が探しているものとはまったく違うようです。具体的には、JavaScriptのencodeURIComponentやdecodeURIComponentなどのメソッドを探しています。

ありがとう。

urlescapinggo
65
Sergi Mansilla

net/url モジュールを使用すると、必要なすべてのURLエンコーディングを実行できます。 URLの各部分の個々のエンコード関数を分解するのではなく、URL全体を構築する必要があります。ソースコードに目を通したことは、非常に優れた、標準に準拠した仕事だと思います。

以下に例を示します（ playground link ）

package main

import (
    "fmt"
    "net/url"
)

func main() {

    Url, err := url.Parse("http://www.example.com")
    if err != nil {
        panic("boom")
    }

    Url.Path += "/some/path/or/other_with_funny_characters?_or_not/"
    parameters := url.Values{}
    parameters.Add("hello", "42")
    parameters.Add("hello", "54")
    parameters.Add("vegetable", "potato")
    Url.RawQuery = parameters.Encode()

    fmt.Printf("Encoded URL is %q\n", Url.String())
}

どの印刷

Encoded URL is "http://www.example.com/some/path/or/other_with_funny_characters%3F_or_not/?vegetable=potato&hello=42&hello=54"
88
Nick Craig-Wood

encodeURIComponentのMDN から：

encodeURIComponentは、以下を除くすべての文字をエスケープします：アルファベット、10進数、'-', '_', '.', '!', '~', '*', ''', '(', ')'

Goのurl.QueryEscapeの実装 （具体的には、shouldEscapeプライベート関数）から、以下を除くすべての文字をエスケープします：アルファベット、10進数、_'-', '_', '.', '~'_。

Javascriptとは異なり、GoのQueryEscape（）willは'!', '*', ''', '(', ')'をエスケープします。基本的に、GoのバージョンはRFC-3986に厳密に準拠しています。 Javascriptの方が緩やかです。再びMDNから：

RFC 3986（！、 '、（、）、および*を予約）を厳守したい場合は、これらの文字に正式なURI区切りの使用法はありませんが、以下を安全に使用できます。

_function fixedEncodeURIComponent (str) {
  return encodeURIComponent(str).replace(/[!'()]/g, escape).replace(/\*/g, "%2A");
}
_
13
mna

Go 1.8以降、この状況は変わりました。現在、古い PathEscape に加えて QueryEscape にアクセスして、パスコンポーネントをエンコードし、対応する非エスケープ PathUnescape 。

7
Flimzy

これはどう：

template.URLQueryEscaper(path)
6
Xian Shu

JavascriptのencodeURIComponent()を模倣するために、文字列ヘルパー関数を作成しました。

例："My String"から"My%20String"

https://github.com/mrap/stringutil/blob/master/urlencode.go

import "net/url"

// UrlEncoded encodes a string like Javascript's encodeURIComponent()
func UrlEncoded(str string) (string, error) {
    u, err := url.Parse(str)
    if err != nil {
        return "", err
    }
    return u.String(), nil
}
5
Mike Rapadas

誰かがJS encodeURIComponentと比較して正確な結果を取得したい場合、私の機能を試してみてくださいそれは汚れていますが、うまく機能します。

https://Gist.github.com/czyang/7ae30f4f625fee14cfc40c143e1b78bf

// #Warning! You Should Use this Code Carefully, and As Your Own Risk.
    package main

    import (
    "fmt"
    "net/url"
    "strings"
)
/*
After hours searching, I can't find any method can get the result exact as the JS encodeURIComponent function.
In my situation I need to write a sign method which need encode the user input exact same as the JS encodeURIComponent.
This function does solved my problem.
*/
func main() {
    params := url.Values{
        "test_string": {"+!+'( )*-._~0-????  ????9a-zA-Z 中文测试 test with ❤️ !@#$%^&&*()~<>?/.,;'[][]:{{}|{}|"},
    }
    urlEncode := params.Encode()
    fmt.Println(urlEncode)
    urlEncode = compatibleRFC3986Encode(urlEncode)
    fmt.Println("RFC3986", urlEncode)
    urlEncode = compatibleJSEncodeURIComponent(urlEncode)
    fmt.Println("JS encodeURIComponent", urlEncode)
}

// Compatible with RFC 3986.
func compatibleRFC3986Encode(str string) string {
    resultStr := str
    resultStr = strings.Replace(resultStr, "+", "%20", -1)
    return resultStr
}

// This func mimic JS encodeURIComponent, JS is wild and not very strict.
func compatibleJSEncodeURIComponent(str string) string {
    resultStr := str
    resultStr = strings.Replace(resultStr, "+", "%20", -1)
    resultStr = strings.Replace(resultStr, "%21", "!", -1)
    resultStr = strings.Replace(resultStr, "%27", "'", -1)
    resultStr = strings.Replace(resultStr, "%28", "(", -1)
    resultStr = strings.Replace(resultStr, "%29", ")", -1)
    resultStr = strings.Replace(resultStr, "%2A", "*", -1)
    return resultStr
}
2
cyang

エスケープとアンエスケープの実装を次に示します（goソースからリッピング）。

package main


import (  
    "fmt"
    "strconv"
)


const (
    encodePath encoding = 1 + iota
    encodeHost
    encodeUserPassword
    encodeQueryComponent
    encodeFragment
)

type encoding int
type EscapeError string

func (e EscapeError) Error() string {
    return "invalid URL escape " + strconv.Quote(string(e))
}


func ishex(c byte) bool {
    switch {
    case '0' <= c && c <= '9':
        return true
    case 'a' <= c && c <= 'f':
        return true
    case 'A' <= c && c <= 'F':
        return true
    }
    return false
}

func unhex(c byte) byte {
    switch {
    case '0' <= c && c <= '9':
        return c - '0'
    case 'a' <= c && c <= 'f':
        return c - 'a' + 10
    case 'A' <= c && c <= 'F':
        return c - 'A' + 10
    }
    return 0
}



// Return true if the specified character should be escaped when
// appearing in a URL string, according to RFC 3986.
//
// Please be informed that for now shouldEscape does not check all
// reserved characters correctly. See golang.org/issue/5684.
func shouldEscape(c byte, mode encoding) bool {
    // §2.3 Unreserved characters (alphanum)
    if 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' {
        return false
    }

    if mode == encodeHost {
        // §3.2.2 Host allows
        //  sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
        // as part of reg-name.
        // We add : because we include :port as part of Host.
        // We add [ ] because we include [ipv6]:port as part of Host
        switch c {
        case '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=', ':', '[', ']':
            return false
        }
    }

    switch c {
    case '-', '_', '.', '~': // §2.3 Unreserved characters (mark)
        return false

    case '$', '&', '+', ',', '/', ':', ';', '=', '?', '@': // §2.2 Reserved characters (reserved)
        // Different sections of the URL allow a few of
        // the reserved characters to appear unescaped.
        switch mode {
        case encodePath: // §3.3
            // The RFC allows : @ & = + $ but saves / ; , for assigning
            // meaning to individual path segments. This package
            // only manipulates the path as a whole, so we allow those
            // last two as well. That leaves only ? to escape.
            return c == '?'

        case encodeUserPassword: // §3.2.1
            // The RFC allows ';', ':', '&', '=', '+', '$', and ',' in
            // userinfo, so we must escape only '@', '/', and '?'.
            // The parsing of userinfo treats ':' as special so we must escape
            // that too.
            return c == '@' || c == '/' || c == '?' || c == ':'

        case encodeQueryComponent: // §3.4
            // The RFC reserves (so we must escape) everything.
            return true

        case encodeFragment: // §4.1
            // The RFC text is silent but the grammar allows
            // everything, so escape nothing.
            return false
        }
    }

    // Everything else must be escaped.
    return true
}




func escape(s string, mode encoding) string {
    spaceCount, hexCount := 0, 0
    for i := 0; i < len(s); i++ {
        c := s[i]
        if shouldEscape(c, mode) {
            if c == ' ' && mode == encodeQueryComponent {
                spaceCount++
            } else {
                hexCount++
            }
        }
    }

    if spaceCount == 0 && hexCount == 0 {
        return s
    }

    t := make([]byte, len(s)+2*hexCount)
    j := 0
    for i := 0; i < len(s); i++ {
        switch c := s[i]; {
        case c == ' ' && mode == encodeQueryComponent:
            t[j] = '+'
            j++
        case shouldEscape(c, mode):
            t[j] = '%'
            t[j+1] = "0123456789ABCDEF"[c>>4]
            t[j+2] = "0123456789ABCDEF"[c&15]
            j += 3
        default:
            t[j] = s[i]
            j++
        }
    }
    return string(t)
}


// unescape unescapes a string; the mode specifies
// which section of the URL string is being unescaped.
func unescape(s string, mode encoding) (string, error) {
    // Count %, check that they're well-formed.
    n := 0
    hasPlus := false
    for i := 0; i < len(s); {
        switch s[i] {
        case '%':
            n++
            if i+2 >= len(s) || !ishex(s[i+1]) || !ishex(s[i+2]) {
                s = s[i:]
                if len(s) > 3 {
                    s = s[:3]
                }
                return "", EscapeError(s)
            }
            i += 3
        case '+':
            hasPlus = mode == encodeQueryComponent
            i++
        default:
            i++
        }
    }

    if n == 0 && !hasPlus {
        return s, nil
    }

    t := make([]byte, len(s)-2*n)
    j := 0
    for i := 0; i < len(s); {
        switch s[i] {
        case '%':
            t[j] = unhex(s[i+1])<<4 | unhex(s[i+2])
            j++
            i += 3
        case '+':
            if mode == encodeQueryComponent {
                t[j] = ' '
            } else {
                t[j] = '+'
            }
            j++
            i++
        default:
            t[j] = s[i]
            j++
            i++
        }
    }
    return string(t), nil
}


func EncodeUriComponent(rawString string) string{
    return escape(rawString, encodeFragment)
}

func DecodeUriCompontent(encoded string) (string, error){
    return unescape(encoded, encodeQueryComponent)
}


// https://golang.org/src/net/url/url.go
// http://remove-line-numbers.ruurtjan.com/
func main() {
    // http://www.url-encode-decode.com/
    Origin := "äöüHel/lo world"
    encoded := EncodeUriComponent(Origin)
    fmt.Println(encoded)

    s, _ := DecodeUriCompontent(encoded)
    fmt.Println(s)
}



// -------------------------------------------------------

/*
func UrlEncoded(str string) (string, error) {
    u, err := url.Parse(str)
    if err != nil {
        return "", err
    }
    return u.String(), nil
}


// http://stackoverflow.com/questions/13820280/encode-decode-urls
// import "net/url"
func old_main() {
    a,err := UrlEncoded("hello world")
    if err != nil {
           fmt.Println(err)
    }
    fmt.Println(a)

    // https://gobyexample.com/url-parsing
    //s := "postgres://user:[email protected]:5432/path?k=v#f"
    s := "postgres://user:[email protected]:5432/path?k=vbla%23fooa#f"
    u, err := url.Parse(s)
    if err != nil {
        panic(err)
    }


    fmt.Println(u.RawQuery)
    fmt.Println(u.Fragment)
    fmt.Println(u.String())
    m, _ := url.ParseQuery(u.RawQuery)
    fmt.Println(m)
    fmt.Println(m["k"][0])

}
*/

// -------------------------------------------------------
1
Stefan Steiger