cURL ist ein Tool, das die URL-Syntax zum Übertragen von Dateien und Daten verwendet. Es unterstützt viele Protokolle wie HTTP, FTP, TELNET usw. Das Beste ist, dass PHP auch die cURL-Bibliothek unterstützt. In diesem Artikel werden einige erweiterte Funktionen von cURL und deren Verwendung in PHP vorgestellt.
Warum cURL verwenden?
Ja, wir können Webinhalte über andere Methoden erhalten. Meistens verwende ich einfach eine einfache PHP-Funktion, weil ich faul sein möchte:
$content = file_get_contents(" http://www.bizhicool.com ");
// oder
$lines = file(" http://www.bizhicool.com ");
// oder
readfile( http://www.bizhicool.com ); Diesem Ansatz mangelt es jedoch an Flexibilität und effektiver Fehlerbehandlung. Darüber hinaus können Sie damit einige schwierige Aufgaben nicht erledigen – etwa den Umgang mit Cookies, die Validierung, das Absenden von Formularen, das Hochladen von Dateien usw.
cURL ist eine leistungsstarke Bibliothek, die viele verschiedene Protokolle und Optionen unterstützt und verschiedene Details zu URL-Anfragen bereitstellen kann.
Grundstruktur Bevor wir uns mit komplexeren Funktionen befassen, werfen wir einen Blick auf die grundlegenden Schritte zum Einrichten einer cURL-Anfrage in PHP:
Initialisieren, Variablen festlegen, ausführen und Ergebnisse abrufen, cURL-Handle freigeben
// 1. Initialisierung
$ch = curl_init();
// 2. Optionen festlegen, einschließlich URL
curl_setopt($ch, CURLOPT_URL, " http://www.bizhicool.com ");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HEADER, 0);
// 3. Führen Sie den Inhalt des HTML-Dokuments aus und erhalten Sie ihn
$output = curl_exec($ch);
// 4. Lockengriff loslassen
curl_close($ch); Der zweite Schritt (also curl_setopt()) ist der wichtigste, und hier liegt das ganze Geheimnis. Es gibt eine lange Liste einstellbarer cURL-Parameter, die verschiedene Details der URL-Anfrage angeben. Es kann schwierig sein, sie alle auf einmal zu lesen und zu verstehen, deshalb werden wir heute nur die gebräuchlicheren und nützlicheren Optionen ausprobieren.
Auf Fehler prüfen Sie können eine Anweisung hinzufügen, um auf Fehler zu prüfen (obwohl dies nicht erforderlich ist):
// ...
$output = curl_exec($ch);
if ($output === FALSE) {
echo "cURL-Fehler: " . curl_error($ch);
}
// ...Bitte beachten Sie, dass wir beim Vergleich „=== FALSE“ anstelle von „== FALSE“ verwenden. Denn wir müssen zwischen einer leeren Ausgabe und dem booleschen Wert FALSE unterscheiden, der der eigentliche Fehler ist.
Informationen abrufen Dies ist eine weitere optionale Einstellung, mit der Informationen zu dieser Anfrage abgerufen werden können, nachdem cURL ausgeführt wurde:
// ...
curl_exec($ch);
$info = curl_getinfo($ch);
echo 'Get'. $info['url'] 'Zeitaufwendig' $info['total_time'] .
// ...das zurückgegebene Array enthält die folgenden Informationen:
"url" //Netzwerkadresse der Ressource
"content_type" //Inhaltskodierung
"http_code" //HTTP-Statuscode
"header_size" //Die Größe des Headers
"request_size" //Größe anfordern
„filetime“ //Erstellungszeitpunkt der Datei
"ssl_verify_result" //SSL-Verifizierungsergebnis
"redirect_count" //Sprungtechnologie
"total_time" //Gesamtzeitaufwand
"namelookup_time" //DNS-Abfragezeit
"connect_time" //Warten auf Verbindungszeit
"pretransfer_time" //Die Vorbereitungszeit vor der Übertragung
"size_upload" //Die Größe der hochgeladenen Daten
"size_download" //Die Größe der heruntergeladenen Daten
"speed_download" //Download-Geschwindigkeit
"speed_upload" //Upload-Geschwindigkeit
"download_content_length" //Die Länge des Download-Inhalts
"upload_content_length" //Die Länge des hochgeladenen Inhalts
"starttransfer_time" //Zeit zum Starten der Übertragung
„redirect_time“ //Umleitung braucht Zeit Browserbasierte Umleitung Im ersten Beispiel stellen wir einen Code bereit, der erkennt, ob der Server über eine browserbasierte Umleitung verfügt. Beispielsweise leiten einige Websites Webseiten basierend darauf um, ob es sich um einen mobilen Browser handelt oder sogar, aus welchem Land der Benutzer kommt.
Wir verwenden die Option CURLOPT_HTTPHEADER, um die von uns gesendeten HTTP-Anforderungsheader (http-Header) festzulegen, einschließlich Benutzeragenteninformationen und Standardsprache. Dann werden wir sehen, ob diese spezifischen Websites uns zu anderen URLs weiterleiten.
// URL zum Testen
$urls = array(
„ http://www.cnn.com “,
„ http://www.mozilla.com “,
„ http://www.facebook.com “
);
// Browserinformationen zum Testen
$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)",
„Sprache“ => „en-us,en;q=0.5“
),
"iphone" => Array (
"user_agent" => "Mozilla/5.0 (iPhone; U; CPU wie Mac OS X; en) AppleWebKit/420+ (KHTML, wie Gecko) Version/3.0 Mobile/1A537a Safari/419.3",
„Sprache“ => „en“
),
"französisch" => Array (
"user_agent" => "Mozilla/4.0 (kompatibel; MSIE 7.0; Windows NT 5.1; GTB6; .NET CLR 2.0.50727)",
„Sprache“ => „fr,fr-FR;q=0,5“
)
);
foreach ($urls als $url) {
echo "URL: $urln";
foreach ($browsers as $test_name => $browser) {
$ch = curl_init();
//URL festlegen
curl_setopt($ch, CURLOPT_URL, $url);
//Setze browserspezifische Header
curl_setopt($ch, CURLOPT_HTTPHEADER, array(
„Benutzeragent: {$browser['user_agent']}“,
„Accept-Language: {$browser['Language']}“
));
// Wir brauchen den Seiteninhalt nicht
curl_setopt($ch, CURLOPT_NOBODY, 1);
// Einfach den HTTP-Header zurückgeben
curl_setopt($ch, CURLOPT_HEADER, 1);
// Das Ergebnis zurückgeben, anstatt es auszudrucken
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$output = curl_exec($ch);
curl_close($ch);
// Gibt es HTTP-Header-Informationen für die Umleitung?
if (preg_match("!Location: (.*)!", $output, $matches)) {
echo „$test_name: leitet zu $matches[1]n weiter“;
} anders {
echo "$test_name: keine Umleitungn";
}
}
echo "nn";
}Zuerst erstellen wir eine Reihe von URLs, die getestet werden müssen, und geben dann eine Reihe von Browserinformationen an, die getestet werden müssen. Abschließend wird eine Schleife verwendet, um verschiedene URL- und Browser-Übereinstimmungssituationen zu testen, die auftreten können.
Da wir die cURL-Option angegeben haben, enthält die zurückgegebene Ausgabe nur HTTP-Header-Informationen (gespeichert in $output). Mithilfe einer einfachen regulären Regel prüfen wir, ob die Header-Informationen das Wort „Location:“ enthalten.
Das Ausführen dieses Codes sollte die folgenden Ergebnisse zurückgeben:
Daten mit der POST-Methode senden Bei einer GET-Anfrage können Daten über einen „Query-String“ an eine URL übergeben werden. Bei der Suche in Google ist der Suchschlüssel beispielsweise Teil der Abfragezeichenfolge der URL:
http://www.google.com/search?q=nettuts In diesem Fall benötigen Sie wahrscheinlich kein cURL zur Simulation. Wenn Sie diese URL an „file_get_contents()“ übergeben, erhalten Sie das gleiche Ergebnis.
Einige HTML-Formulare werden jedoch mit der POST-Methode übermittelt. Beim Absenden dieses Formulars werden die Daten über den HTTP-Anfragetext (Anfragetext) und nicht über die Abfragezeichenfolge gesendet. Wenn Sie beispielsweise das CodeIgniter-Forum-Formular verwenden, werden Sie unabhängig davon, welche Schlüsselwörter Sie eingeben, immer auf die folgende Seite GEPOSTET:
http://codeigniter.com/forums/do_search/ Sie können ein PHP-Skript verwenden, um diese URL-Anfrage zu simulieren. Erstellen Sie zunächst eine neue Datei, die POST-Daten akzeptieren und anzeigen kann. Wir nennen sie post_output.php:
print_r($_POST); Schreiben Sie als Nächstes ein PHP-Skript, um die cURL-Anfrage auszuführen:
$url = " http://localhost/post_output.php ";
$post_data = Array (
„foo“ => „bar“,
"query" => "Nettuts",
„Aktion“ => „Senden“
);
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
// Wir veröffentlichen Daten!
curl_setopt($ch, CURLOPT_POST, 1);
//Füge die Post-Variable hinzu
curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data);
$output = curl_exec($ch);
curl_close($ch);
echo $output;Nach der Ausführung des Codes sollten Sie die folgenden Ergebnisse erhalten:
Dieses Skript sendet eine POST-Anfrage an post_output.php, die $_POST-Variable der Seite, und gibt sie zurück. Wir erfassen diese Ausgabe mit cURL.
Datei-Upload Das Hochladen von Dateien ist dem vorherigen POST sehr ähnlich. Weil alle Datei-Upload-Formulare über die POST-Methode übermittelt werden.
Erstellen Sie zunächst eine neue Seite zum Empfangen von Dateien mit dem Namen upload_output.php:
print_r($_FILES);Das Folgende ist das Skript, das die Datei-Upload-Aufgabe tatsächlich ausführt:
$url = " http://localhost/upload_output.php ";
$post_data = Array (
„foo“ => „bar“,
//Die lokale Dateiadresse, die hochgeladen werden soll
„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; Wenn Sie eine Datei hochladen müssen, übergeben Sie einfach den Dateipfad wie eine Post-Variable, denken Sie jedoch daran, das @-Symbol voranzustellen. Die Ausführung dieses Skripts sollte zu der folgenden Ausgabe führen:
cURL-Stapelverarbeitung (Multi-cURL)
cURL verfügt außerdem über eine erweiterte Funktion – Batch-Handles. Mit dieser Funktion können Sie mehrere URL-Verbindungen gleichzeitig oder asynchron öffnen.
Hier ist Beispielcode von php.net:
//Erstelle zwei cURL-Ressourcen
$ch1 = curl_init();
$ch2 = curl_init();
//URL und entsprechende Parameter angeben
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);
// cURL-Batch-Handle erstellen
$mh = curl_multi_init();
//Die ersten beiden Ressourcenhandles hinzufügen
curl_multi_add_handle($mh,$ch1);
curl_multi_add_handle($mh,$ch2);
// Eine Zustandsvariable vordefinieren
$aktiv = null;
//Stapelverarbeitung ausführen
Tun {
$mrc = curl_multi_exec($mh, $active);
} while ($mrc == CURLM_CALL_MULTI_PERFORM);
while ($active && $mrc == CURLM_OK) {
if (curl_multi_select($mh) != -1) {
Tun {
$mrc = curl_multi_exec($mh, $active);
} while ($mrc == CURLM_CALL_MULTI_PERFORM);
}
}
//Jeden Griff schließen
curl_multi_remove_handle($mh, $ch1);
curl_multi_remove_handle($mh, $ch2);
curl_multi_close($mh); Hier müssen Sie mehrere cURL-Handles öffnen und sie einem Batch-Handle zuweisen. Dann warten Sie einfach in einer While-Schleife, bis der Vorgang abgeschlossen ist.
In diesem Beispiel gibt es zwei Hauptschleifen. Die erste do-while-Schleife ruft wiederholt curl_multi_exec() auf. Diese Funktion ist nicht blockierend, wird aber so wenig wie möglich ausgeführt. Solange dieser Wert der Konstante CURLM_CALL_MULTI_PERFORM entspricht, bedeutet dies, dass noch einige dringende Arbeiten erledigt werden müssen (z. B. das Senden der der URL entsprechenden http-Header-Informationen). Das heißt, wir müssen diese Funktion so lange aufrufen, bis sich der Rückgabewert ändert.
Die folgende while-Schleife wird nur fortgesetzt, wenn die Variable $active wahr ist. Diese Variable wurde zuvor als zweiter Parameter an curl_multi_exec() übergeben und stellt dar, ob im Batch-Handle noch aktive Verbindungen vorhanden sind. Als nächstes rufen wir curl_multi_select() auf, das „blockiert“ wird, bis eine aktive Verbindung (z. B. der Empfang einer Serverantwort) zustande kommt. Nachdem diese Funktion erfolgreich ausgeführt wurde, treten wir in eine weitere Do-While-Schleife ein und fahren mit der nächsten URL fort.
Schauen wir uns an, wie Sie diese Funktion in die Praxis umsetzen können:
WordPress Connection Checker Stellen Sie sich vor, Sie haben einen Blog mit einer großen Anzahl von Artikeln, die eine große Anzahl von Links zu externen Websites enthalten. Nach einiger Zeit wurden viele dieser Links aus dem einen oder anderen Grund ungültig. Entweder wurde es harmonisiert oder die gesamte Website wurde gehackt ...
Lassen Sie uns unten ein Skript erstellen, um alle diese Links zu analysieren, die Websites/Webseiten herauszufinden, die nicht geöffnet werden können oder 404 haben, und einen Bericht zu erstellen.
Bitte beachten Sie, dass es sich bei dem Folgenden nicht um ein wirklich funktionierendes WordPress-Plugin handelt, sondern lediglich um ein Skript mit unabhängigen Funktionen, das nur zur Demonstration dient, vielen Dank.
Okay, fangen wir an. Lesen Sie zunächst alle diese Links aus der Datenbank:
//KONFIG
$db_host = 'localhost';
$db_user = 'root';
$db_pass = '';
$db_name = 'wordpress';
$excluded_domains = array(
'localhost', 'www.meinedomain.com');
$max_connections = 10;
//Einige Variablen initialisieren
$url_list = array();
$working_urls = array();
$dead_urls = array();
$not_found_urls = array();
$aktiv = null;
// Mit MySQL verbinden
if (!mysql_connect($db_host, $db_user, $db_pass)) {
die('Verbindung konnte nicht hergestellt werden: ' . mysql_error());
}
if (!mysql_select_db($db_name)) {
die('Datenbank konnte nicht ausgewählt werden: ' . mysql_error());
}
// Alle Artikel mit Links finden
$q = „SELECT post_content FROM wp_posts
WHERE post_content LIKE '%href=%'
UND post_status = 'veröffentlichen'
UND post_type = 'post'";
$r = mysql_query($q) or die(mysql_error());
while ($d = mysql_fetch_assoc($r)) {
// Regelmäßige Matching-Links verwenden
if (preg_match_all("!href="(.*?)"!", $d['post_content'], $matches)) {
foreach ($matches[1] als $url) {
// einige Domänen ausschließen
$tmp = parse_url($url);
if (in_array($tmp['host'], $excluded_domains)) {
weitermachen;
}
// URL speichern
$url_list []= $url;
}
}
}
// Doppelte Links entfernen
$url_list = array_values(array_unique($url_list));
if (!$url_list) {
die('Keine URL zum Überprüfen');
}Wir konfigurieren zunächst die Datenbank, eine Reihe auszuschließender Domänennamen ($excluded_domains) und die maximale Anzahl gleichzeitiger Verbindungen ($max_connections). Stellen Sie dann eine Verbindung zur Datenbank her, rufen Sie die Artikel und enthaltenen Links ab und sammeln Sie sie in einem Array ($url_list).
Der folgende Code ist etwas kompliziert, daher erkläre ich ihn Schritt für Schritt im Detail:
// 1. Batch-Prozessor
$mh = curl_multi_init();
// 2. Fügen Sie URLs hinzu, die stapelweise verarbeitet werden müssen
for ($i = 0; $i < $max_connections; $i++) {
add_url_to_multi_handle($mh, $url_list);
}
// 3. Erstverarbeitung
Tun {
$mrc = curl_multi_exec($mh, $active);
} while ($mrc == CURLM_CALL_MULTI_PERFORM);
// 4. Hauptschleife
while ($active && $mrc == CURLM_OK) {
// 5. Es besteht eine aktive Verbindung
if (curl_multi_select($mh) != -1) {
// 6. Arbeit
Tun {
$mrc = curl_multi_exec($mh, $active);
} while ($mrc == CURLM_CALL_MULTI_PERFORM);
// 7. Haben Sie Informationen?
if ($mhinfo = curl_multi_info_read($mh)) {
//Bedeutet, dass die Verbindung normal beendet wurde
// 8. Informationen vom Curl-Handle abrufen
$chinfo = curl_getinfo($mhinfo['handle']);
// 9. Toter Link?
if (!$chinfo['http_code']) {
$dead_urls []= $chinfo['url'];
// 10. 404?
} else if ($chinfo['http_code'] == 404) {
$not_found_urls []= $chinfo['url'];
// 11. Noch verfügbar
} anders {
$working_urls []= $chinfo['url'];
}
// 12. Griff entfernen
curl_multi_remove_handle($mh, $mhinfo['handle']);
curl_close($mhinfo['handle']);
// 13. Neue URL hinzufügen und die Arbeit erledigen
if (add_url_to_multi_handle($mh, $url_list)) {
Tun {
$mrc = curl_multi_exec($mh, $active);
} while ($mrc == CURLM_CALL_MULTI_PERFORM);
}
}
}
}
// 14. Fertig
curl_multi_close($mh);
echo "==Tote URLs==n";
echo implode("n",$dead_urls) "nn";
echo "==404 URLs==n";
echo implode("n",$not_found_urls) "nn";
echo "==Arbeits-URLs==n";
echo implode("n",$working_urls);
// 15. URL zum Batch-Prozessor hinzufügen
Funktion add_url_to_multi_handle($mh, $url_list) {
static $index = 0;
// Wenn die URL übrig bleibt, ist sie nutzlos
if ($url_list[$index]) {
//Erstelle ein neues Curl-Handle
$ch = curl_init();
//URL konfigurieren
curl_setopt($ch, CURLOPT_URL, $url_list[$index]);
// Der zurückgegebene Inhalt soll nicht ausgegeben werden
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
// Wir werden dorthin gehen, wohin die Umleitung uns führt
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
// Es ist kein Inhaltskörper erforderlich, was Bandbreite und Zeit sparen kann
curl_setopt($ch, CURLOPT_NOBODY, 1);
//Zum Batch-Prozessor hinzufügen
curl_multi_add_handle($mh, $ch);
// Wählen Sie den Zähler und Sie können die nächste URL hinzufügen, wenn Sie diese Funktion das nächste Mal aufrufen.
$index++;
return true;
} anders {
// Es müssen keine neuen URLs verarbeitet werden
return false;
}
}Der obige Code wird unten erklärt. Die Seriennummern in der Liste entsprechen den fortlaufenden Nummern in den Codekommentaren.
Erstellen Sie einen neuen Stapelprozessor. Erstellt einen Multi-Handle.
Später erstellen wir eine Funktion add_url_to_multi_handle(), die URLs zum Batch-Handler hinzufügt. Bei jedem Aufruf dieser Funktion wird dem Stapelprozessor eine neue URL hinzugefügt. Zunächst fügen wir dem Stapelprozessor 10 URLs hinzu (diese Anzahl wird durch $max_connections bestimmt).
Um die Initialisierungsarbeit durchzuführen, muss curl_multi_exec() ausgeführt werden. Solange CURLM_CALL_MULTI_PERFORM zurückgegeben wird, gibt es noch etwas zu tun. Dies geschieht in erster Linie zum Herstellen der Verbindung und wartet nicht auf die vollständige URL-Antwort.
Die Hauptschleife wird so lange fortgesetzt, wie aktive Verbindungen im Stapel vorhanden sind.
curl_multi_select() wartet, bis eine URL-Abfrage zu einer aktiven Verbindung führt.
Die Arbeit von cURL besteht hier wieder hauptsächlich darin, Antwortdaten zu erhalten.
Überprüfen Sie verschiedene Informationen. Wenn eine URL-Anfrage abgeschlossen ist, wird ein Array zurückgegeben.
Das zurückgegebene Array enthält ein cURL-Handle. Wir verwenden es, um die entsprechenden Informationen für eine einzelne cURL-Anfrage zu erhalten.
Wenn es sich um einen toten Link handelt oder die Anfrage abläuft, wird kein HTTP-Statuscode zurückgegeben.
Wenn diese Seite nicht gefunden werden kann, wird ein 404-Statuscode zurückgegeben.
In anderen Fällen gehen wir davon aus, dass dieser Link verfügbar ist (Sie können natürlich auch auf 500-Fehler und ähnliches prüfen ...).
Entfernen Sie dieses cURL-Handle aus dem Stapel, da es nicht mehr verwendet wird. Schließen Sie es!
Großartig, jetzt können Sie eine weitere URL hinzufügen. Wieder einmal beginnt die Initialisierungsarbeit von neuem...
Nun, alles, was getan werden muss, ist erledigt. Schließen Sie den Stapelprozessor und erstellen Sie den Bericht.
Kehren wir zu der Funktion zurück, die dem Stapelprozessor eine neue URL hinzufügt. Bei jedem Aufruf dieser Funktion wird die statische Variable $index erhöht, sodass wir wissen, wie viele URLs noch verarbeitet werden müssen.
Ich habe dieses Skript auf meinem Blog ausgeführt (Test erforderlich, einige falsche Links wurden absichtlich hinzugefügt) und die Ergebnisse sind wie folgt:
Insgesamt wurden etwa 40 URLs überprüft und es dauerte weniger als zwei Sekunden. Wenn Sie eine größere Anzahl von URLs überprüfen müssen, ist der sorgenfreie Effekt vorstellbar! Wenn Sie 10 Verbindungen gleichzeitig öffnen, geht es zehnmal schneller! Darüber hinaus können Sie auch die nicht blockierende Funktion der cURL-Stapelverarbeitung nutzen, um eine große Anzahl von URL-Anfragen zu verarbeiten, ohne Ihre Webskripte zu blockieren.
Einige andere nützliche cURL-Optionen
HTTP-Authentifizierung Wenn eine URL-Anfrage eine HTTP-basierte Authentifizierung erfordert, können Sie den folgenden Code verwenden:
$url = " http://www.somesite.com/members/ ";
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
//Benutzernamen und Passwort senden
curl_setopt($ch, CURLOPT_USERPWD, "meinBenutzername:meinPasswort");
// Sie können die Umleitung zulassen
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
// Die folgenden Optionen ermöglichen cURL
// Kann auch Benutzername und Passwort senden
curl_setopt($ch, CURLOPT_UNRESTRICTED_AUTH, 1);
$output = curl_exec($ch);
curl_close($ch);FTP-Upload
PHP verfügt über eine eigene FTP-Bibliothek, Sie können aber auch cURL verwenden:
//Öffne einen Dateizeiger
$file = fopen("/path/to/file", "r");
// Die URL enthält die meisten erforderlichen Informationen
$url = " ftp://username:[email protected]:21/path/to/new/file ";
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
//Zugehörige Optionen hochladen
curl_setopt($ch, CURLOPT_UPLOAD, 1);
curl_setopt($ch, CURLOPT_INFILE, $fp);
curl_setopt($ch, CURLOPT_INFILESIZE, filesize("/path/to/file"));
// Ob der ASCII-Modus aktiviert werden soll (nützlich beim Hochladen von Textdateien)
curl_setopt($ch, CURLOPT_FTPASCII, 1);
$output = curl_exec($ch);
curl_close($ch); Um die Mauer zu umgehen, können Sie einen Proxy verwenden, um eine cURL-Anfrage zu initiieren:
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL,'http://www.example.com');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
//Proxy-Adresse angeben
curl_setopt($ch, CURLOPT_PROXY, '11.11.11.11:8080');
// Geben Sie bei Bedarf Benutzernamen und Passwort an
curl_setopt($ch, CURLOPT_PROXYUSERPWD,'user:pass');
$output = curl_exec($ch);
curl_close ($ch); Die Callback-Funktion ermöglicht es cURL, während einer URL-Anfrage eine bestimmte Callback-Funktion aufzurufen. Beginnen Sie beispielsweise mit der Datennutzung, sobald der Inhalt oder die Antwort heruntergeladen wird, anstatt zu warten, bis sie vollständig heruntergeladen sind.
$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);
Funktion progress_function($ch,$str) {
echo $str;
return strlen($str);
}Diese Rückruffunktion muss die Länge der Zeichenfolge zurückgeben, sonst funktioniert diese Funktion nicht ordnungsgemäß.
Während des URL-Antwortempfangsprozesses wird diese Funktion aufgerufen, solange ein Datenpaket empfangen wird.
Zusammenfassung Heute haben wir etwas über die leistungsstarken Funktionen und die flexible Skalierbarkeit der cURL-Bibliothek erfahren. Ich hoffe, es gefällt euch. Wenn Sie das nächste Mal eine URL-Anfrage stellen möchten, denken Sie an cURL!
Danke!
Originaltext: Schnellstart mit cURL auf Basis von PHP
Englischer Originaltext: http://net.tutsplus.com/tutorials/php/techniques-and-resources-for-mastering-curl/
Ursprünglicher Autor: Burak Guzel
Für den Nachdruck muss die Quelle aufbewahrt werden.