मैं PHP स्थापित किया है 5.2 एक अपने परीक्षण कंप्यूटर पर आज और कोड है कि पहले संस्करण में ठीक काम के टुकड़े के एक जोड़े 5.1.6 नए संस्करण में घातक त्रुटियों को फेंक दिया. त्रुटि संदेश था "नेस्टिंग भी गहरे स्तर पर - पुनरावर्ती निर्भरता?"और यह एक छोटे से समय ले लिया
PHP में दो ऑपरेटरों तुलना कर रहे हैं, == और ===. यह आमतौर पर कि पहले ज्ञात है प्रकार के बारे में सख्त नहीं है, लेकिन दूसरे नंबर पर है. इतना, उदाहरण के लिये
गूंज ( == झूठी 0 ); // सच
गूंज ( झूठी === 0 ); // झूठा
- 0 एक पूर्णांक है और झूठे एक बूलीयन है
मेरी समस्या वस्तुओं के साथ गैर सख्त टाइप का उपयोग करने से उठी.
$एक = नई MyObj();
$ख = नई MyObj();
अगर( $एक $ == ख )
…
मैं नहीं माना जाता था कि मैं क्या इस कोड के साथ कर रहा था. जब दो वस्तुओं की तुलना गैर सख्त तुलना ऑपरेटर का उपयोग करके (==) PHP वस्तुओं के सभी गुणों की तुलना और अगर वे मैच रहे हैं वस्तुओं के बराबर नहीं समझा. अगर वे मेल नहीं खाते वे समान नहीं हैं. प्रभाव में, हम प्रत्येक वस्तु के सभी गुणों का एक पुनरावर्ती तुलना है, और अपने सभी गुण, आदि. जब तक हम तार और integers जैसे बुनियादी डेटा प्रकार पहुंच.
अगर, तथापि, हम सख्त तुलना उपयोग (===), PHP की जाँच करेगा कि क्या दो वस्तुओं वही वस्तु है, समान गुणों के साथ न सिर्फ वस्तुओं.
वर्ग MyObj
{
$ सार्वजनिक p;
}$एक = नई MyObj();
$ख = नई MyObj();
$ग = नए MyObj();
$एक>p = 1;
$ख>p = 1;
$ग>p = 2;
गूंज ( $एक $ == ग ); // झूठा
गूंज ( $एक $ == ख ); // सच
गूंज ( $एक === ख $ ); // झूठा
समस्या खड़ी होती है अगर आप अपने वस्तुओं में परिपत्र संदर्भ गुण है. इतना, उदाहरण के लिये
वर्ग MyObj
{
$ सार्वजनिक p;
}
वर्ग OtherObj
{
$ q जनता;
}$एक = नई MyObj();
$ख = नई OtherObj();
$एक>P = $ ख;
$ख>Q = $ एक; // प्रचल संदर्भ: $एक>पी>=== एक $ q$ग = नए MyObj();
$घ = नई OtherObj();
$ग>P = $ d;
$घ ->= $ Q ग;// एक प्रचल संदर्भ: $ग>पी>$ q ग ===गूंज ( $एक $ == ग ); // घातक त्रुटि:
बहुत गहरे स्तर पर नेस्टिंग – पुनरावर्ती निर्भरता?
आदेश में एक $ $ करने के लिए तुलना करने के लिए ग, PHP उनके गुणों की तुलना चाहिए. PHP में तर्क जाता है तो कुछ इस तरह: $ग $ == अगर डॉलर एक>p == $c->पी अगर डॉलर ->p->क्ष == $ ग पी == $ ग -gt;क्ष अगर डपीलर ->p->q->p == $c->p->क्ष ->पी आदि. अनिश्चित काल.
PHP 5.1 करने पर किसी तरह की समस्या चिकनी लग रहा था (शायद recursion का एक निPHP्चित स्तर पर यह केवल झूठी लौट के बाद) – और आमतौर पर यह ठीक काम किया. PHP 5.2 सही ढंग से ऊपर घातक त्रुटि पैदा करता है.
एक बार जब आप इस समस्या का पता, समाधान आसान है – कड़े मुकाबले का उपयोग.
गूंज ( $एक $ === ग ); // झूठा (और कोई त्रुटि)
सख्त तुलना बस जाँच करें कि क्या दो वस्तुओं की स्मृति में एक ही स्थान पर हैं और इसलिए भी संपत्तियों के मूल्यों में नहीं लगती होगी.
नायब. एक ही समस्या पैदा कर सकते हैं जब नकार तुलना ऑपरेटर्स का उपयोग (प्रयोग !के बजाय == !=) और जब in_array का उपयोग (फायदा in_array तीसरे पैरामीटर सख्त तुलना इंगित करने के लिए).
