कैसे PHP समानता (== डबल बराबर) और पहचान (=== ट्रिपल बराबर) तुलना ऑपरेटर भिन्न है?


== और === बीच अंतर क्या है?

  • कैसे ढीले == तुलना काम करता है?
  • सख्त कैसे === तुलना काम करता है?

कुछ उपयोगी उदाहरण क्या होंगे?




Answers


== और === बीच अंतर

ढीले == समान ऑपरेटर और सख्त === समान ऑपरेटर के बीच के अंतर को मैनुअल में समझाया गया है:

तुलना ऑपरेटर

┌──────────┬───────────┬───────────────────────────────────────────────────────────┐
│ Example  │ Name      │ Result                                                    │
├──────────┼───────────┼───────────────────────────────────────────────────────────┤
│$a ==  $b │ Equal     │ TRUE if $a is equal to $b after type juggling.            │
│$a === $b │ Identical │ TRUE if $a is equal to $b, and they are of the same type. │
└──────────┴───────────┴───────────────────────────────────────────────────────────┘

ढीला == बराबर तुलना

यदि आप == ऑपरेटर, या किसी अन्य तुलना ऑपरेटर का उपयोग कर रहे हैं जो कि तुलनात्मक रूप से तुलना में != , <> या == , आपको हमेशा यह देखने के लिए संदर्भ को देखना होगा कि क्या, क्या और क्यों कुछ समझने में परिवर्तित हो जाता है चल रहा है।

नियम बदलने

प्रकार तुलना तालिका

संदर्भ और उदाहरण के रूप में आप मैन्युअल में तुलना की तालिका देख सकते हैं:

== साथ ढीली तुलना

┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
│         │ TRUE  │ FALSE │   1   │   0   │  -1   │  "1"  │  "0"  │ "-1"  │ NULL  │ array() │ "php" │  ""   │
├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────────┼───────┼───────┤
│ TRUE    │ TRUE  │ FALSE │ TRUE  │ FALSE │ TRUE  │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE   │ TRUE  │ FALSE │
│ FALSE   │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ TRUE  │ TRUE    │ FALSE │ TRUE  │
│ 1       │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ 0       │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE   │ TRUE  │ TRUE  │
│ -1      │ TRUE  │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "1"     │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "0"     │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "-1"    │ TRUE  │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE   │ FALSE │ FALSE │
│ NULL    │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ TRUE    │ FALSE │ TRUE  │
│ array() │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ TRUE    │ FALSE │ FALSE │
│ "php"   │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ TRUE  │ FALSE │
│ ""      │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE   │ FALSE │ TRUE  │
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

सख्त === समान तुलना

यदि आप === ऑपरेटर, या किसी अन्य तुलना ऑपरेटर का उपयोग कर रहे हैं जो सख्त तुलना जैसे !== या === का उपयोग करता है, तो आप हमेशा सुनिश्चित कर सकते हैं कि प्रकार जादुई रूप से नहीं बदलेगा, क्योंकि कोई कनवर्टिंग नहीं होगा चल रहा। इसलिए सख्त तुलना के साथ प्रकार और मूल्य समान होना चाहिए, न केवल मूल्य।

प्रकार तुलना तालिका

संदर्भ और उदाहरण के रूप में आप मैन्युअल में तुलना की तालिका देख सकते हैं:

=== साथ सख्त तुलना

┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
│         │ TRUE  │ FALSE │   1   │   0   │  -1   │  "1"  │  "0"  │ "-1"  │ NULL  │ array() │ "php" │  ""   │
├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────────┼───────┼───────┤
│ TRUE    │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ FALSE   │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ 1       │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ 0       │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ -1      │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "1"     │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "0"     │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "-1"    │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE   │ FALSE │ FALSE │
│ NULL    │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE   │ FALSE │ FALSE │
│ array() │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE    │ FALSE │ FALSE │
│ "php"   │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ TRUE  │ FALSE │
│ ""      │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ TRUE  │
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘



ऑपरेटर == दो अलग-अलग प्रकार के बीच डाले हुए हैं यदि वे अलग-अलग हैं, जबकि === ऑपरेटर एक 'टाइपाइफ तुलना' करता है इसका मतलब है कि यह केवल सच ही वापस करेगा अगर दोनों operands एक ही प्रकार और एक ही मूल्य है

उदाहरण:

1 === 1: true
1 == 1: true
1 === "1": false // 1 is an integer, "1" is a string
1 == "1": true // "1" gets casted to an integer, which is 1
"foo" === "foo": true // both operands are strings and have the same value

चेतावनी : समकक्ष सदस्यों के साथ एक ही कक्षा के दो उदाहरण === ऑपरेटर से मेल नहीं खाते हैं। उदाहरण:

$a = new stdClass();
$a->foo = "bar";
$b = clone $a;
var_dump($a === $b); // bool(false)



जावास्क्रिप्ट के संबंध में:

=== ऑपरेटर == ऑपरेटर के समान काम करता है, लेकिन इसकी आवश्यकता है कि इसके ऑपरेंडों के पास न केवल एक ही मान है, बल्कि एक ही डेटा प्रकार भी है।

उदाहरण के लिए, नीचे का नमूना प्रदर्शित होगा 'एक्स और वाई बराबर' हैं, लेकिन 'एक्स और वाई समान नहीं हैं'

var x = 4;
var y = '4';
if (x == y) {
    alert('x and y are equal');
}
if (x === y) {
    alert('x and y are identical');
}



एक तस्वीर एक हजार शब्दों के बराबर होती है:

PHP डबल बराबर == समानता चार्ट:

PHP ट्रिपल बराबर === समानता चार्ट:

इन छवियों को बनाने के लिए स्रोत कोड:

https://github.com/sentientmachine/php_equality_charts

गुरु ध्यान

जो लोग अपनी विवेक रखने की इच्छा रखते हैं, वे आगे नहीं पढ़ते हैं।

  1. '==' जब संभव हो तो संख्याओं को छोड़ दिया और दायां कर्ता परिवर्तित करता है (123 == "123foo", लेकिन "123"! = "123foo"
  2. उद्धरण में एक हेक्स स्ट्रिंग कभी-कभी एक फ्लोट होती है और इसे आपकी इच्छा के विरुद्ध लगाया जाएगा।
  3. == संक्रमणीय नहीं है क्योंकि ("0" == से 0 है, और 0 है == "" लेकिन "0"! = "")
  4. "6" == "6", "4.2" == "4.20", और "133" == "0133" लेकिन 133! = 0133, क्योंकि 0133 ऑक्टल है। लेकिन "0x10" == "16" और "1e3" == "1000"
  5. PHP वेरिएबल्स जिन्हें अभी तक घोषित नहीं किया गया है वे गलत हैं।

  6. झूठी 0 के बराबर है, रिक्त सरणी और खाली सरणी और "0"।

  7. जब संख्याएं बड़ी होती हैं तो वे == अनंत हैं
  8. NAN खुद नहीं ==, लेकिन यह सच है

  9. एक ताजा वर्ग == 1 है

  10. झूठी सबसे खतरनाक मान है क्योंकि कई अन्य चर के कारण झूठी है ==, ज्यादातर इसे अपने उद्देश्य को हराते हैं

आशा है कि:

यदि आप PHP का उपयोग कर रहे हैं, तो तू डबल बराबर ऑपरेटर का उपयोग नहीं करेगा, हमेशा ट्रिपल बराबर का उपयोग करें।




ऑब्जेक्ट की तुलना में संबंधित अन्य उत्तरों के अलावा:

== ऑब्जेक्ट के नाम और उनके मूल्यों का उपयोग करके वस्तुओं की तुलना। यदि दो ऑब्जेक्ट समान प्रकार के होते हैं और समान सदस्य मान हैं, $a == $b उपज सच है।

=== वस्तुओं के आंतरिक ऑब्जेक्ट आईडी की तुलना करता है यहां तक ​​कि अगर सदस्यों के बराबर हैं, $a !== $b यदि वे वही वस्तु नहीं हैं

class TestClassA {
    public $a;
}

class TestClassB {
    public $a;
}

$a1 = new TestClassA();
$a2 = new TestClassA();
$b = new TestClassB();

$a1->a = 10;
$a2->a = 10;
$b->a = 10;

$a1 == $a1;
$a1 == $a2;  // Same members
$a1 != $b;   // Different classes

$a1 === $a1;
$a1 !== $a2; // Not the same object



सरल शब्दों में:

== चेक अगर समकक्ष (केवल मान)

=== जांचता है कि क्या एक ही है (मान && प्रकार)


समरूप बनाम एक ही: एक अनुरूपता

1 + 1 = 2 + 0 (बराबर)

1 + 1 = 1 + 1 (समान)


PHP में:

सच == 1 (सच - मूल्य में समतुल्य)

सच === 1 (झूठी - वही और वही प्रकार में नहीं)

  • सच बुलियन है
  • 1 पूर्णांक है



यह डेटा प्रकारों के बारे में है उदाहरण के लिए एक BOOL (सही या गलत) लें:

true भी 1 बराबर है और false भी 0 बराबर है

== तुलना करते समय डेटा प्रकारों की परवाह नहीं करता है: इसलिए यदि आपके पास एक चर है जो 1 है (जो भी true हो सकता true ):

$var=1;

और फिर == साथ तुलना करें:

if ($var == true)
{
    echo"var is true";
}

लेकिन $var वास्तव में समान नहीं true , है ना? इसके बजाय 1 का इंट मान है, जो बदले में, सत्य के बराबर है।

=== साथ, यह सुनिश्चित करने के लिए डेटा प्रकारों की जांच की जाती है कि दो चर / ऑब्जेक्ट / जो भी उसी प्रकार का उपयोग कर रहे हैं

तो अगर मैंने किया

if ($var === true)
{
    echo "var is true";
}

यह स्थिति सच नहीं होगी, $var !== true रूप में $var !== true यह $var !== true है == true (यदि आप जानते हैं कि मेरा क्या मतलब है)

आपको इसकी आवश्यकता क्यों है?

सरल - चलो एक PHP के कार्यों पर एक नज़र डालें: array_search() :

array_search() फ़ंक्शन, केवल एक सरणी में मान की खोज करता है, और उस तत्व की कुंजी देता है जिसमें मान पाया गया था। अगर मान सरणी में नहीं मिला, तो वह झूठी रिटर्न देता है । लेकिन, क्या होगा अगर आपने सरणी के पहले तत्व में संग्रहीत मूल्य पर array_search() किया है (जो कि 0 की सरणी कुंजी होगी) .... array_search() फ़ंक्शन 0 ... वापस आएगा गलत के बराबर ..

तो अगर आपने किया:

$arr = array("name");
if (array_search("name", $arr) == false)
{
    // This would return 0 (the key of the element the val was found
    // in), but because we're using ==, we'll think the function
    // actually returned false...when it didn't.
}

तो, क्या आप देखते हैं कि यह कैसे एक मुद्दा हो सकता है?

अधिकांश लोगों का उपयोग नहीं करते == false जब कोई फ़ंक्शन झूठा लौटाता है तो जांचता है। इसके बजाय, वे इसका इस्तेमाल करते हैं ! । लेकिन वास्तव में, यह वास्तव में ==false प्रयोग करने जैसा है, इसलिए यदि आपने किया है:

$arr = array("name");
if (!array_search("name", $arr)) // This is the same as doing (array_search("name", $arr) == false)

तो ऐसी चीज़ों के लिए, आप इसके बजाय === प्रयोग करेंगे, ताकि डेटा प्रकार की जांच हो।




एक उदाहरण यह है कि डेटाबेस विशेषता शून्य या "" हो सकती है:

$attributeFromArray = "";
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //true
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //false

$attributeFromArray = null;
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //false
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //true



दिए गए x = 5

1) ऑपरेटर: == "बराबर है" x == 8 गलत है
2) ऑपरेटर: === "बिल्कुल बराबर" (मूल्य और प्रकार) x === 5 सच है, x === "5" झूठा है




$a = 5;   // 5 as an integer

var_dump($a == 5);       // compare value; return true
var_dump($a == '5');     // compare value (ignore type); return true
var_dump($a === 5);      // compare type/value (integer vs. integer); return true
var_dump($a === '5');    // compare type/value (integer vs. string); return false

हालांकि सावधान रहें यहाँ एक कुख्यात समस्या है

// 'test' is found at position 0, which is interpreted as the boolean 'false'
if (strpos('testing', 'test')) {
    // code...
}

बनाम

// true, as strict comparison was made (0 !== false)
if (strpos('testing', 'test') !== false) {
    // code...
}



संक्षेप में, === उसी तरह काम करता है कि == अधिकांश अन्य प्रोग्रामिंग भाषाओं में करता है

PHP आपको उन तुलना की अनुमति देता है जो वास्तव में समझ में नहीं आते हैं। उदाहरण:

$y = "wauv";
$x = false;
if ($x == $y)
    ...

