अगर URL PHP के माध्यम से मौजूद है तो मैं कैसे जांच सकता हूं?

188

अगर PHP में कोई URL मौजूद है (404 नहीं) तो मैं कैसे जाँचूँ?

php  url 
— X10nD
स्रोत
3
— viam0Zah

जवाबों:

296

यहाँ:

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

से यहाँ और सही नीचे ऊपर पोस्ट, वहाँ एक है कर्ल समाधान:

function url_exists($url) {
    if (!$fp = curl_init($url)) return false;
    return true;
}
— karim79
स्रोत
18
मुझे डर है कि CURL-way इस तरह से काम नहीं करेगा। इसे देखें: stackoverflow.com/questions/981954/…
— viam0Zah
4
कुछ वेबसाइटों में $file_headers[0]त्रुटि पृष्ठ पर एक अलग है । उदाहरण के लिए, youtube.com। इसका त्रुटि पृष्ठ उस मान के रूप में है HTTP/1.0 404 Not Found(अंतर 1.0 और 1.1 है)। फिर क्या करना है?
— कृष्णा राज के
21
शायद का उपयोग strpos($headers[0], '404 Not Found')कर चाल हो सकता है
— alexandru.topliceanu
12
@ मर्क सहमत! स्पष्ट करने के लिए, strpos($headers[0], '404')बेहतर है!
— अलेक्जेंड्रू.टॉप्लिसनू
1
@ karim79 SSRF और XSPA के हमलों से सावधान रहें
— M
55

जब पता चलता है कि अगर एक यूआरएल php से मौजूद है, तो कुछ बातों पर ध्यान देना होगा:

  • क्या url अपने आप में मान्य है (एक स्ट्रिंग, खाली नहीं, अच्छा वाक्यविन्यास), यह सर्वर साइड की जाँच करने के लिए त्वरित है।
  • प्रतिक्रिया की प्रतीक्षा में समय लग सकता है और कोड निष्पादन पर रोक लग सकती है।
  • सभी हेडर get_headers () द्वारा वापस नहीं किए जाते हैं जो अच्छी तरह से बनते हैं।
  • कर्ल का उपयोग करें (यदि आप कर सकते हैं)।
  • पूरे शरीर / सामग्री को लाने से रोकें, लेकिन केवल हेडर का अनुरोध करें।
  • पुनर्निर्देशित यूआरएल पर विचार करें:
    • क्या आप पहला कोड वापस चाहते हैं?
    • या सभी पुनर्निर्देशन का पालन करें और अंतिम कोड लौटाएं?
    • आप 200 के साथ समाप्त हो सकते हैं, लेकिन यह मेटा टैग या जावास्क्रिप्ट का उपयोग करके पुनर्निर्देशित कर सकता है। यह पता लगाना कि आखिर क्या होता है।

ध्यान रखें कि आप जो भी विधि का उपयोग करते हैं, उसे प्रतिक्रिया की प्रतीक्षा करने में समय लगता है।
सभी कोड हो सकता है (और शायद) जब तक आप या तो परिणाम को रोक नहीं देंगे या अनुरोधों का समय समाप्त हो गया है।

उदाहरण के लिए: नीचे दिया गया कोड पृष्ठ को प्रदर्शित करने के लिए एक लंबा समय ले सकता है अगर यूआरएल अमान्य या अनुपलब्ध है:

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

नीचे दिए गए कार्य सहायक हो सकते हैं, आप शायद अपनी आवश्यकताओं के अनुरूप उन्हें संशोधित करना चाहते हैं:

    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
स्रोत
किसी कारण से getHttpResponseCode_using_curl () हमेशा मेरे मामले में 200 लौटाता है।
— TD_Nijboer
2
अगर किसी को एक ही समस्या है, तो dns-nameservers चेक करें .. opendns का उपयोग करें जिसमें कोई फॉलो-न किए गए stackoverflow.com/a/11072947/1829460
— TD_Nijboer
रीडायरेक्ट से निपटने के लिए एकमात्र उत्तर होने के लिए +1। केवल सफलताओं को छाँटने के return $codeलिए बदल दिया गयाif($code == 200){return true;} return false;
— बीरेल
@PKHunter: नहीं, मेरा त्वरित preg_match regex एक सरल उदाहरण था और इसमें सूचीबद्ध सभी url से मेल नहीं खाएगा। इस परीक्षण को देखें url: regex101.com/r/EpyDDc/2 यदि आप एक बेहतर चाहते हैं, तो उसे अपने लिंक पर सूचीबद्ध एक ( mathiasbynens.be/demo/url-regex ) के साथ डाईगॉपरिनी से बदलें; यह उन सभी से मेल खाता हुआ लगता है, इस टेस्टिंक को देखें: regex101.com/r/qMQp23/1
— मूनलाइट
46 
$headers = @get_headers($this->_value);
if(strpos($headers[0],'200')===false)return false;

