func (req *Request) PostForm(url interface{}, data interface{}) (resp *Response, err error) {
	args := req2arg(req)
	contentType := ""
	switch data.(type) {
	case io.Reader:
		req.Body = data.(io.Reader)
	case string:
		req.Body = strings.NewReader(data.(string))
	case map[string]string, map[string][]string:
		req.Body, contentType, err = newFormBody(args, data)
		if err != nil {
			return nil, err
		}
	}
	if contentType == "" {
		_, ok := req.Headers["Content-Type"]
		if !ok && req.Files == nil {
			req.Headers["Content-Type"] = DefaultContentType
		}
	} else {
		req.Headers["Content-Type"] = contentType
	}
	args = req2arg(req)
	resp, err = Post(url2string(url), args)
	return
}
PostForm send post form request.

url can be string or *url.URL or ur.URL

data can be map[string]string or map[string][]string or string or io.Reader

data := map[string]string{
"a": "1",
"b": "2",
}

data := map[string][]string{
"a": []string{"1", "2"},
"b": []string{"2", "3"},
}

data : = "a=1&b=2"

data : = strings.NewReader("a=1&b=2")
package request
import (
	"io"
	"net/http"
	"net/http/cookiejar"
	"net/url"
	"strings"
	"golang.org/x/net/publicsuffix"
)
const Version = "0.8.0"
var DefaultClient = new(http.Client)
type FileField struct {
	FieldName string
	FileName  string
	File      io.Reader
}
type BasicAuth struct {
	Username string
	Password string
}
type Args struct {
	Client    *http.Client
	Headers   map[string]string
	Cookies   map[string]string
	Data      map[string]string
	Params    map[string]string
	Files     []FileField
	Json      interface{}
	Proxy     string
	BasicAuth BasicAuth
	Body      io.Reader
	Hooks     []Hook
}
type Request struct {
	*Args
}
func NewArgs(c *http.Client) *Args {
	if c == nil {
		c = DefaultClient
	}
	if c.Jar == nil {
		options := cookiejar.Options{
			PublicSuffixList: publicsuffix.List,
		}
		jar, _ := cookiejar.New(&options)
		c.Jar = jar
	}
	headers := map[string]string{}
	for k, v := range DefaultHeaders {
		headers[k] = v
	}
	return &Args{
		Client:    c,
		Headers:   headers,
		Cookies:   nil,
		Data:      nil,
		Params:    nil,
		Files:     nil,
		Json:      nil,
		Proxy:     "",
		BasicAuth: BasicAuth{},
		Body:      nil,
		Hooks:     []Hook{},
	}
}
func NewRequest(c *http.Client) *Request {
	return &Request{NewArgs(c)}
}
func newURL(u string, params map[string]string) string {
	if params == nil {
		return u
	}
	p := url.Values{}
	for k, v := range params {
		p.Set(k, v)
	}
	if strings.Contains(u, "?") {
		return u + "&" + p.Encode()
	}
	return u + "?" + p.Encode()
}
func newBody(a *Args) (body io.Reader, contentType string, err error) {
	if a.Body != nil {
		return a.Body, "", nil
	}
	if a.Data == nil && a.Files == nil && a.Json == nil {
		return nil, "", nil
	}
	if a.Files != nil {
		return newMultipartBody(a, nil)
	} else if a.Json != nil {
		return newJSONBody(a)
	}
	d := url.Values{}
	for k, v := range a.Data {
		d.Set(k, v)
	}
	return strings.NewReader(d.Encode()), DefaultContentType, nil
}
func buildHTTPRequest(method string, url string, a *Args) (req *http.Request, err error) {
	body, contentType, err := newBody(a)
	if err != nil {
		return nil, err
	}
	u := newURL(url, a.Params)
	req, err = http.NewRequest(method, u, body)
	if err != nil {
		return nil, err
	}
	applyHeaders(a, req, contentType)
	applyCookies(a, req)
	err = applyProxy(a)
	if err != nil {
		return nil, err
	}
	applyCheckRdirect(a)
	if a.BasicAuth.Username != "" {
		req.SetBasicAuth(a.BasicAuth.Username, a.BasicAuth.Password)
	}
	return
}
func newRequest(method string, url string, a *Args) (resp *Response, err error) {
	if a == nil {
		a = NewArgs(DefaultClient)
	}
	req, err := buildHTTPRequest(method, url, a)
	if err != nil {
		return nil, err
	}
	s, err := applyBeforeReqHooks(req, a.Hooks)
	if err != nil {
		return nil, err
	} else if s != nil {
		resp = &Response{s, nil}
		return resp, err
	}
	s, err = a.Client.Do(req)
	newResp, newErr := applyAfterReqHooks(req, s, err, a.Hooks)
	if newErr != nil {
		err = newErr
	}
	if newResp != nil {
		s = newResp
	}
	resp = &Response{s, nil}
	return
}
func Get(url string, a *Args) (resp *Response, err error) {
	resp, err = newRequest("GET", url, a)
	return
}
func (req *Request) Get(url interface{}) (resp *Response, err error) {
	resp, err = Get(url2string(url), req2arg(req))
	return
}
func Head(url string, a *Args) (resp *Response, err error) {
	resp, err = newRequest("HEAD", url, a)
	return
}
func (req *Request) Head(url interface{}) (resp *Response, err error) {
	resp, err = Head(url2string(url), req2arg(req))
	return
}
func Post(url string, a *Args) (resp *Response, err error) {
	resp, err = newRequest("POST", url, a)
	return
}
func (req *Request) Post(url interface{}) (resp *Response, err error) {
	resp, err = Post(url2string(url), req2arg(req))
	return
}