프로퍼티 | 타입 | 설명 | |
---|---|---|---|
$pause_interval | integer | If the value of this property is greater than 0, the library will process as many requests as defined by the {@link threads} property, and then wait for {@link pause_interval pause_interval} seconds before processing the next batch of requests. Default is 0 (the library will keep as many parallel threads as defined by {@link threads} running at all times, until there are no more requests to process). | |
$threads | integer |
process 30 simultaneous requests, at all times
$curl->threads = 30;
Note that, unless {@link pause_interval} is set to a value greater than 0, the library will process a constant
number of requests, at all times; it's doing this by processing a new request as soon as another one
finishes, instead of waiting for each batch to finish, and so on, until there are no more requests to process,
and thus greatly decreasing execution time.
If {@link pause_interval} is set to a value greater than 0, the library will process as many requests as set by
the {@link threads} property and then will wait for {@link pause_interval} seconds before processing the next
batch of requests.
Default is 10. |
메소드 | 설명 | |
---|---|---|
__construct ( boolean $htmlentities = true ) : void | Constructor of the class. | |
cache ( string $path, integer $lifetime = 3600, boolean $compress = true, octal $chmod = 493 ) : void | Use this method to enable caching of requests. | |
cookies ( string $path ) : void | Sets the path and name of the file to save to / retrieve cookies from. All cookie data will be stored in this file on a per-domain basis. Important when cookies need to stored/restored to maintain status/session of requests made to the same domains. | |
delete ( mixed $urls, mixed $callback = '' ) : void | Performs an HTTP DELETE request to one or more URLs with the POST data as specified by the $urls argument, and executes the callback function specified by the $callback argument for each and every request, as soon as a request finishes. | |
download ( mixed $urls, string $path, mixed $callback = '' ) : void | Downloads one or more files from one or more URLs specified by the $urls argument, saves the downloaded files (with their original name) to the path specified by the $path argument, and executes the callback function specified by the $callback argument for each and every request, as soon as a request finishes. | |
ftp_download ( mixed $urls, string $path, string $username = '', string $password = '', mixed $callback = '' ) : void | Works exactly like the {@link download} method only that downloads are made from an FTP server. | |
get ( mixed $urls, mixed $callback = '' ) : void | Performs an HTTP GET request to one or more URLs specified by the $urls argument and executes the callback function specified by the $callback argument for each and every request, as soon as a request finishes. | |
header ( mixed $urls, mixed $callback = '' ) : void | Works exactly like the {@link get} method, the only difference being that this method will only return the headers, without body. | |
http_authentication ( string $username = '', string $password = '', string $type = CURLAUTH_ANY ) : void | Use this method to make requests to pages that require prior HTTP authentication. | |
option ( mixed $option, mixed $value = '' ) : void | Allows you to set one or more {@link http://php.net/manual/en/function.curl-setopt.php cURL options}. | |
post ( mixed $urls, mixed $callback = '' ) : void | Performs an HTTP POST request to one or more URLs with the POST data as specified by the $urls argument, and executes the callback function specified by the $callback argument for each and every request, as soon as a request finishes. | |
proxy ( string $proxy, string $port = 80, string $username = '', string $password = '' ) : void | Instruct the library to tunnel all requests through a proxy server. | |
put ( mixed $urls, mixed $callback = '' ) : void | Performs an HTTP PUT request to one or more URLs with the POST data as specified by the $urls argument, and executes the callback function specified by the $callback argument for each and every request, as soon as a request finishes. | |
queue ( ) : void | Instructs the library to queue requests rather than processing them right away. Useful for grouping different types of requests and treat them as a single request. | |
scrap ( string $url, boolean $body_only = false ) : mixed | A shorthand for making a single {@link get} request without the need of a callback function | |
ssl ( boolean $verify_peer = true, integer $verify_host = 2, mixed $file = false, mixed $path = false ) : void | Requests made to HTTPS servers sometimes require additional configuration, depending on the server. Most of the times {@link __construct() the defaults} set by the library will get you through, but if defaults are not working, you can set specific options using this method. | |
start ( ) : void | Executes queued requests. |
메소드 | 설명 | |
---|---|---|
_debug ( ) : string | Returns the currently set options in "human-readable" format. | |
_get_cache_file_name ( $request ) : string | Returns the cache file name associated with a specific request. | |
_parse_headers ( string $headers ) : mixed | Parse response headers. | |
_process ( ) : void | Does the actual work. | |
_process_paused ( ) : void | A wrapper for the {@link _process} method used when we need to pause between batches of requests to process. | |
_queue_requests ( ) : void | A helper method used by the {@link _process} method, taking care of keeping a constant number of requests queued, so that as soon as one request finishes another one will instantly take its place, thus making sure that the maximum allowed number of parallel threads are running all the time. | |
_user_agent ( ) : void | Generates a (slightly) random user agent (Internet Explorer 9 or 10, on Windows Vista, 7 or 8, with other extra strings) |
public __construct ( boolean $htmlentities = true ) : void | ||
$htmlentities | boolean | Instructs the script whether the response body returned by the {@link get} and {@link post} methods should be run through PHP's {@link http://php.net/manual/en/function.htmlentities.php htmlentities} function. @return void |
리턴 | void |
the callback function to be executed for each and every
request, as soon as a request finishes
the callback function receives as argument an object with 4 properties
(info, header, body and response)
function mycallback($result) {
everything went well at cURL level
if ($result->response[1] == CURLE_OK) {
if server responded with code 200 (meaning that everything went well)
see http://httpstatus.es/ for a list of possible response codes
if ($result->info['http_code'] == 200) {
see all the returned data
print_r('
');
print_r($result);
show the server's response code
} else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
} else die('cURL responded with: ' . $result->response[0]);
}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
cache results in the "cache" folder and for 86400 seconds (24 hours)
$curl->cache('cache', 86400);
let's fetch the RSS feeds of some popular tech-related websites
execute the "mycallback" function for each request, as soon as it finishes
$curl->get(array(
'http://feeds.feedburner.com/alistapart/main',
'http://feeds.feedburner.com/TechCrunch',
'http://feeds.mashable.com/mashable',
), 'mycallback')
public cache ( string $path, integer $lifetime = 3600, boolean $compress = true, octal $chmod = 493 ) : void | ||
$path | string | Path where cache files to be stored. Setting this to FALSE will disable caching. If set to a non-existing path, the library will try to create the folder and will trigger an error if, for whatever reasons, it is unable to do so. If the folder can be created, its permissions will be set to the value of $chmod @param integer $lifetime (Optional) The number of seconds after which cache will be considered expired. Default is 3600 (one hour). @param boolean $compress (Optional) If set to TRUE, cache files will be {@link http://php.net/manual/en/function.gzcompress.php gzcompress}-ed so that they occupy less disk space. Default is TRUE. @param octal $chmod (Optional) The file system permissions to be set for newly created cache files. I suggest using the value "0755" (without the quotes) but, if you know what you are doing, here is how you can calculate the permission levels: - 400 Owner Read - 200 Owner Write - 100 Owner Execute - 40 Group Read - 20 Group Write - 10 Group Execute - 4 Global Read - 2 Global Write - 1 Global Execute Default is "0755" (without the quotes). @return void |
$lifetime | integer | |
$compress | boolean | |
$chmod | octal | |
리턴 | void |
the callback function to be executed for each and every
request, as soon as a request finishes
the callback function receives as argument an object with 4 properties
(info, header, body and response)
function mycallback($result) {
everything went well at cURL level
if ($result->response[1] == CURLE_OK) {
if server responded with code 200 (meaning that everything went well)
see http://httpstatus.es/ for a list of possible response codes
if ($result->info['http_code'] == 200) {
see all the returned data
print_r('
');
print_r($result);
show the server's response code
} else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
} else die('cURL responded with: ' . $result->response[0]);
}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
do a PUT and execute the "mycallback" function for each
request, as soon as it finishes
$curl->delete(array(
'http://www.somewebsite.com' => array(
'data_1' => 'value 1',
'data_2' => 'value 2',
),
), 'mycallback');
public delete ( mixed $urls, mixed $callback = '' ) : void | ||
$urls | mixed | An associative array in the form of url => delete-data, where "delete-data" is an associative array in the form of name => value. "delete-data" can also be an arbitrary string - useful if you want to send raw data (like a JSON) The Content-Type header will be set to multipart/form-data. @param mixed $callback (Optional) Callback function to be called as soon as a request finishes. May be given as a string representing a name of an existing function, as an anonymous function created on the fly via {@link http://www.php.net/manual/en/function.create-function.php create_function} or via a {@link http://www.php.net/manual/en/function.create-function.php closure}. The callback function receives as first argument an object with 4 properties as described below, while any further arguments passed to the {@link delete} method will be passed as extra arguments to the callback function: - info - an associative array containing information about the request that just finished, as returned by PHP's {@link http://php.net/manual/en/function.curl-getinfo.php curl_getinfo()} function; - headers - an associative array with 2 items: - last_request an array with a single entry containing the request headers generated by the last request; so, remember, if there are redirects involved, there will be more requests made, but only information from the last one will be available; if explicitly disabled via the {@link option} method by setting CURLINFO_HEADER_OUT to 0 or FALSE, this will be an empty string; - responses an array with one or more entries (if there are redirects involved) with the response headers of all the requests made; if explicitly disabled via the {@link option} method by setting CURLOPT_HEADER to 0 or FALSE, this will be an empty string; Unless disabled, each entry in the headers' array is an associative array in the form of property => value - body - the response of the request (the content of the page at the URL). Unless disabled via the {@link __construct() constructor}, all applicable characters will be converted to HTML entities via PHP's {@link http://php.net/manual/en/function.htmlentities.php htmlentities} function, so remember to use PHP's {@link http://www.php.net/manual/en/function.html-entity-decode.php html_entity_decode} function to do reverse this, if it's the case; If "body" is explicitly disabled via the {@link option} method by setting CURLOPT_NOBODY to 0 or FALSE, this will be an empty string; - response - the response given by the cURL library as an array with 2 entries: the first entry is the textual representation of the result's code, while second is the result's code itself; if the request was successful, these values will be array(CURLE_OK, 0); consult {@link http://www.php.net/manual/en/function.curl-errno.php#103128 this list} to see the possible values of this property; If the callback function returns FALSE while {@link cache} is enabled, the library will not cache the respective request, making it easy to retry failed requests without having to clear all cache. @since 1.3.3 @return void |
$callback | mixed | |
리턴 | void |
the callback function to be executed for each and every
request, as soon as a request finishes
the callback function receives as argument an object with 4 properties
(info, header, body and response)
function mycallback($result) {
everything went well at cURL level
if ($result->response[1] == CURLE_OK) {
if server responded with code 200 (meaning that everything went well)
see http://httpstatus.es/ for a list of possible response codes
if ($result->info['http_code'] == 200) {
see all the returned data
print_r('
');
print_r($result);
show the server's response code
} else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
} else die('cURL responded with: ' . $result->response[0]);
}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
download 2 images from 2 different websites, and
execute the "mycallback" function for each request, as soon as it finishes
$curl->download(array(
'http://www.somewebsite.com/images/alpha.jpg',
'http://www.otherwebsite.com/images/omega.jpg',
), 'destination/path/', 'mycallback');
public download ( mixed $urls, string $path, mixed $callback = '' ) : void | ||
$urls | mixed | A single URL or an array of URLs to process. @param string $path The path to where to save the file(s) to. If path is not pointing to a directory or is not writable, the library will trigger an error. @param mixed $callback (Optional) Callback function to be called as soon as a request finishes. May be given as a string representing a name of an existing function, as an anonymous function created on the fly via {@link http://www.php.net/manual/en/function.create-function.php create_function} or via a {@link http://www.php.net/manual/en/function.create-function.php closure}. The callback function receives as first argument an object with 4 properties as described below, while any further arguments passed to the {@link download} method will be passed as extra arguments to the callback function: - info - an associative array containing information about the request that just finished, as returned by PHP's {@link http://php.net/manual/en/function.curl-getinfo.php curl_getinfo} function; there's also an extra entry called original_url because, as curl_getinfo() only returns information about the last request, the original URL may be lost otherwise. - headers - an associative array with 2 items: - last_request an array with a single entry containing the request headers generated by the last request; so, remember, if there are redirects involved, there will be more requests made, but only information from the last one will be available; if explicitly disabled via the {@link option} method by setting CURLINFO_HEADER_OUT to 0 or FALSE, this will be an empty string; - responses an empty string as it is not available for this method; Unless disabled, each entry in the headers' array is an associative array in the form of property => value - body - an empty string as it is not available for this method; - response - the response given by the cURL library as an array with 2 entries: the first entry is the textual representation of the result's code, while second is the result's code itself; if the request was successful, these values will be array(CURLE_OK, 0); consult {@link http://www.php.net/manual/en/function.curl-errno.php#103128 this list} to see the possible values of this property; If the callback function returns FALSE while {@link cache} is enabled, the library will not cache the respective request, making it easy to retry failed requests without having to clear all cache. @return void |
$path | string | |
$callback | mixed | |
리턴 | void |
the callback function to be executed for each and every
request, as soon as a request finishes
the callback function receives as argument an object with 4 properties
(info, header, body and response)
function mycallback($result) {
everything went well at cURL level
if ($result->response[1] == CURLE_OK) {
if server responded with code 200 (meaning that everything went well)
see http://httpstatus.es/ for a list of possible response codes
if ($result->info['http_code'] == 200) {
see all the returned data
print_r('
');
print_r($result);
show the server's response code
} else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
} else die('cURL responded with: ' . $result->response[0]);
}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
connect to the FTP server using the given credential, download a file to a given location and
execute the "mycallback" function for each request, as soon as it finishes
$curl->ftp_download('ftp://somefile.ext', 'destination/path', 'username', 'password', 'mycallback');
public ftp_download ( mixed $urls, string $path, string $username = '', string $password = '', mixed $callback = '' ) : void | ||
$urls | mixed | A single URL or an array of URLs to process. @param string $path The path to where to save the file(s) to. If path is not pointing to a directory or is not writable, the library will trigger an error. @param string $username (Optional) The username to be used to connect to the FTP server (if required). @param string $password (Optional) The password to be used to connect to the FTP server (if required). @param mixed $callback (Optional) Callback function to be called as soon as a request finishes. May be given as a string representing a name of an existing function, as an anonymous function created on the fly via {@link http://www.php.net/manual/en/function.create-function.php create_function} or via a {@link http://www.php.net/manual/en/function.create-function.php closure}. The callback function receives as first argument an object with 4 properties as described below, while any further arguments passed to the {@link ftp_download} method will be passed as extra arguments to the callback function: - info - an associative array containing information about the request that just finished, as returned by PHP's {@link http://php.net/manual/en/function.curl-getinfo.php curl_getinfo} function; - headers - an associative array with 2 items: - last_request an array with a single entry containing the request headers generated by the last request; so, remember, if there are redirects involved, there will be more requests made, but only information from the last one will be available; if explicitly disabled via the {@link option} method by setting CURLINFO_HEADER_OUT to 0 or FALSE, this will be an empty string; - responses an empty string as it is not available for this method; Unless disabled, each entry in the headers' array is an associative array in the form of property => value - body - an empty string as it is not available for this method; - response - the response given by the cURL library as an array with 2 entries: the first entry is the textual representation of the result's code, while second is the result's code itself; if the request was successful, these values will be array(CURLE_OK, 0); consult {@link http://www.php.net/manual/en/function.curl-errno.php#103128 this list} to see the possible values of this property; If the callback function returns FALSE while {@link cache} is enabled, the library will not cache the respective request, making it easy to retry failed requests without having to clear all cache. @return void |
$path | string | |
$username | string | |
$password | string | |
$callback | mixed | |
리턴 | void |
the callback function to be executed for each and every
request, as soon as a request finishes
the callback function receives as argument an object with 4 properties
(info, header, body and response)
function mycallback($result) {
everything went well at cURL level
if ($result->response[1] == CURLE_OK) {
if server responded with code 200 (meaning that everything went well)
see http://httpstatus.es/ for a list of possible response codes
if ($result->info['http_code'] == 200) {
see all the returned data
print_r('
');
print_r($result);
show the server's response code
} else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
} else die('cURL responded with: ' . $result->response[0]);
}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
cache results in the "cache" folder and for 3600 seconds (one hour)
$curl->cache('cache', 3600);
let's fetch the RSS feeds of some popular websites
execute the "mycallback" function for each request, as soon as it finishes
$curl->get(array(
'http://feeds.feedburner.com/alistapart/main',
'http://feeds.feedburner.com/TechCrunch',
'http://feeds.mashable.com/mashable',
), 'mycallback')
public get ( mixed $urls, mixed $callback = '' ) : void | ||
$urls | mixed | A single URL or an array of URLs to process. @param mixed $callback (Optional) Callback function to be called as soon as a request finishes. May be given as a string representing a name of an existing function, as an anonymous function created on the fly via {@link http://www.php.net/manual/en/function.create-function.php create_function} or via a {@link http://www.php.net/manual/en/function.create-function.php closure}. The callback function receives as first argument an object with 4 properties as described below, while any further arguments passed to the {@link get} method will be passed as extra arguments to the callback function: - info - an associative array containing information about the request that just finished, as returned by PHP's {@link http://php.net/manual/en/function.curl-getinfo.php curl_getinfo} function; - headers - an associative array with 2 items: - last_request an array with a single entry containing the request headers generated by the last request; so, remember, if there are redirects involved, there will be more requests made, but only information from the last one will be available; - responses an array with one or more entries (if there are redirects involved) with the response headers of all the requests made; Each entry in the headers' array is an associative array in the form of property => value - body - the response of the request (the content of the page at the URL). Unless disabled via the {@link __construct() constructor}, all applicable characters will be converted to HTML entities via PHP's {@link http://php.net/manual/en/function.htmlentities.php htmlentities} function, so remember to use PHP's {@link http://www.php.net/manual/en/function.html-entity-decode.php html_entity_decode} function to do reverse this, if it's the case; - response - the response given by the cURL library as an array with 2 entries: the first entry is the textual representation of the result's code, while second is the result's code itself; if the request was successful, these values will be array(CURLE_OK, 0); consult {@link http://www.php.net/manual/en/function.curl-errno.php#103128 this list} to see the possible values of this property; If the callback function returns FALSE while {@link cache} is enabled, the library will not cache the respective request, making it easy to retry failed requests without having to clear all cache. @return void |
$callback | mixed | |
리턴 | void |
the callback function to be executed for each and every
request, as soon as a request finishes
the callback function receives as argument an object with 4 properties
(info, header, body and response)
function mycallback($result) {
everything went well at cURL level
if ($result->response[1] == CURLE_OK) {
if server responded with code 200 (meaning that everything went well)
see http://httpstatus.es/ for a list of possible response codes
if ($result->info['http_code'] == 200) {
see all the returned data
print_r('
');
print_r($result);
show the server's response code
} else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
} else die('cURL responded with: ' . $result->response[0]);
}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
process given URLs execute the "mycallback" function for each
request, as soon as it finishes
$curl->header('http://www.somewebsite.com', 'mycallback');
public header ( mixed $urls, mixed $callback = '' ) : void | ||
$urls | mixed | A single URL or an array of URLs to process. @param mixed $callback (Optional) Callback function to be called as soon as a request finishes. May be given as a string representing a name of an existing function, as an anonymous function created on the fly via {@link http://www.php.net/manual/en/function.create-function.php create_function} or via a {@link http://www.php.net/manual/en/function.create-function.php closure}. The callback function receives as first argument an object with 4 properties as described below, while any further arguments passed to the {@link header} method will be passed as extra arguments to the callback function: - info - an associative array containing information about the request that just finished, as returned by PHP's {@link http://php.net/manual/en/function.curl-getinfo.php curl_getinfo} function; - headers - an associative array with 2 items: - last_request an array with a single entry containing the request headers generated by the last request; so, remember, if there are redirects involved, there will be more requests made, but only information from the last one will be available; - responses an array with one or more entries (if there are redirects involved) with the response headers of all the requests made; Each entry in the headers' array is an associative array in the form of property => value - body - an empty string as it is not available for this method; - response - the response given by the cURL library as an array with 2 entries: the first entry is the textual representation of the result's code, while second is the result's code itself; if the request was successful, these values will be array(CURLE_OK, 0); consult {@link http://www.php.net/manual/en/function.curl-errno.php#103128 this list} to see the possible values of this property; If the callback function returns FALSE while {@link cache} is enabled, the library will not cache the respective request, making it easy to retry failed requests without having to clear all cache. @return void |
$callback | mixed | |
리턴 | void |
the callback function to be executed for each and every
request, as soon as a request finishes
the callback function receives as argument an object with 4 properties
(info, header, body and response)
function mycallback($result) {
everything went well at cURL level
if ($result->response[1] == CURLE_OK) {
if server responded with code 200 (meaning that everything went well)
see http://httpstatus.es/ for a list of possible response codes
if ($result->info['http_code'] == 200) {
see all the returned data
print_r('
'); print_r($result); show the server's response code } else die('Server responded with code ' . $result->info['http_code']); something went wrong ($result still contains all data that could be gathered) } else die('cURL responded with: ' . $result->response[0]); } include the Zebra_cURL library require 'path/to/Zebra_cURL'; instantiate the Zebra_cURL object $curl = new Zebra_cURL(); prepare user name and password $curl->http_authentication('username', 'password'); get content from a page that requires prior HTTP authentication $curl->get('http://www.some-page-requiring-prior-http-authentication.com', 'mycallback');
If you have to unset previously set values use$curl->http_authentication();
public http_authentication ( string $username = '', string $password = '', string $type = CURLAUTH_ANY ) : void | ||
$username | string | User name to be used for authentication. @param string $password Password to be used for authentication. @param string $type (Optional) The HTTP authentication method(s) to use. The options are: - CURLAUTH_BASIC - CURLAUTH_DIGEST - CURLAUTH_GSSNEGOTIATE - CURLAUTH_NTLM - CURLAUTH_ANY - CURLAUTH_ANYSAFE The bitwise | (or) operator can be used to combine more than one method. If this is done, cURL will poll the server to see what methods it supports and pick the best one. CURLAUTH_ANY is an alias for CURLAUTH_BASIC | CURLAUTH_DIGEST | CURLAUTH_GSSNEGOTIATE | CURLAUTH_NTLM. CURLAUTH_ANYSAFE is an alias for CURLAUTH_DIGEST | CURLAUTH_GSSNEGOTIATE | CURLAUTH_NTLM. Default is CURLAUTH_ANY. @return void |
$password | string | |
$type | string | |
리턴 | void |
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
setting a single option
$curl->option(CURLOPT_CONNECTTIMEOUT, 10);
setting multiple options at once
$curl->option(array(
CURLOPT_TIMEOUT => 10,
CURLOPT_CONNECTTIMEOUT => 10,
));
make a request here...
public option ( mixed $option, mixed $value = '' ) : void | ||
$option | mixed | A single option for which to set a value, or an associative array in the form of option => value (in case of an array, the $value argument will be disregarded). Setting a value to null will "unset" that option. @param mixed $value (Optional) If the $option argument is not an array, then this argument represents the value to be set for the respective option. If the $option argument is an array, then the value of this argument will be ignored. Setting a value to null will "unset" that option. @return void |
$value | mixed | |
리턴 | void |
the callback function to be executed for each and every
request, as soon as a request finishes
the callback function receives as argument an object with 4 properties
(info, header, body and response)
function mycallback($result) {
everything went well at cURL level
if ($result->response[1] == CURLE_OK) {
if server responded with code 200 (meaning that everything went well)
see http://httpstatus.es/ for a list of possible response codes
if ($result->info['http_code'] == 200) {
see all the returned data
print_r('
');
print_r($result);
show the server's response code
} else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
} else die('cURL responded with: ' . $result->response[0]);
}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
do a POST and execute the "mycallback" function for each
request, as soon as it finishes
$curl->post(array(
'http://www.somewebsite.com' => array(
'data_1' => 'value 1',
'data_2' => 'value 2',
),
), 'mycallback');
note that we're also uploading a file this time
and note that we're prefixing the file name with @
$curl->post(array(
'http://www.somewebsite.com' => array(
'data_1' => 'value 1',
'data_2' => 'value 2',
'data_3' => '@absolute/path/to/file.ext',
), 'mycallback');
public post ( mixed $urls, mixed $callback = '' ) : void | ||
$urls | mixed | An associative array in the form of url => post-data, where "post-data" is an associative array in the form of name => value. "post-data" can also be an arbitrary string - useful if you want to send raw data (like a JSON) To post a file, prepend the filename with @ and use the full server path. For PHP 5.5+ files are uploaded using {@link http://php.net/manual/ro/class.curlfile.php CURLFile} and {@link https://wiki.php.net/rfc/curl-file-upload CURLOPT_SAFE_UPLOAD} will be set to TRUE. For lower PHP versions, files will be uploaded the "old" way and the file's mime type should be explicitly specified by following the filename with the type in the format ';type=mimetype'. as most of the times cURL will send the wrong mime type... The Content-Type header will be set to multipart/form-data. @param mixed $callback (Optional) Callback function to be called as soon as a request finishes. May be given as a string representing a name of an existing function, as an anonymous function created on the fly via {@link http://www.php.net/manual/en/function.create-function.php create_function} or via a {@link http://www.php.net/manual/en/function.create-function.php closure}. The callback function receives as first argument an object with 4 properties as described below, while any further arguments passed to the {@link post} method will be passed as extra arguments to the callback function: - info - an associative array containing information about the request that just finished, as returned by PHP's {@link http://php.net/manual/en/function.curl-getinfo.php curl_getinfo} function; - headers - an associative array with 2 items: - last_request an array with a single entry containing the request headers generated by the last request; so, remember, if there are redirects involved, there will be more requests made, but only information from the last one will be available; if explicitly disabled via the {@link option} method by setting CURLINFO_HEADER_OUT to 0 or FALSE, this will be an empty string; - responses an array with one or more entries (if there are redirects involved) with the response headers of all the requests made; if explicitly disabled via the {@link option} method by setting CURLOPT_HEADER to 0 or FALSE, this will be an empty string; Unless disabled, each entry in the headers' array is an associative array in the form of property => value - body - the response of the request (the content of the page at the URL). Unless disabled via the {@link __construct() constructor}, all applicable characters will be converted to HTML entities via PHP's {@link http://php.net/manual/en/function.htmlentities.php htmlentities} function, so remember to use PHP's {@link http://www.php.net/manual/en/function.html-entity-decode.php html_entity_decode} function to do reverse this, if it's the case; If "body" is explicitly disabled via the {@link option} method by setting CURLOPT_NOBODY to 0 or FALSE, this will be an empty string; - response - the response given by the cURL library as an array with 2 entries: the first entry is the textual representation of the result's code, while second is the result's code itself; if the request was successful, these values will be array(CURLE_OK, 0); consult {@link http://www.php.net/manual/en/function.curl-errno.php#103128 this list} to see the possible values of this property; If the callback function returns FALSE while {@link cache} is enabled, the library will not cache the respective request, making it easy to retry failed requests without having to clear all cache. @return void |
$callback | mixed | |
리턴 | void |
the callback function to be executed for each and every
request, as soon as a request finishes
function mycallback($result) {
everything went well at cURL level
if ($result->response[1] == CURLE_OK) {
if server responded with code 200 (meaning that everything went well)
see http://httpstatus.es/ for a list of possible response codes
if ($result->info['http_code'] == 200) {
see all the returned data
print_r('
');
print_r($result);
show the server's response code
} else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
} else die('cURL responded with: ' . $result->response[0]);
}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the class
$curl = new Zebra_cURL();
connect to a proxy server
(that's a random one i got from http://www.hidemyass.com/proxy-list/)
$curl->proxy('187.63.32.250', '3128');
fetch a page
$curl->get('http://www.somewebsite.com/', 'mycallback');
public proxy ( string $proxy, string $port = 80, string $username = '', string $password = '' ) : void | ||
$proxy | string | The HTTP proxy to tunnel requests through. Can be an URL or an IP address. This option can also be set using the {@link option} method and setting CURLOPT_PROXY option to the desired value. Setting this argument to FALSE will "unset" all the proxy-related options. @param string $port (Optional) The port number of the proxy to connect to. Default is 80. This option can also be set using the {@link option} method and setting CURLOPT_PROXYPORT option to the desired value. @param string $username (Optional) The username to be used for the connection to the proxy (if required by the proxy) Default is "" (an empty string) The username and the password can also be set using the {@link option} method and setting CURLOPT_PROXYUSERPWD option to the desired value formatted like [username]:[password]. . @param string $password (Optional) The password to be used for the connection to the proxy (if required by the proxy) Default is "" (an empty string) The username and the password can also be set using the {@link option} method and setting CURLOPT_PROXYUSERPWD option to the desired value formatted like [username]:[password]. . @return void |
$port | string | |
$username | string | |
$password | string | |
리턴 | void |
the callback function to be executed for each and every
request, as soon as a request finishes
the callback function receives as argument an object with 4 properties
(info, header, body and response)
function mycallback($result) {
everything went well at cURL level
if ($result->response[1] == CURLE_OK) {
if server responded with code 200 (meaning that everything went well)
see http://httpstatus.es/ for a list of possible response codes
if ($result->info['http_code'] == 200) {
see all the returned data
print_r('
');
print_r($result);
show the server's response code
} else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
} else die('cURL responded with: ' . $result->response[0]);
}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
do a PUT and execute the "mycallback" function for each
request, as soon as it finishes
$curl->put(array(
'http://www.somewebsite.com' => array(
'data_1' => 'value 1',
'data_2' => 'value 2',
),
), 'mycallback');
public put ( mixed $urls, mixed $callback = '' ) : void | ||
$urls | mixed | An associative array in the form of url => put-data, where "put-data" is an associative array in the form of name => value. "put-data" can also be an arbitrary string - useful if you want to send raw data (like a JSON) To put a file, prepend the filename with @ and use the full server path. For PHP 5.5+ files are uploaded using {@link http://php.net/manual/ro/class.curlfile.php CURLFile} and {@link https://wiki.php.net/rfc/curl-file-upload CURLOPT_SAFE_UPLOAD} will be set to TRUE. For lower PHP versions, files will be uploaded the "old" way and the file's mime type should be explicitly specified by following the filename with the type in the format ';type=mimetype'. as most of the times cURL will send the wrong mime type... The Content-Type header will be set to multipart/form-data. @param mixed $callback (Optional) Callback function to be called as soon as a request finishes. May be given as a string representing a name of an existing function, as an anonymous function created on the fly via {@link http://www.php.net/manual/en/function.create-function.php create_function} or via a {@link http://www.php.net/manual/en/function.create-function.php closure}. The callback function receives as first argument an object with 4 properties as described below, while any further arguments passed to the {@link put} method will be passed as extra arguments to the callback function: - info - an associative array containing information about the request that just finished, as returned by PHP's {@link http://php.net/manual/en/function.curl-getinfo.php curl_getinfo} function; - headers - an associative array with 2 items: - last_request an array with a single entry containing the request headers generated by the last request; so, remember, if there are redirects involved, there will be more requests made, but only information from the last one will be available; if explicitly disabled via the {@link option} method by setting CURLINFO_HEADER_OUT to 0 or FALSE, this will be an empty string; - responses an array with one or more entries (if there are redirects involved) with the response headers of all the requests made; if explicitly disabled via the {@link option} method by setting CURLOPT_HEADER to 0 or FALSE, this will be an empty string; Unless disabled, each entry in the headers' array is an associative array in the form of property => value - body - the response of the request (the content of the page at the URL). Unless disabled via the {@link __construct() constructor}, all applicable characters will be converted to HTML entities via PHP's {@link http://php.net/manual/en/function.htmlentities.php htmlentities} function, so remember to use PHP's {@link http://www.php.net/manual/en/function.html-entity-decode.php html_entity_decode} function to do reverse this, if it's the case; If "body" is explicitly disabled via the {@link option} method by setting CURLOPT_NOBODY to 0 or FALSE, this will be an empty string; - response - the response given by the cURL library as an array with 2 entries: the first entry is the textual representation of the result's code, while second is the result's code itself; if the request was successful, these values will be array(CURLE_OK, 0); consult {@link http://www.php.net/manual/en/function.curl-errno.php#103128 this list} to see the possible values of this property; If the callback function returns FALSE while {@link cache} is enabled, the library will not cache the respective request, making it easy to retry failed requests without having to clear all cache. @since 1.3.3 @return void |
$callback | mixed | |
리턴 | void |
the callback function to be executed for each and every
request, as soon as a request finishes
the callback function receives as argument an object with 4 properties
(info, header, body and response)
function mycallback($result) {
everything went well at cURL level
if ($result->response[1] == CURLE_OK) {
if server responded with code 200 (meaning that everything went well)
see http://httpstatus.es/ for a list of possible response codes
if ($result->info['http_code'] == 200) {
see all the returned data
print_r('
');
print_r($result);
show the server's response code
} else die('Server responded with code ' . $result->info['http_code']);
something went wrong
($result still contains all data that could be gathered)
} else die('cURL responded with: ' . $result->response[0]);
}
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the Zebra_cURL object
$curl = new Zebra_cURL();
queue requests - useful for grouping different types of requests
in this example, when the "start" method is called, we'll execute
the "get" and the "post" requests simultaneously as if it was a
single request
$curl->queue();
do a POST and execute the "mycallback" function for each
request, as soon as it finishes
$curl->post(array(
'http://www.somewebsite.com' => array(
'data_1' => 'value 1',
'data_2' => 'value 2',
),
), 'mycallback');
let's fetch the RSS feeds of some popular websites
execute the "mycallback" function for each request, as soon as it finishes
$curl->get(array(
'http://feeds.feedburner.com/alistapart/main',
'http://feeds.feedburner.com/TechCrunch',
'http://feeds.mashable.com/mashable',
), 'mycallback')
execute queued requests
$curl->start();
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the class
$curl = new Zebra_cURL();
get page's content only
$content = $curl->get('https://www.somewebsite.com/', true);
print that to screen
echo $content;
get everything we can about the page
$content = $curl->get('https://www.somewebsite.com/');
print that to screen
print_r('
');
print_r($content);
public scrap ( string $url, boolean $body_only = false ) : mixed | ||
$url | string | An URL to fetch @param boolean $body_only (Optional) When set to TRUE, will instruct the method to return only the page's content, without info, headers, responses, etc. When set to FALSE, will instruct the method to return everything it can about the scrapped page, as an object with properties as described for the $callback argument of the {@link get} method. Default is FALSE. @since 1.3.3 @return mixed Returns the scrapped page's content, when $body_only is set to TRUE, or an object with properties as described for the $callback argument of the {@link get} method. |
$body_only | boolean | |
리턴 | mixed |
include the Zebra_cURL library
require 'path/to/Zebra_cURL';
instantiate the class
$curl = new Zebra_cURL();
instruct the library to verify peer's SSL certificate
(ignored if request is not made through HTTPS)
$curl->ssl(true);
fetch a page
$curl->get('https://www.somewebsite.com/', create_function('$result', 'print_r("
"); print_r($result);'));
public ssl ( boolean $verify_peer = true, integer $verify_host = 2, mixed $file = false, mixed $path = false ) : void | ||
$verify_peer | boolean | (Optional) Should the peer's certificate be verified by cURL? Default is TRUE. This option can also be set using the {@link option} method and setting CURLOPT_SSL_VERIFYPEER option to the desired value. @param integer $verify_host (Optional) Specifies whether or not to check the existence of a common name in the SSL peer certificate and that it matches with the provided hostname. - 1 to check the existence of a common name in the SSL peer certificate; - 2 to check the existence of a common name and also verify that it matches the hostname provided; in production environments the value of this option should be kept at 2; Default is 2 Support for value 1 removed in cURL 7.28.1 This option can also be set using the {@link option} method and setting CURLOPT_SSL_VERIFYHOST option to the desired value. @param mixed $file (Optional) An absolute path to a file holding one or more certificates to verify the peer with. This only makes sense if CURLOPT_SSL_VERIFYPEER is set to TRUE. Default is FALSE. This option can also be set using the {@link option} method and setting CURLOPT_CAINFO option to the desired value. @param mixed $path (Optional) An absolute path to a directory that holds multiple CA certificates. This only makes sense if CURLOPT_SSL_VERIFYPEER is set to TRUE. Default is FALSE. This option can also be set using the {@link option} method and setting CURLOPT_CAPATH option to the desired value. @return void |
$verify_host | integer | |
$file | mixed | |
$path | mixed | |
리턴 | void |
public int $pause_interval | ||
리턴 | integer |
process 30 simultaneous requests, at all times
$curl->threads = 30;
Note that, unless {@link pause_interval} is set to a value greater than 0, the library will process a constant
number of requests, at all times; it's doing this by processing a new request as soon as another one
finishes, instead of waiting for each batch to finish, and so on, until there are no more requests to process,
and thus greatly decreasing execution time.
If {@link pause_interval} is set to a value greater than 0, the library will process as many requests as set by
the {@link threads} property and then will wait for {@link pause_interval} seconds before processing the next
batch of requests.
Default is 10. public int $threads | ||
리턴 | integer |