यद्यपि यह कुछ रोचक "शॉर्टकट्स" को आपको एक फ़ंक्शन देता है, जिससे वह कुछ देता है (संख्या के बजाय "त्रुटि" की तरह) को ध्यान में रखकर आपको सावधान रहना चाहिए, और आपको यह आश्चर्य होगा कि क्या हुआ।

PHP में, == मूल्यों की तुलना करती है और आवश्यक होने पर प्रकार रूपांतरण करती है (उदाहरण के लिए, स्ट्रिंग "12343sdfjskfjds" एक पूर्णांक तुलना में "12343" बन जाएगा)। === मूल्य और प्रकार की तुलना करेगा और यदि वही समान नहीं है तो झूठी वापसी करेगा

यदि आप PHP मैनुअल में देखते हैं, तो आप देखेंगे कि फ़ंक्शन विफल होने पर बहुत सारे कार्य "झूठे" वापस आते हैं, लेकिन वे सफल परिदृश्य में 0 लौट सकते हैं, यही वजह है कि वे "यदि (फ़ंक्शन ()) करना चाहते हैं! == गलत) "गलतियों से बचने के लिए




उदाहरणों में से कुछ

var_dump(5 == 5);    // True
var_dump(5 == "5");  // True because == checks only same value not type
var_dump(5 === 5);   // True
var_dump(5 === "5"); // False because value are same but data type are different.

पुनश्च

== केवल मूल्य की तुलना करता है, यह डेटा प्रकारों के बारे में परेशान नहीं करेगा

बनाम

=== मूल्यों और डेटा प्रकारों की तुलना करता है




आप यह निर्धारित करने के लिए === का प्रयोग करेंगे कि फ़ंक्शन या वेरिएबल झूठे (शून्य या रिक्त स्ट्रिंग) को समान करने के बजाय झूठे हैं या नहीं।

$needle = 'a';
$haystack = 'abc';
$pos = strpos($haystack, $needle);
if ($pos === false) {
    echo $needle . ' was not found in ' . $haystack;
} else {
    echo $needle . ' was found in ' . $haystack . ' at location ' . $pos;
}

इस मामले में स्ट्रॉप्स 0 पर लौट आएंगे जो परीक्षा में झूठे के समान होगा

if ($pos == false)

या

if (!$pos)

जो नहीं है जो आप यहां चाहते हैं




एक के ऊपर एक का उपयोग करने के लिए के रूप में, उदाहरण के लिए PHP में fwrite() फ़ंक्शन ले।

यह फ़ंक्शन किसी फ़ाइल स्ट्रीम में सामग्री लिखता है। PHP के अनुसार, " fwrite() लिखित में बाइट्स की संख्या देता है, या त्रुटि पर गलत होता है।" यदि आप परीक्षण करना चाहते हैं कि फ़ंक्शन कॉल सफल था, तो यह विधि त्रुटिपूर्ण है:

if (!fwrite(stuff))
{
    log('error!');
}

यह शून्य (और सफल माना जाता है) लौटा सकता है, और आपकी स्थिति अभी भी ट्रिगर हो गई है। सही तरीका होगा:

if (fwrite(stuff) === FALSE)
{
    log('error!');
}



वेरिएबल्स में एक प्रकार और एक मान है I

  • $ var = "test" एक स्ट्रिंग है जिसमें "टेस्ट"
  • $ var2 = 24 एक पूर्णांक भाव मूल्य 24 है

जब आप इन चर का उपयोग करते हैं (PHP में), कभी-कभी आपके पास अच्छा प्रकार नहीं होता है उदाहरण के लिए, यदि आप ऐसा करते हैं

if ($var == 1) {... do something ...}

PHP को "var (डालना") $ var को पूर्णांक में कनवर्ट करना होगा इस स्थिति में, "$ var == 1" सच है क्योंकि किसी भी रिक्त स्ट्रिंग को 1 पर रखा जाता है।

=== का उपयोग करते समय, आप जांचते हैं कि मूल्य और प्रकार बराबर हैं, इसलिए "$ var === 1" झूठा है।

यह उपयोगी है, उदाहरण के लिए, जब आपके पास फ़ंक्शन होता है जो गलत (त्रुटि पर) और 0 (परिणाम) लौटा सकता है:

if(myFunction() == false) { ... error on myFunction ... }

यह कोड गलत है जैसा कि myFunction() 0 देता है, इसे झूठी जाती है और आपको एक त्रुटि दिखाई देती है। सही कोड है:

if(myFunction() === false) { ... error on myFunction ... }

क्योंकि परीक्षा यह है कि रिटर्न वैल्यू "एक बूलियन है और झूठी है" और "झूठे में जाली जा सकती है"




=== ऑपरेटर को सटीक सामग्री समानता की तुलना करना चाहिए, जबकि == ऑपरेटर अर्थ की समानता की तुलना करेगा। विशेष रूप से यह संख्याओं को स्ट्रिंग को बल देगा।

समानता एक विशाल विषय है समानता पर विकिपीडिया लेख देखें




<?php

    /**
     * Comparison of two PHP objects                         ==     ===
     * Checks for
     * 1. References                                         yes    yes
     * 2. Instances with matching attributes and its values  yes    no
     * 3. Instances with different attributes                yes    no
     **/

    // There is no need to worry about comparing visibility of property or
    // method, because it will be the same whenever an object instance is
    // created, however visibility of an object can be modified during run
    // time using ReflectionClass()
    // http://php.net/manual/en/reflectionproperty.setaccessible.php
    //
    class Foo
    {
        public $foobar = 1;

        public function createNewProperty($name, $value)
        {
            $this->{$name} = $value;
        }
    }

    class Bar
    {
    }
    // 1. Object handles or references
    // Is an object a reference to itself or a clone or totally a different object?
    //
    //   ==  true   Name of two objects are same, for example, Foo() and Foo()
    //   ==  false  Name of two objects are different, for example, Foo() and Bar()
    //   === true   ID of two objects are same, for example, 1 and 1
    //   === false  ID of two objects are different, for example, 1 and 2

    echo "1. Object handles or references (both == and    ===) <br />";

    $bar = new Foo();    // New object Foo() created
    $bar2 = new Foo();   // New object Foo() created
    $baz = clone $bar;   // Object Foo() cloned
    $qux = $bar;         // Object Foo() referenced
    $norf = new Bar();   // New object Bar() created
    echo "bar";
    var_dump($bar);
    echo "baz";
    var_dump($baz);
    echo "qux";
    var_dump($qux);
    echo "bar2";
    var_dump($bar2);
    echo "norf";
    var_dump($norf);

    // Clone: == true and === false
    echo '$bar == $bar2';
    var_dump($bar == $bar2); // true

    echo '$bar === $bar2';
    var_dump($bar === $bar2); // false

    echo '$bar == $baz';
    var_dump($bar == $baz); // true

    echo '$bar === $baz';
    var_dump($bar === $baz); // false

    // Object reference: == true and === true
    echo '$bar == $qux';
    var_dump($bar == $qux); // true

    echo '$bar === $qux';
    var_dump($bar === $qux); // true

    // Two different objects: == false and === false
    echo '$bar == $norf';
    var_dump($bar == $norf); // false

    echo '$bar === $norf';
    var_dump($bar === $norf); // false

    // 2. Instances with matching attributes and its values (only ==).
    //    What happens when objects (even in cloned object) have same
    //    attributes but varying values?

    // $foobar value is different
    echo "2. Instances with matching attributes  and its values (only ==) <br />";

    $baz->foobar = 2;
    echo '$foobar' . " value is different <br />";
    echo '$bar->foobar = ' . $bar->foobar . "<br />";
    echo '$baz->foobar = ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // false

    // $foobar's value is the same again
    $baz->foobar = 1;
    echo '$foobar' . " value is the same again <br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$baz->foobar is ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // true

    // Changing values of properties in $qux object will change the property
    // value of $bar and evaluates true always, because $qux = &$bar.
    $qux->foobar = 2;
    echo '$foobar value of both $qux and $bar is 2, because $qux = &$bar' . "<br />";
    echo '$qux->foobar is ' . $qux->foobar . "<br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$bar == $qux';
    var_dump($bar == $qux); // true

    // 3. Instances with different attributes (only ==)
    //    What happens when objects have different attributes even though
    //    one of the attributes has same value?
    echo "3. Instances with different attributes (only ==) <br />";

    // Dynamically create a property with the name in $name and value
    // in $value for baz object
    $name = 'newproperty';
    $value = null;
    $baz->createNewProperty($name, $value);
    echo '$baz->newproperty is ' . $baz->{$name};
    var_dump($baz);

    $baz->foobar = 2;
    echo '$foobar' . " value is same again <br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$baz->foobar is ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // false
    var_dump($bar);
    var_dump($baz);
?>



PHP एक ढीले टाइप की गई भाषा है डबल बराबर ऑपरेटर का प्रयोग करके एक चर की ढीली जांच की जा सकती है।

ढीले से एक मूल्य की जांच कुछ समान की अनुमति होगी, लेकिन बराबर नहीं, मूल्य समान के समान होगा:

  • ''
  • शून्य
  • असत्य
  • 0

इन सभी मूल्यों को दो बराबर ऑपरेटर के बराबर समान समीकरण होगा।




सभी उत्तर अब तक === के साथ एक खतरनाक समस्या की उपेक्षा यह पारित करने में उल्लेख किया गया है, पर बल नहीं दिया गया है, कि पूर्णांक और डबल भिन्न प्रकार हैं, इसलिए निम्नलिखित कोड:

$n = 1000;
$d = $n + 0.0e0;
echo '<br/>'. ( ($n ==  $d)?'equal' :'not equal' );
echo '<br/>'. ( ($n === $d)?'equal' :'not equal' );

देता है:

 equal
 not equal

ध्यान दें कि यह "गोलाई त्रुटि" का मामला नहीं है दो संख्या अंतिम बिट के बराबर हैं, लेकिन उनके पास अलग-अलग प्रकार हैं

यह एक गड़बड़ समस्या है क्योंकि === का उपयोग करते हुए एक कार्यक्रम खुशी से चल सकता है अगर सभी संख्याएं छोटे हों (जहां "छोटा पर्याप्त" आपके हार्डवेयर और ओएस पर निर्भर करता है)। हालांकि, मौके के जरिए, एक पूर्णांक को दोहरे में परिवर्तित किया जा सकता है, इसके प्रकार "हमेशा के लिए" बदल जाता है, हालांकि बाद के ऑपरेशन, या कई परिचालन, मूल्य में एक छोटे पूर्णांक को वापस ला सकता है। और, यह बदतर हो जाता है यह फैल सकता है - डबल नैस संक्रमण को किसी भी चीज के साथ पारित किया जा सकता है, एक समय में एक गणना।

वास्तविक दुनिया में, ऐसे कार्यक्रमों में एक समस्या होने की संभावना है जो वर्ष 2038 से अधिक तारीखों को संभालते हैं, उदाहरण के लिए इस समय, यूनिक्स टाइमस्टैम्प (1 9-01-01-01 00:00:00 यूटीसी से सेकंड की संख्या) को 32-बिट से ज्यादा की आवश्यकता होगी, इसलिए उनका प्रतिनिधित्व "जादुई" कुछ सिस्टमों पर दोगुना हो जाएगा। इसलिए, यदि आप दो बार के बीच अंतर की गणना करते हैं तो आप कुछ सेकंड के साथ समाप्त हो सकते हैं, लेकिन वर्ष 2017 में पूर्णांक परिणाम के बजाय, एक डबल के रूप में।

मुझे लगता है कि यह स्ट्रिंग्स और नंबरों के बीच रूपांतरण के मुकाबले बहुत खराब है क्योंकि यह सूक्ष्म है मुझे यह पता लगाना आसान है कि स्ट्रिंग क्या है और कितनी संख्या है, लेकिन संख्या में बिट्स की संख्या का ट्रैक रखने से मुझे बाहर है

इसलिए, ऊपर के उत्तरों में कुछ अच्छी तालियां हैं, लेकिन 1 (एक पूर्णांक के रूप में) और 1 (सूक्ष्म डबल) और 1.0 (स्पष्ट डबल) के बीच कोई अंतर नहीं है। साथ ही, सलाह है कि आपको हमेशा === का उपयोग करना चाहिए और कभी भी नहीं == बहुत अच्छा नहीं है क्योंकि === कभी-कभी विफल हो जाता है जहां == ठीक से काम करता है इसके अलावा, जावास्क्रिप्ट इस संबंध में समतुल्य नहीं है क्योंकि इसमें केवल एक नंबर प्रकार है (आंतरिक रूप से इसमें थोड़ा-सा अलग-अलग प्रस्तुतियां हो सकती हैं, लेकिन यह === के लिए समस्याओं का कारण नहीं है)।

मेरी सलाह - न तो उपयोग करें आप वास्तव में इस गड़बड़ को ठीक करने के लिए अपनी खुद की तुलना फ़ंक्शन लिखने की आवश्यकता है।