🌋 🛷 👩🏻‍🍳 पीएचपी। उद्धरण चिह्नों पर मंत्रमुग्ध करना 👵🏾 🌭 🙆🏻

PHP माइक्रो-ऑप्टिमाइज़ेशन के लिए, सिंगल कोट्स के साथ दोहरे उद्धरणों को प्रतिस्थापित करके, इतनी प्रतियां तोड़ दी जाती हैं कि यह एक नई स्ट्रीम बनाने के लिए काफी समस्याग्रस्त है। लेकिन मैं कोशिश करूंगा।

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

त्याग

नीचे वर्णित सब कुछ, अधिकांश भाग के लिए, नैनोसेकंड पर बचत है, और व्यवहार में यह इस तरह के माइक्रोएप्टिमाइजेशन पर खोए हुए समय को खोने के अलावा कुछ नहीं करेगा। यह संकलन समय के "अनुकूलन" के लिए विशेष रूप से सच है।
मैं केवल सार को छोड़कर, कोड और आउटपुट में अधिकतम कटौती करूंगा।
एक लेख लिखते समय, मैंने PHP 7.2 का उपयोग किया

आवश्यक परिचयात्मक

संकलन चरण पर दोहरे उद्धरण चिह्नों में एक स्ट्रिंग एकल उद्धरणों में एक स्ट्रिंग की तुलना में थोड़ा अलग तरीके से संसाधित होती है।

एकल उद्धरण इस तरह पार्स किया जाएगा:

statement -> expr -> scalar -> dereferencable_scalar -> T_CONSTANT_ENCAPSED_STRING

ऐसा डबल:

 statement -> expr -> scalar -> '"' encaps_list '"' ->        ,  ,

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

पार्सिंग इको :

 statement -> T_ECHO echo_expr_list -> echo_expr_list ->  echo_expr -> expr

पार्सिंग प्रिंट :

 statement -> expr -> T_PRINT expr -> expr ( )

यानी सामान्य तौर पर, हाँ, प्रतिध्वनि का एक कदम पहले पता चला है और यह कदम, यह ध्यान दिया जाना चाहिए, काफी मुश्किल है।

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

खैर, ताकि दो बार उठना न पड़े। प्रिंट और प्रतिध्वनि संकलन के कार्य इस प्रकार हैं:

 1 - void zend_compile_print(znode *result, zend_ast *ast) /* {{{ */ 1 + void zend_compile_echo(zend_ast *ast) /* {{{ */ 2 2 { 3 3 zend_op *opline; 4 4 zend_ast *expr_ast = ast->child[0]; 5 5 6 6 znode expr_node; 7 7 zend_compile_expr(&expr_node, expr_ast); 8 8 9 9 opline = zend_emit_op(NULL, ZEND_ECHO, &expr_node, NULL); 10 - opline->extended_value = 1; 11 - 12 - result->op_type = IS_CONST; 13 - ZVAL_LONG(&result->u.constant, 1); 10 + opline->extended_value = 0; 14 11 }

ठीक है, आप समझते हैं - वे कार्यक्षमता में समान हैं, लेकिन प्रिंट अतिरिक्त रूप से एक बराबर रिटर्न देता है 1. मुझे लगता है कि इस विषय पर प्रिंट के साथ आप इसे बंद कर सकते हैं और हमेशा के लिए भूल सकते हैं।

सरल रेखा, कोई तामझाम नहीं

स्ट्रिंग्स echo 'Some string'; और echo "Some string"; लगभग 2 (अस्वीकरण P2) टोकन में लगभग विभाजित हो जाएगा।

 T_ECHO: echo T_ENCAPSED_AND_WHITESPACE/T_CONSTANT_ENCAPSED_STRING: "Some string"

इसके अलावा, एकल उद्धरणों के लिए हमेशा T_CONSTANT_ENCAPSED_STRING और दोहरे उद्धरण चिह्नों के लिए, जब यह पसंद आए। यदि पंक्ति में कोई स्थान है, तो T_ENCAPSED_AND_WHITESPACE।

Opcodes अपमान करने के लिए सरल और बिल्कुल समान होगा:

 line #* EIO op fetch ext return operands ----------------------------------------------------------- 4 0 E > ECHO 'Some string'

निष्कर्ष

यदि आप संकलन चरण में कुछ प्रोसेसर चक्रों को सहेजना चाहते हैं, तो, निरंतर तारों के लिए, एकल उद्धरण का उपयोग करें।

गतिशील लाइन

4 विकल्प हैं।

 echo "Hello $name! Have a nice day!"; echo 'Hello '.$name.'! Have a nice day!'; echo 'Hello ', $name, '! Have a nice day!'; printf ('Hello %s! Have a nice day!', $name);

पहले विकल्प के लिए:

 T_ECHO: echo T_ENCAPSED_AND_WHITESPACE: Hello T_VARIABLE: $name T_ENCAPSED_AND_WHITESPACE: ! Have a nice day!

दूसरे के लिए (तीसरे के लिए भी, केवल अवधि के बजाय अल्पविराम होंगे):

 T_ECHO: echo T_CONSTANT_ENCAPSED_STRING: 'Hello ' string: . T_VARIABLE: $name string: . T_CONSTANT_ENCAPSED_STRING: '! Have a nice day!'

चौथे के लिए:

 T_STRING: printf T_CONSTANT_ENCAPSED_STRING: 'Hello %s! Have a nice day!' string: , T_VARIABLE: $name

लेकिन ऑपकोड के साथ सब कुछ बहुत अधिक मनोरंजक होगा।

पहला एक:

 echo "Hello $name! Have a nice day!"; line #* EIO op fetch ext return operands ----------------------------------------------------------- 3 0 E > ASSIGN !0, 'Vasya' 4 1 ROPE_INIT 3 ~3 'Hello+' 2 ROPE_ADD 1 ~3 ~3, !0 3 ROPE_END 2 ~2 ~3, '%21+Have+a+nice+day%21' 4 ECHO ~2

दूसरा:

 echo 'Hello '.$name.'! Have a nice day!'; line #* EIO op fetch ext return operands ----------------------------------------------------------- 3 0 E > ASSIGN !0, 'Vasya' 4 1 CONCAT ~2 'Hello+', !0 2 CONCAT ~3 ~2, '%21+Have+a+nice+day%21' 3 ECHO ~3

तीसरा:

 echo 'Hello ', $name, '! Have a nice day!'; line #* EIO op fetch ext return operands ----------------------------------------------------------- 3 0 E > ASSIGN !0, 'Vasya' 4 1 ECHO 'Hello+' 2 ECHO !0 3 ECHO '%21+Have+a+nice+day%21'

चौथा:

 printf ('Hello %s! Have a nice day!', $name); line #* EIO op fetch ext return operands ----------------------------------------------------------- 3 0 E > ASSIGN !0, 'Vasya' 4 1 INIT_FCALL 'printf' 2 SEND_VAL 'Hello+%25s%21+Have+a+nice+day%21' 3 SEND_VAR !0 4 DO_ICALL

सामान्य ज्ञान हमें बताता है कि `प्रिंटफ` वाला विकल्प पहले तीन से गति में खो जाएगा (विशेष रूप से अंत में अभी भी वही ईसीएचओ है), इसलिए हम इसे उन कार्यों के लिए छोड़ देंगे जहां स्वरूपण की आवश्यकता है और हम इस लेख में अधिक याद नहीं करेंगे।

ऐसा लगता है कि तीसरा विकल्प सबसे तेज़ है - तीन लाइनों को बिना किसी क्रम के, उत्तराधिकारियों के अजीब आरओपीई और अतिरिक्त चर के निर्माण के लिए मुद्रित करना। लेकिन इतना सरल नहीं है। PHP में प्रिंट फ़ंक्शन निश्चित रूप से रॉकेट साइंस नहीं है, लेकिन यह किसी भी तरह से एक C-shny fputs नहीं है । कौन परवाह करता है - गेंद मुख्य / आउटपुट.का फ़ाइल में php_output_write से शुरू होती है ।

Concat। यहां सब कुछ सरल है - हम परिवर्तित करते हैं, यदि आवश्यक हो, तो तार में तर्क और तेजी से मेम्कपी का उपयोग करके एक नया zend_string बनाते हैं। एकमात्र नकारात्मक यह है कि प्रत्येक ऑपरेशन के लिए एक लंबी श्रृंखला के साथ, एक ही बाइट को एक स्थान से दूसरे स्थान पर स्थानांतरित करके नई लाइनें बनाई जाएंगी।

लेकिन ROPE_INIT, ROPE_ADD और ROPE_END के साथ सब कुछ बहुत अधिक दिलचस्प है। हाथों का पालन करें:

