क्यों 'परिभाषित() || 'एक निरंतर

Question

को परिभाषित करने में वाक्य रचना क्यों यह परिभाषित करने से पहले यदि एक निरंतर अस्तित्व की जाँच की इस पद्धति है वहाँ का प्रयोग करने में कोई अंतर है

if !(defined('CONSTANT')) { 
    define('CONSTANT', somedefinition); 
} 

:

defined('CONSTANT') || define('CONSTANT', somedefinition); 

के बजाय इस्तेमाल किया' को परिभाषित() या 'इसके बजाए' || पहली विधि में, मैंने दोनों पुस्तकों में देखा है।

Answer 1

|| (सी, जावा, सी #, पीएचपी) में "शॉर्ट सर्किट" (यदि पहला ऑपरेंड सत्य है, तो दूसरे का मूल्यांकन नहीं किया जाता है क्योंकि अभिव्यक्ति का मूल्यांकन पहले से ही किया जा सकता है, इससे कोई फर्क नहीं पड़ता कि दूसरा क्या है।

(यदि परिभाषित ...:

तो इस क्लासिक सी शैली "संक्षिप्तता" कार्रवाई में है संभव के रूप में कोड के कम लाइनों के रूप में प्रयोग करें, बावजूद इसके कि वास्तव में कुछ और पूरे अक्षरों में लिखावट के रूप में ही कर

तो यह पढ़ता है।।), परिभाषित नहीं करें() बिट ... परिभाषित नहीं किया गया है(), परिभाषित() बिट का मूल्यांकन करने की प्रक्रिया करें और प्रक्रिया में, यह निरंतर परिभाषित करेगा।

Answer 2

defined('CONSTANT') || define('CONSTANT', somedefinition); 

वास्तव में एक चाल है। आप देखते हैं, || ऑपरेटर केवल अभिव्यक्ति के दूसरे भाग को निष्पादित करता है जब पहला भाग झूठा है :) यह एक ही कामकाजी कोड लिखने का एक त्वरित, छोटा तरीका है।

Answer 3

अन्य ने पहले जवाब दिया है आपके प्रश्न का हिस्सा है, इसलिए मैं बाद वाला ले जाऊंगा:

जहां तक ​​or बनाम || संबंधित है इस विशिष्ट मामले में कोई अंतर नहीं है। हालांकि, or (असाइनमेंट ऑपरेटर) से operator precedence कम है, जबकि || अधिक है। यह महत्वपूर्ण है, यदि आप असाइनमेंट करने के लिए शॉर्ट-सर्किटिंग का उपयोग करना चाहते हैं।

पर विचार करें:

$a = 2 or $b = 2; 
var_dump($a); // int(2) 


$a = 3 || $b = 3; 
var_dump($a); // bool(true) 

दूसरे उदाहरण में, ||= से पहले का मूल्यांकन किया गया। कोष्ठकों का उपयोग करते हुए यह इस

$a = (3 || $b = 3); 

कैसा लगेगा जबकि पहले एक

($a = 2) or ($b = 2); 

Answer 4

तो मेरी धारणा शॉर्ट सर्किट, तेजी से होता है के बाद से अगर बयान परिभाषित से बूलियन मान लेने और flipping है यह उपयोग कर रहा है एक नहीं ऑपरेटर, लेकिन सिर्फ पूरी तरह से हो सकता है, यहाँ मेरी बेंचमार्क परीक्षण है:

---

पीएचपी 5.6:

0.23026204109192 - टेस्ट 1 ए: शॉर्ट सर्किट: पहले लूप पर गतिशील परिभाषा।
0.22264909744263 - टेस्ट 1 बी: अगर वक्तव्य: पहले लूप पर गतिशील परिभाषित करें।
0.22433304786682 - टेस्ट 2 ए: शॉर्ट सर्किट: टेस्ट चलाने से पहले स्टेटिक परिभाषित करें।
0.22339177131653 - टेस्ट 2 बी: अगर वक्तव्य: टेस्ट चलाने से पहले स्टेटिक परिभाषित करें।
0.27459692955017 - टेस्ट 3 ए: शॉर्ट सर्किट: चर परिभाषित नहीं करें।
0।28696393966675 - टेस्ट 3 बी: अगर वक्तव्य: चर परिभाषित नहीं करें।

निष्कर्ष
बहुत पास बताने के लिए, हालांकि हम शॉर्ट सर्किट के लिए एक ध्यान देने योग्य गति सुधार देख सकते हैं चर परिभाषित कभी नहीं किया गया है।

---

पीएचपी 7:

0,031289100646973 - Test1a: शॉर्ट सर्किट: गतिशील पहले लूप पर परिभाषित करते हैं।
0.041652917861938 - टेस्ट 1 बी: अगर वक्तव्य: पहले लूप पर गतिशील परिभाषित करें।
0.023349046707153 - टेस्ट 2 ए: शॉर्ट सर्किट: टेस्ट चलाने से पहले स्टेटिक परिभाषित करें।
0.052791118621826 - टेस्ट 2 बी: अगर वक्तव्य: टेस्ट चलाने से पहले स्टेटिक परिभाषित करें।
0.064755916595459 - टेस्ट 3 ए: शॉर्ट सर्किट: चर परिभाषित नहीं करें।
0.056003093719482 - टेस्ट 3 बी: अगर वक्तव्य: चर परिभाषित नहीं करें।

निष्कर्ष पीएचपी 7 स्पष्ट रूप से स्थिरांक/निर्धारित वेरिएबल के मामले में शॉर्ट सर्किट अनुकूलित होते हैं, हालांकि हम विपरीत यदि लगातार परिभाषित कभी नहीं किया गया है। इसका तात्पर्य यह है कि वास्तव में अस्तित्व वाले स्थिरांक की जांच नाटकीय रूप से सुधार की गई है, जिससे अतिरिक्त कथन को जोड़ा जा सकता है जो कि अगर कथन में जोड़े गए ऑपरेटर द्वारा आवश्यक नहीं है।

कुल मिलाकर निष्कर्ष

अंतर नगण्य है (जब तक आप कोड की एक ही पंक्ति का भार के लाखों लोगों में हो रही है) इसलिए का उपयोग जो कुछ भी आप और आपकी टीम के लिए सबसे अधिक समझ में आता है।

इसके अलावा, मैन, PHP7 इन परीक्षणों के प्रदर्शन के संदर्भ में PHP 6.5 को धुआं!

---

कोड:

$c1a=0; 
$title1a = 'Test1a: Short circuit: Dynamic define on first loop.'; 
$c1b=0; 
$title1b = 'Test1b: If Statement: Dynamic define on first loop.'; 

$c2a=0; 
$title2a = 'Test2a: Short circuit: Static define before test is run.'; 
$c2b=0; 
$title2b = 'Test2b: If Statement: Static define before test is run.'; 

$c3a=0; 
$title3a = 'Test3a: Short circuit: Never define variable.'; 
$c3b=0; 
$title3b = 'Test3b: If Statement: Never define variable.'; 

$start1a = microtime(true); 
while ($c1a < 1000000) { 
    ++$c1a; 
    defined('TEST_CONST_1A') || define('TEST_CONST_1A', 'test'); 
} 
$stop1a = microtime(true); 

$start1b = microtime(true); 
while ($c1b < 1000000) { 
    ++$c1b; 
    if (!defined('TEST_CONST_1B')) { 
    define('TEST_CONST_1B', 'test'); 
    } 
} 
$stop1b = microtime(true); 

define('TEST_CONST_2A', 'test'); 
$start2a = microtime(true); 
while ($c2a < 1000000) { 
    ++$c2a; 
    defined('TEST_CONST_2A') || define('TEST_CONST_2A', 'test'); 
} 
$stop2a = microtime(true); 

define('TEST_CONST_2B', 'test'); 
$start2b = microtime(true); 
while ($c2b < 1000000) { 
    ++$c2b; 
    if (!defined('TEST_CONST_2B')) { 
    define('TEST_CONST_2B', 'test'); 
    } 
} 
$stop2b = microtime(true); 

$start3a = microtime(true); 
while ($c3a < 1000000) { 
    ++$c3a; 
    defined('TEST_CONST_3A') || $c3a; 
} 
$stop3a = microtime(true); 

$start3b = microtime(true); 
while ($c3b < 1000000) { 
    ++$c3b; 
    if (!defined('TEST_CONST_3B')) { 
    $c3b; 
    } 
} 
$stop3b = microtime(true); 

print ($stop1a - $start1a) . ' - ' . $title1a . "\n"; 
print ($stop1b - $start1b) . ' - ' . $title1b . "\n"; 
print ($stop2a - $start2a) . ' - ' . $title2a . "\n"; 
print ($stop2b - $start2b) . ' - ' . $title2b . "\n"; 
print ($stop3a - $start3a) . ' - ' . $title3a . "\n"; 
print ($stop3b - $start3b) . ' - ' . $title3b . "\n";