हम PHP तैयार कर रहे हैं। कैसे, जबकि, foreach, array_walk और कुछ अन्य डरावने शब्द हैं

शाम हो चुकी थी, कुछ करने को नहीं था। यह एक छोटे से विश्लेषण की व्यवस्था करने का समय है कि आंतरिक रूप से PHP में सरणियों को छांटने के कुछ तरीके कैसे भिन्न हैं।

मास्टर ब्रांच के सूत्र (यह अब 8 के साथ 7.4 इंटरसेप्टेड है)
Php से opcode जनरेटर 7.3.0।
7.3.6 पर माप किए गए थे।

नर्ड्स के लिए अस्वीकरण: नैनोसेकंड्स और प्रोसेसर चक्रों के एक जोड़े का उल्लेख करना "पॉलीबिकल" नामक एक ऐसी पोलिमिकल ट्रिक है।

हो सकता है, वास्तव में, दसियों या सैकड़ों नैनोसेकंड और हजारों उपाय हैं, लेकिन यह अभी भी इतना छोटा है कि उन पर बचत करने की आवश्यकता बताती है कि आपके कोड में कुछ गलत है।

संकलन मंच

foreach , for और do भाषा के कीवर्ड हैं, जबकि array_ * फ़ंक्शन मानक लाइब्रेरी के कार्य हैं। इसलिए, ceteris paribus, पहले के अनुसार, parser नैनोसेकंड के एक जोड़े को तेजी से निष्पादित करेगा।

पार्सर

बयान टोकन तक, पथ सभी के लिए समान होगा

start -> top_statement_list -> top_statement -> statement 

लूप्स को बयान स्तर पर परिभाषित किया गया है:

 ->T_FOR '(' for_exprs ';' for_exprs ';' for_exprs ')' for_statement ->T_FOREACH '(' expr T_AS foreach_variable ')' foreach_statement ->T_FOREACH '(' expr T_AS foreach_variable T_DOUBLE_ARROW foreach_variable ')' foreach_statement ->T_DO statement T_WHILE '(' expr ')' ';' ->T_WHILE '(' expr ')' while_statement 

For_exprs और बस expr के बीच का अंतर केवल इतना है कि पहले एक के लिए, कई expr लिखने की अनुमति है, अल्पविराम द्वारा अलग की गई है।

foreach_variable एक ऐसा निर्माण है, जो केवल चर के अलावा, सूची या [] का उपयोग करके अपघटन को भी ट्रैक करता है।

for_statement , foreach_statement , जबकि_ statement मानक कथन से भिन्न होता है कि वे वैकल्पिक वाक्यविन्यास को पार्स करने की क्षमता जोड़ते हैं:

 foreach($array as $element): #do something endforeach; 

फ़ंक्शन कॉल को बहुत गहरा दफन किया जाता है:

 -> expr -> variable -> callable_variable -> function_call -> name argument_list 

callable_variable , हम्म ... अजीब बात है, है ना? :)

चलो opcodes पर चलते हैं।

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

foreach

 $arr = ['a', 'b', 'c']; //        foreach($arr as $key => $value) echo $key.$value; 

 line #* EIO op fetch ext return operands --------------------------------------------------------------------------- 2 0 E > ASSIGN !0, <array> 4 1 > FE_RESET_R $4 !0, ->7 2 > > FE_FETCH_R ~5 $4, !1, ->7 3 > ASSIGN !2, ~5 4 CONCAT ~7 !2, !1 5 ECHO ~7 6 > JMP ->2 7 > FE_FREE $4 5 8 > RETURN 1 

यहाँ क्या हो रहा है:

FE_RESET_R : सरणी के लिए $ 4 का पुनरावृत्त बनाता है ! 0 । या, यदि सरणी खाली है, तो यह तुरंत अनुदेश 7 पर जाता है ।
FE_FETCH_R : एक पुनरावृत्ति चरण करता है, ~ 5 पर वर्तमान कुंजी और 1 पर मान निकालता है । या, यदि सरणी का अंत पहुँच गया है, तो यह निर्देश 7 पर जाता है ।
निर्देश 3-6 विशेष रूप से दिलचस्प नहीं हैं । यहाँ एक निष्कर्ष है और FE_FETCH_R पर वापस लौटें ।
FE_FREE : पुनरावृति को नष्ट करता है।

जबकि, के लिए ...

 $length = count($arr); for($i = 0; $i < $length; $i++) echo $i.$arr[$i]; 

यह वास्तव में जबकि का एक विशेष मामला है

 $i = 0; while($i < $length) { echo $i.$arr[$i]; $i++; } 

यह वास्तव में if + goto का एक विशेष मामला है

 $i = 0; goto check; body: echo $i.$arr[$i]; $i++; check: if($i < $length) goto body; 

