Wie kann ich überprüfen, ob eine URL über PHP vorhanden ist?

Antworten:

296

Hier:

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

Von hier und direkt unter dem obigen Beitrag gibt es eine Curl- Lösung:

function url_exists($url) {
    if (!$fp = curl_init($url)) return false;
    return true;
}
karim79
quelle
18
Ich fürchte, der CURL-Weg wird so nicht funktionieren. Überprüfen Sie dies heraus: stackoverflow.com/questions/981954/…
viam0Zah
4
Einige Websites haben eine andere $file_headers[0]Fehlerseite. Zum Beispiel youtube.com. Die Fehlerseite hat den Wert HTTP/1.0 404 Not Found(Differenz ist 1.0 und 1.1). was dann tun?
Krishna Raj K
21
Vielleicht strpos($headers[0], '404 Not Found')könnte die Verwendung den Trick tun
alexandru.topliceanu
12
@ Mark stimmte zu! Zu klären strpos($headers[0], '404')ist besser!
alexandru.topliceanu
1
@ Karim79 Vorsicht vor SSRF- und XSPA-Angriffen
M Rostami
55

Wenn Sie herausfinden möchten, ob eine URL von PHP existiert, sollten Sie einige Dinge beachten:

  • Ist die URL selbst gültig (eine Zeichenfolge, nicht leer, gute Syntax), kann die Serverseite schnell überprüft werden.
  • Das Warten auf eine Antwort kann einige Zeit dauern und die Codeausführung blockieren.
  • Nicht alle von get_headers () zurückgegebenen Header sind gut geformt.
  • Verwenden Sie Locken (wenn Sie können).
  • Verhindern Sie das Abrufen des gesamten Körpers / Inhalts, sondern fordern Sie nur die Header an.
  • Überlegen Sie, URLs umzuleiten:
    • Möchten Sie den ersten Code zurückgeben?
    • Oder folgen Sie allen Weiterleitungen und geben Sie den letzten Code zurück?
    • Möglicherweise erhalten Sie eine 200, die jedoch mithilfe von Meta-Tags oder Javascript umgeleitet wird. Herauszufinden, was danach passiert, ist schwierig.

Denken Sie daran, dass es einige Zeit dauert, auf eine Antwort zu warten, egal welche Methode Sie verwenden.
Der gesamte Code wird möglicherweise (und wird wahrscheinlich) angehalten, bis Sie entweder das Ergebnis kennen oder die Anforderungen abgelaufen sind.

Beispiel: Der folgende Code kann lange dauern, bis die Seite angezeigt wird, wenn die URLs ungültig oder nicht erreichbar sind:

<?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/>";
}

Die folgenden Funktionen könnten hilfreich sein. Sie möchten sie wahrscheinlich an Ihre Bedürfnisse anpassen:

    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;
    }
MoonLite
quelle
Aus irgendeinem Grund gibt getHttpResponseCode_using_curl () in meinem Fall immer 200 zurück.
TD_Nijboer
2
Wenn jemand das gleiche Problem hat, überprüfen Sie DNS-Nameserver. Verwenden Sie opendns ohne followredirects stackoverflow.com/a/11072947/1829460
TD_Nijboer
+1 für die einzige Antwort, die sich mit Weiterleitungen befasst. Changed die return $codeauf if($code == 200){return true;} return false;nur aussortieren Erfolge
Birrel
@PKHunter: Nein. Mein schneller regulärer Ausdruck preg_match war ein einfaches Beispiel und stimmt nicht mit allen dort aufgeführten URLs überein. Siehe diese Test-URL: regex101.com/r/EpyDDc/2 Wenn Sie eine bessere wünschen, ersetzen Sie sie durch die auf Ihrem Link ( mathiasbynens.be/demo/url-regex ) von diegoperini aufgeführte. es scheint allen zu entsprechen, siehe diesen Testlink: regex101.com/r/qMQp23/1
MoonLite
46
$headers = @get_headers($this->_value);
if(strpos($headers[0],'200')===false)return false;

Jedes Mal, wenn Sie eine Website kontaktieren und etwas anderes als 200 erhalten, funktioniert es

lunarnet76
quelle
13
Aber was ist, wenn es sich um eine Weiterleitung handelt? Die Domain ist noch gültig, wird aber weggelassen.
Eric Leroy
4
Oben in einer Zeile : return strpos(@get_headers($url)[0],'200') === false ? false : true. Könnte nützlich sein.
Dejv
$ Dies ist in PHP eine Referenz auf das aktuelle Objekt. Referenz: php.net/manual/en/language.oop5.basic.php Grundierung : phpro.org/tutorials/Object-Oriented-Programming-with-PHP.html Höchstwahrscheinlich wurde das Code-Snippet einer Klasse entnommen und nicht entsprechend korrigiert .
Marc Witteveen
18

Sie können Curl auf bestimmten Servern nicht verwenden. Sie können diesen Code verwenden

<?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';
  }
?>
Minhaz
quelle
Es funktioniert möglicherweise nicht für 302-303 Weiterleitung oder zum Beispiel 304 Nicht geändert
Zippp
8
$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'.
Randy Skretka
quelle
2
Dies funktioniert nicht, wenn allow-url-fopen deaktiviert ist. - php.net/manual/en/…
Daniel Paul Searles
2
Ich würde vorschlagen, nur das erste Byte zu lesen ... if (@file_get_contents ($ url, false, NULL, 0,1))
Daniel Valland
8
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;
}
Leela
quelle
8

Ich benutze diese Funktion:

