Options de demande

Vous pouvez personnaliser les demandes créées et transférées par un client en utilisant options de demande. Les options de requête contrôlent divers aspects d'une requête notamment les en-têtes, les paramètres de la chaîne de requête, les paramètres du délai d'attente, le corps d'une d'une requête, et bien plus encore.

Tous les exemples suivants utilisent le client suivant :

$client = new GuzzleHttp\Client(['base_uri' => 'http://httpbin.org']);

allow_redirects

Résumé

Décrit le comportement de redirection d'une demande

Types
  • bool
  • tableau
Défaut
[
    max' => ; 5,
    strict' => ; false,
    'referer' => ; false,
    'protocols' => ; [ 'http', 'https'],
    'track_redirects' => ; false
]
Constant

GuzzleHttp\RequestOptions::ALLOW_REDIRECTS

Défini à false pour désactiver les redirections.

$res = $client->request('GET', '/redirect/3', ['allow_redirects' => false]);
echo $res->getStatusCode();
// 302

Défini à true (le paramètre par défaut) pour activer les redirections normales avec un nombre maximum de 5 redirections.

$res = $client->request('GET', '/redirect/3');
echo $res->getStatusCode();
// 200

Vous pouvez également transmettre un tableau associatif contenant les paires clé-valeur suivantes :

  • max : (int, default=5) nombre maximum de redirections autorisées.

  • strict : (bool, default=false) Définissez à true pour utiliser des redirections strictes. Les redirections strictes conformes à la RFC signifient que les demandes de redirection POST sont envoyées en tant que demandes POST au lieu de faire ce que la plupart des navigateurs font, c'est-à-dire rediriger les demandes POST avec des demandes GET. avec des demandes GET.

  • referer : (bool, default=false) Mettre à true pour activer l'ajout de l'en-tête Referer lors de la redirection.

  • protocoles : (tableau, default=[ 'http', 'https']) Spécifie les protocoles autorisés pour les requêtes de autorisés pour les demandes de redirection.

  • on_redirect : (appelable) Appelable PHP qui est invoqué lorsqu'une redirection est rencontrée. L'appelable est invoqué avec la requête originale et la réponse de réponse de redirection reçue. Toute valeur de retour de la fonction on_redirect est ignorée.

  • track_redirects : (bool) Lorsqu'il vaut true, chaque URI et code d'état redirigé rencontré sera suivi dans le X-Guzzle-Redirect-History et dans le X-Guzzle-Redirect-History. X-Guzzle-Redirect-Status-History respectivement. Tous les URI et codes d'état seront stockés dans l'ordre dans lequel les redirections ont été rencontrées.

    X-Guzzle-Redirect-History exclura l'URI de la demande initiale. exclura l'URI de la demande initiale et l'en-tête X-Guzzle-Redirect-Status-History exclura le code d'état final.

use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\UriInterface;

$onRedirect = function(
    RequestInterface $request,
    ResponseInterface $response,
    UriInterface $uri
) {
    echo 'Redirecting! ' . $request->getUri() . ' to ' . $uri . "\n";
};

$res = $client->request('GET', '/redirect/3', [
    'allow_redirects' => [
        'max'             => 10,        // allow at most 10 redirects.
        'strict'          => true,      // use "strict" RFC compliant redirects.
        'referer'         => true,      // add a Referer header
        'protocols'       => ['https'], // only allow https URLs
        'on_redirect'     => $onRedirect,
        'track_redirects' => true
    ]
]);

echo $res->getStatusCode();
// 200

echo $res->getHeaderLine('X-Guzzle-Redirect-History');
// http://first-redirect, http://second-redirect, etc...

echo $res->getHeaderLine('X-Guzzle-Redirect-Status-History');
// 301, 302, etc...

Avertissement

Cette option n'a d'effet que si votre gestionnaire possède la fonction L'intergiciel GuzzleHttp\Middleware::redirect. Cet intergiciel est ajouté ajouté par défaut lorsqu'un client est créé sans gestionnaire, et il est ajouté par par défaut lors de la création d'un gestionnaire avec GuzzleHttp\HandlerStack::create.

Note

Cette option n'a aucun effet lorsque vous effectuez des requêtes en utilisant GuzzleHttp\Client::sendRequest(). Afin de rester conforme à PSR-18, toute réponse de redirection est retournée telle quelle.

auth

Résumé

Passez un tableau de paramètres d'authentification HTTP à utiliser avec la requête. Le tableau doit contenir le nom d'utilisateur dans l'index [0], le mot de passe dans l'index l'index [1], et vous pouvez éventuellement fournir un type d'authentification intégré dans l'index index [2]. Passez null pour désactiver l'authentification pour une requête.

Types
  • tableau
  • null
Défaut

Aucun

Constant

GuzzleHttp\RequestOptions::AUTH

Les types d'authentification intégrés sont les suivants :

base
Utilisez l'authentification de base HTTP dans l'en-tête Authorization (paramètre par défaut utilisé si aucun n'est spécifié).
$client->request('GET', '/get', ['auth' => ['username', 'password']]);
résumé
Utilisez l'authentification digest (doit être prise en charge par le gestionnaire HTTP).
$client->request('GET', '/get', [
    'auth' => ['username', 'password', 'digest']
]);

Note

Actuellement, ceci n'est supporté que lors de l'utilisation du gestionnaire cURL, mais mais la création d'un remplacement pouvant être utilisé avec n'importe quel gestionnaire prévue.

ntlm
Utilisez L'authentification Microsoft NTLM (doit être prise en charge par le gestionnaire HTTP).
$client->request('GET', '/get', [
    'auth' => ['username', 'password', 'ntlm']
]);

Note

Actuellement, cette fonction n'est prise en charge que lorsque vous utilisez le gestionnaire cURL.

body

Résumé

L'option body est utilisée pour contrôler le corps d'une entité requête englobante (par exemple, PUT, POST, PATCH).

Types
  • chaîne de caractères
  • fopen() ressource
  • Psr\Http\Message\StreamInterface
Défaut

Aucun

Constant

GuzzleHttp\RequestOptions::BODY

Ce paramètre peut être réglé sur l'un des types suivants :

  • chaîne

    >
    // Vous pouvez envoyer des requêtes qui utilisent une chaîne comme corps de message.
    $client->request('PUT', '/put', [ 'body' => ; 'foo']) ;
    
  • ressource renvoyée par fopen()

    // Vous pouvez envoyer des requêtes qui utilisent une ressource de flux comme corps.
    $resource = \GuzzleHttp\Psr7\Utils::tryFopen('http://httpbin.org', 'r') ;
    $client->request('PUT', '/put', [ 'body' => ; $resource]) ;
    
  • Psr\Http\Message\StreamInterface

    // Vous pouvez envoyer des requêtes qui utilisent un objet de flux Guzzle comme corps
    $stream = GuzzleHttp\Psr7\Utils::streamFor('contents...') ;
    $client->request('POST', '/post', [ 'body' => ; $stream]) ;
    

Note

Cette option ne peut pas être utilisée avec form_params, multipart, ou json.

cert

Résumé

Défini comme une chaîne pour spécifier le chemin d'accès à un fichier contenant un certificat côté client au format PEM côté client. Si un mot de passe est requis, définissez la valeur un tableau contenant le chemin d'accès au fichier PEM dans le premier élément du tableau suivi du mot de passe requis pour le certificat dans le deuxième élément du tableau. élément du tableau.

Types
  • chaîne
  • tableau
Défaut

Aucun

Constant

GuzzleHttp\RequestOptions::CERT

$client->request('GET', '/', ['cert' => ['/path/server.pem', 'password']]);

cookies

Résumé
Indique si des cookies sont utilisés ou non dans une requête, ou quel type de cookies utiliser ou quels cookies envoyer. à utiliser ou les cookies à envoyer.
Types
GuzzleHttp\Cookie\CookieJarInterface
Défaut
Aucun
Constant
GuzzleHttp\RequestOptions::COOKIES

Vous devez spécifier l'option cookies comme GuzzleHttp\Cookie\CookieJarInterface ou false.

$jar = new \GuzzleHttp\Cookie\CookieJar();
$client->request('GET', '/get', ['cookies' => $jar]);

Avertissement

Cette option n'a d'effet que si votre gestionnaire dispose de l'option L'intergiciel GuzzleHttp\Middleware::cookies. Cet intergiciel est ajouté ajouté par défaut lorsqu'un client est créé sans gestionnaire, et il est ajouté par par défaut lors de la création d'un gestionnaire avec GuzzleHttp\default_handler.

Conseil

Lorsque vous créez un client, vous pouvez définir l'option de cookie par défaut sur true pour utiliser une session de cookie partagée associée au client.

connect_timeout

Résumé
Flottant décrivant le nombre de secondes à attendre lors d'une tentative de connexion à un serveur. Utilisez 0 pour attendre indéfiniment (le comportement par défaut).
Types
float
Défaut
0
Constant
GuzzleHttp\RequestOptions::CONNECT_TIMEOUT
// Timeout if the client fails to connect to the server in 3.14 seconds.
$client->request('GET', '/delay/5', ['connect_timeout' => 3.14]);

Note

Ce paramètre doit être pris en charge par le gestionnaire HTTP utilisé pour envoyer une requête. connect_timeout n'est actuellement pris en charge que par le gestionnaire intégré cURL intégré.

debug

Résumé

Défini à true ou défini à un flux PHP retourné par fopen() pour activer la sortie de débogage avec le gestionnaire utilisé pour envoyer une requête. Par exemple, lorsque vous utilisez cURL pour transférer des requêtes, le verbiage de cURL de CURLOPT_VERBOSE sera émis. Lorsque vous utilisez le wrapper de flux PHP, les notifications du wrapper de flux seront émises. S'il est défini à true, la sortie est écrite dans le fichier STDOUT de PHP. Si un flux PHP est fourni, la sortie est écrite dans le flux.

Types
  • bool
  • fopen() ressource
Défaut

Aucun

Constant

GuzzleHttp\RequestOptions::DEBUG

$client->request('GET', '/get', ['debug' => true]);

L'exécution de l'exemple ci-dessus produirait un résultat semblable à celui qui suit :

* About to connect() to httpbin.org port 80 (#0)
*   Trying 107.21.213.98... * Connected to httpbin.org (107.21.213.98) port 80 (#0)
> GET /get HTTP/1.1
Host: httpbin.org
User-Agent: Guzzle/4.0 curl/7.21.4 PHP/5.5.7

< HTTP/1.1 200 OK
< Access-Control-Allow-Origin: *
< Content-Type: application/json
< Date: Sun, 16 Feb 2014 06:50:09 GMT
< Server: gunicorn/0.17.4
< Content-Length: 335
< Connection: keep-alive
<
* Connection #0 to host httpbin.org left intact

decode_content

Résumé

Spécifiez si les réponses Content-Encoding (gzip, deflate, etc.) sont automatiquement décodées.

Types
  • chaîne
  • bool
Défaut

true

Constant

GuzzleHttp\RequestOptions::DECODE_CONTENT

Cette option peut être utilisée pour contrôler la façon dont les corps de réponse codés en contenu sont traités. sont traités. Par défaut, decode_content a la valeur true, ce qui signifie que toute réponse gzippée ou déflatée sera décodée par Guzzle. ou déflatée sera décodée par Guzzle.

Lorsqu'il est défini sur false, le corps d'une réponse n'est jamais décodé, ce qui signifie que les octets passent par le gestionnaire sans être modifiés.

// Request gzipped data, but do not decode it while downloading
$client->request('GET', '/foo.js', [
    'headers'        => ['Accept-Encoding' => 'gzip'],
    'decode_content' => false
]);

Lorsqu'elle est définie sur une chaîne de caractères, les octets d'une réponse sont décodés et la valeur de chaîne de caractères fournie à l'option decode_content est transmise comme en-tête Accept-Encoding de la requête.

// Pass "gzip" as the Accept-Encoding header.
$client->request('GET', '/foo.js', ['decode_content' => 'gzip']);

délai

Résumé

Le nombre de millisecondes à attendre avant d'envoyer la requête.

Types
  • entier
  • flottant
Défaut

null

Constant

GuzzleHttp\RequestOptions::DELAY

attendre

Résumé

Contrôle le comportement de l'en-tête "Expect : 100-Continue".

Types
  • bool
  • nombre entier
Défaut

1048576

Constant

GuzzleHttp\RequestOptions::EXPECT

Défini à true pour activer l'en-tête "Expect : 100-Continue" pour toutes les demandes qui envoient un corps. Défini à false pour désactiver l'en-tête "Expect : 100-Continue". pour toutes les demandes. Défini à un nombre de sorte que la taille de la charge utile doit être supérieure à ce nombre pour que la demande soit acceptée. doit être supérieure à ce nombre pour que l'en-tête Expect soit envoyé. La définition d'un nombre nombre, l'en-tête Expect sera envoyé pour toutes les requêtes pour lesquelles la taille de la charge utile ne peut pas être déterminée ou pour lesquelles l'en-tête Expect sera envoyé. charge utile ne peut être déterminée ou dont le corps n'est pas réenroulable.

Par défaut, Guzzle ajoute l'en-tête "Expect : 100-Continue" lorsque la taille du corps d'une requête est supérieure à 1 Mo et que la requête utilise HTTP/1.1.

Note

Cette option ne prend effet que si vous utilisez HTTP/1.1. Les protocoles HTTP/1.0 et HTTP/2.0 ne prennent pas en charge l'en-tête "Expect : 100-Continue". La prise en charge de la gestion du flux de travail "Expect : 100-Continue" doit être être implémentée par les gestionnaires HTTP de Guzzle utilisés par un client.

force_ip_resolve

Résumé
Mettez "v4" si vous voulez que les gestionnaires HTTP utilisent uniquement le protocole ipv4 ou "v6" pour le protocole ipv6.
Types
chaîne de caractères
Défaut
null
Constant
GuzzleHttp\RequestOptions::FORCE_IP_RESOLVE
// Force ipv4 protocol
$client->request('GET', '/foo', ['force_ip_resolve' => 'v4']);

// Force ipv6 protocol
$client->request('GET', '/foo', ['force_ip_resolve' => 'v6']);

Note

Ce paramètre doit être pris en charge par le gestionnaire HTTP utilisé pour envoyer une requête. force_ip_resolve est actuellement pris en charge uniquement par les gestionnaires intégrés cURL et les gestionnaires de flux intégrés.

form_params

Résumé
Utilisé pour envoyer une demande POST application/x-www-form-urlencoded.
Types
tableau
Constant
GuzzleHttp\RequestOptions::FORM_PARAMS

Tableau associatif de noms de champs de formulaire vers des valeurs où chaque valeur est une chaîne ou un tableau de chaînes de caractères. Définit l'en-tête Content-Type à application/x-www-form-urlencoded lorsque aucun en-tête Content-Type n'est déjà présent.

$client->request('POST', '/post', [
    'form_params' => [
        'foo' => 'bar',
        'baz' => ['hi', 'there!']
    ]
]);

Note

Le form_params ne peut pas être utilisé avec l'option multipart. Vous devez utiliser l'une ou l'autre. Utilisez form_params pour les demandes application/x-www-form-urlencoded et multipart pour les demandes multipart/form-data.

Cette option ne peut pas être utilisée avec body, multipart, ou json.

headers

Résumé
Tableau associatif d'en-têtes à ajouter à la requête. Chaque clé est le nom d'un en-tête, et chaque valeur est une chaîne ou un tableau de chaînes de caractères représentant les valeurs des champs d'en-tête.
Types
tableau
Valeurs par défaut
Aucun
Constant
GuzzleHttp\RequestOptions::HEADERS
// Set various headers on a request
$client->request('GET', '/get', [
    'headers' => [
        'User-Agent' => 'testing/1.0',
        'Accept'     => 'application/json',
        'X-Foo'      => ['Bar', 'Baz']
    ]
]);

Les en-têtes peuvent être ajoutés comme options par défaut lors de la création d'un client. Lorsque des en-têtes sont utilisés comme options par défaut, ils ne sont appliqués que si la requête en cours de création ne contient pas déjà l'en-tête spécifique. Cela inclut les demandes transmises au client par les méthodes send() et sendAsync(), ainsi que les demandes créées par le client (par exemple, request() et requestAsync()).

$client = new GuzzleHttp\Client(['headers' => ['X-Foo' => 'Bar']]);

// Will send a request with the X-Foo header.
$client->request('GET', '/get');

// Sets the X-Foo header to "test", which prevents the default header
// from being applied.
$client->request('GET', '/get', ['headers' => ['X-Foo' => 'test']]);

// Will disable adding in default headers.
$client->request('GET', '/get', ['headers' => null]);

// Will not overwrite the X-Foo header because it is in the message.
use GuzzleHttp\Psr7\Request;
$request = new Request('GET', 'http://foo.com', ['X-Foo' => 'test']);
$client->send($request);

// Will overwrite the X-Foo header with the request option provided in the
// send method.
use GuzzleHttp\Psr7\Request;
$request = new Request('GET', 'http://foo.com', ['X-Foo' => 'test']);
$client->send($request, ['headers' => ['X-Foo' => 'overwrite']]);

http_errors

Résumé
Défini à false pour désactiver l'envoi d'exceptions sur les erreurs de protocole HTTP (c'est-à-dire les réponses 4xx et 5xx). (c'est-à-dire les réponses 4xx et 5xx). Les exceptions sont lancées par défaut lorsque des erreurs de protocole HTTP sont rencontrées.
Types
bool
Défaut
true
Constant
GuzzleHttp\RequestOptions::HTTP_ERRORS
$client->request('GET', '/status/500');
// Throws a GuzzleHttp\Exception\ServerException

$res = $client->request('GET', '/status/500', ['http_errors' => false]);
echo $res->getStatusCode();
// 500

Avertissement

Cette option n'a d'effet que si votre gestionnaire possède l'attribut L'intergiciel GuzzleHttp\Middleware::httpErrors. Cet intergiciel est ajouté ajouté par défaut lorsqu'un client est créé sans gestionnaire, et il est ajouté par par défaut lors de la création d'un gestionnaire avec GuzzleHttp\default_handler.

idn_conversion

Résumé

Prise en charge des noms de domaine internationalisés (IDN) (activée par défaut si intl extension est disponible).

Types
  • bool
  • int
Défaut

true si intl l'extension est disponible (et la bibliothèque ICU est 4.6+ pour PHP 7.2+), false sinon

Constant

GuzzleHttp\RequestOptions::IDN_CONVERSION

$client->request('GET', 'https://яндекс.рф');
// яндекс.рф is translated to xn--d1acpjx3f.xn--p1ai before passing it to the handler

$res = $client->request('GET', 'https://яндекс.рф', ['idn_conversion' => false]);
// The domain part (яндекс.рф) stays unmodified

Active/désactive le support IDN, peut également être utilisé pour un contrôle précis en combinant Constantes IDNA_* (sauf IDNA_ERROR_*), voir le paramètre $options de la fonction idn_to_ascii() pour plus de détails.

json

Résumé
L'option json est utilisée pour télécharger facilement des données encodées en JSON dans le corps d'une requête. Un en-tête Content-Type de application/json sera ajouté si aucun en-tête Content-Type n'est déjà présent dans le message.
Types
Tout type PHP qui peut être exploité par la fonction json_encode() de PHP.
Défaut
Aucun
Constant
GuzzleHttp\RequestOptions::JSON
$response = $client->request('PUT', '/put', ['json' => ['foo' => 'bar']]);

Voici un exemple d'utilisation de l'intergiciel tap pour voir quelle requête est envoyée sur le fil.

use GuzzleHttp\Middleware;

// Create a middleware that echoes parts of the request.
$tapMiddleware = Middleware::tap(function ($request) {
    echo $request->getHeaderLine('Content-Type');
    // application/json
    echo $request->getBody();
    // {"foo":"bar"}
});

// The $handler variable is the handler passed in the
// options to the client constructor.
$response = $client->request('PUT', '/put', [
    'json'    => ['foo' => 'bar'],
    'handler' => $tapMiddleware($handler)
]);

Note

Cette option de requête ne permet pas de personnaliser l'en-tête Content-Type ni aucune des options de la fonction PHP json_encode() de PHP. Si vous devez personnaliser ces paramètres, vous devez transmettre les données codées en format données codées en JSON dans la requête en utilisant l'option de requête body. et vous devez spécifier l'en-tête Content-Type correct à l'aide de l'option headers.

Cette option ne peut pas être utilisée avec body, form_params, ou multipart.

multipart

Résumé
Définit le corps de la demande comme un formulaire multipart/form-data.
Types
tableau
Constant
GuzzleHttp\RequestOptions::MULTIPART

La valeur de multipart est un tableau de tableaux associatifs, chacun contenant les paires clé-valeur suivantes :

  • nom : (string, required) le nom du champ du formulaire
  • contenu : (StreamInterface/resource/string, obligatoire) Les données à utiliser dans l'élément l'élément de formulaire.
  • en-têtes : (array) Tableau associatif facultatif d'en-têtes personnalisés à utiliser avec l'élément de formulaire.
  • nom de fichier : (string) Chaîne optionnelle à envoyer comme nom de fichier dans la pièce.
use GuzzleHttp\Psr7;

$client->request('POST', '/post', [
    'multipart' => [
        [
            'name'     => 'foo',
            'contents' => 'data',
            'headers'  => ['X-Baz' => 'bar']
        ],
        [
            'name'     => 'baz',
            'contents' => Psr7\Utils::tryFopen('/path/to/file', 'r')
        ],
        [
            'name'     => 'qux',
            'contents' => Psr7\Utils::tryFopen('/path/to/file', 'r'),
            'filename' => 'custom_filename.txt'
        ],
    ]
]);

Note

Le multipart ne peut pas être utilisé avec l'option form_params. Vous devrez utiliser l'une ou l'autre. Utilisez form_params pour les demandes application/x-www-form-urlencoded et multipart pour les demandes multipart/form-data.

Cette option ne peut pas être utilisée avec body, form_params, ou json.

on_headers

Résumé

Un appelable qui est invoqué lorsque les en-têtes HTTP de la réponse ont été reçus mais que le corps n'a pas encore commencé à être téléchargé. ont été reçus mais que le corps de la réponse n'a pas encore commencé à être téléchargé

Types
  • appelable
Constant

GuzzleHttp\RequestOptions::ON_HEADERS

L'appelant accepte un objet Psr\Http\Message\ResponseInterface. Si une exception est levée par l'appelant, alors la promesse associée à la réponse sera réponse sera rejetée avec un objet GuzzleHttp\Exception\RequestException qui englobe l'exception levée. exception qui a été déclenchée.

Vous pouvez avoir besoin de savoir quels en-têtes et codes d'état ont été reçus avant que les données puissent être écrites sur le récepteur.

// Reject responses that are greater than 1024 bytes.
$client->request('GET', 'http://httpbin.org/stream/1024', [
    'on_headers' => function (ResponseInterface $response) {
        if ($response->getHeaderLine('Content-Length') > 1024) {
            throw new \Exception('The file is too big!');
        }
    }
]);

Note

Lors de l'écriture de gestionnaires HTTP, la fonction on_headers doit être invoquée avant d'écrire des données dans le corps de la réponse.

on_stats

Résumé

on_stats vous permet d'accéder aux statistiques de transfert d'une demande et d'accéder aux détails de transfert de niveau inférieur du gestionnaire associé à votre client. on_stats est un callable qui est invoqué lorsqu'un gestionnaire a fini d'envoyer une demande. La callback est invoquée avec des statistiques de transfert sur la demande, la réponse reçue ou l'erreur rencontrée. l'erreur rencontrée. Les données comprennent le temps total pris pour envoyer la demande. pour envoyer la demande.

Types
  • appelable
Constant

GuzzleHttp\RequestOptions::ON_STATS

L'appelant accepte un objet GuzzleHttp\TransferStats.

use GuzzleHttp\TransferStats;

$client = new GuzzleHttp\Client();

$client->request('GET', 'http://httpbin.org/stream/1024', [
    'on_stats' => function (TransferStats $stats) {
        echo $stats->getEffectiveUri() . "\n";
        echo $stats->getTransferTime() . "\n";
        var_dump($stats->getHandlerStats());

        // You must check if a response was received before using the
        // response object.
        if ($stats->hasResponse()) {
            echo $stats->getResponse()->getStatusCode();
        } else {
            // Error data is handler specific. You will need to know what
            // type of error data your handler uses before using this
            // value.
            var_dump($stats->getHandlerErrorData());
        }
    }
]);

progrès

Résumé

Définit une fonction à invoquer lorsque le transfert progresse.

Types
  • appelable
Défaut

Aucun

Constant

GuzzleHttp\RequestOptions::PROGRESS

La fonction accepte les arguments positionnels suivants :

  • le nombre total d'octets dont le téléchargement est attendu, zéro si inconnu
  • le nombre d'octets téléchargés jusqu'à présent
  • le nombre total d'octets attendus pour le téléchargement
  • le nombre d'octets téléchargés jusqu'à présent
// Send a GET request to /get?foo=bar
$result = $client->request(
    'GET',
    '/',
    [
        'progress' => function(
            $downloadTotal,
            $downloadedBytes,
            $uploadTotal,
            $uploadedBytes
        ) {
            //do something
        },
    ]
);

proxy

Résumé

Passez une chaîne pour spécifier un proxy HTTP, ou un tableau pour spécifier différents proxys pour différents protocoles

différents mandataires pour différents protocoles.

Types
  • chaîne
  • tableau
Défaut

Aucun

Constant

GuzzleHttp\RequestOptions::PROXY

Passez une chaîne pour spécifier un proxy pour tous les protocoles.

$client->request('GET', '/', ['proxy' => 'http://localhost:8125']);

Passez un tableau associatif pour spécifier les proxies HTTP pour des schémas URI spécifiques (c'est-à-dire "http", "https"). (par exemple, "http", "https"). Fournir une paire clé-valeur no afin de fournir une liste de noms d'hôtes qui ne doivent pas faire l'objet d'un proxy.

Note

Guzzle remplit automatiquement cette valeur avec la variable d'environnement suivante variable d'environnement NO_PROXY. Toutefois, lorsque vous fournissez une option de demande proxy c'est à vous de fournir la valeur no analysée à partir des éléments suivants la variable d'environnement NO_PROXY. (par exemple, explode(',', getenv('NO_PROXY'))).

$client->request('GET', '/', [
    'proxy' => [
        'http'  => 'http://localhost:8125', // Use this proxy with "http"
        'https' => 'http://localhost:9124', // Use this proxy with "https",
        'no' => ['.mit.edu', 'foo.com']    // Don't use a proxy with these
    ]
]);

Note

Vous pouvez fournir des URL de proxy qui contiennent un schéma, un nom d'utilisateur et un mot de passe. Par exemple, "http://username:[email protected]:10".

query

Résumé

Tableau associatif de valeurs de chaîne de requête ou de chaîne de requête à ajouter à la demande

la requête

Types
  • tableau
  • chaîne
Défaut

Aucun

Constant

GuzzleHttp\RequestOptions::QUERY

// Send a GET request to /get?foo=bar
$client->request('GET', '/get', ['query' => ['foo' => 'bar']]);

Les chaînes de requête spécifiées dans l'option query écraseront toutes les valeurs de chaîne de requête fournies dans l'URI d'une demande.

// Send a GET request to /get?foo=bar
$client->request('GET', '/get?abc=123', ['query' => ['foo' => 'bar']]);

read_timeout

Résumé
Flottant décrivant le délai d'attente à utiliser lors de la lecture d'un corps en flux.
Types
float
Défaut
La valeur par défaut est celle du paramètre PHP ini default_socket_timeout.
Constant
GuzzleHttp\RequestOptions::READ_TIMEOUT

Le délai d'attente s'applique aux opérations de lecture individuelles sur un corps en continu (lorsque l'option stream est activée).

$response = $client->request('GET', '/stream', [
    'stream' => true,
    'read_timeout' => 10,
]);

$body = $response->getBody();

// Returns false on timeout
$data = $body->read(1024);

// Returns false on timeout
$line = fgets($body->detach());

sink

Résumé

Indiquez où le corps d'une réponse sera enregistré.

Types
  • string (chemin d'accès au fichier sur le disque)
  • fopen() ressource
  • Psr\Http\Message\StreamInterface
Défaut

Flux temporaire PHP

Constant

GuzzleHttp\RequestOptions::SINK

Passez une chaîne pour spécifier le chemin d'accès à un fichier qui stockera le contenu du corps de la réponse :

$client->request('GET', '/stream/20', ['sink' => '/path/to/file']);

Passez une ressource retournée par fopen() pour écrire la réponse dans un flux PHP :

$resource = \GuzzleHttp\Psr7\Utils::tryFopen('/path/to/file', 'w');
$client->request('GET', '/stream/20', ['sink' => $resource]);

Passez un objet Psr\Http\Message\StreamInterface pour transmettre le corps de la réponse à un flux PSR-7 ouvert.

$resource = \GuzzleHttp\Psr7\Utils::tryFopen('/path/to/file', 'w');
$stream = \GuzzleHttp\Psr7\Utils::streamFor($resource);
$client->request('GET', '/stream/20', ['save_to' => $stream]);

Note

L'option de requête save_to a été dépréciée au profit de l'option de requête sink. La fourniture de l'option save_to est maintenant un alias de sink.

ssl_key

Résumé

Spécifiez le chemin d'accès à un fichier contenant une clé SSL privée au format PEM . Si un mot de passe est requis, il est défini comme un tableau contenant le chemin contenant le chemin d'accès à la clé SSL dans le premier élément du tableau, suivi du mot de passe requis pour le certificat dans le second élément. pour le certificat dans le deuxième élément.

Types
  • chaîne
  • tableau
Défaut

Aucun

Constant

GuzzleHttp\RequestOptions::SSL_KEY

Note

ssl_key est mis en œuvre par les gestionnaires HTTP. Actuellement, cette fonctionnalité n'est actuellement que par le gestionnaire cURL, mais peut être pris en charge par d'autres gestionnaires gestionnaires tiers.

stream

Résumé
Défini à true pour diffuser une réponse en continu plutôt que de la télécharger entièrement à l'avance.
Types
bool
Défaut
false
Constant
GuzzleHttp\RequestOptions::STREAM
$response = $client->request('GET', '/stream/20', ['stream' => true]);
// Read bytes off of the stream until the end of the stream is reached
$body = $response->getBody();
while (!$body->eof()) {
    echo $body->read(1024);
}

Note

La prise en charge des réponses en continu doit être mise en œuvre par le gestionnaire HTTP utilisé par le client. un client. Cette option n'est pas forcément prise en charge par tous les gestionnaires HTTP. l'interface de l'objet de réponse reste la même, qu'elle soit ou non qu'elle soit prise en charge ou non par le gestionnaire.

synchrone

Résumé
Défini à true pour informer les gestionnaires HTTP que vous avez l'intention d'attendre la réponse. réponse. Cela peut être utile pour les optimisations.
Types
bool
Défaut
aucun
Constant
GuzzleHttp\RequestOptions::SYNCHRONOUS

vérifier

Résumé

Décrit le comportement de la vérification du certificat SSL pour une demande.

  • Défini à true pour activer la vérification des certificats SSL et utiliser le groupe d'autorités de certification par défaut fourni par le système d'exploitation
  • par défaut fourni par le système d'exploitation.
  • Définir à false pour désactiver la vérification des certificats (ce n'est pas sûr !).
  • Défini comme une chaîne de caractères pour fournir le chemin d'accès à un faisceau d'autorités de certification afin d'activer la vérification en utilisant un certificat personnalisé. en utilisant un certificat personnalisé.
Types
  • bool
  • chaîne
Défaut

true

Constant

GuzzleHttp\RequestOptions::VERIFY

// Use the system's CA bundle (this is the default setting)
$client->request('GET', '/', ['verify' => true]);

// Use a custom SSL certificate on disk.
$client->request('GET', '/', ['verify' => '/path/to/cert.pem']);

// Disable validation entirely (don't do this!).
$client->request('GET', '/', ['verify' => false]);

Si vous n'avez pas besoin d'un ensemble de certificats spécifique, Mozilla fournit un ensemble d'autorités de certification couramment utilisé, qui peut être téléchargé à partir du site Web de Mozilla. paquet d'AC couramment utilisé qui peut être téléchargé ici (fourni par le responsable de cURL). Une fois que le paquet CA est disponible sur le disque disque, vous pouvez définir le paramètre PHP ini "openssl.cafile" pour qu'il indique le chemin d'accès au le fichier, ce qui vous permet d'omettre l'option de requête "verify". Beaucoup plus de détails sur les Les certificats SSL sont disponibles sur le site site Web cURL.

timeout

Résumé
Flottant décrivant le délai total de la demande en secondes. Utilisez 0 pour attendre indéfiniment (le comportement par défaut).
Types
float
Défaut
0
Constant
GuzzleHttp\RequestOptions::TIMEOUT
// Timeout if a server does not return a response in 3.14 seconds.
$client->request('GET', '/delay/5', ['timeout' => 3.14]);
// PHP Fatal error:  Uncaught exception 'GuzzleHttp\Exception\TransferException'

version

Résumé
Version du protocole à utiliser avec la demande.
Types
string, float
Défaut
1.1
Constant
GuzzleHttp\RequestOptions::VERSION
// Force HTTP/1.0
$request = $client->request('GET', '/get', ['version' => 1.0]);