Recherche…


Syntaxe

  • resp, err: = http.Get (url) // Crée une requête HTTP GET avec le client HTTP par défaut. Une erreur non nulle est renvoyée si la demande échoue.
  • resp, err: = http.Post (url, bodyType, body) // Crée une requête HTTP POST avec le client HTTP par défaut. Une erreur non nulle est renvoyée si la demande échoue.
  • resp, err: = http.PostForm (url, values) // Crée une requête HTTP POST avec le client HTTP par défaut. Une erreur non nulle est renvoyée si la demande échoue.

Paramètres

Paramètre Détails
resp Une réponse de type *http.Response à une requête HTTP
se tromper Une error S'il n'est pas nul, il représente une erreur qui s'est produite lors de l'appel de la fonction.
URL Une URL de type string pour faire une requête HTTP.
bodyType Le type MIME de type string de la charge utile du corps d'une requête POST.
corps Un io.Reader (implémente Read() ) qui sera lu jusqu'à ce qu'une erreur soit atteinte pour être soumis en tant que charge utile du corps d'une requête POST.
valeurs Une carte clé-valeur de type url.Values . Le type sous-jacent est une map[string][]string .

Remarques

Il est important de defer resp.Body.Close() après chaque requête HTTP ne defer resp.Body.Close() pas d'erreur non NULL, sinon les ressources seront fuites.

GET de base

Effectuez une requête GET de base et imprimez le contenu d'un 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 avec des paramètres d'URL et une réponse JSON

Une demande pour les 10 publications les plus récentes de StackOverflow en utilisant l'API Stack Exchange.

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)
    }
}

Demande de délai avec un contexte

1.7+

La temporisation d'une requête HTTP avec un contexte peut être accomplie avec uniquement la bibliothèque standard (pas la sous-position) dans 1.7+:

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()

Avant 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()

Lectures complémentaires

Pour plus d'informations sur le package de context , voir Contexte .

Demande PUT d'objet JSON

Ce qui suit met à jour un objet User via une requête PUT et imprime le code d'état de la requête:

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
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow