La méthode Curl get ne fonctionne pas. CURL PHP : qu'est-ce que c'est et comment l'utiliser ? Envoyer une requête GET à partir d'un formulaire

07.03.2019

Pourquoi avons-nous besoin de PHP CURL ?
Pour envoyer des requêtes HTTP GET, nous pouvons simplement utiliser fichier_get_contents() méthode.

File_get_contents("http://site")

Mais envoi de requête POST et gestion des erreurs ne sont pas facile avec file_get_contents().

L'envoi de requêtes HTTP est très simple avec PHP CURL. Vous devez suivre les quatre étapes pour envoyer la requête.

étape 1). Initialiser la session CURL

$ch = curl_init();

étape 2). Fournir des options pour la session CURL

Curl_setopt($ch,CURLOPT_URL,"http://site"); curl_setopt($ch,CURLOPT_RETURNTRANSFER,true); //curl_setopt($ch,CURLOPT_HEADER, true); //si vous voulez des en-têtes

CURLOPT_URL-> URL à récupérer
CURLOPT_HEADER-> pour inclure l'en-tête/non
CURLOPT_RETURNTRANSFER-> s'il est défini sur true, les données sont renvoyées sous forme de chaîne au lieu de les afficher.

étape 3). Exécuter la session CURL

$output=curl_exec($ch);

étape 4). Fermer la séance

Curl_close($ch);

Note: Vous pouvez vérifier si CURL est activé/non avec ce qui suit code.

If(is_callable("curl_init"))( echo "Enabled"; ) else ( echo "Non activé"; )

1.PHP CURL GET Exemple

Vous pouvez utiliser le code ci-dessous pour envoyer une requête GET.

Fonction httpGet($url) ( $ch = curl_init(); curl_setopt($ch,CURLOPT_URL,$url); curl_setopt($ch,CURLOPT_RETURNTRANSFER,true); // curl_setopt($ch,CURLOPT_HEADER, false); $output= curl_exec($ch); curl_close($ch); return $output; echo httpGet("http://site");

2.Exemple de POST CURL PHP

Vous pouvez utiliser le code ci-dessous pour soumettre le formulaire en utilisant PHP CURL.

Fonction httpPost($url,$params) ( $postData = ""; //crée des paires de valeurs de nom séparées par & foreach($params comme $k => $v) ( $postData .= $k . "=".$ v."&"; $postData = rtrim($postData, "&"); $ch = curl_setopt($ch,CURLOPT_URL,$url); CURLOPT_HEADER, false); curl_setopt($ch, CURLOPT_POST, count($postData)); curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);

Comment utiliser la fonction :

$params = array("name" => "Ravishanker Kusuma", "age" => "32", "location" => "Inde"); echo httpPost("http://site/examples/php/curl-examples/post.php",$params);

3.Envoyer un agent utilisateur aléatoire dans les requêtes

Vous pouvez utiliser la fonction ci-dessous pour obtenir un agent utilisateur aléatoire.

Fonction getRandomUserAgent() ( $userAgents=array("Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.8.1.6) Gecko/20070725 Firefox/2.0.0.6", "Mozilla/4.0 (compatible; MSIE 7.0 ; Windows NT 5.1)", "Mozilla/4.0 (compatible ; MSIE 7.0 ; Windows NT 5.1 ; .NET CLR 1.1.4322 ; .NET CLR 2.0.50727 ; .NET CLR 3.0.04506.30)", "Opera/9.20 (Windows NT 6.0; U; fr)", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; fr) Opera 8.50", "Mozilla/4.0 (compatible; MSIE 6.0; MSIE 5.5; Windows NT 5.1) Opera 7.02 ", "Mozilla/5.0 (Macintosh; U; PPC Mac OS X Mach-O; fr; rv:1.7) Gecko/20040624 Firefox/0.9", "Mozilla/5.0 (Macintosh; U; PPC Mac OS X; fr) AppleWebKit /48 (comme Gecko) Safari/48"); $random = rand(0,count($userAgents)-1); return $userAgents[$random]; )

En utilisant CURLOPT_USERAGENT, vous pouvez définir la chaîne User-Agent.

Curl_setopt($ch,CURLOPT_USERAGENT,getRandomUserAgent());

4.Gérer les redirections (HTTP 301 302)

Pour gérer les redirections d'URL, définissez CURLOPT_FOLLOWLOCATION sur TRUE. Le nombre maximum de redirections peut être contrôlé à l'aide de CURLOPT_MAXREDIRS.

Curl_setopt($ch,CURLOPT_FOLLOWLOCATION,TRUE); curl_setopt($ch,CURLOPT_MAXREDIRS,2);//seulement 2 redirections

5.Comment gérer les erreurs CURL

nous pouvons utiliser les méthodes curl_errno(),curl_error() pour obtenir les dernières erreurs de la session en cours.
erreur_boucle($ch)-> renvoie l'erreur sous forme de chaîne
curl_errno($ch)-> renvoie le numéro d'erreur
Vous pouvez utiliser le code ci-dessous pour gérer les erreurs.

Fonction httpGetWithErros($url) ( $ch = curl_init(); curl_setopt($ch,CURLOPT_URL,$url); curl_setopt($ch,CURLOPT_RETURNTRANSFER,true); $output=curl_exec($ch); if($output == = false) ( echo "Numéro d'erreur :".curl_errno($ch)."
"; echo "Chaîne d'erreur :".curl_error($ch); ) curl_close($ch); return $output; )

cURL est un outil spécial conçu pour transférer des fichiers et des données à l'aide de la syntaxe URL. Cette technologie prend en charge de nombreux protocoles tels que HTTP, FTP, TELNET et bien d'autres. cURL a été initialement conçu pour être un outil en ligne de commande. Heureusement pour nous, la bibliothèque cURL est supportée par le langage Programmation PHP. Dans cet article, nous examinerons quelques avancées fonctions cURL, et abordent également application pratique connaissances acquises en utilisant PHP.

Pourquoi curl ?

En fait, il existe de nombreux moyens alternatifs des exemples de contenu de pages Web. Dans de nombreux cas, principalement par paresse, j'ai utilisé PHP simple fonctions au lieu de cURL :

$content = file_get_contents("http://www.nettuts.com"); // ou $lines = file("http://www.nettuts.com"); // ou readfile("http://www.nettuts.com");

Cependant, ces fonctions n'ont pratiquement aucune flexibilité et contiennent un grand nombre de défauts en termes de gestion des erreurs, etc. De plus, il y a certaines tâches que vous ne pouvez tout simplement pas résoudre avec ces outils. fonctions standards: interaction avec les cookies, authentification, soumission de formulaire, téléchargement de fichiers, etc.

cURL est une bibliothèque puissante qui prend en charge de nombreux protocoles et options différents et fournit informations détaillées sur les demandes d'URL.

Structure de base

Initialisation
Affectation des paramètres
Exécution et récupération du résultat
Libérer de la mémoire

// 1. initialisation $ch = curl_init(); // 2. spécifiez les paramètres, y compris l'url curl_setopt($ch, CURLOPT_URL, "http://www.nettuts.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_HEADER, 0); // 3. obtient le HTML comme résultat $output = curl_exec($ch); // 4. ferme la connexion curl_close($ch);

L'étape 2 (c'est-à-dire l'appel de curl_setopt()) sera beaucoup plus abordée dans cet article que toutes les autres étapes, car À ce stade, toutes les choses les plus intéressantes et utiles que vous devez savoir se produisent. Dans cURL, il existe un grand nombre d'options différentes qui doivent être spécifiées afin de pouvoir configurer la requête URL de la manière la plus soignée. Nous ne considérerons pas toute la liste, mais nous concentrerons uniquement sur ce que je considère nécessaire et utile pour cette leçon. Vous pouvez étudier tout le reste vous-même si ce sujet vous intéresse.

Vérification des erreurs

De plus, vous pouvez également utiliser des instructions conditionnelles pour tester si une opération réussit :

// ... $output = curl_exec($ch); if ($output === FALSE) ( echo "Erreur cURL : " . curl_error($ch); ) // ...

Ici, je vous demande de noter par vous-même très point important: Nous devrions utiliser « === false » pour comparaison au lieu de « == false ». Pour ceux qui ne sont pas au courant, cela nous aidera à faire la distinction entre un résultat vide et une valeur booléenne false, qui indiquera une erreur.

Obtenir des informations

Une autre étape supplémentaire consiste à obtenir des données sur la requête cURL après son exécution.

// ... curl_exec($ch); $info = curl_getinfo($ch); echo " Pris " . $info["total_time"] . "secondes pour l'URL". $info["url"]; //…

Le tableau renvoyé contient les informations suivantes :

"url"
"type_content"
"code_http"
"taille_en-tête"
« taille_demande »
"filetime"
"ssl_verify_result"
« redirect_count »
« durée_totale »
"namelookup_time"
« heure de connexion »
« heure_prétransfert »
"taille_upload"
"taille_télécharger"
"vitesse_téléchargement"
"vitesse_upload"
"download_content_length"
"upload_content_length"
"starttransfer_time"
"redirect_time"

Détection de redirection selon le navigateur

Dans ce premier exemple, nous écrirons du code capable de détecter Redirections d'URL basé sur divers paramètres navigateur. Par exemple, certains sites Web redirigent les navigateurs d’un téléphone portable ou de tout autre appareil.

Nous allons utiliser l'option CURLOPT_HTTPHEADER pour définir nos en-têtes HTTP sortants, y compris le nom du navigateur de l'utilisateur et langues disponibles. À terme, nous pourrons déterminer quels sites nous redirigent vers différentes URL.

// teste l'URL $urls = array("http://www.cnn.com", "http://www.mozilla.com", "http://www.facebook.com"); // test des navigateurs $browsers = array("standard" => array ("user_agent" => "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.6) Gecko/20091201 Firefox/3.5 .6 (.NET CLR 3.5.30729)", "langue" => "en-us,en;q=0.5"), "iphone" => tableau ("user_agent" => "Mozilla/5.0 (iPhone; U ; CPU comme Mac OS X; fr) AppleWebKit/420+ (KHTML, comme Gecko) Version/3.0 Mobile/1A537a Safari/419.3", "langue" => "fr"), "french" => tableau ("user_agent" => "Mozilla/4.0 (compatible ; MSIE 7.0 ; Windows NT 5.1 ; GTB6 ; .NET CLR 2.0.50727)", "langue" => "fr,fr-FR;q=0.5")); foreach ($urls as $url) ( echo "URL: $url\n"; foreach ($browsers as $test_name => $browser) ( $ch = curl_init(); // spécifie l'url curl_setopt($ch, CURLOPT_URL , $url); // spécifie les en-têtes du navigateur curl_setopt($ch, CURLOPT_HTTPHEADER, array("User-Agent: ($browser["user_agent"])", "Accept-Language: ($browser["langue"] )" )); // nous n'avons pas besoin du contenu de la page curl_setopt($ch, CURLOPT_NOBODY, 1); // nous devons obtenir les en-têtes HTTP curl_setopt($ch, CURLOPT_HEADER, 1); // renvoie les résultats au lieu de la sortie curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); $output = curl_exec($ch); curl_close($ch); // y a-t-il eu une redirection HTTP if (preg_match("!Location: (.*)!", $output , $matches) ( echo " $nom_test : redirige vers $matches\n"; ) else ( echo "$nom_test : pas de redirection\n"; ) ) echo "\n\n" )

Tout d'abord, nous spécifions une liste d'URL de sites que nous allons vérifier. Plus précisément, nous avons besoin des adresses de ces sites. Nous devons ensuite définir les paramètres du navigateur pour tester chacune de ces URL. Après cela, nous utiliserons une boucle dans laquelle nous passerons en revue tous les résultats obtenus.

L'astuce que nous utilisons dans cet exemple pour définir les paramètres cURL nous permettra d'obtenir non pas le contenu de la page, mais uniquement les en-têtes HTTP (stockés dans $output). Ensuite, à l'aide d'une simple expression régulière, nous pouvons déterminer si la chaîne « Location : » était présente dans les en-têtes reçus.

Quand tu cours ce code, vous devriez obtenir quelque chose comme le résultat suivant :

Création d'une requête POST vers une URL spécifique

Lors de la formation Requête OBTENIR Les données transmises peuvent être transmises à l'URL via une « chaîne de requête ». Par exemple, lorsque vous effectuez une recherche Google, le terme de recherche est placé dans la barre d'adresse de la nouvelle URL :

Http://www.google.com/search?q=ruseller

Afin de simuler cette demande, vous n'avez pas besoin d'utiliser les fonctionnalités cURL. Si la paresse vous envahit complètement, utilisez la fonction « file_get_contents() » pour obtenir le résultat.

Mais le fait est que certains formulaires HTML envoient des requêtes POST. Les données de ces formulaires sont transportées via le corps de la requête HTTP, et non comme dans le cas précédent. Par exemple, si vous avez rempli un formulaire sur un forum et cliqué sur le bouton de recherche, il est fort probable qu'une requête POST soit effectuée :

Http://codeigniter.com/forums/do_search/

Nous pouvons écrire Script PHP, qui peut simuler ce type d'URL de requête. Créons d'abord un fichier simple à accepter et à afficher Données POST. Appelons-le post_output.php :

Print_r($_POST);

Ensuite nous créons un script PHP pour faire la requête cURL :

$url = "http://localhost/post_output.php"; $post_data = array ("foo" => "bar", "query" => "Nettuts", "action" => "Submit"); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // indique que nous avons une requête POST curl_setopt($ch, CURLOPT_POST, 1); // ajoute des variables curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data); $output = curl_exec($ch); curl_close($ch); écho $sortie ;

Lorsque vous exécutez ce script, vous devriez obtenir un résultat comme celui-ci :

Ainsi, la requête POST a été envoyée au script post_output.php, qui à son tour génère le tableau superglobal $_POST, dont nous avons obtenu le contenu à l'aide de cURL.

Télécharger un fichier

Tout d'abord, créons un fichier afin de le générer et envoyons-le dans le fichier upload_output.php :

Print_r($_FILES);

Et voici le code du script qui exécute la fonctionnalité ci-dessus :

$url = "http://localhost/upload_output.php"; $post_data = array ("foo" => "bar", // fichier à télécharger "upload" => "@C:/wamp/www/test.zip"); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data); $output = curl_exec($ch); curl_close($ch); écho $sortie ;

Lorsque vous souhaitez télécharger un fichier, il vous suffit de le transmettre comme variable de publication normale, précédée d'un symbole @. Lorsque vous exécutez le script écrit, vous obtiendrez le résultat suivant :

Boucle multiple

L'une des plus grandes forces de cURL est la possibilité de créer "plusieurs" gestionnaires cURL. Cela vous permet d'ouvrir une connexion à plusieurs URL simultanément et de manière asynchrone.

DANS version classique La requête cURL suspend l'exécution du script et attend la fin de l'opération d'URL de requête avant que le script puisse continuer à s'exécuter. Si vous avez l'intention d'interagir avec tout un tas d'URL, cela entraînera un investissement de temps assez important, puisque dans la version classique, vous ne pouvez travailler qu'avec une seule URL à la fois. Cependant, nous pouvons le réparer cette situation, à l'aide de gestionnaires spéciaux.

Regardons l'exemple de code que j'ai extrait de php.net :

// crée plusieurs ressources cURL $ch1 = curl_init(); $ch2 = curl_init(); // spécifie l'URL et les autres paramètres curl_setopt($ch1, CURLOPT_URL, "http://lxr.php.net/"); curl_setopt($ch1, CURLOPT_HEADER, 0); curl_setopt($ch2, CURLOPT_URL, "http://www.php.net/"); curl_setopt($ch2, CURLOPT_HEADER, 0); //crée un gestionnaire cURL multiple $mh = curl_multi_init(); //ajoute plusieurs gestionnaires curl_multi_add_handle($mh,$ch1); curl_multi_add_handle($mh,$ch2); $actif = nul ; //exécuter do ( $mrc = curl_multi_exec($mh, $active); ) while ($mrc == CURLM_CALL_MULTI_PERFORM); while ($active && $mrc == CURLM_OK) ( if (curl_multi_select($mh) != -1) ( do ( $mrc = curl_multi_exec($mh, $active); ) while ($mrc == CURLM_CALL_MULTI_PERFORM); ) ) //fermeture curl_multi_remove_handle($mh, $ch1); curl_multi_remove_handle($mh, $ch2); curl_multi_close($mh);

L'idée est que vous pouvez utiliser plusieurs gestionnaires cURL. À l’aide d’une simple boucle, vous pouvez suivre les demandes qui ne sont pas encore terminées.

Il y a deux boucles principales dans cet exemple. D'abord faire une boucle en attendant appelle la fonction curl_multi_exec(). Cette fonction n'est pas bloquable. Il s'exécute aussi vite que possible et renvoie l'état de la demande. Tant que la valeur renvoyée est la constante 'CURLM_CALL_MULTI_PERFORM', cela signifie que le travail n'est pas encore terminé (par exemple, il est en cours d'envoi en-têtes http dans l'URL); C'est pourquoi nous continuons à vérifier cette valeur de retour jusqu'à ce que nous obtenions un résultat différent.

Dans la boucle suivante, nous vérifions la condition tandis que la variable $active = "true". C'est le deuxième paramètre de la fonction curl_multi_exec(). La valeur de cette variable sera "true" tant que l'une des modifications existantes sera active. Ensuite, nous appelons la fonction curl_multi_select(). Son exécution est « bloquée » alors qu'il existe au moins un connexion active, jusqu'à ce qu'une réponse soit reçue. Lorsque cela se produit, nous retournons à la boucle principale pour continuer à exécuter les requêtes.

Appliquons maintenant ce que nous avons appris à un exemple qui sera très utile pour grande quantité personnes.

Vérification des liens dans WordPress

Imaginez un blog avec une somme énorme publications et messages, dont chacun contient des liens vers Internet externe ressources. Certains de ces liens peuvent déjà être morts pour diverses raisons. La page a peut-être été supprimée ou le site ne fonctionne pas du tout.

Nous allons créer un script qui analysera tous les liens et trouvera des sites Web qui ne se chargent pas et des pages 404, puis nous fournira un rapport détaillé.

Laissez-moi dire tout de suite qu'il ne s'agit pas d'un exemple de création d'un plugin pour WordPress. C'est absolument un bon terrain d'essai pour nos tests.

Commençons enfin. Nous devons d’abord récupérer tous les liens de la base de données :

// configuration $db_host = "localhost"; $db_user = "racine" ; $db_pass = ""; $db_name = "wordpress" ; $exclus_domains = array("localhost", "www.mydomain.com"); $max_connexions = 10 ; // initialisation des variables $url_list = array(); $working_urls = tableau(); $dead_urls = tableau(); $not_found_urls = tableau(); $actif = nul ; // se connecte à MySQL if (!mysql_connect($db_host, $db_user, $db_pass)) ( die("Impossible de se connecter : " . mysql_error()); ) if (!mysql_select_db($db_name)) ( die("Pourrait not select db: " . mysql_error()); ) // sélectionne tous les articles publiés avec des liens $q = "SELECT post_content FROM wp_posts WHERE post_content LIKE "%href=%" AND post_status = "publish" AND post_type = "post "" ; $r = mysql_query($q) ou die(mysql_error()); while ($d = mysql_fetch_assoc($r)) ( // récupère les liens à l'aide d'expressions régulières if (preg_match_all("!href=\"(.*?)\"!", $d["post_content"], $ matches) ) ( foreach ($correspond à $url) ( $tmp = parse_url($url); if (in_array($tmp["host"], $exclus_domains)) ( continue; ) $url_list = $url; ) ) ) / / supprimer les doublons $url_list = array_values(array_unique($url_list)); if (!$url_list) ( die("Aucune URL à vérifier"); )

Tout d'abord, nous générons des données de configuration pour l'interaction avec la base de données, puis nous écrivons une liste de domaines qui ne participeront pas au contrôle ($exclusive_domains). Nous définissons également un nombre caractérisant le nombre maximum de connexions simultanées que nous utiliserons dans notre script ($max_connections). Nous rejoignons ensuite la base de données, sélectionnons les publications contenant des liens et les accumulons dans un tableau ($url_list).

Le code suivant est un peu compliqué, alors parcourez-le du début à la fin :

// 1. gestionnaire multiple $mh = curl_multi_init(); // 2. ajoute un ensemble d'URL pour ($i = 0; $i< $max_connections; $i++) { add_url_to_multi_handle($mh, $url_list); } // 3. инициализация выполнения do { $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); // 4. основной цикл while ($active && $mrc == CURLM_OK) { // 5. если всё прошло успешно if (curl_multi_select($mh) != -1) { // 6. делаем дело do { $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); // 7. если есть инфа? if ($mhinfo = curl_multi_info_read($mh)) { // это значит, что запрос завершился // 8. извлекаем инфу $chinfo = curl_getinfo($mhinfo["handle"]); // 9. мёртвая ссылка? if (!$chinfo["http_code"]) { $dead_urls = $chinfo["url"]; // 10. 404? } else if ($chinfo["http_code"] == 404) { $not_found_urls = $chinfo["url"]; // 11. рабочая } else { $working_urls = $chinfo["url"]; } // 12. чистим за собой curl_multi_remove_handle($mh, $mhinfo["handle"]); // в случае зацикливания, закомментируйте cet appel curl_close($mhinfo["handle"]);

// 13. ajoutez une nouvelle URL et continuez à travailler if (add_url_to_multi_handle($mh, $url_list)) ( do ( $mrc = curl_multi_exec($mh, $active); ) while ($mrc == CURLM_CALL_MULTI_PERFORM); ) ) ) ) // 14. achèvement curl_multi_close($mh); echo "==URL mortes==\n"; echo implode("\n",$dead_urls) . "\n\n" ; echo "==404 URL==\n"; echo implode("\n",$not_found_urls) . "\n\n" ; echo "==URL de travail==\n"; echo implode("\n",$working_urls); function add_url_to_multi_handle($mh, $url_list) ( static $index = 0; // si nous avons plus d'URL à récupérer if ($url_list[$index]) ( // nouveau gestionnaire de boucles $ch = curl_init(); // spécifie l'url curl_setopt($ch, CURLOPT_URL, $url_list[$index]); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); $mh, $ch); // va à l'url suivante $index++; return true else ( // l'ajout de nouvelles URL est terminé return false; ) )

Ici, je vais essayer de tout expliquer en détail. Les numéros dans la liste correspondent aux numéros dans le commentaire.
1. Créez un gestionnaire multiple ;
2. Nous écrirons la fonction add_url_to_multi_handle() un peu plus tard. À chaque appel, le traitement d'une nouvelle URL commencera. Initialement, nous ajoutons 10 URL ($max_connections) ;
3. Pour commencer, nous devons exécuter la fonction curl_multi_exec(). Tant qu'il renvoie CURLM_CALL_MULTI_PERFORM, nous avons encore quelque chose à faire. Nous en avons besoin principalement pour créer des liens ;
4. Vient ensuite la boucle principale, qui fonctionnera tant que nous aurons au moins une connexion active ;
5. curl_multi_select() se bloque en attendant la fin de la recherche d'URL ;
6. Encore une fois, nous devons demander à cURL de faire un certain travail, à savoir récupérer les données de réponse de retour ;
7. Les informations sont vérifiées ici. À la suite de l'exécution de la requête, un tableau sera renvoyé ;
8. Le tableau renvoyé contient un gestionnaire cURL. Nous l'utiliserons pour sélectionner des informations sur une requête cURL distincte ;
9. Si le lien était mort ou si le script avait expiré, nous ne devrions alors rechercher aucun code http ;
10. Si le lien nous renvoie une page 404, alors le code http contiendra la valeur 404 ; 11. Sinon, nous avons devant nous lien de travail . (Vous pouvez ajouter contrôles supplémentaires
12. Ensuite, nous supprimons le gestionnaire cURL car nous n'en avons plus besoin ;
13. Nous pouvons maintenant ajouter une autre URL et exécuter tout ce dont nous avons parlé précédemment ;
14. A cette étape, le script termine son travail. Nous pouvons supprimer tout ce dont nous n’avons pas besoin et générer un rapport ;
15. Enfin, nous écrirons une fonction qui ajoutera l'url au gestionnaire. La variable statique $index sera incrémentée à chaque fois cette fonction sera appelé.

j'ai utilisé ce scénario sur mon blog (avec quelques liens brisés, que j'ai ajoutés exprès afin de tester son fonctionnement) et j'ai obtenu le résultat suivant :

Dans mon cas, le script a mis un peu moins de 2 secondes pour parcourir 40 URL. L'augmentation de la productivité est significative lorsque l'on travaille avec plus un grand nombre Adresses URL. Si vous ouvrez dix connexions en même temps, le script peut s'exécuter dix fois plus rapidement.

Quelques mots sur d'autres options cURL utiles

Authentification HTTP

Si allumé Adresse URL Il y a Authentification HTTP, alors vous pouvez facilement utiliser le script suivant :

$url = "http://www.somesite.com/members/"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // spécifie le nom d'utilisateur et le mot de passe curl_setopt($ch, CURLOPT_USERPWD, "myusername:mypassword"); // si la redirection est autorisée curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); // puis sauvegardez nos données dans cURL curl_setopt($ch, CURLOPT_UNRESTRICTED_AUTH, 1); $output = curl_exec($ch); curl_close($ch);

Téléchargement FTP

PHP dispose également d'une bibliothèque pour travailler avec FTP, mais rien ne vous empêche d'utiliser les outils cURL ici :

// ouvre le fichier $file = fopen("/path/to/file", "r"); // l'url doit contenir le contenu suivant $url = "ftp://username : [email protégé]:21/chemin/vers/nouveau/fichier"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_UPLOAD, 1); curl_setopt($ch, CURLOPT_INFILE, $fp); curl_setopt($ch, CURLOPT_INFILESIZE, filesize("/path/to/file")); // spécifie le mode ASCII curl_setopt($ch, CURLOPT_FTPASCII, 1); ); curl_close($ch);

Utiliser un proxy

Vous pouvez effectuer votre demande d'URL via un proxy :

$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://www.example.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // spécifie l'adresse curl_setopt($ch, CURLOPT_PROXY, "11.11.11.11:8080"); // si vous devez fournir un nom d'utilisateur et un mot de passe curl_setopt($ch, CURLOPT_PROXYUSERPWD,"user:pass"); $output = curl_exec($ch); curl_close($ch);

Fonctions de rappel

Il est également possible de spécifier une fonction qui sera déclenchée avant la fin cURL fonctionne demande. Par exemple, pendant le chargement du contenu de la réponse, vous pouvez commencer à utiliser les données sans attendre qu'elles soient complètement chargées.

$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://net.tutsplus.com"); curl_setopt($ch, CURLOPT_WRITEFUNCTION,"progress_function"); curl_exec($ch); curl_close($ch); function progress_function($ch,$str) ( echo $str; return strlen($str); )

Une fonction comme celle-ci DOIT renvoyer la longueur de la chaîne, ce qui est une exigence.

Conclusion

Aujourd'hui, nous avons appris comment utiliser la bibliothèque cURL dans votre à des fins égoïstes. J'espère que vous avez apprécié cet article.

Merci! Passe une bonne journée!

Dans cet article, je vais montrer avec des exemples comment utiliser cURL, où il est utilisé et pourquoi vous devez le comprendre si vous ne l'avez pas déjà fait.

Je vais décrire brièvement ce que c'est et avec quoi on le mange :

Guzzle a été créé pour simplifier le processus d'envoi de requêtes HTTP. Souvent utilisé pour envoyer des demandes à API et n'importe quoi en général.

Exemple réel :

Vous disposez d'une API que vous avez récemment développée et il est temps de commencer à l'utiliser. Vous pourriez écrire votre propre bibliothèque ou même une mini-classe pour travailler avec, mais (1) cela vous prendrait beaucoup de temps, et même si ce n'était pas le cas, la solution ne serait probablement pas la meilleure ( 2) il doit être constamment soutenu et amélioré. Dans ce cas, il vaut mieux utiliser solution toute faite, qui est soutenu par une large communauté et le référentiel Guzzle compte déjà 12 000 étoiles, ce qui est très louable.

Vous vous demandez peut-être : pourquoi est-ce nécessaire s’il existe déjà un grand nombre de bibliothèques ?

Guzzle a rassemblé tout le meilleur en lui-même, l'a rendu encore meilleur et c'est maintenant le plus populaire Bibliothèque PHP travailler avec Requêtes HTTP. C'est vraiment cool, il suffit de regarder la simplicité de la requête :

// Crée un client avec un URI de base $client = new GuzzleHttp\Client(["base_uri" => "http://site/"]); // Vous pouvez maintenant envoyer une requête à http://bologe.. Guzzle se souvient du lien de base et vous ne pouvez désormais spécifier que les pages suivantes pour plus de commodité $response = $client->request("GET", "about");

Cool? J'aime vraiment ça.

La documentation de Guzzle est assez complète, il est impossible de décrire toutes les options, et cela nécessite un article entier, que j'écrirai certainement bientôt :)

Épilogue

Si vous avez des questions, écrivez-les ci-dessous dans cet article et je me ferai un plaisir de vous aider. De plus, si vous avez des corrections à apporter à l'article et que vous avez vu une erreur quelque part ou si vous souhaitez ajouter quelque chose, je serai heureux de vous écouter.

Ce logiciel, composé d'un utilitaire de ligne de commande et d'une bibliothèque, conçu pour transférer des données via divers protocoles (HTTP, FTP, POP3, IMAP, SMTP et bien d'autres). Nous examinerons uniquement l'utilitaire de ligne de commande, dont nous écrirons "curl" comme nom. Les compétences acquises en l'utilisant permettent de maîtriser facilement le travail avec la bibliothèque libcurl. De plus, nous nous limiterons à la formation de requêtes HTTP : GET et POST.

Informations préliminaires

Protocole HTTP

HTTP est un protocole utilisé lors de l'échange de données entre un serveur Web et un programme client (tel qu'un navigateur). Il se compose de chaînes de texte ASCII envoyées du client au serveur pour demander une action. Lorsqu'une demande est reçue, le serveur répond au client avec plusieurs lignes de texte de service, puis fournit le contenu demandé.

En utilisant le commutateur -v, vous pouvez voir exactement quelles commandes curl envoie au serveur. Cette clé permet de comprendre les particularités de l'interaction entre curl et le serveur web et aide au débogage de la requête.

URL

URL (Uniform Resource Locator) spécifie l'adresse d'une ressource spécifique sur Internet. Par exemple, l'URL d'une page Web cURL s'écrit comme ceci : http://curl.haxx.se.

Formulaires

Les formulaires sont des ensembles de champs placés sur une page Web. L'utilisateur saisit des données dans ces champs, puis clique sur le bouton « OK » ou « Soumettre », après quoi les données sont envoyées au serveur. Le serveur reçoit les données et décide quoi faire ensuite : s'il faut rechercher des informations dans la base de données, afficher l'adresse saisie sur une carte ou utiliser les informations pour authentifier l'utilisateur. Bien sûr, « décide » signifie que du côté du serveur, il doit y avoir une sorte de programme qui reçoit et traite les données envoyées. L'exemple le plus simple: Formulaire de requête de recherche Google.

Référence

L'aide pour curl peut être obtenue en tapant ligne de commande

$ - invite de ligne de commande.

Obtenir le contenu de la page (GET)

La requête HTTP la plus simple et la plus courante consiste à obtenir le contenu d'une URL donnée. L'URL peut faire référence à une page Web, une image ou un autre fichier. Le client envoie une requête GET au serveur et reçoit le document demandé. Si vous exécutez la commande

$ curl http://curl.haxx.se

vous obtiendrez la sortie de la page Web vers la fenêtre du terminal (plus précisément, vers la sortie standard). Pour enregistrer cette page dans le fichier curl.html, vous devez spécifier

$ curl http://curl.haxx.se -o "curl.html"

Toutes les réponses HTTP contiennent un ensemble d'en-têtes généralement masqués. Pour voir ces en-têtes ainsi que le document lui-même, utilisez le commutateur -i.

Envoyer une requête GET à partir d'un formulaire

Le formulaire de demande peut utiliser la méthode GET. Par exemple, comme ceci :

Si vous ouvrez ce code dans un navigateur, vous verrez un formulaire avec un champ de texte et un bouton intitulé « OK ». Si, par exemple, vous saisissez « 1990 » dans le formulaire et cliquez sur « OK », le navigateur créera une nouvelle URL qu'il suivra. Cette URL sera une chaîne composée de l'URL précédente et d'une chaîne de requête comme celle-ci : foo.cgi?year=1990&press=OK . Ainsi, si le formulaire se trouvait à l'adresse www.foo.com/year.html (l'adresse a été prise « de nulle part » !), alors lorsque vous cliquez sur le bouton « OK », vous serez redirigé vers l'URL www.foo.com/foo.cgi?year= 1990&press=OK .

Pour générer une requête GET, saisissez ce qui était attendu du formulaire :

$ boucler "www.foo.com/foo.cgi?year=1990&press=OK"

Méthode POST

La méthode GET provoque l'affichage de toutes les informations saisies dans la barre d'adresse du navigateur. Ce n'est évidemment pas le plus meilleure façon dans les cas où vous devez envoyer des données confidentielles ou lorsque la quantité d'informations saisies est très importante. Pour résoudre ce problème Protocole HTTP fournit à l'utilisateur une autre méthode - POST. Avec lui, le client envoie des données séparément de l'URL et vous ne les verrez donc pas dans la barre d'adresse du navigateur.

Le formulaire générant la requête POST ne diffère du précédent que par le mode d'envoi :

curl générera une requête POST avec les mêmes données comme suit :

$ curl -d "année=1990&press=%20OK%20" www.foo.com/foo.cgi

Veuillez noter que les données que vous envoyez au serveur doivent être correctement codées. curl ne fera pas ça pour vous. Par exemple, si vous souhaitez que les données contiennent un espace, vous devez alors remplacer cet espace par %20, etc. Il s'agit de l'une des erreurs les plus courantes, à la suite de laquelle les données ne sont pas transférées comme prévu.

Téléchargement de fichiers à l'aide de POST

Le formulaire où l'utilisateur peut télécharger un fichier ressemble à ceci :

Notez que le Content-Type est défini sur multipart/form-data .

Pour envoyer des données à ce formulaire à l'aide de curl, saisissez :

$ curl -F upload = @localfilename -F press = OK [URL de la page du formulaire]

Champs de formulaire masqués

Les champs masqués dans les formulaires sont l'un des moyens les plus courants de transmettre des informations sur l'état d'une application HTML. Ces champs ne sont pas remplis, ils sont invisibles pour l'utilisateur, mais sont transmis de la même manière que les champs normaux.

Exemple de formulaire avec un champ visible et un champ masqué :

Pour envoyer une requête POST avec curl, vous n'avez pas à vous soucier de savoir si un champ est masqué ou non - pour curl, tous les champs sont identiques :

$ boucle -d "année=1990&press=OK&person=daniel"[URL]

À quoi ressemble une requête POST de l’intérieur ?

Lorsque vous remplissez un formulaire à l'aide de curl et que vous l'envoyez au serveur, vous souhaitez probablement que la requête POST générée par curl ait la même apparence que si elle avait été effectuée à l'aide d'un navigateur.

La façon la plus simple de voir votre requête POST est la suivante :

enregistrez la page Web avec le formulaire sur le disque ;
changez la méthode en GET ;
cliquez sur le bouton « Soumettre » (vous pouvez également modifier l'URL à laquelle les données seront envoyées).

Verrez-vous les données ajoutées à l’URL et séparées par des caractères ? , comme on peut s'y attendre lors de l'utilisation de formulaires GET.