validar - verificar si existe un fichero php
¿Cómo puedo verificar si existe una URL a través de PHP? (16)
¿Cómo puedo verificar si existe una URL (no 404) en PHP?
Al descubrir si existe una url de php hay algunas cosas a las que prestarle atención:
- Es la url en sí misma válida (una cadena, no vacía, buena sintaxis), esto es rápido para verificar el lado del servidor.
- Esperar una respuesta puede llevar tiempo y bloquear la ejecución del código.
- No todos los encabezados devueltos por get_headers () están bien formados.
- Use curl (si puede).
- Evite buscar todo el cuerpo / contenido, pero solo solicite los encabezados.
- Considere redirigir urls:
- ¿Desea que se devuelva el primer código?
- O siga todos los redireccionamientos y devuelva el último código?
- Puede terminar con un 200, pero podría redirigir usando etiquetas meta o javascript. Entender lo que sucede después es difícil.
Tenga en cuenta que cualquiera sea el método que use, lleva tiempo esperar una respuesta.
Todo el código podría (y probablemente lo hará) detenerse hasta que usted sepa el resultado o las solicitudes hayan expirado.
Por ejemplo: el código a continuación podría tomar mucho tiempo para mostrar la página si las URL no son válidas o no están disponibles:
<?php
$urls = getUrls(); // some function getting say 10 or more external links
foreach($urls as $k=>$url){
// this could potentially take 0-30 seconds each
// (more or less depending on connection, target site, timeout settings...)
if( ! isValidUrl($url) ){
unset($urls[$k]);
}
}
echo "yay all done! now show my site";
foreach($urls as $url){
echo "<a href=/"{$url}/">{$url}</a><br/>";
}
Las siguientes funciones podrían ser útiles, probablemente desee modificarlas para satisfacer sus necesidades:
function isValidUrl($url){
// first do some quick sanity checks:
if(!$url || !is_string($url)){
return false;
}
// quick check url is roughly a valid http request: ( http://blah/... )
if( ! preg_match(''/^http(s)?:////[a-z0-9-]+(/.[a-z0-9-]+)*(:[0-9]+)?(//.*)?$/i'', $url) ){
return false;
}
// the next bit could be slow:
if(getHttpResponseCode_using_curl($url) != 200){
// if(getHttpResponseCode_using_getheaders($url) != 200){ // use this one if you cant use curl
return false;
}
// all good!
return true;
}
function getHttpResponseCode_using_curl($url, $followredirects = true){
// returns int responsecode, or false (if url does not exist or connection timeout occurs)
// NOTE: could potentially take up to 0-30 seconds , blocking further code execution (more or less depending on connection, target site, and local timeout settings))
// if $followredirects == false: return the FIRST known httpcode (ignore redirects)
// if $followredirects == true : return the LAST known httpcode (when redirected)
if(! $url || ! is_string($url)){
return false;
}
$ch = @curl_init($url);
if($ch === false){
return false;
}
@curl_setopt($ch, CURLOPT_HEADER ,true); // we want headers
@curl_setopt($ch, CURLOPT_NOBODY ,true); // dont need body
@curl_setopt($ch, CURLOPT_RETURNTRANSFER ,true); // catch output (do NOT print!)
if($followredirects){
@curl_setopt($ch, CURLOPT_FOLLOWLOCATION ,true);
@curl_setopt($ch, CURLOPT_MAXREDIRS ,10); // fairly random number, but could prevent unwanted endless redirects with followlocation=true
}else{
@curl_setopt($ch, CURLOPT_FOLLOWLOCATION ,false);
}
// @curl_setopt($ch, CURLOPT_CONNECTTIMEOUT ,5); // fairly random number (seconds)... but could prevent waiting forever to get a result
// @curl_setopt($ch, CURLOPT_TIMEOUT ,6); // fairly random number (seconds)... but could prevent waiting forever to get a result
// @curl_setopt($ch, CURLOPT_USERAGENT ,"Mozilla/5.0 (Windows NT 6.0) AppleWebKit/537.1 (KHTML, like Gecko) Chrome/21.0.1180.89 Safari/537.1"); // pretend we''re a regular browser
@curl_exec($ch);
if(@curl_errno($ch)){ // should be 0
@curl_close($ch);
return false;
}
$code = @curl_getinfo($ch, CURLINFO_HTTP_CODE); // note: php.net documentation shows this returns a string, but really it returns an int
@curl_close($ch);
return $code;
}
function getHttpResponseCode_using_getheaders($url, $followredirects = true){
// returns string responsecode, or false if no responsecode found in headers (or url does not exist)
// NOTE: could potentially take up to 0-30 seconds , blocking further code execution (more or less depending on connection, target site, and local timeout settings))
// if $followredirects == false: return the FIRST known httpcode (ignore redirects)
// if $followredirects == true : return the LAST known httpcode (when redirected)
if(! $url || ! is_string($url)){
return false;
}
$headers = @get_headers($url);
if($headers && is_array($headers)){
if($followredirects){
// we want the the last errorcode, reverse array so we start at the end:
$headers = array_reverse($headers);
}
foreach($headers as $hline){
// search for things like "HTTP/1.1 200 OK" , "HTTP/1.0 200 OK" , "HTTP/1.1 301 PERMANENTLY MOVED" , "HTTP/1.1 400 Not Found" , etc.
// note that the exact syntax/version/output differs, so there is some string magic involved here
if(preg_match(''/^HTTP///S+/s+([1-9][0-9][0-9])/s+.*/'', $hline, $matches) ){// "HTTP/*** ### ***"
$code = $matches[1];
return $code;
}
}
// no HTTP/xxx found in headers:
return false;
}
// no headers :
return false;
}
Aquí hay una solución que solo lee el primer byte del código fuente ... devolviendo false si el archivo_get_contents falla ... Esto también funcionará para archivos remotos como imágenes.
function urlExists($url)
{
if (@file_get_contents($url,false,NULL,0,1))
{
return true;
}
return false;
}
Aquí:
$file = ''http://www.domain.com/somefile.jpg'';
$file_headers = @get_headers($file);
if(!$file_headers || $file_headers[0] == ''HTTP/1.1 404 Not Found'') {
$exists = false;
}
else {
$exists = true;
}
Desde here y justo debajo de la publicación anterior, hay una solución de curl :
function url_exists($url) {
if (!$fp = curl_init($url)) return false;
return true;
}
La solución get_headers () de karim79 no funcionó para mí ya que obtuve resultados locos con Pinterest.
get_headers(): SSL operation failed with code 1. OpenSSL Error messages: error:14090086:SSL routines:SSL3_GET_SERVER_CERTIFICATE:certificate verify failed
Array
(
[url] => https://www.pinterest.com/jonathan_parl/
[exists] =>
)
get_headers(): Failed to enable crypto
Array
(
[url] => https://www.pinterest.com/jonathan_parl/
[exists] =>
)
get_headers(https://www.pinterest.com/jonathan_parl/): failed to open stream: operation failed
Array
(
[url] => https://www.pinterest.com/jonathan_parl/
[exists] =>
)
De todos modos, este desarrollador demuestra que cURL es mucho más rápido que get_headers ():
http://php.net/manual/fr/function.get-headers.php#104723
Dado que muchas personas pidieron que karim79 lo arregle es la solución cURL, aquí está la solución que construí hoy.
/**
* Send an HTTP request to a the $url and check the header posted back.
*
* @param $url String url to which we must send the request.
* @param $failCodeList Int array list of code for which the page is considered invalid.
*
* @return Boolean
*/
public static function isUrlExists($url, array $failCodeList = array(404)){
$exists = false;
if(!StringManager::stringStartWith($url, "http") and !StringManager::stringStartWith($url, "ftp")){
$url = "https://" . $url;
}
if (preg_match(RegularExpression::URL, $url)){
$handle = curl_init($url);
curl_setopt($handle, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handle, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($handle, CURLOPT_HEADER, true);
curl_setopt($handle, CURLOPT_NOBODY, true);
curl_setopt($handle, CURLOPT_USERAGENT, true);
$headers = curl_exec($handle);
curl_close($handle);
if (empty($failCodeList) or !is_array($failCodeList)){
$failCodeList = array(404);
}
if (!empty($headers)){
$exists = true;
$headers = explode(PHP_EOL, $headers);
foreach($failCodeList as $code){
if (is_numeric($code) and strpos($headers[0], strval($code)) !== false){
$exists = false;
break;
}
}
}
}
return $exists;
}
Déjame explica las opciones de rizo:
CURLOPT_RETURNTRANSFER : devuelve una cadena en lugar de mostrar la página de llamada en la pantalla.
CURLOPT_SSL_VERIFYPEER : cUrl no revisará el certificado
CURLOPT_HEADER : incluye el encabezado en la cadena
CURLOPT_NOBODY : no incluya el cuerpo en la cadena
CURLOPT_USERAGENT : algunos sitios lo necesitan para funcionar correctamente (por ejemplo: https://plus.google.com )
Nota adicional : en esta función estoy usando la expresión regular de Diego Perini para validar la URL antes de enviar la solicitud:
const URL = "%^(?:(?:https?|ftp)://)(?:/S+(?::/S*)?@|/d{1,3}(?:/./d{1,3}){3}|(?:(?:[a-z/d/x{00a1}-/x{ffff}]+-?)*[a-z/d/x{00a1}-/x{ffff}]+)(?:/.(?:[a-z/d/x{00a1}-/x{ffff}]+-?)*[a-z/d/x{00a1}-/x{ffff}]+)*(?:/.[a-z/x{00a1}-/x{ffff}]{2,6}))(?::/d+)?(?:[^/s]*)?$%iu"; //@copyright Diego Perini
Nota adicional 2 : exploto la cadena de encabezado y los encabezados de usuario [0] para asegurarme de que solo valide solo el código de retorno y el mensaje (ejemplo: 200, 404, 405, etc.)
Nota adicional 3 : En algún momento validar solo el código 404 no es suficiente (ver la prueba de la unidad), por lo que hay un parámetro opcional $ failCodeList para proporcionar toda la lista de códigos para rechazar.
Y, por supuesto, esta es la prueba unitaria (que incluye todas las redes sociales populares) para legitimar mi codificación:
public function testIsUrlExists(){
//invalid
$this->assertFalse(ToolManager::isUrlExists("woot"));
$this->assertFalse(ToolManager::isUrlExists("https://www.facebook.com/jonathan.parentlevesque4545646456"));
$this->assertFalse(ToolManager::isUrlExists("https://plus.google.com/+JonathanParentL%C3%A9vesque890800"));
$this->assertFalse(ToolManager::isUrlExists("https://instagram.com/mariloubiz1232132/", array(404, 405)));
$this->assertFalse(ToolManager::isUrlExists("https://www.pinterest.com/jonathan_parl1231/"));
$this->assertFalse(ToolManager::isUrlExists("https://regex101.com/546465465456"));
$this->assertFalse(ToolManager::isUrlExists("https://twitter.com/arcadefire4566546"));
$this->assertFalse(ToolManager::isUrlExists("https://vimeo.com/**($%?%$", array(400, 405)));
$this->assertFalse(ToolManager::isUrlExists("https://www.youtube.com/user/Darkjo666456456456"));
//valid
$this->assertTrue(ToolManager::isUrlExists("www.google.ca"));
$this->assertTrue(ToolManager::isUrlExists("https://www.facebook.com/jonathan.parentlevesque"));
$this->assertTrue(ToolManager::isUrlExists("https://plus.google.com/+JonathanParentL%C3%A9vesque"));
$this->assertTrue(ToolManager::isUrlExists("https://instagram.com/mariloubiz/"));
$this->assertTrue(ToolManager::isUrlExists("https://www.facebook.com/jonathan.parentlevesque"));
$this->assertTrue(ToolManager::isUrlExists("https://www.pinterest.com/"));
$this->assertTrue(ToolManager::isUrlExists("https://regex101.com"));
$this->assertTrue(ToolManager::isUrlExists("https://twitter.com/arcadefire"));
$this->assertTrue(ToolManager::isUrlExists("https://vimeo.com/"));
$this->assertTrue(ToolManager::isUrlExists("https://www.youtube.com/user/Darkjo666"));
}
Gran éxito para todos,
Jonathan Parent-Lévesque de Montreal
Otra forma de verificar si una URL es válida o no puede ser:
<?php
if (isValidURL("http://www.gimepix.com")) {
echo "URL is valid...";
} else {
echo "URL is not valid...";
}
function isValidURL($url) {
$file_headers = @get_headers($url);
if (strpos($file_headers[0], "200 OK") > 0) {
return true;
} else {
return false;
}
}
?>
Yo uso esta función:
/**
* @param $url
* @param array $options
* @return string
* @throws Exception
*/
function checkURL($url, array $options = array()) {
if (empty($url)) {
throw new Exception(''URL is empty'');
}
// list of HTTP status codes
$httpStatusCodes = array(
100 => ''Continue'',
101 => ''Switching Protocols'',
102 => ''Processing'',
200 => ''OK'',
201 => ''Created'',
202 => ''Accepted'',
203 => ''Non-Authoritative Information'',
204 => ''No Content'',
205 => ''Reset Content'',
206 => ''Partial Content'',
207 => ''Multi-Status'',
208 => ''Already Reported'',
226 => ''IM Used'',
300 => ''Multiple Choices'',
301 => ''Moved Permanently'',
302 => ''Found'',
303 => ''See Other'',
304 => ''Not Modified'',
305 => ''Use Proxy'',
306 => ''Switch Proxy'',
307 => ''Temporary Redirect'',
308 => ''Permanent Redirect'',
400 => ''Bad Request'',
401 => ''Unauthorized'',
402 => ''Payment Required'',
403 => ''Forbidden'',
404 => ''Not Found'',
405 => ''Method Not Allowed'',
406 => ''Not Acceptable'',
407 => ''Proxy Authentication Required'',
408 => ''Request Timeout'',
409 => ''Conflict'',
410 => ''Gone'',
411 => ''Length Required'',
412 => ''Precondition Failed'',
413 => ''Payload Too Large'',
414 => ''Request-URI Too Long'',
415 => ''Unsupported Media Type'',
416 => ''Requested Range Not Satisfiable'',
417 => ''Expectation Failed'',
418 => ''I/'m a teapot'',
422 => ''Unprocessable Entity'',
423 => ''Locked'',
424 => ''Failed Dependency'',
425 => ''Unordered Collection'',
426 => ''Upgrade Required'',
428 => ''Precondition Required'',
429 => ''Too Many Requests'',
431 => ''Request Header Fields Too Large'',
449 => ''Retry With'',
450 => ''Blocked by Windows Parental Controls'',
500 => ''Internal Server Error'',
501 => ''Not Implemented'',
502 => ''Bad Gateway'',
503 => ''Service Unavailable'',
504 => ''Gateway Timeout'',
505 => ''HTTP Version Not Supported'',
506 => ''Variant Also Negotiates'',
507 => ''Insufficient Storage'',
508 => ''Loop Detected'',
509 => ''Bandwidth Limit Exceeded'',
510 => ''Not Extended'',
511 => ''Network Authentication Required'',
599 => ''Network Connect Timeout Error''
);
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_NOBODY, true);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
if (isset($options[''timeout''])) {
$timeout = (int) $options[''timeout''];
curl_setopt($ch, CURLOPT_TIMEOUT, $timeout);
}
curl_exec($ch);
$returnedStatusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if (array_key_exists($returnedStatusCode, $httpStatusCodes)) {
return "URL: ''{$url}'' - Error code: {$returnedStatusCode} - Definition: {$httpStatusCodes[$returnedStatusCode]}";
} else {
return "''{$url}'' does not exist";
}
}
la manera simple es curl (y MÁS RÁPIDO también)
<?php
$mylinks="http://site.com/page.html";
$handlerr = curl_init($mylinks);
curl_setopt($handlerr, CURLOPT_RETURNTRANSFER, TRUE);
$resp = curl_exec($handlerr);
$ht = curl_getinfo($handlerr, CURLINFO_HTTP_CODE);
if ($ht == ''404'')
{ echo ''OK'';}
else { echo ''NO'';}
?>
muy rápido:
function http_response($url){
$resURL = curl_init();
curl_setopt($resURL, CURLOPT_URL, $url);
curl_setopt($resURL, CURLOPT_BINARYTRANSFER, 1);
curl_setopt($resURL, CURLOPT_HEADERFUNCTION, ''curlHeaderCallback'');
curl_setopt($resURL, CURLOPT_FAILONERROR, 1);
curl_exec ($resURL);
$intReturnCode = curl_getinfo($resURL, CURLINFO_HTTP_CODE);
curl_close ($resURL);
if ($intReturnCode != 200 && $intReturnCode != 302 && $intReturnCode != 304) { return 0; } else return 1;
}
echo ''google:'';
echo http_response(''http://www.google.com'');
echo ''/ ogogle:'';
echo http_response(''http://www.ogogle.com'');
no puedes usar curl en ciertos servidores puedes usar este código
<?php
$url = ''http://www.example.com'';
$array = get_headers($url);
$string = $array[0];
if(strpos($string,"200"))
{
echo ''url exists'';
}
else
{
echo ''url does not exist'';
}
?>
para verificar si url está en línea o fuera de línea ---
function get_http_response_code($theURL) {
$headers = @get_headers($theURL);
return substr($headers[0], 9, 3);
}
get_headers() devuelve una matriz con los encabezados enviados por el servidor en respuesta a una solicitud HTTP.
$image_path = ''https://your-domain.com/assets/img/image.jpg'';
$file_headers = @get_headers($image_path);
//Prints the response out in an array
//print_r($file_headers);
if($file_headers[0] == ''HTTP/1.1 404 Not Found''){
echo ''Failed because path does not exist.</br>'';
}else{
echo ''It works. Your good to go!</br>'';
}
Todas las soluciones anteriores + azúcar extra. (Ultimate AIO solution)
/**
* Check that given URL is valid and exists.
* @param string $url URL to check
* @return bool TRUE when valid | FALSE anyway
*/
function urlExists ( $url ) {
// Remove all illegal characters from a url
$url = filter_var($url, FILTER_SANITIZE_URL);
// Validate URI
if (filter_var($url, FILTER_VALIDATE_URL) === FALSE
// check only for http/https schemes.
|| !in_array(strtolower(parse_url($url, PHP_URL_SCHEME)), [''http'',''https''], true )
) {
return false;
}
// Check that URL exists
$file_headers = @get_headers($url);
return !(!$file_headers || $file_headers[0] === ''HTTP/1.1 404 Not Found'');
}
Ejemplo:
var_dump ( urlExists(''http://.com/'') );
// Output: true;
$headers = @get_headers($this->_value);
if(strpos($headers[0],''200'')===false)return false;
así que cada vez que contactas un sitio web y obtienes algo más que 200 está bien, funcionará
$url = ''http://google.com'';
$not_url = ''stp://google.com'';
if (@file_get_contents($url)): echo "Found ''$url''!";
else: echo "Can''t find ''$url''.";
endif;
if (@file_get_contents($not_url)): echo "Found ''$not_url!";
else: echo "Can''t find ''$not_url''.";
endif;
// Found ''http://google.com''!Can''t find ''stp://google.com''.
function URLIsValid($URL)
{
$exists = true;
$file_headers = @get_headers($URL);
$InvalidHeaders = array(''404'', ''403'', ''500'');
foreach($InvalidHeaders as $HeaderVal)
{
if(strstr($file_headers[0], $HeaderVal))
{
$exists = false;
break;
}
}
return $exists;
}
function urlIsOk($url)
{
$headers = @get_headers($url);
$httpStatus = intval(substr($headers[0], 9, 3));
if ($httpStatus<400)
{
return true;
}
return false;
}