इसलिए जब भी आप किसी वेबसाइट से संपर्क करते हैं और 200 से अधिक कुछ प्राप्त करते हैं तो यह काम करेगा

— lunarnet76
स्रोत
13
लेकिन क्या होगा अगर यह एक अनुप्रेषित है? डोमेन अभी भी मान्य है, लेकिन इसे छोड़ दिया जाएगा।
— एरिक लेरॉय
4
एक पंक्ति में ऊपर return strpos(@get_headers($url)[0],'200') === false ? false : true:। उपयोगी हो सकता है।
— देजव
$ यह PHP में है, वर्तमान वस्तु का संदर्भ है। संदर्भ: php.net/manual/en/language.oop5.basic.php प्राइमर: phpro.org/tutorials/Object-Oriented-Programming-with-PHP.html सबसे अधिक संभावना है कि कोड स्निपेट एक वर्ग से लिया गया था और तदनुसार निर्धारित नहीं किया गया था। ।
— मार्क विटिटेवेन
18

आप कुछ सर्वरों में कर्ल का उपयोग नहीं कर सकते हैं यू इस कोड का उपयोग कर सकते हैं

<?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
स्रोत
यह 302-303 पुनर्निर्देशित या उदाहरण के लिए नहीं हो सकता है 304 नहीं संशोधित
— 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'.
— रैंडी Skretka
स्रोत
2
यदि अनुमति-url-fopen बंद है तो यह काम नहीं करेगा। - php.net/manual/en/…
— डैनियल पॉल
2
मैं केवल पहली बाइट पढ़ने का सुझाव दूंगा ... अगर (@file_get_contents ($ url, false, NULL, 0,1))
— डैनियल वालैंड
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;
}
— लीला
स्रोत
8

मैं इस फ़ंक्शन का उपयोग करता हूं:

/**
 * @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";
    }
}
— एहसान
स्रोत
5

karim79 के get_headers () समाधान ने मेरे लिए काम नहीं किया क्योंकि मैंने 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] => 
)

वैसे भी, यह डेवलपर दर्शाता है कि cURL, get_headers () से अधिक तेज़ है:

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

चूँकि बहुत से लोगों ने karim79 को ठीक करने के लिए कहा, cURL समाधान है, यहाँ समाधान आज मैंने बनाया है।

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

मुझे कर्ल विकल्प बताते हैं:

CURLOPT_RETURNTRANSFER : स्क्रीन पर कॉलिंग पृष्ठ प्रदर्शित करने के बजाय एक स्ट्रिंग लौटाएं ।

CURLOPT_SSL_VERIFYPEER : cUrl प्रमाणपत्र की जांच नहीं करेगा

CURLOPT_HEADER : स्ट्रिंग में हेडर शामिल करें

CURLOPT_NOBODY : शरीर को स्ट्रिंग में शामिल नहीं करता है

CURLOPT_USERAGENT : कुछ साइट को ठीक से काम करने की जरूरत है (उदाहरण के लिए: https://plus.google.com )

अतिरिक्त नोट : इस फ़ंक्शन में मैं अनुरोध भेजने से पहले URL को मान्य करने के लिए डिएगो पेरीनी के रेगेक्स का उपयोग कर रहा हूं:

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

अतिरिक्त नोट 2 : मैं हेडर स्ट्रिंग और उपयोगकर्ता हेडर को विस्फोटित करता हूं [0] केवल रिटर्न कोड और संदेश को सत्यापित करने के लिए सुनिश्चित करें (उदाहरण: 200, 404, 405, आदि)

अतिरिक्त नोट 3 : कभी-कभी केवल 404 कोड को मान्य करने के लिए पर्याप्त नहीं है (इकाई परीक्षण देखें), इसलिए अस्वीकार करने के लिए सभी कोड सूची की आपूर्ति करने के लिए वैकल्पिक $ failCodeList पैरामीटर है।

और, ज़ाहिर है, मेरी कोडिंग को वैध बनाने के लिए यहां इकाई परीक्षण (सभी लोकप्रिय सामाजिक नेटवर्क सहित):

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

सभी को बड़ी सफलता,

मॉन्ट्रियल से जोनाथन पैरेंट-लेवेस्क

— जोनाथन पैरेंट लेवेस्क
स्रोत
4 
function urlIsOk($url)
{
    $headers = @get_headers($url);
    $httpStatus = intval(substr($headers[0], 9, 3));
    if ($httpStatus<400)
    {
        return true;
    }
    return false;
}
— Spir
स्रोत
3

काफ़ी जल्दी:

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');
— सेबस्टियन लास
स्रोत
रास्ता बहुत जटिल :) stackoverflow.com/questions/981954/…
— Ja Mayck
मैं जब url मौजूद इस exceptionn मिलती है: CURLOPT_HEADERFUNCTION फोन नहीं किया जा सका
— safiot
3

उपरोक्त सभी समाधान + अतिरिक्त चीनी। (अंतिम AIO समाधान) 

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

उदाहरण: 

var_dump ( urlExists('http://stackoverflow.com/') );
// Output: true;
— जुनैद अटारी
स्रोत
3

यह देखने के लिए कि क्या url ऑनलाइन या ऑफलाइन है ---

function get_http_response_code($theURL) {
    $headers = @get_headers($theURL);
    return substr($headers[0], 9, 3);
}
— होसम आलजाग
स्रोत
2

यहाँ एक समाधान है जो केवल स्रोत कोड के पहले बाइट को पढ़ता है ... यदि file_get_contents विफल हो जाता है तो गलत लौट रहा है ... यह छवियों की तरह दूरस्थ फ़ाइलों के लिए भी काम करेगा।

 function urlExists($url)
{
    if (@file_get_contents($url,false,NULL,0,1))
    {
        return true;
    }
    return false;
}
— डैनियल वालैंड
स्रोत
0

सरल तरीका कर्ल है (और तेजी से भी)

<?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
स्रोत
0

यह जांचने का अन्य तरीका है कि URL मान्य है या नहीं:

<?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;
      }
  }
?>
— एंटोनियो कार्लोस बारबोसा
स्रोत
0

get_headers () 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>';
}
— जेकोवी गेल
स्रोत
0

CURL HTTP कोड वापस कर सकता है मुझे नहीं लगता कि सभी अतिरिक्त कोड आवश्यक हैं?

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;
        }
    }
— अरुण विट्टो
स्रोत
0

जब आप 404 के हेडर की जांच करते हैं, तो एक बात ध्यान में रखना चाहिए कि कोई साइट तुरंत 404 उत्पन्न नहीं करती है।

बहुत सारी साइटें यह जांचती हैं कि पृष्ठ PHP / ASP (et cetera) स्रोत में मौजूद है या नहीं और आपको 404 पृष्ठ पर अग्रेषित करता है या नहीं। उन मामलों में हेडर मूल रूप से उत्पन्न 404 के हेडर द्वारा बढ़ाया जाता है। उन मामलों में हेडर की पहली पंक्ति में 404 त्रुटि नहीं है, लेकिन दसवां है।

$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
स्रोत
0

मैं यह देखने के लिए कुछ परीक्षण चलाता हूं कि क्या मेरी साइट के लिंक वैध हैं - मुझे अलर्ट करें जब तीसरे पक्ष अपने लिंक बदलते हैं। मैं एक साइट है कि खराब कॉन्फ़िगर प्रमाण पत्र था कि php get_headers काम नहीं किया था के साथ एक समस्या थी।

एसओ, मैंने पढ़ा कि कर्ल तेज़ था और यह तय किया कि उसे जाना होगा। तब मैंने लिंक्डइन के साथ एक मुद्दा दिया था जिसने मुझे एक 999 त्रुटि दी, जो एक उपयोगकर्ता एजेंट मुद्दा बन गया।

मुझे परवाह नहीं थी अगर प्रमाण पत्र इस परीक्षण के लिए मान्य नहीं था, और अगर प्रतिक्रिया फिर से प्रत्यक्ष थी तो मुझे परवाह नहीं थी।

फिर मुझे लगा कि अगर कोई कर्ल फेल हो रहा हो तो get_headers का इस्तेमाल करें ...।

इसकी कोशिश करें....

/**
 * 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
स्रोत
-2

एक पुराने धागे की तरह, लेकिन .. मैं यह करता हूं:

$file = 'http://www.google.com';
$file_headers = @get_headers($file);
if ($file_headers) {
    $exists = true;
} else {
    $exists = false;
}
— hackdotslashdotkill
स्रोत
Sorta .. लेकिन बिल्कुल नहीं।
— 21
आपका जवाब बेहतर कैसे है?
— जह
@ जह यह स्पष्ट रूप से नहीं, -2 पर है। मैंने शायद देर रात एक पोस्ट किया जब मैं पूरे दिन स्क्रीन पर घूरने के बाद आधा सो रहा था ..
— Hackdotslashdotkill
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.