cURL est un outil qui utilise la syntaxe URL pour transférer des fichiers et des données. Il prend en charge de nombreux protocoles, tels que HTTP, FTP, TELNET, etc. La meilleure chose est que PHP prend également en charge la bibliothèque cURL. Cet article présentera quelques fonctionnalités avancées de cURL et comment l'utiliser en PHP.
Pourquoi utiliser cURL ?
Oui, nous pouvons obtenir du contenu Web par d’autres méthodes. La plupart du temps, parce que je veux être paresseux, j'utilise simplement une simple fonction php :
$content = file_get_contents(" http://www.bizhicool.com ");
// ou
$lines = file(" http://www.bizhicool.com ");
// ou
readfile( http://www.bizhicool.com ); Cependant, cette approche manque de flexibilité et de gestion efficace des erreurs. De plus, vous ne pouvez pas l'utiliser pour effectuer certaines tâches difficiles, telles que la gestion des cookies, la validation, la soumission de formulaires, le téléchargement de fichiers, etc.
cURL est une bibliothèque puissante qui prend en charge de nombreux protocoles et options différents et peut fournir divers détails liés aux requêtes URL.
Structure de base Avant d'en apprendre davantage sur des fonctions plus complexes, examinons les étapes de base de la configuration d'une requête cURL en PHP :
Initialiser, définir des variables, exécuter et obtenir des résultats, libérer le handle cURL
// 1. Initialisation
$ch = curl_init();
// 2. Définir les options, y compris l'URL
curl_setopt($ch, CURLOPT_URL, " http://www.bizhicool.com ");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HEADER, 0);
// 3. Exécuter et obtenir le contenu du document HTML
$output = curl_exec($ch);
// 4. Relâchez la poignée curl
curl_close($ch); La deuxième étape (c'est-à-dire curl_setopt()) est la plus importante, et tout le mystère réside ici. Il existe une longue liste de paramètres cURL pouvant être définis et spécifiant divers détails de la demande d'URL. Il peut être difficile de les lire et de les comprendre tous en même temps, c'est pourquoi nous n'essaierons aujourd'hui que les options les plus courantes et les plus utiles.
Recherche d'erreurs Vous pouvez ajouter une instruction pour vérifier les erreurs (bien que cela ne soit pas obligatoire) :
//...
$output = curl_exec($ch);
si ($output === FALSE) {
echo "Erreur cURL : " curl_error($ch);
}
// ...Veuillez noter que nous utilisons "=== FALSE" au lieu de "== FALSE" lors de la comparaison. Parce qu'il faut faire la distinction entre la sortie vide et la valeur booléenne FALSE, qui est la vraie erreur.
Obtenir des informations Il s'agit d'un autre paramètre facultatif qui peut obtenir des informations sur cette requête après l'exécution de cURL :
//...
curl_exec($ch);
$info = curl_getinfo($ch);
echo 'Obtenir' $info['url'] 'Cela prend du temps' $info['total_time'] 'Secondes';
// ...le tableau renvoyé inclut les informations suivantes :
"url" //Adresse réseau de la ressource
"content_type" //Encodage du contenu
"http_code" //Code d'état HTTP
"header_size" //La taille de l'en-tête
"request_size" //Taille de la requête
"filetime" //Heure de création du fichier
"ssl_verify_result" //Résultat de la vérification SSL
"redirect_count" //Technologie Jump
"total_time" //Temps total pris
"namelookup_time" //Heure de la requête DNS
"connect_time" //Attente de l'heure de connexion
"pretransfer_time" //Le temps de préparation avant transmission
"size_upload" //La taille des données téléchargées
"size_download" //La taille des données téléchargées
"speed_download" //Vitesse de téléchargement
"speed_upload" //Vitesse de téléchargement
"download_content_length" //La longueur du contenu téléchargé
"upload_content_length" //La longueur du contenu téléchargé
"starttransfer_time" //Heure de début du transfert
"redirect_time" //La redirection prend du temps Redirection basée sur le navigateur Dans le premier exemple, nous fournirons un morceau de code qui détecte si le serveur dispose d'une redirection basée sur le navigateur. Par exemple, certains sites Web redirigent les pages Web selon qu'il s'agit d'un navigateur mobile ou même du pays d'origine de l'utilisateur.
Nous utilisons l'option CURLOPT_HTTPHEADER pour définir les en-têtes de requête HTTP que nous envoyons (en-têtes http), y compris les informations sur l'agent utilisateur et la langue par défaut. Nous verrons ensuite si ces sites Web spécifiques nous redirigent vers des URL différentes.
// URL pour tester
$urls = tableau(
" http://www.cnn.com ",
" http://www.mozilla.com ",
" http://www.facebook.com "
);
// Informations sur le navigateur pour les tests
$navigateurs = tableau(
"standard" => tableau (
"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"
),
"français" => 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 comme $url) {
echo "URL : $urln" ;
foreach ($browsers as $test_name => $browser) {
$ch = curl_init();
//Définir l'URL
curl_setopt($ch, CURLOPT_URL, $url);
//Définir les en-têtes spécifiques au navigateur
curl_setopt($ch, CURLOPT_HTTPEADER, tableau(
"Agent utilisateur : {$browser['user_agent']}",
"Accepter-Langue : {$browser['langue']}"
));
// Nous n'avons pas besoin du contenu de la page
curl_setopt($ch, CURLOPT_NOBODY, 1);
// Renvoie simplement l'en-tête HTTP
curl_setopt($ch, CURLOPT_HEADER, 1);
// Renvoie le résultat au lieu de l'imprimer
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$output = curl_exec($ch);
curl_close($ch);
// Existe-t-il des informations d'en-tête HTTP pour la redirection ?
if (preg_match("!Location: (.*)!", $output, $matches)) {
echo "$test_name : redirige vers $matches[1]n" ;
} autre {
echo "$nom_test : pas de redirectionn" ;
}
}
écho "nn" ;
}Tout d'abord, nous créons un ensemble d'URL qui doivent être testées, puis nous spécifions un ensemble d'informations sur le navigateur qui doivent être testées. Enfin, une boucle est utilisée pour tester diverses situations de correspondance d'URL et de navigateur qui peuvent survenir.
Étant donné que nous avons spécifié l'option cURL, la sortie renvoyée inclut uniquement les informations d'en-tête HTTP (stockées dans $output). À l'aide d'une règle simple et régulière, nous vérifions si les informations d'en-tête contiennent le mot « Localisation : ».
L'exécution de ce code devrait renvoyer les résultats suivants :
Envoi de données à l'aide de la méthode POST Lors d'une requête GET, les données peuvent être transmises à une URL via une « chaîne de requête ». Par exemple, lors d'une recherche dans Google, la clé de recherche fait partie de la chaîne de requête de l'URL :
http://www.google.com/search?q=nettuts Dans ce cas, vous n'avez probablement pas besoin de cURL pour simuler. Lancer cette URL vers "file_get_contents()" obtiendra le même résultat.
Cependant, certains formulaires HTML sont soumis à l'aide de la méthode POST. Lorsque ce formulaire est soumis, les données sont envoyées via le corps de la requête HTTP (corps de la requête) au lieu de la chaîne de requête. Par exemple, lorsque vous utilisez le formulaire du forum CodeIgniter, quels que soient les mots-clés que vous saisissez, vous serez toujours POSTÉ sur la page suivante :
http://codeigniter.com/forums/do_search/ Vous pouvez utiliser un script PHP pour simuler cette requête URL. Tout d'abord, créez un nouveau fichier capable d'accepter et d'afficher les données POST. Nous le nommons post_output.php :
print_r($_POST); Ensuite, écrivez un script PHP pour exécuter la requête cURL :
$url = " http://localhost/post_output.php ";
$post_data = tableau (
"foo" => "bar",
"requête" => "Nettuts",
"action" => "Soumettre"
);
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
// Nous publions des données !
curl_setopt($ch, CURLOPT_POST, 1);
//Ajouter la variable de publication
curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data);
$output = curl_exec($ch);
curl_close($ch);
echo $output;Après avoir exécuté le code, vous devriez obtenir les résultats suivants :
Ce script envoie une requête POST à post_output.php, la variable $_POST de la page et la renvoie. Nous capturons cette sortie en utilisant cURL.
Téléchargement de fichiers Le téléchargement de fichiers est très similaire au POST précédent. Parce que tous les formulaires de téléchargement de fichiers sont soumis via la méthode POST.
Tout d'abord, créez une nouvelle page pour recevoir les fichiers, nommée upload_output.php :
print_r($_FILES);Voici le script qui effectue réellement la tâche de téléchargement de fichier :
$url = " http://localhost/upload_output.php ";
$post_data = tableau (
"foo" => "bar",
//L'adresse du fichier local à 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);
echo $output; Si vous devez télécharger un fichier, transmettez simplement le chemin du fichier comme une variable de publication, mais n'oubliez pas d'ajouter le symbole @ devant. L'exécution de ce script devrait donner le résultat suivant :
Traitement par lots cURL (multi cURL)
cURL dispose également d'une fonctionnalité avancée : les poignées de lots. Cette fonctionnalité vous permet d'ouvrir plusieurs connexions URL simultanément ou de manière asynchrone.
Voici un exemple de code de php.net :
//Créer deux ressources cURL
$ch1 = curl_init();
$ch2 = curl_init();
//Spécifiez l'URL et les paramètres appropriés
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éer un handle de lot cURL
$mh = curl_multi_init();
//Ajoute les deux premiers handles de ressources
curl_multi_add_handle($mh,$ch1);
curl_multi_add_handle($mh,$ch2);
// Prédéfinir une variable d'état
$actif = nul ;
//Exécuter le traitement par lots
faire {
$mrc = curl_multi_exec($mh, $active);
} while ($mrc == CURLM_CALL_MULTI_PERFORM);
while ($active && $mrc == CURLM_OK) {
if (curl_multi_select($mh) != -1) {
faire {
$mrc = curl_multi_exec($mh, $active);
} while ($mrc == CURLM_CALL_MULTI_PERFORM);
}
}
//Ferme chaque poignée
curl_multi_remove_handle($mh, $ch1);
curl_multi_remove_handle($mh, $ch2);
curl_multi_close($mh); Ce que vous devez faire ici est d'ouvrir plusieurs handles cURL et de les attribuer à un handle de lot. Ensuite, vous attendez simplement dans une boucle while que cela se termine.
Il y a deux boucles principales dans cet exemple. La première boucle do-while appelle curl_multi_exec() à plusieurs reprises. Cette fonction est non bloquante mais sera exécutée le moins possible. Il renvoie une valeur de statut Tant que cette valeur est égale à la constante CURLM_CALL_MULTI_PERFORM, cela signifie qu'il reste encore du travail urgent à faire (par exemple, envoyer les informations d'en-tête http correspondant à l'URL). Autrement dit, nous devons continuer à appeler cette fonction jusqu'à ce que la valeur de retour change.
La boucle while suivante ne continuera que lorsque la variable $active est vraie. Cette variable a été précédemment transmise à curl_multi_exec() comme deuxième paramètre et indique s'il existe encore des connexions actives dans le descripteur de lots. Ensuite, nous appelons curl_multi_select(), qui est "bloqué" jusqu'à ce qu'une connexion active (comme la réception d'une réponse du serveur) se produise. Une fois cette fonction exécutée avec succès, nous entrerons dans une autre boucle do-while et passerons à l'URL suivante.
Voyons comment mettre cette fonctionnalité en pratique :
WordPress Connection Checker Imaginez que vous ayez un blog avec un grand nombre d'articles contenant un grand nombre de liens vers des sites Web externes. Au bout d’un certain temps, bon nombre de ces liens sont devenus invalides pour une raison ou une autre. Soit il a été harmonisé, soit tout le site a été piraté...
Créons un script ci-dessous pour analyser tous ces liens, découvrir les sites Web/pages Web qui ne peuvent pas être ouverts ou qui ont 404, et générons un rapport.
Veuillez noter que ce qui suit n'est pas un plug-in WordPress réellement fonctionnel, c'est juste un script avec des fonctions indépendantes, à titre de démonstration uniquement, merci.
OK, commençons. Tout d’abord, lisez tous ces liens de la base de données :
//CONFIG.
$db_host = 'localhost';
$db_user = 'racine' ;
$db_pass = '';
$db_name = 'wordpress' ;
$domaines_exclus = tableau(
'localhost', 'www.mondomaine.com');
$max_connexions = 10 ;
//Initialiser certaines variables
$url_list = tableau();
$working_urls = tableau();
$dead_urls = tableau();
$not_found_urls = tableau();
$actif = nul ;
// Connectez-vous à MySQL
if (!mysql_connect($db_host, $db_user, $db_pass)) {
die('Impossible de se connecter : ' . mysql_error());
}
si (!mysql_select_db($db_name)) {
die('Impossible de sélectionner la base de données : ' . mysql_error());
}
// Retrouver tous les articles avec liens
$q = "SÉLECTIONNER post_content FROM wp_posts
OÙ post_content LIKE '%href=%'
ET post_status = 'publier'
ET post_type = 'post'" ;
$r = mysql_query($q) ou die(mysql_error());
tandis que ($d = mysql_fetch_assoc($r)) {
// Utiliser des liens correspondants réguliers
if (preg_match_all("!href="(.*?)"!", $d['post_content'], $matches)) {
foreach ($matches[1] comme $url) {
// exclure certains domaines
$tmp = parse_url($url);
if (in_array($tmp['host'], $exclus_domains)) {
continuer;
}
// stocke l'url
$url_list []= $url;
}
}
}
// Supprime les liens en double
$url_list = array_values(array_unique($url_list));
si (!$url_list) {
die('Aucune URL à vérifier');
}Nous configurons d'abord la base de données, une série de noms de domaine à exclure ($exclusive_domains) et le nombre maximum de connexions simultanées ($max_connections). Ensuite, connectez-vous à la base de données, récupérez les articles et les liens inclus, et rassemblez-les dans un tableau ($url_list).
Le code ci-dessous est un peu compliqué, je vais donc l'expliquer en détail étape par étape :
// 1. Processeur par lots
$mh = curl_multi_init();
// 2. Ajoutez les URL qui doivent être traitées par lots
pour ($i = 0; $i < $max_connections; $i++) {
add_url_to_multi_handle($mh, $url_list);
}
// 3. Traitement initial
faire {
$mrc = curl_multi_exec($mh, $active);
} while ($mrc == CURLM_CALL_MULTI_PERFORM);
// 4. Boucle principale
while ($active && $mrc == CURLM_OK) {
// 5. Il existe une connexion active
if (curl_multi_select($mh) != -1) {
// 6. Travail
faire {
$mrc = curl_multi_exec($mh, $active);
} while ($mrc == CURLM_CALL_MULTI_PERFORM);
// 7. Avez-vous des informations ?
si ($mhinfo = curl_multi_info_read($mh)) {
// Signifie que la connexion s'est terminée normalement
// 8. Obtenir des informations à partir du handle curl
$chinfo = curl_getinfo($mhinfo['handle']);
// 9. Lien mort ?
si ($chinfo['http_code']) {
$dead_urls []= $chinfo['url'];
// 10. 404 ?
} sinon si ($chinfo['http_code'] == 404) {
$not_found_urls []= $chinfo['url'];
// 11. Toujours disponible
} autre {
$working_urls []= $chinfo['url'];
}
// 12. Supprimer la poignée
curl_multi_remove_handle($mh, $mhinfo['handle']);
curl_close($mhinfo['handle']);
// 13. Ajoutez une nouvelle URL et faites le travail
if (add_url_to_multi_handle($mh, $url_list)) {
faire {
$mrc = curl_multi_exec($mh, $active);
} while ($mrc == CURLM_CALL_MULTI_PERFORM);
}
}
}
}
// 14. Terminé
curl_multi_close($mh);
echo "==URL mortes==n";
echo implode("n",$dead_urls) .
echo "==404 URL==n";
echo implode("n",$not_found_urls) .
echo "==URL de travail==n";
echo implode("n",$working_urls);
// 15. Ajouter une URL au processeur par lots
fonction add_url_to_multi_handle($mh, $url_list) {
statique $index = 0 ;
// Si l'url est laissée, cela ne sert à rien
si ($url_list[$index]) {
//Créer un nouveau handle curl
$ch = curl_init();
//Configurer l'URL
curl_setopt($ch, CURLOPT_URL, $url_list[$index]);
// Je ne veux pas afficher le contenu renvoyé
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
// Nous irons là où la redirection nous mènera
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
// Aucun corps de contenu n'est requis, ce qui permet d'économiser de la bande passante et du temps
curl_setopt($ch, CURLOPT_NOBODY, 1);
//Ajouter au processeur par lots
curl_multi_add_handle($mh, $ch);
// Composez le compteur et vous pourrez ajouter la prochaine URL la prochaine fois que vous appellerez cette fonction.
$index++;
renvoie vrai ;
} autre {
// Aucune nouvelle URL ne doit être traitée
renvoie faux ;
}
}Le code ci-dessus est expliqué ci-dessous. Les numéros de série dans la liste correspondent aux numéros séquentiels dans les commentaires du code.
Créez un nouveau processeur par lots. Création d'une poignée multiple.
Plus tard, nous créerons une fonction add_url_to_multi_handle() qui ajoute des URL au gestionnaire de lots. Chaque fois que cette fonction est appelée, une nouvelle URL est ajoutée au processeur par lots. Initialement, nous ajoutons 10 URL au processeur batch (ce nombre est déterminé par $max_connections).
Il est nécessaire d'exécuter curl_multi_exec() pour faire le travail d'initialisation, tant qu'il renvoie CURLM_CALL_MULTI_PERFORM il y a encore quelque chose à faire. Ceci est fait principalement pour créer la connexion, il n'attend pas la réponse complète de l'URL.
La boucle principale continue tant qu'il y a des connexions actives dans le lot.
curl_multi_select() attend qu'une requête URL aboutisse à une connexion active.
Le travail de cURL consiste là encore principalement à obtenir des données de réponse.
Vérifiez diverses informations. Lorsqu'une requête URL est terminée, un tableau est renvoyé.
Il existe un handle cURL dans le tableau renvoyé. Nous l'utilisons pour obtenir les informations correspondantes pour une seule requête cURL.
S'il s'agit d'un lien mort ou si la demande expire, aucun code d'état http ne sera renvoyé.
Si cette page est introuvable, un code d'état 404 sera renvoyé.
Dans d'autres cas, nous supposons que ce lien est disponible (bien sûr, vous pouvez également vérifier 500 erreurs, etc.).
Supprimez ce handle cURL du lot car il n'est plus utile, fermez-le !
Super, vous pouvez maintenant ajouter une autre URL. Une fois de plus, le travail d'initialisation recommence...
Eh bien, tout ce qui doit être fait est fait. Fermez le processeur par lots et générez le rapport.
Revenons à la fonction qui ajoute une nouvelle URL au processeur batch. Chaque fois que cette fonction est appelée, la variable statique $index est incrémentée afin que nous puissions savoir combien d'URL restent à traiter.
J'ai exécuté ce script sur mon blog (besoin de tests, certains mauvais liens ont été ajoutés intentionnellement), et les résultats sont les suivants :
Au total, environ 40 URL ont été vérifiées et cela a pris moins de deux secondes. Lorsque vous devez vérifier un plus grand nombre d’URL, vous pouvez imaginer l’effet d’économie de soucis ! Si vous ouvrez 10 connexions en même temps, ce sera 10 fois plus rapide ! De plus, vous pouvez également profiter de la fonctionnalité non bloquante du traitement par lots cURL pour gérer un grand nombre de requêtes URL sans bloquer vos scripts Web.
Quelques autres options cURL utiles
Authentification HTTP Si une requête URL nécessite une authentification basée sur HTTP, vous pouvez utiliser le code suivant :
$url = " http://www.somesite.com/members/ ";
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
//Envoyer le nom d'utilisateur et le mot de passe
curl_setopt ($ ch, CURLOPT_USERPWD, "mon nom d'utilisateur: mon mot de passe");
// Vous pouvez lui permettre de rediriger
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
// Les options suivantes permettent à cURL de
// Peut également envoyer un nom d'utilisateur et un mot de passe
curl_setopt($ch, CURLOPT_UNRESTRICTED_AUTH, 1);
$output = curl_exec($ch);
curl_close ($ ch); téléchargement FTP
PHP est livré avec sa propre bibliothèque FTP, mais vous pouvez également utiliser cURL :
//Ouvre un pointeur de fichier
$file = fopen("/chemin/vers/fichier", "r");
// L'url contient la plupart des informations requises
$url = " ftp://nom d'utilisateur:[email protected]:21/path/to/new/file ";
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
//Télécharger les options associées
curl_setopt($ch, CURLOPT_UPLOAD, 1);
curl_setopt($ch, CURLOPT_INFILE, $fp);
curl_setopt($ch, CURLOPT_INFILESIZE, filesize("/chemin/vers/fichier"));
// S'il faut activer le mode ASCII (utile lors du téléchargement de fichiers texte)
curl_setopt($ch, CURLOPT_FTPASCII, 1);
$output = curl_exec($ch);
curl_close($ch); Pour contourner le mur, vous pouvez utiliser un proxy pour lancer une requête cURL :
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL,'http://www.example.com');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
//Spécifiez l'adresse proxy
curl_setopt($ch, CURLOPT_PROXY, '11.11.11.11:8080');
// Fournissez le nom d'utilisateur et le mot de passe si nécessaire
curl_setopt($ch, CURLOPT_PROXYUSERPWD,'user:pass');
$output = curl_exec($ch);
curl_close ($ch); La fonction de rappel permet à cURL d'appeler une fonction de rappel spécifiée lors d'une requête URL. Par exemple, commencez à utiliser les données dès que le contenu ou la réponse est téléchargé, plutôt que d'attendre qu'il soit complètement téléchargé.
$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);
fonction progress_function($ch,$str) {
écho $str;
return strlen($str);
}Cette fonction de rappel doit renvoyer la longueur de la chaîne, sinon cette fonction ne fonctionnera pas correctement.
Pendant le processus de réception de la réponse URL, cette fonction sera appelée tant qu'un paquet de données sera reçu.
Résumé Aujourd'hui, nous avons découvert les fonctions puissantes et l'évolutivité flexible de la bibliothèque cURL. J'espère que vous l'aimerez. La prochaine fois que vous souhaiterez faire une demande d'URL, pensez à cURL !
Merci!
Texte original : Démarrage rapide avec cURL basé sur PHP
Texte original anglais : http://net.tutsplus.com/tutorials/php/techniques-and-resources-for-mastering-curl/
Auteur original : Burak Guzel
La source doit être conservée pour la réimpression.