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

509

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

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

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

php  comparison  operators  equality  identity-operator 
— nickf
स्रोत

जवाबों:

633

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

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

तुलना संचालक

┌──────────┬───────────┬────────────────────────── ─────────────────────────────────┐
│ उदाहरण │ नाम │ परिणाम │
├──────────┼───────────┼────────────────────────── ─────────────────────────────────┤
│ $ a == $ b j समान जुगाड़ के बाद यदि $ a $ $ a के बराबर है तो TRUE। │
│ $ a === $ b ical पहचान if TRUE यदि $ a $ b के बराबर है, और वे एक ही प्रकार के हैं। │
└──────────┴───────────┴────────────────────────── ─────────────────────────────────┘

पूरी तरह से ==बराबर तुलना

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

नियम बदलना

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

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

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

┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐
│ │ TRUE AL FALSE │ 1 │ 0 │ -1 1 "1" UE "0" UE "-1" │ NULL (सरणी () │ "php" │ "" UE
├─────────┼───────┼───────┼───────┼───────┼─────── ┼───────┼───────┼───────┼───────┼─────────┼─────── ┼───────┤
│ TRUE UE TRUE │ FALSE │ ट्रायल │ FALSE UE TRUE │ ट्रायल UE FALSE UE ट्रबल AL FALSE SE FALSE │ TRUE │ FUESE │
│ FALSE AL FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ TRUE SE FALSE UE TRUE UE TRUE │ FALSE │ TRUE │
│ 1 │ TRUE AL FALSE │ TRUE │ FALSE AL FALSE │ ट्रायल UE FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │
│ 0 │ FALSE UE TRUE │ FALSE │ TRUE │ FALSE │ FALSE AL TRUE │ FALSE UE TRUE SE FALSE │ TRUE UE TRUE │
│ -1 │ TRUE AL FALSE SE FALSE SE FALSE UE ट्रायल │ FALSE AL FALSE UE ट्रायल SE FALSE SE FALSE │ FALSE │ FALSE │ FALSE │
│ "1" UE TRUE │ FALSE │ TRUE │ FALSE AL FALSE │ ट्रायल │ FALSE AL FALSE │ FALSE │ FALSE │ FALSE │ FALSE │
│ "0" SE FALSE │ ट्रायल │ FALSE │ ट्रायल SE FALSE │ FALSE UE ट्रायल SE FALSE AL FALSE │ FALSE │ FALSE │ FALSE │
AL "-1" UE TRUE │ FALSE SE FALSE UE FALSE UE ट्रायल │ FALSE │ FALSE UE ट्रबल AL FALSE │ FALSE │ FALSE │ FALSE │
UE NULL │ FALSE │ TRUE │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE UE TRUE │ TRUE │ FALSE │ TRUE │
│ सरणी () SE FALSE │ TRUE │ FALSE SE FALSE AL FALSE │ FALSE │ FALSE AL FALSE │ TRUE │ TRUE │ FALSE │ FALSE │
│ "php" UE TRUE "FALSE SE FALSE ph ट्रायल │ FALSE │ FALSE" FALSE "FALSE" FALSE "FALSE" FALSE "FALSE"
│ "" SE FALSE │ ट्रायल │ FALSE │ ट्रायल SE FALSE │ FALSE AL FALSE AL FALSE │ ट्रायल SE FALSE │ FALSE │ TRUE │
└─────────┴───────┴───────┴───────┴───────┴─────── ┴───────┴───────┴───────┴───────┴─────────┴─────── ┴───────┘

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

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

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

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

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

┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐
│ │ TRUE AL FALSE │ 1 │ 0 │ -1 1 "1" UE "0" UE "-1" │ NULL (सरणी () │ "php" │ "" UE
├─────────┼───────┼───────┼───────┼───────┼─────── ┼───────┼───────┼───────┼───────┼─────────┼─────── ┼───────┤
│ TRUE UE TRUE │ FALSE SE FALSE SE FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │
│ FALSE AL FALSE │ ट्रायल │ FALSE SE FALSE AL FALSE │ FALSE AL FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │
│ 1 │ FALSE │ FALSE │ ट्रायल │ FALSE AL FALSE │ FALSE AL FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │
│ 0 │ FALSE │ FALSE SE FALSE │ ट्रायल SE FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │
│ -1 │ FALSE │ FALSE SE FALSE SE FALSE UE TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │
│ "1" SE FALSE SE FALSE SE FALSE 1 FALSE │ FALSE AL ट्रायल │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │
│ "0" │ FALSE SE FALSE SE FALSE 0 FALSE │ FALSE AL FALSE │ FUESE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │
│ "-1" SE FALSE SE FALSE SE FALSE -1 FALSE │ FALSE AL FALSE │ FALSE │ सही UE FALSE │ FALSE │ FALSE │ FALSE │ FALSE │
AL NULL │ FALSE │ FALSE SE FALSE SE FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ अंदाज │ │ FALSE │ FALSE │ FALSE │
│ सरणी () │ FALSE SE FALSE SE FALSE (FALSE │ FALSE AL FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │
│ "php" SE FALSE SE FALSE SE FALSE AL FALSE │ FALSE AL FALSE "FALSE" FALSE "FALSE" FALSE "अंदाज" FALSE "
│ "" SE FALSE │ FALSE SE FALSE SE FALSE AL FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │
└─────────┴───────┴───────┴───────┴───────┴─────── ┴───────┴───────┴───────┴───────┴─────────┴─────── ┴───────┘
— nickf
स्रोत
65
किसी और को यह अजीब लगता है कि "000" == "0000"?
— निक सिप १
36
हमेशा जो मुझे अचंभित करता है, वह यह है कि गलत == सरणी (), और गलत == 0 लेकिन सरणी ()! = 0, इसलिए गलत == सरणी ()! = / = = 0 जो मुझे अजीब लगता है।
— पीम जगर
4
@Pim ... जारी रखा: इसे इस तरह से देखें: BOOL में कास्टिंग, किसी भी मूल्य को केवल दो पक्षों में से एक पर गिरना पड़ता है, trueया false। यह आसान है। सभी अन्य मूल्यों, हालांकि सभी व्यावहारिक उद्देश्यों के लिए, लगभग असीमित संयोजन हैं। है "five" == 5? array(0) == 0? array(0,0,0) == 0? 0.0000000000000000000000000000000000000000000000000001 == array()?
— deceze
12
@ रेथलिन, सरणी से सावधान। falseजावास्क्रिप्ट में अलग-अलग सरणियों के लिए ट्रिपल बराबरी देता है , लेकिन truePHP के लिए जब तक कि उनके मूल्य समान हैं ।
— पचेरियर
14
@ रीथलिन, कई और अधिक गोचर्स। जावास्क्रिप्ट में: "000" != "00" , "000" == null, "000" == false, "0x0" == false, array() == 0, false != null, array() != null, false == "0x0", false == "000"। पीएचपी में, यह विपरीत व्यवहार है: "000" == "00" , "000" != null, "000" != false, "0x0" != false, array() != 0, false == null, array() == null, false != "0x0", false != "000"।
— पचेरियर
239

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

उदाहरण:

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)
— पैट्रिक ग्लैंडियन
स्रोत
3
नाइटपिक: === केवल तभी सही होगा जब दोनों ऑपरेंड एक ही प्रकार के हों और मान समान हों ) =)
— gnud
1
@gnud वह बिल्कुल वही है जो उसने उदाहरण में दिखाया है। यदि यह केवल प्रकारों की तुलना कर रहा है, तो इसे "टाइप तुलना" कहा जाएगा।
— रोब स्टीवेन्सन-लेगेट
3
8 साल के लिए PHP का उपयोग करने के बाद, कल पहली बार मैं एक ऐसी स्थिति में फंस गया, जहाँ मुझे ===
3
=== सच अगर वे समान हैं और एक ही प्रकार के हैं। == सच अगर वे समान हैं। अगर वे बराबर नहीं हैं तो सच है। ! == सच है अगर या तो वे समान नहीं हैं, या समान हैं लेकिन समान प्रकार नहीं हैं।
— जेरेमी सी
1
इसके अलावा, === का उपयोग = = की तुलना में थोड़ा तेज है क्योंकि अगर यह बराबर है तो जाँच करने से पहले मूल्य को बदलने की आवश्यकता नहीं है।
— क्लूजियर
88

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

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

यहाँ छवि विवरण दर्ज करें

PHP ट्रिपल ===इक्वलिटी इक्वलिटी चार्ट:

यहाँ छवि विवरण दर्ज करें

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

https://github.com/sentientmachine/php_equality_charts

गुरु ध्यान

जो लोग अपनी पवित्रता को बनाए रखना चाहते हैं, वे आगे नहीं पढ़ते हैं क्योंकि इसमें से कोई भी अर्थ नहीं होगा, सिवाय यह कहने के कि यह कैसे है, PHP का पागलपन-भग्न डिजाइन किया गया था।

  1. NAN != NANलेकिन NAN == true।
  2. ==बाएँ और दाएँ ऑपरेंड को संख्याओं में परिवर्तित करेंगे यदि बाएँ एक संख्या है। तो 123 == "123foo", लेकिन"123" != "123foo"

  3. उद्धरण में एक हेक्स स्ट्रिंग कभी-कभी एक फ्लोट है, और आपकी इच्छा के खिलाफ फ्लोट करने के लिए आश्चर्यचकित कर दिया जाएगा, जिससे एक रनटाइम त्रुटि हो सकती है।

  4. ==क्योंकि "0"== 0, और 0 == ""लेकिन सकर्मक नहीं है"0" != ""

  5. PHP वेरिएबल्स जो अभी तक घोषित नहीं किए गए हैं, भले ही PHP अपरिभाषित चर का प्रतिनिधित्व करने का एक तरीका है, लेकिन यह सुविधा अक्षम है ==।

  6. "6" == " 6", "4.2" == "4.20"और, "133" == "0133"लेकिन 133 != 0133। लेकिन "0x10" == "16"और "1e3" == "1000"उस आश्चर्य स्ट्रिंग को ऑक्टल में उजागर करने से आपकी अनुदेश या सहमति के बिना, एक रनटाइम त्रुटि हो जाएगी।

  7. False == 0, "", []और "0"।

  8. जब संख्या बड़ी होती है तो वे == अनंत होते हैं।

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

  10. असत्य सबसे खतरनाक मूल्य है, क्योंकि फालसे == है अधिकांश अन्य चर के लिए, ज्यादातर इसे पराजित करना उद्देश्य है।

आशा:

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

कहीं भी आप ==PHP में उपयोग करते हैं एक बुरा कोड गंध है क्योंकि इसमें 85 बग हैं जो अंतर्निहित कास्टिंग नियमों से उजागर होते हैं जो कि ब्राउनियन गति द्वारा लाखों प्रोग्रामर प्रोग्रामिंग द्वारा डिज़ाइन किए गए लगते हैं।

— एरिक लेसचिंस्की
स्रोत
क्या यह वास्तव में एक अच्छा विचार है (सुरक्षित भी) हमेशा ट्रिपल बराबर का उपयोग करने के लिए?
— चेज़ी चैज़
3
हां, ट्रिपल बराबर की सकर्मक संपत्ति इसे और अधिक सुरक्षित और वेबसैल बनाती है।
— एरिक लेसचिन्स्की
एक संख्या अनंत के करीब कैसे हो सकती है? [विस्फोट मस्तिष्क gif]
— टिम
40

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

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

उदाहरण के लिए, नीचे दिया गया नमूना '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');
}
— पीटर मोर्टेंसन
स्रोत
Upvoted, जैसा कि यह php के लिए ठीक यही स्थिति प्रतीत होती है।
— डेविड का कहना है कि मोनिका
1
@DavidThomas यह बिल्कुल same.See है stackoverflow.com/questions/12598407/...
— xdazz
22

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

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

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

== चेक यदि समकक्ष (केवल मूल्य)

=== यह जाँचता है कि क्या समान (मान और& प्रकार)


समतुल्य बनाम समान: एक सादृश्य

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

1 + 1 = 1 + 1 (वही)


PHP में:

सच == 1 (वास्तविक - मूल्य के बराबर)

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

  • सच बुलियन है
  • 1 इंट है
— चांदी
स्रोत
"=== चेक अगर वही (मान और& प्रकार)", बिल्कुल सही नहीं है। दो stdClass ऑब्जेक्ट में एक ही प्रकार की 'ऑब्जेक्ट' (जैसे गेटटाइप () का उपयोग करके) है, लेकिन PHP का कहना है कि यदि आप सख्त तुलना का उपयोग करते हैं तो वे दो अलग-अलग चीजें हैं। इसे देखें ।
— मेकितगढ़ा
8

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

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

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

$var=1;

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

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

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

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

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

if ($var === true)
{
    echo "var is 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)

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

— पीटर मोर्टेंसन
स्रोत
8

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

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

php == एक तुलना ऑपरेटर है जो चर के मूल्य की तुलना करता है। लेकिन === मूल्य और डेटा प्रकार की तुलना करता है।

उदाहरण के लिए,

<?php 
  $var1 = 10;
  $var2 = '10';

  if($var1 == $var2) {
    echo 'Variables are equal';
  } else {
    echo 'Variables are not equal';
  }
?>

इस मामले में आउटपुट 'वेरिएबल्स बराबर हैं' होगा, भले ही उनके डेटा प्रकार भिन्न हों।

लेकिन अगर हम == के बजाय === का उपयोग करते हैं, तो आउटपुट 'वेरिएबल्स न के बराबर' हो जाएगा। Php पहले वेरिएबल के मान और फिर डेटा टाइप की तुलना करता है। यहां मूल्य समान हैं, लेकिन डेटा प्रकार भिन्न हैं।

— 2rahulsk
स्रोत
6

दिया हुआ x = 5

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

— Mannusanghi
स्रोत
3 
$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...
}
— Seph
स्रोत
3

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

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

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

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

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

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

— क्रिश्चियन पी।
स्रोत
1
यह ध्यान दिया जाना चाहिए कि उन "शॉर्टकट" के अलावा, == ऑपरेटर के असामान्य व्यवहारकर्ता को सुरक्षा छेद खोलने के लिए जाना जाता है, उदाहरण के लिए एक लोकप्रिय PHP मंच जहां कुकीज़ पासवर्ड हैश मान को सही, परिधि में सेट करना संभव था। अगर (डेटाबेसश == कुकीहाश) सत्यापन।
— डेविड
3

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

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.

पुनश्च

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

बनाम

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

— मोहित तनवानी
स्रोत
इस उत्तर में क्या समस्या है?
— मोहित तनवानी
2

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

$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)

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

— स्टेसी रिचर्ड्स
स्रोत
2

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

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

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

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

if (fwrite(stuff) === FALSE)
{
    log('error!');
}
— मारियो
स्रोत
2

PHP एक शिथिल टाइप की भाषा है। डबल बराबर ऑपरेटर का उपयोग करना एक चर की ढीली जाँच के लिए अनुमति देता है।

एक मान की जाँच करने पर कुछ समान के लिए अनुमति देता है, लेकिन समान नहीं है, मान समान होने के लिए:

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

ये सभी मान डबल बराबर ऑपरेटर का उपयोग करते हुए समान होंगे।

— कोरी कोलियर
स्रोत
1

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

  • $ var = "परीक्षण" एक स्ट्रिंग है जिसमें "परीक्षण" होता है
  • $ 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, यह गलत पर डाला गया है और आपको कोई त्रुटि लगती है। सही कोड है:

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

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

— ofaurax
स्रोत
गैर-खाली तारों के बारे में, यह वास्तव में सच नहीं है। "a" == 0 TRUE है।
— निक सिप १
1

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

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

— kmkaplan
स्रोत
1 
<?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);
?>
— सतीश
स्रोत
1

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

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

देता है:

 equal
 not equal

ध्यान दें कि यह "राउंडिंग एरर" का मामला नहीं है। दो संख्याएं अंतिम बिट के बराबर होती हैं, लेकिन उनके विभिन्न प्रकार होते हैं।

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

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

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

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

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

— DavidWalley
स्रोत
0

के बीच दो अंतर हैं ==और=== पीएचपी सरणियों और वस्तुओं मुझे लगता है कि यहाँ का उल्लेख नहीं था में; विभिन्न प्रकारों और वस्तुओं के साथ दो सरणियाँ।

विभिन्न प्रकार के साथ दो सरणियाँ

यदि आपके पास एक कुंजी प्रकार के साथ एक सरणी है और किसी भिन्न सरणी के साथ दूसरा सरणी है, तो वे कड़ाई से भिन्न होते हैं (अर्थात उपयोग कर रहे हैं ===)। यदि आप किसी सरणी को कुंजी-क्रमबद्ध करते हैं, और मूल वाले के साथ क्रमबद्ध सरणी की तुलना करने का प्रयास कर सकते हैं।

उदाहरण के लिए, एक खाली सरणी पर विचार करें। सबसे पहले, हम कुछ नए इंडेक्स को बिना किसी विशेष प्रकार के सरणी में धकेलने का प्रयास करते हैं। एक अच्छा उदाहरण कुंजी के रूप में तार के साथ एक सरणी होगा। अब एक उदाहरण में गहरा:

// Define an array
$arr = [];

// Adding unsorted keys
$arr["I"] = "we";
$arr["you"] = "you";
$arr["he"] = "they";

अब, हमारे पास नॉट-सॉर्ट-कीज़ एरे है (जैसे, 'वह' 'आप' के बाद आया)। उसी सरणी पर विचार करें, लेकिन हमने इसकी कुंजियों को वर्णानुक्रम से हल किया:

// Declare array
$alphabetArr = [];

// Adding alphabetical-sorted keys
$alphabetArr["I"] = "we";
$alphabetArr["he"] = "they";
$alphabetArr["you"] = "you";

युक्ति : आप ksort () का उपयोग करके किसी सरणी को सॉर्ट कर सकते हैं फ़ंक्शन ।

अब आपके पास पहले वाले से अलग कुंजी प्रकार के साथ एक और सरणी है। इसलिए, हम उनकी तुलना करने जा रहे हैं:

$arr == $alphabetArr; // true
$arr === $alphabetArr; // false

नोट : यह स्पष्ट हो सकता है, लेकिन दो अलग-अलग सरणियों की तुलना करते हुए सख्त तुलना हमेशा परिणाम देती है false। हालांकि, दो मनमानी सरणियों का उपयोग करना ===या नहीं के बराबर हो सकता है ।

आप कहेंगे: "यह अंतर नगण्य है"। फिर मैं कहता हूं कि यह एक अंतर है और इस पर विचार किया जाना चाहिए और कभी भी हो सकता है। जैसा कि ऊपर उल्लेख किया गया है, सरणी में कुंजियों को क्रमबद्ध करना उस का एक अच्छा उदाहरण है।

वस्तुओं

ध्यान रखें, दो अलग-अलग वस्तुएं कभी भी सख्त-समान नहीं होती हैं । ये उदाहरण मदद करेंगे:

$stdClass1 = new stdClass();
$stdClass2 = new stdClass();
$clonedStdClass1 = clone $stdClass1;

// Comparing
$stdClass1 == $stdClass2; // true
$stdClass1 === $stdClass2; // false
$stdClass1 == $clonedStdClass1; // true
$stdClass1 === $clonedStdClass1; // false

नोट : किसी वस्तु को किसी अन्य चर में संकलित करने से प्रतिलिपि नहीं बनती - बल्कि, यह ऑब्जेक्ट के समान मेमोरी स्थान के लिए एक संदर्भ बनाता है। यहाँ देखें ।

नोट : PHP7 के रूप में, अनाम कक्षाएं जोड़ी गई थीं। परिणामों से, वहाँ कोई अंतर नहीं है new class {}और new stdClass()इसके बाद के संस्करण परीक्षण में।

— MAChitgarha
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.