...
Run Format

Source file src/net/url/example_test.go

Documentation: net/url

  // Copyright 2012 The Go Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style
  // license that can be found in the LICENSE file.
  
  package url_test
  
  import (
  	"encoding/json"
  	"fmt"
  	"log"
  	"net/url"
  	"strings"
  )
  
  func ExampleValues() {
  	v := url.Values{}
  	v.Set("name", "Ava")
  	v.Add("friend", "Jess")
  	v.Add("friend", "Sarah")
  	v.Add("friend", "Zoe")
  	// v.Encode() == "name=Ava&friend=Jess&friend=Sarah&friend=Zoe"
  	fmt.Println(v.Get("name"))
  	fmt.Println(v.Get("friend"))
  	fmt.Println(v["friend"])
  	// Output:
  	// Ava
  	// Jess
  	// [Jess Sarah Zoe]
  }
  
  func ExampleURL() {
  	u, err := url.Parse("http://bing.com/search?q=dotnet")
  	if err != nil {
  		log.Fatal(err)
  	}
  	u.Scheme = "https"
  	u.Host = "google.com"
  	q := u.Query()
  	q.Set("q", "golang")
  	u.RawQuery = q.Encode()
  	fmt.Println(u)
  	// Output: https://google.com/search?q=golang
  }
  
  func ExampleURL_roundtrip() {
  	// Parse + String preserve the original encoding.
  	u, err := url.Parse("https://example.com/foo%2fbar")
  	if err != nil {
  		log.Fatal(err)
  	}
  	fmt.Println(u.Path)
  	fmt.Println(u.RawPath)
  	fmt.Println(u.String())
  	// Output:
  	// /foo/bar
  	// /foo%2fbar
  	// https://example.com/foo%2fbar
  }
  
  func ExampleURL_ResolveReference() {
  	u, err := url.Parse("../../..//search?q=dotnet")
  	if err != nil {
  		log.Fatal(err)
  	}
  	base, err := url.Parse("http://example.com/directory/")
  	if err != nil {
  		log.Fatal(err)
  	}
  	fmt.Println(base.ResolveReference(u))
  	// Output:
  	// http://example.com/search?q=dotnet
  }
  
  func ExampleParseQuery() {
  	m, err := url.ParseQuery(`x=1&y=2&y=3;z`)
  	if err != nil {
  		log.Fatal(err)
  	}
  	fmt.Println(toJSON(m))
  	// Output:
  	// {"x":["1"], "y":["2", "3"], "z":[""]}
  }
  
  func ExampleURL_EscapedPath() {
  	u, err := url.Parse("http://example.com/path with spaces")
  	if err != nil {
  		log.Fatal(err)
  	}
  	fmt.Println(u.EscapedPath())
  	// Output:
  	// /path%20with%20spaces
  }
  
  func ExampleURL_Hostname() {
  	u, err := url.Parse("https://example.org:8000/path")
  	if err != nil {
  		log.Fatal(err)
  	}
  	fmt.Println(u.Hostname())
  	u, err = url.Parse("https://[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:17000")
  	if err != nil {
  		log.Fatal(err)
  	}
  	fmt.Println(u.Hostname())
  	// Output:
  	// example.org
  	// 2001:0db8:85a3:0000:0000:8a2e:0370:7334
  }
  
  func ExampleURL_IsAbs() {
  	u := url.URL{Host: "example.com", Path: "foo"}
  	fmt.Println(u.IsAbs())
  	u.Scheme = "http"
  	fmt.Println(u.IsAbs())
  	// Output:
  	// false
  	// true
  }
  
  func ExampleURL_MarshalBinary() {
  	u, _ := url.Parse("https://example.org")
  	b, err := u.MarshalBinary()
  	if err != nil {
  		log.Fatal(err)
  	}
  	fmt.Printf("%s\n", b)
  	// Output:
  	// https://example.org
  }
  
  func ExampleURL_Parse() {
  	u, err := url.Parse("https://example.org")
  	if err != nil {
  		log.Fatal(err)
  	}
  	rel, err := u.Parse("/foo")
  	if err != nil {
  		log.Fatal(err)
  	}
  	fmt.Println(rel)
  	_, err = u.Parse(":foo")
  	if _, ok := err.(*url.Error); !ok {
  		log.Fatal(err)
  	}
  	// Output:
  	// https://example.org/foo
  }
  
  func ExampleURL_Port() {
  	u, err := url.Parse("https://example.org")
  	if err != nil {
  		log.Fatal(err)
  	}
  	fmt.Println(u.Port())
  	u, err = url.Parse("https://example.org:8080")
  	if err != nil {
  		log.Fatal(err)
  	}
  	fmt.Println(u.Port())
  	// Output:
  	//
  	// 8080
  }
  
  func ExampleURL_Query() {
  	u, err := url.Parse("https://example.org/?a=1&a=2&b=&=3&&&&")
  	if err != nil {
  		log.Fatal(err)
  	}
  	q := u.Query()
  	fmt.Println(q["a"])
  	fmt.Println(q.Get("b"))
  	fmt.Println(q.Get(""))
  	// Output:
  	// [1 2]
  	//
  	// 3
  }
  
  func ExampleURL_String() {
  	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())
  	u.Opaque = "opaque"
  	fmt.Println(u.String())
  	// Output:
  	// https://me:pass@example.com/foo/bar?x=1&y=2#anchor
  	// https:opaque?x=1&y=2#anchor
  }
  
  func ExampleURL_UnmarshalBinary() {
  	u := &url.URL{}
  	err := u.UnmarshalBinary([]byte("https://example.org/foo"))
  	if err != nil {
  		log.Fatal(err)
  	}
  	fmt.Printf("%s\n", u)
  	// Output:
  	// https://example.org/foo
  }
  
  func ExampleURL_RequestURI() {
  	u, err := url.Parse("https://example.org/path?foo=bar")
  	if err != nil {
  		log.Fatal(err)
  	}
  	fmt.Println(u.RequestURI())
  	// Output: /path?foo=bar
  }
  
  func toJSON(m interface{}) string {
  	js, err := json.Marshal(m)
  	if err != nil {
  		log.Fatal(err)
  	}
  	return strings.Replace(string(js), ",", ", ", -1)
  }
  

View as plain text