ROPE_INIT (ext = 3, return = ~ 3, ऑपरेंड = 'Hello +')
हम तीन स्लॉट (एक्सट) से "रस्सी" आवंटित करते हैं, स्ट्रिंग 0 में स्ट्रिंग 'हैलो +' (ऑपरेंड) डालते हैं और "रस्सी" वाले अस्थायी चर ~ 3 (रिटर्न) को वापस करते हैं।
ROPE_ADD (ext = 1, return = ~ 3, ऑपरेंड = ~ 3; 0!)
हम "रस्सी" ~ 3 (ऑपरेंड) के स्लॉट 1 (ext) को स्ट्रिंग 'वास्या' में डालते हैं, जिसे वेरिएबल से प्राप्त किया जाता है! 0 (ऑपरेंड्स) और "रस्सी" ~ 3 (रिटर्न) वापस करें।
ROPE_END (ext = 2, return = ~ 2, ऑपरेंड = ~ 3, '% 21 + है + एक + अच्छा + दिन% 21')
हम पंक्ति 2 (ext) में '% 21 + है + a + अच्छा + दिन% 21' (ऑपरेंड) डालते हैं, फिर आवश्यक आकार का एक zend_string बनाते हैं और सभी "रस्सी" स्लॉट को उसी ccpy के साथ बदले में कॉपी करते हैं।

यह अलग से ध्यान देने योग्य है कि स्थिरांक और अस्थायी चर के मामले में, डेटा के लिंक स्लॉट में रखे जाएंगे, और कोई अनावश्यक प्रतिलिपि नहीं होगी।

मेरी राय में, बहुत सुंदर। :)

चलो बेंचमार्क। स्रोत डेटा के रूप में, हम फ़ाइल को zend_vm_execute.h (IMHO यह सही होगा) 71 हजार लाइनों के लिए लेते हैं और इसे 100 तरीकों के लिए 100 तरीकों से प्रिंट करते हैं, न्यूनतम और अधिकतम (प्रत्येक माप 10 बार शुरू हुई, सबसे आम विकल्प का चयन करते हुए):

 <?php $file = explode("\n", file_get_contents("C:\projects\C\php-src\Zend\zend_vm_execute.h")); $out = []; for ($c = 0; $c < 100; $c++) { $start = microtime(true); ob_start(); $i = 0; foreach ($file as $line) { $i++; // echo 'line: ', $i, 'text: ', $line; // echo 'line: ' . $i . 'text: ' . $line; // echo "line: $i text: $line"; // printf('line: %d text: %s', $i, $line); } ob_end_clean(); $out[] = (microtime(true) - $start); } $min = min($out); $max = max($out); echo (array_sum($out) - $min - $max) / 98;

हम क्या मापते हैं	सेकंड में औसत समय
"रस्सी"	0.0129
कई ECHO	0.0135
कड़ी	0.0158
प्रिंटफ , पूर्णता के लिए	0.0245

निष्कर्ष

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

निष्कर्ष

मेरे लिए ऐसी स्थिति के साथ आना मुश्किल है, जहां इस तरह की सूक्ष्म-अनुकूलन की आवश्यकता उत्पन्न हो सकती है। इस या उस दृष्टिकोण को चुनते समय, अन्य सिद्धांतों द्वारा निर्देशित किया जाना अधिक उचित है - उदाहरण के लिए, कोड पठनीयता या आपकी कंपनी द्वारा अपनाई गई कोडिंग शैली।

मेरे लिए व्यक्तिगत रूप से, मैं विवर्गीज़नी नज़र की वजह से समवर्ती दृष्टिकोण की तरह नहीं हूं, हालांकि कुछ मामलों में इसे उचित ठहराया जा सकता है।

पुनश्च अगर इस तरह का विश्लेषण दिलचस्प है - मुझे बताएं - एक बहुत अधिक है जो हमेशा स्पष्ट और स्पष्ट नहीं है: वीएस ऑब्जेक्ट्स की एक सरणी, वीएस के लिए वीआरईच, आपके विकल्प के लिए ... :)

टिप्पणियों को पढ़ने से थोड़ा स्पष्टीकरण

HEREDOC सिंटैक्स और "जटिल स्ट्रिंग्स" (जहां चर अंदर ब्रेसिज़ हैं) समान डबल-उद्धृत स्ट्रिंग्स हैं और बिल्कुल उसी तरह संकलित हैं।

इस तरह HTML के साथ PHP का मिश्रण:

 <?php $name = 'Vasya';?>Hello <?=$name?>! Have a nice day!

यह एक पंक्ति में सिर्फ 3 गूंज है।

पीएचपी। उद्धरण चिह्नों पर मंत्रमुग्ध करना

त्याग

आवश्यक परिचयात्मक

सरल रेखा, कोई तामझाम नहीं

निष्कर्ष

गतिशील लाइन

निष्कर्ष

निष्कर्ष

टिप्पणियों को पढ़ने से थोड़ा स्पष्टीकरण

More articles: