प्रकार-बाजीगरी और (सख्त) PHP में तुलनात्मक रूप से अधिक / कम

115

PHP अपने प्रकार-बाजीगरी के लिए प्रसिद्ध है। मुझे इसकी पहेली माननी चाहिए, और तुलना में बुनियादी तार्किक / मौलिक चीजों का पता लगाने के लिए मेरे पास कठिन समय है।

उदाहरण के लिए: अगर $a > $bसच है और $b > $cसच है, इसका मतलब यह होगा कि $a > $cहै हमेशा भी सच?

बुनियादी तर्क के बाद, मैं हां कहूंगा लेकिन मैं हैरान हूं कि मुझे वास्तव में इस पर भरोसा नहीं है। शायद कोई ऐसा उदाहरण दे सकता है जहां यह मामला नहीं है?

इसके अलावा, मैं सख्त-से-कम और सख्त से अधिक ऑपरेटरों के साथ सोच रहा हूं (जैसा कि उनका अर्थ कड़ाई से वर्णित है जिसे मैं केवल समानता तुलना से अतीत में जानता था) अगर इसे कोई अंतर पड़ता है तो बाएं और दाएं ऑपरेंड के साथ स्वैप किया जाता है सख्ती से असमान मूल्य:

# Precondition:
if ($a === $b) {
    throw new Exception(
       'Both are strictly equal - can not compare strictly for greater or smaller'
    );
}

($a > $b) !== ($b > $a)

सभी प्रकार के तुलनात्मक संयोजनों में से अधिकांश के लिए इन अधिक / कम तुलना संचालकों को प्रलेखित नहीं किया जाता है, इसलिए इस मामले में मैनुअल पढ़ना वास्तव में सहायक नहीं था।

php  if-statement  comparison  logic  ieee-754 
— hakre
स्रोत
मुझे लगता है कि आप उस रेखा को ठीक करना चाहते हैं ($a > $b) !== ($b < $a)?
— वाल्टर ट्रॉस
आह, ठीक है, तो मैंने गलत समझा। मेरे हिसाब से अपना जवाब तय करना होगा। मज़ेदार उन सभी लोगों को लिखते हैं जो उत्तर के बजाय व्यवहार करते हैं और आपके प्रश्न को ध्यान से नहीं पढ़ते हैं ...
— वाल्टर ट्रॉस

जवाबों:

208

PHP के तुलनात्मक ऑपरेटर कंप्यूटर-वैज्ञानिक परिभाषा से कई मायनों में विचलित करते हैं:

एक समतुल्य संबंध == का गठन करने के लिए रिफ्लेक्टिव, सममित और सकर्मक होना चाहिए:

  • PHP का ==ऑपरेटर रिफ्लेक्टिव नहीं है , यानी $a == $aहमेशा सच नहीं होता है:

    var_dump(NAN == NAN); // bool(false)

    नोट: तथ्य यह है कि किसी भी तुलना में शामिल NANहमेशा falsePHP के लिए विशिष्ट नहीं है। इसे IEEE 754 Standard द्वारा Floating-Point Arithmetic ( अधिक जानकारी ) के लिए अनिवार्य किया गया है ।

  • PHP के ==ऑपरेटर है सममित , यानी $a == $bऔर $b == $aहमेशा एक ही कर रहे हैं।

  • PHP का ==ऑपरेटर ट्रांज़िटिव नहीं है , अर्थात इससे $a == $bऔर $b == $cइसका अनुसरण नहीं करता है $a == $c:

    var_dump(true == "a"); // bool(true)
var_dump("a" == 0);    // bool(true)
var_dump(true == 0);   // bool(false)

आंशिक आदेश का गठन करने के लिए <=/ >=रिफ्लेक्सिव, एंटी-सममित और संक्रमणीय होना चाहिए:

  • PHP का <=ऑपरेटर रिफ्लेक्टिव नहीं है , यानी $a <= $aहमेशा सही नहीं होता (उदाहरण के लिए जैसा है ==)।

  • PHP के <=ऑपरेटर है विरोधी सममित नहीं , से यानी $a <= $bऔर $b <= $aपालन नहीं करता है $a == $b:

    var_dump(NAN <= "foo"); // bool(true)
var_dump("foo" <= NAN); // bool(true)
var_dump(NAN == "foo"); // bool(false)

  • PHP के <=ऑपरेटर है सकर्मक नहीं से, यानी $a <= $bऔर $b <= $cपालन नहीं करता है $a <= $c(के लिए के रूप में उदाहरण एक ही ==)।

  • अतिरिक्त: PHP के <=ऑपरेटर है नहीं कुल , दोनों यानी $a <= $bऔर $b <= $aगलत हो सकते हैं:

    var_dump(new stdClass <= new DateTime); // bool(false)
var_dump(new DateTime <= new stdClass); // bool(false)

आदेश में एक सख्त आंशिक आदेश का गठन </ >अकाट्य, असममित और सकर्मक होना चाहिए:

  • PHP का <ऑपरेटर अकाट्य है , यानी $a < $aकभी सच नहीं है। ध्यान दें कि यह केवल PHP 5.4 के रूप में सच है । पहले इसका INF < INFमूल्यांकन किया गया था true।

  • PHP का <ऑपरेटर असममित नहीं है , अर्थात $a < $bइसका अनुसरण नहीं किया !($b < $a)जाता है (उदाहरण <=सम-विरोधी सममित नहीं होने के कारण)।

  • PHP के <ऑपरेटर है सकर्मक नहीं से, यानी $a < $bऔर $b < $cपालन नहीं करता है $a < $c:

    var_dump(-INF < 0);    // bool(true)
var_dump(0 < TRUE);    // bool(true)
var_dump(-INF < TRUE); // bool(false)

  • अतिरिक्त: PHP का <ऑपरेटर ट्रिकोटोमस नहीं है , यानी सभी $a < $b, $b < $aऔर $a == $bगलत हो सकता है (उदाहरण के लिए <=कुल नहीं होने के रूप में )।

  • अतिरिक्त: PHP का <ऑपरेटर गोलाकार हो सकता है , अर्थात यह संभव है $a < $b, $b < $cऔर $c < $a:

    var_dump(INF < []);           // bool(true)
var_dump([] < new stdClass);  // bool(true)
var_dump(new stdClass < INF); // bool(true)

    नोट: उपरोक्त उदाहरण "क्लास स्टैडक्लास की वस्तु को डबल में परिवर्तित नहीं किया जा सकता है" नोटिस फेंकता है।

आप PHP के तुलना ऑपरेटरों के लिए कुछ अच्छा रेखांकन पा सकते हैं PHP दु: ख 52 - तुलना ऑपरेटरों ।

एक अंतिम नोट के रूप में, मैं यह बताना चाहता हूं कि दो समानताएं हैं जो पीएचपी गारंटी देती हैं ( बिल्कुल बाकी सब कुछ के विपरीत)। ये दोनों हमेशा पकड़ते हैं, बस इसलिए कि कंपाइलर एक को कम करता है:

($a > $b) == ($b < $a)
($a >= $b) == ($b <= $a)
— NikiC
स्रोत
2
वाह, अच्छा एवर। तो यह संभव नहीं है कि PHP के साथ तार्किक अभिव्यक्तियों को तैयार ($a > $b) and ($b > $c)किया जाए, $a > $cभले ही प्रलेखन कहता है कि वे </ >ऑपरेटर कहते हैं कि वे सख्त हैं ?
— १६
26
IMHO ऑपरेटर गणित के नियमों का पालन करते हैं, लेकिन केवल उसी डेटा प्रकार के साथ काम करते समय। टाइप कास्टिंग वास्तव में यहाँ भ्रम पैदा करती है (और कई अन्य स्थितियों में)। जब संख्या और तार और विशेष मानों की तुलना संचालकों से पहले की जाती है, तो कड़ाई से बोलने वाले तुलना संचालक भ्रमित नहीं कर रहे हैं, कास्टिंग है ...
— ivanhoe
6
@ ivanhoe011 सच्चाई यह है: दोनों ही हैं :) PHP के तुलनात्मक नियम और PHP के कास्टिंग नियम भिन्न हैं , आप बस यह नहीं कह सकते कि $a == $bयह समान है (type) $a === (type) $b। इसका एक सरल उदाहरण है "15" == "0xf", लेकिन (int) "15" !== (int) "0xf"। और PHP में तुलना और कास्टिंग दोनों नियम पूरी तरह से पागल हैं ^ ^
— NikiC
3
@NikiC: (int)"0xf"पूर्णांक का मूल्यांकन करता है 0, तो निश्चित रूप से 0 !== 15। इस उदाहरण में तुलना अपेक्षा के अनुरूप व्यवहार करती है। यह कास्टिंग है जो यहां भ्रमित कर रही है। मैं मानता हूँ, (INF < INF) === trueएक वास्तविक तुलना समस्या थी, लेकिन यह एक विशेष मामला था, और जैसा कि आपने बताया है यह हल हो गया है। शानदार जवाब .. +1
— FtDRbwLXw6
1
मैं जरूरी नहीं कि PHP के डिजाइनरों ने कुछ ऐसे फैसलों के लिए गलती की है जो उस समय प्रकार के जबरदस्ती के बारे में समझ में आया था ... लेकिन मुझे ऐसा लगता है कि इन डिज़ाइन विकल्पों के परिणामों पर ध्यान देना चाहिए और तुरंत विकल्पों को महसूस करना स्पष्ट रूप से गलत था। सबसे स्पष्ट उदाहरण @ ravz की टिप्पणी है।
— चाड
88

हैं कोई सख्त समान तुलना ऑपरेटरों ( >==या <==) PHP में (PHP 5.6.14 कम से कम द्वारा) , लेकिन वहाँ के लिए कुछ तरीके हैं एक सख्त प्रकार की जांच लागू ग्रेटर / लोअर की जाँच से पहले:

  1. दोनों चर प्रकारों की जाँच करें if (gettype($a) === gettype($b))
  2. अपने ज़रूरी टाइप-कास्ट जैसे फोर्स। if ((string)$a === (string)$b)
  3. अपने ज़रूरी टाइप-जॉगल को फोर्स करें। if (($a . '') === ($b . ''))

ध्यान दें कि:

  • फ़्लोटिंग पॉइंट सटीक सीमित है
  • INFऔर NANप्रकार के floatअंतर्गत हैंieee754
  • कुछ इन्फिनिटी कुछ अन्य के बराबर होती है इन्फिनिटी (के बाद से पीएचपी 5.4)
  • वैज्ञानिक संकेतन eहमेशा प्रकार का होता है float, और कभी integerभी संख्या छोटी नहीं होती है
  • खत्म होने वाले इंटीजर PHP_INT_MAXअपने आप बदल जाते हैंfloat
  • सिस्टम की सीमाओं से अधिक के फ्लैटों को INFमूल्य मिलता है
  • अपरिभाषित चर प्रकार और मूल्य के होते हैं NULL
  • इससे पहले के इंटीग्रर्स 0को ऑक्टल से दशमलव (कन्वेंशन द्वारा) में बदल दिया जाता है
  • एक पूर्णांक के साथ एक पूर्णांक युक्त स्ट्रिंग्स को परिवर्तित 0 करने से अग्रणी पूर्ण हो जाता है0

कुछ विदेशी तुलनाओं की सूची:

बहुत अजीब:
     $ एक वी.एस. $ b $ a> $ b $ a <$ b $ a <= $ b $ a = = $ b $ a == $ b $ a === $ b
  float (NAN) float (-INF) झूठी झूठी झूठी झूठी झूठी झूठी
  float (NAN) float (0) झूठी झूठी झूठी झूठी झूठी झूठी
  float (NAN) float (1) झूठी झूठी झूठी झूठी झूठी झूठी
  float (NAN) float (INF) झूठी झूठी झूठी झूठी झूठी
  float (NAN) float (NAN) झूठी झूठी झूठी झूठी झूठी झूठी
  float (NAN) int (-1) झूठी झूठी झूठी झूठी झूठी
  फ्लोट (नान) int (0) झूठी झूठी झूठी झूठी झूठी
  float (NAN) int (1) झूठी झूठी झूठी झूठी झूठी

समान लेकिन समान नहीं:

     $ एक वी.एस. $ b $ a> $ b $ a <$ b $ a <= $ b $ a = = $ b $ a == $ b $ a === $ b

  NULL (NULL) सरणी () गलत गलत सही सच true झूठ
  NULL (NULL) बूल (झूठा) झूठे सच्चे सच्चे सच्चे झूठे
  NULL (NULL) फ्लोट (0) झूठी झूठी सच्ची सच्ची झूठी
  NULL (NULL) int (0) झूठी झूठी सच्ची सच्ची झूठी
  NULL (NULL) str ('') झूठे सच्चे सच्चे सच्चे झूठे
   array () बूल (झूठी) झूठी झूठी सच्ची सच्ची true false
 बूल (असत्य) फ्लोट (0) असत्य सच्चा सच्चा सच्चा झूठा
 bool (झूठी) int (0) झूठी झूठी सच्ची सच्ची झूठी
   str ('') bool (मिथ्या) झूठे सच्चे सच्चे सच्चे झूठे
 bool (झूठे) str ('0') false false सच सच true false
 फ्लोट (-INF) बूल (सच्चा) झूठा सच्चा सच्चा सच्चा झूठा
  बूल (सच्चा) नाव (१) झूठा सच्चा सच्चा सच्चा झूठा
  float (INF) बूल (सच्चा) झूठा सच्चा सच्चा सच्चा झूठा
  फ्लोट (नान) बूल (सच्चा) झूठा सच्चा सच्चा सच्चा झूठा
  बूल (सच्चा) int (-1) असत्य सच्चा सच्चा सच्चा झूठा
  bool (true) int (1) झूठी झूठी सच्ची सच्ची झूठी
  बूल (सच्चा) str ("\ 0") झूठी झूठी सच्ची सच्ची झूठी
  bool (true) str ('+') false true सच सच false
  bool (true) str ('-') false false true सच सच्चा false
  bool (सच्चा) str ('01 ') false true सच सच false
  bool (सच्चा) str ('1') false true true true सच्चा false
  बूल (सच्चा) str ('गलत') false true true true असत्य
 str ('text') बूल (सत्य) असत्य असत्य सच्चा सच्चा असत्य
 str ('true') बूल (सत्य) असत्य असत्य सत्य असत्य असत्य
    int (०) फ्लोट (०) झूठी झूठी सच्ची सच्ची झूठी
  str ("\ 0") float (0) झूठी झूठी सच्ची सच्ची झूठी
   str ('') float (0) झूठी झूठी सच्ची सच्ची झूठी
   str ('+') float (0) false false सच सच true false
   str ('-') float (0) झूठी झूठी सच्ची सच्ची झूठी
   str ('0') float (0) झूठी झूठी सच्ची सच्ची झूठी
 str (false false ’) float (0) false false सच सच true false
 str (false text ’) float (0) false false सच सच true false
 str ('true') float (0) false false सच ट्रू true
    int (1) फ्लोट (1) असत्य असत्य सच्चा सच्चा असत्य
   float (1) str ('01 ') false false सच सच true false
   float (1) str ('1') false true true true सच गलत
  str ("\ 0") int (0) गलत गलत सही सच गलत
   str ('') int (0) झूठी झूठी सच्ची सच्ची झूठी
   str ('+') int (0) झूठी झूठी सच्ची सच्ची झूठी
   str ('-') int (0) झूठी झूठी सच्ची सच्ची झूठी
    int (0) str ('0') झूठी झूठी सच्ची सच्ची झूठी
 str (true false ’) int (0) गलत गलत सही सच है
 str (true text ’) int (0) गलत गलत सच true true
 str ('true') int (0) गलत गलत सच true true
    int (1) str ('01 ') झूठी झूठी सच्ची सच्ची झूठी
    int (1) str ('1') असत्य असत्य सच्चा सच्चा असत्य
   str ('1') str ('01 ') झूठी झूठी सच्ची सच्ची झूठी

