¿Cómo puedo comprobar si una dirección URL existe (no 404) en PHP?

InformationsquelleAutor X10nD | 2010-02-17

21 Comentarios

  1. 281

    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;
    }

    De aquí y a la derecha debajo de el post anterior, hay un curl solución:

    function url_exists($url) {
        if (!$fp = curl_init($url)) return false;
        return true;
    }
    • Me temo que el CURL-forma no funcionan de esta manera. Mira esto: stackoverflow.com/questions/981954/…
    • Debemos cerrar el filehande?
    • algunos sitios web tienen un diferente $file_headers[0] en la página de error. por ejemplo, youtube.com. su página de error de tener ese valor como HTTP/1.0 404 Not Found(la diferencia es de 1.0 y 1.1). ¿qué hacer entonces?
    • Tal vez el uso de strpos($headers[0], '404 Not Found') podría hacer el truco
    • Este método no funciona para mí. Yo solía @fopen que funcionaba bien.
    • No funcionó para mí para una URL como http://somedomain.comblabla/path/file.jpg
    • En lugar de if($file_headers[0] == ‘HTTP/1.1 404 not Found’) que harías si(($file_headers[0] == ‘HTTP/1.1 404 not Found’) ||($file_headers[0] == ‘HTTP/1.0 404 No Encontrado’)) puede ser un método más sencillo, pero esto debe ponerse en marcha.
    • El «No se Encontró el» estado del texto es opcional; los desarrolladores pueden poner lo que quieran ahí, es todavía válida.
    • acuerdo! Para aclarar, strpos($headers[0], '404') es mejor!
    • tenga cuidado de la SSRF y XSPA ataques
    • Por favor arreglar el rizo ejemplo !
    • Tenga en cuenta que get_headers volverá boolean false si ocurre un error (por ejemplo. DNS no resolver). Así que asegúrese de comprobar primero si get_headers no es boolean false antes de la prueba, si contiene los códigos de respuesta HTTP..
    • Para ahorrar tiempo y ancho de banda, se podría utilizar la CABEZA de solicitud en lugar de CONSEGUIR con : stream_context_set_default( array( ‘http’ => array( ‘método’ => ‘CABEZA’, ‘tiempo de espera’ => 1.5, ‘ignore_errors’ => true, ) ) );
    • Sólo una advertencia: esto no funcionará si su url se redirige. Esto puede suceder fácilmente si intenta comprobar una dirección url con un dominio que redirija el dominio.las solicitudes de tld http://www.domain.tld. El primer encabezado en este caso es de 301 movido permanentemente o algo similar y el 404 encabezado es después de todo la redirección de los encabezados.

  2. 53

    Cuando determina si una url existe desde php hay un par de cosas para prestar atención a:

    • Es la propia dirección url válida (una cadena no vacía, buena sintaxis), esta es rápida para comprobar el lado del servidor.
    • Esperando una respuesta podría tomar tiempo y bloquear la ejecución de código.
    • No todos los encabezados devuelto por get_headers() están bien formadas.
    • Uso de curl (si se puede).
    • Evitar la captura de todo el cuerpo/contenido, pero sólo a petición de los encabezados.
    • Considerar la posibilidad de redirigir url:
      • ¿Desea que el primer código que devuelve?
      • O siga todas las redirecciones y devolver el último código?
      • Usted podría terminar con una de 200, pero podría redirigir el uso de etiquetas meta o javascript. Averiguar lo que sucede después es difícil.

    Tenga en cuenta que cualquiera que sea el método que use, se necesita tiempo para esperar una respuesta.

    Todo el código se puede (y probablemente lo hará) parar hasta saber el resultado o las solicitudes se han agotado.

    Por ejemplo: el código de abajo podría tomar un LARGO tiempo para mostrar la página si la url no válido o es inalcanzable:

    <?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 funciones que a continuación podría ser útil, es probable que desee modificar para adaptarse a 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;
    }
    • por alguna razón getHttpResponseCode_using_curl() siempre devuelve 200 en mi caso.
    • si alguien tiene el mismo problema, compruebe dns-nameservers.. uso opendns sin followredirects stackoverflow.com/a/11072947/1829460
    • +1 por ser la única respuesta para lidiar con las redirecciones. Cambiado el return $code a if($code == 200){return true;} return false; para ordenar sólo éxitos
    • Será esto todos los patrones de URL en aquí? mathiasbynens.ser/demo/url-regex
    • No. Mi rápido preg_match regex era un simple ejemplo y no coincida con todas las url indicadas allí. Ver esta prueba url: regex101.com/r/EpyDDc/2 Si desea una mejor, sustituir con la que aparece en el enlace ( mathiasbynens.ser/demo/url-regex ) de diegoperini ; parece coincidir con todos ellos, ver este testlink: regex101.com/r/qMQp23/1
  3. 44
    $headers = @get_headers($this->_value);
    if(strpos($headers[0],'200')===false)return false;

    así que en cualquier momento en contacto con un sitio web y obtener algo más de 200 ok funcionará

  4. 15

    usted puede utilizar curl en ciertos servidores
    u puede utilizar 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';
    }
    ?>
    • puede que no funcione para 302-303 redirigir o por ejemplo 304 No Modificado
  5. 7
    $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'.
    • Esto no funcionará si permitir-url fopen está apagado. – php.net/manual/en/…
    • Yo sugeriría que con solo leer el primer byte… if (@file_get_contents($url,false,NULL,0,1))
    • Esto es simplemente INCORRECTO, ya que comprueba si el contenido es cierto, así que si la página que está leyendo en contra de que existe y vacío que no pase de la condición.Usted debe cambiar a», si (@file_get_contents($url) !== false)
  6. 7
    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;
    }
  7. 6

    Puedo usar 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";
    }
    }
  8. 4

    karim79 del get_headers() solución no funcionó para mí como yo vuelto loco resultados 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 la curvatura es mucho más rápido que get_headers():

    http://php.net/manual/fr/function.get-headers.php#104723

    Ya que muchas personas pidieron karim79 a revisión es el cURL de solución, aquí está la solución que se construyen hoy en día.

    /**
    * 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;
    }

    Permítanme explica el rizo opciones:

    CURLOPT_RETURNTRANSFER: devuelve una cadena en lugar de mostrar la página de llamada en la pantalla.

    CURLOPT_SSL_VERIFYPEER: cUrl de no obtener el certificado de

    CURLOPT_HEADER: incluir el encabezado en la cadena de

    CURLOPT_NOBODY: no incluir el cuerpo en la cadena de

    CURLOPT_USERAGENT: algunas de las necesidades del sitio que funcione correctamente (por ejemplo : https://plus.google.com)


    Nota adicional: En esta función el que estoy usando Diego Perini la expresión regular para validar la URL antes de enviar la solicitud:

    const URL = "%^(?:(?:https?|ftp)://)(?:\S+(?::\S*)[email protected]|\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

    La nota complementaria 2: reventar la cadena de encabezado de usuario y encabezados[0] para asegurarse de que sólo validar el código de retorno y el mensaje (ejemplo: 200, 404, 405, etc.)

    En la nota complementaria 3: en Algún momento de la validación sólo el código 404 no es suficiente (véase la unidad de prueba), así que hay un opcional de $failCodeList parámetro para el suministro de todos los de la lista de códigos a rechazar.

    Y, por supuesto, aquí está la prueba de la unidad (incluyendo todos los de la popular red social) 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 Padre-Lévesque de Montreal

  9. 3

    bastante 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');
  10. 3
    function urlIsOk($url)
    {
    $headers = @get_headers($url);
    $httpStatus = intval(substr($headers[0], 9, 3));
    if ($httpStatus<400)
    {
    return true;
    }
    return false;
    }
  11. 3

    Todas las soluciones anteriores + extra de azúcar. (Ultimate AIO solución)

    /**
    * 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://stackoverflow.com/') );
    //Output: true;
  12. 3

    para comprobar si la 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);
    }
  13. 2

    Aquí es una solución que se lee el primer byte de código fuente… devolver false si el file_get_contents no… Esto también funciona para los archivos remotos como imágenes.

     function urlExists($url)
    {
    if (@file_get_contents($url,false,NULL,0,1))
    {
    return true;
    }
    return false;
    }
  14. 0

    la forma más sencilla es curl (y más RÁPIDO)

    <?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';}
    ?>
  15. 0

    Otra forma de comprobar si una URL es válida o no se puede:

    <?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;
    }
    }
    ?>
  16. 0

    get_headers() devuelve un array con las cabeceras enviadas por el servidor en respuesta a una petición 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>';
    }
  17. 0

    cURL puede devolver HTTP de código no creo que todos los que código adicional es necesario?

    function urlExists($url=NULL)
    {
    if($url == NULL) return false;
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_TIMEOUT, 5);
    curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 5);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $data = curl_exec($ch);
    $httpcode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch); 
    if($httpcode>=200 && $httpcode<300){
    return true;
    } else {
    return false;
    }
    }
  18. 0

    Una cosa a tener en cuenta a la hora de comprobar el encabezado de un mensaje de error 404 es el caso cuando un sitio no genera un error 404 de inmediato.

    Un montón de sitios comprueba si la página existe o no en el PHP/ASP (et cetera) de origen y hacia adelante a una página de error 404. En esos casos, el encabezado es, básicamente, extendida por el encabezado de la 404 que se genera. En esos casos, el error 404 no en la primera línea de la cabecera, pero en el décimo.

    $array = get_headers($url);
    $string = $array[0];
    print_r($string) //would generate:
    Array ( 
    [0] => HTTP/1.0 301 Moved Permanently 
    [1] => Date: Fri, 09 Nov 2018 16:12:29 GMT 
    [2] => Server: Apache/2.4.34 (FreeBSD) LibreSSL/2.7.4 PHP/7.0.31 
    [3] => X-Powered-By: PHP/7.0.31 
    [4] => Set-Cookie: landing=%2Freed-diffuser-fig-pudding-50; path=/; HttpOnly 
    [5] => Location: /reed-diffuser-fig-pudding-50/ 
    [6] => Content-Length: 0 
    [7] => Connection: close 
    [8] => Content-Type: text/html; charset=utf-8 
    [9] => HTTP/1.0 404 Not Found 
    [10] => Date: Fri, 09 Nov 2018 16:12:29 GMT 
    [11] => Server: Apache/2.4.34 (FreeBSD) LibreSSL/2.7.4 PHP/7.0.31 
    [12] => X-Powered-By: PHP/7.0.31 
    [13] => Set-Cookie: landing=%2Freed-diffuser-fig-pudding-50%2F; path=/; HttpOnly 
    [14] => Connection: close 
    [15] => Content-Type: text/html; charset=utf-8 
    ) 
  19. 0

    Puedo ejecutar algunas pruebas para ver si los enlaces en mi sitio son válidos – alertas de mí cuando terceros a cambio de sus enlaces. Yo estaba teniendo un problema con un sitio que tenía un mal configurado certificado que significaba que php get_headers no funciona.

    ASÍ que, he leído que se enroscan fue más rápido y se decidió a dar a los que ir. luego tuve un problema con linkedin que me dio un error 999, que resultó ser un agente de usuario cuestión.

    No me importaba si el certificado no es válido para esta prueba, y no me importaba si la respuesta fue una re-directo.

    Entonces me di uso get_headers de todos modos si curl estaba fallando….

    Darle una oportunidad….

    /**
    * returns true/false if the $url is present.
    *
    * @param string $url assumes this is a valid url.
    *
    * @return bool
    */
    private function url_exists (string $url): bool
    {
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_NOBODY, TRUE);             //this does a head request to make it faster.
    curl_setopt($ch, CURLOPT_HEADER, TRUE);             //just the headers
    curl_setopt($ch, CURLOPT_SSL_VERIFYSTATUS, FALSE);  //turn off that pesky ssl stuff - some sys admins can't get it right.
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);
    //set a real user agent to stop linkedin getting upset.
    curl_setopt($ch, CURLOPT_USERAGENT, 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36');
    curl_exec($ch);
    $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    if (($http_code >= HTTP_OK && $http_code < HTTP_BAD_REQUEST) || $http_code === 999)
    {
    curl_close($ch);
    return TRUE;
    }
    $error = curl_error($ch); //used for debugging.
    curl_close($ch);
    //just try the get_headers - it might work!
    stream_context_set_default(array('http' => array('method' => 'HEAD')));
    $file_headers = @get_headers($url);
    if ($file_headers)
    {
    $response_code = substr($file_headers[0], 9, 3);
    return $response_code >= 200 && $response_code < 400;
    }
    return FALSE;
    }
  20. -2

    tipo de un hilo viejo, pero..
    yo hago esto:

    $file = 'http://www.google.com';
    $file_headers = @get_headers($file);
    if ($file_headers) {
    $exists = true;
    } else {
    $exists = false;
    }
    • Esta solución ya existe en la aceptación de la respuesta.
    • Sorta.. Pero no exactamente.
    • ¿cómo es tu mejor respuesta?
    • it&#39;s, obviamente, no se&#39;s en -2. Yo probablemente publicado esta tarde una noche, cuando yo estaba medio dormido después de mirar fijamente las pantallas de todo el día..
    • lol tiene sentido, han estado allí

Dejar respuesta

Please enter your comment!
Please enter your name here