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




comparison operators (16)

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

  • लापरवाही == तुलना कैसे काम करता है?
  • सख्त === तुलनात्मक कार्य वास्तव में कैसे करता है?

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


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

$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

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

उदाहरण:

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)

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

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

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

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

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

== ऑब्जेक्ट के नाम और उनके मानों का उपयोग करके वस्तुओं की तुलना करता है। यदि दो ऑब्जेक्ट एक ही प्रकार के हैं और एक ही सदस्य मान हैं, तो $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

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

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

तुलना ऑपरेटर

┌──────────┬───────────┬───────────────────────────────────────────────────────────┐
│ 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. │
└──────────┴───────────┴───────────────────────────────────────────────────────────┘

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

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

नियमों को परिवर्तित करना

तुलना तालिका टाइप करें

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

== साथ लूज तुलना

┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
│         │ 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  │
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

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

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

तुलना तालिका टाइप करें

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

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

┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
│         │ 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  │
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

<?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);
?>

चर के प्रकार एक प्रकार और एक मूल्य है।

  • $ var = "test" एक स्ट्रिंग है जिसमें "परीक्षण" होता है
  • $ var2 = 24 एक पूर्णांक vhose मान 24 है।

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

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

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

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

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

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

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

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

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


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

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

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

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

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

दिया गया x = 5

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


कुछ उदाहरण

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.

पुनश्च

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

बनाम

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


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

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

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

$var=1;

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

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

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

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

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

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)

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


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

== चेक करता है अगर समकक्ष (केवल मूल्य)

=== जांचता है कि वही (मान और प्रकार)


समकक्ष बनाम वही: एक एनालॉजी

1 + 1 = 2 + 0 (समतुल्य)

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


PHP में:

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

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

  • सच बुलियन है
  • 1 int है

$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 एक ढीली टाइप की गई भाषा है। डबल बराबर ऑपरेटर का उपयोग एक चर की ढीली जांच के लिए अनुमति देता है।

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

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

इन सभी मानों को डबल बराबर ऑपरेटर का उपयोग करके बराबर बराबर बराबर किया जाएगा।


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

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

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

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

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

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





identity-operator