एक ही समय में कम और अधिक?

     $ एक वी.एस. $ b $ a> $ b $ a <$ b $ a <= $ b $ a = = $ b $ a == $ b $ a === $ b
  float (NAN) str ("\ 0") सच्चा सच्चा सच्चा सच्चा खोटा
  float (NAN) str ('') सच्चा सच्चा सच्चा सच्चा खोटा
  float (NAN) str ('+') सच्चा सच्चा सच्चा सच्चा खोटा
  float (NAN) str ('-') सच्चा सच्चा सच्चा खोटा खोटा
  float (NAN) str ('0') सच्चा सच्चा सच्चा सच्चा खोटा
  float (NAN) str ('01 ') सच्चा सच्चा सच्चा सच्चा खोटा
  float (NAN) str ('1') सच्चा सच्चा सच्चा सच्चा खोटा
  float (NAN) str ('मिथ्या') सच्चा सच्चा सच्चा सच्चा झूठी
  float (NAN) str ('text') सच्चा सच्चा सच्चा सच्चा खोटा
  float (NAN) str ('true ’) सच्चा सच्चा सच्चा सच्चा खोटा

समान और समान:

     $ एक वी.एस. $ b $ a> $ b $ a <$ b $ a <= $ b $ a = = $ b $ a == $ b $ a === $ b
  NULL (NULL) NULL (NULL) झूठी झूठी सच्ची सच्ची सच्ची सच्ची
 float (-INF) float (-INF) झूठी झूठी सच्ची सच्ची सच्ची सच्ची
  float (INF) float (INF) झूठी झूठी सच्ची सच्ची सच्ची सच्ची

कम या अधिक:

     $ एक वी.एस. $ b $ a> $ b $ a <$ b $ a <= $ b $ a = = $ b $ a == $ b $ a === $ b

  NULL (NULL) बूल (सच्चा) झूठा सच्चा खोटा खोटा
 फ्लोट (-INF) NULL (NULL) सच्चा झूठा सच्चा झूठी झूठी
  NULL (NULL) फ्लोट (1) गलत सही सच गलत झूठी
  float (INF) NULL (NULL) सच्चा झूठा सच्चा झूठी झूठी
  float (NAN) NULL (NULL) सच्चा झूठा सच्चा झूठा सच
  NULL (NULL) int (-1) गलत सही सच गलत झूठी
  NULL (NULL) int (1) गलत सही सच गलत झूठी
  NULL (NULL) str ("\ 0") गलत सही सच गलत झूठी
  NULL (NULL) str ('+') झूठी सच्ची झूठी झूठी झूठी
  NULL (NULL) str ('-') false true true झूठी झूठी
  NULL (NULL) str ('0') झूठी सच्ची बात झूठी झूठी
  NULL (NULL) str ('01 ') झूठी सच्ची बात झूठी झूठी
  NULL (NULL) str ('1') झूठी सच्ची झूठी झूठी झूठी
  NULL (NULL) str ('गलत') false true true, false
  NULL (NULL) str ('पाठ') गलत सही सच गलत झूठी
  NULL (NULL) str ('true') false true सच गलत गलत
   अरै () बूल (सच्चा) झूठा सच्चा सच्चा झूठा झूठा
 फ्लोट (-INF) सरणी () गलत सही सच गलत झूठी
   अरै () फ्लोट (०) सच्चा झूठा सच्चा झूठा झूठा
   अरै () फ्लोट (१) सच्चा झूठा सच्चा झूठा झूठा
  फ्लोट (INF) सरणी () गलत सही सच गलत झूठी
  फ्लोट (NAN) सरणी () गलत सही सच गलत झूठी
   array () int (-1) true false सच सच गलत
   array () int (0) true false सच सच गलत
   array () int (1) true false सच सच गलत
   सरणी () str ("\ 0") सही गलत सही सच गलत है
   str ('') array () असत्य सच true असत्य false
   array () str ('+') true false सच सच गलत false
   array () str ('-') true false सही सच गलत false
   array () str ('0') true false सच सच गलत
   array () str ('01 ') true false पर सही गलत गलत
   array () str ('1') true false पर सही गलत गलत
   array () str ('गलत') true false पर सही गलत गलत
   array () str ('टेक्स्ट') true false पर सही गलत गलत
   array () str ('ट्रू') true false सच सच false
  बूल (सच्चा) बूल (झूठा) सच्चा झूठा सच्चा झूठा झूठा
 फ्लोट (-INF) बूल (झूठा) सच्चा झूठा सच्चा झूठा झूठा
   फ्लोट (1) बूल (झूठा) सच्चा झूठा सच्चा झूठा झूठा
  float (INF) बूल (झूठा) सच्चा झूठा सच्चा झूठा झूठा
  float (NAN) बूल (झूठा) सच्चा झूठा सच्चा झूठा झूठा
 bool (झूठी) int (-1) झूठी सच्ची झूठी झूठी झूठी
    int (1) बूल (झूठा) सच्चा झूठा सच्चा झूठा
 bool (झूठी) str ("\ 0") झूठी सच्ची झूठी झूठी झूठी
 bool (झूठे) str ('+') false true true झूठे झूठे
 bool (झूठे) str ('-') false true true झूठे झूठे
 bool (झूठे) str ('01 ') false true true झूठे झूठे
   str ('1') बूल (असत्य) सच्चा झूठा सच्चा झूठा झूठा
 bool (झूठे) str ('झूठे') false true true झूठे झूठे
 str ('text') बूल (झूठा) सच्चा झूठा सच्चा झूठा झूठा
 str ('true') बूल (झूठा) सच्चा झूठा सच असत्य झूठा
  बूल (सच्चा) नाव (०) सच्चा झूठा सच्चा झूठा झूठा
  बूल (सच्चा) इंट (०) सच्चा झूठा सच्चा झूठा
   str ('') bool (सत्य) असत्य सत्य असत्य असत्य असत्य
  bool (सच्चा) str ('0') true false, सच में गलत
 फ्लोट (-INF) फ्लोट (0) गलत सच सच गलत झूठी
 फ्लोट (-INF) फ्लोट (1) गलत सच सच गलत झूठी
  float (INF) float (-INF) सच्चा झूठा सच खोटा झूठा
 फ्लोट (-INF) int (-1) गलत सच सच गलत झूठी
 फ्लोट (-INF) int (0) गलत सच सच गलत झूठी
 फ्लोट (-INF) int (1) असत्य सत्य असत्य असत्य असत्य
 फ्लोट (-INF) str ("\ 0") गलत सही सच गलत झूठी
 float (-INF) str ('') false true true झूठी झूठी
 फ्लोट (-INF) str ('+') गलत सही सच गलत झूठी
 float (-INF) str ('-') असत्य सत्य असत्य असत्य असत्य
 फ्लोट (-INF) str ('0') गलत सही सच गलत झूठी
 फ्लोट (-INF) str ('01 ') गलत सही सच गलत झूठी
 float (-INF) str ('1') असत्य सत्य असत्य असत्य असत्य
 float (-INF) str ('गलत') false true true, false
 फ्लोट (-INF) str ('टेक्स्ट') गलत सही सच गलत झूठी
 float (-INF) str ('true') false true सच गलत false false
   float (1) float (0) true false सही सच false झूठी
  float (INF) float (0) true false सही सच false झूठी
   फ्लोट (०) इंट (१) सच्चा झूठा सच्चा झूठा
    int (१) फ्लोट (०) सच्चा झूठा सच्चा झूठा झूठा
   float (0) str ('01 ') false true true झूठी झूठी
   str ('1') float (0) true false पर सही सही गलत पर गलत है
  float (INF) float (1) सच्चा झूठी झूठी झूठी झूठी
   float (1) int (-1) true false सही सच गलत
   float (1) int (0) true false सही सच गलत
   फ्लोट (1) str ("\ 0") सच गलत गलत सही गलत
   str ('') float (1) झूठी सच्ची झूठी झूठी झूठी
   float (1) str ('+') true false पर सही गलत गलत
   float (1) str ('-') true false पर सही गलत गलत
   float (1) str ('0') true false पर सही सही गलत
   float (1) str ('गलत') true false पर सही सही पर गलत है
 str (true text ’) float (1) false true true false, गलत है
 str ('true') float (1) असत्य सत्य असत्य असत्य असत्य
  float (INF) int (-1) सच्चा झूठा सच्चा झूठा झूठ
  float (INF) int (0) सच गलत झूठी झूठी झूठी
  float (INF) int (1) सच्चा झूठा सच्चा झूठा झूठ
  float (INF) str ("\ 0") सच गलत गलत सही गलत
  float (INF) str ('') सच गलत झूठी सच्ची झूठी झूठी
  float (INF) str ('+') true false पर सही गलत गलत
  float (INF) str ('-') true false पर सही गलत गलत
  float (INF) str ('0') true false सही सच गलत false
  float (INF) str ('01 ') सच्चा झूठा सच असत्य झूठा
  float (INF) str ('1') सच्चा झूठा सच्चा झूठा झूठ
  float (INF) str ('गलत') true false पर सही सही पर गलत है
  float (INF) str ('टेक्स्ट') सच्चा झूठा सच असत्य झूठा
  float (INF) str ('true') true false सही सच false
    int (0) int (-1) सच्चा झूठा सच्चा झूठा झूठ
    int (1) int (-1) सच्चा झूठा सच्चा झूठा झूठ
  str ("\ 0") int (-1) true false पर सही गलत गलत
   str ('') int (-1) सच्चा झूठा सच्चा झूठी झूठी
   str ('+') int (-1) सच्चा झूठा सच्चा झूठी झूठी
   str ('-') int (-1) सच्चा झूठा सच्चा झूठी झूठी
   str ('0') int (-1) सच्चा झूठा सच्चा झूठी झूठी
   int (-1) str ('01 ') असत्य सत्य असत्य असत्य असत्य
   str ('1') int (-1) सच्चा झूठा सच्चा झूठा झूठ
 str (false false ’) int (-1) सच्चा झूठा सच्चा झूठी झूठी
 str (false text ’) int (-1) सच्चा झूठा सच्चा खोटा
 str (false true ’) int (-1) true false पर सही गलत गलत
    int (१) int (०) सच्चा झूठा सच्चा झूठा झूठ
    int (0) str ('01 ') गलत सही सच गलत गलत
   str ('1') int (0) सच गलत झूठी झूठी झूठी
    int (1) str ("\ 0") सच गलत गलत सही गलत
   str ('') int (1) असत्य सत्य असत्य असत्य असत्य
    int (1) str ('+') true false पर सही गलत गलत
    int (1) str ('-') true false पर सही गलत गलत
    int (1) str ('0') true false पर सही गलत गलत
    int (1) str ('गलत') true false पर सही गलत पर गलत
 str ('text') int (1) गलत सही सच, गलत झूठी
 str ('true') int (1) असत्य सत्य असत्य असत्य असत्य
   str ('') str ("\ 0") झूठी सच्ची झूठी झूठी झूठी
   str ('+') str ("\ 0") true false पर सही गलत गलत
   str ('-') str ("\ 0") सच गलत झूठी सच्ची झूठी झूठी
  str ("\ 0") str ('0') false true true, false, गलत
  str ("\ 0") str ('01 ') झूठी सच्ची झूठी झूठी झूठी
   str ('1') str ("\ 0") true false पर सही गलत गलत
 str () false ’) str (" \ 0 ") true false पर सही गलत गलत
 str ('text') str ("\ 0") true false पर सही गलत गलत
 str ('true') str ("\ 0") true false पर सही सही गलत पर गलत
   str ('') str ('+') false true true झूठी झूठी
   str ('') str ('-') false true true झूठी झूठी
   str ('') str ('0') झूठी सच्ची झूठी झूठी झूठी
   str ('') str ('01 ') झूठी सच्ची झूठी झूठी झूठी
   str (true ’) str ('1’) असत्य सच्चा असत्य असत्य असत्य
   str ('') str ('false') false true true झूठी झूठी
   str ('') str ('text') असत्य सत्य असत्य असत्य असत्य
   str ('') str ('true') असत्य सत्य असत्य असत्य असत्य
   str ('-') str ('+') true false पर सही गलत गलत
   str ('+') str ('0') झूठी सच्ची झूठी झूठी झूठी
   str (false + ’) str ('01’) false true सच गलत false false
   str ('1') str ('+') true false पर सही सही गलत पर गलत
 str (false false ’) str ('+’) true false पर सही गलत पर गलत है
 str ('text') str ('+') true false पर सही सही गलत
 str (true true ’) str ('+’) true false पर सही गलत पर गलत है
   str ('-') str ('0') झूठी सच्ची झूठी झूठी झूठी
   str ('-') str ('01 ') false true true झूठी झूठी
   str ('1') str ('-') true false पर सही सही गलत
 str (true false ’) str (’ - ’) true false पर सही गलत पर गलत है
 str ('text') str ('-') true false पर सही सही गलत पर गलत
 str (true true ’) str (’ - ’) true false पर सही सही गलत पर गलत
   str ('0') str ('01 ') false true true झूठी झूठी
   str ('1') str ('0') true false पर सही गलत गलत
 str (false false ’) str ('0’) true false पर सही गलत पर गलत
 str ('text') str ('0') true false पर सही सही गलत पर गलत
 str (true true ’) str ('0’) true false पर सही सही गलत पर गलत
 str (true false ’) str ('01’) true false पर सही गलत पर गलत है
 str (true text ’) str ('01’) true false पर सही सही गलत पर गलत
 str (true true ’) str ('01’) true false पर सही सही पर गलत है
   str (false 1 ’) str (1 false’) false true true, false, गलत
 str (true text ’) str ('1’) true false पर सही सही गलत पर गलत
 str (true true ’) str ('1’) true false पर सही सही गलत पर गलत
 str (true text ’) str (text false’) true false पर सही गलत पर गलत
 str (true true ’) str (true false’) true false, सच (असत्य)
 str (true true ’) str () text’) true false पर सही सही पर गलत है

$a > $b > $cConundrum कब: $aसे अधिक नहीं है $c।

A <C: float (NAN)> str ('a')> str ('')
A <C: float (NAN)> str ('a')> str ('1')
A <C: float (NAN)> str ('a')> str ('A')
A <C: float (NAN)> str ('a')> str ('0')
A <C: float (NAN)> str ('1')> str ('')
A <C: float (NAN)> str ('1')> str ('0')
A <C: float (NAN)> str ('A')> str ('')
A <C: float (NAN)> str ('A')> str ('1')
A <C: float (NAN)> str ('A') str ('0')
A <C: float (NAN)> str ('0')> str ('')
A <C: str ('')> float (NAN)> str ('a')
A <C: str ('')> float (NAN)> str ('1')
A <C: str ('')> float (NAN)> str ('ए')
A <C: str ('')> float (NAN)> str ('0')
A <C: str ('a')> str ('')> float (NAN)
A <C: str ('a')> str ('1')> float (NAN)
A <C: str ('a')> str ('A')> float (NAN)
A <C: str ('a') str ('0')> float (NAN)
A <C: str ('0')> str ('')> float (NAN)
A == C: बूल (सच)> str ('')> float (NAN)
A == C: बूल (सत्य)> str ('')> float (-INF)
A == C: बूल (सत्य)> str ('')> int (-1)
A == C: बूल (सच)> str ('')> float (-1)
ए == सी: बूल (सच)> एरे ()> फ्लोट (नान)
ए == सी: बूल (सच)> एरे ()> फ्लोट (इन्फो)
A == C: बूल (सत्य)> एरे ()> फ्लोट (-INF)
ए == सी: बूल (सच)> एरे ()> स्ट्र ('ए')
ए == सी: बूल (सच)> सरणी ()> इंट (1)
ए == सी: बूल (सच)> सरणी ()> फ्लोट (1)
ए == सी: बूल (सच)> एरे ()> स्ट्र ('1')
ए == सी: बूल (सच)> एरे ()> स्ट्र ('ए')
ए == सी: बूल (सच)> सरणी ()> इंट (-1)
ए == सी: बूल (सच)> सरणी ()> फ्लोट (-1)
ए == सी: बूल (सच)> इंट (0)> फ्लोट (-INF)
ए == सी: बूल (सच)> इंट (0)> इंट (-1)
ए == सी: बूल (सच)> इंट (0)> फ्लोट (-1)
A == C: बूल (सच)> str ('0')> float (NAN)
A == C: बूल (सत्य)> str ('0')> float (-INF)
A == C: बूल (सच)> str ('0')> int (-1)
A == C: बूल (सच)> str ('0')> float (-1)
ए == सी: बूल (सच)> फ्लोट (0)> फ्लोट (-INF)
ए == सी: बूल (सच)> फ्लोट (0)> इंट (-1)
ए == सी: बूल (सच)> फ्लोट (0)> फ्लोट (-1)
A == C: int (1)> str ('a')> str ('1')
A == C: int (1)> str ('A')> str ('1')
A == C: फ्लोट (1)> str ('a')> str ('1')
A == C: फ्लोट (1)> str ('A')> str ('1')
A == C: str ('a') str ('1')> int (0)
A == C: str ('a')> str ('1')> float (0)
A == C: str ('')> float (-INF)> NULL (NULL)
A == C: str ('')> float (-INF)> बूल (झूठा)
A == C: str ('')> int (-1)> NULL (NULL)
A == C: str ('')> int (-1)> बूल (झूठा)
A == C: str ('')> float (-1)> NULL (NULL)
A == C: str ('')> float (-1)> बूल (झूठा)
A == C: सरणी ()> फ्लोट (NAN)> NULL (NULL)
ए == सी: सरणी ()> फ्लोट (नान)> बूल (गलत)
A == C: array ()> फ्लोट (INF)> NULL (NULL)
A == C: सरणी ()> फ्लोट (INF)> बूल (गलत)
A == C: array ()> फ्लोट (-INF)> NULL (NULL)
ए == सी: सरणी ()> फ्लोट (-INF)> बूल (गलत)
A == C: array ()> str ('a')> NULL (NULL)
A == C: array ()> str ('a')> बूल (झूठा)
A == C: सरणी ()> int (1)> NULL (NULL)
ए == सी: सरणी ()> इंट (1)> बूल (गलत)
A == C: सरणी ()> फ्लोट (1)> NULL (NULL)
ए == सी: सरणी ()> फ्लोट (1)> बूल (झूठा)
A == C: array ()> str ('1')> NULL (NULL)
A == C: सरणी ()> str ('1')> बूल (झूठा)
A == C: array ()> str ('A')> NULL (NULL)
A == C: array ()> str ('A')> बूल (झूठा)
A == C: array ()> str ('0')> NULL (NULL)
A == C: सरणी ()> int (-1)> NULL (NULL)
ए == सी: सरणी ()> इंट (-1)> बूल (झूठा)
A == C: सरणी ()> फ्लोट (-1)> NULL (NULL)
ए == सी: सरणी ()> फ्लोट (-1)> बूल (झूठा)
A == C: str ('')> फ्लोट (NAN)> बूल (झूठा)
A == C: str ('')> फ्लोट (NAN)> NULL (NULL)
A == C: str ('A')> str ('1')> int (0)
A == C: str ('A')> str ('1')> float (0)
A == C: int (0)> float (-INF)> NULL (NULL)
A == C: int (0)> float (-INF)> बूल (झूठा)
A == C: int (0)> int (-1)> NULL (NULL)
A == C: int (0)> int (-1)> बूल (झूठा)
A == C: int (0)> float (-1)> NULL (NULL)
ए == सी: इंट (0)> फ्लोट (-1)> बूल (झूठा)
A == C: str ('0')> float (NAN)> बूल (झूठा)
A == C: str ('0')> float (-INF)> बूल (झूठा)
A == C: str ('0')> int (-1)> बूल (झूठा)
A == C: str ('0')> float (-1)> बूल (झूठा)
A == C: फ्लोट (0)> फ्लोट (-INF)> NULL (NULL)
ए == सी: फ्लोट (0)> फ्लोट (-INF)> बूल (गलत)
A == C: फ्लोट (0)> int (-1)> NULL (NULL)
ए == सी: फ्लोट (0)> इंट (-1)> बूल (झूठा)
A == C: फ्लोट (0)> फ्लोट (-1)> NULL (NULL)
ए == सी: फ्लोट (0)> फ्लोट (-1)> बूल (झूठा)
A === C: str ('0')> float (NAN)> str ('0')
A === C: str ('')> float (NAN)> str ('')
A === C: str ('a')> float (NAN)> str ('a')
A === C: str ('1')> float (NAN)> str ('1')
A === C: str ('A')> float (NAN)> str ('ए')

मजेदार स्ट्रिंग तुलना: 'क्वीन' >'किंग' >'जैक' >'ऐस'

जोड़े को कवर करने वाली PHP प्रकार की तुलना तालिकाएँ भी देखें :

  • isset() तथा is_null()
  • if() तथा empty()
  • बूलियन ==बनाम===

PHP के संस्करणों के बीच अंतर की जाँच करें। http://3v4l.org/MAfDu ।

— CSᵠ
स्रोत
26
+1 अकेले स्क्रॉल फिक्स्ड कॉलम हेडर के साथ "टेबल" करते हैं - गंधा विचार;)
— hakre
टाइप-कास्टिंग करते समय किसी को सख्त ऑपरेटर का उपयोग करने की आवश्यकता होती है? मेरा मतलब है कि आपने लिखा है, if ( (string)$a===(string)$b )लेकिन क्या यह बिल्कुल वैसा नहीं है if ( (string)$a==(string)$b )?
— वोइटकस
@Voitcus दोनों प्रकार के कलाकारों के लिए हां (string)1==(string)'01'-> bool(true)और टाइप-जॉगल के लिए (1 . '')=='01'-> बिल्कुल वैसा ही bool(true)नहीं जब आप दोनों खातों में ===bool(false)
— मिलेंगे
1
एक नाइट-पिक: ऑक्टल मान "असाइनमेंट पर कनवर्ट नहीं किए जाते हैं", उन्हें कंपाइलर द्वारा व्याख्या की जाती है, जिसे एएससीआईआई को वास्तविक बाइनरी नंबर में बदलना है।
— IMSoP
INFINITY is equal to INFINITY which is mathematically incorrect!एक निश्चित रूप से बहस का बयान है। यह भी ध्यान रखें कि NaNकन्वेंशन से किसी भी प्रोग्रामिंग भाषा में जो मुझे पता है, उससे कम या अधिक से अधिक नहीं है।
— डेवग्रैंडैम
22

आपके प्रश्न के दूसरे भाग के आपके सुधार के बाद, मैं उस हिस्से का उत्तर दूसरों पर छोड़ देता हूं। मैं आपके प्रश्न के पहले भाग का सबसे आश्चर्यजनक जवाब देना चाहता हूं, अर्थात, क्या कोई उदाहरण है <और >ऑपरेटर्स अकर्मक हैं। यही पर है।

ये सभी हैं true:

"10" < "1a"
"1a" < "2"
"10" > "2"

तो <थे सकर्मक ( $a < $b∧ $b < $c⇒ $a < $c), अंतिम पंक्ति होगा

"10" < "2"

लेकिन PHP जब भी यह कर सकता है, संख्याओं के रूप में स्ट्रिंग (और!) की व्याख्या करने की कोशिश करता है।

यह पता चला है कि, उपरोक्त अकर्मण्यता के कारण, sort()एक ही तत्व को उनके इनपुट आदेश के आधार पर एक अलग क्रम में सॉर्ट कर सकते हैं , तब भी जब कोई दो तत्व नहीं होते हैं== (और कोई तत्व एनएएन नहीं है)। मैंने इसे एक टिप्पणी में क्रमबद्ध करने के लिए कहा () , जिसका सार है:

sort(array("10", "1a", "2" )) => array("10", "1a", "2" )
sort(array("10", "2",  "1a")) => array("1a", "2",  "10")
sort(array("1a", "10", "2" )) => array("2",  "10", "1a")
sort(array("1a", "2",  "10")) => array("1a", "2",  "10")
sort(array("2",  "10", "1a")) => array("2",  "10", "1a")
sort(array("2",  "1a", "10")) => array("10", "1a", "2" )
— वाल्टर ट्रॉस
स्रोत
1
पिछली टिप्पणी उत्तर के एक हिस्से (प्रश्न के दूसरे भाग से संबंधित) को संदर्भित करती है जिसे मैंने इस बीच हटा दिया है
— वाल्टर ट्रॉस
अब इसे हटा दिया गया है;) और अच्छी नई sort()तालिका, इसे संबंधित ब्लॉग पोस्ट द ग्रेटेस्ट PHP वैल्यू लिखते समय व्यावहारिक प्रभाव के लिए भी उठाया । आपके उत्तर के लिए फिर से धन्यवाद।
— हक्रे अप्र ha
क्या इसका मतलब यह है कि usortजब भी संभव हो एक का उपयोग करना चाहिए ?
— वोइटकस
2
@Voitcus: मुझे लगता है कि आपका मतलब है usort($arr, 'strcmp')। यह काम करता है (स्ट्रिंग्स के लिए, बेशक), लेकिन इसका उपयोग करना सबसे अच्छा है sort($arr, SORT_STRING)।
— वाल्टर ट्रॉस
@WalterTross मेरा मतलब है कि हमेशा अपने स्वयं के फंक्शन (न केवल तार के लिए) का उपयोग करें यह सुनिश्चित करने के लिए कि यह हमेशा सही है
— Voitcus
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.