तीनों मामलों के ऑपकोड लगभग समान होंगे। जब तक अगर , के मामले में JMPNZ JMPZ + JMP की जोड़ी में बदल जाएगा, अगर उसके शरीर में प्रवेश नहीं किया गया है।
डो लूप के लिए, सत्यापन के बाद की प्रकृति के कारण ऑपकोड थोड़ा अलग होगा।

 line #* EIO op fetch ext return operands --------------------------------------------------------------------------- 3 0 E > ASSIGN !0, <array> 5 1 COUNT ~4 !0 2 ASSIGN !1, ~4 6 3 ASSIGN !2, 0 4 > JMP ->10 5 > FETCH_DIM_R ~7 !0, !2 6 CONCAT ~8 !2, ~7 7 ECHO ~8 8 POST_INC ~9 !2 9 FREE ~9 10 > IS_SMALLER ~10 !2, !1 11 > JMPNZ ~10, ->5 12 > > RETURN 1 

जैसी कि उम्मीद थी, अधिक ऑपकोड हैं।
0-2 : $ लंबाई की गणना।
3: $ i = 0
4, 10, 11 : निकास स्थिति की प्रारंभिक जांच और, वास्तव में, या तो बाहर निकलना या चक्र के शरीर में संक्रमण।
5 (FETCH_DIM_R): $ गिरफ्तार [$ i]
6-7 : निष्कर्ष
8-9: $ i ++ (ध्यान दें कि किसी भी मामले में वेतन वृद्धि एक मान लौटाता है, भले ही इसकी आवश्यकता न हो। इसलिए, इसे खाली करने के लिए एक अतिरिक्त मुफ़्त निर्देश की आवश्यकता होती है)।
10-11 : वेतन वृद्धि के बाद निकास की स्थिति की जाँच करना।

या आप अभी भी पुनरावृति कर सकते हैं

 $value = reset($arr); $key = key($arr); while($key !== null) { echo $key.$value; $value = next($arr); $key = key($arr); } 

यह विकल्प अच्छा है क्योंकि यह किसी भी कुंजी के साथ एक सरणी पर पुनरावृत्ति के लिए उपयुक्त है, और न केवल मोनोटोनिक रूप से बढ़ते पूर्णांक के साथ।

रीसेट , अगला और मुख्य कार्य बहुत हल्के होते हैं, लेकिन उन्हें कॉल करने के लिए कुछ ओवरहेड अभी भी है। और, जैसा कि हम बाद में देखेंगे, ये लागत अधिक हैं।

हालांकि यह दृष्टिकोण फॉर्च्यूनर के सिद्धांत के समान है, उनके बीच दो मूलभूत अंतर हैं।

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

यानी

 foreach($arr as $v) echo $v.' - '.current($arr).PHP_EOL; //---------------- a - a b - a c - a 

2) जब मूल्य से पुनरावृति करने के लिए foreach का उपयोग करते हैं, तो आप जो कुछ भी लूप के अंदर सरणी के साथ करते हैं, मूल डेटा सेट को प्रसारित किया जाएगा

 foreach($arr as $v) { $arr = ['X','Y','Z']; echo $v.PHP_EOL; } var_dump($arr); //---------------- a b c array(3) { [0]=> string(1) "X" [1]=> string(1) "Y" [2]=> string(1) "Z" } 

क्या होगा जब लिंक पर पुनरावृत्ति इस RFC में पढ़ी जा सकती है। वहां सब कुछ बहुत सरल नहीं है।

array_walk अनाम फ़ंक्शन के साथ

 array_walk($arr, function($value, $key){ echo $key.$value;}); 

चूंकि एक कस्टम फ़ंक्शन का उपयोग किया जाता है, अफीम का एक अतिरिक्त सेट होगा।

समारोह

 line #* EIO op fetch ext return operands --------------------------------------------------------------------------- 0 E > RECV !0 1 RECV !1 2 CONCAT ~2 !1, !0 3 ECHO ~2 4 > RETURN null 

मुख्य कोड

 line #* EIO op fetch ext return operands --------------------------------------------------------------------------- 2 0 E > ASSIGN !0, <array> 4 1 INIT_FCALL 'array_walk' 2 SEND_REF !0 3 DECLARE_LAMBDA_FUNCTION '%00%7Bclosure%7D%2Fin%2FHuNEK0x7f9fa62d105a' 4 SEND_VAL ~2 5 DO_ICALL 6 > RETURN 1 

चूंकि array_walk , मानक पुस्तकालय के बाकी कार्यों की तरह, आंतरिक है, इसलिए संकलित ओपकोड में कोई पुनरावृत्ति तंत्र नहीं है।

INIT_FCALL : array_walk पर कॉल प्रारंभ करें
SEND_REF : कॉल स्टैक पर एक सरणी संदर्भ डालें
DECLARE_LAMBDA_FUNCTION : एक अनाम फ़ंक्शन घोषित करें
SEND_VAL : हमने कॉल स्टैक पर एक अनाम फ़ंक्शन डाला
DO_ICALL : निष्पादित करने के लिए array_walk चलाएं

अगला, सरणी के प्रत्येक तत्व के लिए हमारे लैम्ब्डा के कॉल के साथ जादू होता है।

array_walk पूर्वनिर्धारित फ़ंक्शन का उपयोग करते हुए

एक अनाम के साथ कॉल करने से बहुत अलग नहीं, सिवाय इसके कि शायद रनटाइम में लैम्बडा बनाने के ओवरहेड से थोड़ा कम।

 line #* EIO op fetch ext return operands --------------------------------------------------------------------------- 3 0 E > ASSIGN !0, <array> 9 2 INIT_FCALL 'array_walk' 3 SEND_REF !0 4 SEND_VAL 'my_echo' 5 DO_ICALL 6 > RETURN 1 

निष्कर्ष सामान्य हैं। foreach को एररेटिंग एरेज़ के लिए कस्टमाइज़ किया गया है, जबकि बाकी लूप्स केवल + गोटो के ऊपर एक आवरण है।

मानक पुस्तकालय के कार्य एक ब्लैक बॉक्स के सिद्धांत पर काम करते हैं।

थोड़ा और गहरा उतरना

सबसे पहले, इसके और इसके opcode FETCH_DIM_R के साथ मामले पर विचार करें, जिसका उपयोग कुंजी द्वारा मान निकालने के लिए किया जाता है। आइटम को हैश तालिका ( ZEND_HASH_INDEX_FIND ) में एक खोज के माध्यम से निकाला जाता है। हमारे मामले में, निष्कर्षण एक भरे हुए सरणी से आता है (चाबियाँ एक निरंतर संख्यात्मक अनुक्रम हैं) - यह एक काफी आसान और त्वरित संचालन है। अनपेक्षित सरणियों के लिए, यह थोड़ा अधिक महंगा होगा।

अब foreach ( FE_FETCH_R )। सब कुछ यहाँ है:

1. यह देखना कि अगर इटर्इंटर पॉइंटर ऐरे के बाहर है
2. वर्तमान कुंजी और मूल्य को पुनः प्राप्त करें
3. वृद्धि सूचक

खैर, array_walk जैसे फंक्शंस का क्या होता है? हालाँकि वे सभी अलग-अलग काम करते हैं, लेकिन वे सभी एक ही सिद्धांत हैं।

यदि पूरी तरह से सरल किया गया है, तो (छद्म कोड):

 reset_pointer() do { value = get_current_value() if (value == NULL) break //  NULL,   zval  NULL key = get_current_key() call_function(myFunction, key, value) increment_pointer() } while(true) 

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

खैर, कुछ माप

और फिर आखिरकार, माप के बिना लेख क्या है (स्मृति से यह इतना समान रूप से निकला कि उसने अपना माप हटा दिया)।

एक सरणी के रूप में, परंपरा के अनुसार, हम 70.108 लाइनों के लिए zend_vm_execute.h लेते हैं।


प्रत्येक माप को 10 बार चलाया गया, जो पहले 4 अंकों में सबसे अधिक बार होता है।

 foreach time: 0.12159085273743 foreach(reference) time: 0.11191201210022 for, while time: 0.13130807876587 array_walk(lambda) time: 0.87953400611877 array_walk(static lambda) time: 0.87544417497211 array_walk(name) time: 0.50753092765808 next,key time: 1.06258893013 

संक्षेप में देना

परिणामों का विश्लेषण करते हुए, यह ध्यान रखना न भूलें कि उन्हें 70 हजार तत्वों की एक सरणी के माध्यम से 10 पास दिए गए थे।

पूर्ण विरोधी नायक अगली / कुंजी के साथ foreach का "अनुकरण" था। जब तक बिल्कुल आवश्यक न हो ऐसा न करें।

array_walk के साथ एक लैम्ब्डा उसकी पीठ में साँस लेता है, लेकिन एक अति सूक्ष्म अंतर है। आगामी JIT नाटकीय रूप से स्थिति को बदल सकती है। या शायद नहीं बदला। यह देखना दिलचस्प होगा।
array_walk एक तैयार किए गए फ़ंक्शन का उपयोग करके एक मजबूत मिडलिंग है।

चूंकि एक लिंक पर पुनरावृति होने पर foreach थोड़ा अलग तरीके से काम करता है (यह FE_FETCH_RW opcode के बजाय FE_FETCH_R का उपयोग करता है), इसने इसके लिए एक अलग माप बनाया। वह वास्तव में थोड़ा तेज निकला।

जैसा कि यह निकला, मक्खी पर एक लैम्ब्डा बनाना सबसे सस्ता ऑपरेशन नहीं है। ऐसा लगता है कि यह केवल 10 बार बनाया गया है। अध्ययन करना आवश्यक होगा।

अन्य सभी तरीकों ने लगभग समान परिणाम दिखाए, बहुत मामूली अंतर के साथ।

आपका ध्यान के लिए धन्यवाद!

यदि आपके पास कोई सुझाव है, तो आप "पिक" क्या कर सकते हैं - टिप्पणियों में लिखें। मैं अभी भी लंबोदर के बारे में सोच रहा हूं - इस तरह का प्रदर्शन बहुत विचित्र है।

युपीडी
स्थिर लैम्ब्डा के साथ array_walk के लिए पैमाइश जोड़ा गया। अंतर दिखाई नहीं पड़ता।