/**
 * @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";
    }
}
Ehsan
quelle
5

Die get_headers () -Lösung von karim79 hat bei mir nicht funktioniert, da ich mit Pinterest verrückte Ergebnisse erzielt habe.

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] => 
) 

Wie auch immer, dieser Entwickler zeigt, dass cURL viel schneller ist als get_headers ():

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

Da viele Leute nach karim79 gefragt haben, um die cURL-Lösung zu reparieren, ist hier die Lösung, die ich heute erstellt habe.

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

Lassen Sie mich die Curl-Optionen erklären:

CURLOPT_RETURNTRANSFER : Gibt eine Zeichenfolge zurück, anstatt die aufrufende Seite auf dem Bildschirm anzuzeigen.

CURLOPT_SSL_VERIFYPEER : cUrl checkt das Zertifikat nicht aus

CURLOPT_HEADER : Fügen Sie den Header in die Zeichenfolge ein

CURLOPT_NOBODY : Fügen Sie den Body nicht in die Zeichenfolge ein

CURLOPT_USERAGENT : Einige Websites benötigen dies, um ordnungsgemäß zu funktionieren (Beispiel: https://plus.google.com ).


Zusätzlicher Hinweis : In dieser Funktion verwende ich den regulären Ausdruck von Diego Perini zum Überprüfen der URL, bevor die Anfrage gesendet wird:

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

Zusätzlicher Hinweis 2 : Ich habe die Header-Zeichenfolge und die Benutzer-Header [0] aufgelöst, um sicherzustellen, dass nur der Rückkehrcode und die Nachricht überprüft werden (Beispiel: 200, 404, 405 usw.).

Zusätzlicher Hinweis 3 : Manchmal reicht es nicht aus, nur den Code 404 zu validieren (siehe Komponententest). Daher gibt es einen optionalen Parameter $ failCodeList, um die gesamte abzulehnende Codeliste bereitzustellen.

Und hier ist natürlich der Unit-Test (einschließlich aller beliebten sozialen Netzwerke), um meine Codierung zu legitimieren:

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

Großer Erfolg an alle,

Jonathan Parent-Lévesque aus Montreal

Jonathan Parent Lévesque
quelle
4
function urlIsOk($url)
{
    $headers = @get_headers($url);
    $httpStatus = intval(substr($headers[0], 9, 3));
    if ($httpStatus<400)
    {
        return true;
    }
    return false;
}
Spir
quelle
3

sehr schnell:

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');
Sebastian Lasse
quelle
Viel
Ja͢ck
Ich bekomme diese Ausnahme, wenn die URL existiert: Konnte die CURLOPT_HEADERFUNCTION
Safiot
3

Alle oben genannten Lösungen + zusätzlicher Zucker. (Ultimative AIO-Lösung)

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

Beispiel:

var_dump ( urlExists('http://stackoverflow.com/') );
// Output: true;
Junaid Atari
quelle
3

um zu überprüfen, ob die URL online oder offline ist ---

function get_http_response_code($theURL) {
    $headers = @get_headers($theURL);
    return substr($headers[0], 9, 3);
}
Hosam alzagh
quelle
3
function url_exists($url) {
    $headers = @get_headers($url);
    return (strpos($headers[0],'200')===false)? false:true;
}
Krishna Guragai
quelle
2

Hier ist eine Lösung, die nur das erste Byte des Quellcodes liest ... und false zurückgibt, wenn file_get_contents fehlschlägt ... Dies funktioniert auch für entfernte Dateien wie Bilder.

 function urlExists($url)
{
    if (@file_get_contents($url,false,NULL,0,1))
    {
        return true;
    }
    return false;
}
Daniel Valland
quelle
0

Der einfache Weg ist Curl (und SCHNELLER auch)

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

?>
T.Todua
quelle
0

Eine andere Möglichkeit, um zu überprüfen, ob eine URL gültig ist oder nicht, ist:

<?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;
      }
  }
?>
Antonio Carlos Barbosa
quelle
0

get_headers () gibt ein Array mit den Headern zurück, die vom Server als Antwort auf eine HTTP-Anforderung gesendet wurden.

$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>';
}
Jeacovy Gayle
quelle
0

cURL kann HTTP-Code zurückgeben Ich glaube nicht, dass all dieser zusätzliche Code notwendig ist?

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;
        }
    }
Arun Vitto
quelle
0

Eine Sache, die Sie berücksichtigen müssen, wenn Sie den Header für einen 404 überprüfen, ist der Fall, dass eine Site nicht sofort einen 404 generiert.

Viele Websites prüfen, ob eine Seite in der PHP / ASP-Quelle (usw.) vorhanden ist oder nicht, und leiten Sie an eine 404-Seite weiter. In diesen Fällen wird der Header im Wesentlichen um den Header des generierten 404 erweitert. In diesen Fällen ist der 404-Fehler nicht in der ersten Zeile des Headers, sondern in der zehnten.

$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 
) 
Lexib0y
quelle
0

Ich führe einige Tests durch, um festzustellen, ob Links auf meiner Website gültig sind. Warnt mich, wenn Dritte ihre Links ändern. Ich hatte ein Problem mit einer Site, die ein schlecht konfiguriertes Zertifikat hatte, was bedeutete, dass die get_headers von php nicht funktionierten.

Also las ich, dass Curl schneller war und beschloss, es zu versuchen. dann hatte ich ein Problem mit LinkedIn, das mir einen 999-Fehler gab, der sich als Benutzeragentenproblem herausstellte.

Es war mir egal, ob das Zertifikat für diesen Test nicht gültig war, und es war mir egal, ob die Antwort eine Umleitung war.

Dann dachte ich mir, ich benutze sowieso get_headers, wenn die Locke fehlschlägt ...

Probieren Sie es aus....

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

Art eines alten Threads, aber .. ich mache das:

$file = 'http://www.google.com';
$file_headers = @get_headers($file);
if ($file_headers) {
    $exists = true;
} else {
    $exists = false;
}
hackdotslashdotkill
quelle
Sorta .. Aber nicht genau.
Hackdotslashdotkill
Wie ist deine Antwort besser?
Jah
@Jah, es ist offensichtlich nicht bei -2. Ich habe wahrscheinlich so spät in der Nacht gepostet, als ich halb eingeschlafen war, nachdem ich den ganzen Tag auf Bildschirme
gestarrt hatte