Suche…


Syntax

  • resp. err: = http.Get (url) // Erstellt eine HTTP-GET-Anforderung mit dem Standard-HTTP-Client. Wenn die Anforderung fehlschlägt, wird ein Nicht-Null-Fehler zurückgegeben.
  • resp. err: = http.Post (URL, bodyType, body) // Erstellt eine HTTP-POST-Anforderung mit dem Standard-HTTP-Client. Wenn die Anforderung fehlschlägt, wird ein Nicht-Null-Fehler zurückgegeben.
  • resp. err: = http.PostForm (URL, Werte) // Erstellt eine HTTP-Formular-POST-Anforderung mit dem Standard-HTTP-Client. Wenn die Anforderung fehlschlägt, wird ein Nicht-Null-Fehler zurückgegeben.

Parameter

Parameter Einzelheiten
bzw Eine Antwort vom Typ *http.Response auf eine HTTP-Anfrage
Irr Ein error Wenn nicht gleich null, stellt dies einen Fehler dar, der beim Aufruf der Funktion aufgetreten ist.
URL Eine URL vom Typ string an die eine HTTP-Anforderung gesendet werden soll.
Körpertyp Der MIME-Typ der string der Body-Payload einer POST-Anforderung.
Karosserie Ein io.Reader (implementiert Read() ), aus dem gelesen wird, bis ein Fehler erreicht ist, der als Body-Payload einer POST-Anforderung übermittelt wird.
Werte Eine Schlüsselwertzuordnung des Typs url.Values . Der zugrunde liegende Typ ist eine map[string][]string .

Bemerkungen

Es ist wichtig, defer resp.Body.Close() nach jeder HTTP-Anforderung zu defer resp.Body.Close() , die keinen Nicht-Null-Fehler defer resp.Body.Close() Ressourcen verloren.

Basic GET

Führen Sie eine grundlegende GET-Anforderung aus und drucken Sie den Inhalt einer Site (HTML).

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    resp, err := http.Get("https://example.com/")
    if err != nil {
        panic(err)
    }

    // It is important to defer resp.Body.Close(), else resource leaks will occur.
    defer resp.Body.Close()

    data, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    // Will print site contents (HTML) to output
    fmt.Println(string(data))
}

GET mit URL-Parametern und einer JSON-Antwort

Eine Anforderung für die Top 10 der zuletzt aktiven StackOverflow-Posts unter Verwendung der Stack Exchange-API.

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"
)

const apiURL = "https://api.stackexchange.com/2.2/posts?"

// Structs for JSON decoding
type postItem struct {
    Score int    `json:"score"`
    Link  string `json:"link"`
}

type postsType struct {
    Items []postItem `json:"items"`
}

func main() {
    // Set URL parameters on declaration
    values := url.Values{
        "order": []string{"desc"},
        "sort":  []string{"activity"},
        "site":  []string{"stackoverflow"},
    }

    // URL parameters can also be programmatically set
    values.Set("page", "1")
    values.Set("pagesize", "10")

    resp, err := http.Get(apiURL + values.Encode())
    if err != nil {
        panic(err)
    }

    defer resp.Body.Close()

    // To compare status codes, you should always use the status constants
    // provided by the http package.
    if resp.StatusCode != http.StatusOK {
        panic("Request was not OK: " + resp.Status)
    }

    // Example of JSON decoding on a reader.
    dec := json.NewDecoder(resp.Body)
    var p postsType
    err = dec.Decode(&p)
    if err != nil {
        panic(err)
    }

    fmt.Println("Top 10 most recently active StackOverflow posts:")
    fmt.Println("Score", "Link")
    for _, post := range p.Items {
        fmt.Println(post.Score, post.Link)
    }
}

Timeout-Anforderung mit Kontext

1,7+

Das Zeitlimit für eine HTTP-Anforderung mit einem Kontext kann nur mit der Standardbibliothek (nicht mit den untergeordneten Ordnern) in 1.7+ ausgeführt werden:

import (
    "context"
    "net/http"
    "time"
)

req, err := http.NewRequest("GET", `https://example.net`, nil)
ctx, _ := context.WithTimeout(context.TODO(), 200 * time.Milliseconds)
resp, err := http.DefaultClient.Do(req.WithContext(ctx))
// Be sure to handle errors.
defer resp.Body.Close()

Vor 1.7

import (
    "net/http"
    "time"

    "golang.org/x/net/context"
    "golang.org/x/net/context/ctxhttp"
)

ctx, err := context.WithTimeout(context.TODO(), 200 * time.Milliseconds)
resp, err := ctxhttp.Get(ctx, http.DefaultClient, "https://www.example.net")
// Be sure to handle errors.
defer resp.Body.Close()

Lesen Sie weiter

Weitere Informationen zum context Sie unter Kontext .

PUT-Anforderung eines JSON-Objekts

Folgendes aktualisiert ein Benutzerobjekt über eine PUT-Anforderung und gibt den Statuscode der Anforderung aus:

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

type User struct {
    Name  string
    Email string
}

func main() {
    user := User{
        Name:  "John Doe",
        Email: "[email protected]",
    }

    // initialize http client
    client := &http.Client{}

    // marshal User to json
    json, err := json.Marshal(user)
    if err != nil {
        panic(err)
    }

    // set the HTTP method, url, and request body
    req, err := http.NewRequest(http.MethodPut, "http://api.example.com/v1/user", bytes.NewBuffer(json))
    if err != nil {
        panic(err)
    }

    // set the request header Content-Type for json
    req.Header.Set("Content-Type", "application/json; charset=utf-8")
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }

    fmt.Println(resp.StatusCode)
}


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow